148 lines
4.8 KiB
Python
148 lines
4.8 KiB
Python
from __future__ import annotations
|
|
|
|
from uuid import UUID, uuid4
|
|
|
|
import pytest
|
|
from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
|
|
from sqlmodel import SQLModel
|
|
from sqlmodel.ext.asyncio.session import AsyncSession
|
|
|
|
from app.models.approval_task_links import ApprovalTaskLink
|
|
from app.models.approvals import Approval
|
|
from app.models.boards import Board
|
|
from app.models.organizations import Organization
|
|
from app.models.tasks import Task
|
|
from app.services.approval_task_links import (
|
|
load_task_ids_by_approval,
|
|
normalize_task_ids,
|
|
task_counts_for_board,
|
|
)
|
|
|
|
|
|
async def _make_engine() -> AsyncEngine:
|
|
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
|
async with engine.connect() as conn, conn.begin():
|
|
await conn.run_sync(SQLModel.metadata.create_all)
|
|
return engine
|
|
|
|
|
|
async def _make_session(engine: AsyncEngine) -> AsyncSession:
|
|
return AsyncSession(engine, expire_on_commit=False)
|
|
|
|
|
|
async def _seed_board(session: AsyncSession) -> tuple[UUID, UUID, UUID, UUID]:
|
|
org_id = uuid4()
|
|
board_id = uuid4()
|
|
task_a = uuid4()
|
|
task_b = uuid4()
|
|
task_c = uuid4()
|
|
|
|
session.add(Organization(id=org_id, name=f"org-{org_id}"))
|
|
session.add(Board(id=board_id, organization_id=org_id, name="b", slug="b"))
|
|
session.add(Task(id=task_a, board_id=board_id, title="a"))
|
|
session.add(Task(id=task_b, board_id=board_id, title="b"))
|
|
session.add(Task(id=task_c, board_id=board_id, title="c"))
|
|
await session.commit()
|
|
return board_id, task_a, task_b, task_c
|
|
|
|
|
|
def test_normalize_task_ids_dedupes_and_merges_sources() -> None:
|
|
task_a = uuid4()
|
|
task_b = uuid4()
|
|
task_c = uuid4()
|
|
|
|
payload = {
|
|
"task_id": str(task_a),
|
|
"task_ids": [str(task_b), str(task_a)],
|
|
"taskIds": [str(task_c), "not-a-uuid"],
|
|
}
|
|
result = normalize_task_ids(
|
|
task_id=task_b,
|
|
task_ids=[task_a],
|
|
payload=payload,
|
|
)
|
|
|
|
assert result == [task_a, task_b, task_c]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_task_counts_for_board_supports_multi_task_links_and_legacy_rows() -> None:
|
|
engine = await _make_engine()
|
|
async with await _make_session(engine) as session:
|
|
board_id, task_a, task_b, task_c = await _seed_board(session)
|
|
|
|
approval_pending_multi = Approval(
|
|
board_id=board_id,
|
|
task_id=task_a,
|
|
action_type="task.update",
|
|
confidence=80,
|
|
status="pending",
|
|
)
|
|
approval_approved = Approval(
|
|
board_id=board_id,
|
|
task_id=task_a,
|
|
action_type="task.complete",
|
|
confidence=90,
|
|
status="approved",
|
|
)
|
|
approval_pending_two = Approval(
|
|
board_id=board_id,
|
|
task_id=task_b,
|
|
action_type="task.assign",
|
|
confidence=75,
|
|
status="pending",
|
|
)
|
|
approval_legacy = Approval(
|
|
board_id=board_id,
|
|
task_id=task_c,
|
|
action_type="task.comment",
|
|
confidence=65,
|
|
status="pending",
|
|
)
|
|
session.add(approval_pending_multi)
|
|
session.add(approval_approved)
|
|
session.add(approval_pending_two)
|
|
session.add(approval_legacy)
|
|
await session.flush()
|
|
|
|
session.add(
|
|
ApprovalTaskLink(approval_id=approval_pending_multi.id, task_id=task_a),
|
|
)
|
|
session.add(
|
|
ApprovalTaskLink(approval_id=approval_pending_multi.id, task_id=task_b),
|
|
)
|
|
session.add(ApprovalTaskLink(approval_id=approval_approved.id, task_id=task_a))
|
|
session.add(ApprovalTaskLink(approval_id=approval_pending_two.id, task_id=task_b))
|
|
session.add(ApprovalTaskLink(approval_id=approval_pending_two.id, task_id=task_c))
|
|
await session.commit()
|
|
|
|
counts = await task_counts_for_board(session, board_id=board_id)
|
|
|
|
assert counts[task_a] == (2, 1)
|
|
assert counts[task_b] == (2, 2)
|
|
assert counts[task_c] == (2, 2)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_load_task_ids_by_approval_preserves_insert_order() -> None:
|
|
engine = await _make_engine()
|
|
async with await _make_session(engine) as session:
|
|
board_id, task_a, task_b, task_c = await _seed_board(session)
|
|
|
|
approval = Approval(
|
|
board_id=board_id,
|
|
task_id=task_a,
|
|
action_type="task.update",
|
|
confidence=88,
|
|
status="pending",
|
|
)
|
|
session.add(approval)
|
|
await session.flush()
|
|
session.add(ApprovalTaskLink(approval_id=approval.id, task_id=task_a))
|
|
session.add(ApprovalTaskLink(approval_id=approval.id, task_id=task_b))
|
|
session.add(ApprovalTaskLink(approval_id=approval.id, task_id=task_c))
|
|
await session.commit()
|
|
|
|
mapping = await load_task_ids_by_approval(session, approval_ids=[approval.id])
|
|
assert mapping[approval.id] == [task_a, task_b, task_c]
|