...

Source file src/edge-infra.dev/pkg/edge/api/graph/integration/namespace_queries_test.go

Documentation: edge-infra.dev/pkg/edge/api/graph/integration

     1  package integration_test
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/udacity/graphb"
     7  
     8  	"edge-infra.dev/pkg/edge/api/graph/model"
     9  	sqlquery "edge-infra.dev/pkg/edge/api/sql"
    10  	"edge-infra.dev/test/framework/integration"
    11  )
    12  
    13  func (s *Suite) TestCreateNamespace() {
    14  	integration.SkipIf(s.Framework)
    15  	var response struct{ CreateNamespace *model.Namespace }
    16  
    17  	createNamespace := model.NamespaceCreateInput{
    18  		BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a102",
    19  		Name:         "test-namespace-A",
    20  		Workload:     model.WorkloadTypeTenant,
    21  	}
    22  
    23  	mutation := createNamespaceMutation(&createNamespace)
    24  
    25  	err := ResolverClient.Post(mutation, &response)
    26  	s.NoErrorf(err, "error resolving namespace mutation")
    27  
    28  	s.NotNilf(response.CreateNamespace, "returned namespace is null")
    29  	namespace := response.CreateNamespace
    30  	s.Equal(createNamespace.BannerEdgeID, namespace.BannerEdgeID)
    31  	s.Equal(createNamespace.Name, namespace.Name)
    32  	s.Equal(createNamespace.Workload, namespace.Workload)
    33  
    34  	args := []interface{}{
    35  		createNamespace.BannerEdgeID,
    36  		createNamespace.Name,
    37  	}
    38  	_, err = s.DB.Exec(sqlquery.NamespaceDeleteQuery, args...)
    39  	s.NoError(err)
    40  }
    41  
    42  func (s *Suite) TestCreateNamespaceInvalidBanner() {
    43  	integration.SkipIf(s.Framework)
    44  	var response struct{ CreateNamespace *model.Namespace }
    45  
    46  	createNamespace := model.NamespaceCreateInput{
    47  		BannerEdgeID: "banner",
    48  		Name:         "some-namespace",
    49  		Workload:     model.WorkloadTypeTenant,
    50  	}
    51  
    52  	mutation := createNamespaceMutation(&createNamespace)
    53  
    54  	err := ResolverClient.Post(mutation, &response)
    55  	s.Errorf(err, "no error resolving namespace mutation")
    56  	s.Nilf(response.CreateNamespace, "returned namespace is not null")
    57  }
    58  
    59  func (s *Suite) TestCreateNamespaceInvalidName() {
    60  	integration.SkipIf(s.Framework)
    61  	var response struct{ CreateNamespace *model.Namespace }
    62  
    63  	createNamespace := model.NamespaceCreateInput{
    64  		BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a102",
    65  		Name:         "",
    66  		Workload:     model.WorkloadTypeTenant,
    67  	}
    68  
    69  	mutation := createNamespaceMutation(&createNamespace)
    70  
    71  	err := ResolverClient.Post(mutation, &response)
    72  	s.Errorf(err, "no error resolving namespace mutation")
    73  	s.Nilf(response.CreateNamespace, "returned namespace is not null")
    74  }
    75  
    76  func (s *Suite) TestCreateNamespaceExistingNameOnBanner() {
    77  	integration.SkipIf(s.Framework)
    78  	var response struct{ CreateNamespace *model.Namespace }
    79  
    80  	createNamespace := model.NamespaceCreateInput{
    81  		BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a101",
    82  		Name:         "test-namespace",
    83  		Workload:     model.WorkloadTypeTenant,
    84  	}
    85  
    86  	mutation := createNamespaceMutation(&createNamespace)
    87  
    88  	err := ResolverClient.Post(mutation, &response)
    89  	s.Errorf(err, "no error resolving namespace mutation")
    90  	s.Nilf(response.CreateNamespace, "returned namespace is not null")
    91  }
    92  
    93  func (s *Suite) TestDeleteNamespace() {
    94  	integration.SkipIf(s.Framework)
    95  	var response struct{ DeleteNamespace bool }
    96  	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101" //nolint
    97  	name := "delete-namespace"
    98  	mutation := deleteNamespaceMutation(bannerEdgeID, name)
    99  	err := ResolverClient.Post(mutation, &response)
   100  	s.NoErrorf(err, "resolver failed for delete namespace")
   101  	s.Truef(response.DeleteNamespace, "resolver returned false for delete namespace")
   102  }
   103  
   104  // test deleting a namespace with clusters using it
   105  func (s *Suite) TestDeleteNamespaceInUse() {
   106  	integration.SkipIf(s.Framework)
   107  	var response struct{ DeleteNamespace bool }
   108  	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101" //nolint
   109  	name := "delete-namespace-1"
   110  	mutation := deleteNamespaceMutation(bannerEdgeID, name)
   111  	err := ResolverClient.Post(mutation, &response)
   112  	s.Errorf(err, "resolver didn't fail for delete namespace")
   113  	s.Falsef(response.DeleteNamespace, "resolver didn't return false for delete namespace")
   114  }
   115  
   116  // test deleting a namespace that doesn't exist (real bannerEdgeId, fake name)
   117  func (s *Suite) TestDeleteNamespaceFakeOne() {
   118  	integration.SkipIf(s.Framework)
   119  	var response struct{ DeleteNamespace bool }
   120  	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
   121  	name := "fake-namespace"
   122  	mutation := deleteNamespaceMutation(bannerEdgeID, name)
   123  	err := ResolverClient.Post(mutation, &response)
   124  	s.Errorf(err, "resolver didn't fail for delete namespace (1)")
   125  	s.False(response.DeleteNamespace, "resolver didn't return false for delete namespace (1)")
   126  }
   127  
   128  // test deleting a namespace that doesn't exist (fake bannerEdgeId, real name)
   129  func (s *Suite) TestDeleteNamespaceFakeTwo() {
   130  	integration.SkipIf(s.Framework)
   131  	var response struct{ DeleteNamespace bool }
   132  	bannerEdgeID := "ff2874b4-b9b1-4514-a2b0-58482f3d54fa"
   133  	name := "delete-namespace"
   134  	mutation := deleteNamespaceMutation(bannerEdgeID, name)
   135  	err := ResolverClient.Post(mutation, &response)
   136  	s.Errorf(err, "resolver didn't fail for delete namespace (2)")
   137  	s.Falsef(response.DeleteNamespace, "resolver didn't return false for delete namespace (2)")
   138  }
   139  
   140  // get namespaces by bannerEdgeId and name
   141  func (s *Suite) TestGetBannerNamespaces() {
   142  	integration.SkipIf(s.Framework)
   143  	var response struct{ BannerNamespaces []*model.Namespace }
   144  	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
   145  	name := "test-namespace"
   146  	query := getBannerNamespacesQuery(bannerEdgeID, &name)
   147  	err := ResolverClient.Post(query, &response)
   148  
   149  	s.NoErrorf(err, "resolver failed for get namespaces by bannerEdgeID and name")
   150  	s.NotNilf(response.BannerNamespaces, "resolver response nil for get namespaces by bannerEdgeID and name")
   151  	s.Equalf(1, len(response.BannerNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID and name")
   152  	s.Equalf("31d51d8c-b580-4e1a-94f6-a970bae8c132", response.BannerNamespaces[0].NamespaceEdgeID, "returned namespaceEdgeId incorrect")
   153  }
   154  
   155  // get namespaces by bannerEdgeId
   156  func (s *Suite) TestGetAllBannerNamespaces() {
   157  	integration.SkipIf(s.Framework)
   158  	var response struct{ BannerNamespaces []*model.Namespace }
   159  	bannerEdgeID := "98ef1fcb-dc88-4c9f-9980-c09a04564a48"
   160  	query := getBannerNamespacesQuery(bannerEdgeID, nil)
   161  	err := ResolverClient.Post(query, &response)
   162  
   163  	s.NoErrorf(err, "resolver failed for get namespaces by bannerEdgeID")
   164  	s.NotNilf(response.BannerNamespaces, "resolver response nil for get namespaces by bannerEdgeID")
   165  	s.Equalf(2, len(response.BannerNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID")
   166  }
   167  
   168  // get namespaces by clusterEdgeId and namespace name
   169  func (s *Suite) TestGetClusterNamespaces() {
   170  	integration.SkipIf(s.Framework)
   171  	var response struct{ ClusterNamespaces []*model.Namespace }
   172  	clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
   173  	name := "test-namespace"
   174  	query := getClusterNamespacesQuery(clusterEdgeID, &name)
   175  	err := ResolverClient.Post(query, &response)
   176  
   177  	s.NoErrorf(err, "resolver failed for get namespaces by clusterEdgeID and name")
   178  	s.NotNilf(response.ClusterNamespaces, "resolver response nil for get namespaces by clusterEdgeID and name")
   179  	s.Equalf(1, len(response.ClusterNamespaces), "resolver response != 1 for get namespaces by clusterEdgeID and name")
   180  	s.Equalf("31d51d8c-b580-4e1a-94f6-a970bae8c132", response.ClusterNamespaces[0].NamespaceEdgeID, "returned clusterNamespaceEdgeId incorrect")
   181  }
   182  
   183  // get namespaces by clusterEdgeId
   184  func (s *Suite) TestGetAllClusterNamespaces() {
   185  	integration.SkipIf(s.Framework)
   186  	var response struct{ ClusterNamespaces []*model.Namespace }
   187  	clusterEdgeID := "6e04c043-89ca-4dc2-a2ea-4605dbdd4c65"
   188  	query := getClusterNamespacesQuery(clusterEdgeID, nil)
   189  	err := ResolverClient.Post(query, &response)
   190  
   191  	s.NoErrorf(err, "resolver failed for get namespaces by clusterEdgeID")
   192  	s.NotNilf(response.ClusterNamespaces, "resolver response nil for get namespaces by bannerEdgeID")
   193  	s.Equalf(2, len(response.ClusterNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID")
   194  }
   195  
   196  func createNamespaceMutation(createNamespace *model.NamespaceCreateInput) string {
   197  	return fmt.Sprintf(
   198  		"mutation{createNamespace(createNamespace:{bannerEdgeId:\"%s\",name:\"%s\",workload:%s}){namespaceEdgeId,bannerEdgeId,name,workload}}",
   199  		createNamespace.BannerEdgeID, createNamespace.Name, createNamespace.Workload.String(),
   200  	)
   201  }
   202  
   203  func deleteNamespaceMutation(bannerEdgeID string, name string) string {
   204  	return MustParse(graphb.Query{
   205  		Type: graphb.TypeMutation,
   206  		Fields: []*graphb.Field{
   207  			{
   208  				Name: "deleteNamespace",
   209  				Arguments: []graphb.Argument{
   210  					graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
   211  					graphb.ArgumentString("name", name),
   212  				},
   213  			},
   214  		},
   215  	})
   216  }
   217  
   218  func getBannerNamespacesQuery(bannerEdgeID string, name *string) string {
   219  	getNamespacesArg := []graphb.Argument{
   220  		graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
   221  	}
   222  	if name != nil {
   223  		getNamespacesArg = append(getNamespacesArg, graphb.ArgumentString("name", *name))
   224  	}
   225  	return MustParse(graphb.Query{
   226  		Type: graphb.TypeQuery,
   227  		Fields: []*graphb.Field{
   228  			{
   229  				Name:      "bannerNamespaces",
   230  				Arguments: getNamespacesArg,
   231  				Fields:    namespaceFields,
   232  			},
   233  		},
   234  	})
   235  }
   236  
   237  func getClusterNamespacesQuery(clusterEdgeID string, name *string) string {
   238  	getClusterNamespacesArg := []graphb.Argument{
   239  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   240  	}
   241  	if name != nil {
   242  		getClusterNamespacesArg = append(getClusterNamespacesArg, graphb.ArgumentString("name", *name))
   243  	}
   244  	return MustParse(graphb.Query{
   245  		Type: graphb.TypeQuery,
   246  		Fields: []*graphb.Field{
   247  			{
   248  				Name:      "clusterNamespaces",
   249  				Arguments: getClusterNamespacesArg,
   250  				Fields:    namespaceFields,
   251  			},
   252  		},
   253  	})
   254  }
   255  
   256  var namespaceFields = []*graphb.Field{
   257  	{
   258  		Name: "namespaceEdgeId",
   259  	},
   260  	{
   261  		Name: "bannerEdgeId",
   262  	},
   263  	{
   264  		Name: "name",
   265  	},
   266  	{
   267  		Name: "workload",
   268  	},
   269  }
   270  

View as plain text