package integration_test import ( "fmt" "github.com/udacity/graphb" "edge-infra.dev/pkg/edge/api/graph/model" sqlquery "edge-infra.dev/pkg/edge/api/sql" "edge-infra.dev/test/framework/integration" ) func (s *Suite) TestCreateNamespace() { integration.SkipIf(s.Framework) var response struct{ CreateNamespace *model.Namespace } createNamespace := model.NamespaceCreateInput{ BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a102", Name: "test-namespace-A", Workload: model.WorkloadTypeTenant, } mutation := createNamespaceMutation(&createNamespace) err := ResolverClient.Post(mutation, &response) s.NoErrorf(err, "error resolving namespace mutation") s.NotNilf(response.CreateNamespace, "returned namespace is null") namespace := response.CreateNamespace s.Equal(createNamespace.BannerEdgeID, namespace.BannerEdgeID) s.Equal(createNamespace.Name, namespace.Name) s.Equal(createNamespace.Workload, namespace.Workload) args := []interface{}{ createNamespace.BannerEdgeID, createNamespace.Name, } _, err = s.DB.Exec(sqlquery.NamespaceDeleteQuery, args...) s.NoError(err) } func (s *Suite) TestCreateNamespaceInvalidBanner() { integration.SkipIf(s.Framework) var response struct{ CreateNamespace *model.Namespace } createNamespace := model.NamespaceCreateInput{ BannerEdgeID: "banner", Name: "some-namespace", Workload: model.WorkloadTypeTenant, } mutation := createNamespaceMutation(&createNamespace) err := ResolverClient.Post(mutation, &response) s.Errorf(err, "no error resolving namespace mutation") s.Nilf(response.CreateNamespace, "returned namespace is not null") } func (s *Suite) TestCreateNamespaceInvalidName() { integration.SkipIf(s.Framework) var response struct{ CreateNamespace *model.Namespace } createNamespace := model.NamespaceCreateInput{ BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a102", Name: "", Workload: model.WorkloadTypeTenant, } mutation := createNamespaceMutation(&createNamespace) err := ResolverClient.Post(mutation, &response) s.Errorf(err, "no error resolving namespace mutation") s.Nilf(response.CreateNamespace, "returned namespace is not null") } func (s *Suite) TestCreateNamespaceExistingNameOnBanner() { integration.SkipIf(s.Framework) var response struct{ CreateNamespace *model.Namespace } createNamespace := model.NamespaceCreateInput{ BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a101", Name: "test-namespace", Workload: model.WorkloadTypeTenant, } mutation := createNamespaceMutation(&createNamespace) err := ResolverClient.Post(mutation, &response) s.Errorf(err, "no error resolving namespace mutation") s.Nilf(response.CreateNamespace, "returned namespace is not null") } func (s *Suite) TestDeleteNamespace() { integration.SkipIf(s.Framework) var response struct{ DeleteNamespace bool } bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101" //nolint name := "delete-namespace" mutation := deleteNamespaceMutation(bannerEdgeID, name) err := ResolverClient.Post(mutation, &response) s.NoErrorf(err, "resolver failed for delete namespace") s.Truef(response.DeleteNamespace, "resolver returned false for delete namespace") } // test deleting a namespace with clusters using it func (s *Suite) TestDeleteNamespaceInUse() { integration.SkipIf(s.Framework) var response struct{ DeleteNamespace bool } bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101" //nolint name := "delete-namespace-1" mutation := deleteNamespaceMutation(bannerEdgeID, name) err := ResolverClient.Post(mutation, &response) s.Errorf(err, "resolver didn't fail for delete namespace") s.Falsef(response.DeleteNamespace, "resolver didn't return false for delete namespace") } // test deleting a namespace that doesn't exist (real bannerEdgeId, fake name) func (s *Suite) TestDeleteNamespaceFakeOne() { integration.SkipIf(s.Framework) var response struct{ DeleteNamespace bool } bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101" name := "fake-namespace" mutation := deleteNamespaceMutation(bannerEdgeID, name) err := ResolverClient.Post(mutation, &response) s.Errorf(err, "resolver didn't fail for delete namespace (1)") s.False(response.DeleteNamespace, "resolver didn't return false for delete namespace (1)") } // test deleting a namespace that doesn't exist (fake bannerEdgeId, real name) func (s *Suite) TestDeleteNamespaceFakeTwo() { integration.SkipIf(s.Framework) var response struct{ DeleteNamespace bool } bannerEdgeID := "ff2874b4-b9b1-4514-a2b0-58482f3d54fa" name := "delete-namespace" mutation := deleteNamespaceMutation(bannerEdgeID, name) err := ResolverClient.Post(mutation, &response) s.Errorf(err, "resolver didn't fail for delete namespace (2)") s.Falsef(response.DeleteNamespace, "resolver didn't return false for delete namespace (2)") } // get namespaces by bannerEdgeId and name func (s *Suite) TestGetBannerNamespaces() { integration.SkipIf(s.Framework) var response struct{ BannerNamespaces []*model.Namespace } bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101" name := "test-namespace" query := getBannerNamespacesQuery(bannerEdgeID, &name) err := ResolverClient.Post(query, &response) s.NoErrorf(err, "resolver failed for get namespaces by bannerEdgeID and name") s.NotNilf(response.BannerNamespaces, "resolver response nil for get namespaces by bannerEdgeID and name") s.Equalf(1, len(response.BannerNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID and name") s.Equalf("31d51d8c-b580-4e1a-94f6-a970bae8c132", response.BannerNamespaces[0].NamespaceEdgeID, "returned namespaceEdgeId incorrect") } // get namespaces by bannerEdgeId func (s *Suite) TestGetAllBannerNamespaces() { integration.SkipIf(s.Framework) var response struct{ BannerNamespaces []*model.Namespace } bannerEdgeID := "98ef1fcb-dc88-4c9f-9980-c09a04564a48" query := getBannerNamespacesQuery(bannerEdgeID, nil) err := ResolverClient.Post(query, &response) s.NoErrorf(err, "resolver failed for get namespaces by bannerEdgeID") s.NotNilf(response.BannerNamespaces, "resolver response nil for get namespaces by bannerEdgeID") s.Equalf(2, len(response.BannerNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID") } // get namespaces by clusterEdgeId and namespace name func (s *Suite) TestGetClusterNamespaces() { integration.SkipIf(s.Framework) var response struct{ ClusterNamespaces []*model.Namespace } clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101" name := "test-namespace" query := getClusterNamespacesQuery(clusterEdgeID, &name) err := ResolverClient.Post(query, &response) s.NoErrorf(err, "resolver failed for get namespaces by clusterEdgeID and name") s.NotNilf(response.ClusterNamespaces, "resolver response nil for get namespaces by clusterEdgeID and name") s.Equalf(1, len(response.ClusterNamespaces), "resolver response != 1 for get namespaces by clusterEdgeID and name") s.Equalf("31d51d8c-b580-4e1a-94f6-a970bae8c132", response.ClusterNamespaces[0].NamespaceEdgeID, "returned clusterNamespaceEdgeId incorrect") } // get namespaces by clusterEdgeId func (s *Suite) TestGetAllClusterNamespaces() { integration.SkipIf(s.Framework) var response struct{ ClusterNamespaces []*model.Namespace } clusterEdgeID := "6e04c043-89ca-4dc2-a2ea-4605dbdd4c65" query := getClusterNamespacesQuery(clusterEdgeID, nil) err := ResolverClient.Post(query, &response) s.NoErrorf(err, "resolver failed for get namespaces by clusterEdgeID") s.NotNilf(response.ClusterNamespaces, "resolver response nil for get namespaces by bannerEdgeID") s.Equalf(2, len(response.ClusterNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID") } func createNamespaceMutation(createNamespace *model.NamespaceCreateInput) string { return fmt.Sprintf( "mutation{createNamespace(createNamespace:{bannerEdgeId:\"%s\",name:\"%s\",workload:%s}){namespaceEdgeId,bannerEdgeId,name,workload}}", createNamespace.BannerEdgeID, createNamespace.Name, createNamespace.Workload.String(), ) } func deleteNamespaceMutation(bannerEdgeID string, name string) string { return MustParse(graphb.Query{ Type: graphb.TypeMutation, Fields: []*graphb.Field{ { Name: "deleteNamespace", Arguments: []graphb.Argument{ graphb.ArgumentString("bannerEdgeId", bannerEdgeID), graphb.ArgumentString("name", name), }, }, }, }) } func getBannerNamespacesQuery(bannerEdgeID string, name *string) string { getNamespacesArg := []graphb.Argument{ graphb.ArgumentString("bannerEdgeId", bannerEdgeID), } if name != nil { getNamespacesArg = append(getNamespacesArg, graphb.ArgumentString("name", *name)) } return MustParse(graphb.Query{ Type: graphb.TypeQuery, Fields: []*graphb.Field{ { Name: "bannerNamespaces", Arguments: getNamespacesArg, Fields: namespaceFields, }, }, }) } func getClusterNamespacesQuery(clusterEdgeID string, name *string) string { getClusterNamespacesArg := []graphb.Argument{ graphb.ArgumentString("clusterEdgeId", clusterEdgeID), } if name != nil { getClusterNamespacesArg = append(getClusterNamespacesArg, graphb.ArgumentString("name", *name)) } return MustParse(graphb.Query{ Type: graphb.TypeQuery, Fields: []*graphb.Field{ { Name: "clusterNamespaces", Arguments: getClusterNamespacesArg, Fields: namespaceFields, }, }, }) } var namespaceFields = []*graphb.Field{ { Name: "namespaceEdgeId", }, { Name: "bannerEdgeId", }, { Name: "name", }, { Name: "workload", }, }