#!/usr/bin/env python3 """Does the sliding session with a hard ceiling work? - D18 / T13.1 (checked in T13.6). T13.1 shipped with its done-when list unchecked and no test of its own; the old session tests had no idea about idle time. This is that test. 1. Continuous activity keeps a session alive past 30 minutes, but never past the absolute ceiling (AUTH_SESSION_HOURS) measured from the ORIGINAL sign-in. 2. A session idle for more than 30 minutes is refused on its next request. 3. The cookie is not rewritten on every request (the refresh is throttled). 4. A token from before this shipped (no login_at) still gets a hard ceiling, from its iat. 5. A refresh carries identity and login_at forward unchanged. 6. The two variables are documented, and both defaults are flagged as proposed. Self-contained: throwaway SQLite, in-process test client, no network, no browser. Exit 0 all passed, 1 a failure. """ import os import re import sys import tempfile from datetime import datetime, timedelta, timezone ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.insert(0, ROOT) os.environ["DATABASE_URL"] = "sqlite:///" + os.path.join(tempfile.mkdtemp(prefix="wp-idle-"), "t.db").replace("\\", "/") os.environ["AUTH_SECRET_KEY"] = "session-idle-check-secret-not-for-production" os.environ.pop("AUTH_IDLE_MINUTES", None) os.environ.pop("AUTH_SESSION_HOURS", None) import jwt # noqa: E402 from fastapi.testclient import TestClient # noqa: E402 from server import app as appmod, auth, models # noqa: E402 from server.db import Base, SessionLocal, engine # noqa: E402 if not hasattr(auth, "maybe_refresh_token"): print("SKIP: T13.1 (sliding session) is not on this branch. It waits for T14.1.") sys.exit(0) fails = 0 def chk(label, ok, extra=""): global fails print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else "")) if not ok: fails += 1 Base.metadata.create_all(bind=engine) with SessionLocal() as db: db.add(models.User(id="u1", username="alice", email="a@x.test", role=auth.ROLE_ADMIN)) db.commit() USER = db.get(models.User, "u1") db.expunge(USER) # A route the auth gate covers. NOT /api/auth/me: everything under /api/auth/ is # exempt from the gate (auth._EXEMPT_PREFIXES), so no session refresh happens there # and a probe on it would pass without testing anything. PROBE = "/api/projects" IDLE = auth.IDLE_MINUTES CEIL_H = auth.SESSION_HOURS NOW = datetime.now(timezone.utc) def mint(login_at=None, iat=None, exp=None, **extra): """A token with exactly the claims given (None = leave the claim out).""" p = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0} if iat is not None: p["iat"] = iat if login_at is not None: p["login_at"] = login_at.timestamp() if exp is not None: p["exp"] = exp p.update(extra) return jwt.encode(p, auth.SECRET_KEY, algorithm=auth.JWT_ALG) def raw_claims(tok): return jwt.decode(tok, auth.SECRET_KEY, algorithms=[auth.JWT_ALG], options={"verify_exp": False, "verify_iat": False, "verify_nbf": False}) class FakeClock(datetime): _now = NOW @classmethod def now(cls, tz=None): return cls._now real_dt = auth.datetime def at(t): FakeClock._now = t auth.datetime = FakeClock def real(): auth.datetime = real_dt print("defaults: idle %d min, ceiling %d h" % (IDLE, CEIL_H)) # ── 1. continuous activity, then the ceiling ────────────────────────────────── print("\n1. continuous activity stays alive past 30 minutes, but is cut off at the ceiling") at(NOW) tok = auth.create_token(USER) c = raw_claims(tok) chk("a new token carries login_at", "login_at" in c) chk("a new token expires one idle window out, not at the ceiling", abs(c["exp"] - (NOW + timedelta(minutes=IDLE)).timestamp()) < 2) login_at = NOW cur = c alive_past_30 = False rewrites = 0 last_exp = cur["exp"] t = NOW STEP = timedelta(minutes=1) # an active user: a request every minute end = NOW + timedelta(hours=CEIL_H + 2) cut_off_at = None while t < end: t += STEP at(t) if cur["exp"] <= t.timestamp(): # the session already lapsed cut_off_at = t break if t - NOW > timedelta(minutes=IDLE): alive_past_30 = True new = auth.maybe_refresh_token(cur) if new: rewrites += 1 cur = raw_claims(new) last_exp = cur["exp"] real() chk("with a request every minute the session is alive well past 30 minutes", alive_past_30) chk("it is never extended past the ceiling (last exp <= login + %d h)" % CEIL_H, last_exp <= (login_at + timedelta(hours=CEIL_H)).timestamp() + 1, str(datetime.fromtimestamp(last_exp, timezone.utc))) chk("it IS cut off once the ceiling is reached, however active the session", cut_off_at is not None and cut_off_at <= login_at + timedelta(hours=CEIL_H) + timedelta(minutes=IDLE) + STEP, str(cut_off_at)) chk("the claims after the last refresh still carry the ORIGINAL login_at", abs(cur["login_at"] - login_at.timestamp()) < 1) steps = int((CEIL_H * 60) / 1) chk("the cookie was rewritten far less often than once per request (%d rewrites for ~%d requests)" % (rewrites, steps), 0 < rewrites < steps / 5, f"{rewrites}/{steps}") # ── 2. idle ─────────────────────────────────────────────────────────────────── print("\n2. a session idle for more than %d minutes is refused on its next request" % IDLE) client = TestClient(appmod.app) idle_tok = mint(login_at=NOW - timedelta(minutes=IDLE + 1), iat=NOW - timedelta(minutes=IDLE + 1), exp=NOW - timedelta(minutes=1)) client.cookies.set(auth.COOKIE_NAME, idle_tok) r = client.get(PROBE) chk("an idle session gets 401", r.status_code == 401, r.status_code) live_tok = mint(login_at=NOW - timedelta(minutes=5), iat=NOW - timedelta(minutes=5), exp=NOW + timedelta(minutes=IDLE - 5)) client.cookies.clear() client.cookies.set(auth.COOKIE_NAME, live_tok) chk("a session inside the window gets 200", client.get(PROBE).status_code == 200) # ── 3. throttle ─────────────────────────────────────────────────────────────── print("\n3. the cookie is not rewritten on every request") fresh = auth.create_token(USER) client.cookies.clear() client.cookies.set(auth.COOKIE_NAME, fresh) cookies_set = 0 for _ in range(20): r = client.get(PROBE) if "set-cookie" in r.headers and auth.COOKIE_NAME in r.headers["set-cookie"]: cookies_set += 1 chk("20 rapid requests on a fresh session: 0 cookie rewrites", cookies_set == 0, cookies_set) aged = mint(login_at=NOW - timedelta(minutes=20), iat=NOW - timedelta(minutes=20), exp=NOW + timedelta(minutes=2)) # 2 minutes of idle window left client.cookies.clear() client.cookies.set(auth.COOKIE_NAME, aged) r = client.get(PROBE) chk("an aged session gets a refreshed cookie on its next request", r.status_code == 200 and auth.COOKIE_NAME in r.headers.get("set-cookie", "")) m = re.search(auth.COOKIE_NAME + r"=([^;]+)", r.headers.get("set-cookie", "")) newc = raw_claims(m.group(1)) if m else {} chk("the refreshed cookie keeps the original login_at", abs(newc.get("login_at", 0) - (NOW - timedelta(minutes=20)).timestamp()) < 1) client.cookies.clear() client.cookies.set(auth.COOKIE_NAME, m.group(1) if m else "") r2 = client.get(PROBE) chk("...and the very next request does not rewrite it again", auth.COOKIE_NAME not in r2.headers.get("set-cookie", "")) # ── 4. tokens from before D18 ───────────────────────────────────────────────── print("\n4. a token with no login_at still gets a hard ceiling (via iat)") old = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0, "iat": (NOW - timedelta(hours=CEIL_H + 1)).timestamp(), "exp": (NOW + timedelta(hours=3)).timestamp()} # the old flat 12 h exp, still valid chk("past its iat-based ceiling: no refresh, the old exp is not extended", auth.maybe_refresh_token(old) is None) young = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0, "iat": (NOW - timedelta(hours=1)).timestamp(), "exp": (NOW + timedelta(minutes=2)).timestamp()} ref = auth.maybe_refresh_token(young) rc = raw_claims(ref) if ref else {} chk("inside the ceiling: refreshed, and login_at is taken from iat (not 'now')", bool(ref) and abs(rc["login_at"] - young["iat"]) < 1) chk("the refreshed token cannot outlive iat + ceiling", bool(ref) and rc["exp"] <= young["iat"] + CEIL_H * 3600 + 1) nothing = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0, "exp": (NOW + timedelta(minutes=2)).timestamp()} chk("no login_at and no iat: no refresh, and no crash", auth.maybe_refresh_token(nothing) is None) junk = dict(young, login_at="not-a-number") chk("an unparseable login_at falls back to iat, no crash", auth.maybe_refresh_token(junk) is not None) # ── 5. identity carried forward ─────────────────────────────────────────────── print("\n5. a refresh carries the identity forward unchanged") src = {"sub": "u9", "username": "zed", "role": "project_admin", "ver": 7, "iat": (NOW - timedelta(minutes=20)).timestamp(), "login_at": (NOW - timedelta(minutes=20)).timestamp(), "exp": (NOW + timedelta(minutes=2)).timestamp()} rc = raw_claims(auth.maybe_refresh_token(src)) chk("sub, username, role, ver are unchanged", (rc["sub"], rc["username"], rc["role"], rc["ver"]) == ("u9", "zed", "project_admin", 7)) # ── 6. documentation ────────────────────────────────────────────────────────── print("\n6. the two variables are documented, defaults flagged as proposed") env = open(os.path.join(ROOT, "server", ".env.example"), encoding="utf-8").read() dep = open(os.path.join(ROOT, "DEPLOYMENT.md"), encoding="utf-8").read() for name in ("AUTH_IDLE_MINUTES", "AUTH_SESSION_HOURS"): chk(f"{name} is in .env.example", name in env) chk(f"{name} is in DEPLOYMENT.md", name in dep) chk(".env.example calls the defaults proposed, not confirmed", re.search(r"propos", env, re.I) is not None) chk("DEPLOYMENT.md calls the defaults proposed, not confirmed", re.search(r"propos", dep, re.I) is not None) print() print("ALL PASSED" if not fails else f"{fails} FAILED") sys.exit(0 if not fails else 1)