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))
        assert stats == {
            "bcda.patient": 94,
            "bcda.explanation_of_benefit": 538,
            "bcda.eob_item": 2464,
            "bcda.coverage": 175,
        }
        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
        )
        con.close()