1 package services
2
3 import (
4 "context"
5 "database/sql/driver"
6 "strconv"
7 "testing"
8
9 "github.com/DATA-DOG/go-sqlmock"
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12 "k8s.io/utils/ptr"
13
14 "edge-infra.dev/pkg/edge/api/graph/model"
15 sqlquery "edge-infra.dev/pkg/edge/api/sql"
16 "edge-infra.dev/pkg/edge/api/utils"
17 )
18
19 const (
20 testBannerEdgeID101 = "3396a52c-6a22-4049-9593-5a63b596a101"
21 testClusterEdgeID200 = "3396a52c-6a22-4049-9593-5a63b596a200"
22
23 testRegistryEdgeID = "018ea9c2-ca5d-7a8a-830c-d533e8b52e71"
24 testClusterRegistryEdgeID = "019eac81-da8d-3a2d-122c-c264e7b53c90"
25
26 testURL = "registry.io"
27 updatedURL = "updated.registry.io"
28 )
29
30 var (
31 testDescription = "Registry"
32 updatedDescription = "Updated registry"
33
34 registryADescription = "Registry A"
35 registryBDescription = "Registry B"
36 registryCDescription = "Registry C"
37
38 artifactRegistriesColumns = []string{"registry_edge_id", "banner_edge_id", "description", "registry_url"}
39 clusterArtifactRegistriesColumns = []string{"cluster_registry_edge_id", "cluster_edge_id", "registry_edge_id"}
40 existsRows = []string{"exists"}
41
42 testArtifactRegistries = []*model.ArtifactRegistry{
43 {
44 RegistryEdgeID: "018ea9c2-ca5d-7a8a-830c-d533e8b52e71",
45 BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a101",
46 Description: ptr.To(registryADescription),
47 URL: "a.registry.io",
48 },
49 {
50 RegistryEdgeID: "018ea9c2-ca5d-7a8a-830c-d533e8b52e72",
51 BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a101",
52 Description: ptr.To(registryBDescription),
53 URL: "b.registry.io",
54 },
55 {
56 RegistryEdgeID: "018ea9c2-ca5d-7a8a-830c-d533e8b52e73",
57 BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a102",
58 Description: ptr.To(registryCDescription),
59 URL: "c.registry.io",
60 },
61 }
62
63 testClusterArtifactRegistries = []*model.ClusterArtifactRegistry{
64 {
65 ClusterRegistryEdgeID: "019eac81-da8d-3a2d-122c-c264e7b53c90",
66 ClusterEdgeID: "3396a52c-6a22-4049-9593-5a63b596a200",
67 RegistryEdgeID: "018ea9c2-ca5d-7a8a-830c-d533e8b52e71",
68 },
69 {
70 ClusterRegistryEdgeID: "019eac81-da8d-3a2d-122c-c264e7b53c91",
71 ClusterEdgeID: "3396a52c-6a22-4049-9593-5a63b596a200",
72 RegistryEdgeID: "018ea9c2-ca5d-7a8a-830c-d533e8b52e72",
73 },
74 {
75 ClusterRegistryEdgeID: "019eac81-da8d-3a2d-122c-c264e7b53c92",
76 ClusterEdgeID: "3396a52c-6a22-4049-9593-5a63b596a201",
77 RegistryEdgeID: "018ea9c2-ca5d-7a8a-830c-d533e8b52e71",
78 },
79 }
80 )
81
82 func TestGetArtifactRegistry(t *testing.T) {
83 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
84 require.NoError(t, err)
85
86 defer sqlDB.Close()
87
88 returnArtifactRegistry := &model.ArtifactRegistry{
89 RegistryEdgeID: testRegistryEdgeID,
90 BannerEdgeID: testBannerEdgeID,
91 Description: ptr.To(testDescription),
92 URL: testURL,
93 }
94
95 mockGetArtifactRegistryByIDQuery(mock, testRegistryEdgeID, returnArtifactRegistry)
96
97 s := NewArtifactRegistryService(sqlDB)
98 artifactRegistry, err := s.GetArtifactRegistry(context.Background(), testRegistryEdgeID)
99
100 require.NoError(t, err)
101 assert.Equal(t, testRegistryEdgeID, artifactRegistry.RegistryEdgeID)
102 assert.Equal(t, testBannerEdgeID, artifactRegistry.BannerEdgeID)
103 require.NotNil(t, artifactRegistry.Description)
104 assert.Equal(t, testDescription, *artifactRegistry.Description)
105 assert.Equal(t, testURL, artifactRegistry.URL)
106
107 require.NoError(t, mock.ExpectationsWereMet())
108 }
109
110 func TestGetArtifactRegistriesForBanner(t *testing.T) {
111 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
112 require.NoError(t, err)
113
114 defer sqlDB.Close()
115
116 targetBannerEdgeID := testBannerEdgeID101
117
118 returnArtifactRegistries := []*model.ArtifactRegistry{}
119 for _, artifactRegistry := range testArtifactRegistries {
120 if artifactRegistry.BannerEdgeID == targetBannerEdgeID {
121 returnArtifactRegistries = append(returnArtifactRegistries, artifactRegistry)
122 }
123 }
124
125 mockGetArtifactRegistriesForBannerQuery(mock, targetBannerEdgeID, returnArtifactRegistries)
126
127 s := NewArtifactRegistryService(sqlDB)
128 artifactRegistries, err := s.GetArtifactRegistriesForBanner(context.Background(), targetBannerEdgeID)
129
130 require.NoError(t, err)
131 require.Len(t, artifactRegistries, 2)
132 for _, artifactRegistry := range artifactRegistries {
133 assert.Equal(t, targetBannerEdgeID, artifactRegistry.BannerEdgeID)
134 }
135
136 require.NoError(t, mock.ExpectationsWereMet())
137 }
138
139 func TestGetArtifactRegistriesForCluster(t *testing.T) {
140 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
141 require.NoError(t, err)
142
143 defer sqlDB.Close()
144
145 targetBannerEdgeID := testBannerEdgeID101
146 targetClusterEdgeID := testClusterEdgeID200
147 returnArtifactRegistries := testArtifactRegistries[:2]
148
149 mockGetArtifactRegistriesForClusterQuery(mock, targetClusterEdgeID, returnArtifactRegistries)
150
151 s := NewArtifactRegistryService(sqlDB)
152 artifactRegistries, err := s.GetArtifactRegistriesForCluster(context.Background(), targetClusterEdgeID)
153
154 require.NoError(t, err)
155 require.Len(t, artifactRegistries, 2)
156 for _, artifactRegistry := range artifactRegistries {
157 assert.Equal(t, targetBannerEdgeID, artifactRegistry.BannerEdgeID)
158 }
159
160 require.NoError(t, mock.ExpectationsWereMet())
161 }
162
163 func TestCreateArtifactRegistry(t *testing.T) {
164 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
165 require.NoError(t, err)
166
167 defer sqlDB.Close()
168
169 createInput := &model.ArtifactRegistryCreateInput{
170 BannerEdgeID: testBannerEdgeID,
171 Description: ptr.To(testDescription),
172 URL: testURL,
173 }
174
175 mock.ExpectBegin()
176 mockArtifactRegistryCreateQuery(mock, createInput, sqlmock.NewResult(1, 1))
177 mock.ExpectCommit()
178
179 s := NewArtifactRegistryService(sqlDB)
180 artifactRegistry, err := s.CreateArtifactRegistryEntry(context.Background(), createInput)
181
182 require.NoError(t, err)
183 assert.Equal(t, testBannerEdgeID, artifactRegistry.BannerEdgeID)
184 require.NotNil(t, artifactRegistry.Description)
185 assert.Equal(t, testDescription, *artifactRegistry.Description)
186 assert.Equal(t, testURL, artifactRegistry.URL)
187
188 require.NoError(t, mock.ExpectationsWereMet())
189 }
190
191 func TestCreateArtifactRegistryFailsIfURLIsEmpty(t *testing.T) {
192
193 sqlDB, _, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
194 require.NoError(t, err)
195
196 defer sqlDB.Close()
197
198 createInput := &model.ArtifactRegistryCreateInput{
199 BannerEdgeID: testBannerEdgeID,
200 URL: "",
201 }
202
203 s := NewArtifactRegistryService(sqlDB)
204 artifactRegistry, err := s.CreateArtifactRegistryEntry(context.Background(), createInput)
205
206 require.ErrorIs(t, err, utils.ErrRegistryURLCannotBeEmpty)
207 assert.Nil(t, artifactRegistry)
208 }
209
210 func TestUpdateArtifactRegistry(t *testing.T) {
211 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
212 require.NoError(t, err)
213
214 defer sqlDB.Close()
215
216 originalArtifactRegistry := &model.ArtifactRegistry{
217 RegistryEdgeID: testRegistryEdgeID,
218 BannerEdgeID: testBannerEdgeID,
219 Description: ptr.To(testDescription),
220 URL: testURL,
221 }
222
223 updateInput := &model.ArtifactRegistryUpdateInput{
224 Description: &updatedDescription,
225 URL: updatedURL,
226 }
227
228 mockGetArtifactRegistryByIDQuery(mock, testRegistryEdgeID, originalArtifactRegistry)
229
230 mock.ExpectBegin()
231 mockArtifactRegistryUpdateQuery(mock, testRegistryEdgeID, updateInput, sqlmock.NewResult(1, 1))
232 mock.ExpectCommit()
233
234 s := NewArtifactRegistryService(sqlDB)
235 artifactRegistry, err := s.UpdateArtifactRegistryEntry(context.Background(), testRegistryEdgeID, updateInput)
236
237 require.NoError(t, err)
238 require.NotNil(t, artifactRegistry.Description)
239 assert.Equal(t, updatedDescription, *artifactRegistry.Description)
240 assert.Equal(t, updatedURL, artifactRegistry.URL)
241
242 require.NoError(t, mock.ExpectationsWereMet())
243 }
244
245 func TestUpdateArtifactRegistryFailsIfURLIsEmpty(t *testing.T) {
246
247 sqlDB, _, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
248 require.NoError(t, err)
249
250 defer sqlDB.Close()
251
252 updateInput := &model.ArtifactRegistryUpdateInput{
253 URL: "",
254 }
255
256 s := NewArtifactRegistryService(sqlDB)
257 artifactRegistry, err := s.UpdateArtifactRegistryEntry(context.Background(), testRegistryEdgeID, updateInput)
258
259 require.ErrorIs(t, err, utils.ErrRegistryURLCannotBeEmpty)
260 assert.Nil(t, artifactRegistry)
261 }
262
263 func TestUpdateArtifactRegistryDoesNotUpdateIfNoChangesAreMade(t *testing.T) {
264 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
265 require.NoError(t, err)
266
267 defer sqlDB.Close()
268
269 originalArtifactRegistry := &model.ArtifactRegistry{
270 RegistryEdgeID: testRegistryEdgeID,
271 BannerEdgeID: testBannerEdgeID,
272 Description: ptr.To(testDescription),
273 URL: testURL,
274 }
275
276 updateInput := &model.ArtifactRegistryUpdateInput{
277 Description: ptr.To(testDescription),
278 URL: testURL,
279 }
280
281 mockGetArtifactRegistryByIDQuery(mock, testRegistryEdgeID, originalArtifactRegistry)
282
283
284 s := NewArtifactRegistryService(sqlDB)
285 artifactRegistry, err := s.UpdateArtifactRegistryEntry(context.Background(), testRegistryEdgeID, updateInput)
286
287 require.NoError(t, err)
288 require.NotNil(t, artifactRegistry.Description)
289 assert.Equal(t, testDescription, *artifactRegistry.Description)
290 assert.Equal(t, testURL, artifactRegistry.URL)
291
292 require.NoError(t, mock.ExpectationsWereMet())
293 }
294
295 func TestDeleteArtifactRegistry(t *testing.T) {
296 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
297 require.NoError(t, err)
298
299 defer sqlDB.Close()
300
301 mockArtifactRegistryExistsQuery(mock, testRegistryEdgeID, true)
302 mockArtifactRegistryDeleteQuery(mock, testRegistryEdgeID, sqlmock.NewResult(1, 1))
303
304 s := NewArtifactRegistryService(sqlDB)
305 deleted, err := s.DeleteArtifactRegistryEntry(context.Background(), testRegistryEdgeID)
306
307 require.NoError(t, err)
308 assert.True(t, deleted)
309
310
311 mockArtifactRegistryExistsQuery(mock, testRegistryEdgeID, false)
312 deleted, err = s.DeleteArtifactRegistryEntry(context.Background(), testRegistryEdgeID)
313
314 assert.NoError(t, err)
315 assert.False(t, deleted)
316
317 require.NoError(t, mock.ExpectationsWereMet())
318 }
319
320 func TestGetClusterArtifactRegistry(t *testing.T) {
321 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
322 require.NoError(t, err)
323
324 defer sqlDB.Close()
325
326 returnClusterArtifactRegistry := &model.ClusterArtifactRegistry{
327 RegistryEdgeID: testRegistryEdgeID,
328 ClusterEdgeID: testClusterEdgeID,
329 ClusterRegistryEdgeID: testClusterRegistryEdgeID,
330 }
331
332 mockGetClusterArtifactRegistryByIDQuery(mock, testClusterRegistryEdgeID, returnClusterArtifactRegistry)
333
334 s := NewArtifactRegistryService(sqlDB)
335 clusterArtifactRegistry, err := s.GetClusterArtifactRegistry(context.Background(), testClusterRegistryEdgeID)
336
337 require.NoError(t, err)
338 assert.Equal(t, testClusterRegistryEdgeID, clusterArtifactRegistry.ClusterRegistryEdgeID)
339 assert.Equal(t, testClusterEdgeID, clusterArtifactRegistry.ClusterEdgeID)
340 assert.Equal(t, testRegistryEdgeID, clusterArtifactRegistry.RegistryEdgeID)
341
342 require.NoError(t, mock.ExpectationsWereMet())
343 }
344
345 func TestGetClusterArtifactRegistriesForCluster(t *testing.T) {
346 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
347 require.NoError(t, err)
348
349 defer sqlDB.Close()
350
351 targetClusterEdgeID := testClusterEdgeID200
352
353 returnClusterArtifactRegistries := []*model.ClusterArtifactRegistry{}
354 for _, clusterArtifactRegistry := range testClusterArtifactRegistries {
355 if clusterArtifactRegistry.ClusterEdgeID == targetClusterEdgeID {
356 returnClusterArtifactRegistries = append(returnClusterArtifactRegistries, clusterArtifactRegistry)
357 }
358 }
359
360 mockGetClusterArtifactRegistriesForClusterQuery(mock, targetClusterEdgeID, returnClusterArtifactRegistries)
361
362 s := NewArtifactRegistryService(sqlDB)
363 clusterArtifactRegistries, err := s.GetClusterArtifactRegistries(context.Background(), targetClusterEdgeID)
364
365 require.NoError(t, err)
366 require.Len(t, clusterArtifactRegistries, 2)
367 for _, clusterArtifactRegistry := range clusterArtifactRegistries {
368 assert.Equal(t, targetClusterEdgeID, clusterArtifactRegistry.ClusterEdgeID)
369 }
370
371 require.NoError(t, mock.ExpectationsWereMet())
372 }
373
374 func TestCreateClusterArtifactRegistry(t *testing.T) {
375 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
376 require.NoError(t, err)
377
378 defer sqlDB.Close()
379
380 createInput := &model.ClusterArtifactRegistryCreateInput{
381 ClusterEdgeID: testClusterEdgeID,
382 RegistryEdgeID: testRegistryEdgeID,
383 }
384
385 mock.ExpectBegin()
386 mockClusterArtifactRegistryCreateQuery(mock, createInput, sqlmock.NewResult(1, 1))
387 mock.ExpectCommit()
388
389 s := NewArtifactRegistryService(sqlDB)
390 clusterArtifactRegistry, err := s.CreateClusterArtifactRegistryEntry(context.Background(), createInput)
391
392 require.NoError(t, err)
393 assert.Equal(t, testClusterEdgeID, clusterArtifactRegistry.ClusterEdgeID)
394 assert.Equal(t, testRegistryEdgeID, clusterArtifactRegistry.RegistryEdgeID)
395
396 require.NoError(t, mock.ExpectationsWereMet())
397 }
398
399 func TestDeleteClusterArtifactRegistry(t *testing.T) {
400 sqlDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
401 require.NoError(t, err)
402
403 defer sqlDB.Close()
404
405 mockClusterArtifactRegistryExistsQuery(mock, testClusterRegistryEdgeID, true)
406 mockClusterArtifactRegistryDeleteQuery(mock, testClusterRegistryEdgeID, sqlmock.NewResult(1, 1))
407
408 s := NewArtifactRegistryService(sqlDB)
409 deleted, err := s.DeleteClusterArtifactRegistryEntry(context.Background(), testClusterRegistryEdgeID)
410
411 require.NoError(t, err)
412 assert.True(t, deleted)
413
414
415 mockClusterArtifactRegistryExistsQuery(mock, testClusterRegistryEdgeID, false)
416 deleted, err = s.DeleteClusterArtifactRegistryEntry(context.Background(), testClusterRegistryEdgeID)
417
418 assert.NoError(t, err)
419 assert.False(t, deleted)
420
421 require.NoError(t, mock.ExpectationsWereMet())
422 }
423
424 func mockGetArtifactRegistryByIDQuery(mock sqlmock.Sqlmock, registryEdgeID string, returnArtifactRegistry *model.ArtifactRegistry) {
425 rows := mock.NewRows(artifactRegistriesColumns).AddRow(returnArtifactRegistry.RegistryEdgeID,
426 returnArtifactRegistry.BannerEdgeID,
427 returnArtifactRegistry.Description,
428 returnArtifactRegistry.URL,
429 )
430 mock.ExpectQuery(sqlquery.GetArtifactRegistryByIDQuery).WithArgs(registryEdgeID).WillReturnRows(rows)
431 }
432
433 func mockGetArtifactRegistriesForBannerQuery(mock sqlmock.Sqlmock, bannerEdgeID string, returnArtifactRegistries []*model.ArtifactRegistry) {
434 rows := mock.NewRows(artifactRegistriesColumns)
435 for _, artifactRegistry := range returnArtifactRegistries {
436 rows.AddRow(artifactRegistry.RegistryEdgeID, artifactRegistry.BannerEdgeID, artifactRegistry.Description, artifactRegistry.URL)
437 }
438 mock.ExpectQuery(sqlquery.GetArtifactRegistriesForBannerQuery).WithArgs(bannerEdgeID).WillReturnRows(rows)
439 }
440
441 func mockGetArtifactRegistriesForClusterQuery(mock sqlmock.Sqlmock, clusterEdgeID string, returnArtifactRegistries []*model.ArtifactRegistry) {
442 rows := mock.NewRows(artifactRegistriesColumns)
443 for _, artifactRegistry := range returnArtifactRegistries {
444 rows.AddRow(artifactRegistry.RegistryEdgeID, artifactRegistry.BannerEdgeID, artifactRegistry.Description, artifactRegistry.URL)
445 }
446 mock.ExpectQuery(sqlquery.GetArtifactRegistriesForClusterQuery).WithArgs(clusterEdgeID).WillReturnRows(rows)
447 }
448
449 func mockArtifactRegistryCreateQuery(mock sqlmock.Sqlmock, createArtifactRegistry *model.ArtifactRegistryCreateInput, result driver.Result) {
450 args := []driver.Value{
451 sqlmock.AnyArg(),
452 createArtifactRegistry.BannerEdgeID,
453 createArtifactRegistry.Description,
454 createArtifactRegistry.URL,
455 }
456 mock.ExpectExec(sqlquery.ArtifactRegistryCreateQuery).WithArgs(args...).WillReturnResult(result)
457 }
458
459 func mockArtifactRegistryUpdateQuery(mock sqlmock.Sqlmock, registryEdgeID string, updateArtifactRegistry *model.ArtifactRegistryUpdateInput, result driver.Result) {
460 args := []driver.Value{
461 updateArtifactRegistry.Description,
462 updateArtifactRegistry.URL,
463 registryEdgeID,
464 }
465 mock.ExpectExec(sqlquery.ArtifactRegistryUpdateQuery).WithArgs(args...).WillReturnResult(result)
466 }
467
468 func mockArtifactRegistryExistsQuery(mock sqlmock.Sqlmock, registryEdgeID string, exists bool) {
469 rows := mock.NewRows(existsRows).AddRow(strconv.FormatBool(exists))
470 mock.ExpectQuery(sqlquery.ArtifactRegistryExistsQuery).WithArgs(registryEdgeID).WillReturnRows(rows)
471 }
472
473 func mockArtifactRegistryDeleteQuery(mock sqlmock.Sqlmock, registryEdgeID string, result driver.Result) {
474 mock.ExpectExec(sqlquery.ArtifactRegistryDeleteQuery).WithArgs(registryEdgeID).WillReturnResult(result)
475 }
476
477 func mockGetClusterArtifactRegistryByIDQuery(mock sqlmock.Sqlmock, clusterRegistryEdgeID string, returnClusterArtifactRegistry *model.ClusterArtifactRegistry) {
478 rows := mock.NewRows(clusterArtifactRegistriesColumns).AddRow(
479 returnClusterArtifactRegistry.ClusterRegistryEdgeID,
480 returnClusterArtifactRegistry.ClusterEdgeID,
481 returnClusterArtifactRegistry.RegistryEdgeID,
482 )
483 mock.ExpectQuery(sqlquery.GetClusterArtifactRegistryByIDQuery).WithArgs(clusterRegistryEdgeID).WillReturnRows(rows)
484 }
485
486 func mockGetClusterArtifactRegistriesForClusterQuery(mock sqlmock.Sqlmock, clusterEdgeID string, returnClusterArtifactRegistries []*model.ClusterArtifactRegistry) {
487 rows := mock.NewRows(clusterArtifactRegistriesColumns)
488 for _, clusterArtifactRegistry := range returnClusterArtifactRegistries {
489 rows.AddRow(clusterArtifactRegistry.ClusterRegistryEdgeID, clusterArtifactRegistry.ClusterEdgeID, clusterArtifactRegistry.RegistryEdgeID)
490 }
491 mock.ExpectQuery(sqlquery.GetClusterArtifactRegistriesForClusterQuery).WithArgs(clusterEdgeID).WillReturnRows(rows)
492 }
493
494 func mockClusterArtifactRegistryCreateQuery(mock sqlmock.Sqlmock, createClusterArtifactRegistry *model.ClusterArtifactRegistryCreateInput, result driver.Result) {
495 args := []driver.Value{
496 sqlmock.AnyArg(),
497 createClusterArtifactRegistry.ClusterEdgeID,
498 createClusterArtifactRegistry.RegistryEdgeID,
499 }
500 mock.ExpectExec(sqlquery.ClusterArtifactRegistryCreateQuery).WithArgs(args...).WillReturnResult(result)
501 }
502
503 func mockClusterArtifactRegistryExistsQuery(mock sqlmock.Sqlmock, clusterRegistryEdgeID string, exists bool) {
504 rows := mock.NewRows(existsRows).AddRow(strconv.FormatBool(exists))
505 mock.ExpectQuery(sqlquery.ClusterArtifactRegistryExistsQuery).WithArgs(clusterRegistryEdgeID).WillReturnRows(rows)
506 }
507
508 func mockClusterArtifactRegistryDeleteQuery(mock sqlmock.Sqlmock, clusterRegistryEdgeID string, result driver.Result) {
509 mock.ExpectExec(sqlquery.ClusterArtifactRegistryDeleteQuery).WithArgs(clusterRegistryEdgeID).WillReturnResult(result)
510 }
511
View as plain text