fix: collect launch properties when some cluster lacks Kuadrant

testsuite/component_metadata.py

@@ -21,13 +21,14 @@ def __init__(self):
 
     def collect_all_clusters(self):
         """Collect metadata from all configured clusters."""
-        clusters_config = self._get_cluster_configurations()
+        clusters_config = self.get_cluster_configurations()
         for cluster_name, cluster_client in clusters_config:
             metadata = self._collect_single_cluster(cluster_client)
             if metadata:
                 self.all_cluster_metadata[cluster_name] = metadata
 
-    def _get_cluster_configurations(self):
+    @staticmethod
+    def get_cluster_configurations():
         """Get cluster configurations from settings."""
         clusters_config = [("cluster1", settings["control_plane"]["cluster"])]
         if cluster2 := settings["control_plane"].get("cluster2"):
@@ -38,14 +39,16 @@ def _get_cluster_configurations(self):
 
     def _collect_single_cluster(self, cluster_client):
         """Collect metadata for a single cluster."""
-        project = cluster_client.change_project(settings["service_protection"]["system_project"])
-        if not project.connected:
+        if not cluster_client.is_reachable:
             return None
 
+        project = cluster_client.change_project(settings["service_protection"]["system_project"])
+        metadata = self._get_kuadrant_metadata(project) if project.connected else {"kuadrant_image": "not installed"}
+
         return {
-            "metadata": self._get_kuadrant_metadata(project),
+            "metadata": metadata,
             "console_url": self._get_console_url(cluster_client.api_url),
-            "ocp_version": self.get_ocp_version(project),
+            "ocp_version": cluster_client.ocp_version,
         }
 
     @staticmethod
@@ -78,23 +81,6 @@ def _get_console_url(api_url):
             return f"https://{console_hostname}"
         return api_url
 
-    @staticmethod
-    def get_ocp_version(project) -> Optional[str]:
-        """Retrieve and format OCP version from cluster."""
-        try:
-            with project.context:
-                version_result = oc.selector("clusterversion").objects()
-                if version_result:
-                    ocp_version = version_result[0].model.status.history[0].version
-                    if ocp_version:
-                        parts = ocp_version.split(".")
-                        if len(parts) >= 2:
-                            return f"{parts[0]}.{parts[1]}"
-        except (oc.OpenShiftPythonException, AttributeError, KeyError, IndexError, ValueError) as e:
-            logger.warning("Failed to get OCP version: %s", e)
-
-        return None
-
     @staticmethod
     def get_kubernetes_version(project) -> Optional[str]:
         """Run oc version and get the kubernetes version."""

testsuite/kubernetes/client.py

@@ -1,6 +1,8 @@
 """This module implements an KubernetesCLI interface using oc/kubectl binary commands."""
 
+import logging
 from functools import cached_property
+from typing import Optional
 from urllib.parse import urlparse
 import tempfile
 import yaml
@@ -14,6 +16,8 @@
 from .deployment import Deployment
 from .secret import Secret
 
+logger = logging.getLogger(__name__)
+
 
 class KubernetesClient:
     """KubernetesClient is a helper class for invoking kubectl commands"""
@@ -100,6 +104,30 @@ def connected(self):
             return False
         return True
 
+    @property
+    def is_reachable(self):
+        """Returns True if the cluster is reachable, without depending on any specific namespace."""
+        try:
+            self.do_action("api-versions")
+        except OpenShiftPythonException as e:
+            logger.warning("Cluster is not reachable: %s", e)
+            return False
+        return True
+
+    @property
+    def ocp_version(self) -> Optional[str]:
+        """Returns the OpenShift version (major.minor) or None if not available."""
+        result = self.do_action(
+            "get", "clusterversion", "version", "-o", "jsonpath={.status.history[0].version}", auto_raise=False
+        )
+        if result.status() != 0:
+            return None
+        version_str = result.out().strip()
+        parts = version_str.split(".")
+        if len(parts) >= 2:
+            return f"{parts[0]}.{parts[1]}"
+        return None
+
     def get_secret(self, name):
         """Returns dict-like structure for accessing secret data"""
         with self.context:

testsuite/tests/conftest.py

@@ -45,6 +45,10 @@ def pytest_runtest_setup(item):
     # error is raised during has_kuadrant()
     if item.config.getoption("--setup-plan"):
         return
+
+    if item.fspath.basename == "info_collector.py":
+        return
+
     marks = [i.name for i in item.iter_markers()]
     skip_or_fail = pytest.fail if item.config.getoption("--enforce") else pytest.skip
     standalone = item.config.getoption("--standalone")
@@ -422,16 +426,14 @@ def dns_provider_secret(testconfig):
 
 
 @pytest.fixture(scope="session")
-def openshift_version(cluster):
+def openshift_version(testconfig):
     """Get OpenShift cluster version"""
-    result = cluster.do_action(
-        "get", "clusterversion", "version", "-o", "jsonpath={.status.desired.version}", auto_raise=False
-    )
-    if result.status() != 0:
+    cluster = testconfig["control_plane"]["cluster"]
+    version = cluster.ocp_version
+    if version is None:
         return None
-    version_str = result.out().strip()
-    parts = version_str.split(".")
-    return tuple(int(p.split("-")[0]) for p in parts[:2])  # Convert "4.20.0" -> (4, 20)
+    parts = version.split(".")
+    return tuple(int(p.split("-")[0]) for p in parts[:2])  # Convert "4.20" -> (4, 20)
 
 
 @pytest.fixture(autouse=True)

testsuite/tests/info_collector.py

@@ -30,19 +30,30 @@
 
 logger = logging.getLogger(__name__)
 
+
+def _first_connected(namespace):
+    """Return the first (cluster_client, project) connected to the given namespace, or (None, None)."""
+    for _, cluster in ReportPortalMetadataCollector.get_cluster_configurations():
+        project = cluster.change_project(namespace)
+        if project.connected:
+            return cluster, project
+    return None, None
+
+
 pytestmark = pytest.mark.skipif(
     not os.environ.get("COLLECTOR_ENABLE"),
     reason="collector was not explicitly enabled",
 )
 
 
 def gather_cluster_versions() -> dict:
-    """gather all particular versions into a dictionary"""
-    cluster_client = settings["control_plane"]["cluster"]
-    project = cluster_client.change_project(settings["service_protection"]["system_project"])
+    """Gather cluster versions from the first cluster with Kuadrant system namespace."""
+    cluster, project = _first_connected(settings["service_protection"]["system_project"])
+    if project is None:
+        return {}
     return {
         "kubernetes": ReportPortalMetadataCollector.get_kubernetes_version(project),
-        "openshift": ReportPortalMetadataCollector.get_ocp_version(project),
+        "openshift": cluster.ocp_version,
     }
 
 
@@ -79,17 +90,21 @@ def test_cluster_properties(record_testsuite_property):
 
 
 def test_kube_context(record_testsuite_property):
-    """Record current kube context"""
-    kube_context = settings["control_plane"]["cluster"].kubeconfig_path
+    """Record kube context from the first cluster with kuadrant-system."""
+    cluster_client, _ = _first_connected(settings["service_protection"]["system_project"])
+    if cluster_client is None:
+        return
+    kube_context = cluster_client.kubeconfig_path
     print(f"{kube_context=}")
     if kube_context:
         record_testsuite_property("kube_context", kube_context)
 
 
 def test_kuadrant_properties(record_testsuite_property):
-    """Record kuadrant related properties"""
-    cluster_client = settings["control_plane"]["cluster"]
-    project = cluster_client.change_project("kuadrant-system")
+    """Record kuadrant related properties from the first cluster with kuadrant-system."""
+    _, project = _first_connected(settings["service_protection"]["system_project"])
+    if project is None:
+        return
     kuadrant_images = ReportPortalMetadataCollector.get_component_images(project)
     if kuadrant_images:
         print(f"Kuadrant images: {kuadrant_images}")
@@ -98,9 +113,10 @@ def test_kuadrant_properties(record_testsuite_property):
 
 
 def test_istio_properties(record_testsuite_property):
-    """Record Istio related properties"""
-    cluster_client = settings["control_plane"]["cluster"]
-    project = cluster_client.change_project("istio-system")
+    """Record Istio related properties from the first cluster with istio-system."""
+    _, project = _first_connected("istio-system")
+    if project is None:
+        return
     istio_metadata = ReportPortalMetadataCollector.get_istio_metadata(project)
     for key, value in istio_metadata.items():
         print(f"{key}: {value}")