[DPE-2095] integration tests to pytest

pyproject.toml

@@ -76,6 +76,7 @@ codespell = "^2.1.0"
 flake8 = ">=4.0.1"
 Flake8-pyproject = ">=1.1.0"
 mypy = ">=0.910"
+pytest-mypy = ">=0.10.3"
 lightkube = ">=0.11"
 
 [tool.poetry.group.unit]

tests/__init__.py

@@ -1,27 +0,0 @@
-import os
-import random
-from unittest import TestCase, skipIf
-
-from spark8t.utils import create_dir_if_not_exists  # type: ignore
-
-test_path = os.path.dirname(os.path.abspath(__file__))
-
-DATA_FOLDER = os.path.join(test_path, "resources", "data")
-
-integration_test_flag = bool(int(os.environ.get("IE_TEST", "0")))
-integration_test = skipIf(
-    integration_test_flag is False,
-    "Integration test, to be skipped when running unittests",
-)
-
-
-class UnittestWithTmpFolder(TestCase):
-    TMP_FOLDER = os.path.join("/tmp", "%032x" % random.getrandbits(128))
-
-    @classmethod
-    def setUpClass(cls) -> None:
-        create_dir_if_not_exists(cls.TMP_FOLDER)
-
-    @classmethod
-    def tearDownClass(cls) -> None:
-        os.system(f"rm -rf {cls.TMP_FOLDER}/*")

tests/integration/conftest.py

@@ -0,0 +1,63 @@
+import os
+
+import pytest
+from lightkube.resources.core_v1 import Namespace
+
+from spark8t.domain import Defaults
+from spark8t.services import K8sServiceAccountRegistry, KubeInterface, LightKube
+
+integration_test_flag = bool(int(os.environ.get("IE_TEST", "0")))
+
+
+@pytest.fixture
+def integration_test():
+    if not integration_test_flag:
+        pytest.skip(
+            reason="Integration test, to be skipped when running unittests",
+        )
+
+
+@pytest.fixture
+def kubeconfig():
+    return {"KUBECONFIG": f"{os.environ['HOME']}/.kube/config"}
+
+
+@pytest.fixture
+def defs_with_kubeconf(kubeconfig):
+    return Defaults(dict(os.environ) | kubeconfig)
+
+
+def _get_kube_namespaces(interface):
+    ns_data = interface.exec("get namespaces --no-headers -o name")
+    return [item["metadata"]["name"] for item in ns_data["items"]]
+
+
+@pytest.fixture
+def kubeinterface(defs_with_kubeconf):
+    interface = KubeInterface(defs_with_kubeconf.kube_config)
+    ns_before = _get_kube_namespaces(interface)
+    yield interface
+    ns_after = _get_kube_namespaces(interface)
+    for ns in set(ns_after) - set(ns_before):
+        interface.delete("namespace", ns)
+
+
+def _get_lightkube_namespaces(iface):
+    return [ns.metadata.name for ns in iface.client.list(Namespace)]
+
+
+@pytest.fixture
+def lightkubeinterface(defs_with_kubeconf):
+    interface = LightKube(defs_with_kubeconf.kube_config, defs_with_kubeconf)
+    ns_before = _get_lightkube_namespaces(interface)
+    yield interface
+    ns_after = _get_lightkube_namespaces(interface)
+    for ns in set(ns_after) - set(ns_before):
+        interface.client.delete(Namespace, name=ns)
+
+
+@pytest.fixture
+def registry(kubeinterface):
+    registry = K8sServiceAccountRegistry(kubeinterface)
+    yield registry
+    [registry.delete(account.id) for account in registry.all()]

tests/integration/test_kube_interface.py

@@ -1,81 +1,68 @@
-import os
 from time import sleep
-from unittest import TestCase
 
-from parameterized import parameterized
+import pytest
 
-from spark8t.domain import Defaults, KubernetesResourceType, PropertyFile
-from spark8t.services import AbstractKubeInterface, KubeInterface, LightKube
+from spark8t.domain import KubernetesResourceType, PropertyFile
 from spark8t.utils import umask_named_temporary_file
 
 
-class TestKubeInterface(TestCase):
-    kube_interface: AbstractKubeInterface
-    defaults = Defaults(
-        dict(os.environ) | {"KUBECONFIG": f"{os.environ['HOME']}/.kube/config"}
-    )
-
-    def get_kube_interface(self):
-        return KubeInterface(self.defaults.kube_config)
+@pytest.mark.parametrize(
+    "kubeinterface_name", [("kubeinterface"), ("lightkubeinterface")]
+)
+@pytest.mark.parametrize(
+    "resource_type, resource_name, namespace",
+    [
+        (KubernetesResourceType.NAMESPACE, "spark-namespace", None),
+        (KubernetesResourceType.SERVICEACCOUNT, "spark-sa", "default"),
+    ],
+)
+def test_create_exists_delete(
+    kubeinterface_name, resource_type, resource_name, namespace, request
+):
+    kubeinterface = request.getfixturevalue(kubeinterface_name)
+    kubeinterface.create(resource_type, resource_name, namespace)
 
-    @parameterized.expand(
-        [
-            (KubernetesResourceType.NAMESPACE, "spark-namespace", None),
-            (KubernetesResourceType.SERVICEACCOUNT, "spark-sa", "default"),
-        ]
-    )
-    # @integration_test
-    def test_create_exists_delete(self, resource_type, resource_name, namespace):
-        k1 = self.get_kube_interface()
+    assert kubeinterface.exists(resource_type, resource_name, namespace)
 
-        assert not k1.exists(resource_type, resource_name, namespace)
+    kubeinterface.delete(resource_type, resource_name, namespace)
 
-        k1.create(resource_type, resource_name, namespace)
+    if resource_type == KubernetesResourceType.NAMESPACE:
+        sleep(15)
 
-        assert k1.exists(resource_type, resource_name, namespace)
+    assert not kubeinterface.exists(resource_type, resource_name, namespace)
 
-        k1.delete(resource_type, resource_name, namespace)
 
-        if resource_type == KubernetesResourceType.NAMESPACE:
-            sleep(15)
+@pytest.mark.parametrize(
+    "kubeinterface_name", [("kubeinterface"), ("lightkubeinterface")]
+)
+def test_create_exists_delete_secret(kubeinterface_name, request):
+    secret_name = "my-secret"
+    namespace = "default"
 
-        assert not k1.exists(resource_type, resource_name, namespace)
+    property_file = PropertyFile({"key": "value"})
 
-    def test_create_exists_delete_secret(self):
-        secret_name = "my-secret"
-        namespace = "default"
+    kubeinterface = request.getfixturevalue(kubeinterface_name)
 
-        property_file = PropertyFile({"key": "value"})
+    with umask_named_temporary_file(
+        mode="w", prefix="spark-dynamic-conf-k8s-", suffix=".conf"
+    ) as t:
+        property_file.write(t.file)
 
-        k1 = self.get_kube_interface()
+        t.flush()
 
-        assert not k1.exists(
-            KubernetesResourceType.SECRET_GENERIC, secret_name, namespace
+        kubeinterface.create(
+            KubernetesResourceType.SECRET_GENERIC,
+            secret_name,
+            namespace=namespace,
+            **{"from-env-file": str(t.name)},
         )
 
-        with umask_named_temporary_file(
-            mode="w", prefix="spark-dynamic-conf-k8s-", suffix=".conf"
-        ) as t:
-            property_file.write(t.file)
-
-            t.flush()
-
-            k1.create(
-                KubernetesResourceType.SECRET_GENERIC,
-                secret_name,
-                namespace=namespace,
-                **{"from-env-file": str(t.name)},
-            )
-
-        assert k1.exists(KubernetesResourceType.SECRET_GENERIC, secret_name, namespace)
-
-        k1.delete(KubernetesResourceType.SECRET_GENERIC, secret_name, namespace)
-
-        assert not k1.exists(
-            KubernetesResourceType.SECRET_GENERIC, secret_name, namespace
-        )
+    assert kubeinterface.exists(
+        KubernetesResourceType.SECRET_GENERIC, secret_name, namespace
+    )
 
+    kubeinterface.delete(KubernetesResourceType.SECRET_GENERIC, secret_name, namespace)
 
-class TestLightKube(TestKubeInterface):
-    def get_kube_interface(self):
-        return LightKube(self.defaults.kube_config, self.defaults)
+    assert not kubeinterface.exists(
+        KubernetesResourceType.SECRET_GENERIC, secret_name, namespace
+    )