216 lines
8.3 KiB
Python
216 lines
8.3 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Reconcile the simulation database after a swarm run.
|
|
|
|
Checks that the HTTP journey produced a coherent database state:
|
|
orders <-> items <-> invoices <-> payment ledger <-> inventory ledger <-> history.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import sys
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
|
|
from dotenv import load_dotenv
|
|
from sqlalchemy import create_engine, text
|
|
|
|
BACKEND_DIR = Path(__file__).resolve().parents[2]
|
|
SIM_ENV = BACKEND_DIR / ".env.sim"
|
|
ARTIFACT_DIR = BACKEND_DIR / "sim-artifacts"
|
|
|
|
|
|
def scalar(conn, sql: str, **params):
|
|
return conn.execute(text(sql), params).scalar()
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser(description="Validate simulation DB consistency")
|
|
parser.add_argument("--output", default="")
|
|
args = parser.parse_args()
|
|
|
|
if not SIM_ENV.exists():
|
|
raise SystemExit(f"Missing {SIM_ENV}")
|
|
load_dotenv(SIM_ENV, override=True)
|
|
engine = create_engine(os.getenv("COMMERCE_DATABASE_URL"), future=True)
|
|
checks: dict[str, object] = {}
|
|
failures: list[str] = []
|
|
|
|
with engine.connect() as conn:
|
|
checks["customers"] = scalar(conn, "SELECT COUNT(*) FROM ecom_customers")
|
|
checks["carts"] = scalar(conn, "SELECT COUNT(*) FROM carts")
|
|
checks["orders_total"] = scalar(conn, "SELECT COUNT(*) FROM orders")
|
|
checks["order_items"] = scalar(conn, "SELECT COUNT(*) FROM order_items")
|
|
checks["invoices"] = scalar(conn, "SELECT COUNT(*) FROM invoices")
|
|
checks["payment_ledger"] = scalar(conn, "SELECT COUNT(*) FROM payment_ledger")
|
|
checks["history_rows"] = scalar(conn, "SELECT COUNT(*) FROM order_status_history")
|
|
|
|
checks["orders_by_status"] = {
|
|
r[0]: r[1]
|
|
for r in conn.execute(text("SELECT status, COUNT(*) FROM orders GROUP BY status"))
|
|
}
|
|
checks["orders_by_payment"] = {
|
|
r[0]: r[1]
|
|
for r in conn.execute(text("SELECT payment_status, COUNT(*) FROM orders GROUP BY payment_status"))
|
|
}
|
|
checks["ledger_by_provider"] = {
|
|
f"{r[0]}/{r[1]}": r[2]
|
|
for r in conn.execute(
|
|
text("SELECT provider, status, COUNT(*) FROM payment_ledger GROUP BY provider, status")
|
|
)
|
|
}
|
|
|
|
checks["revenue_confirmed"] = float(
|
|
scalar(conn, "SELECT COALESCE(SUM(final_amount),0) FROM orders WHERE status='ORDER_CONFIRMED'") or 0
|
|
)
|
|
checks["duplicate_order_numbers"] = [
|
|
r[0] for r in conn.execute(
|
|
text("SELECT order_no FROM orders GROUP BY order_no HAVING COUNT(*) > 1")
|
|
)
|
|
]
|
|
if checks["duplicate_order_numbers"]:
|
|
failures.append("duplicate order numbers")
|
|
|
|
checks["paid_without_invoice"] = [
|
|
r[0] for r in conn.execute(
|
|
text(
|
|
"SELECT o.order_id FROM orders o "
|
|
"LEFT JOIN invoices i ON i.order_id=o.order_id "
|
|
"WHERE o.payment_status='PAYMENT_CAPTURED' AND i.invoice_id IS NULL"
|
|
)
|
|
)
|
|
]
|
|
if checks["paid_without_invoice"]:
|
|
failures.append("paid orders without invoice")
|
|
|
|
checks["orphan_invoices"] = [
|
|
r[0] for r in conn.execute(
|
|
text(
|
|
"SELECT i.invoice_id FROM invoices i "
|
|
"LEFT JOIN orders o ON o.order_id=i.order_id WHERE o.order_id IS NULL"
|
|
)
|
|
)
|
|
]
|
|
if checks["orphan_invoices"]:
|
|
failures.append("invoices without orders")
|
|
|
|
checks["paid_without_captured_ledger"] = [
|
|
r[0] for r in conn.execute(
|
|
text(
|
|
"SELECT o.order_id FROM orders o "
|
|
"LEFT JOIN payment_ledger p ON p.order_id=o.order_id AND p.status='CAPTURED' "
|
|
"WHERE o.payment_status='PAYMENT_CAPTURED' AND p.payment_id IS NULL"
|
|
)
|
|
)
|
|
]
|
|
if checks["paid_without_captured_ledger"]:
|
|
failures.append("paid orders without captured payment ledger")
|
|
|
|
checks["orders_without_history"] = [
|
|
r[0] for r in conn.execute(
|
|
text(
|
|
"SELECT o.order_id FROM orders o "
|
|
"LEFT JOIN order_status_history h ON h.order_id=o.order_id "
|
|
"WHERE h.history_id IS NULL"
|
|
)
|
|
)
|
|
]
|
|
if checks["orders_without_history"]:
|
|
failures.append("orders without status history")
|
|
|
|
checks["order_total_mismatches"] = [
|
|
r[0] for r in conn.execute(
|
|
text(
|
|
"SELECT o.order_id FROM orders o "
|
|
"JOIN (SELECT order_id, ROUND(SUM(total_price),2) AS items_total FROM order_items GROUP BY order_id) x "
|
|
"ON x.order_id=o.order_id "
|
|
"WHERE ABS(o.total_amount - x.items_total) > 0.01"
|
|
)
|
|
)
|
|
]
|
|
if checks["order_total_mismatches"]:
|
|
failures.append("order total != sum(order_items)")
|
|
|
|
checks["invoice_total_mismatches"] = [
|
|
r[0] for r in conn.execute(
|
|
text(
|
|
"SELECT i.invoice_id FROM invoices i JOIN orders o ON o.order_id=i.order_id "
|
|
"WHERE ABS(i.total_amount - o.final_amount) > 0.01"
|
|
)
|
|
)
|
|
]
|
|
if checks["invoice_total_mismatches"]:
|
|
failures.append("invoice total != order final amount")
|
|
|
|
checks["confirmed_without_sale_ledger"] = [
|
|
r[0] for r in conn.execute(
|
|
text(
|
|
"SELECT o.order_id FROM orders o "
|
|
"WHERE o.status='ORDER_CONFIRMED' AND NOT EXISTS ("
|
|
" SELECT 1 FROM inventory_ledger l "
|
|
" WHERE l.reference_id=o.order_id AND l.event_type='ONLINE_SALE_FROM_RESERVATION'"
|
|
")"
|
|
)
|
|
)
|
|
]
|
|
if checks["confirmed_without_sale_ledger"]:
|
|
failures.append("confirmed orders without sale ledger")
|
|
|
|
checks["negative_stock_variants"] = [
|
|
r[0] for r in conn.execute(
|
|
text(
|
|
"SELECT variant_id FROM inventory_ledger GROUP BY variant_id HAVING SUM(qty) < 0"
|
|
)
|
|
)
|
|
]
|
|
if checks["negative_stock_variants"]:
|
|
failures.append("negative stock")
|
|
|
|
checks["opening_stock"] = scalar(
|
|
conn, "SELECT COALESCE(SUM(qty),0) FROM inventory_ledger WHERE reference_id='SIM_SEED'"
|
|
)
|
|
checks["sold_units"] = scalar(
|
|
conn, "SELECT COALESCE(SUM(-qty),0) FROM inventory_ledger "
|
|
"WHERE event_type='ONLINE_SALE_FROM_RESERVATION'"
|
|
)
|
|
checks["current_stock"] = scalar(conn, "SELECT COALESCE(SUM(qty),0) FROM inventory_ledger")
|
|
checks["stock_delta"] = int(checks["current_stock"]) - int(checks["opening_stock"]) + int(checks["sold_units"])
|
|
if checks["stock_delta"] != 0:
|
|
failures.append("inventory ledger does not balance")
|
|
|
|
checks["carts_with_items"] = scalar(
|
|
conn, "SELECT COUNT(*) FROM carts WHERE items_json IS NOT NULL"
|
|
)
|
|
|
|
report = {
|
|
"checked_at": datetime.now(timezone.utc).isoformat(),
|
|
"database": os.getenv("COMMERCE_DATABASE_URL", "").rsplit("/", 1)[-1],
|
|
"checks": checks,
|
|
"failures": failures,
|
|
"ok": not failures,
|
|
}
|
|
ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
|
|
output = Path(args.output) if args.output else ARTIFACT_DIR / "reconciliation.json"
|
|
output.write_text(json.dumps(report, indent=2, default=str))
|
|
|
|
print(f"=== RECONCILIATION ({'OK' if report['ok'] else 'FAILED'}) ===")
|
|
for key in (
|
|
"customers", "orders_total", "order_items", "invoices", "payment_ledger",
|
|
"history_rows", "revenue_confirmed", "opening_stock", "sold_units", "current_stock",
|
|
):
|
|
print(f"{key:22}: {checks[key]}")
|
|
print(f"{'orders_by_status':22}: {checks['orders_by_status']}")
|
|
print(f"{'orders_by_payment':22}: {checks['orders_by_payment']}")
|
|
print(f"{'ledger_by_provider':22}: {checks['ledger_by_provider']}")
|
|
if failures:
|
|
print("\nFAILURES:")
|
|
for failure in failures:
|
|
print(f" - {failure}")
|
|
print(f"\nreport: {output}")
|
|
return 0 if report["ok"] else 2
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|