Initial commit

2026-06-01 16:48:21 +02:00
commit 53d157535a
159 changed files with 13641 additions and 0 deletions
@@ -0,0 +1,358 @@
+"""Tests for the BreakPeriod repository and service.
+
+Demonstrates the testing pattern for entity-specific repos and services.
+Aim for >=90% coverage on new code (ARCHITECTURE.md §10).
+"""
+
+from datetime import date, datetime
+from uuid import uuid4
+
+import pytest
+
+from app.entities.break_period import BreakPeriod
+from app.entities.personal_data import PersonalData
+from app.entities.workspace import Workspace
+from app.repositories_impl.sqlite.break_period_repository import SQLiteBreakPeriodRepository
+from app.repositories_impl.sqlite.personal_data_repository import SQLitePersonalDataRepository
+from app.repositories_impl.sqlite.workspace_repository import SQLiteWorkspaceRepository
+from app.services.break_period_service import BreakPeriodService
+from app.utils.errors import NotFoundError, ValidationError
+from tests.conftest import SeededIds
+
+
+def _make(workspace_id=None, **overrides) -> BreakPeriod:
+    """Helper to create a test BreakPeriod entity."""
+    base = dict(
+        id=uuid4(),
+        workspace_id=workspace_id or uuid4(),
+        name="Summer Break",
+        start_date=date(2026, 6, 1),
+        end_date=date(2026, 8, 31),
+        target_weeks=8,
+        created_at=datetime.now(),
+        updated_at=datetime.now(),
+    )
+    base.update(overrides)
+    return BreakPeriod(**base)
+
+
+class TestSQLiteBreakPeriodRepository:
+    """Test BreakPeriodRepository SQLite implementation."""
+
+    async def test_create_and_get_by_id(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Create a break period and fetch it by ID."""
+        entity = _make(workspace_id=seeded_ids.workspace_id)
+        created = await break_period_repo.create(entity)
+
+        fetched = await break_period_repo.get_by_id(created.id)
+        assert fetched is not None
+        assert fetched.id == created.id
+        assert fetched.name == "Summer Break"
+        assert fetched.target_weeks == 8
+
+    async def test_get_by_id_missing(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+    ) -> None:
+        """Getting a missing break period returns None."""
+        result = await break_period_repo.get_by_id(uuid4())
+        assert result is None
+
+    async def test_create_preserves_all_fields(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """All fields are preserved through create."""
+        start = date(2026, 7, 1)
+        end = date(2026, 7, 31)
+        entity = _make(
+            workspace_id=seeded_ids.workspace_id,
+            name="July Break",
+            start_date=start,
+            end_date=end,
+            target_weeks=4,
+        )
+        created = await break_period_repo.create(entity)
+
+        assert created.name == "July Break"
+        assert created.start_date == start
+        assert created.end_date == end
+        assert created.target_weeks == 4
+        assert created.workspace_id == seeded_ids.workspace_id
+
+    async def test_get_by_workspace(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+        workspace_repo: SQLiteWorkspaceRepository,
+    ) -> None:
+        """Get all break periods for a workspace."""
+        ws1 = seeded_ids.workspace_id
+
+        # Create a second workspace
+        ws2 = await workspace_repo.create(
+            Workspace(id=uuid4(), name="WS2", created_at=datetime.now())
+        )
+
+        # Create break periods in both workspaces
+        bp1 = await break_period_repo.create(_make(workspace_id=ws1, name="BP1"))
+        bp2 = await break_period_repo.create(_make(workspace_id=ws1, name="BP2"))
+        bp3 = await break_period_repo.create(_make(workspace_id=ws2.id, name="BP3"))
+
+        # Get from ws1 should only return bp1 and bp2
+        rows = await break_period_repo.get_by_workspace(ws1)
+        assert len(rows) == 2
+        ids = {r.id for r in rows}
+        assert bp1.id in ids
+        assert bp2.id in ids
+        assert bp3.id not in ids
+
+    async def test_get_by_workspace_empty(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+    ) -> None:
+        """Getting break periods for workspace with none returns empty list."""
+        result = await break_period_repo.get_by_workspace(uuid4())
+        assert result == []
+
+    async def test_update(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Update a break period."""
+        entity = _make(
+            workspace_id=seeded_ids.workspace_id,
+            name="Summer Break",
+            target_weeks=6,
+        )
+        created = await break_period_repo.create(entity)
+
+        # Modify and update
+        created.name = "Summer Vacation"
+        created.target_weeks = 8
+        updated = await break_period_repo.update(created.id, created)
+
+        assert updated.name == "Summer Vacation"
+        assert updated.target_weeks == 8
+        assert updated.id == created.id
+
+    async def test_update_missing_raises(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+    ) -> None:
+        """Updating a missing break period raises NotFoundError."""
+        with pytest.raises(NotFoundError):
+            await break_period_repo.update(uuid4(), _make())
+
+    async def test_delete(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Delete a break period."""
+        entity = _make(workspace_id=seeded_ids.workspace_id)
+        created = await break_period_repo.create(entity)
+
+        await break_period_repo.delete(created.id)
+
+        # Verify it's deleted
+        result = await break_period_repo.get_by_id(created.id)
+        assert result is None
+
+    async def test_delete_missing_raises(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+    ) -> None:
+        """Deleting a missing break period raises NotFoundError."""
+        with pytest.raises(NotFoundError):
+            await break_period_repo.delete(uuid4())
+
+    async def test_list(
+        self,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """List all break periods (default filter-less list)."""
+        ws = seeded_ids.workspace_id
+
+        bp1 = await break_period_repo.create(_make(workspace_id=ws, name="BP1"))
+        bp2 = await break_period_repo.create(_make(workspace_id=ws, name="BP2"))
+
+        rows = await break_period_repo.list()
+        assert len(rows) >= 2
+        ids = {r.id for r in rows}
+        assert bp1.id in ids
+        assert bp2.id in ids
+
+
+class TestBreakPeriodService:
+    """Test BreakPeriodService business logic."""
+
+    async def test_create_with_valid_dates(
+        self,
+        break_period_service: BreakPeriodService,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Create a break period with valid dates."""
+        result = await break_period_service.create(
+            workspace_id=seeded_ids.workspace_id,
+            name="Summer",
+            start_date=date(2026, 6, 1),
+            end_date=date(2026, 8, 31),
+            target_weeks=12,
+        )
+        assert result.name == "Summer"
+        assert result.target_weeks == 12
+
+    async def test_create_with_end_before_start_raises(
+        self,
+        break_period_service: BreakPeriodService,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Creating with end_date < start_date raises ValidationError."""
+        with pytest.raises(ValidationError):
+            await break_period_service.create(
+                workspace_id=seeded_ids.workspace_id,
+                name="Invalid Break",
+                start_date=date(2026, 8, 31),
+                end_date=date(2026, 6, 1),
+                target_weeks=4,
+            )
+
+    async def test_create_with_same_start_end_allowed(
+        self,
+        break_period_service: BreakPeriodService,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Creating with end_date == start_date is allowed (single day)."""
+        result = await break_period_service.create(
+            workspace_id=seeded_ids.workspace_id,
+            name="One Day",
+            start_date=date(2026, 6, 15),
+            end_date=date(2026, 6, 15),
+            target_weeks=0,
+        )
+        assert result.start_date == result.end_date
+
+    async def test_get(
+        self,
+        break_period_service: BreakPeriodService,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Get a break period by ID."""
+        entity = _make(workspace_id=seeded_ids.workspace_id)
+        created = await break_period_repo.create(entity)
+
+        fetched = await break_period_service.get(created.id)
+        assert fetched.id == created.id
+        assert fetched.name == "Summer Break"
+
+    async def test_get_missing_raises(
+        self,
+        break_period_service: BreakPeriodService,
+    ) -> None:
+        """Getting a missing break period raises NotFoundError."""
+        with pytest.raises(NotFoundError):
+            await break_period_service.get(uuid4())
+
+    async def test_list_for_workspace(
+        self,
+        break_period_service: BreakPeriodService,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """List all break periods for a workspace."""
+        ws = seeded_ids.workspace_id
+
+        bp1 = await break_period_repo.create(_make(workspace_id=ws, name="BP1"))
+        bp2 = await break_period_repo.create(_make(workspace_id=ws, name="BP2"))
+
+        result = await break_period_service.list_for_workspace(ws)
+        assert len(result) == 2
+        ids = {r.id for r in result}
+        assert bp1.id in ids
+        assert bp2.id in ids
+
+    async def test_update_with_valid_dates(
+        self,
+        break_period_service: BreakPeriodService,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Update a break period with valid dates."""
+        entity = _make(workspace_id=seeded_ids.workspace_id)
+        created = await break_period_repo.create(entity)
+
+        result = await break_period_service.update(
+            break_period_id=created.id,
+            name="Updated Name",
+            start_date=date(2026, 7, 1),
+            end_date=date(2026, 7, 31),
+            target_weeks=4,
+        )
+        assert result.name == "Updated Name"
+        assert result.target_weeks == 4
+
+    async def test_update_with_end_before_start_raises(
+        self,
+        break_period_service: BreakPeriodService,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Updating with end_date < start_date raises ValidationError."""
+        entity = _make(workspace_id=seeded_ids.workspace_id)
+        created = await break_period_repo.create(entity)
+
+        with pytest.raises(ValidationError):
+            await break_period_service.update(
+                break_period_id=created.id,
+                name="Invalid",
+                start_date=date(2026, 8, 31),
+                end_date=date(2026, 6, 1),
+                target_weeks=4,
+            )
+
+    async def test_update_missing_raises(
+        self,
+        break_period_service: BreakPeriodService,
+    ) -> None:
+        """Updating a missing break period raises NotFoundError."""
+        with pytest.raises(NotFoundError):
+            await break_period_service.update(
+                break_period_id=uuid4(),
+                name="Name",
+                start_date=date(2026, 6, 1),
+                end_date=date(2026, 8, 31),
+                target_weeks=8,
+            )
+
+    async def test_delete(
+        self,
+        break_period_service: BreakPeriodService,
+        break_period_repo: SQLiteBreakPeriodRepository,
+        seeded_ids: SeededIds,
+    ) -> None:
+        """Delete a break period."""
+        entity = _make(workspace_id=seeded_ids.workspace_id)
+        created = await break_period_repo.create(entity)
+
+        await break_period_service.delete(created.id)
+
+        # Verify it's deleted
+        with pytest.raises(NotFoundError):
+            await break_period_service.get(created.id)
+
+    async def test_delete_missing_raises(
+        self,
+        break_period_service: BreakPeriodService,
+    ) -> None:
+        """Deleting a missing break period raises NotFoundError."""
+        with pytest.raises(NotFoundError):
+            await break_period_service.delete(uuid4())