Merge remote-tracking branch 'upstream/main' into rhoai-3.2

Author: sutaakar

images/tests/.env-odh

@@ -1,3 +1,2 @@
-ODH_NAMESPACE=opendatahub
 FMS_HF_TUNING_IMAGE=quay.io/modh/fms-hf-tuning:release
 NOTEBOOK_IMAGE=quay.io/rhoai/odh-workbench-jupyter-datascience-cpu-py312-rhel9:rhoai-3.2

tests/common/environment.go

@@ -25,8 +25,6 @@ import (
 )
 
 const (
-	// The environment variable for namespace where ODH is installed to.
-	odhNamespaceEnvVar = "ODH_NAMESPACE"
 	// Name of the authenticated Notebook user
 	notebookUserName = "NOTEBOOK_USER_NAME"
 	// Token of the authenticated Notebook user
@@ -59,14 +57,6 @@ var testTiers = []string{tierSmoke, tierSanity, tier1, tier2, tier3, preUpgrade,
 
 var testTierParam string
 
-func GetOpenDataHubNamespace(t Test) string {
-	ns, ok := os.LookupEnv(odhNamespaceEnvVar)
-	if !ok {
-		t.T().Fatalf("Expected environment variable %s not found, please use this environment variable to specify namespace where ODH is installed to.", odhNamespaceEnvVar)
-	}
-	return ns
-}
-
 func GetNotebookUserName(t Test) string {
 	name, ok := os.LookupEnv(notebookUserName)
 	if !ok {

tests/common/notebook.go

@@ -147,13 +147,17 @@ func CreateNotebook(test Test, namespace *corev1.Namespace, notebookUserToken st
 		selectedContainerResources = SmallContainerResources // Fallback to Small container size
 	}
 
+	// Get the ODH namespace from DSCI
+	odhNamespace, err := GetApplicationsNamespaceFromDSCI(test, DefaultDSCIName)
+	test.Expect(err).NotTo(gomega.HaveOccurred())
+
 	// Read the Notebook CR from resources and perform replacements for custom values using go template
 	notebookProps := NotebookProps{
 		IngressDomain:             GetOpenShiftIngressDomain(test),
 		OpenShiftApiUrl:           GetOpenShiftApiUrl(test),
 		KubernetesUserBearerToken: notebookUserToken,
 		Namespace:                 namespace.Name,
-		OpenDataHubNamespace:      GetOpenDataHubNamespace(test),
+		OpenDataHubNamespace:      odhNamespace,
 		Command:                   strCommand,
 		NotebookImage:             GetNotebookImage(test),
 		NotebookConfigMapName:     jupyterNotebookConfigMapName,

tests/common/support/config.go

@@ -55,19 +55,19 @@ func GetOpenShiftApiUrl(test Test) string {
 	return openShiftApiUrl
 }
 
-func GetExpectedRegistry(test Test, odhNamespace string) string {
+func GetExpectedRegistry(test Test, applicationsNamespace string) string {
 	test.T().Helper()
 
 	var registryName string
-	switch odhNamespace {
+	switch applicationsNamespace {
 	case "redhat-ods-applications":
 		registryName = "registry.redhat.io"
 	case "opendatahub":
 		registryName = "quay.io"
 	default:
-		test.T().Fatalf("Unknown ODH namespace: %s. Expected 'redhat-ods-applications' for RHOAI operator or 'opendatahub' ODH operator.", odhNamespace)
+		test.T().Fatalf("Unknown namespace: %s. Expected 'redhat-ods-applications' for RHOAI operator or 'opendatahub' ODH operator.", applicationsNamespace)
 	}
 
-	test.T().Logf("ODH namespace '%s' is using registry: %s", odhNamespace, registryName)
+	test.T().Logf("Namespace '%s' is using registry: %s", applicationsNamespace, registryName)
 	return registryName
 }

tests/common/support/dscInitialization.go

@@ -0,0 +1,52 @@
+/*
+Copyright 2025.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package support
+
+import (
+	"fmt"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+const DefaultDSCIName = "default-dsci"
+
+var DsciGVR = schema.GroupVersionResource{
+	Group:    "dscinitialization.opendatahub.io",
+	Version:  "v2",
+	Resource: "dscinitializations",
+}
+
+func GetDSCI(test Test, name string) (*unstructured.Unstructured, error) {
+	return test.Client().Dynamic().Resource(DsciGVR).Get(test.Ctx(), name, metav1.GetOptions{})
+}
+
+func GetApplicationsNamespaceFromDSCI(test Test, dsciName string) (string, error) {
+	dsci, err := GetDSCI(test, dsciName)
+	if err != nil {
+		return "", err
+	}
+	namespace, found, err := unstructured.NestedString(dsci.Object, "spec", "applicationsNamespace")
+	if err != nil {
+		return "", fmt.Errorf("failed to get applicationsNamespace from DSCI %s: %w", dsciName, err)
+	}
+	if !found {
+		return "", fmt.Errorf("applicationsNamespace field not found in DSCI %s", dsciName)
+	}
+	return namespace, nil
+}

tests/kfto/kfto_smoke_test.go

@@ -12,21 +12,20 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
-	openshiftclient "github.com/openshift/client-go/config/clientset/versioned"
-
 	. "github.com/opendatahub-io/distributed-workloads/tests/common"
 	. "github.com/opendatahub-io/distributed-workloads/tests/common/support"
 )
 
 func TestKftoSmoke(t *testing.T) {
 	Tags(t, Smoke)
-	runSmoke(t, "kubeflow-training-operator", "odh-training-operator")
+	runSmoke(t, "kubeflow-training-operator", "odh-training-operator", "training-operator")
 }
 
 // runSmoke runs a smoke test for a given deployment and expected image name.
-func runSmoke(t *testing.T, deploymentName string, expectedImage string) {
+func runSmoke(t *testing.T, deploymentName string, rhoaiImage string, odhImage string) {
 	test := With(t)
-	namespace := GetOpenDataHubNamespace(test)
+	namespace, err := GetApplicationsNamespaceFromDSCI(test, DefaultDSCIName)
+	test.Expect(err).NotTo(HaveOccurred())
 
 	test.T().Logf("Waiting for %s deployment to be available ...", deploymentName)
 	test.Eventually(func(g Gomega, ctx context.Context) {
@@ -40,18 +39,8 @@ func runSmoke(t *testing.T, deploymentName string, expectedImage string) {
 
 	test.T().Logf("%s deployment is available", deploymentName)
 
-	// Determine registry based on cluster environment
-	configClient, err := openshiftclient.NewForConfig(test.Config())
-	test.Expect(err).NotTo(HaveOccurred())
-
-	infra, err := configClient.ConfigV1().Infrastructures().Get(test.Ctx(), "cluster", metav1.GetOptions{})
-	test.Expect(err).NotTo(HaveOccurred())
-
-	envType := infra.Labels["hypershift.openshift.io/managed"]
-	registryName := "registry.redhat.io"
-	if envType == "true" {
-		registryName = "quay.io"
-	}
+	// Determine registry based on namespace
+	registryName := GetExpectedRegistry(test, namespace)
 
 	test.T().Logf("Verifying %s container image is referred from expected registry ...", deploymentName)
 
@@ -78,7 +67,19 @@ func runSmoke(t *testing.T, deploymentName string, expectedImage string) {
 		test.T().FailNow()
 	}
 
+	var expectedImage string
+	switch registryName {
+	case "registry.redhat.io":
+		expectedImage = registryName + "/rhoai/" + rhoaiImage
+	case "quay.io":
+		expectedImage = registryName + "/opendatahub/" + odhImage
+	default:
+		test.T().Fatalf("Unexpected registry: %s", registryName)
+	}
+
 	containerImage := matchedPods[0].Spec.Containers[0].Image
-	test.Expect(containerImage).To(ContainSubstring(registryName + "/rhoai/" + expectedImage))
+	test.Expect(containerImage).To(ContainSubstring(expectedImage),
+		"Image %s should contain %s", containerImage, expectedImage)
 	test.T().Logf("%s container image is referred from %s", deploymentName, registryName)
+
 }

tests/trainer/cluster_training_runtimes_test.go

@@ -50,7 +50,8 @@ func TestDefaultClusterTrainingRuntimes(t *testing.T) {
 	test := With(t)
 
 	// Determine registry based on ODH namespace
-	namespace := GetOpenDataHubNamespace(test)
+	namespace, err := GetApplicationsNamespaceFromDSCI(test, DefaultDSCIName)
+	test.Expect(err).NotTo(HaveOccurred())
 	registryName := GetExpectedRegistry(test, namespace)
 
 	// Build a map of expected runtimes for quick lookup

tests/trainer/trainer_smoke_test.go

@@ -24,7 +24,8 @@ func TestKubeflowTrainerSmoke(t *testing.T) {
 // runSmoke runs a smoke test for a given deployment and expected image names.
 func runSmoke(t *testing.T, deploymentName string, rhoaiImage string, odhImage string) {
 	test := With(t)
-	namespace := GetOpenDataHubNamespace(test)
+	namespace, err := GetApplicationsNamespaceFromDSCI(test, DefaultDSCIName)
+	test.Expect(err).NotTo(HaveOccurred())
 
 	test.T().Logf("Waiting for %s deployment to be available ...", deploymentName)
 	test.Eventually(func(g Gomega, ctx context.Context) {
@@ -38,7 +39,7 @@ func runSmoke(t *testing.T, deploymentName string, rhoaiImage string, odhImage s
 
 	test.T().Logf("%s deployment is available", deploymentName)
 
-	// Determine registry based on ODH namespace
+	// Determine registry based on namespace
 	registryName := GetExpectedRegistry(test, namespace)
 
 	test.T().Logf("Verifying %s container image is referred from expected registry ...", deploymentName)