add source dv Windows from registry

Signed-off-by: Adam Cinko <acinko@redhat.com>

Author: acinko-rh

tests/storage/cdi_clone/conftest.py

@@ -1,8 +1,11 @@
 import pytest
 from ocp_resources.datavolume import DataVolume
 
+from tests.storage.cdi_clone.constants import WINDOWS_CLONE_TIMEOUT
 from tests.storage.constants import QUAY_FEDORA_CONTAINER_IMAGE
-from utilities.constants import REGISTRY_STR, Images
+from utilities.artifactory import get_artifactory_config_map, get_artifactory_secret, get_test_artifact_server_url
+from utilities.constants import REGISTRY_STR, WIN_2K22, Images
+from utilities.os_utils import get_windows_container_disk_path
 from utilities.storage import create_dv, data_volume
 
 
@@ -59,3 +62,47 @@ def fedora_dv_with_block_volume_mode(
     ) as dv:
         dv.wait_for_dv_success()
         yield dv
+
+
+@pytest.fixture(scope="function")
+def source_dv_windows_registry(
+    unprivileged_client,
+    namespace,
+    storage_class_name_scope_function,
+):
+    """Fixture that creates a Windows 2022 DataVolume from registry."""
+    secret = get_artifactory_secret(namespace=namespace.name)
+    cert = get_artifactory_config_map(namespace=namespace.name)
+
+    with create_dv(
+        client=unprivileged_client,
+        dv_name=f"dv-source-{WIN_2K22}-registry",
+        namespace=namespace.name,
+        source="registry",
+        size=Images.Windows.CONTAINER_DISK_DV_SIZE,
+        storage_class=storage_class_name_scope_function,
+        url=f"{get_test_artifact_server_url(schema='registry')}/{get_windows_container_disk_path(os_value=WIN_2K22)}",
+        secret=secret,
+        cert_configmap=cert.name,
+    ) as dv:
+        dv.wait_for_dv_success(timeout=WINDOWS_CLONE_TIMEOUT)
+        yield dv
+
+
+@pytest.fixture(scope="function")
+def cloned_windows_dv_from_registry(
+    unprivileged_client,
+    source_dv_windows_registry,
+):
+    """Fixture that creates a cloned DataVolume from registry source."""
+    with create_dv(
+        client=unprivileged_client,
+        source="pvc",
+        dv_name=f"dv-target-{WIN_2K22}-vtpm",
+        namespace=source_dv_windows_registry.namespace,
+        size=source_dv_windows_registry.size,
+        source_pvc=source_dv_windows_registry.name,
+        storage_class=source_dv_windows_registry.storage_class,
+    ) as cdv:
+        cdv.wait_for_dv_success(timeout=WINDOWS_CLONE_TIMEOUT)
+        yield cdv

tests/storage/cdi_clone/constants.py

@@ -0,0 +1,5 @@
+"""Constants for CDI clone tests."""
+
+from utilities.constants import TIMEOUT_40MIN
+
+WINDOWS_CLONE_TIMEOUT = TIMEOUT_40MIN

tests/storage/cdi_clone/test_clone.py

@@ -12,16 +12,24 @@
 )
 
 from tests.os_params import FEDORA_LATEST, WINDOWS_11, WINDOWS_11_TEMPLATE_LABELS
+from tests.storage.cdi_clone.constants import WINDOWS_CLONE_TIMEOUT
 from tests.storage.utils import (
     assert_pvc_snapshot_clone_annotation,
     assert_use_populator,
     create_windows_vm_validate_guest_agent_info,
+    validate_os_info_vmi_vs_windows_os,
+    verify_vtpm_in_windows_vm,
+    wait_for_windows_vm,
 )
 from utilities.constants import (
     OS_FLAVOR_FEDORA,
+    OS_FLAVOR_WIN_CONTAINER_DISK,
     OS_FLAVOR_WINDOWS,
     TIMEOUT_1MIN,
     TIMEOUT_40MIN,
+    U1_LARGE,
+    WIN_2K22,
+    WINDOWS_2K22_PREFERENCE,
     Images,
 )
 from utilities.storage import (
@@ -38,8 +46,6 @@
     running_vm,
 )
 
-WINDOWS_CLONE_TIMEOUT = TIMEOUT_40MIN
-
 
 def create_vm_from_clone_dv_template(
     vm_name,
@@ -69,47 +75,6 @@ def create_vm_from_clone_dv_template(
         running_vm(vm=vm)
 
 
-def create_windows_vm_with_vtpm_validate_guest_agent_info(
-    dv,
-    namespace,
-    unprivileged_client,
-    windows_version,
-    admin_client=None,
-):
-    """
-    Create Windows VM with vTPM using instance types and preferences.
-
-    Args:
-        dv: DataVolume to use for the VM
-        namespace: Namespace object
-        unprivileged_client: Client to use
-        windows_version: Windows version string ("11", "2k22", etc.)
-        admin_client: Optional admin client for vTPM validation
-    """
-    from tests.storage.utils import validate_os_info_vmi_vs_windows_os, wait_for_windows_vm
-
-    # Map Windows version to preference name
-    preference_name = f"windows.{windows_version}"  # e.g., "windows.11", "windows.2k22"
-
-    with VirtualMachineForTests(
-        name=f"vm-win-{windows_version}-vtpm",
-        namespace=namespace.name,
-        client=unprivileged_client,
-        os_flavor=OS_FLAVOR_WINDOWS,
-        vm_instance_type=VirtualMachineClusterInstancetype(name="u1.large", client=unprivileged_client),
-        vm_preference=VirtualMachineClusterPreference(name=preference_name, client=unprivileged_client),
-        data_volume_template={"metadata": dv.res["metadata"], "spec": dv.res["spec"]},
-    ) as vm:
-        wait_for_windows_vm(vm=vm, version=windows_version, timeout=TIMEOUT_40MIN)
-        validate_os_info_vmi_vs_windows_os(vm=vm)
-
-        # Validate vTPM if admin_client provided
-        if admin_client:
-            from tests.storage.utils import verify_vtpm_in_windows_vm
-
-            verify_vtpm_in_windows_vm(vm=vm, admin_client=admin_client)
-
-
 @pytest.mark.tier3
 @pytest.mark.parametrize(
     "data_volume_multi_storage_scope_function",
@@ -235,45 +200,31 @@ def test_successful_vm_from_cloned_dv_windows(
 
 
 @pytest.mark.tier3
-@pytest.mark.parametrize(
-    "data_volume_multi_storage_scope_function",
-    [
-        pytest.param(
-            {
-                "dv_name": "dv-source-win11-vtpm",
-                "source": "http",
-                "image": f"{Images.Windows.DIR}/{Images.Windows.WIN11_IMG}",
-                "dv_size": Images.Windows.DEFAULT_DV_SIZE,
-            },
-            marks=pytest.mark.polarion("CNV-3638"),
-        ),
-    ],
-    indirect=True,
-)
+@pytest.mark.polarion("CNV-3638")
 def test_successful_vm_from_cloned_dv_windows_with_vtpm(
+    admin_client,  # only needed for `verify_vtpm_in_windows_vm`, to be deleted once verified
     unprivileged_client,
-    admin_client,
-    data_volume_multi_storage_scope_function,
     namespace,
+    cloned_windows_dv_from_registry,
 ):
-    """Test cloning Windows 11 DV and creating VM with vTPM using instance types."""
-    with create_dv(
+    """Test cloning Windows 2022 DV and creating VM with vTPM using instance types."""
+
+    with VirtualMachineForTests(
+        name=f"vm-{WIN_2K22}-vtpm",
+        namespace=namespace.name,
         client=unprivileged_client,
-        source="pvc",
-        dv_name="dv-target-win11-vtpm",
-        namespace=data_volume_multi_storage_scope_function.namespace,
-        size=data_volume_multi_storage_scope_function.size,
-        source_pvc=data_volume_multi_storage_scope_function.name,
-        storage_class=data_volume_multi_storage_scope_function.storage_class,
-    ) as cdv:
-        cdv.wait_for_dv_success(timeout=WINDOWS_CLONE_TIMEOUT)
-        create_windows_vm_with_vtpm_validate_guest_agent_info(
-            dv=cdv,
-            namespace=namespace,
-            unprivileged_client=unprivileged_client,
-            windows_version="11",
-            admin_client=admin_client,
-        )
+        os_flavor=OS_FLAVOR_WIN_CONTAINER_DISK,
+        vm_instance_type=VirtualMachineClusterInstancetype(name=U1_LARGE, client=unprivileged_client),
+        vm_preference=VirtualMachineClusterPreference(name=WINDOWS_2K22_PREFERENCE, client=unprivileged_client),
+        data_volume_template={
+            "metadata": cloned_windows_dv_from_registry.res["metadata"],
+            "spec": cloned_windows_dv_from_registry.res["spec"],
+        },
+    ) as vm:
+        vm.start()
+        wait_for_windows_vm(vm=vm, version="2k22", timeout=TIMEOUT_40MIN)
+        validate_os_info_vmi_vs_windows_os(vm=vm)
+        verify_vtpm_in_windows_vm(vm=vm, admin_client=admin_client)
 
 
 @pytest.mark.parametrize(

utilities/constants.py

@@ -812,6 +812,7 @@ class NamespacesNames:
 RHEL8_PREFERENCE = "rhel.8"
 RHEL9_PREFERENCE = "rhel.9"
 RHEL10_PREFERENCE = "rhel.10"
+WINDOWS_2K22_PREFERENCE = "windows.2k22"
 U1_SMALL = "u1.small"
 U1_LARGE = "u1.large"
 PROMETHEUS_K8S = "prometheus-k8s"