test: update e2e implementation

Signed-off-by: Jayendra Parsai <jparsai@redhat.com>

Author: jparsai

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

@@ -568,13 +568,3 @@ func buildDefaultSANs(serviceName, namespace string) []string {
 		fmt.Sprintf("%s.%s.svc.cluster.local", serviceName, namespace),
 	}
 }
-
-// GetInitialAdminSecretPassword reads the admin password from the ArgoCD instance's cluster secret
-func GetInitialAdminSecretPassword(argocdCRName, secretNS string, k8sClient client.Client) string {
-	secret := &corev1.Secret{}
-	Expect(k8sClient.Get(context.Background(), types.NamespacedName{
-		Name:      fmt.Sprintf("%s-cluster", argocdCRName),
-		Namespace: secretNS,
-	}, secret)).To(Succeed())
-	return string(secret.Data["admin.password"])
-}

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

@@ -17,7 +17,6 @@ limitations under the License.
 package argocdclient
 
 import (
-	"bytes"
 	"crypto/tls"
 	"encoding/json"
 	"errors"
@@ -33,72 +32,6 @@ import (
 	"github.com/gorilla/websocket"
 )
 
-type ArgoRestClient struct {
-	endpoint string
-	username string
-	password string
-	token    string
-	client   *http.Client
-}
-
-// NewArgoClient returns a new client for Argo CD's REST API
-func NewArgoClient(endpoint, username, password string) *ArgoRestClient {
-	ac := &ArgoRestClient{
-		endpoint: endpoint,
-		username: username,
-		password: password,
-		client: &http.Client{
-			Transport: &http.Transport{
-				TLSClientConfig: &tls.Config{
-					InsecureSkipVerify: true, // #nosec G402
-				},
-			},
-		},
-	}
-	return ac
-}
-
-// Login creates a new Argo CD session
-func (c *ArgoRestClient) Login() error {
-	// Get session token from API
-	authStr := fmt.Sprintf(`{"username": "%s", "password": "%s"}`, c.username, c.password)
-	payload := io.NopCloser(bytes.NewReader([]byte(authStr)))
-	res, err := c.client.Do(&http.Request{
-		Method:        http.MethodPost,
-		URL:           &url.URL{Scheme: "https", Host: c.endpoint, Path: "/api/v1/session"},
-		Body:          payload,
-		Header:        http.Header{"Content-Type": []string{"application/json"}},
-		ContentLength: int64(len(authStr)),
-	})
-	if err != nil {
-		return err
-	}
-	defer func() {
-		_ = res.Body.Close()
-	}()
-	if res.StatusCode != 200 {
-		return fmt.Errorf("expected HTTP 200, got %d", res.StatusCode)
-	}
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return err
-	}
-
-	type tokenResponse struct {
-		Token string `json:"token"`
-	}
-	token := &tokenResponse{}
-	err = json.Unmarshal(body, token)
-	if err != nil {
-		return err
-	}
-	if token.Token == "" {
-		return errors.New("empty token received")
-	}
-	c.token = token.Token
-	return nil
-}
-
 // TerminalClient represents a test client for terminal WebSocket connections.
 type TerminalClient struct {
 	wsConn   *websocket.Conn
@@ -111,15 +44,10 @@ type TerminalClient struct {
 // ExecTerminal opens a terminal session to a pod via WebSocket.
 // This replicates the behavior of the ArgoCD UI when a user opens a terminal session to an application.
 // ArgoCD decides which shell to use based on the configured allowed shells.
-func (c *ArgoRestClient) ExecTerminal(app *v1alpha1.Application, namespace, podName, container string) (*TerminalClient, error) {
-	if err := c.ensureToken(); err != nil {
-		return nil, err
-	}
-
-	// Build the exec URL
+func ExecTerminal(endpoint, token string, app *v1alpha1.Application, namespace, podName, container string) (*TerminalClient, error) {
 	u := &url.URL{
 		Scheme: "wss",
-		Host:   c.endpoint,
+		Host:   endpoint,
 		Path:   "/terminal",
 	}
 
@@ -132,18 +60,15 @@ func (c *ArgoRestClient) ExecTerminal(app *v1alpha1.Application, namespace, podN
 	q.Set("namespace", namespace)
 	u.RawQuery = q.Encode()
 
-	// Create WebSocket dialer with TLS config
 	dialer := websocket.Dialer{
 		TLSClientConfig: &tls.Config{
 			InsecureSkipVerify: true, // #nosec G402
 		},
 	}
 
-	// Set token as cookie - ArgoCD expects auth token in argocd.token cookie
 	headers := http.Header{}
-	headers.Set("Cookie", fmt.Sprintf("argocd.token=%s", c.token))
+	headers.Set("Cookie", fmt.Sprintf("argocd.token=%s", token))
 
-	// Connect to WebSocket
 	wsConn, resp, err := dialer.Dial(u.String(), headers)
 	if err != nil {
 		if resp != nil {
@@ -158,20 +83,11 @@ func (c *ArgoRestClient) ExecTerminal(app *v1alpha1.Application, namespace, podN
 		wsConn: wsConn,
 	}
 
-	// Start reading output in background
 	go session.readOutput()
 
 	return session, nil
 }
 
-// ensureToken makes sure we have a valid authentication token
-func (c *ArgoRestClient) ensureToken() error {
-	if c.token == "" {
-		return c.Login()
-	}
-	return nil
-}
-
 // terminalMessage is the JSON message format used by ArgoCD terminal WebSocket
 type terminalMessage struct {
 	Operation string `json:"operation"`

test/openshift/e2e/ginkgo/sequential/1-053_validate_argocd_agent_principal_connected_test.go

@@ -516,7 +516,7 @@ var _ = Describe("GitOps Operator Sequential E2E Tests", func() {
 		It("Should deploy ArgoCD principal and agent instances in both modes and verify they are working as expected", func() {
 
 			By("Deploy principal and verify it starts successfully")
-			deployPrincipal(ctx, k8sClient, registerCleanup)
+			deployPrincipal(ctx, k8sClient, registerCleanup, false)
 
 			By("Deploy managed agent and verify it starts successfully")
 			deployAgent(ctx, k8sClient, registerCleanup, argov1beta1api.AgentModeManaged)
@@ -609,7 +609,7 @@ var _ = Describe("GitOps Operator Sequential E2E Tests", func() {
 // This function deploys the principal ArgoCD instance and waits for it to be ready.
 // It creates the required secrets for the principal and verifies that the principal deployment is in Ready state.
 // It also verifies that the principal logs contain the expected messages.
-func deployPrincipal(ctx context.Context, k8sClient client.Client, registerCleanup func(func()), enableServerRoute ...bool) {
+func deployPrincipal(ctx context.Context, k8sClient client.Client, registerCleanup func(func()), enableServerRoute bool) {
 	GinkgoHelper()
 
 	nsPrincipal, cleanup := fixture.CreateNamespaceWithCleanupFunc(namespaceAgentPrincipal)
@@ -624,7 +624,7 @@ func deployPrincipal(ctx context.Context, k8sClient client.Client, registerClean
 		waitForLoadBalancer = false
 	}
 
-	if len(enableServerRoute) > 0 && enableServerRoute[0] {
+	if enableServerRoute {
 		argoCDInstance.Spec.Server.Route = argov1beta1api.ArgoCDRouteSpec{
 			Enabled: true,
 		}

…_argocd_agent_terminal_streaming_test.go …_argocd_agent_terminal_streaming_test.gotest/openshift/e2e/ginkgo/sequential/1-054_validate_argocd_agent_terminal_streaming_test.go renamed to test/openshift/e2e/ginkgo/sequential/1-059_validate_argocd_agent_terminal_streaming_test.go test/openshift/e2e/ginkgo/sequential/1-054_validate_argocd_agent_terminal_streaming_test.go renamed to test/openshift/e2e/ginkgo/sequential/1-059_validate_argocd_agent_terminal_streaming_test.go

@@ -37,6 +37,7 @@ import (
 	"github.com/argoproj/gitops-engine/pkg/health"
 
 	argov1beta1api "github.com/argoproj-labs/argocd-operator/api/v1beta1"
+	argocdFixture "github.com/argoproj-labs/argocd-operator/tests/ginkgo/fixture/argocd"
 
 	routev1 "github.com/openshift/api/route/v1"
 
@@ -51,7 +52,7 @@ import (
 // This test validates that terminal streaming works through the ArgoCD agent architecture
 // on OpenShift. It exercises the full terminal flow:
 var _ = Describe("GitOps Operator Sequential E2E Tests", func() {
-	Context("1-054_validate_argocd_agent_terminal_streaming", func() {
+	Context("1-059_validate_argocd_agent_terminal_streaming", func() {
 		var (
 			k8sClient       client.Client
 			ctx             context.Context
@@ -218,9 +219,10 @@ var _ = Describe("GitOps Operator Sequential E2E Tests", func() {
 			argoEndpoint := serverRoute.Spec.Host
 			GinkgoWriter.Printf("ArgoCD server Route host: %s\n", argoEndpoint)
 
-			password := agentFixture.GetInitialAdminSecretPassword(argoCDAgentInstanceNamePrincipal, namespaceAgentPrincipal, k8sClient)
-			argoClient := argocdClient.NewArgoClient(argoEndpoint, "admin", password)
-			Expect(argoClient.Login()).To(Succeed())
+			password := argocdFixture.GetInitialAdminSecretPassword(argoCDAgentInstanceNamePrincipal, namespaceAgentPrincipal, k8sClient)
+			_, sessionToken, closer, err := argocdFixture.CreateArgoCDAPIClient(ctx, argoEndpoint, password)
+			Expect(err).ToNot(HaveOccurred())
+			defer closer.Close()
 
 			// Find the application pod which we want to open a terminal session for.
 			By("Find a running pod in the application namespace")
@@ -257,14 +259,14 @@ var _ = Describe("GitOps Operator Sequential E2E Tests", func() {
 			var session *argocdClient.TerminalClient
 			Eventually(func() error {
 				var err error
-				session, err = argoClient.ExecTerminal(application, managedAgentApplicationNamespace, podName, containerName)
+				session, err = argocdClient.ExecTerminal(argoEndpoint, sessionToken, application, managedAgentApplicationNamespace, podName, containerName)
 				return err
 			}, "30s", "5s").Should(Succeed(), "failed to open terminal session")
 			defer session.Close()
 
 			// Send a resize message first, this is required by the shell to render the
 			// output content accordingly.
-			err := session.SendResize(80, 24)
+			err = session.SendResize(80, 24)
 			Expect(err).ToNot(HaveOccurred(), "failed to send resize")
 
 			// Wait for shell to initialize by checking for any output