Modify integration tests that are dependent on mark.atlan.com to use a different client until they can be refactored

Author: ErnestoLoma

.github/workflows/pytest.yaml

@@ -29,7 +29,9 @@ jobs:
           flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
       - name: Test with pytest
         env: # Or as an environment variable
-          ATLAN_API_KEY: ${{ secrets.MARK_ATLAN_API_KEY }}
-          ATLAN_BASE_URL: https://mark.atlan.com
+          ATLAN_API_KEY: ${{ secrets.ATLAN_API_KEY }}
+          ATLAN_BASE_URL: ${{ secrets.ATLAN_BASE_URL }}
+          MARK_API_KEY: ${{ secrets.MARK_ATLAN_API_KEY }}
+          MARK_BASE_URL: https://mark.atlan.com
         run: |
           pytest

setup.py

@@ -67,6 +67,8 @@ def read(file_name):
             "pre-commit>=2.20.0",
             "deepdiff>=6.2.1",
             "pytest-cov>=4.0.0",
+            "pytest-order==1.1.0",
+            "retry==0.9.2",
             "twine>=4.0.2",
         ]
     },

tests/integration/classification_test.py

@@ -1,25 +1,24 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright 2022 Atlan Pte. Ltd.
-from typing import Generator, Callable
+import logging
+from typing import Callable, Generator
 
 import pytest
+from retry import retry
 
 from pyatlan.cache.classification_cache import ClassificationCache
 from pyatlan.client.atlan import AtlanClient
 from pyatlan.error import AtlanError
 from pyatlan.model.enums import AtlanClassificationColor
 from pyatlan.model.typedef import ClassificationDef
 
-from retry import retry
-import logging
-
 LOGGER = logging.getLogger(__name__)
 
 
 CLS_NAME = "psdk-classification"
 
 
-@pytest.fixture(scope="session", autouse=True)
+@pytest.fixture(scope="module", autouse=True)
 def make_classification(
     client: AtlanClient,
 ) -> Generator[Callable[[str], ClassificationDef], None, None]:

tests/integration/client.py

@@ -1,18 +1,17 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright 2022 Atlan Pte. Ltd.
+import logging
 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)
+@pytest.fixture(scope="module", autouse=True)
 def client() -> AtlanClient:
     return AtlanClient()
 

tests/integration/test_client.py

@@ -12,56 +12,64 @@
 
 
 @pytest.fixture(scope="module")
-def client() -> AtlanClient:
-    return AtlanClient()
+def m_client() -> AtlanClient:
+    from os import environ
+
+    client = AtlanClient(
+        base_url=environ["MARK_BASE_URL"], api_key=environ["MARK_API_KEY"]
+    )
+    AtlanClient.register_client(client)
+    return client
 
 
 @pytest.fixture(scope="module")
-def connection(client: AtlanClient) -> Connection:
-    return client.get_asset_by_guid("b3a5c49a-0c7c-4e66-8453-f4da8d9ce222", Connection)
+def connection(m_client) -> Connection:
+    return m_client.get_asset_by_guid(
+        "b3a5c49a-0c7c-4e66-8453-f4da8d9ce222", Connection
+    )
 
 
 @pytest.fixture(scope="module")
-def glossary(client: AtlanClient) -> Generator[AtlasGlossary, None, None]:
+def glossary(m_client: AtlanClient) -> Generator[AtlasGlossary, None, None]:
     glossary = AtlasGlossary.create(name="Integration Test Glossary")
-    glossary = client.upsert(glossary).assets_created(asset_type=AtlasGlossary)[0]
+    glossary = m_client.upsert(glossary).assets_created(asset_type=AtlasGlossary)[0]
     yield glossary
-    client.purge_entity_by_guid(guid=glossary.guid)
+    m_client.purge_entity_by_guid(guid=glossary.guid)
 
 
 @pytest.fixture()
 def database(
-    client: AtlanClient, connection: Connection
+    m_client: AtlanClient, connection: Connection
 ) -> Generator[Database, None, None]:
     database = Database.create(
         name=f"Integration_Test_Entity_DB{next(iter_count)}",
         connection_qualified_name=connection.attributes.qualified_name,
     )
-    database = client.upsert(database).assets_created(Database)[0]
+    database = m_client.upsert(database).assets_created(Database)[0]
 
     yield database
 
-    client.purge_entity_by_guid(guid=database.guid)
+    m_client.purge_entity_by_guid(guid=database.guid)
 
 
 @pytest.fixture()
 def make_term(
-    client: AtlanClient, glossary
+    m_client: AtlanClient, glossary
 ) -> Generator[Callable[[str], AtlasGlossaryTerm], None, None]:
     created_term_guids = []
 
     def _make_term(name: str) -> AtlasGlossaryTerm:
         term = AtlasGlossaryTerm.create(
             name=f"Integration Test Glossary Term {name}", anchor=glossary
         )
-        term = client.upsert(term).assets_created(AtlasGlossaryTerm)[0]
+        term = m_client.upsert(term).assets_created(AtlasGlossaryTerm)[0]
         created_term_guids.append(term.guid)
         return term
 
     yield _make_term
 
     for guid in created_term_guids:
-        client.purge_entity_by_guid(guid=guid)
+        m_client.purge_entity_by_guid(guid=guid)
 
 
 def test_register_client_with_bad_parameter_raises_valueerror():
@@ -77,66 +85,66 @@ def test_register_client():
 
 
 def test_append_terms_with_guid(
-    client: AtlanClient,
+    m_client: AtlanClient,
     make_term: Callable[[str], AtlasGlossaryTerm],
     database: Database,
 ):
     term = make_term("Term1")
 
     assert (
-        database := client.append_terms(
+        database := m_client.append_terms(
             guid=database.guid, asset_type=Database, terms=[term]
         )
     )
-    database = client.get_asset_by_guid(guid=database.guid, asset_type=Database)
+    database = m_client.get_asset_by_guid(guid=database.guid, asset_type=Database)
     assert len(database.terms) == 1
     assert database.terms[0].guid == term.guid
 
 
 def test_append_terms_with_qualified_name(
-    client: AtlanClient,
+    m_client: AtlanClient,
     make_term: Callable[[str], AtlasGlossaryTerm],
     database: Database,
 ):
     term = make_term("Term1")
 
     assert (
-        database := client.append_terms(
+        database := m_client.append_terms(
             qualified_name=database.qualified_name, asset_type=Database, terms=[term]
         )
     )
-    database = client.get_asset_by_guid(guid=database.guid, asset_type=Database)
+    database = m_client.get_asset_by_guid(guid=database.guid, asset_type=Database)
     assert len(database.terms) == 1
     assert database.terms[0].guid == term.guid
 
 
 def test_append_terms_using_ref_by_guid_for_term(
-    client: AtlanClient,
+    m_client: AtlanClient,
     make_term: Callable[[str], AtlasGlossaryTerm],
     database: Database,
 ):
     term = make_term("Term1")
 
     assert (
-        database := client.append_terms(
+        database := m_client.append_terms(
             qualified_name=database.qualified_name,
             asset_type=Database,
             terms=[AtlasGlossaryTerm.ref_by_guid(guid=term.guid)],
         )
     )
-    database = client.get_asset_by_guid(guid=database.guid, asset_type=Database)
+    database = m_client.get_asset_by_guid(guid=database.guid, asset_type=Database)
     assert len(database.terms) == 1
     assert database.terms[0].guid == term.guid
 
 
 def test_replace_a_term(
-    client: AtlanClient,
+    m_client: AtlanClient,
     make_term: Callable[[str], AtlasGlossaryTerm],
     database: Database,
 ):
     original_term = make_term("Term1")
     assert (
-        database := client.append_terms(
+        database := m_client.append_terms(
             qualified_name=database.qualified_name,
             asset_type=Database,
             terms=[AtlasGlossaryTerm.ref_by_guid(guid=original_term.guid)],
@@ -145,12 +153,12 @@ def test_replace_a_term(
 
     replacemant_term = make_term("Term2")
     assert (
-        database := client.replace_terms(
+        database := m_client.replace_terms(
             guid=database.guid, asset_type=Database, terms=[replacemant_term]
         )
     )
 
-    database = client.get_asset_by_guid(guid=database.guid, asset_type=Database)
+    database = m_client.get_asset_by_guid(guid=database.guid, asset_type=Database)
     assert len(database.terms) == 2
     deleted_terms = [t for t in database.terms if t.relationship_status == "DELETED"]
     assert len(deleted_terms) == 1
@@ -161,41 +169,41 @@ def test_replace_a_term(
 
 
 def test_replace_all_term(
-    client: AtlanClient,
+    m_client: AtlanClient,
     make_term: Callable[[str], AtlasGlossaryTerm],
     database: Database,
 ):
     original_term = make_term("Term1")
     assert (
-        database := client.append_terms(
+        database := m_client.append_terms(
             qualified_name=database.qualified_name,
             asset_type=Database,
             terms=[AtlasGlossaryTerm.ref_by_guid(guid=original_term.guid)],
         )
     )
 
     assert (
-        database := client.replace_terms(
+        database := m_client.replace_terms(
             guid=database.guid, asset_type=Database, terms=[]
         )
     )
 
-    database = client.get_asset_by_guid(guid=database.guid, asset_type=Database)
+    database = m_client.get_asset_by_guid(guid=database.guid, asset_type=Database)
     assert len(database.terms) == 1
     deleted_terms = [t for t in database.terms if t.relationship_status == "DELETED"]
     assert len(deleted_terms) == 1
     assert deleted_terms[0].guid == original_term.guid
 
 
 def test_remove_term(
-    client: AtlanClient,
+    m_client: AtlanClient,
     make_term: Callable[[str], AtlasGlossaryTerm],
     database: Database,
 ):
     original_term = make_term("Term1")
     another_term = make_term("Term2")
     assert (
-        database := client.append_terms(
+        database := m_client.append_terms(
             qualified_name=database.qualified_name,
             asset_type=Database,
             terms=[
@@ -206,14 +214,14 @@ def test_remove_term(
     )
 
     assert (
-        database := client.remove_terms(
+        database := m_client.remove_terms(
             guid=database.guid,
             asset_type=Database,
             terms=[AtlasGlossaryTerm.ref_by_guid(original_term.guid)],
         )
     )
 
-    database = client.get_asset_by_guid(guid=database.guid, asset_type=Database)
+    database = m_client.get_asset_by_guid(guid=database.guid, asset_type=Database)
     assert len(database.terms) == 2
     deleted_terms = [t for t in database.terms if t.relationship_status == "DELETED"]
     assert len(deleted_terms) == 1
@@ -222,8 +230,8 @@ def test_remove_term(
     assert active_terms[0].guid == another_term.guid
 
 
-def test_find_connections_by_name(client: AtlanClient):
-    connections = client.find_connections_by_name(
+def test_find_connections_by_name(m_client: AtlanClient):
+    connections = m_client.find_connections_by_name(
         name="Test Connection",
         connector_type=AtlanConnectorType.SNOWFLAKE,
         attributes=["connectorName"],
@@ -232,8 +240,8 @@ def test_find_connections_by_name(client: AtlanClient):
     assert connections[0].connector_name == AtlanConnectorType.SNOWFLAKE.value
 
 
-def test_get_lineage(client: AtlanClient):
-    response = client.get_lineage(
+def test_get_lineage(m_client: AtlanClient):
+    response = m_client.get_lineage(
         LineageRequest(guid="75474eab-3105-4ef9-9f84-709e386a7d3e")
     )
     for guid, asset in response.guid_entity_map.items():