test: update tests to work with the new DI in db manager

Author: GermanMT

tests/conftest.py

@@ -1,31 +1,68 @@
-from unittest.mock import AsyncMock, MagicMock, patch
+from contextlib import asynccontextmanager
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 from fastapi.testclient import TestClient
 
-_mock_db_manager_patch = patch("app.database.DatabaseManager")
+from app.controllers.auth_controller import get_auth_service
+from app.database import get_database_manager
 
-_mock_db_manager_class = _mock_db_manager_patch.start()
-_mock_db_manager = MagicMock()
-_mock_db_manager_class.return_value = _mock_db_manager
 
-_mock_db_manager.get_odmantic_engine.return_value = AsyncMock()
-_mock_db_manager.get_neo4j_driver.return_value = MagicMock()
-_mock_db_manager.initialize = AsyncMock()
-_mock_db_manager.close = AsyncMock()
+@pytest.fixture(scope="session")
+def mock_db_manager():
+    mock_db = MagicMock()
 
+    mock_engine = AsyncMock()
+    mock_db.get_odmantic_engine.return_value = mock_engine
 
-def pytest_sessionfinish(session, exitstatus):
-    _mock_db_manager_patch.stop()
+    mock_driver = MagicMock()
+    mock_session = AsyncMock()
+    mock_driver.session.return_value.__aenter__.return_value = mock_session
+    mock_db.get_neo4j_driver.return_value = mock_driver
 
+    mock_db.initialize = AsyncMock()
+    mock_db.close = AsyncMock()
 
-@pytest.fixture(autouse=True)
-def reset_auth_service_singleton():
-    yield
+    return mock_db
 
 
-@pytest.fixture(scope="module")
-def client():
+@pytest.fixture(scope="session")
+def mock_auth_service():
+    mock_auth = MagicMock()
+    mock_auth.read_user_by_email = AsyncMock()
+    mock_auth.create_user = AsyncMock()
+    mock_auth.create_revoked_token = AsyncMock()
+    mock_auth.update_user_password = AsyncMock()
+    mock_auth.is_token_revoked = AsyncMock()
+    return mock_auth
+
+
+@pytest.fixture(scope="session")
+def mock_jwt_bearer():
+    class MockJWTBearer:
+        async def __call__(self, request):
+            return {"user_id": "abc123"}
+
+    return MockJWTBearer()
+
+
+@pytest.fixture(scope="function")
+def client(mock_db_manager, mock_auth_service, mock_jwt_bearer):
+    from app.controllers.auth_controller import jwt_bearer
     from app.main import app
+
+    @asynccontextmanager
+    async def test_lifespan(app):
+        yield
+
+    app.router.lifespan_context = test_lifespan
+
+    app.dependency_overrides[get_database_manager] = lambda: mock_db_manager
+    app.dependency_overrides[get_auth_service] = lambda: mock_auth_service
+    app.dependency_overrides[jwt_bearer] = lambda: mock_jwt_bearer
+
     with TestClient(app) as c:
         yield c
+
+    app.dependency_overrides.clear()
+

tests/controllers/test_auth_controller.py

@@ -1,43 +1,21 @@
 from unittest.mock import AsyncMock, patch
 
 import pytest
-from fastapi.testclient import TestClient
 from jwt.exceptions import ExpiredSignatureError, InvalidTokenError
 
-from app.main import app
 from app.models.auth import User
 
 
 @pytest.fixture(scope="session", autouse=True)
 def patch_jwt():
-    with patch("app.utils.jwt_encoder.JWTBearer.__call__", new=AsyncMock(return_value={"user_id": "abc123"})):
+    with patch("app.controllers.auth_controller.jwt_bearer.__call__", new=AsyncMock(return_value={"user_id": "abc123"})):
         yield
 
-@pytest.fixture(autouse=True)
-def mock_services():
-    with patch("app.controllers.auth_controller.auth_service") as mock_auth:
-
-        mock_auth.read_user_by_email = AsyncMock()
-        mock_auth.create_user = AsyncMock()
-        mock_auth.validate_password = AsyncMock()
-        mock_auth.change_password = AsyncMock()
-        mock_auth.revoke_token = AsyncMock()
-        mock_auth.is_token_revoked = AsyncMock()
-        mock_auth.create_revoked_token = AsyncMock()
-        mock_auth.update_user_password = AsyncMock()
-
-        yield mock_auth
-
-        mock_auth.reset_mock()
-
-client = TestClient(app)
-
 
 # --- SIGNUP ---
-def test_signup_success(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = None
-    mock_auth.create_user.return_value = None
+def test_signup_success(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = None
+    mock_auth_service.create_user.return_value = None
 
     response = client.post("/signup", json={
         "email": "test@example.com",
@@ -47,9 +25,8 @@ def test_signup_success(mock_services):
     assert response.json()["detail"] == "signup_success"
 
 
-def test_signup_user_exists(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = {"email": "test@example.com"}
+def test_signup_user_exists(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = {"email": "test@example.com"}
 
     response = client.post("/signup", json={"email": "test@example.com", "password": "13pAssword*"})
     assert response.status_code == 409
@@ -62,48 +39,43 @@ def test_signup_user_exists(mock_services):
     ("weAkkaew", 422, "Value error, the password must contain at least one digit"),
     ("1weAkkaew", 422, "Value error, the password must contain at least one special character")
 ])
-def test_signup_fails_with_weak_password(mock_services, password, status_code, error_message):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = None
-    mock_auth.create_user.return_value = None
+def test_signup_fails_with_weak_password(client, mock_auth_service, password, status_code, error_message):
+    mock_auth_service.read_user_by_email.return_value = None
+    mock_auth_service.create_user.return_value = None
 
     response = client.post("/signup", json={"email": "test@example.com", "password": password})
     assert response.status_code == status_code
     assert response.json()["detail"] == "validation_error"
 
 
-def test_signup_wrong_email(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = None
+def test_signup_wrong_email(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = None
 
     response = client.post("/signup", json={"email": "some_text", "password": "13pAssword*"})
     assert response.status_code == 422
     assert response.json()["detail"] == "validation_error"
 
 
 # --- LOGIN ---
-def test_login_user_not_exist(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = None
+def test_login_user_not_exist(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = None
 
     response = client.post("/login", json={"email": "nouser@example.com", "password": "13pAssword*"})
     assert response.status_code == 400
     assert response.json()["detail"] == "user_no_exist"
 
 
-def test_login_wrong_password(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = User(email="test@example.com", password="hashed")
+def test_login_wrong_password(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = User(email="test@example.com", password="hashed")
 
     with patch("app.controllers.auth_controller.password_encoder.verify", new=AsyncMock(return_value=False)):
         response = client.post("/login", json={"email": "test@example.com", "password": "15pAssword*"})
         assert response.status_code == 400
         assert response.json()["detail"] == "user_incorrect_password"
 
 
-def test_login_success(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = User(email="test@example.com", password="hashed")
+def test_login_success(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = User(email="test@example.com", password="hashed")
 
     with patch("app.controllers.auth_controller.password_encoder.verify", new=AsyncMock(return_value=True)), \
          patch("app.controllers.auth_controller.jwt_bearer.create_access_token", new=AsyncMock(return_value="access")), \
@@ -116,41 +88,40 @@ def test_login_success(mock_services):
 
 
 # --- LOGOUT ---
-def test_logout_no_refresh_token(mock_services):
+def test_logout_no_refresh_token(client, mock_auth_service):
+    headers = {"Authorization": "Bearer faketoken"}
     client.cookies.clear()
     client.cookies.set("access_token", "faketoken")
-    response = client.post("/logout")
+    response = client.post("/logout", headers=headers)
     assert response.status_code == 400
     assert response.json()["detail"] == "missing_refresh_token"
 
 
-def test_logout_success(mock_services):
-    mock_auth = mock_services
-    mock_auth.create_revoked_token.return_value = None
+def test_logout_success(client, mock_auth_service):
+    mock_auth_service.create_revoked_token.return_value = None
 
     with patch("app.controllers.auth_controller.jwt_bearer.read_expiration_date", new=AsyncMock(return_value=123456)):
+        headers = {"Authorization": "Bearer faketoken"}
         client.cookies.clear()
         client.cookies.set("access_token", "faketoken")
         client.cookies.set("refresh_token", "refresh")
-        response = client.post("/logout")
+        response = client.post("/logout", headers=headers)
         assert response.status_code == 200
         assert response.json()["detail"] == "logout_success"
 
 
 # --- ACCOUNT EXISTS ---
-def test_account_exists_true(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = {"email": "test@example.com"}
+def test_account_exists_true(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = {"email": "test@example.com"}
 
     response = client.post("/account_exists", json={"email": "test@example.com"})
     assert response.status_code == 200
     assert response.json()["user_exists"] is True
     assert response.json()["detail"] == "account_exists_success"
 
 
-def test_account_exists_false(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = None
+def test_account_exists_false(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = None
 
     response = client.post("/account_exists", json={"email": "nouser@example.com"})
     assert response.status_code == 200
@@ -159,52 +130,52 @@ def test_account_exists_false(mock_services):
 
 
 # --- CHANGE PASSWORD ---
-def test_change_password_user_not_exist(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = None
+def test_change_password_user_not_exist(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = None
 
+    headers = {"Authorization": "Bearer faketoken"}
     client.cookies.clear()
     client.cookies.set("access_token", "faketoken")
-    response = client.post("/change_password", json={"email": "nouser@example.com", "old_password": "13pAssword*", "new_password": "14pAssword*"})
+    response = client.post("/change_password", json={"email": "nouser@example.com", "old_password": "13pAssword*", "new_password": "14pAssword*"}, headers=headers)
     assert response.status_code == 400
     assert response.json()["detail"] == "user_no_exist"
 
 
-def test_change_password_invalid_old_password(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = User(email="test@example.com", password="hashed")
+def test_change_password_invalid_old_password(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = User(email="test@example.com", password="hashed")
 
     with patch("app.controllers.auth_controller.password_encoder.verify", new=AsyncMock(return_value=False)):
+        headers = {"Authorization": "Bearer faketoken"}
         client.cookies.clear()
         client.cookies.set("access_token", "faketoken")
-        response = client.post("/change_password", json={"email": "test@example.com", "old_password": "15pAssword*", "new_password": "14pAssword*"})
+        response = client.post("/change_password", json={"email": "test@example.com", "old_password": "15pAssword*", "new_password": "14pAssword*"}, headers=headers)
         assert response.status_code == 400
         assert response.json()["detail"] == "user_invalid_old_password"
 
 
-def test_change_password_success(mock_services):
-    mock_auth = mock_services
-    mock_auth.read_user_by_email.return_value = User(email="test@example.com", password="hashed")
-    mock_auth.update_user_password.return_value = None
+def test_change_password_success(client, mock_auth_service):
+    mock_auth_service.read_user_by_email.return_value = User(email="test@example.com", password="hashed")
+    mock_auth_service.update_user_password.return_value = None
 
     with patch("app.controllers.auth_controller.password_encoder.verify", new=AsyncMock(return_value=True)), \
          patch("app.controllers.auth_controller.password_encoder.hash", new=AsyncMock(return_value="new_hashed")):
+        headers = {"Authorization": "Bearer faketoken"}
         client.cookies.clear()
         client.cookies.set("access_token", "faketoken")
-        response = client.post("/change_password", json={"email": "test@example.com", "old_password": "13pAssword*", "new_password": "14pAssword*"})
+        response = client.post("/change_password", json={"email": "test@example.com", "old_password": "13pAssword*", "new_password": "14pAssword*"}, headers=headers)
         assert response.status_code == 200
         assert response.json()["detail"] == "change_password_success"
 
 
 # --- CHECK TOKEN ---
-def test_check_token_missing():
+def test_check_token_missing(client):
     headers = {"Authorization": "Bearer faketoken"}
     response = client.post("/check_token", json={"token": ""}, headers=headers)
     assert response.status_code == 400
     assert response.json()["detail"] == "token_missing"
 
 
-def test_check_token_valid():
+def test_check_token_valid(client):
     headers = {"Authorization": "Bearer faketoken"}
     with patch("app.controllers.auth_controller.jwt_bearer.verify_access_token", new=AsyncMock(return_value={"user_id": "abc123"})):
         response = client.post("/check_token", json={"token": "sometoken"}, headers=headers)
@@ -213,15 +184,15 @@ def test_check_token_valid():
         assert response.json()["detail"] == "token_verification_success"
 
 
-def test_check_token_expired():
+def test_check_token_expired(client):
     headers = {"Authorization": "Bearer faketoken"}
     with patch("app.controllers.auth_controller.jwt_bearer.verify_access_token", new=AsyncMock(side_effect=ExpiredSignatureError)):
         response = client.post("/check_token", json={"token": "expiredtoken"}, headers=headers)
         assert response.status_code == 401
         assert response.json()["detail"] == "token_expired"
 
 
-def test_check_token_invalid():
+def test_check_token_invalid(client):
     headers = {"Authorization": "Bearer faketoken"}
     with patch("app.controllers.auth_controller.jwt_bearer.verify_access_token", new=AsyncMock(side_effect=InvalidTokenError)):
         response = client.post("/check_token", json={"token": "invalidtoken"}, headers=headers)
@@ -230,33 +201,29 @@ def test_check_token_invalid():
 
 
 # --- REFRESH TOKEN ---
-def test_refresh_token_missing(mock_services):
+def test_refresh_token_missing(client, mock_auth_service):
     headers = {"Authorization": "Bearer faketoken"}
     response = client.post("/refresh_token", headers=headers)
     assert response.status_code == 400
     assert response.json()["detail"] == "missing_refresh_token"
 
 
-def test_refresh_token_revoked(mock_services):
-    mock_auth = mock_services
-    mock_auth.is_token_revoked.return_value = True
+def test_refresh_token_revoked(client, mock_auth_service):
+    mock_auth_service.is_token_revoked.return_value = True
 
-    with TestClient(app) as test_client:
-        test_client.cookies.set("refresh_token", "revokedtoken")
-        response = test_client.post("/refresh_token")
-        assert response.status_code == 401
-        assert response.json()["detail"] == "token_revoked"
+    client.cookies.set("refresh_token", "revokedtoken")
+    response = client.post("/refresh_token")
+    assert response.status_code == 401
+    assert response.json()["detail"] == "token_revoked"
 
 
-def test_refresh_token_success(mock_services):
-    mock_auth = mock_services
-    mock_auth.is_token_revoked.return_value = False
+def test_refresh_token_success(client, mock_auth_service):
+    mock_auth_service.is_token_revoked.return_value = False
 
-    with TestClient(app) as test_client:
-        test_client.cookies.set("refresh_token", "validtoken")
-        with patch("app.controllers.auth_controller.jwt_bearer.verify_refresh_token", new=AsyncMock(return_value={"user_id": "1"})), \
-             patch("app.controllers.auth_controller.jwt_bearer.create_access_token", new=AsyncMock(return_value="new_access")):
-            response = test_client.post("/refresh_token")
-            print(response.json())
-            assert response.status_code == 200
-            assert response.json()["detail"] == "refresh_token_success"
+    client.cookies.set("refresh_token", "validtoken")
+    with patch("app.controllers.auth_controller.jwt_bearer.verify_refresh_token", new=AsyncMock(return_value={"user_id": "1"})), \
+         patch("app.controllers.auth_controller.jwt_bearer.create_access_token", new=AsyncMock(return_value="new_access")):
+        response = client.post("/refresh_token")
+        print(response.json())
+        assert response.status_code == 200
+        assert response.json()["detail"] == "refresh_token_success"