stack/tests/rec/pricers/test_pfs.py

"""Tests for rec.pricers.pfs.PfsPricer with a seeded in-memory DuckDB."""

from __future__ import annotations

from rec.base import Pricer
from rec.engine import reconcile
from rec.pricers import PRICERS
from rec.pricers.pfs import PfsPricer


class TestRegistration:
    def test_in_PRICERS(self) -> None:
        assert "pfs" in PRICERS
        assert PRICERS["pfs"] is PfsPricer

    def test_conforms_to_protocol(self) -> None:
        assert isinstance(PfsPricer(), Pricer)

    def test_class_attributes(self) -> None:
        assert PfsPricer.system == "pfs"
        assert PfsPricer.join_keys == ["year", "mac", "locality", "hcpcs", "mod"]
        assert PfsPricer.compare_cols == ["non_fac_fee", "fac_fee"]


class TestGroundTruth:
    def test_row_count(self, con, test_year) -> None:
        p = PfsPricer()
        gt = p.ground_truth(con, test_year)
        # Seeded 3 carrier rows (99213, 99214, 99999)
        assert gt.height == 3

    def test_columns(self, con, test_year) -> None:
        p = PfsPricer()
        gt = p.ground_truth(con, test_year)
        for col in [
            "year",
            "mac",
            "locality",
            "hcpcs",
            "mod",
            "non_fac_fee",
            "fac_fee",
        ]:
            assert col in gt.columns


class TestCalculated:
    def test_excludes_carrier_priced(self, con, test_year) -> None:
        """99999 has status_code='C' so calc side skips it."""
        p = PfsPricer()
        calc = p.calculated(con, test_year)
        hcpcs = calc["hcpcs"].to_list()
        assert "99999" not in hcpcs

    def test_includes_algorithmic(self, con, test_year) -> None:
        """99213, 99214, 88888 all have status 'A'."""
        p = PfsPricer()
        calc = p.calculated(con, test_year)
        hcpcs = set(calc["hcpcs"].to_list())
        assert {"99213", "99214", "88888"}.issubset(hcpcs)

    def test_returns_cents_rounded(self, con, test_year) -> None:
        p = PfsPricer()
        calc = p.calculated(con, test_year)
        # All values should be round to 2 decimals (cents)
        for fee in calc["non_fac_fee"].to_list() + calc["fac_fee"].to_list():
            assert fee == round(fee, 2)


class TestReconcilePfs:
    def test_summary_counts(self, con, test_year) -> None:
        r = reconcile(PfsPricer(), con, test_year)
        # Ground-truth rows: 99213, 99214, 99999 = 3
        assert r.ground_truth_rows == 3
        # Calculated rows: 99213, 99214, 88888 = 3 (99999 skipped)
        assert r.calculated_rows == 3
        # Matched: 99213, 99214 = 2
        assert r.matched_rows == 2
        # gt_only: 99999
        assert r.ground_truth_only == 1
        # calc_only: 88888
        assert r.calculated_only == 1

    def test_exact_and_near(self, con, test_year) -> None:
        r = reconcile(PfsPricer(), con, test_year)
        # 99213 seeded to match exactly; 99214 is 1¢ off on non_fac_fee.
        assert r.exact_matches == 1
        assert r.near_matches == 2

    def test_tolerance_promotes(self, con, test_year) -> None:
        r = reconcile(PfsPricer(), con, test_year, tolerance_cents=1)
        assert r.exact_matches == 2

    def test_delta_table_contains_hcpcs(self, con, test_year) -> None:
        r = reconcile(PfsPricer(), con, test_year)
        hcpcs = set(r.deltas["hcpcs"].to_list())
        # All four distinct hcpcs from outer join
        assert hcpcs == {"99213", "99214", "99999", "88888"}

    def test_years_available(self, con, test_year) -> None:
        p = PfsPricer()
        assert p.years_available(con) == [test_year]

    def test_missing_year_raises(self, con) -> None:
        import pytest

        p = PfsPricer()
        with pytest.raises(KeyError, match="RuleYear missing"):
            p.calculated(con, 1999)