Simplify tests

Author: YuriiMotov

backend/app/tests/api/routes/test_login_with_hashing.py

@@ -6,7 +6,11 @@
 pytestmark = pytest.mark.enable_password_hashing
 
 
-def test_get_access_token_with_hashing(client: TestClient) -> None:
+def test_get_access_token_with_hashing(
+    client: TestClient,
+    disable_password_hashing: bool,
+) -> None:
+    assert disable_password_hashing is False
     login_data = {
         "username": settings.FIRST_SUPERUSER,
         "password": settings.FIRST_SUPERUSER_PASSWORD,
@@ -16,12 +20,3 @@ def test_get_access_token_with_hashing(client: TestClient) -> None:
     assert r.status_code == 200
     assert "access_token" in tokens
     assert tokens["access_token"]
-
-
-def test_get_access_token_incorrect_password(client: TestClient) -> None:
-    login_data = {
-        "username": settings.FIRST_SUPERUSER,
-        "password": "incorrect",
-    }
-    r = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data)
-    assert r.status_code == 400

backend/app/tests/conftest.py

@@ -1,5 +1,5 @@
 from collections.abc import Generator
-from contextlib import nullcontext
+from unittest.mock import patch
 
 import pytest
 from _pytest.fixtures import FixtureRequest
@@ -11,55 +11,43 @@
 from app.main import app
 from app.models import Item, User
 from app.tests.utils.user import authentication_token_from_email
-from app.tests.utils.utils import get_superuser_token_headers, patch_password_hashing
+from app.tests.utils.utils import get_superuser_token_headers
 
 
-@pytest.fixture(scope="module", autouse=True)
+@pytest.fixture(scope="module")
 def disable_password_hashing(request: FixtureRequest) -> Generator[None, None, None]:
-    """Fixture disabling password hashing
-
-    Password hashing can be enabled on module level by marking the module with `pytest.mark.enable_password_hashing`.
+    """
+    Disable password hashing if no `enable_password_hashing` marker set for module.
     """
 
-    with (
-        patch_password_hashing("app.core.security")
-        if all(m.name != "enable_password_hashing" for m in request.node.iter_markers())
-        else nullcontext()
-    ):
-        yield
+    module = request.node.getparent(pytest.Module)
+    if not module.get_closest_marker("enable_password_hashing"):
+        with (
+            patch("app.core.security.pwd_context.verify", lambda x, y: x == y),
+            patch("app.core.security.pwd_context.hash", lambda x: x),
+        ):
+            yield True
+    else:
+        yield False  # Don't patch if `enable_password_hashing` marker is set
 
 
-@pytest.fixture(scope="session")
-def db() -> Generator[Session, None, None]:
-    """
-    Module scoped fixture providing a database session initialized with `init_db`.
-    """
+@pytest.fixture(scope="module")
+def db(disable_password_hashing) -> Generator[Session, None, None]:  # noqa: ARG001
     with Session(engine) as session:
+        session.execute(  # Recreate user for every module, with\without pwd hashing
+            delete(User)
+        )
+        init_db(session)
+        session.commit()
         yield session
         # Cleanup test database
         session.execute(delete(Item))
         session.execute(delete(User))
         session.commit()
 
 
-@pytest.fixture(scope="module", autouse=True)
-def init_db_fixture(db: Session) -> None:
-    # note: deleting all users here is required to enable or disable password hashing per test module.
-    # If we don't delete all users here, the users created during `init_db` will not be re-created and the password will stay (un)hashed,
-    # leading to possibly failing tests relying on the created user for authentication.
-    db.execute(delete(Item))
-    db.execute(delete(User))
-    init_db(db)
-    db.commit()
-
-
 @pytest.fixture(scope="module")
 def client(db: Session) -> Generator[TestClient, None, None]:  # noqa: ARG001
-    """
-    Module scoped fixture providing a `TestClient` instance.
-
-    NOTE: This fixture uses the `db` fixture WITHOUT hashing passwords!
-    """
     with TestClient(app) as c:
         yield c
 

backend/app/tests/utils/utils.py

@@ -1,8 +1,5 @@
 import random
 import string
-from collections.abc import Generator
-from contextlib import ExitStack, contextmanager
-from unittest.mock import patch
 
 from fastapi.testclient import TestClient
 
@@ -27,19 +24,3 @@ def get_superuser_token_headers(client: TestClient) -> dict[str, str]:
     a_token = tokens["access_token"]
     headers = {"Authorization": f"Bearer {a_token}"}
     return headers
-
-
-@contextmanager
-def patch_password_hashing(*modules: str) -> Generator[None, None, None]:
-    """
-    Contextmanager to patch ``pwd_context`` in the given modules.
-    :param modules: list of modules to patch.
-    :return:
-    """
-    with ExitStack() as stack:
-        for module in modules:
-            stack.enter_context(
-                patch(f"{module}.pwd_context.verify", lambda x, y: x == y)
-            )
-            stack.enter_context(patch(f"{module}.pwd_context.hash", lambda x: x))
-        yield