Model/tests/repositories/property/test_property_overrides_postgres_reader.py

"""Integration tests for the ``property_overrides`` read adapter.

The reader is *faithful*: it returns the resolved enum-value snapshots exactly
as the finaliser wrote them, every ``(override_component, building_part)`` for
the Property, with no translation or gating. Verified against a real Postgres
(the ``db_engine`` fixture) because the value is in reading what was actually
persisted.
"""

from __future__ import annotations

from sqlalchemy import Engine
from sqlmodel import Session

from infrastructure.postgres.property_override_table import PropertyOverrideRow
from repositories.property.property_overrides_postgres_reader import (
    PropertyOverridesPostgresReader,
)


def _seed(
    session: Session,
    *,
    override_component: str,
    override_value: str,
    property_id: int = 1,
    portfolio_id: int = 1,
    building_part: int = 0,
) -> None:
    row = PropertyOverrideRow(
        property_id=property_id,
        portfolio_id=portfolio_id,
        building_part=building_part,
        override_component=override_component,
        override_value=override_value,
        original_spreadsheet_description="detached house",
    )
    session.add(row)


def test_reads_a_resolved_override_in_value_space(db_engine: Engine) -> None:
    # Arrange — the finaliser wrote one property_type override for the Property.
    with Session(db_engine) as session:
        _seed(
            session,
            property_id=42,
            override_component="property_type",
            override_value="House",
        )
        session.commit()

    reader = PropertyOverridesPostgresReader(lambda: Session(db_engine))

    # Act
    resolved = reader.overrides_for(42)

    # Assert — the stored enum value, untranslated.
    assert resolved.value("property_type", 0) == "House"


def test_returns_every_component_and_building_part_for_the_property(
    db_engine: Engine,
) -> None:
    # Arrange — three overrides across two building parts for the target Property,
    # plus an override for a *different* Property that must not leak in.
    with Session(db_engine) as session:
        _seed(
            session,
            property_id=7,
            building_part=0,
            override_component="property_type",
            override_value="House",
        )
        _seed(
            session,
            property_id=7,
            building_part=0,
            override_component="built_form_type",
            override_value="Detached",
        )
        _seed(
            session,
            property_id=7,
            building_part=1,
            override_component="wall_type",
            override_value="Solid brick, with internal insulation",
        )
        _seed(
            session,
            property_id=8,
            override_component="property_type",
            override_value="Flat",
        )
        session.commit()

    reader = PropertyOverridesPostgresReader(lambda: Session(db_engine))

    # Act
    resolved = reader.overrides_for(7)

    # Assert — all three of the Property's rows, faithfully; none from Property 8.
    assert len(resolved.rows) == 3
    assert resolved.value("property_type", 0) == "House"
    assert resolved.value("built_form_type", 0) == "Detached"
    assert resolved.value("wall_type", 1) == "Solid brick, with internal insulation"


def test_property_without_overrides_reads_empty(db_engine: Engine) -> None:
    # Arrange — nothing seeded for this Property.
    reader = PropertyOverridesPostgresReader(lambda: Session(db_engine))

    # Act
    resolved = reader.overrides_for(999)

    # Assert
    assert resolved.rows == ()
    assert resolved.value("property_type", 0) is None


def test_overrides_for_many_reads_every_property_in_one_pass(
    db_engine: Engine,
) -> None:
    """The batch read returns an entry for every requested Property — each
    Property's own rows, faithfully, and an empty snapshot for one with none."""
    # Arrange — Property 7 has two overrides, Property 8 has one, Property 9 none.
    with Session(db_engine) as session:
        _seed(
            session,
            property_id=7,
            override_component="property_type",
            override_value="House",
        )
        _seed(
            session,
            property_id=7,
            building_part=1,
            override_component="wall_type",
            override_value="Solid brick, with internal insulation",
        )
        _seed(
            session,
            property_id=8,
            override_component="property_type",
            override_value="Flat",
        )
        session.commit()

    reader = PropertyOverridesPostgresReader(lambda: Session(db_engine))

    # Act
    resolved = reader.overrides_for_many([7, 8, 9])

    # Assert — every requested id present; rows attributed to the right Property.
    assert set(resolved) == {7, 8, 9}
    assert len(resolved[7].rows) == 2
    assert resolved[7].value("property_type", 0) == "House"
    assert resolved[7].value("wall_type", 1) == "Solid brick, with internal insulation"
    assert resolved[8].value("property_type", 0) == "Flat"
    assert resolved[9].rows == ()