Merge pull request #44 from ClassConnect-org/tests

Add: Test for db delete

Author: mmosan

tests/unit/test_db_delete.py

@@ -2,16 +2,35 @@
 from unittest.mock import MagicMock
 
 import pytest
+from fastapi import HTTPException
 from fastapi.responses import Response
 
-# Adjust import to real path
 from app.db.connector import DB
 
 
-# Fake connection and pool classes as per provided tests
+class DummyPool:
+    def __init__(self, conn=None, error=None):
+        self._conn = conn
+        self._error = error
+        self.got = False
+        self.put_back = False
+
+    def getconn(self):
+        self.got = True
+        if self._error:
+            raise self._error
+        return self._conn
+
+    def putconn(self, conn):
+        self.put_back = True
+
+
+# Fake connection and pool classes
 class FakeConn:
-    def __init__(self):
+    def __init__(self, rowcount=1):
         self.cursor_obj = MagicMock()
+        # simulate cursor().rowcount attribute
+        self.cursor_obj.rowcount = rowcount
 
     def cursor(self):
         return self.cursor_obj
@@ -25,7 +44,6 @@ def close(self):
 
 class FakePool:
     def __init__(self, minconn, maxconn, dsn):
-        # can assert on minconn, maxconn, dsn if desired
         self._conn = FakeConn()
         self.getconn = MagicMock(return_value=self._conn)
         self.putconn = MagicMock()
@@ -34,91 +52,66 @@ def __init__(self, minconn, maxconn, dsn):
 
 @pytest.fixture(autouse=True)
 def fake_pool(monkeypatch):
-    # Patch environment and pool initializer
+    # Patch the SimpleConnectionPool to return our FakePool
     monkeypatch.setenv("DATABASE_URL", "postgres://fake")
     monkeypatch.setattr(
         "app.db.connector.pool.SimpleConnectionPool",
         lambda minconn, maxconn, dsn: FakePool(minconn, maxconn, dsn),
     )
-    # Reset singleton
+    # Reset singleton instance
     DB._instance = None
     yield
 
 
-def test_create_table_and_store_chat():
-    # Instantiate DB so __init__ runs create_table
-    db = DB(minconn=2, maxconn=5)
-    fake_pool = db.pool
-    conn = fake_pool.getconn()
-    # Check that DDL for chats table was executed
-    expected_ddl = """
-                CREATE TABLE IF NOT EXISTS chats (
-                    uid UUID PRIMARY KEY,
-                    question TEXT NOT NULL,
-                    answer TEXT NOT NULL,
-                    votes INTEGER DEFAULT 0,
-                    comment TEXT,
-                    user_id UUID
-                );
-            """
-    conn.cursor_obj.execute.assert_any_call(expected_ddl)
-    # putconn called for initialization
-    fake_pool.putconn.assert_called_with(conn)
-
-    # Now test store_chat
-    fake_pool.getconn.reset_mock()
-    fake_pool.putconn.reset_mock()
-    conn.cursor_obj.reset_mock()
-
-    test_uid = str(uuid.uuid4())
-    test_user = uuid.uuid4()
-    db.store_chat("¿Hola?", "¡Hola!", test_uid, test_user)
-
-    # Verify INSERT called with correct SQL and params
-    conn.cursor_obj.execute.assert_called_once_with(
-        """
-                INSERT into chats (uid, question, answer, votes, user_id) values (%s, %s, %s, %s, %s);
-            """,
-        (test_uid, "¿Hola?", "¡Hola!", 0, str(test_user)),
-    )
-    fake_pool.putconn.assert_called_with(conn)
+@pytest.fixture(autouse=True)
+def setup_pool(monkeypatch):
+    # Prepare a DummyPool and assign to DB instances
+    pool = DummyPool()
+    # Patch DB class to use our pool
+    yield pool
 
 
-def test_change_votes_success_up():
-    db = DB()
-    # Prepare inputs
-    chat_id = "11111111-1111-1111-1111-111111111111"
-    user_id = uuid.UUID(int=0)
-    # Call change_votes to upvote
-    response = db.change_votes(
-        chat_id=chat_id,
-        up=True,
-        down=False,
-        equal=False,
-        user_id=user_id,
-        comment="Comentario",
-    )
+def test_delete_chat_success():
+    db = DB(minconn=1, maxconn=1)
+    conn = db.pool.getconn()
+    # Ensure rowcount > 0
+    conn.cursor_obj.rowcount = 1
 
+    response = db.delete_chat(str(uuid.uuid4()))
+    # Should return 204 response
     assert isinstance(response, Response)
     assert response.status_code == 204
+    # Verify DELETE executed
+    sql, params = conn.cursor_obj.execute.call_args[0]
+    assert "DELETE FROM chats" in sql
+    # Connection returned to pool
+    assert db.pool.putconn.called
 
-    # Inspect cursor calls
-    fake_conn = db.pool.getconn()
-    fake_cursor = fake_conn.cursor_obj
-    calls = fake_cursor.execute.call_args_list
-    assert calls, "cursor.execute was not called"
-
-    expected_params = (
-        1,
-        "Comentario",
-        chat_id,
-        str(user_id),
-    )
-    # Find call with UPDATE chats and expected params
-    found = any(
-        "UPDATE chats" in call.args[0] and call.args[1] == expected_params
-        for call in calls
-    )
-    assert found, f"No UPDATE chats call with params {expected_params}, calls: {calls}"
-    # Ensure connection returned
+
+def test_delete_chat_not_found():
+    db = DB(minconn=1, maxconn=1)
+    conn = db.pool.getconn()
+    # Simulate no rows deleted
+    conn.cursor_obj.rowcount = 0
+
+    with pytest.raises(HTTPException) as exc:
+        db.delete_chat(str(uuid.uuid4()))
+    assert exc.value.status_code == 404
+    assert "not found" in exc.value.detail.lower()
+    # Connection returned
     assert db.pool.putconn.called
+
+
+def test_delete_chat_db_error(setup_pool):
+    # Simulate generic exception during getconn
+    setup_pool._conn = None
+    setup_pool._error = Exception("DB down")
+
+    db = DB()
+    result = db.delete_chat("any-id")
+    # On generic exception, should return a 204 Response
+    assert isinstance(result, Response), "Expected a Response on generic error"
+    assert result.status_code == 204, "Expected status code 204"
+    # pool.getconn was attempted
+    # No putconn since conn was never established
+    assert not setup_pool.put_back, "Did not expect pool.putconn when getconn fails"