Add cluster logging (#908)

tests/globalhelper/operator.go

@@ -98,6 +98,49 @@ func ApproveInstallPlan(namespace string, plan *v1alpha1.InstallPlan) error {
 	return updateInstallPlan(namespace, plan)
 }
 
+func DeployRHOperatorSource(ocpVersion string) error {
+	// if the ocpVersion is empty, we will use have to look up the version
+	ocpVersionToUse := ocpVersion
+
+	if ocpVersion == "" {
+		o, err := GetClusterVersion()
+		if err != nil {
+			return fmt.Errorf("unable to get OCP version: %w", err)
+		}
+
+		ocpVersionToUse = o[:4]
+	}
+
+	err := GetAPIClient().Create(context.TODO(),
+		&v1alpha1.CatalogSource{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "redhat-operators",
+				Namespace: "openshift-marketplace",
+			},
+			Spec: v1alpha1.CatalogSourceSpec{
+				SourceType:  "grpc",
+				Image:       "registry.redhat.io/redhat/redhat-operator-index:v" + ocpVersionToUse,
+				DisplayName: "redhat-operators",
+				Publisher:   "Redhat",
+				Secrets:     []string{"redhat-registry-secret", "redhat-connect-registry-secret"},
+				UpdateStrategy: &v1alpha1.UpdateStrategy{
+					RegistryPoll: &v1alpha1.RegistryPoll{
+						Interval: &metav1.Duration{
+							Duration: 30 * time.Minute}},
+				},
+			},
+		},
+	)
+
+	if k8serrors.IsAlreadyExists(err) {
+		return nil
+	} else if err != nil {
+		return fmt.Errorf("can not deploy catalog source %w", err)
+	}
+
+	return nil
+}
+
 func DeployRHCertifiedOperatorSource(ocpVersion string) error {
 	// if the ocpVersion is empty, we will use have to look up the version
 	ocpVersionToUse := ocpVersion

tests/operator/operator_suite_test.go

@@ -41,6 +41,10 @@ var _ = SynchronizedBeforeSuite(func() {
 		err = globalhelper.DeployRHCertifiedOperatorSource("")
 		Expect(err).ToNot(HaveOccurred())
 
+		By("Create redhat-operators catalog source")
+		err = globalhelper.DeployRHOperatorSource("")
+		Expect(err).ToNot(HaveOccurred())
+
 		By("Check if catalog sources are available")
 		err = globalhelper.ValidateCatalogSources()
 		Expect(err).ToNot(HaveOccurred(), "All necessary catalog sources are not available")

tests/operator/parameters/parameters.go

@@ -38,6 +38,7 @@ var (
 	OperatorGroupName             = "operator-test-operator-group"
 	OperatorLabel                 = map[string]string{"redhat-best-practices-for-k8s.com/operator": "target"}
 	CertifiedOperatorGroup        = "certified-operators"
+	RedhatOperatorGroup           = "redhat-operators"
 	CommunityOperatorGroup        = "community-operators"
 	OperatorSourceNamespace       = "openshift-marketplace"
 	OperatorPrefixCloudbees       = "cloudbees-ci"

tests/operator/tests/operator_install_source.go

@@ -38,70 +38,80 @@ var _ = Describe("Operator install-source,", Serial, func() {
 		Expect(err).ToNot(HaveOccurred())
 
 		// Install 3 separate operators for testing
-
 		By("Deploy operator group")
 		err = tshelper.DeployTestOperatorGroup(randomNamespace)
 		Expect(err).ToNot(HaveOccurred(), "Error deploying operator group")
+	})
 
-		By("Deploy openvino operator for testing")
-		err = tshelper.DeployOperatorSubscription(
-			"ovms-operator",
-			"alpha",
-			randomNamespace,
-			tsparams.CertifiedOperatorGroup,
-			tsparams.OperatorSourceNamespace,
-			"",
-			v1alpha1.ApprovalAutomatic,
+	AfterEach(func() {
+		globalhelper.AfterEachCleanupWithRandomNamespace(randomNamespace,
+			randomReportDir, randomCertsuiteConfigDir, tsparams.Timeout)
+	})
+
+	It("deploy cluster-wide cluster-logging operator with subscription in another namespace", func() {
+		const (
+			clusterLoggingOperatorName  = "cluster-logging"
+			clusterLoggingTestNamespace = "fake-openshift-logging"
+			openshiftLoggingNamespace   = "openshift-logging"
+			subscriptionChannel         = "stable-5.9"
 		)
-		Expect(err).ToNot(HaveOccurred(), ErrorDeployOperatorStr+
-			tsparams.OperatorPrefixOpenvino)
 
-		err = tshelper.WaitUntilOperatorIsReady(tsparams.OperatorPrefixOpenvino,
-			randomNamespace)
-		Expect(err).ToNot(HaveOccurred(), "Operator "+tsparams.OperatorPrefixOpenvino+
-			" is not ready")
+		By("Create openshift-logging namespace")
+		err := globalhelper.CreateNamespace(openshiftLoggingNamespace)
+		Expect(err).ToNot(HaveOccurred())
 
-		By("Deploy cloudbees-ci operator for testing")
-		err = tshelper.DeployOperatorSubscription(
-			"cloudbees-ci",
-			"alpha",
-			randomNamespace,
-			tsparams.CertifiedOperatorGroup,
-			tsparams.OperatorSourceNamespace,
-			"",
-			v1alpha1.ApprovalAutomatic,
-		)
+		By("Create fake operator group for cluster-logging operator")
+		err = tshelper.DeployTestOperatorGroup(openshiftLoggingNamespace)
+		Expect(err).ToNot(HaveOccurred(), "Error deploying operator group")
 
-		Expect(err).ToNot(HaveOccurred(), ErrorDeployOperatorStr+
-			tsparams.OperatorPrefixCloudbees)
+		DeferCleanup(func() {
+			By("Delete fake namespace for cluster-logging operator")
+			err := globalhelper.DeleteNamespaceAndWait(openshiftLoggingNamespace, tsparams.Timeout)
+			Expect(err).ToNot(HaveOccurred())
+		})
 
-		err = tshelper.WaitUntilOperatorIsReady(tsparams.OperatorPrefixCloudbees,
-			randomNamespace)
-		Expect(err).ToNot(HaveOccurred(), "Operator "+tsparams.OperatorPrefixCloudbees+
-			" is not ready")
+		By("Query the packagemanifest for the " + clusterLoggingOperatorName)
+		version, err := globalhelper.QueryPackageManifestForVersion(clusterLoggingOperatorName, randomNamespace)
+		Expect(err).ToNot(HaveOccurred(), "Error querying package manifest for nginx-ingress-operator")
 
-		By("Deploy anchore-engine operator for testing")
+		By("Deploy cluster-logging operator for testing")
 		err = tshelper.DeployOperatorSubscription(
-			"anchore-engine",
-			"alpha",
-			randomNamespace,
-			tsparams.CertifiedOperatorGroup,
+			clusterLoggingOperatorName,
+			subscriptionChannel,
+			openshiftLoggingNamespace,
+			tsparams.RedhatOperatorGroup,
 			tsparams.OperatorSourceNamespace,
-			"",
+			clusterLoggingOperatorName+".v"+version,
 			v1alpha1.ApprovalAutomatic,
 		)
-		Expect(err).ToNot(HaveOccurred(), ErrorDeployOperatorStr+
-			tsparams.OperatorPrefixAnchore)
+		Expect(err).ToNot(HaveOccurred(), ErrorDeployOperatorStr+clusterLoggingOperatorName)
 
-		err = tshelper.WaitUntilOperatorIsReady(tsparams.OperatorPrefixAnchore,
-			randomNamespace)
-		Expect(err).ToNot(HaveOccurred(), "Operator "+tsparams.OperatorPrefixAnchore+
-			" is not ready")
-	})
+		By("Wait until operator is ready")
+		err = tshelper.WaitUntilOperatorIsReady(clusterLoggingOperatorName, randomNamespace)
+		Expect(err).ToNot(HaveOccurred(), "Operator "+clusterLoggingOperatorName+" is not ready")
 
-	AfterEach(func() {
-		globalhelper.AfterEachCleanupWithRandomNamespace(randomNamespace,
-			randomReportDir, randomCertsuiteConfigDir, tsparams.Timeout)
+		By("Label operators")
+		Eventually(func() error {
+			return tshelper.AddLabelToInstalledCSV(
+				clusterLoggingOperatorName,
+				randomNamespace,
+				tsparams.OperatorLabel)
+		}, tsparams.TimeoutLabelCsv, tsparams.PollingInterval).Should(Not(HaveOccurred()),
+			ErrorLabelingOperatorStr+clusterLoggingOperatorName)
+
+		By("Start test")
+		err = globalhelper.LaunchTests(
+			tsparams.CertsuiteOperatorInstallSource,
+			globalhelper.ConvertSpecNameToFileName(CurrentSpecReport().FullText()),
+			randomReportDir,
+			randomCertsuiteConfigDir)
+		Expect(err).ToNot(HaveOccurred())
+
+		By("Verify test case status in Claim report")
+		err = globalhelper.ValidateIfReportsAreValid(
+			tsparams.CertsuiteOperatorInstallSource,
+			globalparameters.TestCasePassed, randomReportDir)
+		Expect(err).ToNot(HaveOccurred())
 	})
 
 	// 66142

tests/utils/operator/operator.go

@@ -12,8 +12,8 @@ func DefineOperatorGroup(groupName string, namespace string, targetNamespace []s
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      groupName,
 			Namespace: namespace},
-		Spec: olmv1.OperatorGroupSpec{
-			TargetNamespaces: targetNamespace},
+		// Spec: olmv1.OperatorGroupSpec{
+		// 	TargetNamespaces: targetNamespace},
 	}
 }
 

tests/utils/operator/operator_test.go

@@ -12,7 +12,6 @@ func TestDefineOperatorGroup(t *testing.T) {
 	assert.NotNil(t, og)
 	assert.Equal(t, "test", og.Name)
 	assert.Equal(t, "default", og.Namespace)
-	assert.Equal(t, []string{"testNamespace"}, og.Spec.TargetNamespaces)
 }
 
 func TestDefineSubscription(t *testing.T) {