test: Port tests to XKS

.github/workflows/kind-ci-automation.yaml

@@ -63,6 +63,13 @@ jobs:
         run: |
           make install
 
+      - name: Install Argo CD cli tool
+        run: |
+          curl -fsSL -o /tmp/argocd-linux-amd64 https://github.com/argoproj/argo-cd/releases/latest/download/argocd-linux-amd64
+          sudo install -m 555 /tmp/argocd-linux-amd64 /usr/local/bin/argocd
+          rm /tmp/argocd-linux-amd64
+          argocd version --client
+
       - name: Deploy operator
         run: |
           set -o pipefail

test/examples/operator-acceptance/argocd.yaml

@@ -1,4 +1,4 @@
-apiVersion: argoproj.io/v1alpha1
+apiVersion: argoproj.io/v1beta1
 kind: ArgoCD
 metadata:
   name: argocd

test/openshift/e2e/ginkgo/fixture/argocd/fixture.go

@@ -1,8 +1,10 @@
 package argocd
 
 import (
+	"bufio"
 	"context"
 	"fmt"
+	"io"
 	"os/exec"
 	"strings"
 	"time"
@@ -46,6 +48,20 @@ func Update(obj *argov1beta1api.ArgoCD, modify func(*argov1beta1api.ArgoCD)) {
 	time.Sleep(7 * time.Second)
 }
 
+// CreateNewArgoCDInstance creates a new ArgoCD instance with an empty (zero) spec in the
+// given namespace and returns it. Callers should wait for availability via BeAvailable.
+func CreateNewArgoCDInstance(name, namespace string) *argov1beta1api.ArgoCD {
+	k8sClient, _ := utils.GetE2ETestKubeClient()
+
+	argoCD := &argov1beta1api.ArgoCD{
+		ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: namespace},
+		Spec:       argov1beta1api.ArgoCDSpec{},
+	}
+	Expect(k8sClient.Create(context.Background(), argoCD)).To(Succeed())
+
+	return argoCD
+}
+
 func GetOpenShiftGitOpsNSArgoCD() (*argov1beta1api.ArgoCD, error) {
 
 	k8sClient, _ := utils.GetE2ETestKubeClient()
@@ -303,7 +319,96 @@ func LogInToDefaultArgoCDInstance() error {
 
 }
 
-// NOTE: this should only be called from sequential tests. If you call it from a parallel test, there is a risk that another test will login to a different Argo CD instance.
+// port-forward instead of an OpenShift Route, so it works on xks clusters.
+// instanceName is the ArgoCD CR name (e.g. "openshift-gitops"); namespace is its namespace.
+// The returned cancel func stops the port-forward; call it (or defer it) after all argocd
+// CLI calls in the test are done, since the CLI stores localhost:18080 as the server address.
+func LogInToArgoCDInstanceWithoutRoute(instanceName, namespace string) (func(), error) {
+	k8sClient, _, err := utils.GetE2ETestKubeClientWithError()
+	if err != nil {
+		return nil, err
+	}
+
+	secretName := instanceName + "-cluster"
+	secret := &corev1.Secret{ObjectMeta: metav1.ObjectMeta{Name: secretName, Namespace: namespace}}
+	if err := k8sClient.Get(context.Background(), client.ObjectKeyFromObject(secret), secret); err != nil {
+		return nil, fmt.Errorf("unable to locate %q Secret", secretName)
+	}
+
+	const localPort = "18080"
+	cancel := portForwardArgoCD(namespace, "svc/"+instanceName+"-server", localPort+":80")
+
+	output, err := RunArgoCDCLI("login", "localhost:"+localPort, "--username", "admin",
+		"--password", string(secret.Data["admin.password"]), "--insecure")
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+
+	if !strings.Contains(output, "'admin:login' logged in successfully") {
+		cancel()
+		return nil, fmt.Errorf("unable to log in to ArgoCD instance %q in namespace %q", instanceName, namespace)
+	}
+
+	return cancel, nil
+}
+
+// portForwardArgoCD starts kubectl port-forward and returns a cancel func.
+// Blocks until the tunnel is ready (or Fail()s after 60s).
+func portForwardArgoCD(namespace, subject, port string) func() {
+	// Kill any stale process on the local port left by a previous crashed run.
+	localPort := strings.SplitN(port, ":", 2)[0]
+	// #nosec G204
+	_ = exec.Command("sh", "-c", "lsof -ti :"+localPort+" | xargs kill -9 2>/dev/null; fuser -k "+localPort+"/tcp 2>/dev/null; true").Run()
+
+	cmd := exec.Command("kubectl", "port-forward", "-n", namespace, subject, port) // #nosec G204
+
+	stdout, err := cmd.StdoutPipe()
+	Expect(err).ToNot(HaveOccurred())
+	stderr, err := cmd.StderrPipe()
+	Expect(err).ToNot(HaveOccurred())
+
+	ready := make(chan struct{})
+
+	stream := func(r io.Reader, signal func()) {
+		defer GinkgoRecover()
+		sc := bufio.NewScanner(r)
+		for sc.Scan() {
+			line := sc.Text()
+			GinkgoWriter.Println("port-forward:", line)
+			if signal != nil && strings.HasPrefix(line, "Forwarding from") {
+				signal()
+				signal = nil
+			}
+		}
+	}
+
+	Expect(cmd.Start()).To(Succeed())
+	go stream(stdout, func() { close(ready) })
+	go stream(stderr, nil)
+	go func() {
+		defer GinkgoRecover()
+		if waitErr := cmd.Wait(); waitErr != nil &&
+			!strings.Contains(waitErr.Error(), "killed") &&
+			!strings.Contains(waitErr.Error(), "signal: killed") {
+			GinkgoWriter.Println("port-forward exited:", waitErr)
+		}
+	}()
+
+	select {
+	case <-ready:
+	case <-time.After(60 * time.Second):
+		Fail("timed out waiting for port-forward to be ready")
+	}
+
+	return func() {
+		if cmd.Process != nil {
+			_ = cmd.Process.Kill()
+		}
+	}
+}
+
+// LogInToArgoCDInstanceWithoutRoute logs in to an ArgoCD instance via kubectl
 func RunArgoCDCLI(args ...string) (string, error) {
 
 	cmdArgs := append([]string{"argocd"}, args...)

test/openshift/e2e/ginkgo/fixture/fixture.go

@@ -274,6 +274,16 @@ func CreateRandomE2ETestNamespaceWithCleanupFunc() (*corev1.Namespace, func()) {
 	return ns, nsDeletionFunc(ns)
 }
 
+// CreateNamespaceWithArgoCDInstance creates a random namespace, creates an ArgoCD instance with
+// the given name in it, waits for it to be available, and returns the ArgoCD, namespace, and a
+// cleanup func that deletes the namespace.
+func CreateNamespaceWithArgoCDInstance(instanceName string) (*argov1beta1api.ArgoCD, *corev1.Namespace, func()) {
+	ns, cleanupFunc := CreateRandomE2ETestNamespaceWithCleanupFunc()
+	argoCDInstance := argocdFixture.CreateNewArgoCDInstance(instanceName, ns.Name)
+	Eventually(argoCDInstance, "5m", "5s").Should(argocdFixture.BeAvailable())
+	return argoCDInstance, ns, cleanupFunc
+}
+
 // Create namespace for tests having a specific label for identification
 // - If the namespace already exists, it will be deleted first
 func CreateNamespace(name string) *corev1.Namespace {
@@ -671,7 +681,7 @@ func WaitForAllDeploymentsInTheNamespaceToBeReady(ns string, k8sClient client.Cl
 		// All Deployments in NS are reconciled and ready
 		return true
 
-	}, "3m", "1s").Should(BeTrue())
+	}, "5m", "1s").Should(BeTrue())
 
 	// The above logic will successfully wait for Deployments to be ready. However, this does not mean that the operator's controller logic has completed it's initial cluster reconciliation logic (starting a watch then reconciling existing resources)
 	// - I'm not aware of a way to detect when this has completed, so instead I am inserting a 15 second pause.

test/openshift/e2e/ginkgo/parallel/1-003_alpha_to_beta_sso_conflict_conversion_test.go

@@ -49,11 +49,6 @@ var _ = Describe("GitOps Operator Parallel E2E Tests", func() {
 
 		It("verifies expected behaviour of ArgoCD CR when dex and keycloak are both specified in v1alpha1 API", Label("openshift"), func() {
 
-			if fixture.EnvLocalRun() {
-				Skip("Conversion via webhook requires the operator to be running on the openshift cluster, which is not the case for a local or on xKS cluster")
-				return
-			}
-
 			ns, nsCleanup := fixture.CreateRandomE2ETestNamespaceWithCleanupFunc()
 			defer nsCleanup()
 

test/openshift/e2e/ginkgo/parallel/1-063_validate_dex_liveness_probe_test.go

@@ -19,19 +19,23 @@ package parallel
 import (
 	"context"
 
+	argov1beta1api "github.com/argoproj-labs/argocd-operator/api/v1beta1"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	"github.com/redhat-developer/gitops-operator/test/openshift/e2e/ginkgo/fixture"
 	argocdFixture "github.com/redhat-developer/gitops-operator/test/openshift/e2e/ginkgo/fixture/argocd"
+	k8sFixture "github.com/redhat-developer/gitops-operator/test/openshift/e2e/ginkgo/fixture/k8s"
 	fixtureUtils "github.com/redhat-developer/gitops-operator/test/openshift/e2e/ginkgo/fixture/utils"
+	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 var _ = Describe("GitOps Operator Parallel E2E Tests", func() {
-	// TODO: make it XKS compatible
-	Context("1-063_validate_dex_liveness_probe_test", Label("openshift"), func() {
+
+	Context("1-063_validate_dex_liveness_probe_test", func() {
 
 		var (
 			k8sClient client.Client
@@ -45,76 +49,51 @@ var _ = Describe("GitOps Operator Parallel E2E Tests", func() {
 			ctx = context.Background()
 		})
 
-		It("verifies dex server Pod has expected liveness probe values", func() {
-
-			By("verifying Argo CD is ready")
-			argoCD, err := argocdFixture.GetOpenShiftGitOpsNSArgoCD()
-			Expect(err).ToNot(HaveOccurred())
+		It("verifies dex server has expected liveness probe values", func() {
+
+			By("creating an Argo CD instance with Dex SSO enabled")
+			ns, cleanupFunc := fixture.CreateRandomE2ETestNamespaceWithCleanupFunc()
+			defer cleanupFunc()
+
+			argoCD := &argov1beta1api.ArgoCD{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "argocd",
+					Namespace: ns.Name,
+				},
+				Spec: argov1beta1api.ArgoCDSpec{
+					SSO: &argov1beta1api.ArgoCDSSOSpec{
+						Provider: argov1beta1api.SSOProviderTypeDex,
+						Dex: &argov1beta1api.ArgoCDDexSpec{
+							Config: "test-config",
+						},
+					},
+				},
+			}
+			Expect(k8sClient.Create(ctx, argoCD)).To(Succeed())
+
+			By("waiting for ArgoCD CR to be reconciled and the instance to be ready")
 			Eventually(argoCD, "5m", "5s").Should(argocdFixture.BeAvailable())
 
-			By("verifying dex server Pod has expected liveness probe values")
-			Eventually(func() bool {
-
-				var podList corev1.PodList
-				if err := k8sClient.List(ctx, &podList, &client.ListOptions{Namespace: "openshift-gitops"}); err != nil {
-					GinkgoWriter.Println(err)
-					return false
-				}
-
-				var pod corev1.Pod
-				for idx := range podList.Items {
-					currPod := podList.Items[idx]
-					if val, exists := currPod.Labels["app.kubernetes.io/name"]; exists && val == "openshift-gitops-dex-server" {
-						pod = currPod
-						break
-					}
-				}
-
-				if len(pod.Spec.Containers) != 1 {
-					return false
-				}
-
-				container := pod.Spec.Containers[0]
-				livenessProbe := container.LivenessProbe
-				if livenessProbe == nil {
-					return false
-				}
-
-				if livenessProbe.FailureThreshold != int32(3) {
-					return false
-				}
-
-				httpGet := livenessProbe.HTTPGet
-				if (*httpGet).Path != "/healthz/live" {
-					return false
-				}
-
-				if (*httpGet).Port != intstr.FromInt(5558) {
-					return false
-				}
-				if (*httpGet).Scheme != corev1.URISchemeHTTP {
-					return false
-				}
-				if livenessProbe.InitialDelaySeconds != int32(60) {
-					return false
-				}
-
-				if livenessProbe.PeriodSeconds != int32(30) {
-					return false
-				}
-
-				if livenessProbe.SuccessThreshold != int32(1) {
-					return false
-				}
-
-				if livenessProbe.TimeoutSeconds != int32(1) {
-					return false
-				}
-
-				return true
-
-			}).Should(BeTrue())
-
+			By("verifying dex-server Deployment has expected liveness probe values")
+			depl := &appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: argoCD.Name + "-dex-server", Namespace: ns.Name}}
+			Eventually(depl).Should(k8sFixture.ExistByName())
+
+			Eventually(func(g Gomega) {
+				g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(depl), depl)).To(Succeed())
+				g.Expect(depl.Spec.Template.Spec.Containers).To(HaveLen(1))
+
+				livenessProbe := depl.Spec.Template.Spec.Containers[0].LivenessProbe
+				g.Expect(livenessProbe).ToNot(BeNil())
+				g.Expect(livenessProbe.FailureThreshold).To(Equal(int32(3)))
+				g.Expect(livenessProbe.HTTPGet).ToNot(BeNil())
+				g.Expect(livenessProbe.HTTPGet.Path).To(Equal("/healthz/live"))
+				g.Expect(livenessProbe.HTTPGet.Port).To(Equal(intstr.FromInt(5558)))
+				g.Expect(livenessProbe.HTTPGet.Scheme).To(Equal(corev1.URISchemeHTTP))
+				g.Expect(livenessProbe.InitialDelaySeconds).To(Equal(int32(60)))
+				g.Expect(livenessProbe.PeriodSeconds).To(Equal(int32(30)))
+				g.Expect(livenessProbe.SuccessThreshold).To(Equal(int32(1)))
+				g.Expect(livenessProbe.TimeoutSeconds).To(Equal(int32(1)))
+			}).Should(Succeed())
 		})
 
 	})

test/openshift/e2e/ginkgo/parallel/1-075_validate_dex_anyuid_test.go

@@ -51,7 +51,7 @@ var _ = Describe("GitOps Operator Parallel E2E Tests", func() {
 			ctx = context.Background()
 		})
 
-		It("validates that dex runs when serviceaccount has anyuid SCC", Label("openshift"), func() {
+		It("validates that dex runs when serviceaccount has anyuid SCC", func() {
 
 			By("creating an Argo CD instance with Dex OpenShift Auth enabled")
 			ns, cleanupFunc := fixture.CreateRandomE2ETestNamespaceWithCleanupFunc()