Removed dependency on kubectl binary

Signed-off-by: Anand Francis Joseph <anjoseph@redhat.com>

Author: anandf

tests/ginkgo/fixture/application/fixture.go

@@ -1,6 +1,7 @@
 package application
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"os/exec"
@@ -9,10 +10,20 @@ import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	matcher "github.com/onsi/gomega/types"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
 
 	argocdFixture "github.com/argoproj-labs/argocd-operator/tests/ginkgo/fixture/argocd"
+	fixtureUtils "github.com/argoproj-labs/argocd-operator/tests/ginkgo/fixture/utils"
 )
 
+var applicationGVR = schema.GroupVersionResource{
+	Group:    "argoproj.io",
+	Version:  "v1alpha1",
+	Resource: "applications",
+}
+
 // AppRef is a lightweight reference to an Argo CD Application.
 type AppRef struct {
 	Name      string
@@ -135,7 +146,7 @@ func WithSession(s *argocdFixture.Session) AppOption {
 	return func(c *appConfig) { c.session = s }
 }
 
-// Create creates an Argo CD Application using the argocd CLI in login mode.
+// Create creates an Argo CD Application using the argocd CLI.
 func Create(name, namespace string, opts ...AppOption) *AppRef {
 	cfg := &appConfig{}
 	for _, o := range opts {
@@ -150,38 +161,58 @@ func Create(name, namespace string, opts ...AppOption) *AppRef {
 
 	ref := &AppRef{Name: name, Namespace: namespace, session: cfg.session}
 
-	// Post-create: annotations via kubectl
-	for k, v := range cfg.annotations {
-		out, err := runKubectl("annotate", "application.argoproj.io", name, "-n", namespace,
-			fmt.Sprintf("%s=%s", k, v))
-		Expect(err).ToNot(HaveOccurred(), "kubectl annotate failed: %s", out)
+	// Post-create: apply annotations, labels, and managed namespace metadata via k8s client
+	if len(cfg.annotations) > 0 || len(cfg.labels) > 0 || len(cfg.managedNSLabels) > 0 {
+		patchApp(name, namespace, cfg.annotations, cfg.labels, cfg.managedNSLabels)
 	}
 
-	// Post-create: labels via kubectl
-	for k, v := range cfg.labels {
-		out, err := runKubectl("label", "application.argoproj.io", name, "-n", namespace,
-			fmt.Sprintf("%s=%s", k, v))
-		Expect(err).ToNot(HaveOccurred(), "kubectl label failed: %s", out)
+	return ref
+}
+
+// patchApp applies annotations, labels, and managed namespace metadata to an Application using the k8s client.
+func patchApp(name, namespace string, annotations, labels map[string]string, managedNSLabels map[string]string) {
+	k8sClient, _ := fixtureUtils.GetE2ETestKubeClient()
+	ctx := context.Background()
+
+	app := &unstructured.Unstructured{}
+	app.SetGroupVersionKind(applicationGVR.GroupVersion().WithKind("Application"))
+	Expect(k8sClient.Get(ctx, types.NamespacedName{Name: name, Namespace: namespace}, app)).To(Succeed(), "failed to get Application %s/%s", namespace, name)
+
+	if len(annotations) > 0 {
+		existing := app.GetAnnotations()
+		if existing == nil {
+			existing = make(map[string]string)
+		}
+		for k, v := range annotations {
+			existing[k] = v
+		}
+		app.SetAnnotations(existing)
 	}
 
-	// Post-create: managed namespace metadata labels via kubectl patch
-	if len(cfg.managedNSLabels) > 0 {
-		patch := map[string]any{
-			"spec": map[string]any{
-				"syncPolicy": map[string]any{
-					"managedNamespaceMetadata": map[string]any{
-						"labels": cfg.managedNSLabels,
-					},
-				},
-			},
+	if len(labels) > 0 {
+		existing := app.GetLabels()
+		if existing == nil {
+			existing = make(map[string]string)
 		}
-		patchBytes, _ := json.Marshal(patch)
-		out, err := runKubectl("patch", "application.argoproj.io", name, "-n", namespace,
-			"--type=merge", "-p", string(patchBytes))
-		Expect(err).ToNot(HaveOccurred(), "kubectl patch failed: %s", out)
+		for k, v := range labels {
+			existing[k] = v
+		}
+		app.SetLabels(existing)
 	}
 
-	return ref
+	if len(managedNSLabels) > 0 {
+		spec, _, _ := unstructured.NestedMap(app.Object, "spec")
+		if spec == nil {
+			spec = map[string]interface{}{}
+		}
+		labelsMap := make(map[string]interface{}, len(managedNSLabels))
+		for k, v := range managedNSLabels {
+			labelsMap[k] = v
+		}
+		Expect(unstructured.SetNestedField(app.Object, labelsMap, "spec", "syncPolicy", "managedNamespaceMetadata", "labels")).To(Succeed())
+	}
+
+	Expect(k8sClient.Update(ctx, app)).To(Succeed(), "failed to update Application %s/%s", namespace, name)
 }
 
 // Delete deletes an Argo CD Application.
@@ -192,7 +223,7 @@ func Delete(ref *AppRef) {
 }
 
 // Ref creates a reference to an existing Application without creating it.
-// Session is optional — when nil, kubectl is used for get operations (matchers).
+// Session is optional — when nil, argocd CLI get falls back to the k8s client.
 func Ref(name, namespace string, sessions ...*argocdFixture.Session) *AppRef {
 	var session *argocdFixture.Session
 	if len(sessions) > 0 {
@@ -311,11 +342,14 @@ func getAppJSON(ref *AppRef) (map[string]any, error) {
 			return nil, fmt.Errorf("argocd app get failed: %v, output: %s", err, output)
 		}
 	} else {
-		// No session — use kubectl directly (for Ref-only usage without CLI login)
-		output, err = runKubectl("get", "application.argoproj.io", ref.Name, "-n", ref.Namespace, "-o", "json")
-		if err != nil {
-			return nil, fmt.Errorf("kubectl get application failed: %v, output: %s", err, output)
+		// No session — use k8s client directly (for Ref-only usage without CLI login)
+		k8sClient, _ := fixtureUtils.GetE2ETestKubeClient()
+		app := &unstructured.Unstructured{}
+		app.SetGroupVersionKind(applicationGVR.GroupVersion().WithKind("Application"))
+		if err := k8sClient.Get(context.Background(), types.NamespacedName{Name: ref.Name, Namespace: ref.Namespace}, app); err != nil {
+			return nil, fmt.Errorf("k8s client get application failed: %v", err)
 		}
+		return app.Object, nil
 	}
 
 	var result map[string]any
@@ -353,12 +387,3 @@ func runArgoCDCLI(session *argocdFixture.Session, args ...string) (string, error
 	GinkgoWriter.Println(string(output))
 	return string(output), err
 }
-
-func runKubectl(args ...string) (string, error) {
-	GinkgoWriter.Println("executing kubectl", args)
-	// #nosec G204 -- test code
-	cmd := exec.Command("kubectl", args...)
-	output, err := cmd.CombinedOutput()
-	GinkgoWriter.Println(string(output))
-	return string(output), err
-}

tests/ginkgo/fixture/appproject/fixture.go

@@ -1,10 +1,8 @@
 package appproject
 
 import (
-	"encoding/json"
 	"fmt"
 	"os/exec"
-	"strings"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -65,27 +63,17 @@ func WithSession(s *argocdFixture.Session) ProjOption {
 	return func(c *projConfig) { c.session = s }
 }
 
-// Create creates an Argo CD AppProject.
-// Uses kubectl for projects with DestinationServiceAccounts (not supported by argocd CLI).
+// Create creates an Argo CD AppProject via the argocd CLI.
 func Create(name, namespace string, opts ...ProjOption) *ProjRef {
 	cfg := &projConfig{}
 	for _, o := range opts {
 		o(cfg)
 	}
 
-	ref := &ProjRef{Name: name, Namespace: namespace, session: cfg.session}
-
-	if len(cfg.destinationServiceAccounts) > 0 {
-		createViaKubectl(name, namespace, cfg)
-	} else {
-		Expect(cfg.session).ToNot(BeNil(), "WithSession is required for appproject.Create via CLI")
-		createViaCLI(name, namespace, cfg)
-	}
+	Expect(cfg.session).ToNot(BeNil(), "WithSession is required for appproject.Create")
 
-	return ref
-}
+	ref := &ProjRef{Name: name, Namespace: namespace, session: cfg.session}
 
-func createViaCLI(name, namespace string, cfg *projConfig) {
 	args := []string{"proj", "create", name}
 	for _, repo := range cfg.sourceRepos {
 		args = append(args, "--src", repo)
@@ -96,6 +84,9 @@ func createViaCLI(name, namespace string, cfg *projConfig) {
 	for _, cr := range cfg.clusterResources {
 		args = append(args, "--allow-cluster-resource", fmt.Sprintf("%s/%s", cr[0], cr[1]))
 	}
+	for _, d := range cfg.destinationServiceAccounts {
+		args = append(args, "--dest-service-accounts", fmt.Sprintf("%s,%s,%s", d.Server, d.Namespace, d.Account))
+	}
 
 	output, err := runArgoCDCLI(cfg.session, args...)
 	Expect(err).ToNot(HaveOccurred(), "argocd proj create failed: %s", output)
@@ -105,62 +96,8 @@ func createViaCLI(name, namespace string, cfg *projConfig) {
 		out, err := runArgoCDCLI(cfg.session, "proj", "add-source-namespace", name, ns)
 		Expect(err).ToNot(HaveOccurred(), "argocd proj add-source-namespace failed: %s", out)
 	}
-}
-
-func createViaKubectl(name, namespace string, cfg *projConfig) {
-	spec := map[string]any{}
-
-	if len(cfg.sourceRepos) > 0 {
-		spec["sourceRepos"] = cfg.sourceRepos
-	}
-
-	if len(cfg.destinations) > 0 {
-		dests := make([]map[string]string, len(cfg.destinations))
-		for i, d := range cfg.destinations {
-			dests[i] = map[string]string{"server": d[0], "namespace": d[1]}
-		}
-		spec["destinations"] = dests
-	}
-
-	if len(cfg.clusterResources) > 0 {
-		crs := make([]map[string]string, len(cfg.clusterResources))
-		for i, cr := range cfg.clusterResources {
-			crs[i] = map[string]string{"group": cr[0], "kind": cr[1]}
-		}
-		spec["clusterResourceWhitelist"] = crs
-	}
 
-	if len(cfg.destinationServiceAccounts) > 0 {
-		dsas := make([]map[string]string, len(cfg.destinationServiceAccounts))
-		for i, d := range cfg.destinationServiceAccounts {
-			dsas[i] = map[string]string{
-				"server":                d.Server,
-				"namespace":             d.Namespace,
-				"defaultServiceAccount": d.Account,
-			}
-		}
-		spec["destinationServiceAccounts"] = dsas
-	}
-
-	if len(cfg.sourceNamespaces) > 0 {
-		spec["sourceNamespaces"] = cfg.sourceNamespaces
-	}
-
-	resource := map[string]any{
-		"apiVersion": "argoproj.io/v1alpha1",
-		"kind":       "AppProject",
-		"metadata": map[string]any{
-			"name":      name,
-			"namespace": namespace,
-		},
-		"spec": spec,
-	}
-
-	jsonBytes, err := json.Marshal(resource)
-	Expect(err).ToNot(HaveOccurred())
-
-	out, err := runKubectlWithStdin(string(jsonBytes), "apply", "-f", "-")
-	Expect(err).ToNot(HaveOccurred(), "kubectl apply failed: %s", out)
+	return ref
 }
 
 // AddDestination adds a destination to an existing AppProject.
@@ -198,13 +135,3 @@ func runArgoCDCLI(session *argocdFixture.Session, args ...string) (string, error
 	GinkgoWriter.Println(string(output))
 	return string(output), err
 }
-
-func runKubectlWithStdin(stdin string, args ...string) (string, error) {
-	GinkgoWriter.Println("executing kubectl", args)
-	// #nosec G204 -- test code
-	cmd := exec.Command("kubectl", args...)
-	cmd.Stdin = strings.NewReader(stdin)
-	output, err := cmd.CombinedOutput()
-	GinkgoWriter.Println(string(output))
-	return string(output), err
-}

tests/ginkgo/fixture/argocd/fixture.go

@@ -77,7 +77,7 @@ func findFreePort() int {
 	listener, err := net.Listen("tcp", "127.0.0.1:0")
 	Expect(err).ToNot(HaveOccurred(), "failed to find free port")
 	port := listener.Addr().(*net.TCPAddr).Port
-	listener.Close()
+	Expect(err).ToNot(HaveOccurred(), "error listening on port %d", port)
 	return port
 }