| """Etsy-specific checkout and order closure over the shared payment ledger. |
| |
| The clone owns cart, checkout, address, and immutable order snapshots. The |
| vendored ``websitebench.site_backend`` runtime owns site binding and the |
| test-only payment state machine. A successful order always consumes the |
| matching approval inside the same SQLite transaction that creates the order. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import os |
| import re |
| import secrets |
| import sqlite3 |
| from collections.abc import Mapping |
| from typing import Any |
|
|
| from websitebench.site_backend import ( |
| PaymentConflict, |
| PaymentError, |
| PaymentRejected, |
| SiteBackend, |
| ) |
|
|
| from backend import db |
|
|
|
|
| SITE_ID = "etsy" |
| CURRENCY = "USD" |
| SHIPPING_CENTS = 0 |
| TAX_BASIS_POINTS = 825 |
| PAYMENT_ADAPTER_ENV = "WEBSITEBENCH_PAYMENT_ADAPTER" |
|
|
| _POSTAL_RE = re.compile(r"^[0-9]{5}(?:-[0-9]{4})?$") |
| _STATE_RE = re.compile(r"^[A-Z]{2}$") |
| _SAFE_SCENARIO_LABELS = { |
| "approved": "Approve test payment", |
| "declined": "Decline test payment", |
| "retryable": "Ask to retry test payment", |
| } |
|
|
|
|
| class PurchaseError(RuntimeError): |
| """The checkout is invalid, stale, foreign, or not payable.""" |
|
|
|
|
| def _require_transaction(connection: sqlite3.Connection) -> None: |
| if not isinstance(connection, sqlite3.Connection) or not connection.in_transaction: |
| raise PurchaseError("purchase operation requires an active transaction") |
|
|
|
|
| def money(cents: int | str) -> str: |
| return f"${int(cents) / 100:.2f}" |
|
|
|
|
| def payment_owner(account_id: str) -> str: |
| return f"etsy-account:{account_id}" |
|
|
|
|
| def payment_adapter(backend: SiteBackend) -> str: |
| adapter = str( |
| os.environ.get( |
| PAYMENT_ADAPTER_ENV, |
| backend.config.payments["default_adapter"], |
| ) |
| ).strip() |
| if adapter not in {"local-sandbox", "stripe-test"}: |
| raise PurchaseError("the configured test payment adapter is invalid") |
| if adapter == "stripe-test" and backend.config.payments["stripe_test"] is None: |
| raise PurchaseError("Stripe test Checkout is not configured") |
| return adapter |
|
|
|
|
| def payment_scenarios(backend: SiteBackend) -> tuple[dict[str, str], ...]: |
| if payment_adapter(backend) != "local-sandbox": |
| return () |
| return tuple( |
| { |
| "id": str(item["id"]), |
| "outcome": str(item["outcome"]), |
| "label": _SAFE_SCENARIO_LABELS[str(item["outcome"])], |
| } |
| for item in backend.config.payments["local_sandbox"]["scenarios"] |
| ) |
|
|
|
|
| def validate_address(values: Mapping[str, str]) -> tuple[dict[str, str], list[str]]: |
| address = { |
| "name": str(values.get("name", "")).strip(), |
| "address1": str(values.get("address1", "")).strip(), |
| "address2": str(values.get("address2", "")).strip(), |
| "city": str(values.get("city", "")).strip(), |
| "state": str(values.get("state", "")).strip().upper(), |
| "postal_code": str(values.get("postal_code", "")).strip(), |
| "country": "US", |
| } |
| errors: list[str] = [] |
| for field, label, maximum in ( |
| ("name", "Full name", 100), |
| ("address1", "Street address", 160), |
| ("city", "City", 100), |
| ): |
| value = address[field] |
| if not value or len(value) > maximum or any(ord(char) < 32 for char in value): |
| errors.append(f"{label} is required and must be {maximum} characters or fewer.") |
| if len(address["address2"]) > 160 or any( |
| ord(char) < 32 for char in address["address2"] |
| ): |
| errors.append("Apartment or suite must be 160 characters or fewer.") |
| if _STATE_RE.fullmatch(address["state"]) is None: |
| errors.append("State must be a two-letter US abbreviation.") |
| if _POSTAL_RE.fullmatch(address["postal_code"]) is None: |
| errors.append("ZIP code must be a valid five- or nine-digit US ZIP code.") |
| return address, errors |
|
|
|
|
| def _cart_rows(connection: sqlite3.Connection, owner_key: str) -> list[sqlite3.Row]: |
| return connection.execute( |
| "SELECT c.*,l.title,l.slug,l.image,l.stock_state,l.version AS current_version " |
| "FROM cart_lines c JOIN listings l ON l.listing_id=c.listing_id " |
| "WHERE c.owner_key=? ORDER BY c.rowid", |
| (owner_key,), |
| ).fetchall() |
|
|
|
|
| def _cart_snapshot( |
| connection: sqlite3.Connection, |
| *, |
| account_id: str, |
| owner_key: str, |
| address: Mapping[str, str], |
| ) -> dict[str, Any]: |
| rows = _cart_rows(connection, owner_key) |
| if not rows: |
| raise PurchaseError("Your cart is empty.") |
| lines: list[dict[str, Any]] = [] |
| item_total = 0 |
| for position, row in enumerate(rows): |
| if row["stock_state"] != "in-stock" or row["listing_version"] != row["current_version"]: |
| raise PurchaseError("Your cart changed. Refresh it before checkout.") |
| subtotal = int(row["unit_price_cents"]) * int(row["quantity"]) |
| item_total += subtotal |
| lines.append( |
| { |
| "position": position, |
| "cart_line_token": str(row["line_token"]), |
| "listing_id": str(row["listing_id"]), |
| "listing_version": str(row["listing_version"]), |
| "title": str(row["title"]), |
| "slug": str(row["slug"]), |
| "image": str(row["image"]), |
| "variations_json": str(row["variations_json"]), |
| "personalization": str(row["personalization"]), |
| "quantity": int(row["quantity"]), |
| "unit_price_cents": int(row["unit_price_cents"]), |
| "subtotal_cents": subtotal, |
| } |
| ) |
| tax = (item_total * TAX_BASIS_POINTS + 5_000) // 10_000 |
| total = item_total + SHIPPING_CENTS + tax |
| canonical = { |
| "site_id": SITE_ID, |
| "account_id": account_id, |
| "currency": CURRENCY, |
| "address": dict(address), |
| "lines": lines, |
| "item_total_cents": item_total, |
| "shipping_cents": SHIPPING_CENTS, |
| "tax_cents": tax, |
| "total_cents": total, |
| } |
| fingerprint = hashlib.sha256( |
| json.dumps(canonical, sort_keys=True, separators=(",", ":")).encode("utf-8") |
| ).hexdigest() |
| return {**canonical, "fingerprint": fingerprint} |
|
|
|
|
| def create_checkout( |
| connection: sqlite3.Connection, |
| backend: SiteBackend, |
| *, |
| account_id: str, |
| owner_key: str, |
| address: Mapping[str, str], |
| ) -> dict[str, Any]: |
| _require_transaction(connection) |
| snapshot = _cart_snapshot( |
| connection, |
| account_id=account_id, |
| owner_key=owner_key, |
| address=address, |
| ) |
| existing = connection.execute( |
| "SELECT * FROM checkouts WHERE account_id=? AND cart_fingerprint=?", |
| (account_id, snapshot["fingerprint"]), |
| ).fetchone() |
| if existing is not None: |
| return dict(existing) |
|
|
| checkout_id = f"checkout_{secrets.token_urlsafe(18)}" |
| adapter = payment_adapter(backend) |
| try: |
| flow = backend.payments.create_intent( |
| owner=payment_owner(account_id), |
| amount_minor=int(snapshot["total_cents"]), |
| currency=CURRENCY, |
| fingerprint=str(snapshot["fingerprint"]), |
| idempotency_key=f"etsy-checkout:{snapshot['fingerprint'][:48]}", |
| adapter=adapter, |
| connection=connection, |
| ) |
| except (PaymentConflict, PaymentError, PaymentRejected) as exc: |
| raise PurchaseError("The test payment flow could not be created.") from exc |
|
|
| address_json = json.dumps(dict(address), sort_keys=True, separators=(",", ":")) |
| connection.execute( |
| "INSERT INTO checkouts(checkout_id,account_id,status,currency,item_total_cents," |
| "shipping_cents,tax_cents,total_cents,cart_fingerprint,address_json," |
| "payment_flow_id,version,created_at,updated_at) " |
| "VALUES (?,?,?,?,?,?,?,?,?,?,?,1,?,?)", |
| ( |
| checkout_id, |
| account_id, |
| "pending-payment", |
| CURRENCY, |
| snapshot["item_total_cents"], |
| snapshot["shipping_cents"], |
| snapshot["tax_cents"], |
| snapshot["total_cents"], |
| snapshot["fingerprint"], |
| address_json, |
| flow["flow_id"], |
| db.FROZEN_CLOCK, |
| db.FROZEN_CLOCK, |
| ), |
| ) |
| for line in snapshot["lines"]: |
| connection.execute( |
| "INSERT INTO checkout_lines(checkout_id,position,cart_line_token,listing_id," |
| "listing_version,title,slug,image,variations_json,personalization,quantity," |
| "unit_price_cents,subtotal_cents) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", |
| ( |
| checkout_id, |
| line["position"], |
| line["cart_line_token"], |
| line["listing_id"], |
| line["listing_version"], |
| line["title"], |
| line["slug"], |
| line["image"], |
| line["variations_json"], |
| line["personalization"], |
| line["quantity"], |
| line["unit_price_cents"], |
| line["subtotal_cents"], |
| ), |
| ) |
| return dict( |
| connection.execute( |
| "SELECT * FROM checkouts WHERE checkout_id=?", (checkout_id,) |
| ).fetchone() |
| ) |
|
|
|
|
| def checkout_for_owner( |
| connection: sqlite3.Connection, account_id: str, checkout_id: str |
| ) -> dict[str, Any] | None: |
| row = connection.execute( |
| "SELECT * FROM checkouts WHERE checkout_id=? AND account_id=?", |
| (checkout_id, account_id), |
| ).fetchone() |
| return dict(row) if row is not None else None |
|
|
|
|
| def checkout_lines(connection: sqlite3.Connection, checkout_id: str) -> list[dict[str, Any]]: |
| return [ |
| dict(row) |
| for row in connection.execute( |
| "SELECT * FROM checkout_lines WHERE checkout_id=? ORDER BY position", |
| (checkout_id,), |
| ) |
| ] |
|
|
|
|
| def decorate_checkout( |
| connection: sqlite3.Connection, checkout: Mapping[str, Any] |
| ) -> dict[str, Any]: |
| value = dict(checkout) |
| value["address"] = json.loads(str(value["address_json"])) |
| value["lines"] = checkout_lines(connection, str(value["checkout_id"])) |
| for line in value["lines"]: |
| line["summary"] = _line_summary(line) |
| line["unit_price"] = money(line["unit_price_cents"]) |
| line["subtotal"] = money(line["subtotal_cents"]) |
| for key in ("item_total", "shipping", "tax", "total"): |
| value[key] = money(value[f"{key}_cents"]) |
| return value |
|
|
|
|
| def _line_summary(line: Mapping[str, Any]) -> str: |
| variations = json.loads(str(line["variations_json"])) |
| parts = [f"{label}: {value}" for label, value in variations.items()] |
| if line.get("personalization"): |
| parts.append(f"Personalization: {line['personalization']}") |
| return " · ".join(parts) |
|
|
|
|
| def _checkout_is_current( |
| connection: sqlite3.Connection, |
| checkout: Mapping[str, Any], |
| ) -> bool: |
| expected = checkout_lines(connection, str(checkout["checkout_id"])) |
| owner_key = f"account:{checkout['account_id']}" |
| current = _cart_rows(connection, owner_key) |
| if len(current) != len(expected): |
| return False |
| for row, line in zip(current, expected, strict=True): |
| if ( |
| str(row["line_token"]) != str(line["cart_line_token"]) |
| or str(row["listing_id"]) != str(line["listing_id"]) |
| or str(row["listing_version"]) != str(line["listing_version"]) |
| or str(row["current_version"]) != str(line["listing_version"]) |
| or str(row["stock_state"]) != "in-stock" |
| or str(row["variations_json"]) != str(line["variations_json"]) |
| or str(row["personalization"]) != str(line["personalization"]) |
| or int(row["quantity"]) != int(line["quantity"]) |
| or int(row["unit_price_cents"]) != int(line["unit_price_cents"]) |
| ): |
| return False |
| return True |
|
|
|
|
| def _mark_nonapproved( |
| connection: sqlite3.Connection, checkout_id: str, outcome: str |
| ) -> None: |
| status = "payment-declined" if outcome == "DECLINED" else "payment-retry" |
| connection.execute( |
| "UPDATE checkouts SET status=?,version=version+1,updated_at=? " |
| "WHERE checkout_id=? AND status!='completed'", |
| (status, db.FROZEN_CLOCK, checkout_id), |
| ) |
|
|
|
|
| def _finalize_order( |
| connection: sqlite3.Connection, |
| backend: SiteBackend, |
| *, |
| checkout: Mapping[str, Any], |
| ) -> dict[str, Any]: |
| _require_transaction(connection) |
| existing = connection.execute( |
| "SELECT * FROM orders WHERE checkout_id=? AND account_id=?", |
| (checkout["checkout_id"], checkout["account_id"]), |
| ).fetchone() |
| if existing is not None: |
| return dict(existing) |
| if checkout["status"] == "completed" or not _checkout_is_current(connection, checkout): |
| raise PurchaseError("The checkout is stale or already completed.") |
| try: |
| payment = backend.payments.consume_approval( |
| connection, |
| flow_id=str(checkout["payment_flow_id"]), |
| owner=payment_owner(str(checkout["account_id"])), |
| amount_minor=int(checkout["total_cents"]), |
| currency=str(checkout["currency"]), |
| fingerprint=str(checkout["cart_fingerprint"]), |
| ) |
| except (PaymentConflict, PaymentError, PaymentRejected) as exc: |
| raise PurchaseError("The test payment approval is missing or stale.") from exc |
|
|
| order_id = f"order_{secrets.token_urlsafe(18)}" |
| connection.execute( |
| "INSERT INTO orders(order_id,account_id,checkout_id,payment_flow_id,status," |
| "currency,item_total_cents,shipping_cents,tax_cents,total_cents,address_json,placed_at) " |
| "VALUES (?,?,?,?, 'paid',?,?,?,?,?,?,?)", |
| ( |
| order_id, |
| checkout["account_id"], |
| checkout["checkout_id"], |
| checkout["payment_flow_id"], |
| checkout["currency"], |
| checkout["item_total_cents"], |
| checkout["shipping_cents"], |
| checkout["tax_cents"], |
| checkout["total_cents"], |
| checkout["address_json"], |
| db.FROZEN_CLOCK, |
| ), |
| ) |
| lines = checkout_lines(connection, str(checkout["checkout_id"])) |
| for line in lines: |
| connection.execute( |
| "INSERT INTO order_lines(order_id,position,listing_id,listing_version,title," |
| "slug,image,variations_json,personalization,quantity,unit_price_cents," |
| "subtotal_cents) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)", |
| ( |
| order_id, |
| line["position"], |
| line["listing_id"], |
| line["listing_version"], |
| line["title"], |
| line["slug"], |
| line["image"], |
| line["variations_json"], |
| line["personalization"], |
| line["quantity"], |
| line["unit_price_cents"], |
| line["subtotal_cents"], |
| ), |
| ) |
| connection.execute( |
| "DELETE FROM cart_lines WHERE line_token=? AND owner_key=?", |
| (line["cart_line_token"], f"account:{checkout['account_id']}"), |
| ) |
| event_snapshot = { |
| "site_id": SITE_ID, |
| "order_id": order_id, |
| "checkout_id": checkout["checkout_id"], |
| "payment_flow_id": checkout["payment_flow_id"], |
| "payment_attempt_id": payment["attempt_id"], |
| "total_cents": int(checkout["total_cents"]), |
| "currency": CURRENCY, |
| "is_simulation": True, |
| } |
| connection.execute( |
| "INSERT INTO order_events(event_id,order_id,event_type,snapshot_json,created_at) " |
| "VALUES (?,?,'order-created',?,?)", |
| ( |
| f"orderevt_{secrets.token_urlsafe(18)}", |
| order_id, |
| json.dumps(event_snapshot, sort_keys=True, separators=(",", ":")), |
| db.FROZEN_CLOCK, |
| ), |
| ) |
| connection.execute( |
| "UPDATE checkouts SET status='completed',version=version+1,updated_at=? " |
| "WHERE checkout_id=?", |
| (db.FROZEN_CLOCK, checkout["checkout_id"]), |
| ) |
| return dict( |
| connection.execute("SELECT * FROM orders WHERE order_id=?", (order_id,)).fetchone() |
| ) |
|
|
|
|
| def attempt_local_payment( |
| connection: sqlite3.Connection, |
| backend: SiteBackend, |
| *, |
| account_id: str, |
| checkout_id: str, |
| scenario_id: str, |
| ) -> tuple[str, dict[str, Any] | None]: |
| _require_transaction(connection) |
| checkout = checkout_for_owner(connection, account_id, checkout_id) |
| if checkout is None: |
| raise PurchaseError("Checkout not found.") |
| existing = connection.execute( |
| "SELECT * FROM orders WHERE checkout_id=? AND account_id=?", |
| (checkout_id, account_id), |
| ).fetchone() |
| if existing is not None: |
| return "APPROVED", dict(existing) |
| if payment_adapter(backend) != "local-sandbox": |
| raise PurchaseError("Local test payment is not enabled.") |
| if not _checkout_is_current(connection, checkout): |
| connection.execute( |
| "UPDATE checkouts SET status='stale',version=version+1,updated_at=? " |
| "WHERE checkout_id=? AND status!='completed'", |
| (db.FROZEN_CLOCK, checkout_id), |
| ) |
| raise PurchaseError("Your cart changed. Start checkout again.") |
| allowed = {item["id"] for item in payment_scenarios(backend)} |
| if scenario_id not in allowed: |
| raise PurchaseError("Choose a valid test payment outcome.") |
| try: |
| attempt = backend.payments.attempt( |
| flow_id=str(checkout["payment_flow_id"]), |
| owner=payment_owner(account_id), |
| amount_minor=int(checkout["total_cents"]), |
| currency=CURRENCY, |
| fingerprint=str(checkout["cart_fingerprint"]), |
| scenario_id=scenario_id, |
| idempotency_key=f"etsy-attempt:{checkout_id}:{scenario_id}", |
| connection=connection, |
| ) |
| except (PaymentConflict, PaymentError, PaymentRejected) as exc: |
| raise PurchaseError("The test payment attempt was rejected.") from exc |
| outcome = str(attempt["status"]) |
| if outcome == "APPROVED": |
| return outcome, _finalize_order(connection, backend, checkout=checkout) |
| _mark_nonapproved(connection, checkout_id, outcome) |
| return outcome, None |
|
|
|
|
| def approve_verified_stripe( |
| connection: sqlite3.Connection, |
| backend: SiteBackend, |
| *, |
| checkout: Mapping[str, Any], |
| provider_session_id: str, |
| provider_snapshot: Mapping[str, Any], |
| ) -> dict[str, Any]: |
| _require_transaction(connection) |
| account_id = str(checkout["account_id"]) |
| existing = connection.execute( |
| "SELECT * FROM orders WHERE checkout_id=? AND account_id=?", |
| (checkout["checkout_id"], account_id), |
| ).fetchone() |
| if existing is not None: |
| return dict(existing) |
| if payment_adapter(backend) != "stripe-test" or not _checkout_is_current( |
| connection, checkout |
| ): |
| raise PurchaseError("Stripe test checkout is stale or unavailable.") |
| try: |
| attempt = backend.payments.attempt_verified_stripe( |
| flow_id=str(checkout["payment_flow_id"]), |
| owner=payment_owner(account_id), |
| amount_minor=int(checkout["total_cents"]), |
| currency=CURRENCY, |
| fingerprint=str(checkout["cart_fingerprint"]), |
| provider_session_id=provider_session_id, |
| idempotency_key=f"etsy-stripe:{checkout['checkout_id']}:{provider_session_id}", |
| provider_verifier=lambda _session_id: provider_snapshot, |
| connection=connection, |
| ) |
| except (PaymentConflict, PaymentError, PaymentRejected) as exc: |
| raise PurchaseError("The Stripe test Session was rejected.") from exc |
| if str(attempt["status"]) != "APPROVED": |
| raise PurchaseError("The Stripe test Session was not paid.") |
| return _finalize_order(connection, backend, checkout=checkout) |
|
|
|
|
| def checkout_by_flow( |
| connection: sqlite3.Connection, flow_id: str |
| ) -> dict[str, Any] | None: |
| row = connection.execute( |
| "SELECT * FROM checkouts WHERE payment_flow_id=?", (flow_id,) |
| ).fetchone() |
| return dict(row) if row is not None else None |
|
|
|
|
| def payment_flow( |
| connection: sqlite3.Connection, checkout: Mapping[str, Any] |
| ) -> dict[str, Any]: |
| """Return the immutable public flow facts used by the Stripe gateway.""" |
| row = connection.execute( |
| "SELECT flow_id,site_id,owner,amount_minor,currency,fingerprint,adapter," |
| "status,is_simulation FROM websitebench_payment_flows " |
| "WHERE flow_id=? AND site_id=?", |
| (checkout["payment_flow_id"], SITE_ID), |
| ).fetchone() |
| if row is None: |
| raise PurchaseError("The test payment flow is missing.") |
| value = dict(row) |
| value["is_simulation"] = bool(value["is_simulation"]) |
| return value |
|
|
|
|
| def order_for_owner( |
| connection: sqlite3.Connection, account_id: str, order_id: str |
| ) -> dict[str, Any] | None: |
| row = connection.execute( |
| "SELECT * FROM orders WHERE order_id=? AND account_id=?", |
| (order_id, account_id), |
| ).fetchone() |
| if row is None: |
| return None |
| value = dict(row) |
| value["address"] = json.loads(str(value["address_json"])) |
| value["lines"] = [ |
| dict(line) |
| for line in connection.execute( |
| "SELECT * FROM order_lines WHERE order_id=? ORDER BY position", (order_id,) |
| ) |
| ] |
| for line in value["lines"]: |
| line["summary"] = _line_summary(line) |
| line["unit_price"] = money(line["unit_price_cents"]) |
| line["subtotal"] = money(line["subtotal_cents"]) |
| for key in ("item_total", "shipping", "tax", "total"): |
| value[key] = money(value[f"{key}_cents"]) |
| return value |
|
|
|
|
| def orders_for_owner(connection: sqlite3.Connection, account_id: str) -> list[dict[str, Any]]: |
| orders: list[dict[str, Any]] = [] |
| for row in connection.execute( |
| "SELECT * FROM orders WHERE account_id=? ORDER BY placed_at DESC,order_id DESC", |
| (account_id,), |
| ): |
| order = dict(row) |
| order["total"] = money(order["total_cents"]) |
| order["line_count"] = int( |
| connection.execute( |
| "SELECT COUNT(*) FROM order_lines WHERE order_id=?", (order["order_id"],) |
| ).fetchone()[0] |
| ) |
| orders.append(order) |
| return orders |
|
|
|
|
| __all__ = [ |
| "CURRENCY", |
| "PurchaseError", |
| "approve_verified_stripe", |
| "attempt_local_payment", |
| "checkout_by_flow", |
| "checkout_for_owner", |
| "checkout_lines", |
| "create_checkout", |
| "decorate_checkout", |
| "money", |
| "order_for_owner", |
| "orders_for_owner", |
| "payment_adapter", |
| "payment_flow", |
| "payment_owner", |
| "payment_scenarios", |
| "validate_address", |
| ] |
|
|
