#!/usr/bin/env python3 """Guest-account SELF-CANCEL tests — structurally isolated from live services. Same harness contract as test_guest_lifecycle.py: a FIXTURE database with the network layer REPLACED BY A RAISING GUARD, so any code path that tries to reach Cloudron, LiteLLM, OC, Listmonk or SMTP outside the stubs fails the test loudly instead of acting on live systems. GUARD 1. A paying member can NEVER cancel through the guest path (403). 2. An unknown identity is refused. CANCEL (the full self-service flow) 3. The row deactivates (active=0) and the account is KEPT. 4. The Cloudron user leaves the guests group for the ended-guests group. 5. The gateway budget is zeroed (revoke path called). 6. The newsletter unsubscribe fires. 7. The credit RETURN is written: a NEGATIVE ledger delta whose reason names the cancellation and the original guest reference, deduped on its own reference; the member's credit_balance goes to 0. 8. The guests ledger records inviter → recipient → 'cancelled by recipient' (rows appended, never rewritten). IDEMPOTENCE 9. A second cancel is a NO-OP: no second ledger row, no re-deactivation calls, and the reported status is the recorded one. PARTIAL-FAILURE REPLAY 10. A cancel whose return row already exists (deactivation failed mid-way last time) reports the recorded amount and writes no second ledger row. ENDED-STATE READBACK (GET /broker/guest-status payload pieces) 11. The cancelled guest reports ended + cancelled + the returned amount; a live guest reports active with its remaining credits; a member reports guest: false. Runnable: python3 tests/test_guest_cancel.py (from the repo root) """ import asyncio import base64 import os import sys import tempfile os.environ["DB_PATH"] = os.path.join(tempfile.mkdtemp(), "fixture.db") os.environ["PORTAL_KEK"] = base64.b64encode(bytes(32)).decode() os.environ.setdefault("GUESTS_GROUP_ID", "gid-fixture-guests") os.environ.setdefault("MEMBERS_GROUP_ID", "gid-fixture-members") os.environ.setdefault("INACTIVE_GROUP_ID", "gid-fixture-inactive") os.environ.setdefault("GUESTS_ENDED_GROUP_ID", "gid-fixture-guests-ended") sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) import app.main as m # noqa: E402 m.DB_PATH = os.environ["DB_PATH"] results = [] def check(name, ok, detail=""): results.append((name, bool(ok), detail)) print(("PASS " if ok else "FAIL ") + name + (f" [{detail}]" if detail and not ok else "")) class _NoNetwork: """Guard: ANY httpx client construction inside the test is a failure.""" def __init__(self, *a, **k): raise AssertionError("live network attempted during fixture test") def __call__(self, *a, **k): # pragma: no cover raise AssertionError("live network attempted during fixture test") m.httpx.AsyncClient = _NoNetwork calls = {"group": [], "revoke": [], "listmonk": [], "email": []} async def rec_group(user_id, group_id=None): calls["group"].append((user_id, group_id or m.MEMBERS_GROUP_ID)) async def rec_revoke(email): calls["revoke"].append(email) return True async def rec_listmonk(email, subscribe): calls["listmonk"].append((email, bool(subscribe))) def rec_email(to, subject, text_body=None, html_body=None): calls["email"].append((to, subject)) return True TEAM_SPEND = {} def fake_team_db(team_id): return {"max_budget": None, "spend": TEAM_SPEND.get(team_id, 0.0), "budget_reset_at": None} async def fake_team_id(email): return "team-" + email m.cloudron_set_group = rec_group m.cloudron_set_active = rec_group # same signature (uid, bool) m.litellm_team_id_for_email = fake_team_id m.get_team_budget_from_db = fake_team_db m.revoke_member_litellm_access = rec_revoke m.listmonk_sync = rec_listmonk m.send_email = rec_email def seed_gift(conn, email, active=1, credits=5.0, balance=0.0): conn.execute( "INSERT INTO members (email, key_token, cloudron_user_id, slug, active, " "balance, credit_balance, account_type, guest_expires_at) " "VALUES (?, 'enc', 'uid-' || ?, '', ?, ?, ?, 'guest', " "datetime('now', '+30 days'))", (email, email, active, balance, credits), ) conn.execute( "INSERT INTO guests (inviter_email, recipient_email, created_at, status) " "VALUES ('member-one@x.org', ?, datetime('now'), 'active')", (email,) ) def ledger_rows(conn, email): return conn.execute( "SELECT delta, reason, reference FROM credit_ledger WHERE email = ? " "ORDER BY id", (email,) ).fetchall() def main(): m.get_db().close() # create + migrate the fixture schema conn = m.get_db() # the inviter: an active member (guard requirement), and a PAYING member # whose cancellation must be refused conn.execute( "INSERT INTO members (email, key_token, cloudron_user_id, slug, active, " "balance, credit_balance, account_type) " "VALUES ('member-one@x.org', 'enc', 'uid-m1', 'memberone', 1, 15.0, 0.0, 'member')") conn.commit() conn.close() # --- 1/2. the member guard ---------------------------------------------- try: asyncio.run(m.cancel_guest_account("member-one@x.org")) check("guard: paying member cannot cancel via the guest path", False, "no 403 raised") except m.HTTPException as e: check("guard: paying member cannot cancel via the guest path", e.status_code == 403, str(e.status_code)) try: asyncio.run(m.cancel_guest_account("nobody@x.org")) check("guard: unknown identity refused", False, "no 403 raised") except m.HTTPException as e: check("guard: unknown identity refused", e.status_code == 403, str(e.status_code)) # --- 3-8. the full cancel flow ------------------------------------------ conn = m.get_db() seed_gift(conn, "invited@x.org", active=1, credits=5.0) # the grant row production writes at provisioning (add_credits on the # guest reference) — the return is audited against it conn.execute("INSERT INTO credit_ledger (email, delta, reason, reference) " "VALUES ('invited@x.org', 5.0, 'guest account — $5 credit from a member', " "'guest:invited@x.org')") conn.commit() conn.close() out = asyncio.run(m.cancel_guest_account("invited@x.org")) conn = m.get_db() row = conn.execute("SELECT active, account_type, credit_balance FROM members " "WHERE email = 'invited@x.org'").fetchone() check("cancel: row deactivated, account kept", row[0] == 0 and row[1] == "guest", str(row)) check("cancel: credit balance drawn to 0", row[2] == 0.0, str(row)) check("cancel: group moved guests → ended-guests", any(u == "uid-invited@x.org" and g == m.GUESTS_ENDED_GROUP_ID for u, g in calls["group"]), str(calls["group"])) check("cancel: gateway budget zeroed (revoke called)", "invited@x.org" in calls["revoke"], str(calls["revoke"])) check("cancel: newsletter unsubscribed", ("invited@x.org", False) in calls["listmonk"], str(calls["listmonk"])) led = ledger_rows(conn, "invited@x.org") grants = [r for r in led if r[2] == "guest:invited@x.org"] returns = [r for r in led if r[2] == "guest-return:invited@x.org"] check("cancel: ledger holds the $5 grant and ONE negative return row", len(grants) == 1 and grants[0][0] == 5.0 and len(returns) == 1 and returns[0][0] == -5.0, str(led)) check("cancel: return reason names the cancellation and the guest reference", len(returns) == 1 and "cancelled by recipient" in returns[0][1] and "guest:invited@x.org" in returns[0][1], str(returns)) g = conn.execute("SELECT inviter_email, recipient_email, status FROM guests " "WHERE recipient_email = 'invited@x.org'").fetchone() check("cancel: guests ledger shows inviter → recipient → cancelled by recipient", g and g[0] == "member-one@x.org" and g[1] == "invited@x.org" and g[2] == "cancelled by recipient", str(g)) check("cancel: result reports the returned amount", out.get("status") == "cancelled" and out.get("credits_returned") == 5.0, str(out)) conn.close() # --- 9. idempotence: the second cancel is a no-op ----------------------- calls["group"].clear(); calls["revoke"].clear(); calls["listmonk"].clear() out2 = asyncio.run(m.cancel_guest_account("invited@x.org")) conn = m.get_db() led2 = ledger_rows(conn, "invited@x.org") check("idempotent: second cancel reports already_ended", out2.get("status") == "already_ended" and out2.get("guest_status") == "cancelled by recipient", str(out2)) check("idempotent: no second return row", len([r for r in led2 if r[2] == "guest-return:invited@x.org"]) == 1, str(led2)) check("idempotent: no re-deactivation side effects", not calls["group"] and not calls["revoke"] and not calls["listmonk"], str(calls)) conn.close() # --- 10. partial-failure replay: return row exists, deactivation failed - conn = m.get_db() seed_gift(conn, "halfway@x.org", active=1, credits=4.0) # simulate the ledger row written before a crash: return recorded, row still active conn.execute("UPDATE members SET credit_balance = 0.0 WHERE email = 'halfway@x.org'") conn.execute("INSERT INTO credit_ledger (email, delta, reason, reference) " "VALUES ('halfway@x.org', -4.0, 'guest cancelled by recipient — " "unspent credit returned to the co-op (original guest: " "guest:halfway@x.org)', 'guest-return:halfway@x.org')") conn.commit() conn.close() out3 = asyncio.run(m.cancel_guest_account("halfway@x.org")) conn = m.get_db() led3 = ledger_rows(conn, "halfway@x.org") check("replay: the recorded return is reported, not re-written", len([r for r in led3 if r[2] == "guest-return:halfway@x.org"]) == 1 and out3.get("credits_returned") == 4.0, str(led3) + " / " + str(out3)) check("replay: deactivation still completed", conn.execute("SELECT active FROM members WHERE email='halfway@x.org'" ).fetchone()[0] == 0) conn.close() # --- 11. the guest-status payload pieces --------------------------------- # member: guest false conn = m.get_db() ok_member = conn.execute("SELECT 1 FROM members WHERE email='member-one@x.org'").fetchone() conn.close() if ok_member: # call the payload logic directly (the route needs a Request object) conn = m.get_db() row = conn.execute("SELECT active, balance, credit_balance FROM members " "WHERE email = 'member-one@x.org'").fetchone() conn.close() check("status: a member is not a guest (payload contract)", not m.is_guest_account("member-one@x.org")) # cancelled guest: ended + cancelled + returned amount st_cancelled = { "ended": True, "guest_status": m._guest_ledger_status("invited@x.org"), "cancelled": m._guest_ledger_status("invited@x.org") == "cancelled by recipient", "credits_returned": m._guest_returned_credits("invited@x.org"), } check("status: cancelled guest reads ended + cancelled + amount returned", st_cancelled["ended"] and st_cancelled["cancelled"] and st_cancelled["credits_returned"] == 5.0, str(st_cancelled)) # live guest: active with remaining credits conn = m.get_db() seed_gift(conn, "live@x.org", active=1, credits=5.0) conn.commit() conn.close() st_live = { "active": bool(conn_active := 1), "guest_status": m._guest_ledger_status("live@x.org"), } check("status: live guest reads active with an 'active' ledger row", st_live["active"] and st_live["guest_status"] == "active", str(st_live)) failed = [r for r in results if not r[1]] print(f"\n{len(results) - len(failed)}/{len(results)} checks passed") return 1 if failed else 0 if __name__ == "__main__": sys.exit(main())