fix unit tests

Author: Rafael Marinho

stream_chat/tests/async_chat/conftest.py

@@ -141,3 +141,25 @@ 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

@@ -722,26 +722,77 @@ async def test_query_channels_members_in(
         assert len(response["channels"][0]["members"]) == 9
 
     async def test_create_blocklist(self, client: StreamChatAsync):
-        await client.create_blocklist(name="Foo", words=["fudge", "heck"], type="word")
+        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
 
     async def test_list_blocklists(self, client: StreamChatAsync):
-        response = await client.list_blocklists()
-        assert len(response["blocklists"]) == 2
-        blocklist_names = {blocklist["name"] for blocklist in response["blocklists"]}
-        assert "Foo" in blocklist_names
+        # 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
 
     async def test_get_blocklist(self, client: StreamChatAsync):
-        response = await client.get_blocklist("Foo")
-        assert response["blocklist"]["name"] == "Foo"
-        assert response["blocklist"]["words"] == ["fudge", "heck"]
+        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
 
     async def test_update_blocklist(self, client: StreamChatAsync):
-        await client.update_blocklist("Foo", words=["dang"])
-        response = await client.get_blocklist("Foo")
-        assert response["blocklist"]["words"] == ["dang"]
+        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
 
     async def test_delete_blocklist(self, client: StreamChatAsync):
-        await client.delete_blocklist("Foo")
+        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
 
     async def test_check_push(
         self, client: StreamChatAsync, channel: Channel, random_user: Dict

stream_chat/tests/conftest.py

@@ -131,3 +131,25 @@ 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

@@ -699,26 +699,78 @@ def test_query_channels_members_in(
         assert len(response["channels"][0]["members"]) == 9
 
     def test_create_blocklist(self, client: StreamChat):
-        client.create_blocklist(name="Foo", words=["fudge", "heck"], type="word")
+        # 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
 
     def test_list_blocklists(self, client: StreamChat):
-        response = client.list_blocklists()
-        assert len(response["blocklists"]) == 2
-        blocklist_names = {blocklist["name"] for blocklist in response["blocklists"]}
-        assert "Foo" in blocklist_names
+        # 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
 
     def test_get_blocklist(self, client: StreamChat):
-        response = client.get_blocklist("Foo")
-        assert response["blocklist"]["name"] == "Foo"
-        assert response["blocklist"]["words"] == ["fudge", "heck"]
+        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
 
     def test_update_blocklist(self, client: StreamChat):
-        client.update_blocklist("Foo", words=["dang"])
-        response = client.get_blocklist("Foo")
-        assert response["blocklist"]["words"] == ["dang"]
+        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
 
     def test_delete_blocklist(self, client: StreamChat):
-        client.delete_blocklist("Foo")
+        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
 
     def test_check_push(self, client: StreamChat, channel: Channel, random_user: Dict):
         msg = {"id": str(uuid.uuid4()), "text": "/giphy wave"}