...

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

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

     1  package integration_test
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/udacity/graphb"
     7  
     8  	"edge-infra.dev/pkg/edge/api/graph/mapper"
     9  	"edge-infra.dev/pkg/edge/api/graph/model"
    10  	"edge-infra.dev/pkg/edge/api/services"
    11  	"edge-infra.dev/pkg/edge/api/utils"
    12  	"edge-infra.dev/pkg/edge/constants"
    13  	"edge-infra.dev/test/framework/integration"
    14  )
    15  
    16  var (
    17  	clusterNetworkServiceEdgeID = "3396a52c-6a22-4049-9593-5a63b596a200"
    18  	clusterCreateConfigEdgeID   = "5bc12c67-d9b0-4f13-a6d4-4852b0c11291"
    19  	k8sServiceEdgeID            = "3396a52c-6a22-4049-9593-5a63b596a210"
    20  	dnsNetworkServiceID         = "bc51dae7-f4cb-4b20-b2c9-508bf9089b3e"
    21  	dnsNetworkServiceID2        = "f79165b7-ebb7-426e-a91c-0d3bf2a148b5"
    22  	podNetworkServiceID         = "1c67eeb0-e1c4-4a8a-b9e1-46233ef5ad33"
    23  	serviceNetworkServiceID     = "d79dabaf-afc3-4a44-9031-e06a2512b1de"
    24  	testFamily                  = "inet"
    25  	testIP                      = "8.8.8.8"
    26  	testIP2                     = "9.9.9.9"
    27  	testIP3                     = "10.10.10.10"
    28  	testServiceType             = "dns"
    29  	falseValue                  = false
    30  	trueValue                   = true
    31  )
    32  
    33  func (s *Suite) TestSiteEU() {
    34  	integration.SkipIf(s.Framework)
    35  	clusterEdgeID := clusterCreateConfigEdgeID
    36  	siteQuery := siteQuery(clusterEdgeID)
    37  	var getStoresSiteResponse struct{ Site *model.StoreSiteInfo }
    38  	ResolverClient.MustPost(siteQuery, &getStoresSiteResponse)
    39  	s.NotNil(getStoresSiteResponse)
    40  	s.Equal(getStoresSiteResponse.Site.SiteName, "test-store")
    41  	s.Equal(getStoresSiteResponse.Site.EnterpriseUnitName, "test-enterprise-unit-name")
    42  	s.Equal(getStoresSiteResponse.Site.Status, services.ActiveStatus)
    43  	s.Equal(*getStoresSiteResponse.Site.ID, "test_bsl_site_id-3")
    44  	s.Equal(getStoresSiteResponse.Site.Coordinates.Latitude, services.DefaultLatitude)
    45  	s.Equal(getStoresSiteResponse.Site.Coordinates.Longitude, services.DefaultLongitude)
    46  }
    47  
    48  func (s *Suite) TestSiteWithMismatches() {
    49  	clusterEdgeID := testClusterEdgeID
    50  	siteQuery := siteQuery(clusterEdgeID)
    51  	var getStoresSiteResponse struct{ Site *model.StoreSiteInfo }
    52  	err := ResolverClient.Post(siteQuery, &getStoresSiteResponse)
    53  	s.NoError(err)
    54  	s.NotNil(getStoresSiteResponse)
    55  	s.Equal(getStoresSiteResponse.Site.SiteName, "test-store")
    56  	s.Equal(getStoresSiteResponse.Site.EnterpriseUnitName, "test-enterprise-unit-name")
    57  	s.Equal(getStoresSiteResponse.Site.Status, services.ActiveStatus)
    58  	s.Equal(*getStoresSiteResponse.Site.ID, "test_bsl_site_id")
    59  	s.Equal(getStoresSiteResponse.Site.Coordinates.Latitude, services.DefaultLatitude)
    60  	s.Equal(getStoresSiteResponse.Site.Coordinates.Longitude, services.DefaultLongitude)
    61  }
    62  
    63  func (s *Suite) TestSiteORG() {
    64  	integration.SkipIf(s.Framework)
    65  	siteQuery := siteQuery(testClusterEdgeID2)
    66  	var getStoresSiteResponse struct{ Site *model.StoreSiteInfo }
    67  	ResolverClient.MustPost(siteQuery, &getStoresSiteResponse)
    68  	s.NotNil(getStoresSiteResponse)
    69  	s.Equal(getStoresSiteResponse.Site.SiteName, "test-store")
    70  	s.Equal(getStoresSiteResponse.Site.EnterpriseUnitName, "test-enterprise-unit-name")
    71  	s.Equal(getStoresSiteResponse.Site.Status, services.ActiveStatus)
    72  	s.Equal(*getStoresSiteResponse.Site.ID, "test_bsl_site_id-2")
    73  	s.Equal(getStoresSiteResponse.Site.Coordinates.Latitude, services.DefaultLatitude)
    74  	s.Equal(getStoresSiteResponse.Site.Coordinates.Longitude, services.DefaultLongitude)
    75  }
    76  
    77  func (s *Suite) TestUpdateSite() {
    78  	integration.SkipIf(s.Framework)
    79  	updateSiteQuery := updateSiteQuery(testClusterEdgeID2)
    80  	var updateSiteResponse struct{ UpdateSite *model.StoreSiteInfo }
    81  	ResolverClient.MustPost(updateSiteQuery, &updateSiteResponse)
    82  	s.NotNil(updateSiteResponse)
    83  	s.Equal(updateSiteResponse.UpdateSite.SiteName, "test-store")
    84  	s.Equal(updateSiteResponse.UpdateSite.EnterpriseUnitName, "test-enterprise-unit-name")
    85  	s.Equal(updateSiteResponse.UpdateSite.Status, services.ActiveStatus)
    86  	s.Equal(*updateSiteResponse.UpdateSite.ID, "test-site-id")
    87  	s.Equal(updateSiteResponse.UpdateSite.Coordinates.Latitude, services.DefaultLatitude)
    88  	s.Equal(updateSiteResponse.UpdateSite.Coordinates.Longitude, services.DefaultLongitude)
    89  }
    90  
    91  func (s *Suite) TestDeleteCluster() {
    92  	integration.SkipIf(s.Framework)
    93  	clusterEdgeID := "3d589401-8e64-4845-ad7b-0466e8e65f13"
    94  	deleteSite := false
    95  	deleteClusterQuery := deleteClusterQuery(clusterEdgeID, deleteSite)
    96  	var deleteClusterResponse struct{ DeleteCluster *bool }
    97  	ResolverClient.MustPost(deleteClusterQuery, &deleteClusterResponse)
    98  	s.NotNil(deleteClusterQuery)
    99  }
   100  
   101  func (s *Suite) TestDeleteClusters1() {
   102  	type test struct {
   103  		testName       string
   104  		clusterEdgeIDs []string
   105  		deleteSite     bool
   106  	}
   107  	tests := []test{
   108  		{
   109  			testName:       "DeleteClustersWithoutBslSite",
   110  			clusterEdgeIDs: []string{"2a589401-8e64-4845-ad7b-0466e8e65f13", "2b589401-8e64-4845-ad7b-0466e8e65f13"},
   111  			deleteSite:     false,
   112  		},
   113  		{
   114  			testName:       "DeleteClustersAndBslSite",
   115  			clusterEdgeIDs: []string{"2c589401-8e64-4845-ad7b-0466e8e65f13", "2d589401-8e64-4845-ad7b-0466e8e65f13"},
   116  			deleteSite:     true,
   117  		},
   118  	}
   119  	for _, tc := range tests {
   120  		integration.SkipIf(s.Framework)
   121  		clusterEdgeIDs := tc.clusterEdgeIDs
   122  		deleteSite := tc.deleteSite
   123  		deleteClustersQuery := deleteClustersQuery(clusterEdgeIDs, deleteSite)
   124  		var deleteClustersResponse struct{ DeleteClusters *bool }
   125  		ResolverClient.MustPost(deleteClustersQuery, &deleteClustersResponse)
   126  		s.NotNil(deleteClustersQuery)
   127  	}
   128  }
   129  
   130  func (s *Suite) TestGetClusters() {
   131  	integration.SkipIf(s.Framework)
   132  	query := clustersQuery(testOrgBannerEdgeID, []string{})
   133  	var clustersResponse struct{ Clusters []*model.Cluster }
   134  	ResolverClient.MustPost(query, &clustersResponse)
   135  }
   136  
   137  func (s *Suite) TestGetClustersWithLabels() {
   138  	integration.SkipIf(s.Framework)
   139  	query := clustersQuery(testOrgBannerEdgeID, []string{"store", "basic-store"})
   140  	var clustersResponse struct{ Clusters []*model.Cluster }
   141  	ResolverClient.MustPost(query, &clustersResponse)
   142  }
   143  
   144  func (s *Suite) TestUpdateClusterName() {
   145  	clusterEdgeID := "3d589401-0000-1111-2222-0466e8e65f13"
   146  	updatedName := "new-name"
   147  	query := clusterQuery(clusterEdgeID)
   148  	var clusterResponse struct{ Cluster *model.Cluster }
   149  	ResolverClient.MustPost(query, &clusterResponse)
   150  
   151  	s.NotNil(clusterResponse.Cluster)
   152  	s.NotEqual(updatedName, clusterResponse.Cluster.Name)
   153  
   154  	mutation := updateClusterName(clusterEdgeID, updatedName)
   155  	var response struct{ UpdateClusterName *model.Cluster }
   156  	ResolverClient.MustPost(mutation, &response)
   157  
   158  	s.NotNil(response.UpdateClusterName)
   159  	s.Equal(updatedName, response.UpdateClusterName.Name)
   160  }
   161  
   162  func (s *Suite) TestUpdateClusteFleetVersion() {
   163  	integration.SkipIf(s.Framework)
   164  	clusterEdgeID := "dc8e59c3-6338-4c28-a776-f54e93a19ff4"
   165  	updatedFleetVersion := "0.16.0"
   166  	query := clusterQuery(clusterEdgeID)
   167  	var clusterResponse struct{ Cluster *model.Cluster }
   168  	ResolverClient.MustPost(query, &clusterResponse)
   169  
   170  	s.NotNil(clusterResponse.Cluster)
   171  	s.NotEqual(updatedFleetVersion, clusterResponse.Cluster.FleetVersion)
   172  
   173  	mutation := updateClusterFleetVersion(clusterEdgeID, updatedFleetVersion)
   174  	var response struct{ UpdateClusterFleetVersion *model.Cluster }
   175  	ResolverClient.MustPost(mutation, &response)
   176  
   177  	s.NotNil(response.UpdateClusterFleetVersion)
   178  	s.Equal(updatedFleetVersion, response.UpdateClusterFleetVersion.FleetVersion)
   179  }
   180  
   181  func (s *Suite) TestStoreStatusActive() {
   182  	integration.SkipIf(s.Framework)
   183  	q := storeStatus(testClusterEdgeID)
   184  	var response struct{ StoreStatus *model.StoreStatusInfo }
   185  	ResolverClient.MustPost(q, &response)
   186  	s.NotNil(response.StoreStatus)
   187  	s.Equal("test_cluster", response.StoreStatus.Name)
   188  	s.Equal(testOrgBannerEdgeID, response.StoreStatus.BannerEdgeID)
   189  	s.NotNil(response.StoreStatus.KubeVersion)
   190  	s.NotNil(response.StoreStatus.Status)
   191  	s.Equal("v1.23.6", *response.StoreStatus.KubeVersion)
   192  	s.Equal("Ready", response.StoreStatus.Status.Status)
   193  	s.Equal("Edge Syncing", response.StoreStatus.Status.Message)
   194  	s.Equal(1, len(response.StoreStatus.BucketStatus))
   195  	s.Equal("test-bucket-name", response.StoreStatus.BucketStatus[0].BucketName)
   196  	s.Equal(true, response.StoreStatus.BucketStatus[0].FluxStatus.Suspended)
   197  	s.Equal("test-bucket-1", response.StoreStatus.BucketStatus[0].FluxStatus.Name)
   198  	s.Equal(2, len(response.StoreStatus.KustomizationStatus))
   199  	s.Contains("test-kustomization-1 test-kustomization-2", response.StoreStatus.KustomizationStatus[0].FluxStatus.Name)
   200  	s.Contains("test-kustomization-1 test-kustomization-2", response.StoreStatus.KustomizationStatus[1].FluxStatus.Name)
   201  }
   202  
   203  func (s *Suite) TestStoreStatusNotActive() {
   204  	integration.SkipIf(s.Framework)
   205  	if !integration.IsIntegrationTest() {
   206  		s.NoError(
   207  			setUpTestBannerAndClusterStatus("3396a52c-6a22-4049-9593-5a63b596a104", "3396a52c-6a22-4049-9593-5a63b596a202"))
   208  	}
   209  	q := storeStatus("3396a52c-6a22-4049-9593-5a63b596a202")
   210  	var response struct{ StoreStatus *model.StoreStatusInfo }
   211  	ResolverClient.MustPost(q, &response)
   212  	s.NotNil(response.StoreStatus)
   213  	s.Equal("status not found", response.StoreStatus.Status.Message)
   214  	s.Equal(mapper.Provisioning, response.StoreStatus.Status.Status)
   215  }
   216  
   217  func (s *Suite) TestDeleteClusterAndBslSite() {
   218  	integration.SkipIf(s.Framework)
   219  	clusterEdgeID := "25980ab2-cb78-46ab-bf8f-9a7b78239b7f"
   220  	deleteBslSite := true
   221  	deleteClusterQuery := deleteClusterQuery(clusterEdgeID, deleteBslSite)
   222  	var deleteClusterResponse struct{ DeleteCluster *bool }
   223  	ResolverClient.MustPost(deleteClusterQuery, &deleteClusterResponse)
   224  	s.NotNil(deleteClusterResponse)
   225  }
   226  
   227  func (s *Suite) TestGetClusterNetworkService() {
   228  	clusterEdgeID := clusterNetworkServiceEdgeID
   229  	getCluster := getClusterNetworkServices(clusterEdgeID)
   230  
   231  	var getClusterResponse struct {
   232  		Cluster *model.Cluster
   233  	}
   234  
   235  	err := ResolverClient.Post(getCluster, &getClusterResponse)
   236  
   237  	s.NoError(err)
   238  	s.NotNil(getClusterResponse)
   239  
   240  	var dnsService *model.ClusterNetworkServiceInfo
   241  	for _, service := range getClusterResponse.Cluster.ClusterNetworkServices {
   242  		if service.ServiceType == "dns" && service.NetworkServiceID == dnsNetworkServiceID {
   243  			dnsService = service
   244  		}
   245  	}
   246  
   247  	searchDNSServers := []string{"8.8.8.8"}
   248  
   249  	s.Equal(getClusterResponse.Cluster.ClusterEdgeID, clusterEdgeID)
   250  	s.Equal(dnsService.ServiceType, "dns")
   251  	s.Equal(dnsService.Family, testFamily)
   252  	s.Equal(dnsService.ServiceType, testServiceType)
   253  	s.Contains(searchDNSServers, dnsService.IP)
   254  	s.Equal(*dnsService.Priority, 100)
   255  }
   256  
   257  func (s *Suite) TestCreateClusterNetworkService() {
   258  	clusterEdgeID := clusterNetworkServiceEdgeID
   259  	// Use a different IP here since dns services with the following IP's, [8.8.8.8, 9.9.9.9, 10.10.10.10], already exist for this cluster
   260  	testNewIP := "0.0.0.0"
   261  	networkServiceCreate := createNetworkServiceInput(testNewIP, testFamily, testServiceType, 100)
   262  	allNetworkServices := []*model.CreateNetworkServiceInfo{networkServiceCreate}
   263  	createClusterNetworkServiceQuery := createClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   264  
   265  	var createClusterNetworkServiceResponse struct {
   266  		CreateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   267  	}
   268  
   269  	err := ResolverClient.Post(createClusterNetworkServiceQuery, &createClusterNetworkServiceResponse)
   270  
   271  	s.NoError(err)
   272  	s.NotNil(createClusterNetworkServiceResponse)
   273  }
   274  
   275  func (s *Suite) TestCreateClusterNetworkServiceInvalidIP() {
   276  	clusterEdgeID := clusterNetworkServiceEdgeID
   277  	testIP := "...." // Invalid IP
   278  	networkServiceCreate := createNetworkServiceInput(testIP, testFamily, testServiceType, 100)
   279  	allNetworkServices := []*model.CreateNetworkServiceInfo{networkServiceCreate}
   280  	createClusterNetworkServiceQuery := createClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   281  
   282  	var createClusterNetworkServiceResponse struct {
   283  		CreateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   284  	}
   285  
   286  	err := ResolverClient.Post(createClusterNetworkServiceQuery, &createClusterNetworkServiceResponse)
   287  
   288  	s.Error(err)
   289  	s.NotNil(createClusterNetworkServiceResponse)
   290  }
   291  
   292  func (s *Suite) TestCreateClusterNetworkServiceInvalidServiceType() {
   293  	clusterEdgeID := clusterNetworkServiceEdgeID
   294  	testServiceType := "domainnameserver" // Invalid service type
   295  	networkServiceCreate := createNetworkServiceInput(testIP, testFamily, testServiceType, 100)
   296  	allNetworkServices := []*model.CreateNetworkServiceInfo{networkServiceCreate}
   297  	createClusterNetworkServiceQuery := createClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   298  
   299  	var createClusterNetworkServiceResponse struct {
   300  		CreateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   301  	}
   302  
   303  	err := ResolverClient.Post(createClusterNetworkServiceQuery, &createClusterNetworkServiceResponse)
   304  
   305  	s.Error(err)
   306  	s.NotNil(createClusterNetworkServiceResponse)
   307  }
   308  
   309  func (s *Suite) TestCreateClusterNetworkServiceDuplicateIP() {
   310  	clusterEdgeID := clusterNetworkServiceEdgeID
   311  	// Use testIP2 since the combination [ServiceType: dns, IP: 9.9.9.9] already exists for this cluster
   312  	networkServiceCreate := createNetworkServiceInput(testIP2, testFamily, testServiceType, 100)
   313  	allNetworkServices := []*model.CreateNetworkServiceInfo{networkServiceCreate}
   314  	createClusterNetworkServiceQuery := createClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   315  
   316  	var createClusterNetworkServiceResponse struct {
   317  		CreateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   318  	}
   319  
   320  	err := ResolverClient.Post(createClusterNetworkServiceQuery, &createClusterNetworkServiceResponse)
   321  
   322  	s.Error(err)
   323  	s.NotNil(createClusterNetworkServiceResponse)
   324  }
   325  
   326  func (s *Suite) TestUpdateAndDeleteClusterNetworkService() {
   327  	clusterEdgeID := clusterNetworkServiceEdgeID
   328  	getCluster := getClusterNetworkServices(clusterEdgeID)
   329  
   330  	var getClusterResponse struct {
   331  		Cluster *model.Cluster
   332  	}
   333  
   334  	err := ResolverClient.Post(getCluster, &getClusterResponse)
   335  	s.NoError(err)
   336  
   337  	networkServiceID := getClusterResponse.Cluster.ClusterNetworkServices[0].NetworkServiceID
   338  	testNewIP := "216.239.35.4"
   339  	testNewFamily := testFamily
   340  	testNewPriority := 99
   341  	networkServiceUpdate := updateNetworkServiceInput(testNewIP, testNewFamily, networkServiceID, testNewPriority)
   342  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   343  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   344  
   345  	var updateClusterNetworkServiceResponse struct {
   346  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   347  	}
   348  
   349  	err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   350  
   351  	s.NoError(err)
   352  	s.NotNil(updateClusterNetworkServiceResponse)
   353  
   354  	s.Equal(updateClusterNetworkServiceResponse.UpdateClusterNetworkServices[0].NetworkServiceID, networkServiceID)
   355  	s.Equal(updateClusterNetworkServiceResponse.UpdateClusterNetworkServices[0].Family, testNewFamily)
   356  	s.Equal(updateClusterNetworkServiceResponse.UpdateClusterNetworkServices[0].IP, testNewIP)
   357  	s.Equal(*updateClusterNetworkServiceResponse.UpdateClusterNetworkServices[0].Priority, 99)
   358  
   359  	deleteClusterNetworkServiceQuery := deleteClusterNetworkServiceQuery(clusterEdgeID, networkServiceID)
   360  	var deleteClusterNetworkServiceResponse struct{ DeleteClusterNetworkService *bool }
   361  	err = ResolverClient.Post(deleteClusterNetworkServiceQuery, &deleteClusterNetworkServiceResponse)
   362  	s.NoError(err)
   363  	s.NotNil(deleteClusterNetworkServiceResponse)
   364  	s.True(*deleteClusterNetworkServiceResponse.DeleteClusterNetworkService)
   365  }
   366  
   367  func (s *Suite) TestUpdateAndDeleteK8sServiceSubnetWhenClusterActive() {
   368  	clusterEdgeID := clusterNetworkServiceEdgeID // cluster.Active = True
   369  	networkServiceID := "f20e75ea-28b9-4f1d-8e79-ad871601261b"
   370  	cidr := "10.96.0.0/17"
   371  
   372  	networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
   373  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   374  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   375  
   376  	var updateClusterNetworkServiceResponse struct {
   377  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   378  	}
   379  
   380  	err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   381  	s.ErrorContains(err, "cluster network service service-network-cidr cannot be updated after bootstrapping the first")
   382  }
   383  
   384  func (s *Suite) TestUpdateK8sServiceSubnetInvalidRangeLowerBound() {
   385  	clusterEdgeID := k8sServiceEdgeID
   386  	networkServiceID := serviceNetworkServiceID
   387  	cidr := "10.96.0.0/15"
   388  
   389  	networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
   390  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   391  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   392  
   393  	var updateClusterNetworkServiceResponse struct {
   394  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   395  	}
   396  
   397  	err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   398  	s.ErrorContains(err, "invalid prefix length. Prefix length must be between /16 and /22 for k8s service network")
   399  }
   400  
   401  func (s *Suite) TestUpdateK8sServiceSubnetInvalidRangeUpperBound() {
   402  	clusterEdgeID := k8sServiceEdgeID
   403  	networkServiceID := serviceNetworkServiceID
   404  	cidr := "10.96.0.0/23"
   405  
   406  	networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
   407  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   408  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   409  
   410  	var updateClusterNetworkServiceResponse struct {
   411  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   412  	}
   413  
   414  	err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   415  	s.ErrorContains(err, "invalid prefix length. Prefix length must be between /16 and /22 for k8s service network")
   416  }
   417  
   418  func (s *Suite) TestUpdateK8sPodSubnetInvalidRangeLowerBound() {
   419  	clusterEdgeID := k8sServiceEdgeID
   420  	networkServiceID := podNetworkServiceID
   421  	cidr := "100.127.0.0/15"
   422  
   423  	networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
   424  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   425  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   426  
   427  	var updateClusterNetworkServiceResponse struct {
   428  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   429  	}
   430  
   431  	err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   432  	s.ErrorContains(err, "invalid prefix length. Prefix length must be between /16 and /21 for k8s pod network")
   433  }
   434  
   435  func (s *Suite) TestUpdateK8sPodSubnetInvalidRangeUpperBound() {
   436  	clusterEdgeID := k8sServiceEdgeID
   437  	networkServiceID := podNetworkServiceID
   438  	cidr := "100.127.0.0/22"
   439  
   440  	networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
   441  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   442  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   443  
   444  	var updateClusterNetworkServiceResponse struct {
   445  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   446  	}
   447  
   448  	err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   449  	s.ErrorContains(err, "invalid prefix length. Prefix length must be between /16 and /21 for k8s pod network")
   450  }
   451  
   452  func (s *Suite) TestUpdateClusterPodNetworkService() {
   453  	clusterEdgeID := k8sServiceEdgeID
   454  	networkServiceID := podNetworkServiceID
   455  	podCidr := "100.156.0.0/16"
   456  
   457  	networkServiceUpdate := updateNetworkServiceInput(podCidr, testFamily, networkServiceID, 100)
   458  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   459  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   460  
   461  	var updateClusterNetworkServiceResponse struct {
   462  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   463  	}
   464  
   465  	err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   466  	s.NoError(err)
   467  	s.NotNil(updateClusterNetworkServiceResponse)
   468  }
   469  
   470  func (s *Suite) TestForbiddenNetServiceDeletion() {
   471  	clusterEdgeID := k8sServiceEdgeID
   472  	networkServiceID := podNetworkServiceID
   473  
   474  	deleteClusterNetworkServiceQuery := deleteClusterNetworkServiceQuery(clusterEdgeID, networkServiceID)
   475  	var deleteClusterNetworkServiceResponse struct{ DeleteClusterNetworkService *bool }
   476  
   477  	err = ResolverClient.Post(deleteClusterNetworkServiceQuery, &deleteClusterNetworkServiceResponse)
   478  	s.ErrorContains(err, fmt.Sprintf("adhoc deletion of the %s is forbidden", constants.ServiceTypePodNetworkCIDR))
   479  }
   480  
   481  func (s *Suite) TestInvalidK8sSubnetOverlap() {
   482  	clusterEdgeID := k8sServiceEdgeID
   483  	podNetworkServiceType := constants.ServiceTypePodNetworkCIDR
   484  	serviceNetworkServiceType := constants.ServiceTypeServiceNetworkCIDR
   485  	networkServiceID := podNetworkServiceID
   486  	podCidr := "10.96.0.0/16"
   487  
   488  	networkServiceUpdate := updateNetworkServiceInput(podCidr, testFamily, networkServiceID, 100)
   489  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   490  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   491  
   492  	var updateClusterNetworkServiceResponse struct {
   493  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   494  	}
   495  
   496  	err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   497  	s.ErrorContains(err, fmt.Sprintf("invalid subnet - %s must not overlap with %s", podNetworkServiceType, serviceNetworkServiceType))
   498  }
   499  
   500  func (s *Suite) TestValidIPNotASubnet() {
   501  	clusterEdgeID := k8sServiceEdgeID
   502  	serviceType := constants.ServiceTypeServiceNetworkCIDR
   503  	networkServiceID := serviceNetworkServiceID
   504  	serviceCidr := "10.96.0.0"
   505  
   506  	networkServiceUpdate := updateNetworkServiceInput(serviceCidr, testFamily, networkServiceID, 100)
   507  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   508  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   509  
   510  	var updateClusterNetworkServiceResponse struct {
   511  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   512  	}
   513  
   514  	err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   515  	s.ErrorContains(err, fmt.Sprintf("invalid CIDR address %s for %s", serviceCidr, serviceType))
   516  }
   517  
   518  func (s *Suite) TestUpdateK8sNetworkServiceInvalid() {
   519  	clusterEdgeID := k8sServiceEdgeID
   520  	networkServiceID := "1c67eeb0-e1c4-4a8a-b9e1-46233ef5ad33"
   521  	serviceType := constants.ServiceTypePodNetworkCIDR
   522  	cidr := "not-a-cidr-subnet"
   523  
   524  	networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
   525  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   526  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   527  
   528  	var updateClusterNetworkServiceResponse struct {
   529  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   530  	}
   531  
   532  	err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   533  	s.ErrorContains(err, fmt.Sprintf("invalid CIDR address %s for %s", cidr, serviceType))
   534  }
   535  
   536  func (s *Suite) TestUpdateK8sClusterDNSNotPermitted() {
   537  	clusterEdgeID := k8sServiceEdgeID
   538  	networkServiceID := "7fa65f85-1856-4c8e-90e5-a68c410a6c0d"
   539  	serviceType := constants.ServiceTypeClusterDNS
   540  	cidr := "100.127.0.0/23"
   541  
   542  	networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
   543  	allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   544  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
   545  
   546  	var updateClusterNetworkServiceResponse struct {
   547  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   548  	}
   549  
   550  	err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   551  	s.ErrorContains(err, fmt.Sprintf("cluster network service %s is not configurable", serviceType))
   552  }
   553  
   554  func (s *Suite) TestUpdateClusterNetworkServiceDuplicateIP() {
   555  	clusterEdgeID := clusterNetworkServiceEdgeID
   556  	testExistingIP := testIP3
   557  	networkServiceUpdate := updateNetworkServiceInput(testExistingIP, testFamily, dnsNetworkServiceID2, 100)
   558  
   559  	allNetworkServicesUpdate := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
   560  	updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServicesUpdate)
   561  
   562  	var updateClusterNetworkServiceResponse struct {
   563  		UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
   564  	}
   565  
   566  	err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
   567  	s.Error(err)
   568  	s.ErrorContains(err, fmt.Sprintf("IP address %s already exists for %s", testExistingIP, testServiceType))
   569  }
   570  
   571  func (s *Suite) TestCreateUpdateDeleteGetClusterConfig() {
   572  	configClusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a201"
   573  
   574  	var responseCreate struct {
   575  		CreateClusterConfig model.ClusterConfig
   576  	}
   577  
   578  	createClusterConfig := model.CreateClusterConfig{
   579  		AcRelay:              &trueValue,
   580  		PxeEnabled:           &falseValue,
   581  		BootstrapAck:         &falseValue,
   582  		VpnEnabled:           &trueValue,
   583  		ThickPos:             &trueValue,
   584  		EgressGatewayEnabled: &trueValue,
   585  	}
   586  
   587  	createClusterConfigMutation := createClusterConfigMutation(configClusterEdgeID, createClusterConfig)
   588  	err := ResolverClient.Post(createClusterConfigMutation, &responseCreate)
   589  
   590  	s.NoError(err)
   591  	s.NotEmpty(responseCreate.CreateClusterConfig)
   592  	s.True(responseCreate.CreateClusterConfig.AcRelay)
   593  	s.False(responseCreate.CreateClusterConfig.PxeEnabled)
   594  	s.False(responseCreate.CreateClusterConfig.BootstrapAck)
   595  	s.True(responseCreate.CreateClusterConfig.VpnEnabled)
   596  	s.True(responseCreate.CreateClusterConfig.ThickPos)
   597  	s.True(responseCreate.CreateClusterConfig.EgressGatewayEnabled)
   598  
   599  	var responseUpdate struct {
   600  		UpdateClusterConfig model.ClusterConfig
   601  	}
   602  
   603  	config := model.UpdateClusterConfig{
   604  		AcRelay:              &falseValue,
   605  		PxeEnabled:           &trueValue,
   606  		BootstrapAck:         &falseValue,
   607  		ThickPos:             &falseValue,
   608  		VpnEnabled:           &trueValue,
   609  		EgressGatewayEnabled: &falseValue,
   610  	}
   611  
   612  	updateClusterConfig := updateClusterConfigMutation(configClusterEdgeID, config)
   613  	err = ResolverClient.Post(updateClusterConfig, &responseUpdate)
   614  
   615  	s.NoError(err)
   616  	s.False(responseUpdate.UpdateClusterConfig.AcRelay)
   617  	s.True(responseUpdate.UpdateClusterConfig.PxeEnabled)
   618  	s.False(responseUpdate.UpdateClusterConfig.BootstrapAck)
   619  	s.False(responseUpdate.UpdateClusterConfig.ThickPos)
   620  	s.True(responseUpdate.UpdateClusterConfig.VpnEnabled)
   621  	s.False(responseUpdate.UpdateClusterConfig.EgressGatewayEnabled)
   622  
   623  	var responseGet struct {
   624  		ClusterConfig *model.ClusterConfig
   625  	}
   626  
   627  	getClusterConfigQuery := getClusterConfigQuery(configClusterEdgeID)
   628  	err = ResolverClient.Post(getClusterConfigQuery, &responseGet)
   629  
   630  	s.NoError(err)
   631  	s.NotEmpty(responseGet.ClusterConfig)
   632  	s.False(responseGet.ClusterConfig.AcRelay)
   633  	s.True(responseGet.ClusterConfig.PxeEnabled)
   634  	s.False(responseGet.ClusterConfig.BootstrapAck)
   635  	s.False(responseGet.ClusterConfig.ThickPos)
   636  	s.True(responseGet.ClusterConfig.VpnEnabled)
   637  	s.False(responseGet.ClusterConfig.EgressGatewayEnabled)
   638  }
   639  
   640  func (s *Suite) TestGetEventsForCluster() {
   641  	integration.SkipIf(s.Framework)
   642  
   643  	// Query for cluster with events
   644  	query := clusterQuery("3396a52c-6a22-4049-9593-5a63b596a200")
   645  	var response struct{ Cluster *model.Cluster }
   646  	ResolverClient.MustPost(query, &response)
   647  	err := ResolverClient.Post(query, &response)
   648  
   649  	s.NoError(err)
   650  	s.NotNil(response.Cluster.Status.Events)
   651  	s.Equal(2, len(response.Cluster.Status.Events))
   652  
   653  	for _, event := range response.Cluster.Status.Events {
   654  		s.NotEmpty(event.EventEdgeID)
   655  		s.NotEmpty(event.Name)
   656  		s.NotNil(event.InvolvedObject)
   657  		s.NotEmpty(event.InvolvedObject.Kind)
   658  		s.NotEmpty(event.InvolvedObject.Name)
   659  		s.NotEmpty(event.Reason)
   660  		s.NotEmpty(event.Message)
   661  		s.NotEmpty(event.Source)
   662  		s.NotEmpty(event.Status)
   663  		s.NotEmpty(event.ClusterEdgeID)
   664  		s.NotEmpty(event.CreatedAt)
   665  	}
   666  }
   667  
   668  func siteQuery(clusterEdgeID string) string {
   669  	args := []graphb.Argument{
   670  		graphb.ArgumentString("clusterEdgeID", clusterEdgeID),
   671  	}
   672  	return MustParse(graphb.Query{
   673  		Type: graphb.TypeQuery,
   674  		Fields: []*graphb.Field{
   675  			{
   676  				Name:      "site",
   677  				Arguments: args,
   678  				Fields: []*graphb.Field{
   679  					graphb.NewField("organizationName"),
   680  					graphb.NewField("id"),
   681  					graphb.NewField("status"),
   682  					graphb.NewField("siteName"),
   683  					graphb.NewField("enterpriseUnitName"),
   684  					graphb.NewField("coordinates", graphb.OfFields(
   685  						"latitude",
   686  						"longitude",
   687  					)),
   688  					graphb.NewField("enterpriseSettings", graphb.OfFields(
   689  						"enterpriseUnitId",
   690  					)),
   691  					graphb.NewField("dayparts", graphb.OfFields(
   692  						"description",
   693  						"startTime",
   694  						"endTime",
   695  						"name",
   696  					)),
   697  				},
   698  			},
   699  		},
   700  	})
   701  }
   702  
   703  func updateSiteQuery(clusterEdgeID string) string {
   704  	args := []graphb.Argument{
   705  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   706  		graphb.ArgumentCustomType("site",
   707  			graphb.ArgumentString("siteName", "test-store"),
   708  			graphb.ArgumentString("status", "ACTIVE"),
   709  			graphb.ArgumentString("enterpriseUnitName", "test-enterprise-unit-name"),
   710  			graphb.ArgumentString("description", "test site description"),
   711  			graphb.ArgumentCustomType("coordinates",
   712  				graphb.ArgumentInt("latitude", 90.0),
   713  				graphb.ArgumentInt("longitude", 180.0),
   714  			),
   715  		),
   716  	}
   717  	return MustParse(graphb.Query{
   718  		Type: graphb.TypeMutation,
   719  		Fields: []*graphb.Field{
   720  			{
   721  				Name:      "updateSite",
   722  				Arguments: args,
   723  				Fields: []*graphb.Field{
   724  					graphb.NewField("organizationName"),
   725  					graphb.NewField("id"),
   726  					graphb.NewField("status"),
   727  					graphb.NewField("siteName"),
   728  					graphb.NewField("enterpriseUnitName"),
   729  					graphb.NewField("coordinates", graphb.OfFields(
   730  						"latitude",
   731  						"longitude",
   732  					)),
   733  					graphb.NewField("enterpriseSettings", graphb.OfFields(
   734  						"enterpriseUnitId",
   735  					)),
   736  					graphb.NewField("dayparts", graphb.OfFields(
   737  						"description",
   738  						"startTime",
   739  						"endTime",
   740  						"name",
   741  					)),
   742  				},
   743  			},
   744  		},
   745  	})
   746  }
   747  
   748  func storeStatus(clusterEdgeID string) string {
   749  	args := []graphb.Argument{
   750  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   751  	}
   752  	return MustParse(graphb.Query{
   753  		Type: graphb.TypeQuery,
   754  		Fields: []*graphb.Field{
   755  			{
   756  				Name:      "storeStatus",
   757  				Arguments: args,
   758  				Fields: []*graphb.Field{
   759  					graphb.NewField("name"),
   760  					graphb.NewField("bannerEdgeId"),
   761  					graphb.NewField("status", graphb.OfFields(
   762  						"status",
   763  						"message",
   764  					)),
   765  					graphb.NewField("kubeVersion"),
   766  					{
   767  						Name: "bucketStatus",
   768  						Fields: []*graphb.Field{
   769  							graphb.NewField("excludes"),
   770  							graphb.NewField("bucketName"),
   771  							graphb.NewField("fluxStatus", graphb.OfFields("name", "error", "lastUpdated", "revision", "statusMessage", "suspended"))},
   772  					},
   773  					{
   774  						Name: "kustomizationStatus",
   775  						Fields: []*graphb.Field{
   776  							graphb.NewField("path"),
   777  							graphb.NewField("source"),
   778  							graphb.NewField("fluxStatus", graphb.OfFields("name", "error", "lastUpdated", "revision", "statusMessage", "suspended"))},
   779  					},
   780  				},
   781  			},
   782  		},
   783  	})
   784  }
   785  
   786  func deleteClusterQuery(clusterEdgeID string, deleteBslSite bool) string {
   787  	args := []graphb.Argument{
   788  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   789  		graphb.ArgumentBool("deleteBSLSite", deleteBslSite),
   790  	}
   791  	return MustParse(graphb.Query{
   792  		Type: graphb.TypeMutation,
   793  		Fields: []*graphb.Field{
   794  			{
   795  				Name:      "deleteCluster",
   796  				Arguments: args,
   797  			},
   798  		},
   799  	})
   800  }
   801  
   802  func deleteClustersQuery(clusterEdgeIDs []string, deleteBslSite bool) string {
   803  	args := []graphb.Argument{
   804  		graphb.ArgumentStringSlice("clusterEdgeIds", clusterEdgeIDs...),
   805  		graphb.ArgumentBool("deleteBSLSite", deleteBslSite),
   806  	}
   807  	return MustParse(graphb.Query{
   808  		Type: graphb.TypeMutation,
   809  		Fields: []*graphb.Field{
   810  			{
   811  				Name:      "deleteClusters",
   812  				Arguments: args,
   813  			},
   814  		},
   815  	})
   816  }
   817  
   818  func deleteClusterNetworkServiceQuery(clusterEdgeID, networkServiceID string) string {
   819  	args := []graphb.Argument{
   820  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   821  		graphb.ArgumentString("networkServiceId", networkServiceID),
   822  	}
   823  	return MustParse(graphb.Query{
   824  		Type: graphb.TypeMutation,
   825  		Fields: []*graphb.Field{
   826  			{
   827  				Name:      "deleteClusterNetworkService",
   828  				Arguments: args,
   829  			},
   830  		},
   831  	})
   832  }
   833  
   834  func createNetworkServiceInput(ip, family, serviceType string, priority int) *model.CreateNetworkServiceInfo { // nolint: unparam
   835  	return &model.CreateNetworkServiceInfo{
   836  		IP:          ip,
   837  		Family:      family,
   838  		ServiceType: serviceType,
   839  		Priority:    &priority,
   840  	}
   841  }
   842  
   843  func createClusterNetworkServiceQuery(clusterEdgeID string, clusterNetworkServices []*model.CreateNetworkServiceInfo) string {
   844  	arguments := make([][]graphb.Argument, 0, len(clusterNetworkServices))
   845  	for _, networkService := range clusterNetworkServices {
   846  		newNetworkServiceArgument := graphb.ArgumentCustomTypeSliceElem(
   847  			graphb.ArgumentString("serviceType", networkService.ServiceType),
   848  			graphb.ArgumentString("ip", networkService.IP),
   849  			graphb.ArgumentString("family", networkService.Family),
   850  			graphb.ArgumentInt("priority", *networkService.Priority),
   851  		)
   852  		arguments = append(arguments, newNetworkServiceArgument)
   853  	}
   854  
   855  	args := []graphb.Argument{
   856  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   857  		graphb.ArgumentCustomTypeSlice("networkServicesInfo", arguments...),
   858  	}
   859  
   860  	return MustParse(graphb.Query{
   861  		Type: graphb.TypeMutation,
   862  		Fields: []*graphb.Field{
   863  			{
   864  				Name:      "createClusterNetworkServices",
   865  				Arguments: args,
   866  				Fields: []*graphb.Field{
   867  					graphb.NewField("serviceType"),
   868  					graphb.NewField("ip"),
   869  					graphb.NewField("family"),
   870  					graphb.NewField("priority"),
   871  				},
   872  			},
   873  		},
   874  	})
   875  }
   876  
   877  func getClusterNetworkServices(clusterEdgeID string) string {
   878  	args := []graphb.Argument{
   879  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   880  	}
   881  	return MustParse(graphb.Query{
   882  		Type: graphb.TypeQuery,
   883  		Fields: []*graphb.Field{
   884  			{
   885  				Name:      "cluster",
   886  				Arguments: args,
   887  				Fields: []*graphb.Field{
   888  					{
   889  						Name: "clusterNetworkServices",
   890  						Fields: []*graphb.Field{
   891  							graphb.NewField("networkServiceId"),
   892  							graphb.NewField("ip"),
   893  							graphb.NewField("family"),
   894  							graphb.NewField("serviceType"),
   895  							graphb.NewField("priority")},
   896  					},
   897  					{
   898  						Name: "clusterEdgeId",
   899  					},
   900  					{
   901  						Name: "name",
   902  					},
   903  				},
   904  			},
   905  		},
   906  	})
   907  }
   908  
   909  func updateNetworkServiceInput(ip, family, networkServiceID string, priority int) *model.UpdateNetworkServiceInfo {
   910  	return &model.UpdateNetworkServiceInfo{
   911  		NetworkServiceID: networkServiceID,
   912  		IP:               ip,
   913  		Family:           family,
   914  		Priority:         &priority,
   915  	}
   916  }
   917  
   918  func updateClusterNetworkServiceQuery(clusterEdgeID string, clusterNetworkServices []*model.UpdateNetworkServiceInfo) string {
   919  	arguments := make([][]graphb.Argument, 0, len(clusterNetworkServices))
   920  	for _, networkService := range clusterNetworkServices {
   921  		newNetworkServiceArgument := graphb.ArgumentCustomTypeSliceElem(
   922  			graphb.ArgumentString("networkServiceId", networkService.NetworkServiceID),
   923  			graphb.ArgumentString("ip", networkService.IP),
   924  			graphb.ArgumentString("family", networkService.Family),
   925  			graphb.ArgumentInt("priority", *networkService.Priority),
   926  		)
   927  		arguments = append(arguments, newNetworkServiceArgument)
   928  	}
   929  
   930  	args := []graphb.Argument{
   931  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   932  		graphb.ArgumentCustomTypeSlice("networkServicesInfo", arguments...),
   933  	}
   934  
   935  	return MustParse(graphb.Query{
   936  		Type: graphb.TypeMutation,
   937  		Fields: []*graphb.Field{
   938  			{
   939  				Name:      "updateClusterNetworkServices",
   940  				Arguments: args,
   941  				Fields: []*graphb.Field{
   942  					graphb.NewField("networkServiceId"),
   943  					graphb.NewField("serviceType"),
   944  					graphb.NewField("ip"),
   945  					graphb.NewField("family"),
   946  					graphb.NewField("priority"),
   947  				},
   948  			},
   949  		},
   950  	})
   951  }
   952  
   953  func updateClusterName(clusterEdgeID string, name string) string {
   954  	args := []graphb.Argument{
   955  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   956  		graphb.ArgumentString("name", name),
   957  	}
   958  	return MustParse(graphb.Query{
   959  		Type: graphb.TypeMutation,
   960  		Fields: []*graphb.Field{
   961  			{
   962  				Name:      "updateClusterName",
   963  				Arguments: args,
   964  				Fields: []*graphb.Field{
   965  					graphb.NewField("clusterEdgeId"),
   966  					graphb.NewField("name"),
   967  					graphb.NewField("projectId"),
   968  					graphb.NewField("bannerEdgeId"),
   969  					graphb.NewField("registered"),
   970  					graphb.NewField("active"),
   971  					graphb.NewField("labels", graphb.OfFields(
   972  						"labelEdgeId",
   973  						"key",
   974  						"type",
   975  					)),
   976  					graphb.NewField("bslSiteID"),
   977  				},
   978  			},
   979  		},
   980  	})
   981  }
   982  
   983  func updateClusterFleetVersion(clusterEdgeID, fleetVersion string) string {
   984  	args := []graphb.Argument{
   985  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
   986  		graphb.ArgumentString("fleetVersion", fleetVersion),
   987  	}
   988  	return MustParse(graphb.Query{
   989  		Type: graphb.TypeMutation,
   990  		Fields: []*graphb.Field{
   991  			{
   992  				Name:      "updateClusterFleetVersion",
   993  				Arguments: args,
   994  				Fields: []*graphb.Field{
   995  					graphb.NewField("clusterEdgeId"),
   996  					graphb.NewField("name"),
   997  					graphb.NewField("projectId"),
   998  					graphb.NewField("bannerEdgeId"),
   999  					graphb.NewField("registered"),
  1000  					graphb.NewField("active"),
  1001  					graphb.NewField("labels", graphb.OfFields(
  1002  						"labelEdgeId",
  1003  						"key",
  1004  						"type",
  1005  					)),
  1006  					graphb.NewField("bslSiteID"),
  1007  					graphb.NewField("fleetVersion"),
  1008  				},
  1009  			},
  1010  		},
  1011  	})
  1012  }
  1013  
  1014  func clusterQuery(clusterEdgeID string) string {
  1015  	return MustParse(graphb.Query{
  1016  		Type: graphb.TypeQuery,
  1017  		Fields: []*graphb.Field{
  1018  			{
  1019  				Name: "cluster",
  1020  				Arguments: []graphb.Argument{
  1021  					graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
  1022  				},
  1023  				Fields: []*graphb.Field{
  1024  					graphb.NewField("clusterEdgeId"),
  1025  					graphb.NewField("name"),
  1026  					graphb.NewField("projectId"),
  1027  					graphb.NewField("bannerEdgeId"),
  1028  					graphb.NewField("registered"),
  1029  					graphb.NewField("active"),
  1030  					graphb.NewField("labels", graphb.OfFields(
  1031  						"labelEdgeId",
  1032  						"key",
  1033  						"type",
  1034  					)),
  1035  					graphb.NewField("bslSiteID"),
  1036  					graphb.NewField("status").SetFields(
  1037  						graphb.NewField("events").SetFields(
  1038  							graphb.NewField("involvedObject", graphb.OfFields("kind", "name")),
  1039  							graphb.NewField("eventEdgeID"),
  1040  							graphb.NewField("name"),
  1041  							graphb.NewField("clusterEdgeID"),
  1042  							graphb.NewField("reason"),
  1043  							graphb.NewField("message"),
  1044  							graphb.NewField("status"),
  1045  							graphb.NewField("source"),
  1046  							graphb.NewField("createdAt"),
  1047  						),
  1048  					),
  1049  				},
  1050  			},
  1051  		},
  1052  	})
  1053  }
  1054  
  1055  func clustersQuery(bannerEdgeID string, labels []string) string {
  1056  	return MustParse(graphb.Query{
  1057  		Type: graphb.TypeQuery,
  1058  		Fields: []*graphb.Field{
  1059  			{
  1060  				Name: "clusters",
  1061  				Arguments: []graphb.Argument{
  1062  					graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
  1063  					graphb.ArgumentStringSlice("labels", labels...),
  1064  				},
  1065  				Fields: []*graphb.Field{
  1066  					graphb.NewField("clusterEdgeId"),
  1067  					graphb.NewField("name"),
  1068  					graphb.NewField("projectId"),
  1069  					graphb.NewField("bannerEdgeId"),
  1070  					graphb.NewField("registered"),
  1071  					graphb.NewField("active"),
  1072  					graphb.NewField("labels", graphb.OfFields(
  1073  						"labelEdgeId",
  1074  						"key",
  1075  						"type",
  1076  					)),
  1077  					graphb.NewField("bslSiteID"),
  1078  				},
  1079  			},
  1080  		},
  1081  	})
  1082  }
  1083  
  1084  func createClusterConfigMutation(clusterEdgeID string, createClusterConfig model.CreateClusterConfig) string {
  1085  	config := graphb.ArgumentCustomTypeSliceElem(
  1086  		graphb.ArgumentBool("acRelay", *createClusterConfig.AcRelay),
  1087  		graphb.ArgumentBool("pxeEnabled", *createClusterConfig.PxeEnabled),
  1088  		graphb.ArgumentBool("bootstrapAck", *createClusterConfig.BootstrapAck),
  1089  		graphb.ArgumentBool("vpnEnabled", *createClusterConfig.VpnEnabled),
  1090  		graphb.ArgumentBool("thickPos", *createClusterConfig.ThickPos),
  1091  		graphb.ArgumentBool("egressGatewayEnabled", *createClusterConfig.EgressGatewayEnabled),
  1092  	)
  1093  	args := []graphb.Argument{
  1094  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
  1095  		graphb.ArgumentCustomType("createClusterConfig", config...),
  1096  	}
  1097  	return MustParse(graphb.Query{
  1098  		Type: graphb.TypeMutation,
  1099  		Fields: []*graphb.Field{
  1100  			{
  1101  				Name:      "createClusterConfig",
  1102  				Arguments: args,
  1103  				Fields: []*graphb.Field{
  1104  					graphb.NewField("clusterEdgeId"),
  1105  					graphb.NewField("acRelay"),
  1106  					graphb.NewField("pxeEnabled"),
  1107  					graphb.NewField("bootstrapAck"),
  1108  					graphb.NewField("vpnEnabled"),
  1109  					graphb.NewField("thickPos"),
  1110  					graphb.NewField("egressGatewayEnabled"),
  1111  				},
  1112  			},
  1113  		},
  1114  	})
  1115  }
  1116  
  1117  func updateClusterConfigMutation(clusterEdgeID string, updateClusterConfig model.UpdateClusterConfig) string {
  1118  	config := graphb.ArgumentCustomTypeSliceElem(
  1119  		graphb.ArgumentBool("acRelay", utils.ConvertToBool(updateClusterConfig.AcRelay)),
  1120  		graphb.ArgumentBool("pxeEnabled", utils.ConvertToBool(updateClusterConfig.PxeEnabled)),
  1121  		graphb.ArgumentBool("bootstrapAck", utils.ConvertToBool(updateClusterConfig.BootstrapAck)),
  1122  		graphb.ArgumentBool("vpnEnabled", utils.ConvertToBool(updateClusterConfig.VpnEnabled)),
  1123  		graphb.ArgumentBool("thickPos", utils.ConvertToBool(updateClusterConfig.ThickPos)),
  1124  		graphb.ArgumentBool("egressGatewayEnabled", utils.ConvertToBool(updateClusterConfig.EgressGatewayEnabled)),
  1125  	)
  1126  	args := []graphb.Argument{
  1127  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
  1128  		graphb.ArgumentCustomType("updateClusterConfig", config...),
  1129  	}
  1130  	return MustParse(graphb.Query{
  1131  		Type: graphb.TypeMutation,
  1132  		Fields: []*graphb.Field{
  1133  			{
  1134  				Name:      "updateClusterConfig",
  1135  				Arguments: args,
  1136  				Fields: []*graphb.Field{
  1137  					graphb.NewField("clusterEdgeId"),
  1138  					graphb.NewField("acRelay"),
  1139  					graphb.NewField("pxeEnabled"),
  1140  					graphb.NewField("bootstrapAck"),
  1141  					graphb.NewField("vpnEnabled"),
  1142  					graphb.NewField("thickPos"),
  1143  					graphb.NewField("egressGatewayEnabled"),
  1144  				},
  1145  			},
  1146  		},
  1147  	})
  1148  }
  1149  
  1150  func getClusterConfigQuery(clusterEdgeID string) string {
  1151  	args := []graphb.Argument{
  1152  		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
  1153  	}
  1154  	return MustParse(graphb.Query{
  1155  		Type: graphb.TypeQuery,
  1156  		Fields: []*graphb.Field{
  1157  			{
  1158  				Name:      "clusterConfig",
  1159  				Arguments: args,
  1160  				Fields: []*graphb.Field{
  1161  					graphb.NewField("clusterEdgeId"),
  1162  					graphb.NewField("acRelay"),
  1163  					graphb.NewField("pxeEnabled"),
  1164  					graphb.NewField("bootstrapAck"),
  1165  					graphb.NewField("vpnEnabled"),
  1166  					graphb.NewField("thickPos"),
  1167  					graphb.NewField("egressGatewayEnabled"),
  1168  				},
  1169  			},
  1170  		},
  1171  	})
  1172  }
  1173  

View as plain text