revert

Author: Rafael Marinho

stream_chat/tests/async_chat/conftest.py

@@ -141,25 +141,3 @@ async def hard_delete_users(client: StreamChatAsync, user_ids: List[str]):
         )
     except Exception:
         pass
-
-
-async def cleanup_blocklists_async(client: StreamChatAsync):
-    """Clean up test blocklists"""
-    try:
-        # Delete common test blocklist names
-        test_blocklists = ["Foo", "TestBlocklist", "TestBlocklistAsync"]
-        for blocklist_name in test_blocklists:
-            try:
-                await client.delete_blocklist(blocklist_name)
-            except Exception:
-                pass  # Blocklist might not exist
-    except Exception:
-        pass
-
-
-@pytest.fixture(autouse=True, scope="session")
-async def cleanup_test_data():
-    """Global cleanup for test data"""
-    yield
-    # This runs after all tests complete
-    # Add any global cleanup here if needed

stream_chat/tests/async_chat/test_client.py

@@ -15,10 +15,7 @@
 from stream_chat.async_chat import StreamChatAsync
 from stream_chat.async_chat.channel import Channel
 from stream_chat.base.exceptions import StreamAPIException
-from stream_chat.tests.async_chat.conftest import (
-    cleanup_blocklists_async,
-    hard_delete_users,
-)
+from stream_chat.tests.async_chat.conftest import hard_delete_users
 from stream_chat.tests.utils import wait_for_async
 
 
@@ -725,89 +722,26 @@ async def test_query_channels_members_in(
         assert len(response["channels"][0]["members"]) == 9
 
     async def test_create_blocklist(self, client: StreamChatAsync):
-        blocklist_name = f"TestBlocklistAsync_{uuid.uuid4().hex[:8]}"
-        await client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-
-        # Clean up after test
-        try:
-            await client.delete_blocklist(blocklist_name)
-        except Exception:
-            pass
+        await client.create_blocklist(name="Foo", words=["fudge", "heck"], type="word")
 
     async def test_list_blocklists(self, client: StreamChatAsync):
-        # First, clean up any existing test blocklists
-        await cleanup_blocklists_async(client)
-
-        # Create a test blocklist
-        blocklist_name = f"TestBlocklistAsync_{uuid.uuid4().hex[:8]}"
-        await client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-
-        try:
-            response = await client.list_blocklists()
-            # Should have at least 1 blocklist (the one we just created)
-            assert len(response["blocklists"]) >= 1
-            blocklist_names = {
-                blocklist["name"] for blocklist in response["blocklists"]
-            }
-            assert blocklist_name in blocklist_names
-        finally:
-            # Clean up
-            try:
-                await client.delete_blocklist(blocklist_name)
-            except Exception:
-                pass
+        response = await client.list_blocklists()
+        assert len(response["blocklists"]) == 2
+        blocklist_names = {blocklist["name"] for blocklist in response["blocklists"]}
+        assert "Foo" in blocklist_names
 
     async def test_get_blocklist(self, client: StreamChatAsync):
-        blocklist_name = f"TestBlocklistAsync_{uuid.uuid4().hex[:8]}"
-        await client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-
-        try:
-            response = await client.get_blocklist(blocklist_name)
-            assert response["blocklist"]["name"] == blocklist_name
-            assert response["blocklist"]["words"] == ["fudge", "heck"]
-        finally:
-            # Clean up
-            try:
-                await client.delete_blocklist(blocklist_name)
-            except Exception:
-                pass
+        response = await client.get_blocklist("Foo")
+        assert response["blocklist"]["name"] == "Foo"
+        assert response["blocklist"]["words"] == ["fudge", "heck"]
 
     async def test_update_blocklist(self, client: StreamChatAsync):
-        blocklist_name = f"TestBlocklistAsync_{uuid.uuid4().hex[:8]}"
-        await client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-
-        try:
-            await client.update_blocklist(blocklist_name, words=["dang"])
-            response = await client.get_blocklist(blocklist_name)
-            assert response["blocklist"]["words"] == ["dang"]
-        finally:
-            # Clean up
-            try:
-                await client.delete_blocklist(blocklist_name)
-            except Exception:
-                pass
+        await client.update_blocklist("Foo", words=["dang"])
+        response = await client.get_blocklist("Foo")
+        assert response["blocklist"]["words"] == ["dang"]
 
     async def test_delete_blocklist(self, client: StreamChatAsync):
-        blocklist_name = f"TestBlocklistAsync_{uuid.uuid4().hex[:8]}"
-        await client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-        await client.delete_blocklist(blocklist_name)
-
-        # Verify it's deleted
-        try:
-            await client.get_blocklist(blocklist_name)
-            pytest.fail("Blocklist should have been deleted")
-        except Exception:
-            pass  # Expected - blocklist should not exist
+        await client.delete_blocklist("Foo")
 
     async def test_check_push(
         self, client: StreamChatAsync, channel: Channel, random_user: Dict

stream_chat/tests/conftest.py

@@ -131,25 +131,3 @@ def hard_delete_users(client: StreamChat, user_ids: List[str]):
         client.delete_users(user_ids, "hard", conversations="hard", messages="hard")
     except Exception:
         pass
-
-
-def cleanup_blocklists(client: StreamChat):
-    """Clean up test blocklists"""
-    try:
-        # Delete common test blocklist names
-        test_blocklists = ["Foo", "TestBlocklist", "TestBlocklistAsync"]
-        for blocklist_name in test_blocklists:
-            try:
-                client.delete_blocklist(blocklist_name)
-            except Exception:
-                pass  # Blocklist might not exist
-    except Exception:
-        pass
-
-
-@pytest.fixture(autouse=True, scope="session")
-def cleanup_test_data():
-    """Global cleanup for test data"""
-    yield
-    # This runs after all tests complete
-    # Add any global cleanup here if needed

stream_chat/tests/test_client.py

@@ -15,7 +15,7 @@
 from stream_chat import StreamChat
 from stream_chat.base.exceptions import StreamAPIException
 from stream_chat.channel import Channel
-from stream_chat.tests.conftest import cleanup_blocklists, hard_delete_users
+from stream_chat.tests.conftest import hard_delete_users
 from stream_chat.tests.utils import wait_for
 
 
@@ -699,90 +699,26 @@ def test_query_channels_members_in(
         assert len(response["channels"][0]["members"]) == 9
 
     def test_create_blocklist(self, client: StreamChat):
-        # Use a unique name to avoid conflicts
-        blocklist_name = f"TestBlocklist_{uuid.uuid4().hex[:8]}"
-        client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-
-        # Clean up after test
-        try:
-            client.delete_blocklist(blocklist_name)
-        except Exception:
-            pass
+        client.create_blocklist(name="Foo", words=["fudge", "heck"], type="word")
 
     def test_list_blocklists(self, client: StreamChat):
-        # First, clean up any existing test blocklists
-        cleanup_blocklists(client)
-
-        # Create a test blocklist
-        blocklist_name = f"TestBlocklist_{uuid.uuid4().hex[:8]}"
-        client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-
-        try:
-            response = client.list_blocklists()
-            # Should have at least 1 blocklist (the one we just created)
-            assert len(response["blocklists"]) >= 1
-            blocklist_names = {
-                blocklist["name"] for blocklist in response["blocklists"]
-            }
-            assert blocklist_name in blocklist_names
-        finally:
-            # Clean up
-            try:
-                client.delete_blocklist(blocklist_name)
-            except Exception:
-                pass
+        response = client.list_blocklists()
+        assert len(response["blocklists"]) == 2
+        blocklist_names = {blocklist["name"] for blocklist in response["blocklists"]}
+        assert "Foo" in blocklist_names
 
     def test_get_blocklist(self, client: StreamChat):
-        blocklist_name = f"TestBlocklist_{uuid.uuid4().hex[:8]}"
-        client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-
-        try:
-            response = client.get_blocklist(blocklist_name)
-            assert response["blocklist"]["name"] == blocklist_name
-            assert response["blocklist"]["words"] == ["fudge", "heck"]
-        finally:
-            # Clean up
-            try:
-                client.delete_blocklist(blocklist_name)
-            except Exception:
-                pass
+        response = client.get_blocklist("Foo")
+        assert response["blocklist"]["name"] == "Foo"
+        assert response["blocklist"]["words"] == ["fudge", "heck"]
 
     def test_update_blocklist(self, client: StreamChat):
-        blocklist_name = f"TestBlocklist_{uuid.uuid4().hex[:8]}"
-        client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-
-        try:
-            client.update_blocklist(blocklist_name, words=["dang"])
-            response = client.get_blocklist(blocklist_name)
-            assert response["blocklist"]["words"] == ["dang"]
-        finally:
-            # Clean up
-            try:
-                client.delete_blocklist(blocklist_name)
-            except Exception:
-                pass
+        client.update_blocklist("Foo", words=["dang"])
+        response = client.get_blocklist("Foo")
+        assert response["blocklist"]["words"] == ["dang"]
 
     def test_delete_blocklist(self, client: StreamChat):
-        blocklist_name = f"TestBlocklist_{uuid.uuid4().hex[:8]}"
-        client.create_blocklist(
-            name=blocklist_name, words=["fudge", "heck"], type="word"
-        )
-        client.delete_blocklist(blocklist_name)
-
-        # Verify it's deleted
-        try:
-            client.get_blocklist(blocklist_name)
-            pytest.fail("Blocklist should have been deleted")
-        except Exception:
-            pass  # Expected - blocklist should not exist
+        client.delete_blocklist("Foo")
 
     def test_check_push(self, client: StreamChat, channel: Channel, random_user: Dict):
         msg = {"id": str(uuid.uuid4()), "text": "/giphy wave"}