stack/tests/aco/test_load_bcda.py

"""Tests for BCDA data loading."""

from __future__ import annotations

from pathlib import Path

import pytest

from aco.load.bcda import _find_latest_export


class TestFindLatestExport:
    def test_no_exports_dir_raises(self, tmp_path: Path) -> None:
        with pytest.raises(FileNotFoundError, match="No exports directory"):
            _find_latest_export(tmp_path)

    def test_empty_exports_dir_raises(self, tmp_path: Path) -> None:
        (tmp_path / "exports").mkdir()
        with pytest.raises(FileNotFoundError, match="No export directories"):
            _find_latest_export(tmp_path)

    def test_finds_latest(self, tmp_path: Path) -> None:
        import os

        exports = tmp_path / "exports"
        exports.mkdir()
        (exports / "old_job").mkdir()
        (exports / "new_job").mkdir()
        # Set old_job mtime to past so new_job is clearly newer
        os.utime(exports / "old_job", (1000000, 1000000))
        result = _find_latest_export(tmp_path)
        assert [d.name for d in result] == ["new_job"]

    def test_newest_per_resource_type(self, tmp_path: Path) -> None:
        """Three single-type v3 jobs: each type comes from its own dir."""
        import os

        exports = tmp_path / "exports"
        exports.mkdir()
        for i, (name, rtype) in enumerate(
            [
                ("j_eob", "ExplanationOfBenefit"),
                ("j_pat", "Patient"),
                ("j_cov", "Coverage"),
            ]
        ):
            d = exports / name
            d.mkdir()
            (d / f"{rtype}.ndjson").write_text("{}\n")
            os.utime(d, (1000000 + i, 1000000 + i))
        # a newer Patient-only job supersedes j_pat
        d = exports / "j_pat2"
        d.mkdir()
        (d / "Patient.ndjson").write_text("{}\n")
        os.utime(d, (2000000, 2000000))
        result = _find_latest_export(tmp_path)
        assert [d.name for d in result] == ["j_eob", "j_cov", "j_pat2"]


class TestLoadV3EndToEnd:
    """Official v3 samples, split like three single-type jobs → DuckDB."""

    def test_load_from_three_export_dirs(self, tmp_path: Path) -> None:
        import shutil

        import duckdb

        from aco.load.bcda import load_bcda
        from conf import path as conf_path

        samples = Path(__file__).resolve().parents[2] / "dev" / "vendor" / "bcda-site"
        store = tmp_path / "store"
        for job, rtype in (
            ("j1", "Patient"),
            ("j2", "Coverage"),
            ("j3", "ExplanationOfBenefit"),
        ):
            d = store / "exports" / job
            d.mkdir(parents=True)
            shutil.copy(samples / f"v3_{rtype}.ndjson", d / f"{rtype}.ndjson")
        # a second EOB part in the same job dir
        shutil.copy(
            samples / "v3_ExplanationOfBenefit.ndjson",
            store / "exports" / "j3" / "ExplanationOfBenefit.1.ndjson",
        )
        db = tmp_path / "aco.duckdb"

        from unittest.mock import patch

        real_path = conf_path

        def fake_path(key: str):
            if key == "storage.bcda":
                return store
            return real_path(key)

        with patch("conf.path", side_effect=fake_path):
            stats = load_bcda(database=str(db), run_pipeline=True)
        assert stats == {
            "bcda.patient": 94,
            "bcda.explanation_of_benefit": 538,
            "bcda.eob_item": 2464,
            "bcda.coverage": 175,
            # the connector pipeline ran and landed input_layer.*; the
            # duplicated EOB part collapses on claim control number
            "input_layer.medical_claim": 1021,
            "input_layer.pharmacy_claim": 102,
            "input_layer.eligibility": 94,
        }
        con = duckdb.connect(str(db), read_only=True)
        plans = dict(
            con.execute(
                "select class_plan, count(*) from bcda.coverage group by 1"
            ).fetchall()
        )
        assert set(plans) == {"Part A", "Part B", "Part C", "Dual Medicare/Medicaid"}
        sys_types = dict(
            con.execute(
                "select system_type, count(*) from bcda.explanation_of_benefit group by 1"
            ).fetchall()
        )
        assert sys_types == {"NationalClaimsHistory": 282, "DDPS": 256}
        assert (
            con.execute(
                "select count(*) from bcda.patient where bene_mbi_id is null"
            ).fetchone()[0]
            == 0
        )
        assert (
            con.execute(
                "select count(distinct claim_id) from input_layer.medical_claim"
            ).fetchone()[0]
            == 131
        )
        assert (
            con.execute(
                "select count(*) from input_layer.medical_claim "
                "where claim_type = 'institutional' and length(bill_type_code) <> 4"
            ).fetchone()[0]
            == 0
        )
        con.close()


class TestLoadReconciled:
    """A store with job records goes through bcda.sync, not the newest-dir rule."""

    def test_reconcile_path(self, tmp_path: Path) -> None:
        from datetime import datetime, timedelta, timezone
        from unittest.mock import patch

        import duckdb

        from aco.load.bcda import load_bcda
        from bcda import sync
        from bcda.store import Store
        from conf import path as conf_path
        from tests.bcda.test_sync import _rows, add_job

        store = Store(path=str(tmp_path / "store"))
        t0 = datetime(2026, 10, 1, tzinfo=timezone.utc)
        add_job(store, "B_PAT", {"Patient": _rows("Patient")}, transaction_time=t0)
        add_job(store, "B_COV", {"Coverage": _rows("Coverage")}, transaction_time=t0)
        add_job(
            store,
            "B_EOB",
            {"ExplanationOfBenefit": _rows("ExplanationOfBenefit")},
            transaction_time=t0,
        )
        # a Patient delta that retires nothing and adds one new enrollee
        import copy

        new_pat = copy.deepcopy(_rows("Patient")[0])
        new_pat["id"] = "-424242"
        new_pat["meta"]["lastUpdated"] = "2026-10-03T00:00:00.000+00:00"
        for ident in new_pat.get("identifier", []):  # a new enrollee: new MBI too
            ident["value"] = ident["value"] + "X"
        add_job(
            store,
            "D_PAT",
            {"Patient": [new_pat]},
            since=sync.format_instant(t0),
            transaction_time=t0 + timedelta(days=7),
        )
        real_path = conf_path

        def fake_path(key: str):
            return tmp_path / "store" if key == "storage.bcda" else real_path(key)

        db = tmp_path / "aco.duckdb"
        with patch("conf.path", side_effect=fake_path):
            stats = load_bcda(database=str(db), run_pipeline=True)
        assert stats["bcda.patient"] == 95
        assert stats["bcda.explanation_of_benefit"] == 269
        assert stats["bcda.eob_item"] == 1232
        assert stats["bcda.coverage"] == 175
        assert stats["bcda.sync_ledger"] == 4
        assert stats["input_layer.eligibility"] == 95
        con = duckdb.connect(str(db), read_only=True)
        wm = dict(
            con.execute(
                "select resource_type, job_key from bcda.sync_watermark"
            ).fetchall()
        )
        assert wm == {
            "Patient": "D_PAT",
            "Coverage": "B_COV",
            "ExplanationOfBenefit": "B_EOB",
        }
        assert (
            con.execute(
                "select count(*) from bcda.patient where _job_key = 'D_PAT'"
            ).fetchone()[0]
            == 1
        )
        con.close()
        # second load: nothing new to apply, same counts, ledger unchanged
        with patch("conf.path", side_effect=fake_path):
            stats2 = load_bcda(database=str(db), run_pipeline=False)
        assert stats2["bcda.patient"] == 95 and stats2["bcda.sync_ledger"] == 4
        # skip_flatten reuses the reconciled parquet; reconcile=False with no
        # explicit dir falls back to the newest-directory rule (Patient from D_PAT only)
        with patch("conf.path", side_effect=fake_path):
            assert load_bcda(database=str(db), skip_flatten=True)["bcda.patient"] == 95
            legacy = load_bcda(database=str(db), reconcile=False)
        assert legacy["bcda.patient"] == 1