cleanup(kubevirt_vm): Simplify tests

Simplify kubevirt_vm tests by not using fixtures if not needed.

Signed-off-by: Felix Matouschek <fmatouschek@redhat.com>

tests/unit/plugins/modules/test_kubevirt_vm.py

@@ -20,134 +20,26 @@ from ansible_collections.kubevirt.core.tests.unit.utils.ansible_module_mock impo
 )
 
 
-@pytest.fixture(scope="module")
+def test_module_fails_when_required_args_missing(mocker):
-def vm_definition_create():
+    mocker.patch.object(AnsibleModule, "fail_json", fail_json)
-    return {
+    with pytest.raises(AnsibleFailJson):
-        "apiVersion": "kubevirt.io/v1",
+        set_module_args({})
-        "kind": "VirtualMachine",
+        kubevirt_vm.main()
-        "metadata": {
-            "name": "testvm",
-            "namespace": "default",
-            "labels": {"environment": "staging", "service": "loadbalancer"},
-        },
-        "spec": {
-            "running": True,
-            "instancetype": {"name": "u1.medium"},
-            "preference": {"name": "fedora"},
-            "dataVolumeTemplates": [
-                {
-                    "metadata": {"name": "testdv"},
-                    "spec": {
-                        "source": {
-                            "registry": {
-                                "url": "docker://quay.io/containerdisks/fedora:latest"
-                            },
-                        },
-                        "storage": {
-                            "accessModes": ["ReadWriteOnce"],
-                            "resources": {"requests": {"storage": "5Gi"}},
-                        },
-                    },
-                }
-            ],
-            "template": {
-                "metadata": {
-                    "labels": {"environment": "staging", "service": "loadbalancer"}
-                },
-                "spec": {
-                    "domain": {"devices": {}},
-                    "terminationGracePeriodSeconds": 180,
-                },
-            },
-        },
-    }
 
 
-@pytest.fixture(scope="module")
+VM_DEFINITION_CREATE = {
-def vm_definition_running():
+    "apiVersion": "kubevirt.io/v1",
-    return {
+    "kind": "VirtualMachine",
-        "apiVersion": "kubevirt.io/v1",
+    "metadata": {
-        "kind": "VirtualMachine",
-        "metadata": {
-            "name": "testvm",
-            "namespace": "default",
-        },
-        "spec": {
-            "running": True,
-            "template": {
-                "spec": {
-                    "domain": {"devices": {}},
-                },
-            },
-        },
-    }
-
-
-@pytest.fixture(scope="module")
-def vm_definition_stopped():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "name": "testvm",
-            "namespace": "default",
-        },
-        "spec": {
-            "running": False,
-            "template": {
-                "spec": {
-                    "domain": {"devices": {}},
-                },
-            },
-        },
-    }
-
-
-@pytest.fixture(scope="module")
-def module_params_default():
-    return {
-        "api_version": "kubevirt.io/v1",
-        "annotations": None,
-        "labels": None,
-        "running": True,
-        "instancetype": None,
-        "preference": None,
-        "data_volume_templates": None,
-        "spec": None,
-        "wait": False,
-        "wait_sleep": 5,
-        "wait_timeout": 5,
-        "kubeconfig": None,
-        "context": None,
-        "host": None,
-        "api_key": None,
-        "username": None,
-        "password": None,
-        "validate_certs": None,
-        "ca_cert": None,
-        "client_cert": None,
-        "client_key": None,
-        "proxy": None,
-        "no_proxy": None,
-        "proxy_headers": None,
-        "persist_config": None,
-        "impersonate_user": None,
-        "impersonate_groups": None,
-        "state": "present",
-        "force": False,
-        "delete_options": None,
-    }
-
-
-@pytest.fixture(scope="module")
-def module_params_create(module_params_default):
-    return module_params_default | {
         "name": "testvm",
         "namespace": "default",
-        "labels": {"service": "loadbalancer", "environment": "staging"},
+        "labels": {"environment": "staging", "service": "loadbalancer"},
+    },
+    "spec": {
+        "running": True,
         "instancetype": {"name": "u1.medium"},
         "preference": {"name": "fedora"},
-        "data_volume_templates": [
+        "dataVolumeTemplates": [
             {
                 "metadata": {"name": "testdv"},
                 "spec": {
@@ -163,121 +55,187 @@ def module_params_create(module_params_default):
                 },
             }
         ],
-        "spec": {
+        "template": {
-            "domain": {"devices": {}},
+            "metadata": {
-            "terminationGracePeriodSeconds": 180,
+                "labels": {"environment": "staging", "service": "loadbalancer"}
+            },
+            "spec": {
+                "domain": {"devices": {}},
+                "terminationGracePeriodSeconds": 180,
+            },
         },
-    }
+    },
+}
 
-
+VM_DEFINITION_RUNNING = {
-@pytest.fixture(scope="module")
+    "apiVersion": "kubevirt.io/v1",
-def module_params_running(module_params_default):
+    "kind": "VirtualMachine",
-    return module_params_default | {
+    "metadata": {
         "name": "testvm",
         "namespace": "default",
+    },
+    "spec": {
         "running": True,
-    }
+        "template": {
+            "spec": {
+                "domain": {"devices": {}},
+            },
+        },
+    },
+}
 
-
+VM_DEFINITION_STOPPED = {
-@pytest.fixture(scope="module")
+    "apiVersion": "kubevirt.io/v1",
-def module_params_stopped(module_params_default):
+    "kind": "VirtualMachine",
-    return module_params_default | {
+    "metadata": {
         "name": "testvm",
         "namespace": "default",
+    },
+    "spec": {
         "running": False,
-    }
+        "template": {
+            "spec": {
+                "domain": {"devices": {}},
+            },
+        },
+    },
+}
 
+MODULE_PARAMS_DEFAULT = {
+    "api_version": "kubevirt.io/v1",
+    "annotations": None,
+    "labels": None,
+    "running": True,
+    "instancetype": None,
+    "preference": None,
+    "data_volume_templates": None,
+    "spec": None,
+    "wait": False,
+    "wait_sleep": 5,
+    "wait_timeout": 5,
+    "kubeconfig": None,
+    "context": None,
+    "host": None,
+    "api_key": None,
+    "username": None,
+    "password": None,
+    "validate_certs": None,
+    "ca_cert": None,
+    "client_cert": None,
+    "client_key": None,
+    "proxy": None,
+    "no_proxy": None,
+    "proxy_headers": None,
+    "persist_config": None,
+    "impersonate_user": None,
+    "impersonate_groups": None,
+    "state": "present",
+    "force": False,
+    "delete_options": None,
+}
 
-@pytest.fixture(scope="module")
+MODULE_PARAMS_CREATE = MODULE_PARAMS_DEFAULT | {
-def module_params_delete(module_params_default):
+    "name": "testvm",
-    return module_params_default | {
+    "namespace": "default",
-        "name": "testvm",
+    "labels": {"service": "loadbalancer", "environment": "staging"},
-        "namespace": "default",
+    "instancetype": {"name": "u1.medium"},
-        "state": "absent",
+    "preference": {"name": "fedora"},
-        "wait": True,
+    "data_volume_templates": [
-    }
+        {
+            "metadata": {"name": "testdv"},
+            "spec": {
+                "source": {
+                    "registry": {
+                        "url": "docker://quay.io/containerdisks/fedora:latest"
+                    },
+                },
+                "storage": {
+                    "accessModes": ["ReadWriteOnce"],
+                    "resources": {"requests": {"storage": "5Gi"}},
+                },
+            },
+        }
+    ],
+    "spec": {
+        "domain": {"devices": {}},
+        "terminationGracePeriodSeconds": 180,
+    },
+}
 
+MODULE_PARAMS_RUNNING = MODULE_PARAMS_DEFAULT | {
+    "name": "testvm",
+    "namespace": "default",
+    "running": True,
+}
 
-@pytest.fixture(scope="module")
+MODULE_PARAMS_STOPPED = MODULE_PARAMS_DEFAULT | {
-def k8s_module_params_create(module_params_create, vm_definition_create):
+    "name": "testvm",
-    return module_params_create | {
+    "namespace": "default",
-        "generate_name": None,
+    "running": False,
-        "resource_definition": vm_definition_create,
+}
-        "wait_condition": {"type": "Ready", "status": True},
-    }
 
+MODULE_PARAMS_DELETE = MODULE_PARAMS_DEFAULT | {
+    "name": "testvm",
+    "namespace": "default",
+    "state": "absent",
+    "wait": True,
+}
 
-@pytest.fixture(scope="module")
+K8S_MODULE_PARAMS_CREATE = MODULE_PARAMS_CREATE | {
-def k8s_module_params_running(module_params_running, vm_definition_running):
+    "generate_name": None,
-    return module_params_running | {
+    "resource_definition": VM_DEFINITION_CREATE,
-        "generate_name": None,
+    "wait_condition": {"type": "Ready", "status": True},
-        "resource_definition": vm_definition_running,
+}
-        "wait_condition": {"type": "Ready", "status": True},
-    }
 
+K8S_MODULE_PARAMS_RUNNING = MODULE_PARAMS_RUNNING | {
+    "generate_name": None,
+    "resource_definition": VM_DEFINITION_RUNNING,
+    "wait_condition": {"type": "Ready", "status": True},
+}
 
-@pytest.fixture(scope="module")
+K8S_MODULE_PARAMS_STOPPED = MODULE_PARAMS_STOPPED | {
-def k8s_module_params_stopped(module_params_stopped, vm_definition_stopped):
+    "generate_name": None,
-    return module_params_stopped | {
+    "resource_definition": VM_DEFINITION_STOPPED,
-        "generate_name": None,
+    "wait_condition": {"type": "Ready", "status": False, "reason": "VMINotExists"},
-        "resource_definition": vm_definition_stopped,
+}
-        "wait_condition": {"type": "Ready", "status": False, "reason": "VMINotExists"},
-    }
 
-
+K8S_MODULE_PARAMS_DELETE = MODULE_PARAMS_DELETE | {
-@pytest.fixture(scope="module")
+    "generate_name": None,
-def k8s_module_params_delete(module_params_delete, vm_definition_running):
+    "resource_definition": VM_DEFINITION_RUNNING,
-    return module_params_delete | {
+    "wait_condition": {"type": "Ready", "status": True},
-        "generate_name": None,
+}
-        "resource_definition": vm_definition_running,
-        "wait_condition": {"type": "Ready", "status": True},
-    }
-
-
-def test_module_fails_when_required_args_missing(mocker):
-    mocker.patch.object(AnsibleModule, "fail_json", fail_json)
-    with pytest.raises(AnsibleFailJson):
-        set_module_args({})
-        kubevirt_vm.main()
 
 
 @pytest.mark.parametrize(
     "module_params,k8s_module_params,vm_definition,method",
     [
         (
-            "module_params_create",
+            MODULE_PARAMS_CREATE,
-            "k8s_module_params_create",
+            K8S_MODULE_PARAMS_CREATE,
-            "vm_definition_create",
+            VM_DEFINITION_CREATE,
             "create",
         ),
         (
-            "module_params_running",
+            MODULE_PARAMS_RUNNING,
-            "k8s_module_params_running",
+            K8S_MODULE_PARAMS_RUNNING,
-            "vm_definition_running",
+            VM_DEFINITION_RUNNING,
             "update",
         ),
         (
-            "module_params_stopped",
+            MODULE_PARAMS_STOPPED,
-            "k8s_module_params_stopped",
+            K8S_MODULE_PARAMS_STOPPED,
-            "vm_definition_stopped",
+            VM_DEFINITION_STOPPED,
             "update",
         ),
         (
-            "module_params_delete",
+            MODULE_PARAMS_DELETE,
-            "k8s_module_params_delete",
+            K8S_MODULE_PARAMS_DELETE,
-            "vm_definition_running",
+            VM_DEFINITION_RUNNING,
             "delete",
         ),
     ],
 )
-def test_module(
+def test_module(mocker, module_params, k8s_module_params, vm_definition, method):
-    request,
-    mocker,
-    module_params,
-    k8s_module_params,
-    vm_definition,
-    method,
-):
     mocker.patch.object(AnsibleModule, "exit_json", exit_json)
     mocker.patch.object(runner, "get_api_client")
 
@@ -292,57 +250,192 @@ def test_module(
     )
 
     with pytest.raises(AnsibleExitJson):
-        set_module_args(request.getfixturevalue(module_params))
+        set_module_args(module_params)
         kubevirt_vm.main()
 
     perform_action.assert_called_once_with(
         mocker.ANY,
-        request.getfixturevalue(vm_definition),
+        vm_definition,
-        request.getfixturevalue(k8s_module_params),
+        k8s_module_params,
     )
 
 
-@pytest.fixture(scope="module")
+CREATE_VM_PARAMS = {
-def create_vm_params():
+    "api_version": "kubevirt.io/v1",
-    return {
+    "running": True,
-        "api_version": "kubevirt.io/v1",
+    "namespace": "default",
-        "running": True,
+}
+
+CREATE_VM_PARAMS_ANNOTATIONS = CREATE_VM_PARAMS | {
+    "annotations": {"test": "test"},
+}
+
+CREATE_VM_PARAMS_LABELS = CREATE_VM_PARAMS | {
+    "labels": {"test": "test"},
+}
+
+CREATE_VM_PARAMS_INSTANCETYPE = CREATE_VM_PARAMS | {
+    "instancetype": {"name": "u1.medium"},
+}
+
+CREATE_VM_PARAMS_PREFERENCE = CREATE_VM_PARAMS | {
+    "preference": {"name": "fedora"},
+}
+
+CREATE_VM_PARAMS_DATAVOLUMETEMPLATE = CREATE_VM_PARAMS | {
+    "data_volume_templates": [
+        {
+            "metadata": {"name": "testdv"},
+            "spec": {
+                "source": {
+                    "registry": {
+                        "url": "docker://quay.io/containerdisks/fedora:latest"
+                    },
+                },
+                "storage": {
+                    "accessModes": ["ReadWriteOnce"],
+                    "resources": {"requests": {"storage": "5Gi"}},
+                },
+            },
+        },
+    ],
+}
+
+CREATE_VM_PARAMS_NAME = CREATE_VM_PARAMS | {
+    "name": "testvm",
+}
+
+CREATE_VM_PARAMS_GENERATE_NAME = CREATE_VM_PARAMS | {
+    "generate_name": "testvm-1234",
+}
+
+CREATE_VM_PARAMS_SPECS = CREATE_VM_PARAMS | {
+    "spec": {
+        "domain": {
+            "devices": {
+                "cpu": {
+                    "cores": 2,
+                    "socket": 1,
+                    "threads": 2,
+                }
+            }
+        }
+    }
+}
+
+CREATED_VM = {
+    "apiVersion": "kubevirt.io/v1",
+    "kind": "VirtualMachine",
+    "metadata": {
         "namespace": "default",
-    }
+    },
+    "spec": {
+        "running": True,
+        "template": {
+            "spec": {
+                "domain": {
+                    "devices": {},
+                },
+            },
+        },
+    },
+}
 
+CREATED_VM_LABELS = {
+    "apiVersion": "kubevirt.io/v1",
+    "kind": "VirtualMachine",
+    "metadata": {
+        "namespace": "default",
+        "labels": {
+            "test": "test",
+        },
+    },
+    "spec": {
+        "running": True,
+        "template": {
+            "metadata": {
+                "labels": {"test": "test"},
+            },
+            "spec": {
+                "domain": {
+                    "devices": {},
+                },
+            },
+        },
+    },
+}
 
-@pytest.fixture(scope="module")
+CREATED_VM_ANNOTATIONS = {
-def create_vm_params_annotations(create_vm_params):
+    "apiVersion": "kubevirt.io/v1",
-    return create_vm_params | {
+    "kind": "VirtualMachine",
-        "annotations": {"test": "test"},
+    "metadata": {
-    }
+        "namespace": "default",
+        "annotations": {
+            "test": "test",
+        },
+    },
+    "spec": {
+        "running": True,
+        "template": {
+            "metadata": {
+                "annotations": {"test": "test"},
+            },
+            "spec": {
+                "domain": {
+                    "devices": {},
+                },
+            },
+        },
+    },
+}
 
-
+CREATED_VM_INSTANCETYPE = {
-@pytest.fixture(scope="module")
+    "apiVersion": "kubevirt.io/v1",
-def create_vm_params_labels(create_vm_params):
+    "kind": "VirtualMachine",
-    return create_vm_params | {
+    "metadata": {
-        "labels": {"test": "test"},
+        "namespace": "default",
-    }
+    },
-
+    "spec": {
-
+        "running": True,
-@pytest.fixture(scope="module")
-def create_vm_params_instancetype(create_vm_params):
-    return create_vm_params | {
         "instancetype": {"name": "u1.medium"},
-    }
+        "template": {
+            "spec": {
+                "domain": {
+                    "devices": {},
+                },
+            },
+        },
+    },
+}
 
-
+CREATED_VM_PREFERENCE = {
-@pytest.fixture(scope="module")
+    "apiVersion": "kubevirt.io/v1",
-def create_vm_params_preference(create_vm_params):
+    "kind": "VirtualMachine",
-    return create_vm_params | {
+    "metadata": {
+        "namespace": "default",
+    },
+    "spec": {
+        "running": True,
         "preference": {"name": "fedora"},
-    }
+        "template": {
+            "spec": {
+                "domain": {
+                    "devices": {},
+                },
+            },
+        },
+    },
+}
 
-
+CREATED_VM_DATAVOLUMETEMPLATE = {
-@pytest.fixture(scope="module")
+    "apiVersion": "kubevirt.io/v1",
-def create_vm_params_datavolumetemplate(create_vm_params):
+    "kind": "VirtualMachine",
-    return create_vm_params | {
+    "metadata": {
-        "data_volume_templates": [
+        "namespace": "default",
+    },
+    "spec": {
+        "running": True,
+        "dataVolumeTemplates": [
             {
                 "metadata": {"name": "testdv"},
                 "spec": {
@@ -358,282 +451,92 @@ def create_vm_params_datavolumetemplate(create_vm_params):
                 },
             },
         ],
-    }
+        "template": {
+            "spec": {
+                "domain": {
+                    "devices": {},
+                },
+            },
+        },
+    },
+}
 
-
+CREATED_VM_NAME = {
-@pytest.fixture(scope="module")
+    "apiVersion": "kubevirt.io/v1",
-def create_vm_params_name(create_vm_params):
+    "kind": "VirtualMachine",
-    return create_vm_params | {
+    "metadata": {
         "name": "testvm",
-    }
+        "namespace": "default",
-
+    },
-
+    "spec": {
-@pytest.fixture(scope="module")
+        "running": True,
-def create_vm_params_generate_name(create_vm_params):
+        "template": {
-    return create_vm_params | {
+            "spec": {
-        "generate_name": "testvm-1234",
+                "domain": {
-    }
+                    "devices": {},
-
+                },
-
+            },
-@pytest.fixture(scope="module")
-def create_vm_params_specs(create_vm_params):
-    return create_vm_params | {
-        "spec": {
-            "domain": {
-                "devices": {
-                    "cpu": {
-                        "cores": 2,
-                        "socket": 1,
-                        "threads": 2,
-                    }
-                }
-            }
-        }
-    }
-
-
-@pytest.fixture(scope="module")
-def created_vm():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "namespace": "default",
         },
-        "spec": {
+    },
-            "running": True,
+}
-            "template": {
+
-                "spec": {
+CREATED_VM_GENERATE_NAME = {
-                    "domain": {
+    "apiVersion": "kubevirt.io/v1",
-                        "devices": {},
+    "kind": "VirtualMachine",
+    "metadata": {
+        "generateName": "testvm-1234",
+        "namespace": "default",
+    },
+    "spec": {
+        "running": True,
+        "template": {
+            "spec": {
+                "domain": {
+                    "devices": {},
+                },
+            },
+        },
+    },
+}
+
+CREATED_VM_SPECS = {
+    "apiVersion": "kubevirt.io/v1",
+    "kind": "VirtualMachine",
+    "metadata": {
+        "namespace": "default",
+    },
+    "spec": {
+        "running": True,
+        "template": {
+            "spec": {
+                "domain": {
+                    "devices": {
+                        "cpu": {
+                            "cores": 2,
+                            "socket": 1,
+                            "threads": 2,
+                        }
                     },
                 },
             },
         },
-    }
+    },
-
+}
-
-@pytest.fixture(scope="module")
-def created_vm_labels():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "namespace": "default",
-            "labels": {
-                "test": "test",
-            },
-        },
-        "spec": {
-            "running": True,
-            "template": {
-                "metadata": {
-                    "labels": {"test": "test"},
-                },
-                "spec": {
-                    "domain": {
-                        "devices": {},
-                    },
-                },
-            },
-        },
-    }
-
-
-@pytest.fixture(scope="module")
-def created_vm_annotations():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "namespace": "default",
-            "annotations": {
-                "test": "test",
-            },
-        },
-        "spec": {
-            "running": True,
-            "template": {
-                "metadata": {
-                    "annotations": {"test": "test"},
-                },
-                "spec": {
-                    "domain": {
-                        "devices": {},
-                    },
-                },
-            },
-        },
-    }
-
-
-@pytest.fixture(scope="module")
-def created_vm_instancetype():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "namespace": "default",
-        },
-        "spec": {
-            "running": True,
-            "instancetype": {"name": "u1.medium"},
-            "template": {
-                "spec": {
-                    "domain": {
-                        "devices": {},
-                    },
-                },
-            },
-        },
-    }
-
-
-@pytest.fixture(scope="module")
-def created_vm_preference():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "namespace": "default",
-        },
-        "spec": {
-            "running": True,
-            "preference": {"name": "fedora"},
-            "template": {
-                "spec": {
-                    "domain": {
-                        "devices": {},
-                    },
-                },
-            },
-        },
-    }
-
-
-@pytest.fixture(scope="module")
-def created_vm_datavolumetemplate():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "namespace": "default",
-        },
-        "spec": {
-            "running": True,
-            "dataVolumeTemplates": [
-                {
-                    "metadata": {"name": "testdv"},
-                    "spec": {
-                        "source": {
-                            "registry": {
-                                "url": "docker://quay.io/containerdisks/fedora:latest"
-                            },
-                        },
-                        "storage": {
-                            "accessModes": ["ReadWriteOnce"],
-                            "resources": {"requests": {"storage": "5Gi"}},
-                        },
-                    },
-                },
-            ],
-            "template": {
-                "spec": {
-                    "domain": {
-                        "devices": {},
-                    },
-                },
-            },
-        },
-    }
-
-
-@pytest.fixture(scope="module")
-def created_vm_name():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "name": "testvm",
-            "namespace": "default",
-        },
-        "spec": {
-            "running": True,
-            "template": {
-                "spec": {
-                    "domain": {
-                        "devices": {},
-                    },
-                },
-            },
-        },
-    }
-
-
-@pytest.fixture(scope="module")
-def created_vm_generate_name():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "generateName": "testvm-1234",
-            "namespace": "default",
-        },
-        "spec": {
-            "running": True,
-            "template": {
-                "spec": {
-                    "domain": {
-                        "devices": {},
-                    },
-                },
-            },
-        },
-    }
-
-
-@pytest.fixture(scope="module")
-def created_vm_specs():
-    return {
-        "apiVersion": "kubevirt.io/v1",
-        "kind": "VirtualMachine",
-        "metadata": {
-            "namespace": "default",
-        },
-        "spec": {
-            "running": True,
-            "template": {
-                "spec": {
-                    "domain": {
-                        "devices": {
-                            "cpu": {
-                                "cores": 2,
-                                "socket": 1,
-                                "threads": 2,
-                            }
-                        },
-                    },
-                },
-            },
-        },
-    }
 
 
 @pytest.mark.parametrize(
     "params,expected",
     [
-        ("create_vm_params", "created_vm"),
+        (CREATE_VM_PARAMS, CREATED_VM),
-        ("create_vm_params_annotations", "created_vm_annotations"),
+        (CREATE_VM_PARAMS_ANNOTATIONS, CREATED_VM_ANNOTATIONS),
-        ("create_vm_params_labels", "created_vm_labels"),
+        (CREATE_VM_PARAMS_LABELS, CREATED_VM_LABELS),
-        ("create_vm_params_instancetype", "created_vm_instancetype"),
+        (CREATE_VM_PARAMS_INSTANCETYPE, CREATED_VM_INSTANCETYPE),
-        ("create_vm_params_preference", "created_vm_preference"),
+        (CREATE_VM_PARAMS_PREFERENCE, CREATED_VM_PREFERENCE),
-        ("create_vm_params_datavolumetemplate", "created_vm_datavolumetemplate"),
+        (CREATE_VM_PARAMS_DATAVOLUMETEMPLATE, CREATED_VM_DATAVOLUMETEMPLATE),
-        ("create_vm_params_name", "created_vm_name"),
+        (CREATE_VM_PARAMS_NAME, CREATED_VM_NAME),
-        ("create_vm_params_generate_name", "created_vm_generate_name"),
+        (CREATE_VM_PARAMS_GENERATE_NAME, CREATED_VM_GENERATE_NAME),
-        ("create_vm_params_specs", "created_vm_specs"),
+        (CREATE_VM_PARAMS_SPECS, CREATED_VM_SPECS),
     ],
 )
-def test_create_vm(request, params, expected):
+def test_create_vm(params, expected):
-    assert kubevirt_vm.create_vm(
+    assert kubevirt_vm.create_vm(params) == expected
-        request.getfixturevalue(params)
-    ) == request.getfixturevalue(expected)