FabledScribe/tests/test_integration_inception.py

"""Real-Postgres integration tests for project inception (milestone 297).

What mocks can't prove: a decision's effects land through the real services
(exclusions filter the always-on set, subscriptions bind, the design system
points, the standard Systems seed once), the record is written last, a bad
target applies nothing.
"""
import pytest
import pytest_asyncio

from scribe.models import async_session
from scribe.models.project import Project
from scribe.services import inception as inception_svc
from scribe.services import rulebooks as rulebooks_svc
from scribe.services import canonical_systems as canonical_svc
from scribe.services import systems as systems_svc
from tests.helpers import ensure_user

pytestmark = [pytest.mark.integration, pytest.mark.usefixtures("_dispose_engine")]


@pytest_asyncio.fixture
async def seeded():
    """Owner, a fresh project, one always-on rulebook (with a rule) and one
    ordinary rulebook (with a rule)."""
    async with async_session() as s:
        owner = await ensure_user(s, "inception_owner")
        project = Project(user_id=owner.id, title="Inception target")
        s.add(project)
        await s.flush()
        ids = {"owner": owner.id, "pid": project.id}
        await s.commit()
    # Two ordinary rulebooks. One was flagged always-on until milestone 394
    # removed the tier; a rulebook now reaches a project only by subscription,
    # so what used to be "binds automatically" and "binds if you opt in" are
    # the same kind of thing.
    always = await rulebooks_svc.create_rulebook(ids["owner"], "Family standards")
    other = await rulebooks_svc.create_rulebook(ids["owner"], "Optional practices")
    t1 = await rulebooks_svc.create_topic(always.id, ids["owner"], "git")
    await rulebooks_svc.create_rule(t1.id, ids["owner"], "dev is home", "Work on dev.")
    t2 = await rulebooks_svc.create_topic(other.id, ids["owner"], "docs")
    await rulebooks_svc.create_rule(t2.id, ids["owner"], "Write the why", "Record reasons.")
    ids.update({"always": always.id, "other": other.id})
    return ids


@pytest.mark.integration
async def test_decide_applies_every_effect_and_records_last(seeded):
    owner, pid = seeded["owner"], seeded["pid"]
    # Undecided: nothing binds, because nothing has been subscribed. Before
    # milestone 394 the always-on rulebook bound here without being asked for,
    # and this assertion read the other way round.
    defaults = await inception_svc.current_defaults(owner, pid)
    assert sorted(r["id"] for r in defaults["rulebooks"]) == sorted(
        [seeded["always"], seeded["other"]])
    assert defaults["systems"] == 0 and defaults["design_system_id"] is None
    assert (await rulebooks_svc.get_applicable_rules(pid, owner))["rules"] == []

    out = await inception_svc.decide(owner, pid, via="mcp", choices={
        "subscribe_rulebooks": [seeded["other"]],
        "design_system_id": None,
        "seed_systems": True,
    })
    assert out["effects"]["subscribed"] == [seeded["other"]]
    catalog = await canonical_svc.list_canonical_systems()
    assert len(out["effects"]["systems_seeded"]) == len(catalog)
    # Seeded Systems come out mapped, not needing a later reconciliation.
    seeded_systems = await systems_svc.list_systems(owner, pid)
    assert all(s.canonical_id is not None for s in seeded_systems)

    # The subscription is what binds, and it is the ONLY thing that does —
    # the unsubscribed rulebook contributes nothing even though it used to
    # bind every project by default.
    applicable = await rulebooks_svc.get_applicable_rules(pid, owner)
    assert [s["id"] for s in applicable["subscribed_rulebooks"]] == [seeded["other"]]
    assert "dev is home" not in [r["title"] for r in applicable["rules"]]
    # The record, written last, says why.
    async with async_session() as s:
        project = await s.get(Project, pid)
    assert inception_svc.is_decided(project)
    assert project.inception["via"] == "mcp" and project.inception["decided_by"] == owner
    assert project.inception["choices"]["subscribe_rulebooks"] == [seeded["other"]]
    # Re-deciding with seed again mints nothing twice.
    again = await inception_svc.decide(owner, pid, via="ui", choices={"seed_systems": True})
    assert again["effects"]["systems_seeded"] == []
    assert len(await systems_svc.list_systems(owner, pid)) == len(catalog)


@pytest.mark.integration
async def test_a_bad_decision_applies_nothing(seeded):
    owner, pid = seeded["owner"], seeded["pid"]
    # A subscription to a rulebook that is not yours is refused BEFORE any
    # effect lands — the seed must not happen on a decision that fails.
    with pytest.raises(ValueError, match="not found"):
        await inception_svc.decide(owner, pid, via="mcp", choices={
            "subscribe_rulebooks": [999999], "seed_systems": True,
        })
    assert await systems_svc.list_systems(owner, pid) == []
    with pytest.raises(ValueError, match="not found"):
        await inception_svc.decide(owner, pid, via="mcp", choices={"subscribe_rulebooks": [999999]})
    with pytest.raises(ValueError, match="legacy"):
        await inception_svc.decide(owner, pid, via="legacy", choices={})
    async with async_session() as s:
        project = await s.get(Project, pid)
    assert not inception_svc.is_decided(project)
    # An outsider cannot decide someone else's project.
    async with async_session() as s:
        other = await ensure_user(s, "inception_other")
        other_id = other.id
        await s.commit()
    with pytest.raises(ValueError, match="not found"):
        await inception_svc.decide(other_id, pid, via="mcp", choices={})