github.com/verrazzano/verrazzano@v1.7.1/tests/e2e/scripts/install/install_test.go

// Copyright (c) 2021, 2023, Oracle and/or its affiliates.
// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

package install

import (
	"context"
	"fmt"
	vzconst "github.com/verrazzano/verrazzano/platform-operator/constants"
	"os"
	"strings"
	"time"

	"github.com/verrazzano/verrazzano/pkg/constants"
	vzapi "github.com/verrazzano/verrazzano/platform-operator/apis/verrazzano/v1beta1"
	"github.com/verrazzano/verrazzano/tests/e2e/pkg/test/framework"

	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	"github.com/verrazzano/verrazzano/tests/e2e/pkg"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

const (
	waitTimeout     = 5 * time.Minute
	pollingInterval = 5 * time.Second
)

var kubeConfigFromEnv = os.Getenv("KUBECONFIG")

var t = framework.NewTestFramework("install")

var beforeSuite = t.BeforeSuiteFunc(func() {})
var _ = BeforeSuite(beforeSuite)
var afterSuite = t.AfterSuiteFunc(func() {})
var _ = AfterSuite(afterSuite)
var _ = t.AfterEach(func() {})

// This test checks that the Verrazzano install resource has the expected console URLs.
var _ = t.Describe("Verify Verrazzano install scripts.", Label("f:platform-lcm.install"), func() {

	t.Context("Check", Label("f:ui.console"), func() {
		t.It("the expected Console URLs are there in the installed Verrazzano resource", func() {
			// Validation for passed in cluster
			Eventually(func() bool {
				return validateConsoleUrlsCluster(kubeConfigFromEnv)
			}, waitTimeout, pollingInterval).Should(BeTrue())
		})
	})
})

// Validate the console URLs for the admin cluster and single cluster installation
func validateConsoleUrlsCluster(kubeconfig string) bool {
	consoleUrls, err := getConsoleURLsFromResource(kubeconfig)
	if err != nil {
		t.Logs.Errorf("There is an error getting console URLs from the installed Verrazzano resource - %v", err)
		return false
	}
	expectedConsoleUrls, err := getExpectedConsoleURLs(kubeconfig)
	if err != nil {
		t.Logs.Errorf("There is an error getting console URLs from ingress resources - %v", err)
		return false
	}
	t.Logs.Infof("Expected URLs based on ingresses: %v", expectedConsoleUrls)
	t.Logs.Infof("Actual URLs in Verrazzano resource: %v", consoleUrls)

	return pkg.SlicesContainSameStrings(consoleUrls, expectedConsoleUrls)
}

// Get the list of console URLs from the status block of the installed Verrazzano resource
func getConsoleURLsFromResource(kubeconfig string) ([]string, error) {
	var consoleUrls []string
	vz, err := pkg.GetVerrazzanoInstallResourceInClusterV1beta1(kubeconfig)
	if err != nil {
		return consoleUrls, err
	}

	if vz.Status.VerrazzanoInstance.ConsoleURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.ConsoleURL)
	}
	if vz.Status.VerrazzanoInstance.GrafanaURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.GrafanaURL)
	}
	if vz.Status.VerrazzanoInstance.OpenSearchURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.OpenSearchURL)
	}
	if vz.Status.VerrazzanoInstance.KeyCloakURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.KeyCloakURL)
	}
	if vz.Status.VerrazzanoInstance.OpenSearchDashboardsURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.OpenSearchDashboardsURL)
	}
	if vz.Status.VerrazzanoInstance.KialiURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.KialiURL)
	}
	if vz.Status.VerrazzanoInstance.PrometheusURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.PrometheusURL)
	}
	if vz.Status.VerrazzanoInstance.RancherURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.RancherURL)
	}
	if vz.Status.VerrazzanoInstance.JaegerURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.JaegerURL)
	}
	if vz.Status.VerrazzanoInstance.ArgoCDURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.ArgoCDURL)
	}
	if vz.Status.VerrazzanoInstance.ThanosQueryURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.ThanosQueryURL)
	}
	if vz.Status.VerrazzanoInstance.ThanosRulerURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.ThanosRulerURL)
	}
	if vz.Status.VerrazzanoInstance.AlertmanagerURL != nil {
		consoleUrls = append(consoleUrls, *vz.Status.VerrazzanoInstance.AlertmanagerURL)
	}

	return consoleUrls, nil
}

// Get the expected console URLs for the given cluster from the ingress resources
func getExpectedConsoleURLs(kubeConfig string) ([]string, error) {
	var expectedUrls []string
	clientset, err := pkg.GetKubernetesClientsetForCluster(kubeConfig)
	if err != nil {
		return expectedUrls, err
	}
	ingresses, err := clientset.NetworkingV1().Ingresses("").List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		return expectedUrls, err
	}

	consoleURLExpected, err := isConsoleURLExpected(kubeConfig)
	if err != nil {
		return expectedUrls, err
	}

	for _, ingress := range ingresses.Items {
		ingressHost := ingress.Spec.Rules[0].Host
		// elasticsearch and kibana ingresses are created for permanent redirection when upgraded from older VZ releases to 1.5.0 or later.
		// The Thanos Store API endpoints are not stored in the Verrazzano instance and can be ignored
		// The Dex endpoint doesn't need to be exposed as a console URL
		if strings.HasPrefix(ingressHost, "elasticsearch") ||
			strings.HasPrefix(ingressHost, "kibana") ||
			strings.HasPrefix(ingressHost, "thanos-query-store") ||
			strings.HasPrefix(ingressHost, vzconst.DexHostPrefix) {
			continue
		}
		// Any verrazzano-managed ingresses in the Rancher namespace are created for managed clusters to be
		// able to use an older DNS name to connect to Rancher proxy until the managed clusters are updated.
		// Those will not exist in the VZ resource.
		if ingress.Namespace == constants.RancherSystemNamespace && pkg.IsVerrazzanoManaged(ingress.Labels) {
			continue
		}
		// If it's not the console ingress, or it is and the console is enabled, add it to the expected set of URLs
		if !isConsoleIngressHost(ingressHost) || consoleURLExpected {
			expectedUrls = append(expectedUrls, fmt.Sprintf("https://%s", ingressHost))
		}
	}

	return expectedUrls, nil
}

// isConsoleIngressHost - Returns true if the given ingress host is the one for the VZ UI console
func isConsoleIngressHost(ingressHost string) bool {
	return strings.HasPrefix(ingressHost, "verrazzano.")
}

// isConsoleURLExpected - Returns true in VZ < 1.1.1. For VZ >= 1.1.1, returns false only if explicitly disabled
// in the CR or when managed cluster profile is used
func isConsoleURLExpected(kubeconfigPath string) (bool, error) {
	isAtleastVz111, err := pkg.IsVerrazzanoMinVersion("1.1.1", kubeconfigPath)
	if err != nil {
		return false, err
	}
	// Pre 1.1.1, the console URL was always present irrespective of whether console is enabled
	// This behavior changed in VZ 1.1.1
	if !isAtleastVz111 {
		return true, nil
	}

	// In 1.1.1 and later, the console URL will only be present in the VZ status instance info if the console is enabled
	vz, err := pkg.GetVerrazzanoInstallResourceInClusterV1beta1(kubeconfigPath)
	if err != nil {
		return false, err
	}
	// Return the value of the Console enabled flag if present
	if vz != nil && vz.Spec.Components.Console != nil && vz.Spec.Components.Console.Enabled != nil {
		return *vz.Spec.Components.Console.Enabled, nil
	}
	// otherwise, expect console to be enabled for all profiles but managed-cluster
	return vz.Spec.Profile != vzapi.ManagedCluster, nil
}