ManikandanandClaude Opus 5.5
ce9bdbd974
Sign-in: brand panel, show / hide password, Caps Lock warning, moving background, tab icon. Roles: Super Admin manages Admins and Viewers, Admin manages Viewers only (and can Start / Stop, see Sign-ins), Viewer sees claims and Runs only. create_tables.sql moves an old table. 71 test files, 1220 tests. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
320 lines
11 KiB
Python
320 lines
11 KiB
Python
"""
|
|
Portal Users, Sign-in rules and sessions — `web/users.py` (spec 2026-10-22
|
|
Stage 2, EEWA-32), against an in-memory store (no SQL Server).
|
|
|
|
python tests\\test_portal_users.py
|
|
|
|
* Passwords: hashed with their own salt, never kept in plain; 10+
|
|
characters, not the username.
|
|
* Sign-in: a wrong password and an unknown username read the same;
|
|
5 wrong in a row lock the user for 15 minutes; a disabled user cannot
|
|
sign in; every outcome is recorded.
|
|
* Admin changes: a new user must pick their own password at first
|
|
Sign-in, a reset does the same, the last active Admin cannot be
|
|
demoted or disabled, nobody disables themselves.
|
|
* Sessions: 30 minutes idle ends one; ending a user's sessions works.
|
|
"""
|
|
|
|
import sys
|
|
import pathlib
|
|
from datetime import datetime, timedelta
|
|
|
|
ROOT = pathlib.Path(__file__).resolve().parent.parent
|
|
sys.path.insert(0, str(ROOT))
|
|
sys.path.insert(0, str(ROOT / "src"))
|
|
|
|
from web import users # noqa: E402
|
|
|
|
users.ITERATIONS = 1_000 # fast tests; the real count is checked below
|
|
CASES = []
|
|
|
|
|
|
def case(fn):
|
|
CASES.append(fn)
|
|
return fn
|
|
|
|
|
|
class FakeUserStore:
|
|
"""The SqlUserStore methods, in memory."""
|
|
|
|
def __init__(self):
|
|
self.users = {}
|
|
self.events = []
|
|
|
|
def get(self, username):
|
|
u = self.users.get(username)
|
|
return dict(u) if u else None
|
|
|
|
def list(self):
|
|
return [dict(u) for _, u in sorted(self.users.items())]
|
|
|
|
def create(self, user):
|
|
self.users[user["username"]] = dict(user)
|
|
|
|
def update(self, username, **fields):
|
|
self.users[username].update(fields)
|
|
|
|
def record(self, username, event, by=""):
|
|
self.events.append((username, event, by or ""))
|
|
|
|
def history(self, limit=300):
|
|
return [{"at": datetime(2026, 10, 22, 12, 0), "username": u,
|
|
"event": e, "by_user": b or None}
|
|
for u, e, b in reversed(self.events)][:limit]
|
|
|
|
|
|
class Clock:
|
|
def __init__(self):
|
|
self.t = datetime(2026, 10, 22, 9, 0, 0)
|
|
|
|
def __call__(self):
|
|
return self.t
|
|
|
|
|
|
def _accounts():
|
|
store, clock = FakeUserStore(), Clock()
|
|
acc = users.Accounts(store, now=clock)
|
|
acc.create_user("Asha", "Asha R", "Super Admin", "first-password-1")
|
|
return acc, store, clock
|
|
|
|
|
|
@case
|
|
def the_real_iteration_count_is_at_least_600k():
|
|
import importlib
|
|
fresh = importlib.reload(users)
|
|
try:
|
|
assert fresh.ITERATIONS >= 600_000, fresh.ITERATIONS
|
|
finally:
|
|
fresh.ITERATIONS = 1_000
|
|
|
|
|
|
@case
|
|
def a_password_is_kept_only_as_a_salted_hash():
|
|
acc, store, _ = _accounts()
|
|
u = store.users["asha"]
|
|
assert "first-password-1" not in str(u), u
|
|
assert len(u["pw_hash"]) == 64 and len(u["pw_salt"]) == 32, u
|
|
a, s1, _ = users.hash_password("same-password!")
|
|
b, s2, _ = users.hash_password("same-password!")
|
|
assert a != b and s1 != s2, "each hash has its own salt"
|
|
|
|
|
|
@case
|
|
def password_rules():
|
|
assert users.password_problem("short", "x")
|
|
assert users.password_problem("asha.r.123", "asha.r.123")
|
|
assert users.password_problem("long-enough-1", "asha") is None
|
|
|
|
|
|
@case
|
|
def a_user_made_by_the_tool_signs_in_and_names_are_case_blind():
|
|
acc, store, _ = _accounts()
|
|
assert store.users["asha"]["must_change"] is False, "tool user"
|
|
user, why = acc.sign_in(" ASHA ", "first-password-1")
|
|
assert why == "ok" and user["username"] == "asha", why
|
|
assert store.events[-1] == ("asha", "sign_in", "")
|
|
|
|
|
|
@case
|
|
def wrong_password_and_unknown_user_read_the_same():
|
|
acc, store, _ = _accounts()
|
|
assert acc.sign_in("asha", "wrong-password-x") == (None, "bad")
|
|
assert acc.sign_in("nobody", "wrong-password-x") == (None, "bad")
|
|
assert [e[1] for e in store.events[-2:]] == ["wrong_password"] * 2
|
|
|
|
|
|
@case
|
|
def five_wrong_passwords_lock_for_fifteen_minutes():
|
|
acc, store, clock = _accounts()
|
|
for _ in range(4):
|
|
assert acc.sign_in("asha", "nope-nope-nope")[1] == "bad"
|
|
assert acc.sign_in("asha", "nope-nope-nope")[1] == "locked"
|
|
assert acc.sign_in("asha", "first-password-1")[1] == "locked", \
|
|
"even the right password waits"
|
|
clock.t += timedelta(minutes=15, seconds=1)
|
|
assert acc.sign_in("asha", "first-password-1")[1] == "ok"
|
|
assert store.users["asha"]["failed_count"] == 0
|
|
|
|
|
|
@case
|
|
def a_good_sign_in_clears_the_wrong_count():
|
|
acc, store, _ = _accounts()
|
|
for _ in range(4):
|
|
acc.sign_in("asha", "nope-nope-nope")
|
|
acc.sign_in("asha", "first-password-1")
|
|
for _ in range(4):
|
|
assert acc.sign_in("asha", "nope-nope-nope")[1] == "bad"
|
|
|
|
|
|
@case
|
|
def an_admin_made_user_must_change_and_a_reset_does_the_same():
|
|
acc, store, _ = _accounts()
|
|
acc.create_user("ravi", "Ravi", "Viewer", "temp-password-1", by="asha")
|
|
assert store.users["ravi"]["must_change"] is True
|
|
assert store.users["ravi"]["created_by"] == "asha"
|
|
acc.change_password("ravi", "temp-password-1", "ravis-own-pass")
|
|
assert store.users["ravi"]["must_change"] is False
|
|
acc.reset_password("ravi", "another-temp-1", by="asha")
|
|
assert store.users["ravi"]["must_change"] is True
|
|
assert ("ravi", "password_reset", "asha") in store.events
|
|
|
|
|
|
@case
|
|
def change_password_needs_the_current_one_and_a_new_one():
|
|
acc, _, _ = _accounts()
|
|
for current, new in (("wrong-current", "brand-new-pass"),
|
|
("first-password-1", "first-password-1"),
|
|
("first-password-1", "short")):
|
|
try:
|
|
acc.change_password("asha", current, new)
|
|
raise AssertionError(f"accepted {current!r} -> {new!r}")
|
|
except users.UserError:
|
|
pass
|
|
|
|
|
|
@case
|
|
def bad_new_users_are_refused():
|
|
acc, _, _ = _accounts()
|
|
for args in (("a", "A", "Viewer", "long-enough-1"),
|
|
("bad name", "B", "Viewer", "long-enough-1"),
|
|
("bob", "B", "Boss", "long-enough-1"),
|
|
("bob", "B", "Viewer", "short"),
|
|
("asha", "A", "Viewer", "long-enough-1")):
|
|
try:
|
|
acc.create_user(*args, by="asha")
|
|
raise AssertionError(f"accepted {args}")
|
|
except users.UserError:
|
|
pass
|
|
|
|
|
|
@case
|
|
def a_disabled_user_cannot_sign_in_and_is_never_deleted():
|
|
acc, store, _ = _accounts()
|
|
acc.create_user("ravi", "Ravi", "Viewer", "temp-password-1", by="asha")
|
|
acc.set_disabled("ravi", True, by="asha")
|
|
assert acc.sign_in("ravi", "temp-password-1") == (None, "disabled")
|
|
assert "ravi" in store.users
|
|
acc.set_disabled("ravi", False, by="asha")
|
|
assert acc.sign_in("ravi", "temp-password-1")[1] == "ok"
|
|
|
|
|
|
@case
|
|
def an_admin_adds_and_changes_viewers_only():
|
|
"""Operator, 2026-10-27: an Admin creates users, and users means
|
|
Viewers."""
|
|
acc, store, _ = _accounts()
|
|
acc.create_user("ravi", "Ravi", "Admin", "temp-password-1", by="asha")
|
|
acc.create_user("vee", "Vee", "Viewer", "temp-password-1", by="ravi")
|
|
acc.reset_password("vee", "temp-password-2", by="ravi")
|
|
acc.set_disabled("vee", True, by="ravi")
|
|
acc.set_disabled("vee", False, by="ravi")
|
|
acc.create_user("mani", "Mani", "Admin", "temp-password-1", by="asha")
|
|
for fn in (lambda: acc.create_user("kim", "K", "Admin", "temp-password-1",
|
|
by="ravi"),
|
|
lambda: acc.set_role("vee", "Admin", by="ravi"),
|
|
lambda: acc.set_disabled("mani", True, by="ravi"),
|
|
lambda: acc.reset_password("mani", "temp-password-3",
|
|
by="ravi"),
|
|
lambda: acc.set_role("asha", "Viewer", by="ravi"),
|
|
lambda: acc.set_disabled("asha", True, by="ravi")):
|
|
try:
|
|
fn()
|
|
raise AssertionError("an Admin went past Viewers")
|
|
except users.UserError:
|
|
pass
|
|
assert "kim" not in store.users and store.users["vee"]["role"] == "Viewer"
|
|
|
|
|
|
@case
|
|
def the_super_admin_runs_admins_and_nobody_touches_a_super_admin():
|
|
acc, store, _ = _accounts()
|
|
assert store.users["asha"]["role"] == "Super Admin"
|
|
acc.create_user("ravi", "Ravi", "Admin", "temp-password-1", by="asha")
|
|
acc.set_role("ravi", "Viewer", by="asha")
|
|
acc.set_role("ravi", "Admin", by="asha")
|
|
acc.set_disabled("ravi", True, by="asha")
|
|
assert ("ravi", "role_admin", "asha") in store.events
|
|
for fn in (lambda: acc.create_user("boss", "B", "Super Admin",
|
|
"temp-password-1", by="asha"),
|
|
lambda: acc.set_role("asha", "Viewer", by="asha"),
|
|
lambda: acc.set_disabled("asha", True, by="asha"),
|
|
lambda: acc.set_role("ravi", "Super Admin", by="asha"),
|
|
lambda: acc.create_user("bob", "B", "Viewer",
|
|
"temp-password-1", by="nobody")):
|
|
try:
|
|
fn()
|
|
raise AssertionError("allowed")
|
|
except users.UserError:
|
|
pass
|
|
assert store.users["asha"]["role"] == "Super Admin"
|
|
acc.create_user("boss", "B", "Super Admin", "temp-password-1")
|
|
assert store.users["boss"]["role"] == "Super Admin", "the PC tool may"
|
|
|
|
|
|
@case
|
|
def the_old_operator_role_is_gone():
|
|
assert users.ROLES == ("Super Admin", "Admin", "Viewer"), users.ROLES
|
|
assert users.CAN_RUN == ("Super Admin", "Admin")
|
|
acc, _, _ = _accounts()
|
|
try:
|
|
acc.create_user("olu", "Olu", "Operator", "temp-password-1")
|
|
raise AssertionError("Operator accepted")
|
|
except users.UserError:
|
|
pass
|
|
|
|
|
|
@case
|
|
def the_sql_table_allows_the_same_roles_and_moves_old_ones():
|
|
sql = (pathlib.Path(__file__).resolve().parent.parent / "tools" / "sql"
|
|
/ "create_tables.sql").read_text(encoding="utf-8")
|
|
check = "CHECK (role IN ('Super Admin', 'Admin', 'Viewer'))"
|
|
assert sql.count(check) == 2, "the new table and the old one moved"
|
|
first = sql.index("SET role = 'Super Admin' WHERE role = 'Admin'")
|
|
assert first < sql.index("SET role = 'Admin' WHERE role = 'Operator'"), "Admins move up before Operators take their place"
|
|
|
|
|
|
@case
|
|
def sessions_time_out_after_thirty_idle_minutes():
|
|
clock = Clock()
|
|
s = users.Sessions(now=clock)
|
|
tok = s.new({"username": "asha", "role": "Admin", "pw_hash": "x"})
|
|
user, _ = s.get(tok)
|
|
assert user["username"] == "asha" and "pw_hash" not in user, user
|
|
clock.t += timedelta(minutes=29)
|
|
assert s.get(tok)[0], "29 idle minutes is fine, and resets the clock"
|
|
clock.t += timedelta(minutes=30, seconds=1)
|
|
assert s.get(tok) == (None, "asha"), "timed out, says whose"
|
|
assert s.get(tok) == (None, None), "gone"
|
|
|
|
|
|
@case
|
|
def a_users_sessions_can_be_ended_and_refreshed():
|
|
s = users.Sessions()
|
|
t1 = s.new({"username": "ravi", "role": "Admin"})
|
|
t2 = s.new({"username": "asha", "role": "Admin"})
|
|
s.refresh_user({"username": "ravi", "role": "Viewer"})
|
|
assert s.get(t1)[0]["role"] == "Viewer"
|
|
s.drop_user("ravi")
|
|
assert s.get(t1) == (None, None) and s.get(t2)[0]
|
|
|
|
|
|
def main() -> int:
|
|
failures = 0
|
|
for fn in CASES:
|
|
name = fn.__name__.replace("_", " ")
|
|
try:
|
|
fn()
|
|
print(f" ok {name}")
|
|
except AssertionError as exc:
|
|
print(f" FAIL {name}: {exc}")
|
|
failures += 1
|
|
except Exception as exc:
|
|
print(f" ERROR {name}: {type(exc).__name__}: {exc}")
|
|
failures += 1
|
|
print(f"\n{len(CASES) - failures}/{len(CASES)} passed")
|
|
return 1 if failures else 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|