add tests

Author: enitrat

python/src/cairo_coder/server/app.py

@@ -55,7 +55,7 @@ def hash_user_id(user_id: str | None) -> str | None:
     Returns:
         Hashed user ID (first 32 chars of SHA-256 hex digest) or None if no input
     """
-    if not user_id:
+    if user_id is None:
         return None
     return hashlib.sha256(user_id.encode()).hexdigest()[:32]
 

python/tests/integration/conftest.py

@@ -183,6 +183,7 @@ async def test_db_pool(postgres_container):
                 agent_id VARCHAR(50) NOT NULL,
                 mcp_mode BOOLEAN NOT NULL DEFAULT FALSE,
                 conversation_id VARCHAR(100),
+                user_id VARCHAR(100),
                 chat_history JSONB,
                 query TEXT NOT NULL,
                 generated_answer TEXT,
@@ -199,6 +200,8 @@ async def test_db_pool(postgres_container):
                 ON user_interactions(agent_id);
             CREATE INDEX IF NOT EXISTS idx_interactions_conversation_id
                 ON user_interactions(conversation_id);
+            CREATE INDEX IF NOT EXISTS idx_interactions_user_id
+                ON user_interactions(user_id);
             """
         )
 

python/tests/integration/test_insights_api.py

@@ -221,6 +221,72 @@ async def seed():
         assert len(matching) == 1
         assert matching[0]["conversation_id"] == conv_id
 
+    def test_get_queries_with_user_id_filter(self, client, db_connection):
+        """Test that queries can be filtered by user_id."""
+        import asyncio
+        import json as _json
+        import uuid
+        from datetime import datetime, timedelta, timezone
+
+        now = datetime.now(timezone.utc)
+        user_id = "test-user-hash-789"
+
+        # Seed records with and without user_id
+        async def seed():
+            await db_connection.execute(
+                """
+                INSERT INTO user_interactions (id, created_at, agent_id, mcp_mode, user_id, chat_history, query, generated_answer)
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8),
+                       ($9, $10, $11, $12, $13, $14, $15, $16),
+                       ($17, $18, $19, $20, $21, $22, $23, $24)
+                """,
+                uuid.uuid4(), now - timedelta(hours=2), "cairo-coder", False, user_id, _json.dumps([]), "First msg", "Response 1",
+                uuid.uuid4(), now - timedelta(hours=1), "cairo-coder", False, user_id, _json.dumps([{"role": "user", "content": "First msg"}]), "Second msg", "Response 2",
+                uuid.uuid4(), now - timedelta(minutes=30), "cairo-coder", False, None, _json.dumps([]), "Other msg", "Other response",
+            )
+
+        asyncio.get_event_loop().run_until_complete(seed())
+
+        # Filter by user_id
+        resp = client.get(
+            "/v1/insights/queries",
+            params={"user_id": user_id, "limit": 100, "offset": 0},
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["total"] == 2
+        assert all(item["user_id"] == user_id for item in data["items"])
+
+    def test_get_queries_returns_user_id(self, client, db_connection):
+        """Test that user_id is included in the response."""
+        import asyncio
+        import json as _json
+        import uuid
+        from datetime import datetime, timezone
+
+        now = datetime.now(timezone.utc)
+        user_id = "response-test-user-456"
+
+        async def seed():
+            await db_connection.execute(
+                """
+                INSERT INTO user_interactions (id, created_at, agent_id, mcp_mode, user_id, chat_history, query, generated_answer)
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+                """,
+                uuid.uuid4(), now, "cairo-coder", False, user_id, _json.dumps([]), "Test query", "Test response",
+            )
+
+        asyncio.get_event_loop().run_until_complete(seed())
+
+        resp = client.get("/v1/insights/queries", params={"limit": 100, "offset": 0})
+        assert resp.status_code == 200
+        data = resp.json()
+
+        # Find our seeded record and verify user_id is present
+        matching = [item for item in data["items"] if item.get("user_id") == user_id]
+        assert len(matching) == 1
+        assert matching[0]["user_id"] == user_id
+
 
 class TestDataIngestion:
     async def test_chat_completion_logs_interaction_to_db(self, client, test_db_pool):

python/tests/unit/db/test_repository.py

@@ -202,6 +202,72 @@ async def test_get_interactions_filter_by_conversation_id(test_db_pool, db_conne
     assert None in conv_ids
 
 
+@pytest.mark.asyncio
+async def test_create_user_interaction_with_user_id(test_db_pool, db_connection):
+    """Test that user_id is stored correctly."""
+    from cairo_coder.db.models import UserInteraction
+    from cairo_coder.db.repository import create_user_interaction
+
+    user_id = "hashed_user_abc123"
+    interaction = UserInteraction(
+        agent_id="cairo-coder",
+        mcp_mode=False,
+        user_id=user_id,
+        chat_history=[{"role": "user", "content": "Hello"}],
+        query="Hello",
+        generated_answer="Hi",
+    )
+
+    await create_user_interaction(interaction)
+
+    row = await db_connection.fetchrow("SELECT * FROM user_interactions WHERE id = $1", interaction.id)
+    assert row is not None
+    assert row["user_id"] == user_id
+
+
+@pytest.mark.asyncio
+async def test_get_interactions_filter_by_user_id(test_db_pool, db_connection):
+    """Test that interactions can be filtered by user_id."""
+    from cairo_coder.db.repository import get_interactions
+
+    now = datetime.now(timezone.utc)
+    user_id_1 = "hashed_user_aaa"
+    user_id_2 = "hashed_user_bbb"
+
+    # Seed records with different user IDs
+    await db_connection.execute(
+        """
+        INSERT INTO user_interactions (id, created_at, agent_id, mcp_mode, query, user_id)
+        VALUES ($1, $2, $3, $4, $5, $6),
+               ($7, $8, $9, $10, $11, $12),
+               ($13, $14, $15, $16, $17, $18),
+               ($19, $20, $21, $22, $23, $24)
+        """,
+        uuid.uuid4(), now - timedelta(hours=3), "cairo-coder", False, "First message user 1", user_id_1,
+        uuid.uuid4(), now - timedelta(hours=2), "cairo-coder", False, "Second message user 1", user_id_1,
+        uuid.uuid4(), now - timedelta(hours=1), "cairo-coder", False, "First message user 2", user_id_2,
+        uuid.uuid4(), now - timedelta(minutes=30), "cairo-coder", False, "No user", None,
+    )
+
+    # Filter by user_id 1
+    items, total = await get_interactions(None, None, None, 100, 0, user_id=user_id_1)
+    assert total == 2
+    assert all(it["user_id"] == user_id_1 for it in items)
+
+    # Filter by user_id 2
+    items, total = await get_interactions(None, None, None, 100, 0, user_id=user_id_2)
+    assert total == 1
+    assert items[0]["user_id"] == user_id_2
+
+    # Verify user_id is returned in results
+    items, total = await get_interactions(None, None, None, 100, 0)
+    assert total == 4
+    user_ids = [it.get("user_id") for it in items]
+    assert user_id_1 in user_ids
+    assert user_id_2 in user_ids
+    assert None in user_ids
+
+
 @pytest.mark.asyncio
 async def test_migrate_user_interaction_upsert(test_db_pool, db_connection):
     """Test that migrate_user_interaction performs upsert (insert or update)."""

python/tests/unit/test_server_utils.py

@@ -0,0 +1,30 @@
+"""
+Unit tests for server utility functions.
+"""
+class TestHashUserId:
+    """Tests for the hash_user_id function."""
+
+    def test_hash_user_id_returns_consistent_hash(self):
+        """Test that the same input always produces the same hash."""
+        from cairo_coder.server.app import hash_user_id
+
+        user_id = "test-user-123"
+        hash1 = hash_user_id(user_id)
+        hash2 = hash_user_id(user_id)
+
+        assert hash1 == hash2
+        assert len(hash1) == 32  # Truncated to 32 chars
+
+    def test_hash_user_id_returns_none_for_none_input(self):
+        """Test that None input returns None."""
+        from cairo_coder.server.app import hash_user_id
+
+        result = hash_user_id(None)
+        assert result is None
+
+    def test_hash_user_id_returns_hash_for_empty_string(self):
+        """Test that empty string input returns a hash."""
+        from cairo_coder.server.app import hash_user_id
+
+        result = hash_user_id("")
+        assert result == "e3b0c44298fc1c149afbf4c8996fb924"