T13.6 (part): test T13.1's sliding session, and record what it found
T13.1 shipped with its done-when list unchecked and no test of its own. Adds tests/session_idle_check.py (28 checks): continuous activity survives 30 minutes but not the ceiling, an idle session gets 401, the cookie is not rewritten per request, a pre-D18 token still gets a ceiling via iat, identity carries forward, both variables are documented. Mutation-tested (no throttle, no ceiling, a fresh ceiling for legacy tokens each fail it). Notes in wave-13.md: /api/auth/* is exempt from the refresh, and the wave exit criteria say AUTH_SESSION_HOURS 2 while T13.1 and the code say 8.
This commit is contained in:
232
tests/session_idle_check.py
Normal file
232
tests/session_idle_check.py
Normal file
@@ -0,0 +1,232 @@
|
||||
#!/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
|
||||
|
||||
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)
|
||||
Reference in New Issue
Block a user