Files
member-portal/tests/test_credit_pack_idempotence.py
inference-bot e6ab177a05 credits: make the credit-pack webhook grant idempotent (audit H1)
- reference built per-order from the webhook's order.idV2 (the id the
  amount lookup resolves) instead of the absent data.id that produced
  the legacy empty-suffix 'oc:<slug>:' format; legacy ledger rows are
  neither re-keyed nor rejected (a new-format reference can never match
  one)
- credit_reference_exists() gates add_credits; a re-delivered order
  returns 'already_credited' with the standing balance
- hold path: one hold per purchase via a pre-check plus a UNIQUE index
  on held_credits.oc_reference (index creation logs CRITICAL and
  continues if the live table ever carried duplicates — audited: none)
- get_order_amount sends the webhook-supplied order id as a GraphQL
  variable instead of interpolating it into the query (audit L9)
- regression test: replay credits exactly once; legacy rows never
  block a first grant; unique-index semantics incl. NULLs
2026-11-05 15:54:29 +00:00

155 lines
7.0 KiB
Python

#!/usr/bin/env python3
"""Regression tests for credit-pack webhook idempotence (audit H1, 2026-11-05).
Runnable:
* from the repo root: python3 tests/test_credit_pack_idempotence.py
* inside the portal app: PORTAL_CODE_DIR=/app/code python3 /tmp/test_credit_pack_idempotence.py
(the container has the app's own dependencies; the host usually does not)
WHY THIS EXISTS
The webhook credit-pack grant used to key its dedupe on `data.get('id')`,
which is absent from real OC deliveries — every recorded reference came out
`oc:<slug>:` (empty suffix), so the key could not distinguish two purchases
by the same member, and NO exists-check guarded the grant at all. One
re-delivered (or replayed, or forged-but-OC-resolvable) event then credits
the pack a second time.
Covered:
- the reference is built per-ORDER (per-purchase), non-empty
- a replayed order credits exactly once, even though the handler runs
twice (simulated by replaying the same grant sequence)
- a NEW order from the same member is never blocked by an earlier one
- a LEGACY empty-suffix ledger row neither matches nor rejects a new
grant (no re-shaping of historical rows — the invariant the fix
must respect)
- held_credits.oc_reference carries a UNIQUE index (one hold per
purchase; NULLs and distinct legacy refs stay legal)
- the DB starts with the unique index present even though legacy
rows exist (no duplicate live rows to violate it)
"""
import os
import sqlite3
import sys
import tempfile
_TEST_DB = os.path.join(tempfile.mkdtemp(prefix="creditpack-test-"), "members.db")
os.environ["DB_PATH"] = _TEST_DB # must exist BEFORE app.main is imported
# Locate the app package: explicit env, the deployed path, or the repo root.
for _cand in (os.environ.get("PORTAL_CODE_DIR"), "/app/code",
os.path.dirname(os.path.dirname(os.path.abspath(__file__)))):
if _cand and os.path.isfile(os.path.join(_cand, "app", "main.py")):
sys.path.insert(0, _cand)
break
from app.main import ( # noqa: E402
add_credits, credit_pack_reference, credit_reference_exists, get_credit_balance, get_db,
)
failures = 0
def check(name, got, want):
global failures
ok = got == want
if not ok:
failures += 1
print(f"[{'PASS' if ok else 'FAIL'}] {name}")
if not ok:
print(f" got {got!r}\n want {want!r}")
def grant_once(email, amount, ref):
"""The exact grant sequence the webhook now runs (exists-check gates add)."""
if credit_reference_exists(ref):
return "already_credited"
add_credits(email, amount, reason="credit pack purchase (Open Collective)", reference=ref)
return "credits_added"
# --- reference building: per-order, non-empty, distinct per purchase ---
check("reference keyed on the order id",
credit_pack_reference("caseyg", {"idV2": "or_abc123"}), "oc:caseyg:or_abc123")
check("two purchases differ even from one member",
credit_pack_reference("caseyg", {"idV2": "or_1"}) != credit_pack_reference("caseyg", {"idV2": "or_2"}),
True)
try:
credit_pack_reference("caseyg", {})
check("missing order idV2 refused (no ambiguous/empty reference)", False, True)
credit_pack_reference("caseyg", {"idV2": ""})
check("empty order idV2 refused", False, True)
except ValueError:
check("missing/empty order idV2 refused (no ambiguous/empty reference)", True, True)
# --- replay on a real (temporary) DB: one replay = exactly one credit ---
conn = get_db() # initializes schema (incl. the unique index) on the temp db
conn.execute("INSERT INTO members (email, key_token, active) VALUES ('p@example.com', '', 1)")
conn.commit()
ref_a = credit_pack_reference("p", {"idV2": "or_test_a"})
r1 = grant_once("p@example.com", 10.0, ref_a) # first delivery
r2 = grant_once("p@example.com", 10.0, ref_a) # re-delivery of the SAME order
check("first delivery grants", r1, "credits_added")
check("replay of the same order is refused", r2, "already_credited")
n = conn.execute("SELECT COUNT(*) FROM credit_ledger WHERE reference = ?", (ref_a,)).fetchone()[0]
check("exactly ONE ledger row for the replayed order", n, 1)
check("balance credited once (10, not 20)", get_credit_balance("p@example.com"), 10.0)
# --- a NEW purchase from the same member is never blocked ---
ref_b = credit_pack_reference("p", {"idV2": "or_test_b"})
r3 = grant_once("p@example.com", 5.0, ref_b)
check("a different order still credits normally", r3, "credits_added")
check("balance includes the second purchase", get_credit_balance("p@example.com"), 15.0)
# --- legacy empty-suffix rows: never matched, never reshaped ---
grant_once("legacy@example.com", 23.0, "oc:caseyg:") # simulate a pre-fix ledger row
legacy_rows = conn.execute(
"SELECT COUNT(*) FROM credit_ledger WHERE reference = 'oc:caseyg:'").fetchone()[0]
check("legacy row stored exactly as it was written", legacy_rows, 1)
new_from_legacy_member = credit_pack_reference("caseyg", {"idV2": "or_new"})
check("a new purchase does NOT match the legacy empty-suffix row",
credit_reference_exists(new_from_legacy_member), False)
check("a new purchase by the legacy member credits normally",
grant_once("legacy@example.com", 15.0, new_from_legacy_member), "credits_added")
still = conn.execute(
"SELECT COUNT(*) FROM credit_ledger WHERE reference = 'oc:caseyg:'").fetchone()[0]
check("the legacy row was neither rejected nor re-shaped", still, 1)
# --- held_credits.oc_reference: UNIQUE index semantics ---
idx = conn.execute(
"SELECT name FROM sqlite_master WHERE type='index' AND name='idx_held_credits_oc_reference'"
).fetchone()
check("unique index exists on a fresh (and the live-shaped) db", bool(idx), True)
conn.execute(
"INSERT INTO held_credits (slug, email, name, amount, oc_reference, status) "
"VALUES ('buyer-a', NULL, 'Buyer A', 20.0, 'oc:buyer-a:or_h1', 'held')")
try:
conn.execute(
"INSERT INTO held_credits (slug, email, name, amount, oc_reference, status) "
"VALUES ('buyer-a', NULL, 'Buyer A', 20.0, 'oc:buyer-a:or_h1', 'held')")
conn.commit()
check("second hold for the SAME order rejected by the unique index", False, True)
except sqlite3.IntegrityError:
conn.rollback()
check("second hold for the SAME order rejected by the unique index", True, True)
conn.execute(
"INSERT INTO held_credits (slug, email, name, amount, oc_reference, status) "
"VALUES ('buyer-b', NULL, 'Buyer B', 10.0, 'oc:buyer-b:or_h2', 'held')")
conn.commit()
check("a different purchase still gets its own hold", True, True)
conn.execute(
"INSERT INTO held_credits (slug, email, name, amount, oc_reference, status) "
"VALUES ('unknown', NULL, NULL, 10.0, NULL, 'held')")
conn.execute(
"INSERT INTO held_credits (slug, email, name, amount, oc_reference, status) "
"VALUES ('unknown', NULL, NULL, 10.0, NULL, 'held')")
conn.commit()
check("NULL oc_reference rows stay legal (index does not overblock)", True, True)
conn.close()
print(f"\n{'FAILED' if failures else 'OK'} — {failures} failure(s)")
sys.exit(1 if failures else 0)