test: isolated testing (#38)

* tests: `make test` now sets up a docker db

* chore: improved `.env` file resolution in `Settings`

* tests: proper isolation and first integration tests

Author: ivanskv2000

backend/Makefile

@@ -21,7 +21,21 @@ lint:
 	poetry run flake8 .
 
 test:
-	poetry run pytest --cov=app --cov-report=term --cov-report=html tests
+	@echo "Starting test database container..."
+	@docker run --name evsy-db-test -e POSTGRES_USER=evsy_test -e POSTGRES_PASSWORD=evsy_test -e POSTGRES_DB=evsy_test -p 5433:5432 -d postgres:15-alpine > /dev/null
+	@echo "Waiting for database to be ready..."
+	@until docker exec evsy-db-test pg_isready -U evsy_test > /dev/null 2>&1; do sleep 1; done
+	@echo "Database is ready. Running tests..."
+	-@ENV=test poetry run pytest --cov=app --cov-report=term --cov-report=html tests
+	@echo "Cleaning up..."
+	@docker rm -f evsy-db-test > /dev/null
 
 test-fast:
-	poetry run pytest tests
+	@echo "Starting test database container..."
+	@docker run --name evsy-db-test -e POSTGRES_USER=evsy_test -e POSTGRES_PASSWORD=evsy_test -e POSTGRES_DB=evsy_test -p 5433:5432 -d postgres:15-alpine > /dev/null
+	@echo "Waiting for database to be ready..."
+	@until docker exec evsy-db-test pg_isready -U evsy_test > /dev/null 2>&1; do sleep 1; done
+	@echo "Database is ready. Running tests..."
+	-@ENV=test poetry run pytest tests
+	@echo "Cleaning up..."
+	@docker rm -f evsy-db-test > /dev/null

backend/app/settings.py

@@ -3,18 +3,52 @@
 from pathlib import Path
 from typing import Literal, Optional
 
-from pydantic import ConfigDict, Field
-from pydantic_settings import BaseSettings
+from dotenv import load_dotenv
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
-def resolve_env_file(base_dir: str = ".") -> str:
-    env_mode = os.getenv("ENV", "dev")
-    path = Path(base_dir) / f".env.{env_mode}"
-    return str(path) if path.exists() else str(Path(base_dir) / ".env")
+def resolve_env_file() -> Optional[str]:
+    # 1. Check if ENV is set (e.g., ENV=test)
+    env_mode = os.getenv("ENV")
+
+    # Priority: current working directory (for tests)
+    cwd = Path.cwd()
+    if env_mode and (cwd / f".env.{env_mode}").exists():
+        return str(cwd / f".env.{env_mode}")
+    if (cwd / ".env").exists():
+        return str(cwd / ".env")
+
+    # Fallback: Absolute paths relative to this file
+    backend_root = Path(__file__).parent.parent
+    if env_mode:
+        test_path = backend_root / f".env.{env_mode}"
+        if test_path.exists():
+            return str(test_path)
+
+    local_env = backend_root / ".env"
+    if local_env.exists():
+        return str(local_env)
+
+    root_env = backend_root.parent / ".env"
+    if root_env.exists():
+        return str(root_env)
+
+    return None
 
 
 class Settings(BaseSettings):
-    env: Literal["dev", "prod", "demo"] = Field(default="dev", alias="ENV")
+    def __init__(self, _env_file: Optional[str] = None, **kwargs):
+        # Dynamically resolve env file if not provided
+        if _env_file is None:
+            _env_file = resolve_env_file()
+
+        if _env_file:
+            load_dotenv(_env_file, override=True)
+
+        super().__init__(**kwargs)
+
+    env: Literal["dev", "prod", "demo", "test"] = Field(default="dev", alias="ENV")
     database_url: str = "sqlite:///./test.db"
     frontend_url: Optional[str] = None
 
@@ -26,10 +60,10 @@ class Settings(BaseSettings):
     google_client_id: Optional[str] = None
     google_client_secret: Optional[str] = None
 
-    model_config = ConfigDict(
-        env_file=resolve_env_file(),
+    model_config = SettingsConfigDict(
         env_file_encoding="utf-8",
         case_sensitive=False,
+        extra="ignore",
     )
 
     @property

backend/tests/conftest.py

@@ -1,93 +1,105 @@
 import bcrypt
 import pytest
 from fastapi.testclient import TestClient
-from sqlalchemy.orm import Session
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session, sessionmaker
 
-from app.core.database import Base, get_db, init_db
+from app.core.database import Base, get_db
 from app.factory import create_app
 from app.modules.auth.crud import create_user
 from app.modules.auth.token import create_access_token
 from app.settings import Settings
 
+# No need for manual load_dotenv, Settings() will handle it via resolve_env_file()
+# or we can pass it explicitly for maximum clarity in tests.
+
 
 @pytest.fixture(scope="session")
 def test_settings():
-    """Session-scoped fixture for test settings, using a file-based SQLite DB."""
-    settings = Settings(_env_file=".env.test")
-    settings.database_url = "sqlite:///./test.db"
-    return settings
+    """Session-scoped fixture for test settings, using a Postgres DB."""
+    # We explicitly pass the env file to ensure we use exactly what we want
+    return Settings(_env_file=".env.test")
 
 
 @pytest.fixture(scope="session")
-def db_engine_session(test_settings: Settings):
-    """Session-scoped fixture for the database engine and session factory."""
-    engine, session_local = init_db(test_settings)
-    return engine, session_local
+def db_engine(test_settings: Settings):
+    """Session-scoped engine for the Postgres database."""
+    engine = create_engine(test_settings.database_url)
+    Base.metadata.create_all(bind=engine)
+    yield engine
+    Base.metadata.drop_all(bind=engine)
 
 
 @pytest.fixture(scope="session")
-def app(test_settings: Settings, db_engine_session):
+def app(test_settings: Settings, db_engine):
     """Session-scoped fixture for the FastAPI application instance."""
-    _, session_local = db_engine_session
-    return create_app(test_settings, session_local)
+    # We use a dummy session_local here because we'll override get_db at the request level
+    dummy_session_local = sessionmaker(bind=db_engine)
+    return create_app(test_settings, dummy_session_local)
 
 
-@pytest.fixture(scope="session")
-def override_get_db(db_engine_session):
-    """Session-scoped fixture to override the `get_db` dependency."""
-    _, session_local = db_engine_session
+@pytest.fixture
+def db(db_engine):
+    """
+    Function-scoped fixture that provides a transactional database session.
+    Everything is rolled back at the end of the test.
+    """
+    connection = db_engine.connect()
+    transaction = connection.begin()
+    session = Session(bind=connection)
 
-    def _override_get_db():
-        db: Session = session_local()
-        try:
-            yield db
-        finally:
-            db.close()
+    yield session
 
-    return _override_get_db
+    session.close()
+    transaction.rollback()
+    connection.close()
 
 
-@pytest.fixture(scope="session", autouse=True)
-def setup_database(app, db_engine_session, override_get_db):
-    """
-    Session-scoped, autouse fixture to set up the database schema and dependency overrides.
-    """
-    engine, _ = db_engine_session
-    Base.metadata.create_all(bind=engine)
-    app.dependency_overrides[get_db] = override_get_db
-    yield
-    Base.metadata.drop_all(bind=engine)
+@pytest.fixture
+def override_get_db(app, db):
+    """Fixture to override the get_db dependency for every test."""
 
+    def _get_db():
+        yield db
 
-@pytest.fixture(scope="session")
-def test_user(override_get_db):
-    """Create a test user in the DB"""
-    db = next(override_get_db())
+    app.dependency_overrides[get_db] = _get_db
+    yield _get_db  # Yield the function so it can be called if needed
+    app.dependency_overrides.pop(get_db, None)
+
+
+@pytest.fixture(autouse=True)
+def auto_override_get_db(override_get_db):
+    """Automatically apply the get_db override for every test."""
+    pass
+
+
+@pytest.fixture
+def test_user(db):
+    """Create a test user in the DB for the current transaction."""
     user = create_user(
         db,
         email="test@example.com",
         hashed_pw=bcrypt.hashpw(b"password123", bcrypt.gensalt()).decode("utf-8"),
     )
-
     return user
 
 
-@pytest.fixture(scope="session")
+@pytest.fixture
 def access_token(test_user):
     """Create an access token for the test user."""
     return create_access_token({"sub": str(test_user.email)})
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture
 def client(app):
-    """Module-scoped test client for unauthenticated requests."""
+    """Test client for unauthenticated requests."""
     with TestClient(app) as c:
         yield c
 
 
 @pytest.fixture
 def auth_client(app, access_token):
-    """Function-scoped test client for authenticated requests."""
+    """Test client for authenticated requests."""
     with TestClient(app) as auth_client:
         auth_client.headers.update({"Authorization": f"Bearer {access_token}"})
         yield auth_client

backend/tests/test_auth.py

@@ -18,13 +18,17 @@ def test_signup_returns_token(client, auth_data):
 
 
 def test_signup_duplicate_email(client, auth_data):
+    # First signup
+    client.post("/v1/auth/signup", json=auth_data)
     # Repeat signup to trigger duplicate error
     response = client.post("/v1/auth/signup", json=auth_data)
     assert response.status_code == 400
     assert "already exists" in response.json()["message"].lower()
 
 
 def test_login_with_valid_credentials(client, auth_data):
+    # Ensure user exists
+    client.post("/v1/auth/signup", json=auth_data)
     response = client.post("/v1/auth/login", json=auth_data)
     assert response.status_code == 200
     data = response.json()
@@ -63,6 +67,8 @@ def test_me_with_valid_token(auth_client, auth_data):
 
 
 def test_login_for_access_token(client, auth_data):
+    # Ensure user exists
+    client.post("/v1/auth/signup", json=auth_data)
     form_data = {
         "username": auth_data["email"],
         "password": auth_data["password"],

backend/tests/test_events.py

@@ -19,10 +19,14 @@ def test_create_event(auth_client, sample_event):
     assert response.json()["name"] == sample_event.name
 
 
-def test_get_event(auth_client):
-    response = auth_client.get("/v1/events/1")
+def test_get_event(auth_client, sample_event):
+    # Create an event first
+    create_response = auth_client.post("/v1/events/", json=sample_event.model_dump())
+    event_id = create_response.json()["id"]
+
+    response = auth_client.get(f"/v1/events/{event_id}")
     assert response.status_code == 200
-    assert response.json()["id"] == 1
+    assert response.json()["id"] == event_id
 
 
 def test_create_event_with_invalid_field(auth_client):

backend/tests/test_fields.py

@@ -20,6 +20,10 @@ def test_create_field(auth_client, sample_field):
 
 def test_get_field(auth_client, sample_field):
     """Тест на получение события"""
-    response = auth_client.get("/v1/fields/1")
+    # Create a field first
+    create_response = auth_client.post("/v1/fields/", json=sample_field.model_dump())
+    field_id = create_response.json()["id"]
+
+    response = auth_client.get(f"/v1/fields/{field_id}")
     assert response.status_code == 200
-    assert response.json()["id"] == 1
+    assert response.json()["id"] == field_id