Merge branch 'main' of https://github.com/RedHatQE/openshift-virtualization-tests into ocs_to_aws

Author: jpeimer

tests/conftest.py

@@ -2725,10 +2725,10 @@ def rhsm_created_secret(rhsm_credentials_from_bitwarden, namespace):
 
 
 @pytest.fixture(scope="session")
-def machine_config_pools():
+def machine_config_pools(admin_client):
     return [
-        get_machine_config_pool_by_name(mcp_name="master"),
-        get_machine_config_pool_by_name(mcp_name="worker"),
+        get_machine_config_pool_by_name(mcp_name="master", admin_client=admin_client),
+        get_machine_config_pool_by_name(mcp_name="worker", admin_client=admin_client),
     ]
 
 

tests/install_upgrade_operators/product_install/conftest.py

@@ -8,7 +8,6 @@
 from ocp_resources.hyperconverged import HyperConverged
 from ocp_resources.installplan import InstallPlan
 from ocp_resources.persistent_volume import PersistentVolume
-from ocp_resources.resource import get_client
 from pytest_testconfig import py_config
 
 from tests.install_upgrade_operators.product_install.constants import (
@@ -140,6 +139,7 @@ def hyperconverged_catalog_source(admin_client, is_production_source, cnv_image_
     catalog_source = create_catalog_source(
         catalog_name=HCO_CATALOG_SOURCE,
         image=cnv_image_url,
+        admin_client=admin_client,
     )
     wait_for_catalogsource_ready(
         admin_client=admin_client,
@@ -163,17 +163,19 @@ def created_cnv_namespace(admin_client):
 
 
 @pytest.fixture(scope="module")
-def created_cnv_operator_group(created_cnv_namespace):
+def created_cnv_operator_group(admin_client, created_cnv_namespace):
     cnv_namespace_name = created_cnv_namespace.name
     return create_operator_group(
         namespace_name=cnv_namespace_name,
         operator_group_name="openshift-cnv-group",
+        admin_client=admin_client,
         target_namespaces=[cnv_namespace_name],
     )
 
 
 @pytest.fixture(scope="module")
 def installed_cnv_subscription(
+    admin_client,
     is_production_source,
     hyperconverged_catalog_source,
     created_cnv_namespace,
@@ -184,6 +186,7 @@ def installed_cnv_subscription(
         package_name=py_config["hco_cr_name"],
         namespace_name=created_cnv_namespace.name,
         catalogsource_name=PRODUCTION_CATALOG_SOURCE if is_production_source else hyperconverged_catalog_source.name,
+        admin_client=admin_client,
         channel_name=cnv_version_to_install_info["channel"],
     )
 
@@ -230,10 +233,11 @@ def installed_openshift_virtualization(
 
 
 @pytest.fixture(scope="module")
-def created_hco_cr(created_cnv_namespace, installed_openshift_virtualization):
+def created_hco_cr(admin_client, created_cnv_namespace, installed_openshift_virtualization):
     return create_operator(
         operator_class=HyperConverged,
         operator_name=py_config["hco_cr_name"],
+        admin_client=admin_client,
         namespace_name=created_cnv_namespace.name,
     )
 
@@ -266,11 +270,11 @@ def cluster_backend_storage(admin_client):
 
 
 @pytest.fixture(scope="module")
-def hpp_volume_size(cluster_backend_storage):
+def hpp_volume_size(admin_client, cluster_backend_storage):
     hpp_volume_size = "70Gi"
     if cluster_backend_storage == LOCAL_BLOCK_HPP:
         persistent_volumes = PersistentVolume.get(
-            dyn_client=get_client(),
+            dyn_client=admin_client,
             label_selector=f"storage.openshift.com/local-volume-owner-name={cluster_backend_storage}",
         )
         for persistent_volume in persistent_volumes:
@@ -281,19 +285,22 @@ def hpp_volume_size(cluster_backend_storage):
 
 
 @pytest.fixture(scope="module")
-def installed_hpp(cluster_backend_storage, hpp_volume_size):
+def installed_hpp(admin_client, cluster_backend_storage, hpp_volume_size):
     LOGGER.info(f"Creating HPP CR using backend storage: {cluster_backend_storage} and storage size: {hpp_volume_size}")
     hpp_cr = HPPWithStoragePool(
         name=HostPathProvisioner.Name.HOSTPATH_PROVISIONER,
         backend_storage_class_name=cluster_backend_storage,
         volume_size=hpp_volume_size,
+        client=admin_client,
     )
     hpp_cr.deploy(wait=True)
     create_hpp_storage_class(
         storage_class_name=HppCsiStorageClass.Name.HOSTPATH_CSI_BASIC,
+        admin_client=admin_client,
     )
     create_hpp_storage_class(
         storage_class_name=HppCsiStorageClass.Name.HOSTPATH_CSI_PVC_BLOCK,
+        admin_client=admin_client,
     )
 
 

tests/install_upgrade_operators/product_install/utils.py

@@ -115,7 +115,7 @@ def wait_for_pod_running_by_prefix(
 
 
 def validate_hpp_installation(admin_client, cnv_namespace, schedulable_nodes):
-    hpp_deployment = Deployment(name=HOSTPATH_PROVISIONER_OPERATOR, namespace=cnv_namespace.name)
+    hpp_deployment = Deployment(name=HOSTPATH_PROVISIONER_OPERATOR, namespace=cnv_namespace.name, client=admin_client)
     assert hpp_deployment.exists
     hpp_deployment.wait_for_replicas(timeout=TIMEOUT_15MIN)
     wait_for_pod_running_by_prefix(

tests/install_upgrade_operators/product_uninstall/test_remove_hco.py

@@ -41,22 +41,22 @@ def assert_expected_strategy(resource_objects, expected_strategy):
     )
 
 
-def delete_cdi_configmap_and_secret(hco_namespace_name):
+def delete_cdi_configmap_and_secret(hco_namespace_name, admin_client):
     cdi_configmaps = [
         "cdi-apiserver-signer-bundle",
         "cdi-uploadproxy-signer-bundle",
         "cdi-uploadserver-client-signer-bundle",
         "cdi-uploadserver-signer-bundle",
     ]
     secret_objects = [
-        Secret(name=_secret, namespace=hco_namespace_name)
+        Secret(name=_secret, namespace=hco_namespace_name, client=admin_client)
         for _secret in CDI_SECRETS
-        if Secret(name=_secret, namespace=hco_namespace_name).exists
+        if Secret(name=_secret, namespace=hco_namespace_name, client=admin_client).exists
     ]
     configmap_objects = [
-        ConfigMap(name=_cm, namespace=hco_namespace_name)
+        ConfigMap(name=_cm, namespace=hco_namespace_name, client=admin_client)
         for _cm in cdi_configmaps
-        if ConfigMap(name=_cm, namespace=hco_namespace_name).exists
+        if ConfigMap(name=_cm, namespace=hco_namespace_name, client=admin_client).exists
     ]
 
     for resource in secret_objects + configmap_objects:
@@ -167,7 +167,7 @@ def stopped_fedora_vm(hco_fedora_vm):
 @pytest.fixture(scope="function")
 def removed_hco(admin_client, hco_namespace, hyperconverged_resource_scope_function):
     hyperconverged_resource_scope_function.delete(wait=True, timeout=TIMEOUT_10MIN)
-    delete_cdi_configmap_and_secret(hco_namespace_name=hco_namespace.name)
+    delete_cdi_configmap_and_secret(hco_namespace_name=hco_namespace.name, admin_client=admin_client)
     yield
 
     # Recreate HCO, if it doesn't exist

tests/install_upgrade_operators/product_upgrade/conftest.py

@@ -260,7 +260,7 @@ def ocp_image_url(pytestconfig):
 
 @pytest.fixture(scope="session")
 def cluster_version(admin_client):
-    cluster_version = ClusterVersion(name="version")
+    cluster_version = ClusterVersion(name="version", client=admin_client)
     if cluster_version.exists:
         return cluster_version
 
@@ -455,13 +455,13 @@ def machine_config_pools_conditions(active_machine_config_pools):
 
 
 @pytest.fixture(scope="session")
-def master_machine_config_pools():
-    return [get_machine_config_pool_by_name(mcp_name="master")]
+def master_machine_config_pools(admin_client):
+    return [get_machine_config_pool_by_name(mcp_name="master", admin_client=admin_client)]
 
 
 @pytest.fixture(scope="session")
-def worker_machine_config_pools():
-    return [get_machine_config_pool_by_name(mcp_name="worker")]
+def worker_machine_config_pools(admin_client):
+    return [get_machine_config_pool_by_name(mcp_name="worker", admin_client=admin_client)]
 
 
 @pytest.fixture(scope="module")
@@ -607,7 +607,8 @@ def updated_odf_subscription_source(odf_subscription, odf_version):
 
 @pytest.fixture()
 def upgraded_odf(
+    admin_client,
     odf_version,
     updated_odf_subscription_source,
 ):
-    wait_for_odf_update(target_version=odf_version)
+    wait_for_odf_update(target_version=odf_version, admin_client=admin_client)

tests/install_upgrade_operators/product_upgrade/utils.py

@@ -681,10 +681,10 @@ def wait_for_hco_csv_creation(admin_client: DynamicClient, hco_namespace: str, h
         raise
 
 
-def wait_for_odf_update(target_version: str) -> None:
-    def _get_updated_odf_csv(_target_version: str) -> list[str]:
+def wait_for_odf_update(target_version: str, admin_client: DynamicClient) -> None:
+    def _get_updated_odf_csv(_target_version: str, _admin_client: DynamicClient) -> list[str]:
         csv_list = []
-        for csv in ClusterServiceVersion.get(namespace=NamespacesNames.OPENSHIFT_STORAGE):
+        for csv in ClusterServiceVersion.get(dyn_client=_admin_client, namespace=NamespacesNames.OPENSHIFT_STORAGE):
             if any(
                 csv_name in csv.name
                 for csv_name in [
@@ -706,6 +706,7 @@ def _get_updated_odf_csv(_target_version: str) -> list[str]:
         sleep=TIMEOUT_30SEC,
         func=_get_updated_odf_csv,
         _target_version=target_version,
+        _admin_client=admin_client,
     )
 
     for sample in upgrade_sampler:

tests/observability/metrics/test_general_metrics.py

@@ -89,11 +89,10 @@ def test_vm_name_in_virt_launcher_label(self, fedora_vm_without_name_in_label):
 class TestVirtHCOSingleStackIpv6:
     @pytest.mark.ipv6
     @pytest.mark.polarion("CNV-11740")
+    @pytest.mark.s390x
     def test_metric_kubevirt_hco_single_stack_ipv6(self, prometheus, ipv6_single_stack_cluster):
-        if not ipv6_single_stack_cluster:
-            pytest.fail("The cluster is not ipv6 single stack")
         validate_metrics_value(
             prometheus=prometheus,
             metric_name="kubevirt_hco_single_stack_ipv6",
-            expected_value="1",
+            expected_value="1" if ipv6_single_stack_cluster else "0",
         )

tests/storage/hpp/test_hpp_csi_cr.py

@@ -112,11 +112,12 @@ def deleted_hpp_storage_classes(request, cluster_storage_classes):
 
 
 @pytest.fixture()
-def hpp_csi_storage_classes(request, cluster_storage_classes):
+def hpp_csi_storage_classes(request, admin_client, cluster_storage_classes):
     created_storage_classes_dict = {}
     for storage_class in request.param:
         sc = HppCsiStorageClass(
             name=storage_class,
+            client=admin_client,
             storage_pool=STORAGE_CLASS_TO_STORAGE_POOL_MAPPING[storage_class],
         )
         sc.deploy()

tests/storage/upgrade/conftest.py

@@ -120,26 +120,28 @@ def snapshots_for_upgrade_b(
 
 
 @pytest.fixture(scope="session")
-def blank_disk_dv_with_default_sc(upgrade_namespace_scope_session):
+def blank_disk_dv_with_default_sc(admin_client, upgrade_namespace_scope_session):
     with create_dv(
         source="blank",
         dv_name="blank-dv",
         namespace=upgrade_namespace_scope_session.name,
         size="1Gi",
         storage_class=py_config["default_storage_class"],
         consume_wffc=False,
+        client=admin_client,
     ) as dv:
         yield dv
 
 
 @pytest.fixture(scope="session")
-def fedora_vm_for_hotplug_upg(upgrade_namespace_scope_session, cluster_common_node_cpu):
+def fedora_vm_for_hotplug_upg(unprivileged_client, upgrade_namespace_scope_session, cluster_common_node_cpu):
     name = "fedora-hotplug-upg"
     with VirtualMachineForTests(
         name=name,
         namespace=upgrade_namespace_scope_session.name,
         body=fedora_vm_body(name=name),
         cpu_model=cluster_common_node_cpu,
+        client=unprivileged_client,
     ) as vm:
         running_vm(vm=vm)
         yield vm
@@ -166,9 +168,9 @@ def fedora_vm_for_hotplug_upg_ssh_connectivity(fedora_vm_for_hotplug_upg):
 
 
 @pytest.fixture(scope="session")
-def skip_if_config_default_storage_class_access_mode_rwo():
+def skip_if_config_default_storage_class_access_mode_rwo(admin_client):
     storage_class = py_config["default_storage_class"]
-    access_modes = StorageProfile(name=storage_class).first_claim_property_set_access_modes()
+    access_modes = StorageProfile(name=storage_class, client=admin_client).first_claim_property_set_access_modes()
     assert access_modes, f"Could not get the access mode from the {storage_class} storage profile"
     access_mode = access_modes[0]
     LOGGER.info(f"Storage class '{storage_class}' has access mode: '{access_mode}'")

tests/storage/upgrade/test_upgrade_storage.py

@@ -60,6 +60,7 @@ def test_cdiconfig_scratch_overriden_before_upgrade(
     @pytest.mark.dependency(name=f"{STORAGE_NODE_ID_PREFIX}::test_vm_snapshot_restore_before_upgrade")
     def test_vm_snapshot_restore_before_upgrade(
         self,
+        admin_client,
         skip_if_no_storage_class_for_snapshot,
         cirros_vm_for_upgrade_a,
         snapshots_for_upgrade_a,
@@ -69,6 +70,7 @@ def test_vm_snapshot_restore_before_upgrade(
             namespace=snapshots_for_upgrade_a.namespace,
             vm_name=cirros_vm_for_upgrade_a.name,
             snapshot_name=snapshots_for_upgrade_a.name,
+            client=admin_client,
         ) as vm_restore:
             vm_restore.wait_restore_done()
             cirros_vm_for_upgrade_a.start(wait=True)
@@ -164,12 +166,15 @@ def test_vm_snapshot_restore_check_after_upgrade(
         ],
         scope=DEPENDENCY_SCOPE_SESSION,
     )
-    def test_vm_snapshot_restore_create_after_upgrade(self, cirros_vm_for_upgrade_b, snapshots_for_upgrade_b):
+    def test_vm_snapshot_restore_create_after_upgrade(
+        self, admin_client, cirros_vm_for_upgrade_b, snapshots_for_upgrade_b
+    ):
         with VirtualMachineRestore(
             name=f"restore-snapshot-{cirros_vm_for_upgrade_b.name}",
             namespace=snapshots_for_upgrade_b.namespace,
             vm_name=cirros_vm_for_upgrade_b.name,
             snapshot_name=snapshots_for_upgrade_b.name,
+            client=admin_client,
         ) as vm_restore:
             vm_restore.wait_restore_done()
             cirros_vm_for_upgrade_b.start(wait=True)