trustrender 0.3.1__tar.gz → 0.3.2__tar.gz

{trustrender-0.3.1/src/trustrender.egg-info → trustrender-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustrender
-Version: 0.3.1
+Version: 0.3.2
 Summary: Validate and normalize Stripe, Shopify, and custom billing data for Factur-X/ZUGFeRD
 License-Expression: MIT
 Project-URL: Homepage, https://trustrender.dev
@@ -44,7 +44,7 @@ Dynamic: license-file
 
 Validate and normalize billing data from Stripe, Shopify, and custom systems before Factur-X/ZUGFeRD embedding.
 
-If you're bridging a non-compliant billing platform into EU e-invoicing, libraries like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) assume your data is already correct. TrustRender catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before compliant XML gets embedded.
+If you're bridging a non-compliant billing platform into EU e-invoicing, TrustRender adds a validation and normalization layer before tools like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) generate or embed compliant XML. It catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before handoff.
 
 ```
 pip install trustrender
@@ -158,6 +158,23 @@ result = validate_invoice(from_stripe(raw_stripe_response), zugferd=True)
 
 The adapter converts cents to dollars, timestamps to dates, extracts line items from `lines.data[]`, and maps customer fields to recipient. Seller info is not included in Stripe invoices — TrustRender will flag it if required for ZUGFeRD compliance.
 
+## Shopify adapter
+
+Shopify orders use decimal strings, split customer names, and a different structure from invoices:
+
+```bash
+trustrender validate shopify_order.json --source shopify
+```
+
+```python
+from trustrender import validate_invoice
+from trustrender.adapters import from_shopify
+
+result = validate_invoice(from_shopify(raw_shopify_order))
+```
+
+The adapter parses string amounts to floats, combines first_name + last_name, maps order fields to invoice structure, and preserves structured address fields. Shopify orders have no seller info or due date — TrustRender handles both correctly.
+
 ## What it normalizes
 
 90+ vendor field aliases across QuickBooks, Xero, Stripe, and generic CSV/ERP formats:

{trustrender-0.3.1 → trustrender-0.3.2}/README.md

@@ -2,7 +2,7 @@
 
 Validate and normalize billing data from Stripe, Shopify, and custom systems before Factur-X/ZUGFeRD embedding.
 
-If you're bridging a non-compliant billing platform into EU e-invoicing, libraries like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) assume your data is already correct. TrustRender catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before compliant XML gets embedded.
+If you're bridging a non-compliant billing platform into EU e-invoicing, TrustRender adds a validation and normalization layer before tools like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) generate or embed compliant XML. It catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before handoff.
 
 ```
 pip install trustrender
@@ -116,6 +116,23 @@ result = validate_invoice(from_stripe(raw_stripe_response), zugferd=True)
 
 The adapter converts cents to dollars, timestamps to dates, extracts line items from `lines.data[]`, and maps customer fields to recipient. Seller info is not included in Stripe invoices — TrustRender will flag it if required for ZUGFeRD compliance.
 
+## Shopify adapter
+
+Shopify orders use decimal strings, split customer names, and a different structure from invoices:
+
+```bash
+trustrender validate shopify_order.json --source shopify
+```
+
+```python
+from trustrender import validate_invoice
+from trustrender.adapters import from_shopify
+
+result = validate_invoice(from_shopify(raw_shopify_order))
+```
+
+The adapter parses string amounts to floats, combines first_name + last_name, maps order fields to invoice structure, and preserves structured address fields. Shopify orders have no seller info or due date — TrustRender handles both correctly.
+
 ## What it normalizes
 
 90+ vendor field aliases across QuickBooks, Xero, Stripe, and generic CSV/ERP formats:

{trustrender-0.3.1 → trustrender-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trustrender"
-version = "0.3.1"
+version = "0.3.2"
 description = "Validate and normalize Stripe, Shopify, and custom billing data for Factur-X/ZUGFeRD"
 license = "MIT"
 classifiers = [

{trustrender-0.3.1 → trustrender-0.3.2}/src/trustrender/__init__.py

@@ -36,7 +36,7 @@ class RenderResult:
     trace_id: str | None = None
 
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"
 
 __all__ = [
     # Core API (always available)

{trustrender-0.3.1 → trustrender-0.3.2}/src/trustrender/adapters/__init__.py

@@ -10,5 +10,6 @@ catches what's wrong.
 """
 
 from .stripe import from_stripe
+from .shopify import from_shopify
 
-__all__ = ["from_stripe"]
+__all__ = ["from_stripe", "from_shopify"]

trustrender-0.3.2/src/trustrender/adapters/shopify.py

@@ -0,0 +1,178 @@
+"""Shopify Order adapter.
+
+Converts a raw Shopify Admin API order response
+(GET /admin/api/2024-01/orders/{id}.json) into a dict that
+ingest_invoice() can normalize and validate.
+
+Shopify has orders, not invoices. This adapter maps order data
+to invoice-like structure for validation before e-invoice embedding.
+
+Key transformations:
+  - Amounts: decimal strings ("100.00") → floats
+  - Dates: ISO 8601 strings → YYYY-MM-DD
+  - Customer name: first_name + last_name → combined name string
+  - Line items: title → description, price (per-unit string) → unit_price (float)
+  - Line totals: computed as quantity × unit_price (Shopify doesn't always include them)
+  - Billing address: structured fields preserved for ZUGFeRD handoff
+  - Seller: NOT included in Shopify orders. Adapter leaves sender empty.
+    The validation pipeline will flag missing sender data — this is correct behavior.
+
+Usage::
+
+    from trustrender import validate_invoice
+    from trustrender.adapters import from_shopify
+
+    result = validate_invoice(from_shopify(raw_shopify_order))
+"""
+
+from __future__ import annotations
+
+
+def from_shopify(raw: dict) -> dict:
+    """Convert raw Shopify Order API response to ingest-ready dict.
+
+    Args:
+        raw: The full JSON response from GET /admin/api/.../orders/{id}.json.
+             Amounts are decimal strings. Currency is uppercase.
+
+    Returns:
+        A dict ready for ingest_invoice(). Not yet canonical,
+        not yet validated — just structurally bridged.
+
+    Raises:
+        ValueError: If raw is not a dict.
+    """
+    if not isinstance(raw, dict):
+        raise ValueError(f"from_shopify expects a dict, got {type(raw).__name__}")
+
+    out: dict = {}
+
+    # ── Order identity ───────────────────────────────────────────
+
+    # Shopify uses "name" ("#1001") or "order_number" (1001)
+    if "name" in raw:
+        out["invoice_number"] = str(raw["name"]).lstrip("#")
+    elif "order_number" in raw:
+        out["invoice_number"] = str(raw["order_number"])
+
+    if "created_at" in raw and isinstance(raw["created_at"], str):
+        out["invoice_date"] = raw["created_at"][:10]  # ISO 8601 → YYYY-MM-DD
+
+    # Shopify orders have no due_date — they are immediate payment
+
+    if "currency" in raw:
+        out["currency"] = raw["currency"]
+
+    # ── Amounts (strings → floats) ───────────────────────────────
+
+    for src, dst in [
+        ("subtotal_price", "subtotal"),
+        ("total_tax", "tax_amount"),
+        ("total_price", "total"),
+    ]:
+        val = raw.get(src)
+        if val is not None:
+            try:
+                out[dst] = float(val)
+            except (ValueError, TypeError):
+                pass
+
+    # ── Tax rate (from top-level tax_lines if available) ─────────
+
+    tax_lines = raw.get("tax_lines")
+    if isinstance(tax_lines, list) and len(tax_lines) == 1:
+        rate = tax_lines[0].get("rate")
+        if isinstance(rate, (int, float)):
+            out["tax_rate"] = rate
+
+    # ── Customer → recipient ─────────────────────────────────────
+
+    recipient: dict = {}
+
+    if isinstance(raw.get("customer"), dict):
+        cust = raw["customer"]
+        name_parts = []
+        if cust.get("first_name"):
+            name_parts.append(cust["first_name"])
+        if cust.get("last_name"):
+            name_parts.append(cust["last_name"])
+        if name_parts:
+            recipient["name"] = " ".join(name_parts)
+        if cust.get("email"):
+            recipient["email"] = cust["email"]
+
+    # Billing address
+    if isinstance(raw.get("billing_address"), dict):
+        addr = raw["billing_address"]
+        # Use billing_address.name as fallback for recipient name
+        if not recipient.get("name") and addr.get("name"):
+            recipient["name"] = addr["name"]
+        # Flatten to string for canonical address field
+        recipient["address"] = _flatten_address(addr)
+        # Preserve structured fields for ZUGFeRD handoff
+        if addr.get("city"):
+            recipient["city"] = addr["city"]
+        if addr.get("zip"):
+            recipient["postal_code"] = addr["zip"]
+        if addr.get("country_code"):
+            recipient["country"] = addr["country_code"]
+
+    if recipient:
+        out["recipient"] = recipient
+
+    # Seller is NOT available in Shopify order objects.
+    # The validation pipeline will flag this as blocked if sender.name is required.
+
+    # ── Line items ───────────────────────────────────────────────
+
+    if isinstance(raw.get("line_items"), list):
+        items = []
+        for li in raw["line_items"]:
+            if not isinstance(li, dict):
+                continue
+            item: dict = {}
+
+            if "title" in li:
+                item["description"] = li["title"]
+            if "quantity" in li:
+                item["quantity"] = li["quantity"]
+
+            # Price is per-unit, as a string
+            if "price" in li:
+                try:
+                    unit_price = float(li["price"])
+                    item["unit_price"] = unit_price
+                    # Compute line_total (Shopify doesn't always include it)
+                    if "quantity" in li:
+                        item["line_total"] = unit_price * li["quantity"]
+                except (ValueError, TypeError):
+                    pass
+
+            if item:
+                items.append(item)
+
+        if items:
+            out["items"] = items
+
+    return out
+
+
+def _flatten_address(addr: dict) -> str:
+    """Flatten Shopify address object into a single string."""
+    parts = []
+    if addr.get("address1"):
+        parts.append(addr["address1"])
+    if addr.get("address2"):
+        parts.append(addr["address2"])
+    city_parts = []
+    if addr.get("city"):
+        city_parts.append(addr["city"])
+    if addr.get("province"):
+        city_parts.append(addr["province"])
+    if addr.get("zip"):
+        city_parts.append(addr["zip"])
+    if city_parts:
+        parts.append(", ".join(city_parts))
+    if addr.get("country"):
+        parts.append(addr["country"])
+    return ", ".join(parts)

{trustrender-0.3.1 → trustrender-0.3.2}/src/trustrender/adapters/stripe.py

@@ -80,7 +80,16 @@ def from_stripe(raw: dict) -> dict:
     if raw.get("customer_email"):
         recipient["email"] = raw["customer_email"]
     if isinstance(raw.get("customer_address"), dict):
-        recipient["address"] = _flatten_address(raw["customer_address"])
+        addr = raw["customer_address"]
+        # Flatten to string for the canonical address field
+        recipient["address"] = _flatten_address(addr)
+        # Preserve structured fields for ZUGFeRD XML generation
+        if addr.get("city"):
+            recipient["city"] = addr["city"]
+        if addr.get("postal_code"):
+            recipient["postal_code"] = addr["postal_code"]
+        if addr.get("country"):
+            recipient["country"] = addr["country"]
 
     # Expanded customer object (if customer was expanded in the API call)
     if isinstance(raw.get("customer"), dict):

{trustrender-0.3.1 → trustrender-0.3.2}/src/trustrender/cli.py

@@ -62,7 +62,7 @@ def main(argv: list[str] | None = None) -> int:
     # ── Core: validation (no render deps required) ──
     validate_cmd = sub.add_parser("validate", help="Validate invoice data before Factur-X/ZUGFeRD embedding")
     validate_cmd.add_argument("data", help="Path to JSON invoice data (use '-' for stdin)")
-    validate_cmd.add_argument("--source", choices=["stripe"], help="Apply source adapter before validation (e.g. --source stripe)")
+    validate_cmd.add_argument("--source", choices=["stripe", "shopify"], help="Apply source adapter before validation (e.g. --source stripe)")
     validate_cmd.add_argument("--zugferd", action="store_true", help="Run ZUGFeRD EN 16931 readiness checks")
     validate_cmd.add_argument("--format", choices=["text", "json"], default="text", dest="output_format", help="Output format (default: text)")
 
@@ -308,6 +308,9 @@ def _run_validate(args: argparse.Namespace) -> int:
         if args.source == "stripe":
             from .adapters.stripe import from_stripe
             raw = from_stripe(raw)
+        elif args.source == "shopify":
+            from .adapters.shopify import from_shopify
+            raw = from_shopify(raw)
 
     result = validate_invoice(raw, zugferd=args.zugferd)
 
@@ -884,6 +887,8 @@ def _run_audit(args: argparse.Namespace) -> int:
 
 def _run_baseline(args: argparse.Namespace) -> int:
     """Manage render baselines."""
+    from . import audit
+
     import json as json_mod
 
     if args.baseline_action is None:

{trustrender-0.3.1 → trustrender-0.3.2/src/trustrender.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustrender
-Version: 0.3.1
+Version: 0.3.2
 Summary: Validate and normalize Stripe, Shopify, and custom billing data for Factur-X/ZUGFeRD
 License-Expression: MIT
 Project-URL: Homepage, https://trustrender.dev
@@ -44,7 +44,7 @@ Dynamic: license-file
 
 Validate and normalize billing data from Stripe, Shopify, and custom systems before Factur-X/ZUGFeRD embedding.
 
-If you're bridging a non-compliant billing platform into EU e-invoicing, libraries like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) assume your data is already correct. TrustRender catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before compliant XML gets embedded.
+If you're bridging a non-compliant billing platform into EU e-invoicing, TrustRender adds a validation and normalization layer before tools like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) generate or embed compliant XML. It catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before handoff.
 
 ```
 pip install trustrender
@@ -158,6 +158,23 @@ result = validate_invoice(from_stripe(raw_stripe_response), zugferd=True)
 
 The adapter converts cents to dollars, timestamps to dates, extracts line items from `lines.data[]`, and maps customer fields to recipient. Seller info is not included in Stripe invoices — TrustRender will flag it if required for ZUGFeRD compliance.
 
+## Shopify adapter
+
+Shopify orders use decimal strings, split customer names, and a different structure from invoices:
+
+```bash
+trustrender validate shopify_order.json --source shopify
+```
+
+```python
+from trustrender import validate_invoice
+from trustrender.adapters import from_shopify
+
+result = validate_invoice(from_shopify(raw_shopify_order))
+```
+
+The adapter parses string amounts to floats, combines first_name + last_name, maps order fields to invoice structure, and preserves structured address fields. Shopify orders have no seller info or due date — TrustRender handles both correctly.
+
 ## What it normalizes
 
 90+ vendor field aliases across QuickBooks, Xero, Stripe, and generic CSV/ERP formats:

{trustrender-0.3.1 → trustrender-0.3.2}/src/trustrender.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ src/trustrender.egg-info/entry_points.txt
 src/trustrender.egg-info/requires.txt
 src/trustrender.egg-info/top_level.txt
 src/trustrender/adapters/__init__.py
+src/trustrender/adapters/shopify.py
 src/trustrender/adapters/stripe.py
 src/trustrender/builtin_templates/einvoice.j2.typ
 src/trustrender/builtin_templates/einvoice_data.json

trustrender-0.3.2/tests/test_adapters.py

@@ -0,0 +1,357 @@
+"""Tests for source adapters (Stripe first)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from trustrender.adapters.stripe import from_stripe
+from trustrender.adapters.shopify import from_shopify
+from trustrender import validate_invoice
+
+FIXTURES = Path(__file__).parent / "fixtures" / "adapters"
+
+
+# ── from_stripe: structural transformation ───────────────────────────
+
+class TestStripeAdapter:
+
+    def test_invoice_number(self):
+        result = from_stripe({"number": "INV-001"})
+        assert result["invoice_number"] == "INV-001"
+
+    def test_amounts_cents_to_dollars(self):
+        result = from_stripe({"subtotal": 10000, "tax": 850, "total": 10850})
+        assert result["subtotal"] == 100.00
+        assert result["tax_amount"] == 8.50
+        assert result["total"] == 108.50
+
+    def test_unix_timestamps_to_dates(self):
+        result = from_stripe({"created": 1775779200, "due_date": 1778371200})
+        assert result["invoice_date"] == "2026-04-10"
+        assert result["due_date"] == "2026-05-10"
+
+    def test_currency_uppercased(self):
+        result = from_stripe({"currency": "usd"})
+        assert result["currency"] == "USD"
+
+    def test_customer_name_and_email(self):
+        result = from_stripe({
+            "customer_name": "Acme Corp",
+            "customer_email": "billing@acme.com",
+        })
+        assert result["recipient"]["name"] == "Acme Corp"
+        assert result["recipient"]["email"] == "billing@acme.com"
+
+    def test_customer_address_flattened_and_structured(self):
+        result = from_stripe({
+            "customer_address": {
+                "line1": "123 Main St",
+                "city": "Chicago",
+                "state": "IL",
+                "postal_code": "60601",
+                "country": "US",
+            },
+        })
+        # Flattened string for canonical address field
+        addr = result["recipient"]["address"]
+        assert "123 Main St" in addr
+        assert "Chicago" in addr
+
+        # Structured fields preserved for ZUGFeRD handoff
+        assert result["recipient"]["city"] == "Chicago"
+        assert result["recipient"]["postal_code"] == "60601"
+        assert result["recipient"]["country"] == "US"
+
+    def test_expanded_customer_object(self):
+        result = from_stripe({
+            "customer": {
+                "name": "Expanded Corp",
+                "email": "expanded@corp.com",
+            },
+        })
+        assert result["recipient"]["name"] == "Expanded Corp"
+        assert result["recipient"]["email"] == "expanded@corp.com"
+
+    def test_line_items_extracted(self):
+        result = from_stripe({
+            "lines": {
+                "data": [
+                    {
+                        "description": "Widget",
+                        "quantity": 2,
+                        "amount": 5000,
+                        "price": {"unit_amount": 2500},
+                    },
+                ],
+            },
+        })
+        assert len(result["items"]) == 1
+        item = result["items"][0]
+        assert item["description"] == "Widget"
+        assert item["quantity"] == 2
+        assert item["unit_price"] == 25.00
+        assert item["line_total"] == 50.00
+
+    def test_no_sender_in_output(self):
+        """Stripe invoices don't include seller info. Adapter must not invent it."""
+        result = from_stripe({"number": "INV-001", "customer_name": "Buyer"})
+        assert "sender" not in result
+
+    def test_missing_fields_left_missing(self):
+        """Adapter does not guess. Missing data stays missing."""
+        result = from_stripe({})
+        assert "invoice_number" not in result
+        assert "subtotal" not in result
+        assert "items" not in result
+
+    def test_metadata_passthrough(self):
+        result = from_stripe({"metadata": {"po_number": "PO-123"}})
+        assert result["_metadata"]["po_number"] == "PO-123"
+
+    def test_rejects_non_dict(self):
+        with pytest.raises(ValueError):
+            from_stripe("not a dict")
+        with pytest.raises(ValueError):
+            from_stripe([1, 2, 3])
+
+
+# ── Full fixture: end-to-end ─────────────────────────────────────────
+
+class TestStripeEndToEnd:
+
+    def test_full_fixture_validates(self):
+        """Full Stripe invoice fixture → adapter → validate → pass (except missing sender)."""
+        raw = json.loads((FIXTURES / "stripe_invoice.json").read_text())
+        adapted = from_stripe(raw)
+        result = validate_invoice(adapted)
+
+        # Should block on missing sender (Stripe doesn't include seller)
+        assert result["status"] == "blocked"
+        blocked_rules = {e["rule_id"] for e in result["errors"] if e.get("severity") == "blocked"}
+        assert "identity.sender_name" in blocked_rules
+
+        # But everything else should be correct
+        canonical = result["canonical"]
+        assert canonical["invoice_number"] == "INV-2026-0042"
+        assert canonical["recipient"]["name"] == "Momentum Ventures LLC"
+        assert canonical["total"] == pytest.approx(643.40)
+        assert canonical["currency"] == "USD"
+        assert len(canonical["items"]) == 3
+
+    def test_full_fixture_with_sender_passes(self):
+        """Add sender to Stripe output → should pass validation."""
+        raw = json.loads((FIXTURES / "stripe_invoice.json").read_text())
+        adapted = from_stripe(raw)
+        adapted["sender"] = {"name": "Buildspace Labs Inc.", "email": "billing@buildspace.so"}
+        result = validate_invoice(adapted)
+        assert result["render_ready"] is True
+
+    def test_incomplete_fixture_blocks(self):
+        """Stripe invoice missing customer + number → blocks on multiple rules."""
+        raw = json.loads((FIXTURES / "stripe_incomplete.json").read_text())
+        adapted = from_stripe(raw)
+        result = validate_invoice(adapted)
+        assert result["status"] == "blocked"
+        blocked_rules = {e["rule_id"] for e in result["errors"] if e.get("severity") == "blocked"}
+        assert "identity.sender_name" in blocked_rules
+        assert "identity.recipient_name" in blocked_rules
+        assert "identity.invoice_number" in blocked_rules
+
+    def test_structured_address_survives_validation(self):
+        """Structured address fields survive through validate_invoice for ZUGFeRD handoff."""
+        raw = json.loads((FIXTURES / "stripe_invoice.json").read_text())
+        adapted = from_stripe(raw)
+        adapted["sender"] = {"name": "Buildspace Labs Inc."}
+        result = validate_invoice(adapted)
+
+        # Canonical recipient.address is a string
+        recipient = result["canonical"]["recipient"]
+        assert isinstance(recipient["address"], str)
+        assert "200 Corporate Plaza" in recipient["address"]
+
+    def test_zugferd_xml_with_stripe_data(self):
+        """from_stripe → validate → build_invoice_xml should work with full data."""
+        from trustrender.zugferd import validate_zugferd_invoice_data
+
+        raw = json.loads((FIXTURES / "stripe_invoice.json").read_text())
+        adapted = from_stripe(raw)
+
+        # Supply full seller data needed for ZUGFeRD
+        adapted["sender"] = {
+            "name": "Buildspace Labs Inc.",
+            "address": "500 Tech Park Dr",
+            "city": "San Francisco",
+            "postal_code": "94105",
+            "country": "DE",
+            "vat_id": "DE123456789",
+            "email": "billing@buildspace.so",
+        }
+
+        result = validate_invoice(adapted)
+        assert result["render_ready"] is True
+
+        # Recipient should have structured fields from adapter
+        assert adapted["recipient"]["city"] == "Chicago"
+        assert adapted["recipient"]["postal_code"] == "60601"
+        assert adapted["recipient"]["country"] == "US"
+
+    def test_amounts_are_dollars_not_cents(self):
+        """Verify cents→dollars conversion happened correctly."""
+        raw = json.loads((FIXTURES / "stripe_invoice.json").read_text())
+        adapted = from_stripe(raw)
+
+        # Raw Stripe: subtotal=59300 (cents) → adapted should be 593.00
+        assert adapted["subtotal"] == 593.00
+        assert adapted["tax_amount"] == 50.40
+        assert adapted["total"] == 643.40
+
+
+# ── from_shopify: structural transformation ──────────────────────────
+
+class TestShopifyAdapter:
+
+    def test_order_number_from_name(self):
+        result = from_shopify({"name": "#1047"})
+        assert result["invoice_number"] == "1047"
+
+    def test_order_number_fallback(self):
+        result = from_shopify({"order_number": 1047})
+        assert result["invoice_number"] == "1047"
+
+    def test_amounts_strings_to_floats(self):
+        result = from_shopify({
+            "subtotal_price": "100.00",
+            "total_tax": "19.00",
+            "total_price": "119.00",
+        })
+        assert result["subtotal"] == 100.00
+        assert result["tax_amount"] == 19.00
+        assert result["total"] == 119.00
+
+    def test_date_extracted(self):
+        result = from_shopify({"created_at": "2026-04-08T14:30:00+02:00"})
+        assert result["invoice_date"] == "2026-04-08"
+
+    def test_currency_preserved(self):
+        result = from_shopify({"currency": "EUR"})
+        assert result["currency"] == "EUR"
+
+    def test_customer_name_combined(self):
+        result = from_shopify({
+            "customer": {"first_name": "Klaus", "last_name": "Berger"},
+        })
+        assert result["recipient"]["name"] == "Klaus Berger"
+
+    def test_customer_email(self):
+        result = from_shopify({
+            "customer": {"first_name": "A", "last_name": "B", "email": "a@b.com"},
+        })
+        assert result["recipient"]["email"] == "a@b.com"
+
+    def test_billing_address_flattened_and_structured(self):
+        result = from_shopify({
+            "billing_address": {
+                "address1": "Werkstr. 15",
+                "city": "Düsseldorf",
+                "province": "NRW",
+                "zip": "40210",
+                "country": "Germany",
+                "country_code": "DE",
+            },
+        })
+        assert "Werkstr. 15" in result["recipient"]["address"]
+        assert result["recipient"]["city"] == "Düsseldorf"
+        assert result["recipient"]["postal_code"] == "40210"
+        assert result["recipient"]["country"] == "DE"
+
+    def test_line_items_mapped(self):
+        result = from_shopify({
+            "line_items": [
+                {"title": "Widget", "quantity": 3, "price": "25.00"},
+            ],
+        })
+        assert len(result["items"]) == 1
+        item = result["items"][0]
+        assert item["description"] == "Widget"
+        assert item["quantity"] == 3
+        assert item["unit_price"] == 25.00
+        assert item["line_total"] == 75.00
+
+    def test_no_sender_in_output(self):
+        result = from_shopify({"name": "#1", "customer": {"first_name": "A", "last_name": "B"}})
+        assert "sender" not in result
+
+    def test_missing_fields_left_missing(self):
+        result = from_shopify({})
+        assert "invoice_number" not in result
+        assert "subtotal" not in result
+
+    def test_tax_rate_from_tax_lines(self):
+        result = from_shopify({
+            "tax_lines": [{"title": "VAT", "price": "19.00", "rate": 0.19}],
+        })
+        assert result["tax_rate"] == 0.19
+
+    def test_rejects_non_dict(self):
+        with pytest.raises(ValueError):
+            from_shopify("not a dict")
+
+    def test_billing_address_name_fallback(self):
+        """If customer has no name, use billing_address.name."""
+        result = from_shopify({
+            "customer": {"email": "test@test.com"},
+            "billing_address": {"name": "Klaus Berger"},
+        })
+        assert result["recipient"]["name"] == "Klaus Berger"
+
+
+# ── Shopify end-to-end ───────────────────────────────────────────────
+
+class TestShopifyEndToEnd:
+
+    def test_full_fixture_validates(self):
+        raw = json.loads((FIXTURES / "shopify_order.json").read_text())
+        adapted = from_shopify(raw)
+        result = validate_invoice(adapted)
+
+        # Blocks on missing sender
+        assert result["status"] == "blocked"
+        blocked_rules = {e["rule_id"] for e in result["errors"] if e.get("severity") == "blocked"}
+        assert "identity.sender_name" in blocked_rules
+
+        # But data is correct
+        canonical = result["canonical"]
+        assert canonical["invoice_number"] == "1047"
+        assert canonical["recipient"]["name"] == "Klaus Berger"
+        assert canonical["total"] == pytest.approx(1309.00)
+        assert canonical["currency"] == "EUR"
+        assert len(canonical["items"]) == 3
+
+    def test_full_fixture_with_sender_passes(self):
+        raw = json.loads((FIXTURES / "shopify_order.json").read_text())
+        adapted = from_shopify(raw)
+        adapted["sender"] = {"name": "Werkzeug-Shop GmbH", "email": "shop@werkzeug.de"}
+        result = validate_invoice(adapted)
+        assert result["render_ready"] is True
+
+    def test_incomplete_fixture_blocks(self):
+        raw = json.loads((FIXTURES / "shopify_incomplete.json").read_text())
+        adapted = from_shopify(raw)
+        result = validate_invoice(adapted)
+        assert result["status"] == "blocked"
+        blocked_rules = {e["rule_id"] for e in result["errors"] if e.get("severity") == "blocked"}
+        assert "identity.sender_name" in blocked_rules
+        assert "identity.recipient_name" in blocked_rules
+
+    def test_amounts_are_floats_not_strings(self):
+        raw = json.loads((FIXTURES / "shopify_order.json").read_text())
+        adapted = from_shopify(raw)
+        assert isinstance(adapted["subtotal"], float)
+        assert adapted["subtotal"] == 1100.00
+        assert adapted["total"] == 1309.00
+        # First item: 5 × 120.00 = 600.00
+        assert adapted["items"][0]["line_total"] == 600.00
+        assert adapted["items"][0]["unit_price"] == 120.00

{trustrender-0.3.1 → trustrender-0.3.2}/tests/test_doctor.py

@@ -31,7 +31,7 @@ class TestIndividualChecks:
     def test_trustrender_import(self):
         status, msg = check_trustrender_import()
         assert status == OK
-        assert "0.1.0" in msg
+        assert "importable" in msg
 
     def test_typst_py(self):
         status, msg = check_typst_py()

{trustrender-0.3.1 → trustrender-0.3.2}/tests/test_fingerprint.py

@@ -33,7 +33,7 @@ class TestComputeFingerprint:
         assert fp.template_hash.sha256.startswith("sha256:")
         assert fp.data_hash.startswith("sha256:")
         assert fp.fingerprint.startswith("sha256:")
-        assert fp.trustrender_version == "0.1.0"
+        assert fp.trustrender_version  # version string present
         assert fp.created_at  # ISO timestamp present
 
     def test_deterministic(self):

{trustrender-0.3.1 → trustrender-0.3.2}/tests/test_provenance.py

@@ -26,7 +26,7 @@ class TestCreateProvenance:
     def test_creates_record(self):
         record = create_provenance(EXAMPLES / "invoice.j2.typ", _load_invoice_data())
         assert record.engine == "trustrender"
-        assert record.engine_version == "0.1.0"
+        assert record.engine_version  # version string present
         assert record.template_name == "invoice.j2.typ"
         assert record.template_hash.startswith("sha256:")
         assert record.data_hash.startswith("sha256:")

trustrender-0.3.1/tests/test_adapters.py

@@ -1,170 +0,0 @@
-"""Tests for source adapters (Stripe first)."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import pytest
-
-from trustrender.adapters.stripe import from_stripe
-from trustrender import validate_invoice
-
-FIXTURES = Path(__file__).parent / "fixtures" / "adapters"
-
-
-# ── from_stripe: structural transformation ───────────────────────────
-
-class TestStripeAdapter:
-
-    def test_invoice_number(self):
-        result = from_stripe({"number": "INV-001"})
-        assert result["invoice_number"] == "INV-001"
-
-    def test_amounts_cents_to_dollars(self):
-        result = from_stripe({"subtotal": 10000, "tax": 850, "total": 10850})
-        assert result["subtotal"] == 100.00
-        assert result["tax_amount"] == 8.50
-        assert result["total"] == 108.50
-
-    def test_unix_timestamps_to_dates(self):
-        result = from_stripe({"created": 1775779200, "due_date": 1778371200})
-        assert result["invoice_date"] == "2026-04-10"
-        assert result["due_date"] == "2026-05-10"
-
-    def test_currency_uppercased(self):
-        result = from_stripe({"currency": "usd"})
-        assert result["currency"] == "USD"
-
-    def test_customer_name_and_email(self):
-        result = from_stripe({
-            "customer_name": "Acme Corp",
-            "customer_email": "billing@acme.com",
-        })
-        assert result["recipient"]["name"] == "Acme Corp"
-        assert result["recipient"]["email"] == "billing@acme.com"
-
-    def test_customer_address_flattened(self):
-        result = from_stripe({
-            "customer_address": {
-                "line1": "123 Main St",
-                "city": "Chicago",
-                "state": "IL",
-                "postal_code": "60601",
-                "country": "US",
-            },
-        })
-        addr = result["recipient"]["address"]
-        assert "123 Main St" in addr
-        assert "Chicago" in addr
-        assert "IL" in addr
-
-    def test_expanded_customer_object(self):
-        result = from_stripe({
-            "customer": {
-                "name": "Expanded Corp",
-                "email": "expanded@corp.com",
-            },
-        })
-        assert result["recipient"]["name"] == "Expanded Corp"
-        assert result["recipient"]["email"] == "expanded@corp.com"
-
-    def test_line_items_extracted(self):
-        result = from_stripe({
-            "lines": {
-                "data": [
-                    {
-                        "description": "Widget",
-                        "quantity": 2,
-                        "amount": 5000,
-                        "price": {"unit_amount": 2500},
-                    },
-                ],
-            },
-        })
-        assert len(result["items"]) == 1
-        item = result["items"][0]
-        assert item["description"] == "Widget"
-        assert item["quantity"] == 2
-        assert item["unit_price"] == 25.00
-        assert item["line_total"] == 50.00
-
-    def test_no_sender_in_output(self):
-        """Stripe invoices don't include seller info. Adapter must not invent it."""
-        result = from_stripe({"number": "INV-001", "customer_name": "Buyer"})
-        assert "sender" not in result
-
-    def test_missing_fields_left_missing(self):
-        """Adapter does not guess. Missing data stays missing."""
-        result = from_stripe({})
-        assert "invoice_number" not in result
-        assert "subtotal" not in result
-        assert "items" not in result
-
-    def test_metadata_passthrough(self):
-        result = from_stripe({"metadata": {"po_number": "PO-123"}})
-        assert result["_metadata"]["po_number"] == "PO-123"
-
-    def test_rejects_non_dict(self):
-        with pytest.raises(ValueError):
-            from_stripe("not a dict")
-        with pytest.raises(ValueError):
-            from_stripe([1, 2, 3])
-
-
-# ── Full fixture: end-to-end ─────────────────────────────────────────
-
-class TestStripeEndToEnd:
-
-    def test_full_fixture_validates(self):
-        """Full Stripe invoice fixture → adapter → validate → pass (except missing sender)."""
-        raw = json.loads((FIXTURES / "stripe_invoice.json").read_text())
-        adapted = from_stripe(raw)
-        result = validate_invoice(adapted)
-
-        # Should block on missing sender (Stripe doesn't include seller)
-        assert result["status"] == "blocked"
-        blocked_rules = {e["rule_id"] for e in result["errors"] if e.get("severity") == "blocked"}
-        assert "identity.sender_name" in blocked_rules
-
-        # But everything else should be correct
-        canonical = result["canonical"]
-        assert canonical["invoice_number"] == "INV-2026-0042"
-        assert canonical["recipient"]["name"] == "Momentum Ventures LLC"
-        assert canonical["total"] == pytest.approx(643.40)
-        assert canonical["currency"] == "USD"
-        assert len(canonical["items"]) == 3
-
-    def test_full_fixture_with_sender_passes(self):
-        """Add sender to Stripe output → should pass validation."""
-        raw = json.loads((FIXTURES / "stripe_invoice.json").read_text())
-        adapted = from_stripe(raw)
-        adapted["sender"] = {"name": "Buildspace Labs Inc.", "email": "billing@buildspace.so"}
-        result = validate_invoice(adapted)
-        assert result["render_ready"] is True
-
-    def test_incomplete_fixture_blocks(self):
-        """Stripe invoice missing customer + number → blocks on multiple rules."""
-        raw = json.loads((FIXTURES / "stripe_incomplete.json").read_text())
-        adapted = from_stripe(raw)
-        result = validate_invoice(adapted)
-        assert result["status"] == "blocked"
-        blocked_rules = {e["rule_id"] for e in result["errors"] if e.get("severity") == "blocked"}
-        assert "identity.sender_name" in blocked_rules
-        assert "identity.recipient_name" in blocked_rules
-        assert "identity.invoice_number" in blocked_rules
-
-    def test_amounts_are_dollars_not_cents(self):
-        """Verify cents→dollars conversion happened correctly."""
-        raw = json.loads((FIXTURES / "stripe_invoice.json").read_text())
-        adapted = from_stripe(raw)
-
-        # Raw Stripe: subtotal=59300 (cents) → adapted should be 593.00
-        assert adapted["subtotal"] == 593.00
-        assert adapted["tax_amount"] == 50.40
-        assert adapted["total"] == 643.40
-
-        # Line items also converted
-        assert adapted["items"][0]["line_total"] == 399.00
-        assert adapted["items"][0]["unit_price"] == 399.00
-        assert adapted["items"][1]["line_total"] == 45.00