357 lines
12 KiB
Python
357 lines
12 KiB
Python
"""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.workspace import Workspace
|
|
from app.repositories_impl.sqlite.break_period_repository import SQLiteBreakPeriodRepository
|
|
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())
|