from datetime import date from decimal import Decimal from pathlib import Path import pytest from payslip_ingest.parsers.meta_uk import ParserError, parse_meta_uk FIXTURES = Path(__file__).parent / "fixtures" def _load(name: str) -> str: return (FIXTURES / name).read_text(encoding="utf-8") def test_parses_variant_b_modern() -> None: """Feb 2026 — variant B (post-2024), RSU vest, salary-sacrifice pension.""" result = parse_meta_uk(_load("meta_uk_2026_02.txt")) assert result.pay_date == date(2026, 2, 27) assert result.pay_period_start == date(2026, 2, 1) assert result.pay_period_end == date(2026, 2, 27) assert result.employer == "Facebook UK Limited" assert result.salary == Decimal("10003.33") assert result.bonus == Decimal("0") assert result.pension_sacrifice == Decimal("600.20") assert result.rsu_vest == Decimal("30479.76") # RSU Tax Offset + RSU Excs Refund assert result.rsu_offset == Decimal("0") # modern Meta template omits offset assert result.gross_pay == Decimal("39882.89") assert result.income_tax == Decimal("31311.90") assert result.national_insurance == Decimal("1602.89") assert result.net_pay == Decimal("6968.10") assert result.taxable_pay == Decimal("72096.92") assert result.ytd_tax_paid == Decimal("155626.37") assert result.ytd_taxable_pay == Decimal("373601.64") assert result.ytd_gross == Decimal("232630.34") # Derived cash-only PAYE: income_tax * (gross - pension_sacrifice) / taxable_pay # = 31311.90 * 39282.69 / 72096.92 = 17060.59 (vs 31311.90 total PAYE) assert result.cash_income_tax is not None assert abs(result.cash_income_tax - Decimal("17060.59")) <= Decimal("0.02") # YTD column of RSU lines in the Payments grid assert result.ytd_rsu_tax_offset == Decimal("124674.27") assert result.ytd_rsu_excs_refund == Decimal("3221.32") def test_parses_variant_b_with_bonus() -> None: """March 2025 — variant B, bonus + RSU + multiple other deductions.""" result = parse_meta_uk(_load("meta_uk_2025_03.txt")) assert result.pay_date == date(2025, 3, 27) assert result.salary == Decimal("10000.00") assert result.bonus == Decimal("25000.00") assert result.pension_sacrifice == Decimal("1200.00") assert result.rsu_vest == Decimal("20000.00") assert result.gross_pay == Decimal("53720.00") assert result.net_pay == Decimal("4753.69") assert "Private Medical" in result.other_deductions def test_parses_variant_c_2022_11() -> None: """Nov 2022 — mid-era template. Real pdftotext from doc_id=53. Side-by-side Payments | Deductions | Year To Date (capital "To"), dot- separated date, RSU labels use `RSU Gain Taxabl` / `Nicabl` (abbreviated) and a matching `RSU Net Gain` offset on the deductions side. """ result = parse_meta_uk(_load("meta_uk_2022_11_variant_c.txt")) assert result.pay_date == date(2022, 11, 30) assert result.employer == "Facebook UK Limited" assert result.salary == Decimal("8983.33") assert result.bonus == Decimal("0") assert result.pension_sacrifice == Decimal("539.00") # rsu_vest = RSU Gain Taxabl + RSU Gain Nicabl + RSU Net Cash assert result.rsu_vest == Decimal("15192.00") # rsu_offset = RSU Net Gain (the matching deduction) assert result.rsu_offset == Decimal("11522.91") assert result.gross_pay == Decimal("23636.33") assert result.income_tax == Decimal("5800.07") assert result.national_insurance == Decimal("612.65") assert result.student_loan == Decimal("1233.00") assert result.net_pay == Decimal("4467.70") assert result.taxable_pay == Decimal("16070.14") assert result.ytd_tax_paid == Decimal("34886.93") assert result.ytd_taxable_pay == Decimal("99784.08") assert result.ytd_gross == Decimal("131034.64") def test_parses_variant_a_with_ee_discount_bik() -> None: """June 2021 — variant A. Real pdftotext from doc_id=49. Has an `EE Discount BIK` line present in BOTH Payments AND Deductions blocks with value 12.00. Needs to land in `other_deductions` so the validation formula accounts for it (earlier parser version filtered it out, causing an off-by-12.00 validation failure). """ result = parse_meta_uk(_load("meta_uk_2021_06_variant_a_bik.txt")) assert result.pay_date == date(2021, 6, 30) assert result.salary == Decimal("5096.65") assert result.pension_sacrifice == Decimal("152.90") assert result.rsu_vest == Decimal("0") # RSU lines are YTD-only this period assert result.rsu_offset == Decimal("0") assert result.gross_pay == Decimal("5095.86") assert result.income_tax == Decimal("1410.07") assert result.national_insurance == Decimal("423.17") assert result.student_loan == Decimal("244.00") assert result.net_pay == Decimal("2906.51") assert result.other_deductions.get("Private Dental Insurance") == Decimal("15.61") assert result.other_deductions.get("Private Medical Insurance") == Decimal("84.50") assert result.other_deductions.get("EE Discount BIK") == Decimal("12.00") def test_parses_variant_a_2021_08() -> None: """Aug 2021 — variant A. Real pdftotext from doc_id=43. Single-column Description | This Period | This Year layout. Parenthesized negatives `(152.90)`, Facebook UK Ltd (not Limited), date `Date : 31 Aug 2021`. BIK items (Dental/Medical) appear as both earnings and deductions. """ result = parse_meta_uk(_load("meta_uk_2021_08_variant_a.txt")) assert result.pay_date == date(2021, 8, 31) assert result.employer == "Facebook UK Ltd" assert result.salary == Decimal("5096.65") assert result.bonus == Decimal("0") assert result.pension_sacrifice == Decimal("152.90") # rsu_vest = RSU Gain Taxable + RSU Gain Nicable + RSU Net Cash UK assert result.rsu_vest == Decimal("20654.51") assert result.rsu_offset == Decimal("15666.13") assert result.gross_pay == Decimal("25738.37") assert result.income_tax == Decimal("5500.87") assert result.national_insurance == Decimal("627.72") assert result.student_loan == Decimal("1165.00") assert result.net_pay == Decimal("2678.54") # BIK offsets on the deductions side assert result.other_deductions.get("Private Dental Insurance") == Decimal("15.61") assert result.other_deductions.get("Private Medical Insurance") == Decimal("84.50") # Variant A surfaces Taxable Pay via a trailing line `Taxable Pay : This # Period £XXXX.XX : To Date £YYYY.YY`. assert result.taxable_pay == Decimal("15323.16") def test_cash_income_tax_falls_back_when_taxable_pay_missing() -> None: """When taxable_pay is None, cash_income_tax == income_tax (no RSU grossing).""" from payslip_ingest.parsers.meta_uk import _cash_income_tax assert _cash_income_tax(Decimal("1000"), Decimal("5000"), Decimal("100"), None) == Decimal("1000") assert _cash_income_tax(Decimal("1000"), Decimal("5000"), Decimal("100"), Decimal("0")) == Decimal("1000") def test_variant_a_cash_income_tax_pro_rata() -> None: """Variant A fixture with taxable_pay → cash_income_tax is pro-rata. 2021-06 has taxable_pay=5095.86 (= gross_pay), pension_sacrifice=152.90, income_tax=1410.07 → cash_income_tax = 1410.07 * 4942.96 / 5095.86 = 1367.76. """ result = parse_meta_uk(_load("meta_uk_2021_06_variant_a_bik.txt")) assert result.taxable_pay == Decimal("5095.86") assert result.cash_income_tax is not None assert abs(result.cash_income_tax - Decimal("1367.76")) <= Decimal("0.02") @pytest.mark.parametrize("taxable_pay_line", [ "Taxable Pay : This Period £1234.56 : To Date £12345.67", "Taxable Pay: This Period £1234.56", "Taxable Pay This Period £1234.56 To Date £12345.67", "TAXABLE PAY : This Period £1234.56", "taxable pay : this period £1234.56", "Taxable Pay : Period £1234.56", "Taxable Pay : This Period £1,234.56", ]) def test_taxable_pay_variant_a_regex_matches(taxable_pay_line: str) -> None: """Variant-A Taxable Pay line appears in several layouts pre-2022. Original regex only matched `Taxable Pay : This Period £...` exactly. Widen to tolerate: missing/different colons, uppercase, no "This", whitespace in place of colons. Rows that don't match fall back to Claude in the back-fill path. """ from payslip_ingest.parsers.meta_uk import _match_variant_a_taxable_pay result = _match_variant_a_taxable_pay(taxable_pay_line) assert result == Decimal("1234.56") def test_taxable_pay_variant_a_regex_rejects_unmatched() -> None: """If there's no `Taxable Pay` label we should return None, not crash.""" from payslip_ingest.parsers.meta_uk import _match_variant_a_taxable_pay assert _match_variant_a_taxable_pay("some random line") is None assert _match_variant_a_taxable_pay("") is None def test_raises_on_non_meta_payslip() -> None: with pytest.raises(ParserError): parse_meta_uk("This is not a Meta payslip\nRandom text\n") def test_raises_on_empty_text() -> None: with pytest.raises(ParserError): parse_meta_uk("") @pytest.mark.parametrize("fixture_name", [ "meta_uk_2026_02.txt", "meta_uk_2025_03.txt", "meta_uk_2022_11_variant_c.txt", "meta_uk_2021_08_variant_a.txt", "meta_uk_2021_06_variant_a_bik.txt", ]) def test_all_fixtures_validate_totals(fixture_name: str) -> None: """Every fixture must satisfy gross - deductions ≈ net within 2p.""" from payslip_ingest.schema import validate_totals result = parse_meta_uk(_load(fixture_name)) assert validate_totals(result), ( f"{fixture_name}: gross={result.gross_pay} tax={result.income_tax} " f"nic={result.national_insurance} student={result.student_loan} " f"pension_employee={result.pension_employee} rsu_offset={result.rsu_offset} " f"other={result.other_deductions} net={result.net_pay}")