...

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

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

     1  package integration_test
     2  
     3  import (
     4  	"github.com/udacity/graphb"
     5  
     6  	"edge-infra.dev/pkg/edge/api/graph/model"
     7  	"edge-infra.dev/test/framework/integration"
     8  )
     9  
    10  const (
    11  	testBannerA = "3396a52c-6a22-4049-9593-5a63b596a101"
    12  	testBannerB = "3396a52c-6a22-4049-9593-5a63b596a105"
    13  
    14  	testClusterA = "3396a52c-6a22-4049-9593-5a63b596a200"
    15  	testClusterB = "3396a52c-6a22-4049-9593-5a63b596a201"
    16  
    17  	testRegistryA = "018ea9c2-ca5d-7a8a-830c-d533e8b52e71"
    18  	testRegistryB = "018ea9c2-ca5d-7a8a-830c-d533e8b52e72"
    19  	testRegistryC = "018ea9c2-ca5d-7a8a-830c-d533e8b52e73"
    20  
    21  	testRegistryAURL = "a.registry.io"
    22  	testRegistryBURL = "b.registry.io"
    23  
    24  	testRegistryADescription = "Artifact registry A"
    25  	testRegistryBDescription = "Artifact registry B"
    26  
    27  	testClusterRegistryA = "019eac81-da8d-3a2d-122c-c264e7b53c91"
    28  )
    29  
    30  var (
    31  	artifactRegistriesFields = []*graphb.Field{
    32  		{Name: "registryEdgeId"},
    33  		{Name: "bannerEdgeId"},
    34  		{Name: "description"},
    35  		{Name: "url"},
    36  	}
    37  
    38  	clusterArtifactRegistriesFields = []*graphb.Field{
    39  		{Name: "clusterRegistryEdgeId"},
    40  		{Name: "clusterEdgeId"},
    41  		{Name: "registryEdgeId"},
    42  	}
    43  )
    44  
    45  type artifactRegistryResponse struct {
    46  	ArtifactRegistry       *model.ArtifactRegistry
    47  	ArtifactRegistries     []*model.ArtifactRegistry
    48  	CreateArtifactRegistry *model.ArtifactRegistry
    49  	UpdateArtifactRegistry *model.ArtifactRegistry
    50  	DeleteArtifactRegistry bool
    51  }
    52  
    53  type clusterArtifactRegistryResponse struct {
    54  	ClusterArtifactRegistry       *model.ClusterArtifactRegistry
    55  	ClusterArtifactRegistries     []*model.ClusterArtifactRegistry
    56  	CreateClusterArtifactRegistry *model.ClusterArtifactRegistry
    57  	DeleteClusterArtifactRegistry bool
    58  }
    59  
    60  func (s *Suite) TestArtifactRegistry() {
    61  	integration.SkipIf(s.Framework)
    62  
    63  	registryEdgeID := testRegistryA
    64  
    65  	var response artifactRegistryResponse
    66  	query := artifactRegistryQuery(testRegistryA)
    67  	s.Require().NoError(ResolverClient.Post(query, &response))
    68  
    69  	expectedBannerEdgeID := testBannerA
    70  	expectedDescription := testRegistryADescription
    71  	expectedURL := testRegistryAURL
    72  
    73  	s.Require().NotNil(response.ArtifactRegistry)
    74  	s.Equal(registryEdgeID, response.ArtifactRegistry.RegistryEdgeID)
    75  	s.Equal(expectedBannerEdgeID, response.ArtifactRegistry.BannerEdgeID)
    76  	s.Require().NotNil(response.ArtifactRegistry.Description)
    77  	s.Equal(expectedDescription, *response.ArtifactRegistry.Description)
    78  	s.Equal(expectedURL, response.ArtifactRegistry.URL)
    79  }
    80  
    81  func artifactRegistryQuery(registryEdgeID string) string {
    82  	return MustParse(graphb.Query{
    83  		Type: graphb.TypeQuery,
    84  		Fields: []*graphb.Field{
    85  			{
    86  				Name: "artifactRegistry",
    87  				Arguments: []graphb.Argument{
    88  					graphb.ArgumentString("registryEdgeId", registryEdgeID),
    89  				},
    90  				Fields: artifactRegistriesFields,
    91  			},
    92  		},
    93  	})
    94  }
    95  
    96  func (s *Suite) TestArtifactRegistriesForBanner() {
    97  	integration.SkipIf(s.Framework)
    98  
    99  	bannerEdgeID := testBannerA
   100  
   101  	var response artifactRegistryResponse
   102  	query := artifactRegistriesQuery(&bannerEdgeID, nil)
   103  	s.Require().NoError(ResolverClient.Post(query, &response))
   104  
   105  	s.Require().NotNil(response.ArtifactRegistries)
   106  	s.Require().Len(response.ArtifactRegistries, 2)
   107  	for _, artifactRegistry := range response.ArtifactRegistries {
   108  		s.Equal(bannerEdgeID, artifactRegistry.BannerEdgeID)
   109  		s.NotEmpty(artifactRegistry.RegistryEdgeID)
   110  		s.Require().NotNil(artifactRegistry.Description)
   111  		s.NotEmpty(*artifactRegistry.Description)
   112  		s.NotEmpty(artifactRegistry.URL)
   113  	}
   114  }
   115  
   116  func (s *Suite) TestArtifactRegistriesForCluster() {
   117  	integration.SkipIf(s.Framework)
   118  
   119  	clusterEdgeID := testClusterA
   120  
   121  	var response artifactRegistryResponse
   122  	query := artifactRegistriesQuery(nil, &clusterEdgeID)
   123  	s.Require().NoError(ResolverClient.Post(query, &response))
   124  
   125  	expectedBannerEdgeID := testBannerA
   126  
   127  	s.Require().NotNil(response.ArtifactRegistries)
   128  	s.Require().Len(response.ArtifactRegistries, 2)
   129  	for _, artifactRegistry := range response.ArtifactRegistries {
   130  		s.Equal(expectedBannerEdgeID, artifactRegistry.BannerEdgeID)
   131  		s.NotEmpty(artifactRegistry.RegistryEdgeID)
   132  		s.Require().NotNil(artifactRegistry.Description)
   133  		s.NotEmpty(*artifactRegistry.Description)
   134  		s.NotEmpty(artifactRegistry.URL)
   135  	}
   136  }
   137  
   138  func (s *Suite) TestArtifactRegistriesFailsWithInvalidArgs() {
   139  	integration.SkipIf(s.Framework)
   140  
   141  	var response artifactRegistryResponse
   142  	query := artifactRegistriesQuery(nil, nil)
   143  	err := ResolverClient.Post(query, &response)
   144  
   145  	s.ErrorContains(err, "must specify banner or cluster Edge ID")
   146  }
   147  
   148  func artifactRegistriesQuery(bannerEdgeID, clusterEdgeID *string) string {
   149  	query := graphb.Query{
   150  		Type: graphb.TypeQuery,
   151  		Fields: []*graphb.Field{
   152  			{
   153  				Name:   "artifactRegistries",
   154  				Fields: artifactRegistriesFields,
   155  			},
   156  		},
   157  	}
   158  
   159  	args := []graphb.Argument{}
   160  	if bannerEdgeID != nil {
   161  		args = append(args, graphb.ArgumentString("bannerEdgeId", *bannerEdgeID))
   162  	}
   163  	if clusterEdgeID != nil {
   164  		args = append(args, graphb.ArgumentString("clusterEdgeId", *clusterEdgeID))
   165  	}
   166  
   167  	query.Fields[0].Arguments = args
   168  	return MustParse(query)
   169  }
   170  
   171  func (s *Suite) TestCreateArtifactRegistry() {
   172  	integration.SkipIf(s.Framework)
   173  
   174  	bannerEdgeID := testBannerB
   175  	description := "Newly created registry"
   176  	url := "new.registry.io"
   177  
   178  	var response artifactRegistryResponse
   179  	mutation := createArtifactRegistryMutation(bannerEdgeID, url, &description)
   180  	s.Require().NoError(ResolverClient.Post(mutation, &response))
   181  
   182  	s.Require().NotNil(response.CreateArtifactRegistry)
   183  	s.NotEmpty(response.CreateArtifactRegistry.RegistryEdgeID)
   184  	s.Equal(bannerEdgeID, response.CreateArtifactRegistry.BannerEdgeID)
   185  	s.Require().NotNil(response.CreateArtifactRegistry.Description)
   186  	s.Equal(description, *response.CreateArtifactRegistry.Description)
   187  	s.Equal(url, response.CreateArtifactRegistry.URL)
   188  }
   189  
   190  func (s *Suite) TestCreateArtifactRegistryWithoutDescription() {
   191  	integration.SkipIf(s.Framework)
   192  
   193  	bannerEdgeID := testBannerB
   194  	url := "new.withoutdescription.registry.io"
   195  
   196  	var response artifactRegistryResponse
   197  	mutation := createArtifactRegistryMutation(bannerEdgeID, url, nil)
   198  	s.Require().NoError(ResolverClient.Post(mutation, &response))
   199  
   200  	s.Require().NotNil(response.CreateArtifactRegistry)
   201  	s.NotEmpty(response.CreateArtifactRegistry.RegistryEdgeID)
   202  	s.Equal(bannerEdgeID, response.CreateArtifactRegistry.BannerEdgeID)
   203  	s.Nil(response.CreateArtifactRegistry.Description)
   204  	s.Equal(url, response.CreateArtifactRegistry.URL)
   205  }
   206  
   207  func (s *Suite) TestCreateArtifactRegistryFailsIfURLAlreadyExistsForBanner() {
   208  	integration.SkipIf(s.Framework)
   209  
   210  	bannerEdgeID := testBannerA
   211  	description := testRegistryADescription
   212  	alreadyExistsURL := testRegistryAURL
   213  
   214  	var response artifactRegistryResponse
   215  	mutation := createArtifactRegistryMutation(bannerEdgeID, alreadyExistsURL, &description)
   216  	err := ResolverClient.Post(mutation, &response)
   217  
   218  	s.Require().Error(err)
   219  	s.Nil(response.CreateArtifactRegistry)
   220  }
   221  
   222  func createArtifactRegistryMutation(bannerEdgeID, url string, description *string) string {
   223  	query := graphb.Query{
   224  		Type: graphb.TypeMutation,
   225  		Fields: []*graphb.Field{
   226  			{
   227  				Name: "createArtifactRegistry",
   228  				Arguments: []graphb.Argument{
   229  					graphb.ArgumentCustomType(
   230  						"createArtifactRegistry",
   231  						graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
   232  						graphb.ArgumentString("url", url),
   233  					),
   234  				},
   235  				Fields: artifactRegistriesFields,
   236  			},
   237  		},
   238  	}
   239  
   240  	if description != nil {
   241  		query.Fields[0].Arguments[0] = graphb.ArgumentCustomType(
   242  			"createArtifactRegistry",
   243  			graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
   244  			graphb.ArgumentString("url", url),
   245  			graphb.ArgumentString("description", *description),
   246  		)
   247  	}
   248  
   249  	return MustParse(query)
   250  }
   251  
   252  func (s *Suite) TestUpdateArtifactRegistry() {
   253  	integration.SkipIf(s.Framework)
   254  
   255  	registryEdgeID := testRegistryB
   256  	updatedDescription := "Updated registry"
   257  	updatedURL := "updated.registry.io"
   258  
   259  	var response artifactRegistryResponse
   260  	mutation := updateArtifactRegistryMutation(registryEdgeID, updatedDescription, updatedURL)
   261  	s.Require().NoError(ResolverClient.Post(mutation, &response))
   262  
   263  	expectedBannerEdgeID := testBannerA
   264  
   265  	s.Require().NotNil(response.UpdateArtifactRegistry)
   266  	s.Equal(registryEdgeID, response.UpdateArtifactRegistry.RegistryEdgeID)
   267  	s.Equal(expectedBannerEdgeID, response.UpdateArtifactRegistry.BannerEdgeID)
   268  	s.Require().NotNil(response.UpdateArtifactRegistry.Description)
   269  	s.Equal(updatedDescription, *response.UpdateArtifactRegistry.Description)
   270  	s.Equal(updatedURL, response.UpdateArtifactRegistry.URL)
   271  
   272  	// check we can update description by itself
   273  	updatedDescription = "Updated description"
   274  	mutation = updateArtifactRegistryMutation(registryEdgeID, updatedDescription, updatedURL)
   275  	s.Require().NoError(ResolverClient.Post(mutation, &response))
   276  
   277  	s.Require().NotNil(response.UpdateArtifactRegistry)
   278  	s.Equal(registryEdgeID, response.UpdateArtifactRegistry.RegistryEdgeID)
   279  	s.Equal(expectedBannerEdgeID, response.UpdateArtifactRegistry.BannerEdgeID)
   280  	s.Require().NotNil(response.UpdateArtifactRegistry.Description)
   281  	s.Equal(updatedDescription, *response.UpdateArtifactRegistry.Description)
   282  	s.Equal(updatedURL, response.UpdateArtifactRegistry.URL)
   283  }
   284  
   285  func (s *Suite) TestUpdateArtifactRegistryFailsIfURLAlreadyExistsForBanner() {
   286  	integration.SkipIf(s.Framework)
   287  
   288  	registryEdgeID := testRegistryB
   289  	updatedDescription := "Updated registry"
   290  	alreadyExistsURL := testRegistryAURL
   291  
   292  	var response artifactRegistryResponse
   293  	mutation := updateArtifactRegistryMutation(registryEdgeID, updatedDescription, alreadyExistsURL)
   294  	err := ResolverClient.Post(mutation, &response)
   295  
   296  	s.Require().Error(err)
   297  	s.Nil(response.CreateArtifactRegistry)
   298  }
   299  
   300  func updateArtifactRegistryMutation(registryEdgeID, description, url string) string {
   301  	return MustParse(graphb.Query{
   302  		Type: graphb.TypeMutation,
   303  		Fields: []*graphb.Field{
   304  			{
   305  				Name: "updateArtifactRegistry",
   306  				Arguments: []graphb.Argument{
   307  					graphb.ArgumentString("registryEdgeId", registryEdgeID),
   308  					graphb.ArgumentCustomType(
   309  						"updateArtifactRegistry",
   310  						graphb.ArgumentString("description", description),
   311  						graphb.ArgumentString("url", url),
   312  					),
   313  				},
   314  				Fields: artifactRegistriesFields,
   315  			},
   316  		},
   317  	})
   318  }
   319  
   320  func (s *Suite) TestDeleteArtifactRegistry() {
   321  	integration.SkipIf(s.Framework)
   322  
   323  	registryEdgeID := "018ea9c2-ca5d-7a8a-830c-d533e8b52e75"
   324  
   325  	var response artifactRegistryResponse
   326  
   327  	// check it exists before deletion
   328  	query := artifactRegistryQuery(registryEdgeID)
   329  	s.Require().NoError(ResolverClient.Post(query, &response))
   330  
   331  	mutation := deleteArtifactRegistryMutation(registryEdgeID)
   332  	s.Require().NoError(ResolverClient.Post(mutation, &response))
   333  
   334  	s.Require().NotNil(response.DeleteArtifactRegistry)
   335  	s.True(response.DeleteArtifactRegistry)
   336  
   337  	// check it no longer exists
   338  	s.Error(ResolverClient.Post(query, &response))
   339  
   340  	// deleting it again should do nothing
   341  	s.Require().NoError(ResolverClient.Post(mutation, &response))
   342  	s.Require().NotNil(response.DeleteArtifactRegistry)
   343  	s.False(response.DeleteArtifactRegistry)
   344  }
   345  
   346  func deleteArtifactRegistryMutation(registryEdgeID string) string {
   347  	return MustParse(graphb.Query{
   348  		Type: graphb.TypeMutation,
   349  		Fields: []*graphb.Field{
   350  			{
   351  				Name: "deleteArtifactRegistry",
   352  				Arguments: []graphb.Argument{
   353  					graphb.ArgumentString("registryEdgeId", registryEdgeID),
   354  				},
   355  			},
   356  		},
   357  	})
   358  }
   359  
   360  func (s *Suite) TestClusterArtifactRegistry() {
   361  	integration.SkipIf(s.Framework)
   362  
   363  	clusterRegistryEdgeID := testClusterRegistryA
   364  
   365  	var response clusterArtifactRegistryResponse
   366  	query := clusterArtifactRegistryQuery(clusterRegistryEdgeID)
   367  	s.Require().NoError(ResolverClient.Post(query, &response))
   368  
   369  	expectedClusterEdgeID := testClusterA
   370  	expectedRegistryEdgeID := testRegistryA
   371  
   372  	s.Require().NotNil(response.ClusterArtifactRegistry)
   373  	s.Equal(response.ClusterArtifactRegistry.ClusterRegistryEdgeID, clusterRegistryEdgeID)
   374  	s.Equal(response.ClusterArtifactRegistry.ClusterEdgeID, expectedClusterEdgeID)
   375  	s.Equal(response.ClusterArtifactRegistry.RegistryEdgeID, expectedRegistryEdgeID)
   376  }
   377  
   378  func clusterArtifactRegistryQuery(clusterRegistryEdgeID string) string {
   379  	return MustParse(graphb.Query{
   380  		Type: graphb.TypeQuery,
   381  		Fields: []*graphb.Field{
   382  			{
   383  				Name: "clusterArtifactRegistry",
   384  				Arguments: []graphb.Argument{
   385  					graphb.ArgumentString("clusterRegistryEdgeId", clusterRegistryEdgeID),
   386  				},
   387  				Fields: clusterArtifactRegistriesFields,
   388  			},
   389  		},
   390  	})
   391  }
   392  
   393  func (s *Suite) TestClusterArtifactRegistries() {
   394  	integration.SkipIf(s.Framework)
   395  
   396  	clusterEdgeID := testClusterA
   397  
   398  	var response clusterArtifactRegistryResponse
   399  	query := clusterArtifactRegistriesQuery(clusterEdgeID)
   400  	s.Require().NoError(ResolverClient.Post(query, &response))
   401  
   402  	s.Require().NotNil(response.ClusterArtifactRegistries)
   403  	s.Require().Len(response.ClusterArtifactRegistries, 2)
   404  	for _, clusterArtifactRegistry := range response.ClusterArtifactRegistries {
   405  		s.Equal(clusterEdgeID, clusterArtifactRegistry.ClusterEdgeID)
   406  		s.NotEmpty(clusterArtifactRegistry.ClusterRegistryEdgeID)
   407  		s.NotEmpty(clusterArtifactRegistry.RegistryEdgeID)
   408  	}
   409  }
   410  
   411  func clusterArtifactRegistriesQuery(clusterEdgeID string) string {
   412  	return MustParse(graphb.Query{
   413  		Type: graphb.TypeQuery,
   414  		Fields: []*graphb.Field{
   415  			{
   416  				Name:   "clusterArtifactRegistries",
   417  				Fields: clusterArtifactRegistriesFields,
   418  				Arguments: []graphb.Argument{
   419  					graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   420  				},
   421  			},
   422  		},
   423  	})
   424  }
   425  
   426  func (s *Suite) TestCreateClusterArtifactRegistry() {
   427  	integration.SkipIf(s.Framework)
   428  
   429  	clusterEdgeID := testClusterB
   430  	registryEdgeID := testRegistryC
   431  
   432  	var response clusterArtifactRegistryResponse
   433  	mutation := createClusterArtifactRegistryMutation(clusterEdgeID, registryEdgeID)
   434  	s.Require().NoError(ResolverClient.Post(mutation, &response))
   435  
   436  	s.Require().NotNil(response.CreateClusterArtifactRegistry)
   437  	s.NotEmpty(response.CreateClusterArtifactRegistry.ClusterRegistryEdgeID)
   438  	s.Equal(clusterEdgeID, response.CreateClusterArtifactRegistry.ClusterEdgeID)
   439  	s.Equal(registryEdgeID, response.CreateClusterArtifactRegistry.RegistryEdgeID)
   440  }
   441  
   442  func (s *Suite) TestCreateClusterArtifactRegistryFailsIfRegistryAlreadyExistsForCluster() {
   443  	integration.SkipIf(s.Framework)
   444  
   445  	clusterEdgeID := testClusterA
   446  	alreadyExistsRegistryEdgeID := testRegistryA
   447  
   448  	var response clusterArtifactRegistryResponse
   449  	mutation := createClusterArtifactRegistryMutation(clusterEdgeID, alreadyExistsRegistryEdgeID)
   450  	err := ResolverClient.Post(mutation, &response)
   451  
   452  	s.Require().Error(err)
   453  	s.Nil(response.CreateClusterArtifactRegistry)
   454  }
   455  
   456  func createClusterArtifactRegistryMutation(clusterEdgeID, registryEdgeID string) string {
   457  	return MustParse(graphb.Query{
   458  		Type: graphb.TypeMutation,
   459  		Fields: []*graphb.Field{
   460  			{
   461  				Name: "createClusterArtifactRegistry",
   462  				Arguments: []graphb.Argument{
   463  					graphb.ArgumentCustomType(
   464  						"createClusterArtifactRegistry",
   465  						graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   466  						graphb.ArgumentString("registryEdgeId", registryEdgeID),
   467  					),
   468  				},
   469  				Fields: clusterArtifactRegistriesFields,
   470  			},
   471  		},
   472  	})
   473  }
   474  
   475  func (s *Suite) TestDeleteClusterArtifactRegistry() {
   476  	integration.SkipIf(s.Framework)
   477  
   478  	clusterRegistryEdgeID := "019eac81-da8d-3a2d-122c-c264e7b53c94"
   479  
   480  	var response clusterArtifactRegistryResponse
   481  
   482  	// check it exists before deletion
   483  	query := clusterArtifactRegistryQuery(clusterRegistryEdgeID)
   484  	s.Require().NoError(ResolverClient.Post(query, &response))
   485  
   486  	mutation := deleteClusterArtifactRegistryMutation(clusterRegistryEdgeID)
   487  	s.Require().NoError(ResolverClient.Post(mutation, &response))
   488  
   489  	s.Require().NotNil(response.DeleteClusterArtifactRegistry)
   490  	s.True(response.DeleteClusterArtifactRegistry)
   491  
   492  	// check it no longer exists
   493  	s.Error(ResolverClient.Post(query, &response))
   494  
   495  	// deleting it again should do nothing
   496  	s.Require().NoError(ResolverClient.Post(mutation, &response))
   497  	s.Require().NotNil(response.DeleteClusterArtifactRegistry)
   498  	s.False(response.DeleteClusterArtifactRegistry)
   499  }
   500  
   501  func deleteClusterArtifactRegistryMutation(clusterRegistryEdgeID string) string {
   502  	return MustParse(graphb.Query{
   503  		Type: graphb.TypeMutation,
   504  		Fields: []*graphb.Field{
   505  			{
   506  				Name: "deleteClusterArtifactRegistry",
   507  				Arguments: []graphb.Argument{
   508  					graphb.ArgumentString("clusterRegistryEdgeId", clusterRegistryEdgeID),
   509  				},
   510  			},
   511  		},
   512  	})
   513  }
   514  

View as plain text