diaspora-event-sdk 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

diaspora_event_sdk/sdk/web_client.py

@@ -1,4 +1,3 @@
-import json
 from typing import Optional
 
 import globus_sdk
@@ -25,131 +24,47 @@ class WebClient(globus_sdk.BaseClient):
         self._user_app_name = None
         self.user_app_name = app_name
 
-    def create_key(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
-        return self.get("/api/v2/create_key", headers={"Subject": str(subject)})
-
-    def list_topics(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
-        return self.get("/api/v2/topics", headers={"Subject": str(subject)})
-
-    def register_topic(
-        self, subject: UUID_LIKE_T, topic: str, action: str
-    ) -> globus_sdk.GlobusHTTPResponse:
-        return self.put(
-            f"/api/v2/topic/{topic}",
-            headers={"Subject": str(subject), "Action": action},
-        )
+    def create_user(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 create_user endpoint (POST /api/v3/user)."""
+        return self.post("/api/v3/user", headers={"Subject": str(subject)})
 
-    def get_topic_configs(
-        self, subject: UUID_LIKE_T, topic: str
-    ) -> globus_sdk.GlobusHTTPResponse:
-        return self.get(
-            f"/api/v2/topic/{topic}", headers={"Subject": str(subject), "Topic": topic}
-        )
+    def delete_user(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 delete_user endpoint (DELETE /api/v3/user)."""
+        return self.delete("/api/v3/user", headers={"Subject": str(subject)})
 
-    def update_topic_configs(
-        self, subject: UUID_LIKE_T, topic: str, configs: dict
-    ) -> globus_sdk.GlobusHTTPResponse:
-        return self.post(
-            f"/api/v2/topic/{topic}",
-            headers={
-                "Subject": str(subject),
-                "Topic": topic,
-                "Content-Type": "text/plain",
-            },
-            data=json.dumps(configs).encode("utf-8"),
-        )
+    def create_key(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 create_key endpoint (POST /api/v3/key)."""
+        return self.post("/api/v3/key", headers={"Subject": str(subject)})
 
-    def update_topic_partitions(
-        self, subject: UUID_LIKE_T, topic: str, new_partitions: int
-    ) -> globus_sdk.GlobusHTTPResponse:
-        return self.post(
-            f"/api/v2/topic/{topic}/partitions",
-            headers={
-                "Subject": str(subject),
-                "Topic": topic,
-                "NewPartitions": str(new_partitions),
-            },
-        )
+    def delete_key(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 delete_key endpoint (DELETE /api/v3/key)."""
+        return self.delete("/api/v3/key", headers={"Subject": str(subject)})
 
-    def reset_topic(
-        self, subject: UUID_LIKE_T, topic: str
-    ) -> globus_sdk.GlobusHTTPResponse:
-        return self.post(
-            f"/api/v2/topic/{topic}/reset",
-            headers={"Subject": str(subject), "Topic": topic},
-        )
+    def list_namespaces(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 list_namespaces endpoint (GET /api/v3/namespace)."""
+        return self.get("/api/v3/namespace", headers={"Subject": str(subject)})
 
-    def grant_user_access(
-        self, subject: UUID_LIKE_T, topic: str, user: UUID_LIKE_T, action: str
+    def create_topic(
+        self, subject: UUID_LIKE_T, namespace: str, topic: str
     ) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 create_topic endpoint (POST /api/v3/{namespace}/{topic})."""
         return self.post(
-            f"/api/v2/topic/{topic}/user",
-            headers={
-                "Subject": str(subject),
-                "Action": action,
-                "Topic": topic,
-                "User": str(user),
-            },
+            f"/api/v3/{namespace}/{topic}", headers={"Subject": str(subject)}
         )
 
-    def list_topic_users(
-        self, subject: UUID_LIKE_T, topic: str
+    def delete_topic(
+        self, subject: UUID_LIKE_T, namespace: str, topic: str
     ) -> globus_sdk.GlobusHTTPResponse:
-        return self.get(
-            f"/api/v2/topic/{topic}/users",
-            headers={"Subject": str(subject), "Topic": topic},
+        """Call the v3 delete_topic endpoint (DELETE /api/v3/{namespace}/{topic})."""
+        return self.delete(
+            f"/api/v3/{namespace}/{topic}", headers={"Subject": str(subject)}
         )
 
-    def list_triggers(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
-        return self.get("/api/v2/triggers", headers={"Subject": str(subject)})
-
-    def create_trigger(
-        self,
-        subject: UUID_LIKE_T,
-        topic: str,
-        function: str,
-        action: str,
-        function_configs: dict,
-        trigger_configs: dict,
+    def recreate_topic(
+        self, subject: UUID_LIKE_T, namespace: str, topic: str
     ) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 recreate_topic endpoint (PUT /api/v3/{namespace}/{topic}/recreate)."""
         return self.put(
-            "/api/v2/trigger",
-            headers={
-                "Subject": str(subject),
-                "Topic": topic,
-                "Trigger": function,
-                "Action": action,
-                "Content-Type": "text/plain",
-            },
-            data=json.dumps(
-                {"function": function_configs, "trigger": trigger_configs}
-            ).encode("utf-8"),
-        )
-
-    def update_trigger(
-        self, subject: UUID_LIKE_T, trigger_uuid: UUID_LIKE_T, trigger_configs: dict
-    ) -> globus_sdk.GlobusHTTPResponse:
-        return self.post(
-            f"/api/v2/triggers/{trigger_uuid}",
-            headers={
-                "Subject": str(subject),
-                "Trigger_id": str(trigger_uuid),
-                "Content-Type": "text/plain",
-            },
-            data=json.dumps(trigger_configs).encode("utf-8"),
-        )
-
-    def list_log_streams(
-        self, subject: UUID_LIKE_T, trigger: str
-    ) -> globus_sdk.GlobusHTTPResponse:
-        return self.get(
-            "/api/v2/logs", headers={"Subject": str(subject), "Trigger": trigger}
-        )
-
-    def get_log_events(
-        self, subject: UUID_LIKE_T, trigger: str, stream: str
-    ) -> globus_sdk.GlobusHTTPResponse:
-        return self.get(
-            "/api/v2/log",
-            headers={"Subject": str(subject), "Trigger": trigger, "Stream": stream},
+            f"/api/v3/{namespace}/{topic}/recreate",
+            headers={"Subject": str(subject)},
         )

diaspora_event_sdk/version.py

@@ -1 +1 @@
-__version__ = "0.4.1"
+__version__ = "0.4.3"

{diaspora_event_sdk-0.4.1.dist-info → diaspora_event_sdk-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: diaspora-event-sdk
-Version: 0.4.1
+Version: 0.4.3
 Summary: Diaspora Event Fabric SDK
 Home-page: https://github.com/globus-labs/diaspora-event-sdk
 License: Apache 2.0
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: globus-sdk<4,>=3.20.1
+Requires-Dist: globus-sdk<4,>=3.59.0
 Provides-Extra: kafka-python
 Requires-Dist: kafka-python; extra == "kafka-python"
 Provides-Extra: test
@@ -27,6 +27,15 @@ Requires-Dist: mypy; extra == "test"
 Requires-Dist: tox; extra == "test"
 Requires-Dist: check-manifest; extra == "test"
 Requires-Dist: pre-commit; extra == "test"
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 # Diaspora Event Fabric SDK
 

{diaspora_event_sdk-0.4.1.dist-info → diaspora_event_sdk-0.4.3.dist-info}/RECORD

@@ -1,12 +1,12 @@
-diaspora_event_sdk/__init__.py,sha256=x5A69JeA_iNi0i1XK3T2wuSTiOLxRhNdGYN4G39wtFw,455
-diaspora_event_sdk/version.py,sha256=pMtTmSUht-XtbR_7Doz6bsQqopJJd8rZ8I8zy2HwwoA,22
+diaspora_event_sdk/__init__.py,sha256=Tayc-lBVFUjkbs-Qvxg_J6vBM0Mhl4yhef53cdkUoPI,426
+diaspora_event_sdk/version.py,sha256=Nyg0pmk5ea9-SLCAFEIF96ByFx4-TJFtrqYPN-Zn6g4,22
 diaspora_event_sdk/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-diaspora_event_sdk/sdk/_environments.py,sha256=HH5mDqxmgryJfc_LOYkfSL6V9oSC6GmIvPvUV-qbn0c,697
+diaspora_event_sdk/sdk/_environments.py,sha256=zuvyoMtGsUA3J0GI92NBn-z_1J4GbiE7WaUgKe8-dpI,501
 diaspora_event_sdk/sdk/aws_iam_msk.py,sha256=9fPH7lgdfZhxKohdZE7shGPYIA4-X-XRbA5KdY-Agjo,3933
-diaspora_event_sdk/sdk/client.py,sha256=6UuFuFX02Q62_iOkjRHDp7iFQs9vGRJ3J-QDa_rqJDc,8767
+diaspora_event_sdk/sdk/client.py,sha256=RMSWVTsW6JQr9L2rp5LktMw5oztpRJkrIQk5GFo8Ses,4277
 diaspora_event_sdk/sdk/decorators.py,sha256=Gel8AyhIjbf4-FNintTNcOqvC9hHH_YwbOH257Nfmf0,884
-diaspora_event_sdk/sdk/kafka_client.py,sha256=sXkqGx3ckyvaXU35um7EgAFhmqpDd5szl7ZVUYZD2zM,4780
-diaspora_event_sdk/sdk/web_client.py,sha256=mc6OvYgq8Cl-irjOW5FfhU_1fl1nRF8OKlPPmaQc0zo,4992
+diaspora_event_sdk/sdk/kafka_client.py,sha256=WSYkyGRmTtPtLQiPe-Slc3Zq2QqohVVX1d_qJu7h6ZE,6124
+diaspora_event_sdk/sdk/web_client.py,sha256=VtEk4luVw7afc0vhtGhG-qd4vWvuBGLA6vkU_qriuoA,2791
 diaspora_event_sdk/sdk/botocore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diaspora_event_sdk/sdk/botocore/auth.py,sha256=QXwCNMzM0wAqD64RlFd-K27atRpixti73VKConpb1kk,18699
 diaspora_event_sdk/sdk/botocore/awsrequest.py,sha256=fcR28YxbsCk2ZT1rGtgWxhje-sYt-SxIqixjOWAFLcM,9344
@@ -19,16 +19,15 @@ diaspora_event_sdk/sdk/login_manager/client_login.py,sha256=e8o6Tf40AW61auHNhQ_5
 diaspora_event_sdk/sdk/login_manager/decorators.py,sha256=JlCEwoceSMmFy6PLQ5kz5mpkKfitJgCVAA6I4I_k1nw,1013
 diaspora_event_sdk/sdk/login_manager/globus_auth.py,sha256=pbDy67Mdf4SKFf0IlXD3ZFGj4lG-xpzFTD1ygW-0H1k,430
 diaspora_event_sdk/sdk/login_manager/login_flow.py,sha256=NjmDtr9QWCG1SIPt9TL3pxcUgLfz2qzzWVHBBMJWvE0,978
-diaspora_event_sdk/sdk/login_manager/manager.py,sha256=AD3f8rx154oesgkpqG0K-eZsEGjntr08Vgrxr1m6uao,7040
+diaspora_event_sdk/sdk/login_manager/manager.py,sha256=NU5uzYE8UTiQjMLhpO7Mrr3vbUZy5DYQ3u60wUEHZVc,9335
 diaspora_event_sdk/sdk/login_manager/protocol.py,sha256=ipAOUi7GYF5YfU-az1LWUbU_rNXHarDwUkKn6TUyjVY,678
 diaspora_event_sdk/sdk/login_manager/tokenstore.py,sha256=ImncC8EIxoAuGtDiZIwdtUgOD2fWo8oBP22G-fiZ5L4,2036
 diaspora_event_sdk/sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diaspora_event_sdk/sdk/utils/uuid_like.py,sha256=xbxf0YXpDhdii16lwPLWRN21qFekHrNrqODSToMPtCg,470
+diaspora_event_sdk-0.4.3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/unit/apis_test.py,sha256=Fo_WxVARfcqIPmKuLHJFAwRINW-3wzEWmttunOcOhMQ,4463
-tests/unit/client_test.py,sha256=kmvrZnxzri20BDO8g8IWiZvnQGNjD1b970kLr4BwEe4,3012
-diaspora_event_sdk-0.4.1.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-diaspora_event_sdk-0.4.1.dist-info/METADATA,sha256=-AvJC2ZPBxMe7pGEYfNXSfE0lfYRqOsZqv6LS-0AhWQ,3631
-diaspora_event_sdk-0.4.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-diaspora_event_sdk-0.4.1.dist-info/top_level.txt,sha256=OVun-67t3fkLFEIwvJuNINgFFvAc--bClYhXjLhMmvs,25
-diaspora_event_sdk-0.4.1.dist-info/RECORD,,
+tests/unit/apis_test.py,sha256=x9Pd8Ss2COtXk7nKez4wHw0-Xp7GDeJT9bIWXJ1K5GQ,9140
+diaspora_event_sdk-0.4.3.dist-info/METADATA,sha256=xbh2IbvzvA9GzImKof6slxSVw2E0OGe524Tcf1hEbI8,3828
+diaspora_event_sdk-0.4.3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+diaspora_event_sdk-0.4.3.dist-info/top_level.txt,sha256=OVun-67t3fkLFEIwvJuNINgFFvAc--bClYhXjLhMmvs,25
+diaspora_event_sdk-0.4.3.dist-info/RECORD,,

{diaspora_event_sdk-0.4.1.dist-info → diaspora_event_sdk-0.4.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.1)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/unit/apis_test.py

@@ -1,9 +1,8 @@
 import pytest
 import os
 import logging
-from globus_sdk import ConfidentialAppAuthClient
+import uuid
 from diaspora_event_sdk import Client
-from diaspora_event_sdk.sdk.login_manager import tokenstore
 
 # Configure module-level logger
 logging.basicConfig(
@@ -14,123 +13,277 @@ logger = logging.getLogger(__name__)
 
 
 @pytest.fixture(scope="module")
-def setup():
-    client_id = os.environ["DIASPORA_SDK_CLIENT_ID"]
-    client_secret = os.environ["DIASPORA_SDK_CLIENT_SECRET"]
-    requested_scopes = os.environ["CLIENT_SCOPE"]
-    # assert client_id
-    # assert client_secret
-    # assert requested_scopes
-
-    ca = ConfidentialAppAuthClient(
-        client_id=client_id,
-        client_secret=client_secret,
+def client():
+    """Create a Client instance for integration tests.
+
+    Requires environment variables:
+    - DIASPORA_SDK_CLIENT_ID
+    - DIASPORA_SDK_CLIENT_SECRET
+    - DIASPORA_SCOPE (optional, defaults to action_all scope)
+
+    Note: CLIENT_SCOPE is used for backward compatibility but should only
+    contain scopes for a single resource server.
+    """
+    # Ensure required environment variables are set
+    assert os.environ.get("DIASPORA_SDK_CLIENT_ID"), (
+        "DIASPORA_SDK_CLIENT_ID must be set"
     )
-    token_response = ca.oauth2_client_credentials_tokens(
-        requested_scopes=requested_scopes,
+    assert os.environ.get("DIASPORA_SDK_CLIENT_SECRET"), (
+        "DIASPORA_SDK_CLIENT_SECRET must be set"
     )
-    token = token_response.by_resource_server[client_id]
 
-    storage = tokenstore.get_token_storage_adapter()
-    storage.store(token_response)
-    storage.get_by_resource_server()
+    # Set DIASPORA_SCOPE if CLIENT_SCOPE is set (for backward compatibility)
+    # This ensures the LoginManager uses the correct scope for client credentials
+    if "CLIENT_SCOPE" in os.environ and "DIASPORA_SCOPE" not in os.environ:
+        os.environ["DIASPORA_SCOPE"] = os.environ["CLIENT_SCOPE"]
 
-    return {
-        "client_id": client_id,
-        "client_secret": client_secret,
-        "requested_scopes": requested_scopes,
-        "token_response": token_response,
-        "token": token,
-    }
+    return Client()
 
 
-@pytest.fixture(scope="module")
-def client():
-    return Client()
+@pytest.mark.integration
+def test_create_user(client):
+    """Test create_user API."""
+    result = client.create_user()
+    logger.info(f"create_user result: {result}")
+    assert result["status"] == "success"
+    assert "subject" in result
+    assert "namespace" in result
+    assert result["namespace"].startswith("ns-")
+
+
+@pytest.mark.integration
+def test_create_user_idempotent(client):
+    """Test create_user is idempotent (can be called multiple times)."""
+    result1 = client.create_user()
+    logger.info(f"create_user first call: {result1}")
+    assert result1["status"] == "success"
+
+    result2 = client.create_user()
+    logger.info(f"create_user second call: {result2}")
+    assert result2["status"] == "success"
+    # Should return same namespace
+    assert result1["namespace"] == result2["namespace"]
+
+
+@pytest.mark.integration
+def test_create_key(client):
+    """Test create_key API."""
+    # Ensure user exists first
+    client.create_user()
+
+    result = client.create_key()
+    logger.info(f"create_key result: {result}")
+    assert result["status"] == "success"
+    assert "access_key" in result
+    assert "secret_key" in result
+    assert "create_date" in result
+    assert "endpoint" in result
+    assert len(result["access_key"]) > 0
+    assert len(result["secret_key"]) > 0
+
+
+@pytest.mark.integration
+def test_create_key_idempotent(client):
+    """Test create_key is idempotent (returns existing key if present)."""
+    # Ensure user exists
+    client.create_user()
+
+    result1 = client.create_key()
+    logger.info(f"create_key first call: {result1}")
+    assert result1["status"] == "success"
+    access_key1 = result1["access_key"]
+
+    result2 = client.create_key()
+    logger.info(f"create_key second call: {result2}")
+    assert result2["status"] == "success"
+    # Should return same access key (idempotent)
+    assert result2["access_key"] == access_key1
+
+
+@pytest.mark.integration
+def test_list_namespaces(client):
+    """Test list_namespaces API."""
+    # Ensure user and namespace exist
+    client.create_user()
+
+    result = client.list_namespaces()
+    logger.info(f"list_namespaces result: {result}")
+    assert result["status"] == "success"
+    assert "namespaces" in result
+    assert isinstance(result["namespaces"], dict)
+    # Should include the default namespace
+    assert client.namespace in result["namespaces"]
+
+
+@pytest.mark.integration
+def test_create_topic(client):
+    """Test create_topic API."""
+    # Ensure user exists
+    client.create_user()
+
+    topic_name = f"test-topic-{str(uuid.uuid4())[:8]}"
+    result = client.create_topic(topic_name)
+    logger.info(f"create_topic result: {result}")
+    assert result["status"] == "success"
+    assert "topics" in result
+    assert isinstance(result["topics"], list)
+    assert topic_name in result["topics"]
+
+    # Cleanup
+    client.delete_topic(topic_name)
+
+
+@pytest.mark.integration
+def test_create_topic_idempotent(client):
+    """Test create_topic is idempotent (can be called multiple times)."""
+    # Ensure user exists
+    client.create_user()
+
+    topic_name = f"test-topic-{str(uuid.uuid4())[:8]}"
+    result1 = client.create_topic(topic_name)
+    logger.info(f"create_topic first call: {result1}")
+    assert result1["status"] == "success"
+
+    result2 = client.create_topic(topic_name)
+    logger.info(f"create_topic second call: {result2}")
+    assert result2["status"] == "success"
+    # Topic should still be in the list
+    assert topic_name in result2["topics"]
+
+    # Cleanup
+    client.delete_topic(topic_name)
+
+
+@pytest.mark.integration
+def test_delete_topic(client):
+    """Test delete_topic API."""
+    # Ensure user exists
+    client.create_user()
+
+    topic_name = f"test-topic-{str(uuid.uuid4())[:8]}"
+    # Create topic first
+    create_result = client.create_topic(topic_name)
+    assert create_result["status"] == "success"
+    assert topic_name in create_result["topics"]
+
+    # Delete topic
+    result = client.delete_topic(topic_name)
+    logger.info(f"delete_topic result: {result}")
+    assert result["status"] == "success"
+    assert "topics" in result
+    assert topic_name not in result["topics"]
+
+
+@pytest.mark.integration
+def test_delete_topic_idempotent(client):
+    """Test delete_topic is idempotent (can be called multiple times)."""
+    # Ensure user exists
+    client.create_user()
+
+    topic_name = f"test-topic-{str(uuid.uuid4())[:8]}"
+    # Create topic first
+    client.create_topic(topic_name)
+
+    # Delete topic first time
+    result1 = client.delete_topic(topic_name)
+    logger.info(f"delete_topic first call: {result1}")
+    assert result1["status"] == "success"
+
+    # Delete topic second time (should still succeed)
+    result2 = client.delete_topic(topic_name)
+    logger.info(f"delete_topic second call: {result2}")
+    assert result2["status"] in ("success", "failure")  # May fail if already deleted
+
+
+@pytest.mark.integration
+def test_recreate_topic(client):
+    """Test recreate_topic API."""
+    # Ensure user exists
+    client.create_user()
+
+    topic_name = f"test-topic-{str(uuid.uuid4())[:8]}"
+    # Create topic first
+    create_result = client.create_topic(topic_name)
+    assert create_result["status"] == "success"
+
+    # Recreate topic
+    result = client.recreate_topic(topic_name)
+    logger.info(f"recreate_topic result: {result}")
+    assert result["status"] == "success"
+
+    # Cleanup
+    client.delete_topic(topic_name)
+
+
+@pytest.mark.integration
+def test_delete_key(client):
+    """Test delete_key API."""
+    # Ensure user and key exist
+    client.create_user()
+    client.create_key()
+
+    result = client.delete_key()
+    logger.info(f"delete_key result: {result}")
+    assert result["status"] == "success"
+
+
+@pytest.mark.integration
+def test_delete_key_idempotent(client):
+    """Test delete_key is idempotent (can be called multiple times)."""
+    # Ensure user and key exist
+    client.create_user()
+    client.create_key()
+
+    # Delete key first time
+    result1 = client.delete_key()
+    logger.info(f"delete_key first call: {result1}")
+    assert result1["status"] == "success"
+
+    # Delete key second time (should still succeed)
+    result2 = client.delete_key()
+    logger.info(f"delete_key second call: {result2}")
+    assert result2["status"] in ("success", "failure")  # May fail if already deleted
+
+
+@pytest.mark.integration
+def test_full_lifecycle(client):
+    """Test full user lifecycle: create user, key, topic, then cleanup."""
+    # 1. Create user
+    user_result = client.create_user()
+    logger.info(f"Created user: {user_result}")
+    assert user_result["status"] == "success"
+    namespace = user_result["namespace"]
+
+    # 2. Create key
+    key_result = client.create_key()
+    logger.info(f"Created key: {key_result}")
+    assert key_result["status"] == "success"
+    assert "access_key" in key_result
+
+    # 3. List namespaces
+    namespaces_result = client.list_namespaces()
+    logger.info(f"Listed namespaces: {namespaces_result}")
+    assert namespaces_result["status"] == "success"
+    assert namespace in namespaces_result["namespaces"]
+
+    # 4. Create topic
+    topic_name = f"test-topic-{str(uuid.uuid4())[:8]}"
+    topic_result = client.create_topic(topic_name)
+    logger.info(f"Created topic: {topic_result}")
+    assert topic_result["status"] == "success"
+    assert topic_name in topic_result["topics"]
+
+    # 5. Delete topic
+    delete_topic_result = client.delete_topic(topic_name)
+    logger.info(f"Deleted topic: {delete_topic_result}")
+    assert delete_topic_result["status"] == "success"
 
+    # 6. Delete key
+    delete_key_result = client.delete_key()
+    logger.info(f"Deleted key: {delete_key_result}")
+    assert delete_key_result["status"] == "success"
 
-def test_create_key(setup, client):
-    key_response = client.create_key()
-    assert isinstance(key_response, dict)
-    assert "access_key" in key_response
-    assert "secret_key" in key_response
-    assert "endpoint" in key_response
-
-
-def test_register_topic(setup, client):
-    topic = "topic" + client.subject_openid[-12:]
-    register_response = client.register_topic(topic)
-    assert register_response["status"] in ["success", "no-op"]
-    assert "message" in register_response
-
-
-def test_list_topics(setup, client):
-    topics = client.list_topics()
-    print(client.subject_openid, topics)
-    assert topics["status"] == "success"
-    assert isinstance(topics["topics"], list)
-    assert len(topics["topics"]) > 0
-    expected_topics = ["diaspora-cicd"]
-    assert set(expected_topics).issubset(set(topics["topics"]))
-
-
-def test_get_topic_configs(setup, client):
-    topic = "topic" + client.subject_openid[-12:]
-    client.register_topic(topic)
-    configs_response = client.get_topic_configs(topic)
-    assert configs_response["status"] == "success"
-    assert "configs" in configs_response
-    assert isinstance(configs_response["configs"], dict)
-
-
-def test_update_topic_configs(setup, client):
-    topic = "topic" + client.subject_openid[-12:]
-    client.register_topic(topic)
-    configs = {"min.insync.replicas": 1}
-    update_response = client.update_topic_configs(topic, configs)
-    assert update_response["status"] == "success"
-    assert "before" in update_response
-    assert "after" in update_response
-    assert isinstance(update_response["before"], dict)
-    assert isinstance(update_response["after"], dict)
-
-
-def test_update_topic_partitions(setup, client):
-    topic = "topic" + client.subject_openid[-12:]
-    client.register_topic(topic)
-    new_partitions = 2
-    partitions_response = client.update_topic_partitions(topic, new_partitions)
-    assert partitions_response["status"] in ["success", "error"]
-    if partitions_response["status"] == "error":
-        assert "message" in partitions_response
-
-
-def test_reset_topic(setup, client):
-    topic = "topic" + client.subject_openid[-12:]
-    client.register_topic(topic)
-    reset_response = client.reset_topic(topic)
-    assert reset_response["status"] in ["success", "error"]
-    if reset_response["status"] == "error":
-        assert "message" in reset_response
-
-
-def test_user_access_management(setup, client):
-    topic = "topic" + client.subject_openid[-12:]
-    client.register_topic(topic)
-    user_id = "diaspora-cicd"
-    grant_response = client.grant_user_access(topic, user_id)
-    assert grant_response["status"] in ["success", "no-op"]
-    assert "message" in grant_response
-
-    list_users_response = client.list_topic_users(topic)
-    assert list_users_response["status"] == "success"
-    assert "users" in list_users_response
-    assert isinstance(list_users_response["users"], list)
-
-    revoke_response = client.revoke_user_access(topic, user_id)
-    assert revoke_response["status"] in ["success", "no-op"]
-    assert "message" in revoke_response
-
-
-if __name__ == "__main__":
-    pytest.main(["-s", "tests/unit/test_apis.py"])
+    # 7. Delete user
+    delete_user_result = client.delete_user()
+    logger.info(f"Deleted user: {delete_user_result}")
+    assert delete_user_result["status"] == "success"