Files
member-portal/tests/test_guest_requests.py
T
Inferencebot 88ca8bfe18 Guest state: provisioned-but-not-set-up reads 'invited', never 'active'
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.
2026-11-08 20:40:23 +00:00

433 lines
19 KiB
Python

#!/usr/bin/env python3
"""Member self-serve guest invitations — structurally isolated from live services.
WHY THIS EXISTS
The member path creates REAL guest accounts ($2 of credits, Cloudron users,
invitation email) IMMEDIATELY on a valid request (operator decision,
2026-11-08: the trial-era approval gate is gone — nothing waits, nothing is
pending). Every path proven here runs against a FIXTURE database with the
network layer REPLACED BY A RAISING GUARD: any code path that tries to reach
Cloudron, LiteLLM, OC, Listmonk, Loomio, Matrix or SMTP outside the stubs
fails the test loudly instead of acting on live systems.
IMMEDIATE PROVISIONING (POST /broker/guests, member broker identity)
1. A valid member invitation provisions at once through the FULL guest
pipeline: row marked account_type='guest', the $2 non-expiring credit,
the LiteLLM cap at $2, guest_expires_at set (the 60-day box), a guests
ledger row inviter → recipient, the invitation email (the INVITING
member named in it), and the newsletter subscription.
2. NO guest_requests row is written — no pending state exists anywhere.
3. The member's own trail shows the new guest (active) and the rolling
window flips them ineligible with next_eligible_at.
PROTECTIONS (member path — every rule still enforced)
4. A SECOND invitation by the same member inside the rolling 30-day
window is refused (one guest per member per month — the window is
counted from the guests ledger).
5. A recipient who is an EXISTING MEMBER is refused.
6. A recipient with a PRIOR guest (ledger row) is refused.
7. A recipient on MANUAL_MEMBERS is refused.
8. A non-member (no portal row) and a GUEST account are refused — only
members invite guests.
9. Re-inviting an address that was just provisioned is refused (one guest
per recipient ever — the moved-state guard behind the endpoint).
10. The GATE IS GONE: the app defines no guest-request approve/reject
routes and no GUEST_AUTO_APPROVE flag — nothing to approve anywhere.
LEGACY HISTORY
11. A rejected request from the trial period still shows in the member's
trail (history only); a rejected request blocks nothing.
PANEL LEDGER FEED
12. GET /admin/guest-ledger serves the guests ledger (the panel's
duplicate-send guard reads it).
Runnable: python3 tests/test_guest_requests.py (from the repo root)
"""
import asyncio
import base64
import os
import sys
import tempfile
from datetime import datetime, timedelta, timezone
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 ""))
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")
# The trail now derives each guest's invited/active state from the Cloudron
# user record, so it opens an httpx client around a STUBBED users fetch: the
# client is constructible but every real HTTP attempt still raises — the
# guard, kept.
class _FakeClient(_NoNetwork):
def __init__(self, *a, **k):
pass
async def __aenter__(self):
return self
async def __aexit__(self, *a):
return False
async def get(self, *a, **k):
raise AssertionError("live network attempted during fixture test")
async def post(self, *a, **k):
raise AssertionError("live network attempted during fixture test")
m.httpx.AsyncClient = _FakeClient
# Cloudron users fixture for the invited-state derivation: the fixture guest's
# Cloudron user id is 'uid-fixture' (fake_user_create below) with the invite
# NOT yet accepted. Tests flip `inviteAccepted` to simulate acceptance.
CLOUDRON_USERS = {"uid-fixture": {"inviteAccepted": False, "username": None}}
async def fake_fetch_users(client):
return [{"id": uid, "username": v.get("username"),
"inviteAccepted": v.get("inviteAccepted", False)}
for uid, v in CLOUDRON_USERS.items()]
m.cloudron_fetch_all_users = fake_fetch_users
# --- recorders (same contract as test_guest_lifecycle) ---------------------- #
calls = {"group": [], "budget": [], "email": [], "listmonk": [], "loomio": 0,
"matrix": 0}
async def rec_group(user_id, group_id=None):
calls["group"].append((user_id, group_id or m.MEMBERS_GROUP_ID))
def rec_email(to, subject, text_body=None, html_body=None):
calls["email"].append((to, subject, text_body or ""))
return True
async def rec_listmonk(email, subscribe):
calls["listmonk"].append((email, bool(subscribe)))
async def rec_loomio():
calls["loomio"] += 1
async def rec_matrix():
calls["matrix"] += 1
async def fake_team_id(email):
return "team-" + email
async def fake_get_or_create_team(email, budget, budget_duration="30d"):
return "team-fixture"
async def fake_create_key(email, budget, team_id):
return "***"
async def fake_user_create(email, name):
return "uid-fixture"
async def fake_invite_link(user_id):
return "https://my.example/setupaccount.html?inviteToken=x"
async def fake_activated(user_id):
return False
def fake_team_db(team_id):
return {"max_budget": None, "spend": 0.0, "budget_reset_at": None}
m.cloudron_set_group = rec_group
m.cloudron_set_active = rec_group
m.cloudron_create_user = fake_user_create
m.cloudron_get_invite_link = fake_invite_link
m.cloudron_is_activated = fake_activated
m.litellm_get_or_create_team = fake_get_or_create_team
m.litellm_create_key = fake_create_key
m.litellm_team_id_for_email = fake_team_id
m.litellm_update_team_budget = async_rec_budget = (lambda *a: None) # replaced below
m.get_team_budget_from_db = fake_team_db
m.send_email = rec_email
m.listmonk_sync = rec_listmonk
m.sync_loomio_memberships = rec_loomio
m.sync_matrix_space = rec_matrix
async def rec_budget(team_id, budget):
calls["budget"].append((team_id, round(float(budget), 2)))
m.litellm_update_team_budget = rec_budget
# --- 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_member(conn, email, account_type="member", active=1):
conn.execute(
"INSERT INTO members (email, key_token, cloudron_user_id, slug, active, "
"balance, credit_balance, account_type) "
"VALUES (?, 'enc', 'uid-' || ?, '', ?, ?, 0, ?)",
(email, email, active, m.MEMBER_BUDGET, account_type),
)
def main():
m.get_db().close() # create + migrate the fixture schema
conn = m.get_db()
m._ensure_allowance_tables(conn)
inviter = "member-one@x.org"
seed_member(conn, inviter, active=1)
conn.execute("UPDATE members SET slug = 'member-one' WHERE email = ?", (inviter,))
conn.commit()
conn.close()
# --- 1-3. a valid invitation PROVISIONS IMMEDIATELY ----------------------
reset = lambda: calls.update({"group": [], "budget": [], "email": [],
"listmonk": [], "loomio": 0, "matrix": 0})
reset()
conn = m.get_db()
refusal = m.guest_request_guard(conn, inviter, "friend@x.org")
check("guard: passes for an active member + fresh recipient",
refusal is None, str(refusal))
conn.close()
async def post_guest(email_addr, recipient, name=""):
"""Drive the POST /broker/guests handler directly (auth is stubbed)."""
m._verify_broker_secret = lambda request: email_addr
return await m.broker_guest_invite(
make_request("POST", {"email": recipient, "name": name}))
outcome = asyncio.run(post_guest(inviter, "friend@x.org", "Friend"))
check("invite: status is provisioned (immediate, nothing pending)",
outcome.get("status") == "provisioned", str(outcome))
check("invite: no pending_approval status anywhere in the response",
"pending" not in str(outcome).lower(), str(outcome))
check("invite: response carries the cap and the box",
outcome.get("budget") == m.GUEST_BUDGET
and outcome.get("expires_in_days") == int(m.GUEST_DAYS), str(outcome))
conn = m.get_db()
acct = conn.execute(
"SELECT account_type, balance, credit_balance, guest_expires_at "
"FROM members WHERE email = ?", ("friend@x.org",)).fetchone()
check("invite: recipient row marked guest",
acct and acct[0] == "guest", str(acct))
check("invite: allowance balance 0 (the $2 is all credit)",
acct and acct[1] == 0.0, str(acct))
check("invite: $2 non-expiring credit granted",
acct and acct[2] == m.GUEST_BUDGET, str(acct))
check("invite: 60-day box set (guest_expires_at)",
acct and bool(acct[3]), str(acct))
if acct and acct[3]:
exp = datetime.strptime(str(acct[3])[:19], "%Y-%m-%d %H:%M:%S")
delta = exp - datetime.now(timezone.utc).replace(tzinfo=None)
check("invite: expiry sits ~GUEST_DAYS out",
timedelta(0) < delta <= timedelta(days=int(m.GUEST_DAYS)),
str(acct[3]))
ledger = conn.execute(
"SELECT inviter_email, recipient_email, status FROM guests "
"WHERE recipient_email = 'friend@x.org'").fetchall()
check("invite: ledger row inviter → recipient (active)",
ledger and ledger[0][0] == inviter and ledger[0][2] == "active", str(ledger))
reqs = conn.execute("SELECT COUNT(*) FROM guest_requests").fetchone()[0]
check("invite: NO guest_requests row written (no pending state exists)",
reqs == 0, str(reqs))
conn.close()
check("invite: LiteLLM cap set to the guest budget (one-time)",
calls["budget"] == [("team-fixture", round(m.GUEST_BUDGET, 2))],
str(calls["budget"]))
check("invite: Cloudron user created into the guests group",
calls["group"] and calls["group"][0][1] == m.GUESTS_GROUP_ID, str(calls["group"]))
check("invite: invitation email sent to the recipient AT ONCE",
len(calls["email"]) == 1 and calls["email"][0][0] == "friend@x.org",
str(calls["email"]))
check("invite: invitation email NAMES the inviting member",
"member-one" in calls["email"][0][2], str(calls["email"]))
check("invite: newsletter subscribe fired",
calls["listmonk"] == [("friend@x.org", True)], str(calls["listmonk"]))
check("invite: NO Loomio/Matrix invites", not calls["loomio"] and not calls["matrix"])
# --- 3. the member's own trail shows the guest + the closed window -------
m._verify_broker_secret = lambda request: inviter
view = asyncio.run(m.broker_guest_list(make_request("GET")))
guests = [t for t in view["trail"] if t.get("kind") == "guest"]
check("trail: the new guest visible to the member as active",
len(guests) == 1 and guests[0]["recipient"] == "friend@x.org"
and guests[0]["status"] == "active", str(view["trail"]))
check("trail: un-accepted invite shows state='invited' (never reads active)",
guests and guests[0]["state"] == "invited", str(guests))
CLOUDRON_USERS["uid-fixture"]["inviteAccepted"] = True # simulate acceptance
view = asyncio.run(m.broker_guest_list(make_request("GET")))
guests = [t for t in view["trail"] if t.get("kind") == "guest"]
check("trail: after acceptance the state follows the ledger (active)",
guests and guests[0]["state"] == "active", str(guests))
check("trail: no pending entries in the member's trail",
not any(t.get("status") == "pending" for t in view["trail"]),
str(view["trail"]))
check("trail: member is not eligible inside the 30-day window",
view["eligible"] is False, str(view["eligible"]))
check("trail: next_eligible_at given", bool(view["next_eligible_at"]),
str(view["next_eligible_at"]))
# --- 4. second invitation inside the window: refused (1/month) -----------
conn = m.get_db()
refusal = m.guest_request_guard(conn, inviter, "friend2@x.org")
check("limit: second guest within 30 days refused",
refusal is not None and "30 days" in refusal, str(refusal))
# another member may still invite a DIFFERENT recipient
seed_member(conn, "member-two@x.org", active=1)
conn.commit()
refusal = m.guest_request_guard(conn, "member-two@x.org", "other@x.org")
check("limit: a DIFFERENT member is not blocked by someone else's guest",
refusal is None, str(refusal))
conn.close()
# --- 5-8. recipient-side + inviter-side refusal paths ---------------------
conn = m.get_db()
seed_member(conn, "existing@x.org", account_type="member", active=1)
conn.commit()
refusal = m.guest_request_guard(conn, "member-two@x.org", "existing@x.org")
check("refusal: existing member as recipient", refusal is not None, str(refusal))
conn.execute(
"INSERT INTO guests (inviter_email, recipient_email, created_at, status) "
"VALUES ('member-two@x.org', 'prior@x.org', datetime('now'), 'active')")
conn.commit()
refusal = m.guest_request_guard(conn, "member-two@x.org", "prior@x.org")
check("refusal: prior guest (ledger) as recipient", refusal is not None, str(refusal))
conn.close()
old_manual = set(m.MANUAL_MEMBERS)
m.MANUAL_MEMBERS = {"manual@x.org"}
conn = m.get_db()
refusal = m.guest_request_guard(conn, "member-two@x.org", "manual@x.org")
check("refusal: recipient on MANUAL_MEMBERS", refusal is not None, str(refusal))
conn.close()
m.MANUAL_MEMBERS = old_manual
# --- 8. only members reach the member path -------------------------------
conn = m.get_db()
# a non-member: no portal row at all → guest_provision_guard refuses
refusal = m.guest_request_guard(conn, "stranger@x.org", "someone@x.org")
check("refusal: non-member inviter", refusal is not None, str(refusal))
seed_member(conn, "guest-acct@x.org", account_type="guest", active=1)
conn.commit()
refusal = m.guest_request_guard(conn, "guest-acct@x.org", "someone@x.org")
check("refusal: a GUEST cannot invite guests", refusal is not None, str(refusal))
conn.close()
# --- 9. re-inviting a just-provisioned address is refused (moved state) --
reset()
conn = m.get_db()
seed_member(conn, "member-three@x.org", active=1)
conn.commit()
conn.close()
try:
asyncio.run(post_guest("member-three@x.org", "friend@x.org"))
check("moved-state: duplicate invite refused", False, "no exception raised")
except Exception as e:
code = getattr(e, "status_code", None)
check("moved-state: duplicate invite refused (429)",
code == 429 and "already received a guest account" in str(getattr(e, "detail", e)),
str(e))
conn = m.get_db()
reqs = conn.execute("SELECT COUNT(*) FROM guest_requests").fetchone()[0]
check("moved-state: still NO pending state written", reqs == 0, str(reqs))
conn.close()
# --- 10. the gate is GONE from the app -----------------------------------
paths = {getattr(r, "path", "") for r in m.app.routes}
gone = [p for p in paths if "guest-requests" in p]
check("gate gone: no guest-request routes remain on the app",
not gone, str(sorted(gone)))
check("gate gone: GUEST_AUTO_APPROVE no longer exists",
not hasattr(m, "GUEST_AUTO_APPROVE"), str(getattr(m, "GUEST_AUTO_APPROVE", None)))
# --- 11. legacy rejected history shows in the trail; blocks nothing ------
conn = m.get_db()
conn.execute(
"INSERT INTO guest_requests (inviter_email, recipient_email, status, decided_at, note) "
"VALUES (?, 'rejected-back-then@x.org', 'rejected', datetime('now'), 'not right now')",
(inviter,))
conn.commit()
conn.close()
m._verify_broker_secret = lambda request: inviter
view = asyncio.run(m.broker_guest_list(make_request("GET")))
rej = [t for t in view["trail"] if t.get("kind") == "request"
and t.get("recipient") == "rejected-back-then@x.org"]
check("legacy: a rejected request still shows in the trail (history)",
len(rej) == 1 and rej[0]["status"] == "rejected", str(view["trail"]))
check("legacy: no pending entries ever appear in the trail",
not any(t.get("status") == "pending" for t in view["trail"]),
str(view["trail"]))
conn = m.get_db()
# (member-three is already seeded and active with a fresh recipient; the
# point is a legacy rejection blocks nothing)
refusal = m.guest_request_guard(conn, "member-three@x.org", "fresh@x.org")
check("legacy: a legacy rejection does not count against anyone's window",
refusal is None, str(refusal))
conn.close()
# --- 12. the panel's ledger feed -----------------------------------------
fed = asyncio.run(m.admin_guest_ledger(
make_request("GET", headers={"X-Admin-Token": "test-admin-token"})))
recips = [r["recipient"] for r in fed.get("ledger", [])]
check("ledger feed: serves the guests ledger for the panel's guard",
"friend@x.org" in recips and "prior@x.org" in recips, str(fed))
check("ledger feed: no pending key in the payload",
"pending" not in fed and "decided" not in fed, str(sorted(fed.keys())))
print()
passed = sum(1 for _, ok, _ in results if ok)
print(f"{passed}/{len(results)} checks passed")
return 0 if passed == len(results) else 1
if __name__ == "__main__":
sys.exit(main())