package integration_test import ( "context" "encoding/base64" "encoding/json" "fmt" "net/http" "time" pubSub "cloud.google.com/go/pubsub" "cloud.google.com/go/secretmanager/apiv1/secretmanagerpb" "github.com/99designs/gqlgen/client" "github.com/99designs/gqlgen/graphql" "github.com/99designs/gqlgen/graphql/handler" "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/clients/generated/apis/k8s/v1alpha1" resourceApi "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/clients/generated/apis/resourcemanager/v1beta1" helmApi "github.com/fluxcd/helm-controller/api/v2" "github.com/gin-gonic/gin" "github.com/golang/mock/gomock" "github.com/google/go-containerregistry/pkg/name" _ "github.com/lib/pq" "google.golang.org/api/compute/v1" "google.golang.org/api/container/v1" "google.golang.org/api/option" corev1 "k8s.io/api/core/v1" k8sErrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/selection" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/rest" runtimeclient "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/client/fake" "edge-infra.dev/pkg/edge/api/apierror" bsltypes "edge-infra.dev/pkg/edge/api/bsl/types" "edge-infra.dev/pkg/edge/api/clients" "edge-infra.dev/pkg/edge/api/graph/generated" "edge-infra.dev/pkg/edge/api/graph/mapper" "edge-infra.dev/pkg/edge/api/graph/model" "edge-infra.dev/pkg/edge/api/graph/resolver" testApi "edge-infra.dev/pkg/edge/api/graph/test" "edge-infra.dev/pkg/edge/api/middleware" "edge-infra.dev/pkg/edge/api/mocks" "edge-infra.dev/pkg/edge/api/services" "edge-infra.dev/pkg/edge/api/services/artifacts" clustersvc "edge-infra.dev/pkg/edge/api/services/cluster" "edge-infra.dev/pkg/edge/api/services/clustersecrets" "edge-infra.dev/pkg/edge/api/services/edgenode" "edge-infra.dev/pkg/edge/api/services/kinform" "edge-infra.dev/pkg/edge/api/services/virtualmachine" edgesql "edge-infra.dev/pkg/edge/api/sql" "edge-infra.dev/pkg/edge/api/testutils" "edge-infra.dev/pkg/edge/api/testutils/seededpostgres" "edge-infra.dev/pkg/edge/api/types" "edge-infra.dev/pkg/edge/api/utils" "edge-infra.dev/pkg/edge/bsl" chariotAPI "edge-infra.dev/pkg/edge/chariot/client" "edge-infra.dev/pkg/edge/constants/api/fleet" "edge-infra.dev/pkg/edge/ctlfish" "edge-infra.dev/pkg/edge/ctlfish/monitor" edgeAgentClientApi "edge-infra.dev/pkg/edge/edgeagent/model" "edge-infra.dev/pkg/edge/info" "edge-infra.dev/pkg/edge/okta" "edge-infra.dev/pkg/f8n/warehouse/pallet" unstructuredutil "edge-infra.dev/pkg/k8s/unstructured" fftest "edge-infra.dev/pkg/lib/featureflag/testutil" iamutils "edge-infra.dev/pkg/lib/gcp/iam/utils" "edge-infra.dev/pkg/lib/runtime/version" "edge-infra.dev/test/fixtures" "edge-infra.dev/test/framework" chariotClientApiTestutils "edge-infra.dev/test/framework/gcp/pubsub" ) const ( topLevelProjectID = "topLevelProjectId" testProject = "test-org" testServiceAccountEmail = "test-app@appspot.gserviceaccount.com" testOauth2ClientID = "test-oauth-2-client-id" testChariotPubsubTopic = "chariot-pubsub-topic" testChariotPubsubSubscription = "chariot-pubsub-subscription" testClusterEdgeID = "3396a52c-6a22-4049-9593-5a63b596a200" testClusterEdgeID2 = "3396a52c-6a22-4049-9593-5a63b596a201" testResetURL = "https://www.example.com" ) var ( ClusterDeletedCount = 0 testOrgBannerEdgeID = "3396a52c-6a22-4049-9593-5a63b596a101" MockCtrl *gomock.Controller runtimeClient runtimeclient.Client seededPostgres *seededpostgres.SeededPostgres defaultCfg = &types.Config{} ) func cleanupUnitTest() { if seededPostgres != nil { err := seededPostgres.Close() if err != nil { panic(err) } } } func setupUnitTest(config *types.TestConfig) (*Suite, error) { runtimeClient = fake.NewClientBuilder().WithScheme(scheme.Scheme).Build() // used only for unit tests // default retry for unit test defaultRetry = wait.Backoff{ Steps: 2, Duration: 2 * time.Second, Factor: 1.1, // change here for backoff Jitter: 0.1, } chariotClient, err := createChariotV2TestTopic() if err != nil { panic(err) } // mock feature flags fftest.MustInitTestFeatureFlags(map[string]bool{}) bspMockServer := services.GetMockBspServer(testOrg, testApi.TestOrgID, testUser, testUserRole, testEmail, testResetURL) mockGkeClient := createGKEMockClient() mockContainer := mockeGKEContainer() mockCompute := createMockComputeService() mockSecretManager := createMockForSecretManager() mockBigQuery := createMockBigQuery() mockCompatibility := createMockCompatibilityService() mockGCP := mocks.NewMockGcpClientService(MockCtrl) mockGCP.EXPECT().GetSecretClient(gomock.Any(), gomock.Any()).Return(mockSecretManager, nil).AnyTimes() mockGCP.EXPECT().GetContainerClient(gomock.Any(), gomock.Any()).Return(mockContainer, nil).AnyTimes() mockGCP.EXPECT().GetComputeClient(gomock.Any(), gomock.Any()).Return(mockCompute, nil).AnyTimes() appConfig := types.Config{ BSP: bsltypes.BSPConfig{ Root: "/customers/", Endpoint: bspMockServer.URL, ResetURL: testResetURL, }, Bff: types.BffConfig{TopLevelProjectID: "test-org"}, Chariot: types.ChariotConfig{}, Okta: types.OktaConfig{ OktaIssuer: "", ClientID: "abc123", }, } mockOktaServer := okta.MockServer(&appConfig.Okta) hc, _ := iamutils.NewIAMTestServer("projects/test-org", testProject, testServiceAccountEmail, testOauth2ClientID) iamHTTPClient := option.WithHTTPClient(hc) seededPostgres, err = seededpostgres.New() if err != nil { mockOktaServer.Close() return nil, err } db, err := seededPostgres.DB() if err != nil { _ = seededPostgres.Close() mockOktaServer.Close() return nil, err } // Insert current version as new latest store version versionTag := version.New().SemVer major, minor, patch, err := version.New().SemVerMajorMinorPatch() if err != nil { _ = seededPostgres.Close() mockOktaServer.Close() return nil, err } if _, err = db.Exec(edgesql.AddCurrentVersionToAvailableArtifacts, fleet.Store, versionTag, major, minor, patch); err != nil { _ = seededPostgres.Close() mockOktaServer.Close() return nil, err } if _, err = db.Exec(edgesql.UpdateLatestAvailableArtifact, fleet.Store, major, minor, patch); err != nil { _ = seededPostgres.Close() mockOktaServer.Close() return nil, err } if _, err = db.Exec(edgesql.UpdateClusterFleetVersion, testBootstrapClusterID, versionTag); err != nil { _ = seededPostgres.Close() mockOktaServer.Close() return nil, err } if _, err = db.Exec(edgesql.UpdateClusterFleetVersion, testBootstrapInactiveClusterID, versionTag); err != nil { _ = seededPostgres.Close() mockOktaServer.Close() return nil, err } secret := &bsl.AccessKey{SecretKey: "testPassword", SharedKey: "testUsername"} bslClient := bsl.NewBSLClient(appConfig.BSP, func(_ context.Context, _ string) (*bsl.AccessKey, error) { return secret, nil }) oktaClient := okta.New(appConfig.Okta) ac := mocks.NewMockArtifactRegistryClient(MockCtrl) path, err := fixtures.Layout() if err != nil { mockOktaServer.Close() return nil, err } bsl, err := path.Get(name.MustParseReference("edge-bsl:latest")) if err != nil { mockOktaServer.Close() return nil, err } p, err := pallet.New(bsl) if err != nil { mockOktaServer.Close() return nil, err } ac.EXPECT(). Get(gomock.Any(), gomock.Any(), gomock.Any()). Return(p, nil).AnyTimes() //defer db.Close() clusterLabelSvc := clustersvc.NewLabelService(db) gcpService := services.NewGcpService(mockGCP, "top-level-project", mockBigQuery) chariotService := services.NewChariotService(topLevelProjectID, testChariotPubsubTopic, chariotClient) roleService := services.NewRoleService(appConfig.BSP, bslClient) bannerService := services.NewBannerService(mockGkeClient, chariotService, bslClient, "top-level-project", db, defaultCfg) userManagementService := services.NewUserManagementService(appConfig, bslClient, oktaClient, roleService, bannerService) secretService := services.NewSecretService(mockGkeClient, chariotService, gcpService, mockBigQuery) iamService := services.NewIAMService(iamHTTPClient) bslSiteService := services.NewBSLSiteService(bslClient, db) artifactsService := artifacts.NewArtifactsService(db, clusterLabelSvc) labelService := services.NewLabelService(artifactsService, db) tenantService := services.NewTenantService(db, bslClient, &appConfig.BSP) clusterConfigService := services.NewClusterConfigService(db) terminalService := services.NewTerminalServiceBQ(db, mockBigQuery, labelService) compatibilityService := services.NewCompatibilityService(db) storeClusterService := services.NewStoreClusterService(mockGkeClient, mockBigQuery, db, chariotService, terminalService, compatibilityService) bootstrapService := services.NewBootstrapService("top-level-project", ac, db) terminalLabelService := services.NewTerminalLabelService(db, chariotService, terminalService, storeClusterService, labelService) activationCodeService := edgenode.NewActivationCodeService(db, terminalService, storeClusterService, clusterConfigService, secretService, gcpService, bannerService) registrationService := services.NewRegistrationService(mockGkeClient, topLevelProjectID, secretService, gcpService, bslSiteService, iamService, db, chariotService, terminalService, activationCodeService, clusterLabelSvc, labelService) helmService := services.NewHelmService(&appConfig, chariotService, gcpService, db, mockBigQuery, mockCompatibility) edgeAgentService := services.NewEdgeAgentService(edgeAgentClientApi.EdgeAgentTopicAndOwner) virtualMachineService := services.NewVirtualMachineService(db) namespaceService := services.NewNamespaceService(db) artifactRegistryService := services.NewArtifactRegistryService(db) clusterSecretService := clustersecrets.NewClusterSecretService(db, gcpService, &config.Config) kinformService := kinform.New(db) vmStatusService := virtualmachine.NewVirtualMachineStatusService(db, kinformService) resolver := &resolver.Resolver{ GKEClient: mockGkeClient, UserManagementService: userManagementService, SecretService: secretService, RoleService: roleService, HelmService: helmService, GCPService: gcpService, GCPClientService: mockGCP, BannerService: bannerService, RegistrationService: registrationService, StoreClusterService: storeClusterService, BSLSiteService: bslSiteService, IAMService: iamService, BootstrapService: bootstrapService, ChariotService: chariotService, LabelService: labelService, TenantService: tenantService, Config: &appConfig, TerminalService: terminalService, ClusterConfigService: clusterConfigService, TerminalLabelService: terminalLabelService, VirtualMachineService: virtualMachineService, ArtifactsService: artifactsService, NamespaceService: namespaceService, CompatibilityService: compatibilityService, ArtifactRegistryService: artifactRegistryService, ActivationCodeService: activationCodeService, VirtualMachineStatusService: vmStatusService, KinformService: kinformService, ClusterSecretService: clusterSecretService, EdgeAgentService: edgeAgentService, } noAuthTest := func(ctx context.Context, _ interface{}, next graphql.Resolver, _ string) (res interface{}, err error) { return next(ctx) } gqlConfig := generated.Config{Resolvers: resolver} gqlConfig.Directives.HasRole = resolver.HasRole() gqlConfig.Directives.HasBannerAccess = noAuthTest gqlConfig.Directives.HasBannerAccessInput = noAuthTest gqlConfig.Directives.HasClusterAccess = noAuthTest gqlConfig.Directives.HasClusterAccessInput = noAuthTest gqlConfig.Directives.HasHelmWorkloadAccess = noAuthTest gqlConfig.Directives.HasHelmWorkloadAccessInput = noAuthTest gqlConfig.Directives.HasLabelAccessInput = noAuthTest gqlConfig.Directives.HasLabelAccess = noAuthTest gqlConfig.Directives.HasTerminalAccess = noAuthTest gqlConfig.Directives.HasTerminalAccessInput = noAuthTest gqlConfig.Directives.CanAssignRole = resolver.CanAssignRole() srv := handler.NewDefaultServer(generated.NewExecutableSchema(gqlConfig)) srv.Use(&apierror.Extension{}) //todo figure out why this is needed and fix it testHelmChart = "test-helm-chart1" // use super admin permission for testing, web can later change permission at request level, see auth_service_test.go token, err := middleware.CreateToken(testUser, testEmail, testOrg, jwtSecret, []string{superAdminRole, edgeLeadsRole}, "bslToken", "bsl", "") if err != nil { _ = seededPostgres.Close() mockOktaServer.Close() return nil, err } if err = testSetup(); err != nil { _ = seededPostgres.Close() mockOktaServer.Close() return nil, err } unWrap := func(f gin.HandlerFunc) func(http.Handler) http.Handler { return func(h http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { c, _ := gin.CreateTestContext(w) c.Request = r f(c) h.ServeHTTP(w, r.WithContext(c.Request.Context())) }) } } handler := unWrap(middleware.AuthMiddleware(jwtSecret, totpSecret, db))(srv) ResolverClient = client.New(handler, client.AddHeader("Authorization", "Bearer "+token)) testTime := fmt.Sprintf("%d", time.Now().UnixNano()) f := framework.New("edge-backend-unit") return &Suite{ Framework: f, client: runtimeClient, ctx: context.Background(), projectID: projectID, testBannerEU: &testApi.TestBannerEU, testTime: testTime, ChariotClient: chariotClient, Resolver: resolver, DB: db, Config: config, }, nil } func createChariotV2TestTopic() (option.ClientOption, error) { chariotPubsubClient, err := chariotClientApiTestutils.NewMockPubsubServer() if err != nil { return nil, err } _, err = chariotClientApiTestutils.CreateMockTopic(context.Background(), topLevelProjectID, testChariotPubsubTopic, chariotPubsubClient) if err != nil { return nil, err } go func() { err := chariotClientApiTestutils.CreateMockSubscription(context.Background(), nil, topLevelProjectID, testChariotPubsubTopic, testChariotPubsubSubscription, 20*time.Second, "", func(msg *pubSub.Message) { message := &chariotAPI.ChariotMessage{} err := json.Unmarshal(msg.Data, message) if err != nil { fmt.Println(err) } fmt.Printf("Chariot Message: %v\n", message) for _, t := range message.Objects { rawDecodedText, _ := base64.StdEncoding.DecodeString(t) resource := &unstructured.Unstructured{} _ = resource.UnmarshalJSON(rawDecodedText) err = chariotAction(context.Background(), message.Operation, resource) fmt.Println("PublishMessage", resource.GetKind(), resource.GetNamespace(), resource.GetName(), resource.GetLabels(), resource.GetResourceVersion()) if err != nil { fmt.Println(err) } if resource.GetKind() == "Cluster" && message.Operation == "DELETE" { ClusterDeletedCount++ } } }, chariotPubsubClient) if err != nil { fmt.Println(err) } }() return chariotPubsubClient, nil } func chariotAction(ctx context.Context, operation string, un *unstructured.Unstructured) error { switch operation { case "update", "UPDATE": un.SetCreationTimestamp(metav1.Time{}) //un.SetResourceVersion("") //un.SetUID("") //un.SetGeneration(0) //un.SetSelfLink("") err = runtimeClient.Update(ctx, un) case "delete", "DELETE": err = runtimeClient.Delete(ctx, un) default: err = runtimeClient.Create(ctx, un) } return err } func createMockBigQuery() clients.BQClient { mockBigQuery := mocks.NewMockBQClient(MockCtrl) //mockBigQuery.EXPECT().Read(gomock.Any(), gomock.Any()).DoAndReturn(func(ctx context.Context, query string) ([]string, error) { // return bigQueryDataRetrieval(ctx, query) //}).AnyTimes() //todo convert this to work for getKubeResource mockBigQuery.EXPECT().GetKubeResource(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(ctx context.Context, _ string, cluster *model.Cluster, input model.LoqRequest) ([]string, error) { return bigQueryDataRetrieval(ctx, cluster, input) }).AnyTimes() return mockBigQuery } func createMockComputeService() *mocks.MockComputeService { mockCompute := mocks.NewMockComputeService(MockCtrl) mockCompute.EXPECT().GetZones(gomock.Any()).Return(&compute.ZoneList{Items: []*compute.Zone{{Name: testClusterZone}, {Name: "us-east1-c"}}}, nil).AnyTimes() mockCompute.EXPECT().GetMachineTypes(gomock.Any(), testClusterZone).Return(&compute.MachineTypeList{ Items: []*compute.MachineType{{Name: testClusterMachineType, GuestCpus: 16, MemoryMb: 64 * 1024}, {Name: "c2-standard-8", GuestCpus: 8, MemoryMb: 32 * 1024}}, }, nil).AnyTimes() mockCompute.EXPECT().GetMachineTypes(gomock.Any(), "bad-zone").Return(nil, k8sErrors.NewNotFound(schema.GroupResource{}, "")).AnyTimes() mockCompute.EXPECT().GetMachineType(gomock.Any(), testClusterZone, testClusterMachineType).Return(&compute.MachineType{Name: testClusterMachineType, GuestCpus: 16, MemoryMb: 64 * 1024}, nil).AnyTimes() mockCompute.EXPECT().GetMachineType(gomock.Any(), testClusterZone, "bad-machine-type").Return(nil, k8sErrors.NewNotFound(schema.GroupResource{}, "")).AnyTimes() return mockCompute } func mockeGKEContainer() *mocks.MockContainerService { mockContainer := mocks.NewMockContainerService(MockCtrl) mockContainer.EXPECT().GetServerConfig(gomock.Any(), testClusterZone).Return(&container.ServerConfig{ValidMasterVersions: []string{"1.19.10-gke.1600", "1.19.10-gke.1000"}}, nil).AnyTimes() mockContainer.EXPECT().GetServerConfig(gomock.Any(), "bad-zone").Return(nil, k8sErrors.NewNotFound(schema.GroupResource{}, "")).AnyTimes() return mockContainer } func createGKEMockClient() *mocks.MockGkeClient { mockGkeClient := mocks.NewMockGkeClient(MockCtrl) mockGkeClient.EXPECT().GetConfigForCluster(gomock.Any(), mapper.CreateGKECluster(&testRegion, &testOrg)).Return(&rest.Config{ Host: "http://localhost:8080", TLSClientConfig: rest.TLSClientConfig{ CAData: []byte("CAData"), }, }, nil).AnyTimes() mockGkeClient.EXPECT().GetRuntimeClient(gomock.Any(), mapper.CreateGKECluster(&badCluster, &testOrg)).Return(nil, k8sErrors.NewNotFound(schema.GroupResource{}, "")).AnyTimes() mockGkeClient.EXPECT().GetRuntimeClient(gomock.Any(), gomock.Any()).Return(runtimeClient, nil).AnyTimes() return mockGkeClient } func createMockCompatibilityService() *mocks.MockCompatibilityService { mockCompatibility := mocks.NewMockCompatibilityService(MockCtrl) mockCompatibility.EXPECT().IsCompatible(gomock.Any(), gomock.Any(), gomock.Any()).Return(true, nil).AnyTimes() return mockCompatibility } func createMockForSecretManager() *mocks.MockSecretManagerService { mockSecretManager := mocks.NewMockSecretManagerService(MockCtrl) mockSecretManager.EXPECT().AddSecret(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()). DoAndReturn(func(_ context.Context, secretID string, secretValue []byte, labels map[string]string, _ bool, _ *time.Time, _ string) error { return testutils.AddToSecretManager(secretValue, secretID, testOrg, labels) }).AnyTimes() mockSecretManager.EXPECT().GetSecret(gomock.Any(), gomock.Any()). DoAndReturn(func(_ context.Context, name string) (*secretmanagerpb.Secret, error) { result, err := testutils.GetFromSecretManager(testOrg, name) if err != nil { return nil, err } return result[0], err }).AnyTimes() mockSecretManager.EXPECT().DeleteSecret(gomock.Any(), gomock.Any()). DoAndReturn(func(_ context.Context, name string) error { return testutils.DeleteFromSecretManager(testOrg, name) }).AnyTimes() mockSecretManager.EXPECT().GetLatestSecretValue(gomock.Any(), gomock.Any()). DoAndReturn(func(_ context.Context, secretID string) ([]byte, error) { s, err := testutils.GetSecretInfoFromSecretManager(testOrg, secretID) return s[0].SecretValue, err }).AnyTimes() mockSecretManager.EXPECT().GetLatestSecretValueInfo(gomock.Any(), gomock.Any()). DoAndReturn(func(_ context.Context, secretID string) (*secretmanagerpb.SecretVersion, error) { s, err := testutils.GetSecretInfoFromSecretManager(testOrg, secretID) if err != nil { return nil, err } return s[0].SecretVersion, err }).AnyTimes() mockSecretManager.EXPECT().ListSecrets(gomock.Any(), gomock.Any()). DoAndReturn(func(_ context.Context, pageToken string) ([]*secretmanagerpb.Secret, string, error) { result, err := testutils.GetFromSecretManager(testOrg, pageToken) return result, projectID, err }).AnyTimes() mockSecretManager.EXPECT().GetProjectID().Return(testOrg).AnyTimes() return mockSecretManager } func testSetup() error { if err := runtimeClient.Create(context.Background(), &corev1.Namespace{ ObjectMeta: metav1.ObjectMeta{Name: "flux-system"}, }); err != nil { return err } if err := runtimeClient.Create(context.Background(), getDefaultServiceAccountSecret()); err != nil { return err } if err := runtimeClient.Create(context.Background(), getHelmRelease()); err != nil { return err } if err := runtimeClient.Create(context.Background(), newBSLUserSecret("edge-system", testOrg)); err != nil { return err } if err := runtimeClient.Create(context.Background(), getTestProject(testOrg)); err != nil { return err } if err := runtimeClient.Create(context.Background(), getEdgeInfoConfigmap()); err != nil { return err } return err } func getEdgeInfoConfigmap() *corev1.ConfigMap { return info.BuildConfigMap("test-org", testStore, "store", testRegion, "test-org", "fleet", topLevelProjectID, "3396a52c-6a22-4049-9593-5a63b596a100", "3396a52c-6a22-4049-9593-5a63b596a201", "test-env-url") } // Test Object: The objects already exists before bff runs func getDefaultServiceAccountSecret() *corev1.Secret { data := make(map[string][]byte) sa, _ := json.Marshal(&model.ServiceAccount{ ProjectID: &projectID, }) data["key.json"] = sa return &corev1.Secret{ TypeMeta: metav1.TypeMeta{ APIVersion: "v1", Kind: "Secret", }, ObjectMeta: metav1.ObjectMeta{ Namespace: mapper.SANamespace, Name: mapper.SAName, CreationTimestamp: metav1.Now(), }, Data: data, } } func getHelmRelease() *helmApi.HelmRelease { return &helmApi.HelmRelease{ ObjectMeta: metav1.ObjectMeta{ Name: "test-helm-release", Namespace: "flux-system", }, Spec: helmApi.HelmReleaseSpec{ Interval: metav1.Duration{ Duration: time.Duration(2) * time.Minute, }, ReleaseName: "test-helm-release", TargetNamespace: "flux-system", Chart: &helmApi.HelmChartTemplate{ Spec: helmApi.HelmChartTemplateSpec{ Chart: "podinfo", Version: "1.0", SourceRef: helmApi.CrossNamespaceObjectReference{ Kind: "HelmRepository", Name: "test-repo", }, }, }, }, } } // newBSLUserSecret return a new initialized secret. func newBSLUserSecret(ns, name string) *corev1.Secret { return &corev1.Secret{ TypeMeta: metav1.TypeMeta{ APIVersion: "v1", Kind: "Secret", }, ObjectMeta: metav1.ObjectMeta{ Namespace: ns, Name: name, }, Data: map[string][]byte{ bsl.SharedKey: []byte("testSharedKey"), bsl.SecretKey: []byte("testSecretKey"), }, } } // Test Object func getTestProject(name string) *resourceApi.Project { return &resourceApi.Project{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: name, }, Spec: resourceApi.ProjectSpec{ BillingAccountRef: &v1alpha1.ResourceRef{ Name: "billingAccount", }, FolderRef: &v1alpha1.ResourceRef{ Name: "folderRef", }, Name: name, ResourceID: &name, }, } } func bigQueryDataRetrieval(ctx context.Context, cluster *model.Cluster, query model.LoqRequest) ([]string, error) { // exclude delete label so only resources that have not been deleted are returned key := &runtimeclient.ObjectKey{} if query.Name == nil && query.Namespace == nil { key = nil } if query.Namespace != nil { key.Namespace = *query.Namespace } if query.Name != nil { key.Name = *query.Name } gvk := &schema.GroupVersionKind{ Kind: query.Kind, Group: query.Group, Version: query.Version, } excludedLabels := []string{"delete"} newReq, err := labels.NewRequirement("type", selection.NotIn, excludedLabels) if err != nil { return nil, err } newSelector := labels.NewSelector() newSelector.Add(*newReq) matcher := runtimeclient.MatchingLabelsSelector{Selector: newSelector} switch { case (key == nil || (query.Namespace == nil && query.Name == nil)) && query.Kind != "HelmRelease": list := &unstructured.UnstructuredList{} list.SetGroupVersionKind(*gvk) if err := runtimeClient.List(ctx, list, matcher); err != nil { return nil, err } return unstructuredutil.UnstructuredListToStrings(list) case query.Kind == "ClusterStatus": return handleStoreStatusQuery(key) case query.Kind == "HelmRelease": list := &unstructured.UnstructuredList{} list.SetGroupVersionKind(*gvk) if err := runtimeClient.List(ctx, list, runtimeclient.InNamespace("flux-system"), matcher); err != nil { return nil, err } return unstructuredutil.UnstructuredListToStrings(list) case query.Kind == "ConfigMap" && key.Name == bsl.BSLInfoConfigMapName: return handleConfigMapQuery(cluster.ClusterEdgeID, cluster.Name) case utils.Contains([]string{"Banner", "GKECluster", "Cluster", "ConfigMap"}, gvk.GroupKind().Kind): fmt.Println("Cluster Scope", gvk, key, "delete") fallthrough case key.Name == "" && key.Namespace != "": list := &unstructured.UnstructuredList{} list.SetGroupVersionKind(*gvk) if err := runtimeClient.List(ctx, list, runtimeclient.InNamespace(key.Namespace), matcher); err != nil { return nil, err } return unstructuredutil.UnstructuredListToStrings(list) default: un := &unstructured.Unstructured{} un.SetGroupVersionKind(*gvk) if err := runtimeClient.Get(ctx, *key, un); err != nil { return nil, err } data, err := un.MarshalJSON() return []string{string(data)}, err } } func handleStoreStatusQuery(key *runtimeclient.ObjectKey) ([]string, error) { nodeVersion := "v1.23.6" if key.Name == ctlfish.ClusterStatusName { testSyncInfo := monitor.SyncInfo{ LastUpdated: "test-last-updated", Revision: "test-revision", StatusMessage: "test-status-message", Error: false, Suspended: true, } buckets := map[string]monitor.BucketInfo{ "test-bucket-1": { Excludes: "test-excludes", BucketName: "test-bucket-name", FluxStatus: testSyncInfo, }, } kustomizations := map[string]monitor.KustomizationInfo{ "test-kustomization-1": {Path: "test-path-1", Source: "test-source-1", FluxStatus: testSyncInfo}, "test-kustomization-2": {Path: "test-path-2", Source: "test-source-2", FluxStatus: testSyncInfo}, } status := &monitor.ClusterStatus{ Status: "Ready", NodeVersion: nodeVersion, Buckets: buckets, Kustomizations: kustomizations, } data, err := json.Marshal(status) return []string{string(data)}, err } return []string{}, fmt.Errorf("%v store status not found", key) } func handleConfigMapQuery(clusterEdgeID, clusterName string) ([]string, error) { if clusterEdgeID == "5bc12c67-d9b0-4f13-a6d4-4852b0c11291" || clusterName == "test_cluster-3" { return getConfigMap("test_bsl_site_id-3", "") } else if clusterEdgeID == testClusterEdgeID2 || clusterName == "test_cluster-2" { return getConfigMap("test_bsl_site_id-2", "") } else if clusterEdgeID == testClusterEdgeID || clusterName == "test_cluster02" { return getConfigMap("test_bsl_site_id", "test mismatch in site description") } return []string{}, fmt.Errorf("bsl-info config map not found, cluster: %s, %s", clusterEdgeID, clusterName) } func getConfigMap(bslSiteID, description string) ([]string, error) { configMap := bsl.BuildConfigMap("test-store", "test-enterprise-unit-name", "", services.DefaultLatitude, services.DefaultLongitude, &bslSiteID) if description != "" { configMap.Data[bsl.BSLSiteDescription] = description } data, err := json.Marshal(configMap) return []string{string(data)}, err }