...

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

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

     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  	// revert update to fix mismatches in bsl and sql banners
    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() { // might want to run this as integration test in the future
   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  	//wait for two messages to be sent delete banner and delete infra
   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  	// revert update to fix mismatches in bsl and sql banners
   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  	// Query for banner with 'READY' status
   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  	// Query for banner with 'PROVISIONING' status & no message
   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  	// Multiple roles
   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  	// Make a call again to double check new roles can still be added
   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  	//Revoke role
   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  	// Invalid roles
   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  	// Empty roles in an input slice
   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 { //nolint: unparam
   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 { //nolint: unparam
   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