1 package integration_test
2
3 import (
4 "context"
5 "encoding/base64"
6 "encoding/json"
7 "fmt"
8 "time"
9
10 pubSub "cloud.google.com/go/pubsub"
11 "github.com/thoas/go-funk"
12 "github.com/udacity/graphb"
13 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
14 "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
15
16 "edge-infra.dev/pkg/edge/api/apierror"
17 "edge-infra.dev/pkg/edge/api/graph/model"
18 "edge-infra.dev/pkg/edge/api/services"
19 bannerApi "edge-infra.dev/pkg/edge/apis/banner/v1alpha1"
20 clusterApi "edge-infra.dev/pkg/edge/apis/cluster/v1alpha1"
21 gkeClusterApi "edge-infra.dev/pkg/edge/apis/gkecluster/v1alpha1"
22 chariotAPI "edge-infra.dev/pkg/edge/chariot/client"
23 "edge-infra.dev/pkg/edge/controllers/util/edgedb"
24 chariotClientApiTestutils "edge-infra.dev/test/framework/gcp/pubsub"
25 "edge-infra.dev/test/framework/integration"
26 )
27
28 func (s *Suite) TestCreateBanner() {
29 integration.SkipIf(s.Framework)
30 var response struct{ CreateBanner *model.EdgeResponsePayload }
31 mutation := createBannerMutation("test-create-org", false, "")
32 ResolverClient.MustPost(mutation, &response)
33 s.NotNil(response.CreateBanner)
34 s.Equal(200, response.CreateBanner.StatusCode)
35 s.Equal("Successfully created test-create-org", response.CreateBanner.Message)
36 }
37
38 func (s *Suite) TestCreateBannerWithExisitingOrg() {
39 integration.SkipIf(s.Framework)
40 var response struct{ CreateBanner *model.EdgeResponsePayload }
41 mutation := createBannerMutation("test-create-with-exisiting-org", true, "3ea81a9de9564c3584015b98dd8bcfe9")
42 ResolverClient.MustPost(mutation, &response)
43 s.NotNil(response.CreateBanner)
44 s.Equal(200, response.CreateBanner.StatusCode)
45 }
46
47 func (s *Suite) TestCreateBannerWithExisitingEu() {
48 integration.SkipIf(s.Framework)
49 var response struct{ CreateBanner *model.EdgeResponsePayload }
50 mutation := createBannerMutation("test-create-eu", false, "cc5c02f7289343cd9c68c879ffb11c85")
51 ResolverClient.MustPost(mutation, &response)
52 s.NotNil(response.CreateBanner)
53 s.Equal(200, response.CreateBanner.StatusCode)
54 }
55
56 func (s *Suite) TestCreateBannerWithDeletedEu() {
57 integration.SkipIf(s.Framework)
58 var response struct{ CreateBanner *model.EdgeResponsePayload }
59 mutation := createBannerMutation("test-create-eu", false, "test-bsl-id-for-deleted-eu")
60 err := ResolverClient.Post(mutation, &response)
61 fmt.Println(err.Error())
62 s.Error(err)
63 s.Contains(err.Error(), "enterprise unit test-bsl-id-for-deleted-eu is deleted")
64 s.Nil(response.CreateBanner)
65 }
66
67 func (s *Suite) TestCreateBannerWithDeletedOrg() {
68 integration.SkipIf(s.Framework)
69 var response struct{ CreateBanner *model.EdgeResponsePayload }
70 mutation := createBannerMutation("test-create-org", true, "test-bsl-id-for-deleted-org")
71 err := ResolverClient.Post(mutation, &response)
72 s.Error(err)
73 s.Contains(err.Error(), "bsl subOrg test-bsl-id-for-deleted-org is deleted")
74 s.Nil(response.CreateBanner)
75 }
76
77 func (s *Suite) TestUpdateBanner() {
78 integration.SkipIf(s.Framework)
79 var response struct{ UpdateBanner *model.EdgeResponsePayload }
80 mutation := updateBannerMutation("3396a52c-6a22-4049-9593-5a63b596a100", "new-name", "new-desc")
81 ResolverClient.MustPost(mutation, &response)
82 s.NotNil(response.UpdateBanner)
83 s.Equal(200, response.UpdateBanner.StatusCode)
84 s.Equal("Successfully updated new-name", response.UpdateBanner.Message)
85
86
87 mutation = updateBannerMutation("3396a52c-6a22-4049-9593-5a63b596a100", "test-org", "test_description")
88 ResolverClient.MustPost(mutation, &response)
89 s.NotNil(response.UpdateBanner)
90 s.Equal(200, response.UpdateBanner.StatusCode)
91 s.Equal("Successfully updated test-org", response.UpdateBanner.Message)
92 }
93
94 func (s *Suite) TestCreateBannerError() {
95 integration.SkipIf(s.Framework)
96 var response struct{ CreateBanner *model.EdgeResponsePayload }
97 mutation := createBannerMutation("test-create-org-with-error", false, "")
98 s.NoError(ResolverClient.Post(mutation, &response))
99 mutation = createBannerMutation("test-create-org-with-error", false, "")
100 s.Error(ResolverClient.Post(mutation, &response))
101 s.Nil(response.CreateBanner)
102 }
103
104 func (s *Suite) TestDeleteBanner() {
105 integration.SkipIf(s.Framework)
106 if !integration.IsIntegrationTest() {
107 s.NoError(s.client.Create(context.Background(), getTestProject("test-delete-org")))
108 }
109 var deleteOrganizationResponse struct{ DeleteBanner *model.EdgeResponsePayload }
110 mutation := deleteBannerMutation("3396a52c-6a22-4049-9593-5a63b596a103")
111
112 done := make(chan bool)
113 messageCount := 0
114 chariotPubSubValidationFN := func(msg *pubSub.Message) {
115 message := &chariotAPI.ChariotMessage{}
116 err := json.Unmarshal(msg.Data, message)
117 if err != nil {
118 fmt.Println(err)
119 }
120 fmt.Printf("Special Chariot Message: %v\n", message)
121 for _, t := range message.Objects {
122 rawDecodedText, _ := base64.StdEncoding.DecodeString(t)
123 resource := &unstructured.Unstructured{}
124 _ = resource.UnmarshalJSON(rawDecodedText)
125 if resource.GetKind() != "Cluster" && resource.GetKind() != "Banner" {
126 s.FailNow("Chariot message not a banner or cluster")
127 }
128 s.Equal("DELETE", message.Operation)
129 messageCount++
130 }
131 }
132 ctx, cancel := context.WithCancel(context.Background())
133 defer cancel()
134 go func() {
135 err := chariotClientApiTestutils.CreateMockSubscription(ctx, done, topLevelProjectID, testChariotPubsubTopic, "tsub", 20*time.Second, "", chariotPubSubValidationFN, s.ChariotClient)
136 s.NoError(err)
137 }()
138 ResolverClient.MustPost(mutation, &deleteOrganizationResponse)
139 s.NotNil(deleteOrganizationResponse.DeleteBanner)
140 s.Equal(200, deleteOrganizationResponse.DeleteBanner.StatusCode)
141 s.Equal("Successfully deleted delete-banner", deleteOrganizationResponse.DeleteBanner.Message)
142
143
144 select {
145 case <-done:
146 case <-time.After(2 * time.Second):
147 s.Fail("Failed to send delete message")
148 }
149 select {
150 case <-done:
151 case <-time.After(2 * time.Second):
152 s.Fail("Failed to send delete message")
153 }
154 s.Equal(2, messageCount)
155 }
156
157 func (s *Suite) TestDeleteBanner_NotExists() {
158 integration.SkipIf(s.Framework)
159 var deleteOrganizationResponse struct{ DeleteOrganization *model.EdgeResponsePayload }
160 mutation := deleteBannerMutation("test-org-not-exist-id")
161 s.Error(ResolverClient.Post(mutation, &deleteOrganizationResponse))
162 s.Nil(deleteOrganizationResponse.DeleteOrganization)
163 }
164
165 func (s *Suite) TestBanner() {
166 integration.SkipIf(s.Framework)
167 query := getBannerQuery("98ef1fcb-dc88-4c9f-9980-c09a04564a48")
168 var response struct{ Banner *model.Banner }
169 err := ResolverClient.Post(query, &response)
170 s.NoError(err)
171 s.Equal(response.Banner.BannerBSLId, "eu-banner-bsl-id")
172 s.Equal(response.Banner.Name, "test-banner-eu")
173 s.NotNil(response.Banner.BannerStatus)
174 s.NotNil(*response.Banner.BslDataSynced)
175 s.Equal(2, len(response.Banner.BslEntityTypes))
176 s.True(response.Banner.OptInEdgeSecurityCompliance, "edge-opt-in-compliance is expected to be enabled")
177 s.ElementsMatch([]string{"item", "item-price"}, response.Banner.BslEntityTypes)
178 }
179
180 func (s *Suite) TestBanner_Mismatches() {
181 integration.SkipIf(s.Framework)
182 query := getBannerQuery("3396a52c-6a22-4049-9593-5a63b596a101")
183 var response struct{ Banner *model.Banner }
184 err := ResolverClient.Post(query, &response)
185 s.Contains(err.Error(), apierror.BannerCheckMessage)
186 s.Contains(err.Error(), "banner test-org-banner not found in bsl")
187 s.Equal(response.Banner.BannerBSLId, "test-org-banner")
188 s.Equal(response.Banner.Name, "test-org-banner")
189 s.False(response.Banner.OptInEdgeSecurityCompliance, "edge-opt-into-compliance is expected to be disabled")
190 }
191
192 func (s *Suite) TestBanners() {
193 integration.SkipIf(s.Framework)
194 query := getBannersQuery()
195 var response struct{ Banners []*model.Banner }
196 err := ResolverClient.Post(query, &response)
197 s.NoError(err)
198 s.NotZero(len(response.Banners))
199 s.NotNil(funk.Find(response.Banners, func(o *model.Banner) bool { return o.Name == testOrg }))
200 }
201
202 func (s *Suite) TestBanners_Mismatches() {
203 integration.SkipIf(s.Framework)
204 var updateResp struct{ UpdateBanner *model.EdgeResponsePayload }
205 mutation := updateBannerMutation("3396a52c-6a22-4049-9593-5a63b596a100", "new-name", "new-desc")
206 ResolverClient.MustPost(mutation, &updateResp)
207 s.NotNil(updateResp.UpdateBanner)
208 s.Equal(200, updateResp.UpdateBanner.StatusCode)
209 s.Equal("Successfully updated new-name", updateResp.UpdateBanner.Message)
210
211 query := getBannersQuery()
212 var response struct{ Banners []*model.Banner }
213 err := ResolverClient.Post(query, &response)
214 s.NoError(err)
215 s.NotZero(len(response.Banners))
216 s.NotNil(funk.Find(response.Banners, func(o *model.Banner) bool { return o.Name == testOrg }))
217
218
219 mutation = updateBannerMutation("3396a52c-6a22-4049-9593-5a63b596a100", "test-org", "test_description")
220 ResolverClient.MustPost(mutation, &updateResp)
221 s.NotNil(updateResp.UpdateBanner)
222 s.Equal(200, updateResp.UpdateBanner.StatusCode)
223 s.Equal("Successfully updated test-org", updateResp.UpdateBanner.Message)
224 }
225
226 func (s Suite) TestBannerStatus() {
227 integration.SkipIf(s.Framework)
228
229
230 query := bannerStatusQuery("98ef1fcb-dc88-4c9f-9980-c09a04564a48")
231 var response struct{ BannerStatus *model.BannerStatus }
232 err := ResolverClient.Post(query, &response)
233 s.NoError(err)
234 s.NotNil(response.BannerStatus)
235 s.Equal(services.ProvisionedStatus, response.BannerStatus.Reason)
236 s.Equal("ProvisionSucceeded: banner reconciled successfully", response.BannerStatus.Message)
237 s.True(response.BannerStatus.Ready)
238 s.NotEmpty(response.BannerStatus.LastUpdatedAt)
239
240 _, err = time.Parse(time.RFC3339, response.BannerStatus.LastUpdatedAt)
241 s.NoError(err)
242
243
244 query = bannerStatusQuery("3396a52c-6a22-4049-9593-5a63b596a104")
245 var response2 struct{ BannerStatus *model.BannerStatus }
246 err = ResolverClient.Post(query, &response2)
247 s.NoError(err)
248 s.NotNil(response2.BannerStatus)
249 s.Equal(string(edgedb.InfraStatusProvisioning), response2.BannerStatus.Reason)
250 s.Equal(services.ProvisioningStatusMessage, response2.BannerStatus.Message)
251 s.False(response2.BannerStatus.Ready)
252 s.NotEmpty(response2.BannerStatus.LastUpdatedAt)
253
254 _, err = time.Parse(time.RFC3339, response2.BannerStatus.LastUpdatedAt)
255 s.NoError(err)
256 }
257
258 func (s *Suite) TestAssignUserToEUBanner() {
259 integration.SkipIf(s.Framework)
260 mutation := assignUserToBannerMutation(testUser, []string{"3396a52c-6a22-4049-9593-5a63b596a102"})
261 var response struct{ AssignUserToBanner *model.EdgeResponsePayload }
262 ResolverClient.MustPost(mutation, &response)
263 s.NotNil(response.AssignUserToBanner)
264 s.Equal(200, response.AssignUserToBanner.StatusCode)
265 s.Equal("Successfully assigned user acct:emerald-edge-dev@testing to banners [eu-banner]", response.AssignUserToBanner.Message)
266 }
267
268 func (s *Suite) TestAssignUserToOrgBanner() {
269 integration.SkipIf(s.Framework)
270 mutation := assignUserToBannerMutation(testUser, []string{"3396a52c-6a22-4049-9593-5a63b596a100"})
271 var response struct{ AssignUserToBanner *model.EdgeResponsePayload }
272 ResolverClient.MustPost(mutation, &response)
273 s.NotNil(response.AssignUserToBanner)
274 s.Equal(200, response.AssignUserToBanner.StatusCode)
275 s.Equal("Successfully assigned user acct:emerald-edge-dev@testing to banners [test-org]", response.AssignUserToBanner.Message)
276 }
277
278 func (s *Suite) TestAssignUserToEUAndOrgBanner() {
279 integration.SkipIf(s.Framework)
280 mutation := assignUserToBannerMutation(testUser, []string{"3396a52c-6a22-4049-9593-5a63b596a102", "3396a52c-6a22-4049-9593-5a63b596a100"})
281 var response struct{ AssignUserToBanner *model.EdgeResponsePayload }
282 ResolverClient.MustPost(mutation, &response)
283 s.NotNil(response.AssignUserToBanner)
284 s.Equal(200, response.AssignUserToBanner.StatusCode)
285 s.Equal("Successfully assigned user acct:emerald-edge-dev@testing to banners [eu-banner test-org]", response.AssignUserToBanner.Message)
286 }
287
288 func (s *Suite) TestAssignRoleToUser() {
289 integration.SkipIf(s.Framework)
290 mutation := assignRoleToUserMutation(testUser, adminRole)
291 var response struct{ AssignRoleToUser *model.EdgeResponsePayload }
292 ResolverClient.MustPost(mutation, &response)
293 s.NotNil(response.AssignRoleToUser)
294 s.Equal(200, response.AssignRoleToUser.StatusCode)
295 s.Equal(fmt.Sprintf("%s role added successfully", adminRole), response.AssignRoleToUser.Message)
296 }
297
298 func (s *Suite) TestAssignRolesToUser() {
299
300 validRoles := []string{"EDGE_BANNER_VIEWER", "EDGE_BANNER_OPERATOR"}
301 validRolesPlus := []string{"EDGE_BANNER_VIEWER", "EDGE_L3"}
302 var revokeRole []string
303
304 mutation1 := assignRolesToUserMutation(testUser, validRoles)
305 var response1 struct{ AssignRolesToUser *model.EdgeResponsePayload }
306 ResolverClient.MustPost(mutation1, &response1)
307 s.NotNil(response1.AssignRolesToUser)
308 s.Equal(200, response1.AssignRolesToUser.StatusCode)
309 s.Equal(fmt.Sprintf("%s role added successfully", validRoles), response1.AssignRolesToUser.Message)
310
311
312 mutation1 = assignRolesToUserMutation(testUser, validRolesPlus)
313 var response1plus struct{ AssignRolesToUser *model.EdgeResponsePayload }
314 ResolverClient.MustPost(mutation1, &response1plus)
315 s.NotNil(response1plus.AssignRolesToUser)
316 s.Equal(200, response1plus.AssignRolesToUser.StatusCode)
317 s.Equal(fmt.Sprintf("%s role added successfully", validRolesPlus), response1plus.AssignRolesToUser.Message)
318
319
320 mutation1Revoke := assignRolesToUserMutation(testUser, revokeRole)
321 var response1revoke struct{ AssignRolesToUser *model.EdgeResponsePayload }
322 ResolverClient.MustPost(mutation1Revoke, &response1revoke)
323 s.NotNil(response1revoke.AssignRolesToUser)
324 s.Equal(200, response1revoke.AssignRolesToUser.StatusCode)
325 s.Equal("roles revoked successfully", response1revoke.AssignRolesToUser.Message)
326
327
328 invalidRoles := []string{"Jibberish", "EDGE_BANNER_OPERATOR"}
329 mutation2 := assignRolesToUserMutation(testUser, invalidRoles)
330 var response2 struct{ AssignRolesToUser *model.EdgeResponsePayload }
331 err2 := ResolverClient.Post(mutation2, &response2)
332 s.Error(err2)
333 s.Contains(err2.Error(), "access denied: user cannot assign the requested role Jibberish")
334
335
336 emptyRoles := []string{"EDGE_BANNER_OPERATOR", ""}
337 mutation3 := assignRolesToUserMutation(testUser, emptyRoles)
338 var response3 struct{ AssignRolesToUser *model.EdgeResponsePayload }
339 err3 := ResolverClient.Post(mutation3, &response3)
340 s.Error(err3)
341 s.Contains(err3.Error(), "empty role input")
342 }
343
344 func (s *Suite) TestGetBannerRemoteAccessIP() {
345 integration.SkipIf(s.Framework)
346 query := getRemoteAccessIPQuery("98ef1fcb-dc88-4c9f-9980-c09a04564a48")
347 var response struct{ Banner *model.Banner }
348 err := ResolverClient.Post(query, &response)
349 s.NoError(err)
350 s.NotNil(response.Banner)
351 s.Equal("136.108.49.132", response.Banner.RemoteAccessIP)
352 }
353
354 func (s *Suite) TestUpdateBannerOptOutSecurityCompliance() {
355 integration.SkipIf(s.Framework)
356 var response struct{ UpdateBanner *model.EdgeResponsePayload }
357 mutation := "mutation{updateBanner(bannerEdgeId: \"4cb5d0e5-42cd-4483-8dca-547507d2adb0\", edgeSecurityCompliance: optOut){message, statusCode}}"
358 ResolverClient.MustPost(mutation, &response)
359 s.NotNil(response.UpdateBanner)
360 s.Equal(200, response.UpdateBanner.StatusCode)
361 s.Equal("Successfully updated test-sec-compliance", response.UpdateBanner.Message)
362
363 var banner struct{ Banner model.Banner }
364 query := "query {banner(bannerEdgeId: \"4cb5d0e5-42cd-4483-8dca-547507d2adb0\") {optInEdgeSecurityCompliance}}"
365 err = ResolverClient.Post(query, &banner)
366 s.False(banner.Banner.OptInEdgeSecurityCompliance)
367 s.updateBannerSecurityCompliance(testSecurityBannerID, true)
368 }
369
370 func createBannerMutation(bannerName string, isOrgBanner bool, bslID string) string {
371 return MustParse(graphb.Query{
372 Type: graphb.TypeMutation,
373 Fields: []*graphb.Field{
374 {
375 Name: "createBanner",
376 Arguments: []graphb.Argument{
377 graphb.ArgumentString("name", bannerName),
378 graphb.ArgumentString("description", "bff integration testing"),
379 graphb.ArgumentBool("isOrgBanner", isOrgBanner),
380 graphb.ArgumentString("bslId", bslID),
381 },
382 Fields: graphb.Fields("statusCode", "message"),
383 },
384 },
385 })
386 }
387
388 func updateBannerMutation(id, name, desc string) string {
389 return MustParse(graphb.Query{
390 Type: graphb.TypeMutation,
391 Fields: []*graphb.Field{
392 {
393 Name: "updateBanner",
394 Arguments: []graphb.Argument{
395 graphb.ArgumentString("displayName", name),
396 graphb.ArgumentString("description", desc),
397 graphb.ArgumentString("bannerEdgeId", id),
398 },
399 Fields: graphb.Fields("statusCode", "message"),
400 },
401 },
402 })
403 }
404
405 func deleteBannerMutation(bannerEdgeID string) string {
406 return MustParse(graphb.Query{
407 Type: graphb.TypeMutation,
408 Fields: []*graphb.Field{
409 {
410 Name: "deleteBanner",
411 Arguments: []graphb.Argument{
412 graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
413 },
414 Fields: graphb.Fields("statusCode", "message"),
415 },
416 },
417 })
418 }
419
420 func getBannerQuery(bannerEdgeID string) string {
421 return MustParse(graphb.Query{
422 Type: graphb.TypeQuery,
423 Fields: []*graphb.Field{
424 {
425 Name: "banner",
426 Arguments: []graphb.Argument{
427 graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
428 },
429 Fields: []*graphb.Field{
430 {Name: "name"},
431 {Name: "bannerBSLId"},
432 {Name: "bannerType"},
433 {Name: "bslDataSynced"},
434 {Name: "bslEntityTypes"},
435 {Name: "optInEdgeSecurityCompliance"},
436 {
437 Name: "bannerStatus",
438 Fields: graphb.Fields("lastUpdatedAt", "message", "reason", "ready"),
439 },
440 },
441 },
442 },
443 })
444 }
445
446 func getBannersQuery() string {
447 return MustParse(graphb.Query{
448 Type: graphb.TypeQuery,
449 Fields: []*graphb.Field{
450 {
451 Name: "banners",
452 Fields: graphb.Fields("name", "bannerBSLId", "bannerType", "bslDataSynced", "bslEntityTypes"),
453 },
454 },
455 })
456 }
457
458 func assignUserToBannerMutation(username string, banners []string) string {
459 return MustParse(graphb.Query{
460 Type: graphb.TypeMutation,
461 Fields: []*graphb.Field{
462 {
463 Name: "assignUserToBanner",
464 Arguments: []graphb.Argument{
465 graphb.ArgumentString("username", username),
466 graphb.ArgumentStringSlice("bannerEdgeIds", banners...),
467 },
468 Fields: graphb.Fields("statusCode", "message"),
469 },
470 },
471 })
472 }
473
474 func assignRoleToUserMutation(username string, role string) string {
475 return MustParse(graphb.Query{
476 Type: graphb.TypeMutation,
477 Fields: []*graphb.Field{
478 {
479 Name: "assignRoleToUser",
480 Arguments: []graphb.Argument{
481 graphb.ArgumentString("username", username),
482 graphb.ArgumentString("role", role),
483 },
484 Fields: graphb.Fields("statusCode", "message"),
485 },
486 },
487 })
488 }
489
490 func assignRolesToUserMutation(username string, roles []string) string {
491 return MustParse(graphb.Query{
492 Type: graphb.TypeMutation,
493 Fields: []*graphb.Field{
494 {
495 Name: "assignRolesToUser",
496 Arguments: []graphb.Argument{
497 graphb.ArgumentString("username", username),
498 graphb.ArgumentStringSlice("roles", roles...),
499 },
500 Fields: graphb.Fields("statusCode", "message"),
501 },
502 },
503 })
504 }
505
506 func bannerStatusQuery(bannerEdgeID string) string {
507 return MustParse(graphb.Query{
508 Type: graphb.TypeQuery,
509 Fields: []*graphb.Field{
510 {
511 Name: "bannerStatus",
512 Arguments: []graphb.Argument{
513 graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
514 },
515 Fields: graphb.Fields("lastUpdatedAt", "message", "reason", "ready"),
516 },
517 },
518 })
519 }
520
521 func setUpTestBannerAndClusterStatus(bannerID, clusterEdgeID string) error {
522 if err := runtimeClient.Create(context.Background(), buildTestBanner(bannerID)); err != nil {
523 return err
524 }
525 if err := runtimeClient.Create(context.Background(), buildTestCluster(clusterEdgeID)); err != nil {
526 return err
527 }
528 return runtimeClient.Create(context.Background(), buildTestGKECluster(bannerID))
529 }
530
531 func buildTestBanner(name string) *bannerApi.Banner {
532 return &bannerApi.Banner{
533 ObjectMeta: metav1.ObjectMeta{
534 Name: name,
535 },
536 Status: bannerApi.BannerStatus{
537 Conditions: []metav1.Condition{
538 {
539 Type: "Ready",
540 Status: metav1.ConditionTrue,
541 Reason: "ProvisionSucceeded",
542 Message: "banner reconciled successfully",
543 },
544 },
545 },
546 }
547 }
548
549 func buildTestCluster(name string) *clusterApi.Cluster {
550 return &clusterApi.Cluster{
551 ObjectMeta: metav1.ObjectMeta{
552 Name: name,
553 },
554 Spec: clusterApi.ClusterSpec{
555 Type: "gke",
556 },
557 Status: clusterApi.ClusterStatus{
558 Conditions: []metav1.Condition{
559 {
560 Type: "Ready",
561 Status: metav1.ConditionTrue,
562 Reason: "ClusterReadyReason",
563 Message: "cluster reconciled successfully",
564 },
565 },
566 },
567 }
568 }
569
570 func buildTestGKECluster(name string) *gkeClusterApi.GKECluster {
571 return &gkeClusterApi.GKECluster{
572 ObjectMeta: metav1.ObjectMeta{
573 Name: name,
574 },
575 Status: gkeClusterApi.GKEClusterStatus{
576 Conditions: []metav1.Condition{
577 {
578 Type: "Ready",
579 Status: metav1.ConditionTrue,
580 Reason: "GKEClusterReadyReason",
581 Message: "GKECluster reconciled successfully",
582 },
583 },
584 },
585 }
586 }
587
588 func getRemoteAccessIPQuery(bannerEdgeID string) string {
589 return MustParse(graphb.Query{
590 Type: graphb.TypeQuery,
591 Fields: []*graphb.Field{
592 {
593 Name: "banner",
594 Arguments: []graphb.Argument{
595 graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
596 },
597 Fields: graphb.Fields("remoteAccessIp"),
598 },
599 },
600 })
601 }
602
View as plain text