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
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
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
338 s.Error(ResolverClient.Post(query, &response))
339
340
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
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
493 s.Error(ResolverClient.Post(query, &response))
494
495
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