Spaces:
Sleeping
Sleeping
File size: 8,876 Bytes
a003369 b6beb2d a003369 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 | """Unit tests for the document schema and its normalizers.
Covers the acceptance criterion for build-plan task 1.1: valid dicts parse,
and malformed money/date values are handled (absent -> ``None``, present but
unparseable -> ``ValidationError``).
"""
from __future__ import annotations
from datetime import date
import pytest
from pydantic import ValidationError
from docfield.schema.models import Document, LineItem
def test_minimal_document_uses_defaults() -> None:
"""An empty payload yields a fully-defaulted, pipeline-ready document."""
document = Document()
assert document.doc_type == "other"
assert document.vendor_name is None
assert document.invoice_number is None
assert document.document_date is None
assert document.line_items == []
assert document.total is None
assert document.field_confidence == {}
assert document.validation == {}
assert document.decision is None
def test_full_valid_dict_parses() -> None:
"""A realistic, slightly messy dict parses and normalizes end-to-end."""
document = Document.model_validate(
{
"doc_type": "Invoice",
"vendor_name": " Acme Corp ",
"vendor_address": "1 Market St",
"invoice_number": "INV-2024-001",
"document_date": "2024-01-15",
"due_date": "2024/02/14",
"currency": "usd",
"line_items": [
{"description": "Widget", "quantity": "2", "unit_price": "10.00", "amount": "20.00"},
],
"subtotal": "$20.00",
"tax": "1.60",
"total": "$21.60",
}
)
assert document.doc_type == "invoice"
assert document.vendor_name == "Acme Corp"
assert document.invoice_number == "INV-2024-001"
assert document.document_date == date(2024, 1, 15)
assert document.due_date == date(2024, 2, 14)
assert document.currency == "USD"
assert document.subtotal == pytest.approx(20.00)
assert document.tax == pytest.approx(1.60)
assert document.total == pytest.approx(21.60)
assert len(document.line_items) == 1
item = document.line_items[0]
assert item.description == "Widget"
assert item.quantity == pytest.approx(2.0)
assert item.unit_price == pytest.approx(10.0)
assert item.amount == pytest.approx(20.0)
@pytest.mark.parametrize(
("raw", "expected"),
[
("$1,234.56", 1234.56), # US: symbol + thousands + decimal
("1.234,56", 1234.56), # European: dot grouping, comma decimal
("1,234", 1234.0), # bare thousands grouping
("1,234,567", 1234567.0), # multi-group thousands
("12,50", 12.5), # decimal comma
("1.234.567", 1234567.0), # European dot grouping
("USD 99.99", 99.99), # leading currency code
(" 42 ", 42.0), # surrounding whitespace
("(123.45)", -123.45), # accounting-style negative
("-50.00", -50.0), # explicit negative
("0", 0.0), # zero is a real value, not absent
(2, 2.0), # native int
(3.5, 3.5), # native float
],
)
def test_money_normalization(raw: object, expected: float) -> None:
"""Monetary strings strip symbols/separators and parse to ``float``."""
document = Document.model_validate({"total": raw})
assert document.total == pytest.approx(expected)
@pytest.mark.parametrize("token", ["", " ", "N/A", "na", "-", "--", "none", "null"])
def test_money_null_tokens_become_none(token: str) -> None:
"""Absent-value sentinels normalize to ``None`` rather than raising."""
document = Document.model_validate({"total": token})
assert document.total is None
@pytest.mark.parametrize("bad", ["abc", "12.3.4", "1,2,3", "twelve"])
def test_money_unparseable_raises(bad: str) -> None:
"""A present-but-unparseable number raises (routes the doc to review).
Malformed grouping like ``12.3.4`` must not be silently mangled into a
plausible-but-wrong number; it raises so the document routes to review.
"""
with pytest.raises(ValidationError):
Document.model_validate({"total": bad})
def test_money_rejects_non_finite() -> None:
"""Infinite/NaN numeric inputs are rejected."""
with pytest.raises(ValidationError):
Document.model_validate({"total": float("inf")})
def test_money_rejects_boolean() -> None:
"""Booleans are not accepted as monetary values."""
with pytest.raises(ValidationError):
Document.model_validate({"total": True})
@pytest.mark.parametrize(
("raw", "expected"),
[
("2024-01-15", date(2024, 1, 15)), # ISO 8601
("2024-01-15T13:45:00", date(2024, 1, 15)), # ISO datetime
("2024/01/15", date(2024, 1, 15)),
("15/01/2024", date(2024, 1, 15)), # day-first
("04/13/2024", date(2024, 4, 13)), # day-first impossible -> month-first
("15-01-2024", date(2024, 1, 15)),
("15.01.2024", date(2024, 1, 15)),
("15 Jan 2024", date(2024, 1, 15)),
("January 15, 2024", date(2024, 1, 15)),
("Jan 15, 2024", date(2024, 1, 15)),
("20240115", date(2024, 1, 15)),
(date(2024, 1, 15), date(2024, 1, 15)), # passthrough
],
)
def test_date_normalization(raw: object, expected: date) -> None:
"""Common date formats normalize to ``datetime.date``."""
document = Document.model_validate({"document_date": raw})
assert document.document_date == expected
def test_date_ambiguous_resolves_day_first() -> None:
"""An ambiguous DD/MM vs MM/DD string resolves day-first."""
document = Document.model_validate({"document_date": "03/04/2024"})
assert document.document_date == date(2024, 4, 3)
@pytest.mark.parametrize("token", ["", " ", "N/A", "-", "none"])
def test_date_null_tokens_become_none(token: str) -> None:
"""Absent-value date sentinels normalize to ``None``."""
document = Document.model_validate({"document_date": token})
assert document.document_date is None
@pytest.mark.parametrize("bad", ["not-a-date", "2024-13-40", "31/31/2024"])
def test_date_unparseable_raises(bad: str) -> None:
"""A present-but-unparseable date raises."""
with pytest.raises(ValidationError):
Document.model_validate({"document_date": bad})
@pytest.mark.parametrize(
("raw", "expected"),
[("receipt", "receipt"), ("INVOICE", "invoice"), (" Other ", "other")],
)
def test_doc_type_normalized(raw: str, expected: str) -> None:
"""``doc_type`` is lower-cased and trimmed."""
document = Document.model_validate({"doc_type": raw})
assert document.doc_type == expected
@pytest.mark.parametrize("raw", ["purchase_order", "statement", "unknown"])
def test_unknown_doc_type_falls_back_to_other(raw: str) -> None:
"""An unrecognized ``doc_type`` maps to "other" instead of raising."""
document = Document.model_validate({"doc_type": raw})
assert document.doc_type == "other"
def test_currency_is_upper_cased() -> None:
"""Currency codes are upper-cased; blank values become ``None``."""
assert Document.model_validate({"currency": "sgd"}).currency == "SGD"
assert Document.model_validate({"currency": " "}).currency is None
@pytest.mark.parametrize("token", ["", " ", "N/A", "-"])
def test_blank_text_fields_become_none(token: str) -> None:
"""Blank/sentinel free-text fields normalize to ``None``."""
document = Document.model_validate(
{"vendor_name": token, "vendor_address": token, "invoice_number": token}
)
assert document.vendor_name is None
assert document.vendor_address is None
assert document.invoice_number is None
def test_numeric_invoice_number_becomes_string() -> None:
"""A numeric invoice number is preserved as text, not coerced away."""
document = Document.model_validate({"invoice_number": 100245})
assert document.invoice_number == "100245"
def test_line_item_defaults_and_normalization() -> None:
"""``LineItem`` defaults are all ``None`` and its numbers normalize."""
assert LineItem() == LineItem(
description=None, quantity=None, unit_price=None, amount=None
)
item = LineItem.model_validate(
{"description": " Coffee ", "quantity": "3", "unit_price": "$2.50", "amount": "7.50"}
)
assert item.description == "Coffee"
assert item.quantity == pytest.approx(3.0)
assert item.unit_price == pytest.approx(2.5)
assert item.amount == pytest.approx(7.5)
def test_json_roundtrip_serializes_dates_as_iso() -> None:
"""JSON serialization renders dates as ISO 8601 and round-trips cleanly."""
document = Document.model_validate(
{"document_date": "15/01/2024", "total": "$21.60", "currency": "usd"}
)
payload = document.model_dump_json()
assert '"document_date":"2024-01-15"' in payload
restored = Document.model_validate_json(payload)
assert restored == document
|