Files
member-portal/tests/test_guest_invited_state.py
inference-bot 58214be0db Guest state: the overview payload carries the definitive display state
Single derivation point (tested once, here): 'invited' while the Cloudron
invite is unaccepted, else the guests-ledger status (the record of record),
membership state only as a no-ledger-row fallback. The panel and dashboard
become pure consumers of `state` — their local invited/active derivation
goes away in their own repos next. Live-behaviour note: today's four live
guests render byte-identically; the change only shows for ended guests
(ledger 'expired' instead of the bare inactive flag), which is what the
panel already displayed via its own guest_status preference.
2026-11-11 05:16:13 +00:00

318 lines
14 KiB
Python

#!/usr/bin/env python3
"""Guest invited state — a provisioned-but-NOT-set-up guest never reads 'active'.
WHY THIS EXISTS
A guest invitation provisions IMMEDIATELY (Cloudron user + invitation email
with the setup link), but the Cloudron account is not ACCEPTED until the
guest clicks that link (inviteAccepted=false, no username) — they cannot
log in yet. Every surface that reads the guest's state must therefore show
'invited' (awaiting setup) at that point, never 'active', and flip to the
ordinary state only when the invite is accepted. Display/state semantics
only: access rules, the guest cap and the expiry box are unchanged.
Every path here runs against a FIXTURE database with the network layer
REPLACED: any code path that reaches Cloudron/LiteLLM/OC/Listmonk outside
the stubs fails the test loudly instead of acting on live systems.
1. guest_invite_pending — the derivation itself: accepted, username-set,
unseen-record (fetch failed) and no-user-id cases.
2. GET /admin/overview: a fresh guest (inviteAccepted=false, no
username) reports state='invited' with an 'awaiting setup' reason.
Once accepted, state FOLLOWS THE LEDGER STATUS (active / expired /
...) — the single derivation point for the guest display state,
consumed as-is by the panel and dashboard; a guest with no ledger
row falls back to the membership state.
3. Simulated acceptance (inviteAccepted flips true, or a username is
chosen) → the same endpoint reports state='active'.
4. A FAILED Cloudron users fetch never claims 'invited' — the row falls
back to the membership state rather than inventing a state the data
does not show.
5. An established MEMBER row is untouched by the guest branch: state
'active', empty reason, still in members[].
6. The member's trail (GET /broker/guests) carries state='invited' for
the un-accepted guest and state=<ledger status> once accepted.
Runnable: python3 tests/test_guest_invited_state.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["ADMIN_TOKEN"] = "test-admin-token" # admin endpoints authenticate on this
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")
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 ""))
# --- Cloudron users fixture (the ONLY external signal this feature reads) --- #
CLOUDRON_USERS = {
"uid-guest@x.org": {"inviteAccepted": False, "username": None},
"uid-member@x.org": {"inviteAccepted": True, "username": "established"},
}
class _FakeResponse:
status_code = 200
def raise_for_status(self):
pass
def json(self):
return [] # LiteLLM /team/list: no teams in this fixture
class _FakeClient:
"""Answers only what admin_overview asks: cloudron_fetch_all_users (stubbed
separately) and the LiteLLM team/list GET (empty)."""
def __init__(self, *a, **k):
pass
async def __aenter__(self):
return self
async def __aexit__(self, *a):
return False
async def get(self, url, **k):
return _FakeResponse()
class _NoNetwork:
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 = _FakeClient # ONLY _FakeClient.__init__-safe paths run
async def fetch_users_ok(client):
return [{"id": uid, "username": v.get("username"),
"inviteAccepted": v.get("inviteAccepted", False)}
for uid, v in CLOUDRON_USERS.items()]
async def fetch_users_broken(client):
return None # page 1 unresolvable — the documented fetch-failure shape
m.cloudron_fetch_all_users = fetch_users_ok
# The overview's all-time-spend query is a PG read — absent in the fixture and
# fail-soft by design; make that loud rather than implicit.
def _no_pg(*a, **k):
raise AssertionError("live PG attempted during fixture test")
m._pg_connect = _no_pg
# --- real Request objects (the slowapi limiter decorator requires them) ----- #
from starlette.requests import Request as StarletteRequest # noqa: E402
import json as _json # noqa: E402
def make_request(method="GET", body=None, headers=None):
raw = _json.dumps(body or {}).encode()
headers = dict(headers or {})
if raw and "content-length" not in headers:
headers["content-length"] = str(len(raw))
async def receive():
return {"type": "http.request", "body": raw, "more_body": False}
scope = {
"type": "http", "method": method, "path": "/", "query_string": b"",
"headers": [(k.lower().encode(), v.encode()) for k, v in (headers or {}).items()],
"server": ("testserver", 80), "client": ("testclient", 123),
}
return StarletteRequest(scope, receive)
def seed_account(conn, email, account_type="member", active=1, uid=None):
conn.execute(
"INSERT INTO members (email, key_token, cloudron_user_id, slug, active, "
"balance, credit_balance, account_type) "
"VALUES (?, 'enc', ?, '', ?, ?, 0, ?)",
(email, uid or ("uid-" + email), active, 0.0, account_type),
)
def seed_guest_ledger(conn, inviter, recipient, status="active"):
conn.execute(
"INSERT INTO guests (inviter_email, recipient_email, oc_reference, "
"guest_expires_at, status, created_at) "
"VALUES (?, ?, NULL, datetime('now', '+60 days'), ?, datetime('now'))",
(inviter, recipient, status),
)
def main():
m.get_db().close() # create + migrate the fixture schema
conn = m.get_db()
m._ensure_allowance_tables(conn)
# --- 1. the derivation itself --------------------------------------------
check("derive: accepted invite is not pending",
m.guest_invite_pending("u", {}, {"u": True}) is False)
check("derive: a chosen username counts as accepted (first login)",
m.guest_invite_pending("u", {"u": "theirname"}, {"u": False}) is False)
check("derive: un-accepted + no username IS pending",
m.guest_invite_pending("u", {}, {"u": False}) is True)
check("derive: a record we never saw is NOT pending (fetch failed)",
m.guest_invite_pending("u", {}, {}) is False)
check("derive: no user id is never pending",
m.guest_invite_pending(None, {}, {"u": False}) is False)
# --- 2-5. /admin/overview --------------------------------------------------
inviter = "info@inference.coop" # the admin path's inviter
seed_account(conn, "member@x.org", account_type="member", active=1)
seed_account(conn, "guest@x.org", account_type="guest", active=1)
seed_account(conn, "ended@x.org", account_type="guest", active=0)
seed_guest_ledger(conn, inviter, "guest@x.org")
seed_guest_ledger(conn, inviter, "ended@x.org", status="expired")
conn.commit()
conn.close()
async def overview():
return await m.admin_overview(make_request(
"GET", headers={"X-Admin-Token": "test-admin-token"}))
data = asyncio.run(overview())
g = [x for x in data["guests"] if x["email"] == "guest@x.org"][0]
check("overview: fresh guest listed under guests[], never members[]",
len(data["guests"]) == 2 and not any(x["email"] == "guest@x.org" for x in data["members"]),
str([x["email"] for x in data["guests"]]))
check("overview: un-accepted guest reads state='invited'",
g["state"] == "invited", str(g.get("state")))
check("overview: invited reason is the awaiting-setup line",
str(g.get("state_reason", "")).startswith("awaiting setup"),
str(g.get("state_reason")))
check("overview: ledger status still the record of record",
g.get("guest_status") == "active", str(g.get("guest_status")))
check("overview: activated flag agrees (pending)",
g.get("activated") is False, str(g.get("activated")))
ended = [x for x in data["guests"] if x["email"] == "ended@x.org"][0]
check("overview: ended guest reads its LEDGER status ('expired'), not the bare flag",
ended["state"] == "expired" and ended["state_reason"] == "",
f"{ended.get('state')} / {ended.get('state_reason')!r}")
# The ledger is the record of record even when it disagrees with the
# members.active flag: an active-flagged guest whose access has ENDED
# (expired ledger row, active flag not yet flipped) reads 'expired'.
conn = m.get_db()
CLOUDRON_USERS["uid-lapsed@x.org"] = {"inviteAccepted": True, "username": "lapsedg"}
seed_account(conn, "lapsed@x.org", account_type="guest", active=1,
uid="uid-lapsed@x.org")
seed_guest_ledger(conn, inviter, "lapsed@x.org", status="expired")
# ...and a guest with NO ledger row falls back to the membership state.
CLOUDRON_USERS["uid-noledger@x.org"] = {"inviteAccepted": True, "username": "noledger"}
seed_account(conn, "noledger@x.org", account_type="guest", active=1,
uid="uid-noledger@x.org")
conn.commit()
conn.close()
data = asyncio.run(overview())
lapsed = [x for x in data["guests"] if x["email"] == "lapsed@x.org"][0]
check("overview: ledger status wins over the active flag (lapsed guest = 'expired')",
lapsed["state"] == "expired", str(lapsed.get("state")))
noledger = [x for x in data["guests"] if x["email"] == "noledger@x.org"][0]
check("overview: no ledger row → membership-state fallback ('active')",
noledger["state"] == "active", str(noledger.get("state")))
# --- 3. simulated acceptance: the flip to active ---------------------------
CLOUDRON_USERS["uid-guest@x.org"]["inviteAccepted"] = True
data = asyncio.run(overview())
g = [x for x in data["guests"] if x["email"] == "guest@x.org"][0]
check("overview: after acceptance the guest reads state='active'",
g["state"] == "active", str(g.get("state")))
check("overview: accepted guest carries no awaiting-setup reason",
g.get("state_reason", "") == "", str(g.get("state_reason")))
check("overview: activated flag agrees (yes)",
g.get("activated") is True, str(g.get("activated")))
# ...and the username-only variant (the guest finished setup by name):
CLOUDRON_USERS["uid-guest@x.org"]["inviteAccepted"] = False
CLOUDRON_USERS["uid-guest@x.org"]["username"] = "theirname"
data = asyncio.run(overview())
g = [x for x in data["guests"] if x["email"] == "guest@x.org"][0]
check("overview: a chosen username alone flips the guest to active",
g["state"] == "active", str(g.get("state")))
CLOUDRON_USERS["uid-guest@x.org"]["username"] = None
# --- 4. a failed Cloudron fetch never claims 'invited' ---------------------
m.cloudron_fetch_all_users = fetch_users_broken
data = asyncio.run(overview())
g = [x for x in data["guests"] if x["email"] == "guest@x.org"][0]
check("overview: users fetch failed → fallback state, never 'invited'",
g["state"] == "active" and g["state_reason"] == "",
f"{g.get('state')} / {g.get('state_reason')!r}")
m.cloudron_fetch_all_users = fetch_users_ok
# --- 5. an established member's row is untouched ----------------------------
data = asyncio.run(overview()) # fresh payload from the working fetch
mem = [x for x in data["members"] if x["email"] == "member@x.org"][0]
check("overview: established member state unchanged ('active', no reason)",
mem["state"] == "active" and mem["state_reason"] == "",
f"{mem.get('state')} / {mem.get('state_reason')!r}")
check("overview: established member activated (not caught by the guest branch)",
mem.get("activated") is True, str(mem.get("activated")))
# --- 6. the member's trail carries the same derivation ----------------------
m._verify_broker_secret = lambda request: "member@x.org"
conn = m.get_db()
seed_guest_ledger(conn, "member@x.org", "friend@x.org")
seed_account(conn, "friend@x.org", account_type="guest", active=1)
conn.commit()
conn.close()
CLOUDRON_USERS["uid-friend@x.org"] = {"inviteAccepted": False, "username": None}
view = asyncio.run(m.broker_guest_list(make_request("GET")))
trail_guests = [t for t in view["trail"] if t.get("kind") == "guest"]
check("trail: un-accepted guest carries state='invited'",
len(trail_guests) == 1 and trail_guests[0]["state"] == "invited",
str(view["trail"]))
check("trail: ledger status still 'active' underneath",
trail_guests and trail_guests[0]["status"] == "active", str(view["trail"]))
CLOUDRON_USERS["uid-friend@x.org"]["inviteAccepted"] = True
view = asyncio.run(m.broker_guest_list(make_request("GET")))
trail_guests = [t for t in view["trail"] if t.get("kind") == "guest"]
check("trail: after acceptance state follows the ledger status",
trail_guests and trail_guests[0]["state"] == "active", str(view["trail"]))
conn = m.get_db()
conn.execute("UPDATE members SET active = 0 WHERE email = 'friend@x.org'")
conn.execute("UPDATE guests SET status = 'expired' WHERE recipient_email = 'friend@x.org'")
conn.commit()
conn.close()
view = asyncio.run(m.broker_guest_list(make_request("GET")))
trail_guests = [t for t in view["trail"] if t.get("kind") == "guest"]
check("trail: an ended guest shows its ledger status, never 'invited'",
trail_guests and trail_guests[0]["state"] == "expired", str(view["trail"]))
failed = [name for name, ok, _ in results if not ok]
print()
print(f"{len(results) - len(failed)}/{len(results)} checks passed")
if failed:
print("FAILED: " + ", ".join(failed))
sys.exit(1)
if __name__ == "__main__":
main()