284 lines
12 KiB
Python
284 lines
12 KiB
Python
#!/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=2.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=2.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', 2.0, 'guest account — $2 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 $2 grant and ONE negative return row",
|
|
len(grants) == 1 and grants[0][0] == 2.0 and len(returns) == 1
|
|
and returns[0][0] == -2.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") == 2.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"] == 2.0, str(st_cancelled))
|
|
|
|
# live guest: active with remaining credits
|
|
conn = m.get_db()
|
|
seed_gift(conn, "live@x.org", active=1, credits=2.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())
|