github.com/redhat-appstudio/e2e-tests@v0.0.0-20230619105049-9a422b2094d7/tests/release/e2e-test-default-bundle.go (about)

     1  package release
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  
     7  	ecp "github.com/enterprise-contract/enterprise-contract-controller/api/v1alpha1"
     8  	. "github.com/onsi/ginkgo/v2"
     9  	. "github.com/onsi/gomega"
    10  	appservice "github.com/redhat-appstudio/application-api/api/v1alpha1"
    11  	"github.com/redhat-appstudio/e2e-tests/pkg/constants"
    12  	"github.com/redhat-appstudio/e2e-tests/pkg/framework"
    13  	"github.com/redhat-appstudio/e2e-tests/pkg/utils"
    14  	"github.com/redhat-appstudio/e2e-tests/pkg/utils/release"
    15  	"github.com/redhat-appstudio/e2e-tests/pkg/utils/tekton"
    16  	releaseApi "github.com/redhat-appstudio/release-service/api/v1alpha1"
    17  	"gopkg.in/yaml.v2"
    18  	corev1 "k8s.io/api/core/v1"
    19  	"knative.dev/pkg/apis"
    20  )
    21  
    22  var _ = framework.ReleaseSuiteDescribe("[HACBS-738]test-release-service-default-pipeline", Label("release", "defaultBundle", "HACBS"), func() {
    23  	defer GinkgoRecover()
    24  
    25  	var fw *framework.Framework
    26  	var err error
    27  	var compName string
    28  	var devNamespace = utils.GetGeneratedNamespace("release-dev")
    29  	var managedNamespace = utils.GetGeneratedNamespace("release-managed")
    30  	var component *appservice.Component
    31  
    32  	BeforeAll(func() {
    33  		// Initialize the tests controllers
    34  		fw, err = framework.NewFramework("release-e2e-bundle")
    35  		Expect(err).NotTo(HaveOccurred())
    36  		kubeController := tekton.KubeController{
    37  			Commonctrl: *fw.AsKubeAdmin.CommonController,
    38  			Tektonctrl: *fw.AsKubeAdmin.TektonController,
    39  		}
    40  
    41  		_, err := fw.AsKubeAdmin.CommonController.CreateTestNamespace(devNamespace)
    42  		Expect(err).NotTo(HaveOccurred(), "Error when creating devNamespace: %v", err)
    43  		GinkgoWriter.Println("Dev Namespace created: %s ", devNamespace)
    44  
    45  		_, err = fw.AsKubeAdmin.CommonController.CreateTestNamespace(managedNamespace)
    46  		Expect(err).NotTo(HaveOccurred(), "Error when creating managedNamespace: %v", err)
    47  		GinkgoWriter.Println("Managed Namespace created: %s", managedNamespace)
    48  
    49  		sourceAuthJson := utils.GetEnv("QUAY_TOKEN", "")
    50  		Expect(sourceAuthJson).ToNot(BeEmpty())
    51  
    52  		destinationAuthJson := utils.GetEnv("QUAY_OAUTH_TOKEN_RELEASE_DESTINATION", "")
    53  		Expect(destinationAuthJson).ToNot(BeEmpty())
    54  
    55  		_, err = fw.AsKubeAdmin.CommonController.CreateServiceAccount(releaseStrategyServiceAccountDefault, managedNamespace, managednamespaceSecret)
    56  		Expect(err).NotTo(HaveOccurred())
    57  
    58  		_, err = fw.AsKubeAdmin.CommonController.CreateRegistryAuthSecret(hacbsReleaseTestsTokenSecret, devNamespace, sourceAuthJson)
    59  		Expect(err).ToNot(HaveOccurred())
    60  
    61  		_, err = fw.AsKubeAdmin.CommonController.CreateRegistryAuthSecret(redhatAppstudioUserSecret, managedNamespace, destinationAuthJson)
    62  		Expect(err).ToNot(HaveOccurred())
    63  
    64  		err = fw.AsKubeAdmin.CommonController.LinkSecretToServiceAccount(devNamespace, hacbsReleaseTestsTokenSecret, serviceAccount, true)
    65  		Expect(err).ToNot(HaveOccurred())
    66  
    67  		err = fw.AsKubeAdmin.CommonController.LinkSecretToServiceAccount(managedNamespace, redhatAppstudioUserSecret, serviceAccount, true)
    68  		Expect(err).ToNot(HaveOccurred())
    69  
    70  		publicKey, err := kubeController.GetTektonChainsPublicKey()
    71  		Expect(err).ToNot(HaveOccurred())
    72  		Expect(kubeController.CreateOrUpdateSigningSecret(
    73  			publicKey, publicSecretNameAuth, managedNamespace)).To(Succeed())
    74  
    75  		defaultEcPolicy, err := kubeController.GetEnterpriseContractPolicy("default", "enterprise-contract-service")
    76  		Expect(err).NotTo(HaveOccurred())
    77  
    78  		defaultEcPolicySpec := ecp.EnterpriseContractPolicySpec{
    79  			Description: "Red Hat's enterprise requirements",
    80  			PublicKey:   string(publicKey),
    81  			Sources:     defaultEcPolicy.Spec.Sources,
    82  			Configuration: &ecp.EnterpriseContractPolicyConfiguration{
    83  				Collections: []string{"minimal"},
    84  				Exclude:     []string{"cve"},
    85  			},
    86  		}
    87  
    88  		// using cdq since git ref is not known
    89  		compName = componentName
    90  		var componentDetected appservice.ComponentDetectionDescription
    91  		cdq, err := fw.AsKubeAdmin.HasController.CreateComponentDetectionQuery(compName, devNamespace, gitSourceComponentUrl, "", "", "", false)
    92  		Expect(err).NotTo(HaveOccurred())
    93  		Expect(len(cdq.Status.ComponentDetected)).To(Equal(1), "Expected length of the detected Components was not 1")
    94  
    95  		for _, compDetected := range cdq.Status.ComponentDetected {
    96  			compName = compDetected.ComponentStub.ComponentName
    97  			componentDetected = compDetected
    98  		}
    99  
   100  		_, err = fw.AsKubeAdmin.ReleaseController.CreateReleasePlan(sourceReleasePlanName, devNamespace, applicationNameDefault, managedNamespace, "")
   101  		Expect(err).NotTo(HaveOccurred())
   102  
   103  		components := []release.Component{{Name: compName, Repository: releasedImagePushRepo}}
   104  		sc := fw.AsKubeAdmin.ReleaseController.GenerateReleaseStrategyConfig(components)
   105  		scYaml, err := yaml.Marshal(sc)
   106  		Expect(err).ShouldNot(HaveOccurred())
   107  
   108  		scPath := "release-default-bundle.yaml"
   109  		Expect(fw.AsKubeAdmin.CommonController.Github.CreateRef("strategy-configs", "main", compName)).To(Succeed())
   110  		_, err = fw.AsKubeAdmin.CommonController.Github.CreateFile("strategy-configs", scPath, string(scYaml), compName)
   111  		Expect(err).ShouldNot(HaveOccurred())
   112  
   113  		_, err = fw.AsKubeAdmin.ReleaseController.CreateReleaseStrategy(releaseStrategyDefaultName, managedNamespace, releasePipelineNameDefault, constants.ReleasePipelineImageRef, releaseStrategyPolicyDefault, releaseStrategyServiceAccountDefault, []releaseApi.Params{
   114  			{Name: "extraConfigGitUrl", Value: fmt.Sprintf("https://github.com/%s/strategy-configs.git", utils.GetEnv(constants.GITHUB_E2E_ORGANIZATION_ENV, "redhat-appstudio-qe"))},
   115  			{Name: "extraConfigPath", Value: scPath},
   116  			{Name: "extraConfigGitRevision", Value: compName},
   117  		})
   118  		Expect(err).NotTo(HaveOccurred())
   119  
   120  		_, err = fw.AsKubeAdmin.ReleaseController.CreateReleasePlanAdmission(targetReleasePlanAdmissionName, devNamespace, applicationNameDefault, managedNamespace, "", "", releaseStrategyDefaultName)
   121  		Expect(err).NotTo(HaveOccurred())
   122  
   123  		_, err = fw.AsKubeAdmin.TektonController.CreateEnterpriseContractPolicy(releaseStrategyPolicyDefault, managedNamespace, defaultEcPolicySpec)
   124  		Expect(err).NotTo(HaveOccurred())
   125  
   126  		_, err = fw.AsKubeAdmin.TektonController.CreatePVCInAccessMode(releasePvcName, managedNamespace, corev1.ReadWriteOnce)
   127  		Expect(err).NotTo(HaveOccurred())
   128  
   129  		_, err = fw.AsKubeAdmin.CommonController.CreateRole("role-release-service-account", managedNamespace, map[string][]string{
   130  			"apiGroupsList": {""},
   131  			"roleResources": {"secrets"},
   132  			"roleVerbs":     {"get", "list", "watch"},
   133  		})
   134  		Expect(err).NotTo(HaveOccurred())
   135  
   136  		_, err = fw.AsKubeAdmin.CommonController.CreateRoleBinding("role-release-service-account-binding", managedNamespace, "ServiceAccount", releaseStrategyServiceAccountDefault, "Role", "role-release-service-account", "rbac.authorization.k8s.io")
   137  		Expect(err).NotTo(HaveOccurred())
   138  
   139  		_, err = fw.AsKubeAdmin.HasController.CreateHasApplication(applicationNameDefault, devNamespace)
   140  		Expect(err).NotTo(HaveOccurred())
   141  
   142  		component, err = fw.AsKubeAdmin.HasController.CreateComponentFromStubSkipInitialChecks(componentDetected, devNamespace, "", "", applicationNameDefault, false)
   143  		Expect(err).NotTo(HaveOccurred())
   144  	})
   145  
   146  	AfterAll(func() {
   147  		err = fw.AsKubeAdmin.CommonController.Github.DeleteRef("strategy-configs", compName)
   148  		if err != nil {
   149  			Expect(err.Error()).To(ContainSubstring("Reference does not exist"))
   150  		}
   151  		if !CurrentSpecReport().Failed() {
   152  			Expect(fw.AsKubeAdmin.TektonController.DeleteAllPipelineRunsInASpecificNamespace(devNamespace)).NotTo(HaveOccurred())
   153  			Expect(fw.AsKubeAdmin.CommonController.DeleteNamespace(devNamespace)).NotTo(HaveOccurred())
   154  			Expect(fw.AsKubeAdmin.CommonController.DeleteNamespace(managedNamespace)).NotTo(HaveOccurred())
   155  			Expect(fw.SandboxController.DeleteUserSignup(fw.UserName)).NotTo(BeFalse())
   156  		}
   157  	})
   158  
   159  	var _ = Describe("Post-release verification", func() {
   160  
   161  		It("verifies that a build PipelineRun is created in dev namespace and succeeds", func() {
   162  			Expect(fw.AsKubeAdmin.HasController.WaitForComponentPipelineToBeFinished(component, "", 2)).To(Succeed())
   163  		})
   164  
   165  		It("verifies that in managed namespace will be created a PipelineRun.", func() {
   166  			Eventually(func() bool {
   167  				prList, err := fw.AsKubeAdmin.TektonController.ListAllPipelineRuns(managedNamespace)
   168  				if err != nil || prList == nil || len(prList.Items) < 1 {
   169  					return false
   170  				}
   171  
   172  				return strings.Contains(prList.Items[0].Name, "release")
   173  			}, releasePipelineRunCreationTimeout, defaultInterval).Should(BeTrue())
   174  		})
   175  
   176  		It("verifies a PipelineRun started in managed namespace succeeded.", func() {
   177  			Eventually(func() bool {
   178  				prList, err := fw.AsKubeAdmin.TektonController.ListAllPipelineRuns(managedNamespace)
   179  				if prList == nil || err != nil || len(prList.Items) < 1 {
   180  					return false
   181  				}
   182  
   183  				return prList.Items[0].HasStarted() && prList.Items[0].IsDone() && prList.Items[0].Status.GetCondition(apis.ConditionSucceeded).IsTrue()
   184  			}, releasePipelineRunCompletionTimeout, defaultInterval).Should(BeTrue())
   185  		})
   186  
   187  		It("tests a Release should have been created in the dev namespace and succeeded.", func() {
   188  			Eventually(func() bool {
   189  				releaseCreated, err := fw.AsKubeAdmin.ReleaseController.GetFirstReleaseInNamespace(devNamespace)
   190  				if releaseCreated == nil || err != nil {
   191  					return false
   192  				}
   193  
   194  				return releaseCreated.IsReleased()
   195  			}, releaseCreationTimeout, defaultInterval).Should(BeTrue())
   196  		})
   197  	})
   198  })