Refactors integration tests

Signed-off-by: Christopher Grote <cmgrote@users.noreply.github.com>

Author: cmgrote

requirements-dev.txt

@@ -4,6 +4,7 @@ black==22.10.0
 types-requests==2.28.11.17
 pytest==7.3.1
 pytest-order==1.1.0
+retry==0.9.2
 pre-commit==2.20.0
 deepdiff==6.2.1
 pytest-cov==4.0.0

tests/integration/classification_test.py

@@ -1,55 +1,84 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright 2022 Atlan Pte. Ltd.
-from typing import Generator
+import time
+from typing import Generator, Callable
 
 import pytest
 
 from pyatlan.cache.classification_cache import ClassificationCache
 from pyatlan.client.atlan import AtlanClient
+from pyatlan.error import AtlanError
 from pyatlan.model.enums import AtlanClassificationColor, AtlanTypeCategory
 from pyatlan.model.typedef import ClassificationDef
 
+from retry import retry
+import logging
+
+LOGGER = logging.getLogger(__name__)
+
+
 CLS_NAME = "psdk-classification"
 
 
-class ClassificationTest:
-    @staticmethod
-    def create_classification(client: AtlanClient, name: str) -> ClassificationDef:
+@pytest.fixture(scope="session", autouse=True)
+def make_classification(
+    client: AtlanClient,
+) -> Generator[Callable[[str], ClassificationDef], None, None]:
+    created_names = []
+
+    @retry(
+        AtlanError,
+        delay=1,
+        tries=3,
+        max_delay=5,
+        backoff=2,
+        jitter=(0, 1),
+        logger=LOGGER,
+    )
+    def _wait_for_successful_purge(name: str):
+        client.purge_typedef(name)
+
+    def _make_classification(name: str) -> ClassificationDef:
         classification_def = ClassificationDef.create(
             name=name, color=AtlanClassificationColor.GREEN
         )
-        response = client.create_typedef(classification_def)
-        assert response
-        assert len(response.classification_defs) == 1
-        created = response.classification_defs[0]
-        assert created.category == AtlanTypeCategory.CLASSIFICATION
-        assert created.name
-        assert created.guid
-        assert created.name != name
-        assert created.display_name == name
-        return created
-
-    @staticmethod
-    def delete_classification(client: AtlanClient, cls: ClassificationDef) -> None:
-        client.purge_typedef(cls.name)
+        r = client.create_typedef(classification_def)
+        c = r.classification_defs[0]
+        created_names.append(c.name)
+        return c
 
+    yield _make_classification
 
-@pytest.fixture(scope="session")
-def client() -> AtlanClient:
-    return AtlanClient()
+    for n in created_names:
+        try:
+            _wait_for_successful_purge(n)
+        except AtlanError as err:
+            LOGGER.error(err)
 
 
 @pytest.fixture(scope="module")
-def classification_def(client: AtlanClient) -> Generator[ClassificationDef, None, None]:
-    c = ClassificationTest.create_classification(client, CLS_NAME)
-    yield c
-    ClassificationTest.delete_classification(client, c)
+def classification_def(
+    client: AtlanClient, make_classification: Callable[[str], ClassificationDef]
+) -> ClassificationDef:
+    return make_classification(CLS_NAME)
+
+
+def test_classification_def(classification_def: ClassificationDef):
+    assert classification_def
+    assert classification_def.guid
+    assert classification_def.display_name == CLS_NAME
+    assert classification_def.name != CLS_NAME
+    assert classification_def.options
+    assert "color" in classification_def.options.keys()
+    assert (
+        classification_def.options.get("color") == AtlanClassificationColor.GREEN.value
+    )
 
 
-@pytest.mark.usefixtures("classification_def")
-def test_classification_cache():
+def test_classification_cache(classification_def: ClassificationDef):
     cls_id = ClassificationCache.get_id_for_name(CLS_NAME)
     assert cls_id
+    assert cls_id == classification_def.name
     cls_name = ClassificationCache.get_name_for_id(cls_id)
     assert cls_name
     assert cls_name == CLS_NAME

tests/integration/client.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2022 Atlan Pte. Ltd.
+from typing import Type
+
+import pytest
+
+from pyatlan.client.atlan import AtlanClient
+from pyatlan.model.response import A
+
+import logging
+
+LOGGER = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="session", autouse=True)
+def client() -> AtlanClient:
+    return AtlanClient()
+
+
+def delete_asset(client: AtlanClient, asset_type: Type[A], guid: str) -> None:
+    # These assertions check the cleanup actually worked
+    r = client.purge_entity_by_guid(guid)
+    s = r is not None
+    s = s and len(r.assets_deleted(asset_type)) == 1
+    s = s and r.assets_deleted(asset_type)[0].guid == guid
+    if not s:
+        LOGGER.error(f"Failed to remove {asset_type} with GUID {guid}.")

tests/integration/conftest.py

@@ -0,0 +1,5 @@
+pytest_plugins = [
+    "tests.integration.client",
+    "tests.integration.glossary_test",
+    "tests.integration.classification_test",
+]