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.
318 lines
14 KiB
Python
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()
|