refactor: adjust based on feedback

Signed-off-by: Jack Yu <[email protected]>

Author: Yu-Jack

apiclient/harvester_api/managers/images.py

@@ -78,17 +78,13 @@ def delete(self, name, namespace=DEFAULT_NAMESPACE, *, raw=False):
     def download(self, name, namespace=DEFAULT_NAMESPACE):
         return self._get(self.DOWNLOAD_fmt.format(uid=name, ns=namespace), raw=True)
 
-    def create_crypto_image(
+    def create_by_encrypt(
         self,
         source_image_name,
         new_image_name,
         storage_class_name,
-        crypto_operation,
-        namespace="default",
+        namespace=DEFAULT_NAMESPACE,
     ):
-        """
-        Create encrypted/decrypted image, crypto_operation can be "encrypt" or "decrypt"
-        """
         data = self.create_data(
             name=new_image_name,
             url=None,
@@ -100,12 +96,36 @@ def create_crypto_image(
             storageclass=storage_class_name
         )
 
-        # Remove unnecessary fields
-        data["spec"].pop("checksum", None)
-        data["spec"].pop("url", None)
         # Add securityParameters
         data["spec"]["securityParameters"] = {
-            "cryptoOperation": crypto_operation,
+            "cryptoOperation": "encrypt",
+            "sourceImageName": source_image_name,
+            "sourceImageNamespace": namespace,
+        }
+
+        return self.create("", namespace=namespace, json=data)
+
+    def create_by_decrypt(
+        self,
+        source_image_name,
+        new_image_name,
+        storage_class_name,
+        namespace=DEFAULT_NAMESPACE,
+    ):
+        data = self.create_data(
+            name=new_image_name,
+            url=None,
+            desc="",
+            stype="clone",
+            namespace=namespace,
+            image_checksum=None,
+            display_name=new_image_name,
+            storageclass=storage_class_name
+        )
+
+        # Add securityParameters
+        data["spec"]["securityParameters"] = {
+            "cryptoOperation": "decrypt",
             "sourceImageName": source_image_name,
             "sourceImageNamespace": namespace,
         }

apiclient/harvester_api/managers/secrets.py

@@ -25,14 +25,10 @@ def create_data(self, name, namespace, data, annotations=None):
 
     def create(self, name, data, namespace=DEFAULT_NAMESPACE, annotations=None, **kwargs):
         secret_data = self.create_data(name, namespace, data, annotations=annotations)
-        return self._create(
-            self.CREATE_fmt,
-            json=secret_data, **kwargs)
+        return self._create(self.CREATE_fmt, json=secret_data, **kwargs)
 
     def get(self, name, namespace=DEFAULT_NAMESPACE, *, raw=False):
-        return self._get(
-            self.PATH_fmt.format(ns=namespace, name=name), raw=raw)
+        return self._get(self.PATH_fmt.format(ns=namespace, name=name), raw=raw)
 
     def delete(self, name, namespace=DEFAULT_NAMESPACE, *, raw=False):
-        return self._delete(
-            self.PATH_fmt.format(ns=namespace, name=name), raw=raw)
+        return self._delete(self.PATH_fmt.format(ns=namespace, name=name), raw=raw)

apiclient/harvester_api/managers/storageclasses.py

@@ -23,7 +23,7 @@ def get_default(self):
         else:
             return code, data
 
-    def create_data(self, name, replicas):
+    def create_data(self, name, replicas, **options):
         data = {
             "type": f"{self.API_VERSION}",
             "metadata": {
@@ -39,18 +39,11 @@ def create_data(self, name, replicas):
             "reclaimPolicy": "Delete",
             "volumeBindingMode": "Immediate"
         }
+        return merge_dict(options, data)
 
-        return data
-
-    def create(self, name, replicas=3, *, raw=False):
-        path = self.CREATE_PATH_fmt.format(SC_API=self.API_VERSION)
-        data = self.create_data(name, replicas)
-        return self._create(path, json=data, raw=raw)
-
-    def create_by_parameters(self, name, parameters, replicas=3, *, raw=False):
+    def create(self, name, replicas=3, *, raw=False, **options):
         path = self.CREATE_PATH_fmt.format(SC_API=self.API_VERSION)
-        data = self.create_data(name, replicas)
-        merge_dict(parameters, data["parameters"])
+        data = self.create_data(name, replicas, **options)
         return self._create(path, json=data, raw=raw)
 
     def set_default(self, name, *, raw=False):

harvester_e2e_tests/fixtures/resources.py

@@ -0,0 +1,21 @@
+import pytest
+from .base import wait_until
+
+
+@pytest.fixture(scope="session")
+def resource_checker(api_client, wait_timeout, sleep_timeout):
+    class ResourceChecker:
+        def __init__(self):
+            pass
+
+        @wait_until(wait_timeout, sleep_timeout)
+        def wait_deleted(self, func_get, name, namespace=None):
+            if namespace is not None:
+                code, data = func_get(name, namespace=namespace)
+            else:
+                code, data = func_get(name)
+            if code == 404:
+                return True, (code, data)
+            return False, (code, data)
+
+    return ResourceChecker()

harvester_e2e_tests/integrations/test_1_images.py

@@ -37,27 +37,6 @@ def fake_invalid_image_file():
         yield Path(f.name)
 
 
-def wait_resource_deleted(get_func, name, wait_timeout, namespace=None, sleep_time=3):
-    """
-    Long polling until resource is deleted (get_func returns 404) or timeout.
-    get_func: function to get the resource, should return (code, data)
-    name: resource name
-    wait_timeout: timeout in seconds
-    namespace: optional, if needed by get_func
-    sleep_time: polling interval in seconds
-    """
-    endtime = datetime.now() + timedelta(seconds=wait_timeout)
-    while endtime > datetime.now():
-        if namespace is not None:
-            code, _ = get_func(name, namespace=namespace)
-        else:
-            code, _ = get_func(name)
-        if code == 404:
-            return
-        sleep(sleep_time)
-    raise AssertionError(f"Failed to delete resource {name} in {wait_timeout} seconds")
-
-
 def wait_image_progress(api_client, image_name, wait_timeout):
     """
     Long polling image status until progress == 100 or timeout.
@@ -162,7 +141,7 @@ def cluster_network(api_client, vlan_nic):
 
 
 @pytest.fixture(scope="module")
-def shared_image(api_client, image_ubuntu, unique_name, wait_timeout):
+def shared_image(api_client, image_ubuntu, unique_name, wait_timeout, image_checker):
     source_image_name = f"shared-ubuntu-{unique_name}"
     image_info = image_ubuntu
     create_image_url(
@@ -178,7 +157,7 @@ def shared_image(api_client, image_ubuntu, unique_name, wait_timeout):
     # Cleanup: delete the image after tests
     code, _ = api_client.images.delete(source_image_name)
     if code == 200:
-        wait_resource_deleted(api_client.images.get, source_image_name, wait_timeout)
+        image_checker.wait_deleted(source_image_name)
 
 
 @pytest.fixture(scope="class")