A guest invitation provisions immediately, but the Cloudron account is not ACCEPTED until the guest clicks the setup link (inviteAccepted=false, no username) — until then they cannot log in, so no surface may read them as active. guest_invite_pending() derives it from the same Cloudron signal the overview's activated flag uses; unseen-record (users fetch failed) is never pending, so the state falls back instead of asserting what the data does not show. /admin/overview: guest rows report state='invited' with an 'awaiting setup' reason (invite date named when the ledger has it); /broker/guests trail entries carry state='invited' the same way, status stays the ledger record of record. Display/state semantics only — access rules, the $2 cap and the expiry box are unchanged. Tests: new test_guest_invited_state.py (derivation, overview flip, fetch-failure fallback, member rows untouched, trail state); test_guest_requests.py gains the trail invited/accepted assertions and a constructible-but-loud fake client so the stubbed users fetch runs.
292 lines
13 KiB
Python
292 lines
13 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;
|
|
the guests ledger status stays the record of record.
|
|
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: an inactive guest still reads inactive (not invited)",
|
|
ended["state"] == "inactive", str(ended.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()
|