unis_manager/tests/test_rbac.py

371 lines
21 KiB
Python
Executable File
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

"""RBAC:菜单授权矩阵、多角色并集、后端总闸、自我保护、会话与审计。"""
from __future__ import annotations
from app import security
from app.db import SessionLocal
from app.models import Role, RoleMenu, User, UserRole
# ------------------------------------------------------------------ 元信息
def test_权限元信息给全前端要的三样(h):
meta = h.admin.get("/api/rbac/meta").json()
assert [m["key"] for m in meta["menus"]] == [
"board", "projects", "custom", "focus", "staff", "intake", "settings", "rbac"]
assert all(m["label"] for m in meta["menus"])
assert [lv["value"] for lv in meta["levels"]] == ["rw", "ro", ""]
assert {a["value"] for a in meta["actions"]} == {
"create", "update", "delete", "login", "logout", "password", "revoke", "deny"}
def test_内置角色与管理员账号自动就位(h):
roles = h.roles()
assert set(roles) == {"管理员", "部门成员", "只读访客"}
assert all(r["is_builtin"] for r in roles.values())
assert roles["管理员"]["menus"]["rbac"] == "rw"
# 部门成员:业务菜单可编辑,设置与权限管理一律没有
assert roles["部门成员"]["menus"]["custom"] == "rw"
assert "settings" not in roles["部门成员"]["menus"] and "rbac" not in roles["部门成员"]["menus"]
assert all(v == "ro" for k, v in roles["只读访客"]["menus"].items() if k != "rbac")
assert "rbac" not in roles["只读访客"]["menus"]
assert h.admin.get("/api/auth/me").json()["username"] == "admin"
# ------------------------------------------------------------------ 后端总闸
def test_没授权的菜单读不到也改不了(h):
c = h.user_client("only_board", menus={"board": "rw"})
assert c.get("/api/weekly").status_code == 200
for path in ("/api/projects", "/api/custom/finance", "/api/staff", "/api/focus", "/api/settings"):
assert c.get(path).status_code == 403, path
assert c.post("/api/projects", json={"name": "越权"}).status_code == 403
assert c.get("/api/rbac/users").status_code == 403 # 权限管理必须显式授权
def test_只读能看不能改(h):
c = h.user_client("readonly", menus={"custom": "ro", "projects": "ro"})
assert c.get("/api/custom/projects").status_code == 200
assert c.get("/api/projects").status_code == 200
assert c.post("/api/custom/projects", json={"name": "只读新建"}).status_code == 403
assert c.patch("/api/custom/projects/1", json={"amount": 1}).status_code == 403
assert "只读" in c.post("/api/custom/projects", json={"name": "x"}).json()["detail"]
def test_导出接口跟着对应页面的权限(h):
viewer = h.user_client("viewer", menus={"custom": "ro", "focus": "ro"})
assert viewer.get("/api/export/custom").status_code == 200
assert viewer.get("/api/export/focus").status_code == 200
assert viewer.get("/api/export/projects").status_code == 403
writer = h.user_client("writer", menus={"projects": "rw"})
assert writer.get("/api/export/projects").status_code == 200
assert writer.get("/api/export/custom").status_code == 403
def test_周期列表人人可读但只有设置页可改(h):
member = h.user_client("member_a") # 部门成员:没有 settings
assert member.get("/api/periods").status_code == 200
assert member.post("/api/periods", json={"label": "1月第1周"}).status_code == 403
assert member.get("/api/settings").status_code == 403
assert h.admin.post("/api/periods", json={"label": "1月第1周"}).status_code == 200
def test_录入页权限管住AI接口(h):
no_intake = h.user_client("no_intake", menus={"board": "rw"})
assert no_intake.post("/api/ai/parse", json={"raw_text": "干了点活"}).status_code == 403
assert no_intake.post("/api/custom/ai/parse", json={"raw_text": "干了点活"}).status_code == 403
intake = h.user_client("intake_guy", menus={"intake": "rw"})
assert intake.post("/api/ai/parse", json={"raw_text": "完成了接口"}).status_code == 200
ro_intake = h.user_client("intake_ro", menus={"intake": "ro"})
assert ro_intake.post("/api/ai/parse", json={"raw_text": "x"}).status_code == 403
def test_一个角色被清空权限后该用户什么都干不了(h):
c = h.user_client("nobody", menus={"board": "rw"})
assert c.get("/api/weekly").status_code == 200
role = h.roles()["角色-nobody"]
h.admin.patch(f"/api/rbac/roles/{role['id']}", json={"menus": {}})
assert c.get("/api/auth/me").status_code == 401 # 改授权后强制重新登录
fresh = h.login("nobody")
# 登录本身还是通的(前端要靠 /auth/me 判断并给出「请联系管理员」的提示),但业务接口全关
me = fresh.get("/api/auth/me")
assert me.status_code == 200 and me.json()["menus"] == {}
for path in ("/api/weekly", "/api/projects", "/api/custom/finance", "/api/rbac/users"):
assert fresh.get(path).status_code == 403, path
# ------------------------------------------------------------------ 多角色并集
def test_多角色取并集同一菜单取更高级别(h):
r_board_ro = h.role("只看看", {"board": "ro", "projects": "ro"})["id"]
r_board_rw = h.role("能改看板", {"board": "rw"})["id"]
r_custom = h.role("只管定制", {"custom": "rw"})["id"]
u = h.user("multi_role", role_ids=[r_board_ro, r_board_rw, r_custom])
assert sorted(u["role_ids"]) == sorted([r_board_ro, r_board_rw, r_custom])
assert set(u["role_names"]) == {"只看看", "能改看板", "只管定制"}
menus = u["menus"]
assert menus["board"] == "rw" and menus["projects"] == "ro" and menus["custom"] == "rw"
assert "staff" not in menus
c = h.login("multi_role")
assert c.get("/api/weekly").status_code == 200
assert c.post("/api/custom/projects", json={"name": "定制能写"}).status_code == 200
assert c.post("/api/projects", json={"name": "项目不能写"}).status_code == 403
assert c.get("/api/staff").status_code == 403
# ------------------------------------------------------------------ 角色管理
def test_角色增删改的基本规则(h):
r = h.role("报表岗", {"board": "ro", "custom": "ro"}, description="只看数")
assert r["menus"] == {"board": "ro", "custom": "ro"} and r["is_builtin"] is False
assert h.admin.post("/api/rbac/roles", json={"name": "报表岗"}).status_code == 400
assert h.admin.post("/api/rbac/roles", json={"name": " "}).status_code == 400
# 未知菜单 / 非法级别一律丢掉,前端传什么都不怕
r2 = h.role("脏权限", {"board": "rw", "不存在的菜单": "rw", "custom": "读写", "staff": "admin"})
assert r2["menus"] == {"board": "rw"}
up = h.admin.patch(f"/api/rbac/roles/{r['id']}",
json={"name": "报表查看", "description": "", "menus": {"board": "rw"}})
assert up.status_code == 200 and up.json()["name"] == "报表查看"
assert up.json()["description"] is None and up.json()["menus"] == {"board": "rw"}
assert h.admin.patch(f"/api/rbac/roles/{r['id']}", json={"name": " "}).status_code == 400
assert h.admin.patch("/api/rbac/roles/99999", json={"name": "x"}).status_code == 404
assert h.admin.delete(f"/api/rbac/roles/{r['id']}").json() == {"ok": True}
assert h.admin.delete("/api/rbac/roles/99999").status_code == 404
def test_角色改名不能撞已有的名字(h):
h.role("先建的", {"board": "ro"})
r2 = h.role("后建的", {"board": "ro"})
r = h.admin.patch(f"/api/rbac/roles/{r2['id']}", json={"name": "先建的"})
assert r.status_code == 400 and "已存在" in r.json()["detail"]
def test_内置角色的三道锁(h):
builtin = h.roles()["管理员"]
assert h.admin.delete(f"/api/rbac/roles/{builtin['id']}").status_code == 400
assert h.admin.patch(f"/api/rbac/roles/{builtin['id']}", json={"name": "超级管理员"}).status_code == 400
# 想把管理员的「权限管理」授权去掉?会被强行留一份,杜绝把自己锁在门外
r = h.admin.patch(f"/api/rbac/roles/{builtin['id']}", json={"menus": {"board": "rw"}})
assert r.status_code == 200
assert r.json()["menus"] == {"board": "rw", "rbac": "rw"}
# 改授权会把这个角色下的用户一并踢下线——管理员改自己的角色也不例外,得重新登录
assert h.admin.get("/api/auth/me").status_code == 401
h.admin = h.login("admin")
assert h.admin.get("/api/auth/me").json()["menus"]["board"] == "rw"
# 另外两个内置角色可以改授权,但不能删
member = h.roles()["部门成员"]
assert h.admin.delete(f"/api/rbac/roles/{member['id']}").status_code == 400
assert h.admin.patch(f"/api/rbac/roles/{member['id']}", json={"menus": {"board": "ro"}}).status_code == 200
assert h.roles()["部门成员"]["menus"] == {"board": "ro"}
# 还原内置授权,免得影响同一次运行里的其它断言
with SessionLocal() as db:
db.query(RoleMenu).filter(RoleMenu.role_id == member["id"]).delete(synchronize_session=False)
for menu, level in security.BUILTIN_ROLES[1][2].items():
db.add(RoleMenu(role_id=member["id"], menu=menu, level=level))
db.commit()
def test_正在使用的角色不能删(h):
r = h.role("临时岗", {"board": "ro"})
h.user("temp_user", role_ids=[r["id"]])
res = h.admin.delete(f"/api/rbac/roles/{r['id']}")
assert res.status_code == 400 and "还有用户" in res.json()["detail"]
# 自己正在用的角色也不能删(管理员角色就是 admin 正在用的)
assert h.admin.delete(f"/api/rbac/roles/{h.roles()['管理员']['id']}").status_code == 400
assert "内置角色" in h.admin.delete(f"/api/rbac/roles/{h.roles()['管理员']['id']}").json()["detail"]
# ------------------------------------------------------------------ 用户管理
def test_建账号的校验(h):
h.user("dup_user", menus={"board": "ro"})
assert h.admin.post("/api/rbac/users", json={"name": "重名", "username": "dup_user",
"password": "pw123456"}).status_code == 400
assert h.admin.post("/api/rbac/users", json={"name": "", "username": "no_name",
"password": "pw123456"}).status_code == 400
assert h.admin.post("/api/rbac/users", json={"name": "短密码", "username": "short_pw",
"password": "123"}).status_code == 400
assert h.admin.post("/api/rbac/users", json={"name": "没这个角色", "username": "ghost_role",
"password": "pw123456",
"role_ids": [424242]}).status_code == 400
# 不指定角色 → 默认给「部门成员」,避免建出一个进不了门的账号
d = h.user("default_role")
assert d["role_names"] == ["部门成员"]
def test_用户列表字段与在线状态(h):
h.user("online_one", menus={"board": "ro"})
h.login("online_one") # 制造一个在线会话
users = {u["username"]: u for u in h.admin.get("/api/rbac/users").json()}
u = users["online_one"]
assert u["online"] >= 1 and u["active"] is True
assert u["menus"] == {"board": "ro"} and len(u["role_ids"]) == 1
assert "password_hash" not in u and "role_id" not in u
def test_改名改权限会踢掉该账号的会话(h):
u = h.user("revoke_me", menus={"board": "rw"})
c = h.login("revoke_me")
assert c.get("/api/weekly").status_code == 200
r = h.role("换个岗位", {"custom": "rw"})
assert h.admin.patch(f"/api/rbac/users/{u['id']}", json={"role_ids": [r["id"]]}).status_code == 200
assert c.get("/api/weekly").status_code == 401 # 权限变了必须重新登录
fresh = h.login("revoke_me")
assert fresh.get("/api/weekly").status_code == 403
assert fresh.get("/api/custom/projects").status_code == 200
def test_管理员重置密码不需要旧密码但会下线对方(h):
u = h.user("reset_pw", menus={"board": "ro"})
c = h.login("reset_pw")
assert h.admin.patch(f"/api/rbac/users/{u['id']}", json={"password": "brandnew1"}).status_code == 200
assert c.get("/api/auth/me").status_code == 401
assert h.anon.post("/api/auth/login", json={"username": "reset_pw",
"password": "pw123456"}).status_code == 401
assert h.login("reset_pw", "brandnew1").get("/api/auth/me").status_code == 200
assert h.admin.patch(f"/api/rbac/users/{u['id']}", json={"password": "1"}).status_code == 400
def test_不能动自己(h):
me = h.admin.get("/api/auth/me").json()
member_role = h.roles()["部门成员"]["id"]
r1 = h.admin.patch(f"/api/rbac/users/{me['id']}", json={"role_ids": [member_role]})
assert r1.status_code == 400 and "自己的角色" in r1.json()["detail"]
r2 = h.admin.patch(f"/api/rbac/users/{me['id']}", json={"active": False})
assert r2.status_code == 400 and "停用" in r2.json()["detail"]
r3 = h.admin.delete(f"/api/rbac/users/{me['id']}")
assert r3.status_code == 400 and "删除自己" in r3.json()["detail"]
# 但改自己的昵称是允许的
assert h.admin.put("/api/auth/me", json={"name": "系统管理员"}).json()["name"] == "系统管理员"
def test_删除账号会连带清掉会话与角色关联(h):
u = h.user("drop_me", menus={"board": "ro"})
c = h.login("drop_me")
assert h.admin.delete(f"/api/rbac/users/{u['id']}").json() == {"ok": True}
assert c.get("/api/auth/me").status_code == 401
assert u["id"] not in {x["id"] for x in h.admin.get("/api/rbac/users").json()}
assert h.admin.delete("/api/rbac/users/424242").status_code == 404
def test_没人能管权限时启动补种会自动补一个管理员(db):
"""防锁死兜底:最后一个可管理账号丢了,ensure_seed 会把管理员角色补给最早的账号。"""
with SessionLocal() as s:
member = s.query(Role).filter(Role.name == "部门成员").one()
admin_role = s.query(Role).filter(Role.name == "管理员").one()
victim = s.query(User).filter(User.username == "admin").one()
s.query(UserRole).filter(UserRole.user_id == victim.id).delete()
s.add(UserRole(user_id=victim.id, role_id=member.id))
s.commit()
assert victim.menus.get("rbac") is None
notes = security.ensure_seed(s)
assert any("管理员" in n for n in notes), notes
s.expire_all()
assert s.get(User, victim.id).menus["rbac"] == "rw"
assert admin_role is not None
# ------------------------------------------------------------------ 会话
def test_会话列表能看得到并能逐个下线(h):
u = h.user("sess_one", menus={"board": "ro"})
h.login("sess_one")
sessions = h.admin.get("/api/rbac/sessions").json()
mine = [s for s in sessions if s["user_id"] == u["id"]]
assert len(mine) == 1
s = mine[0]
assert s["username"] == "sess_one" and s["token"]
# 列表只展示打码后的 token_hint,但下线要用完整 token
assert s["token"].startswith(s["token_hint"].rstrip("…")) and "…" in s["token_hint"]
assert s["expires_at"] and s["created_at"]
assert h.admin.delete(f"/api/rbac/sessions/{s['token']}").json() == {"ok": True}
assert [x for x in h.admin.get("/api/rbac/sessions").json() if x["user_id"] == u["id"]] == []
assert h.admin.delete("/api/rbac/sessions/不存在的token").status_code == 404
def test_下线自己的会话等于自己退出(h):
tokens = {s["username"]: s["token"] for s in h.admin.get("/api/rbac/sessions").json()}
assert h.admin.delete(f"/api/rbac/sessions/{tokens['admin']}").status_code == 200
assert h.admin.get("/api/auth/me").status_code == 401
# ------------------------------------------------------------------ 审计
def test_写操作与越权尝试都留痕并能筛选(h):
r = h.role("审计岗", {"board": "ro"})
u = h.user("audit_user", role_ids=[r["id"]])
# 角色下还有人 → 删不掉,这次失败的尝试同样进日志
assert h.admin.delete(f"/api/rbac/roles/{r['id']}").status_code == 400
h.admin.delete(f"/api/rbac/users/{u['id']}")
assert h.admin.delete(f"/api/rbac/roles/{r['id']}").status_code == 200
logs = h.admin.get("/api/rbac/logs", params={"menu": "rbac", "limit": 100}).json()
assert logs["total"] >= 3
actions = {x["action"] for x in logs["items"]}
assert {"create", "delete"} <= actions
details = ";".join(x["detail"] or "" for x in logs["items"])
assert "新建角色「审计岗」" in details and "删除角色「审计岗」" in details
assert all(x["username"] == "admin" for x in logs["items"])
# 被拒的那次删除也留了痕,说明里带上了状态码
denied_role = [x for x in logs["items"] if x["status"] == 400]
assert denied_role and "HTTP 400" in denied_role[0]["detail"]
# 越权尝试同样进日志:一律记 action=deny(含 GET),并带上被拒的说明
h.user("bad_try", menus={"board": "ro"})
c = h.login("bad_try")
assert c.post("/api/projects", json={"name": "越权"}).status_code == 403
assert c.get("/api/projects").status_code == 403 # 只读越权探测也要留痕
denied = h.admin.get("/api/rbac/logs",
params={"username": "bad_try", "action": "deny"}).json()
assert denied["total"] == 2
assert {x["method"] for x in denied["items"]} == {"POST", "GET"}
assert all(x["status"] == 403 and "HTTP 403" in x["detail"] for x in denied["items"])
assert {x["menu"] for x in denied["items"]} == {"projects"}
assert not h.admin.get("/api/rbac/logs",
params={"username": "bad_try", "action": "create"}).json()["items"]
# 失败的登录也按被尝试的账号记一笔
h.anon.post("/api/auth/login", json={"username": "bad_try", "password": "错的答案"})
by_action = h.admin.get("/api/rbac/logs", params={"action": "login"}).json()
assert any(x["status"] == 401 and "登录失败" in (x["detail"] or "") for x in by_action["items"])
# 筛选参数与分页:强制下线按语义记 revoke(不再被 POST→create 吞掉)
uid = [x["id"] for x in h.admin.get("/api/rbac/users").json() if x["username"] == "bad_try"][0]
assert h.admin.post(f"/api/rbac/users/{uid}/revoke", json={}).status_code == 200
revoked = h.admin.get("/api/rbac/logs", params={"action": "revoke"}).json()
assert revoked["total"] >= 1 and revoked["items"][0]["path"].endswith("/revoke")
page1 = h.admin.get("/api/rbac/logs", params={"limit": 1, "offset": 0}).json()
page2 = h.admin.get("/api/rbac/logs", params={"limit": 1, "offset": 1}).json()
assert page1["total"] == page2["total"] and page1["items"][0]["id"] != page2["items"][0]["id"]
assert h.admin.get("/api/rbac/logs", params={"days": 0}).status_code == 422
def test_ensure_seed_锁死自救(h, db):
"""「至少一人能管权限」兜底:优先补给启用账号;全员停用则复活最早账号;
重复跑不炸(查重后插入,不撞 user_roles 唯一键)。"""
from app import security
from app.models import User, UserRole
backup = h.user("seed_backup") # 启用、无 rbac 权限
admin = db.query(User).filter(User.username == "admin").one() # 接口不许自停用,直改库模拟
admin.active = False
db.commit()
notes = security.ensure_seed(db)
assert any("seed_backup" in n for n in notes), notes
# 再跑一次:seed_backup 已是 rw,不重复挂角色也不报错
assert security.ensure_seed(db) == []
# 全员停用 → 复活最早账号(admin),且不再重复插角色
db.query(User).update({User.active: False})
db.commit()
notes = security.ensure_seed(db)
assert any("重新启用" in n for n in notes), notes
db.expire_all()
assert db.get(User, admin.id).active is True
assert db.query(UserRole).filter_by(user_id=admin.id).count() >= 1
def test_清空日志(h):
h.role("要被记一笔", {"board": "ro"})
assert h.admin.get("/api/rbac/logs").json()["total"] >= 1
assert h.admin.delete("/api/rbac/logs", params={"days": 0}).json()["deleted"] >= 1
# 清空动作本身也会被记一笔,剩下的只应有一条「删除 /api/rbac/logs」
rest = h.admin.get("/api/rbac/logs").json()["items"]
assert all(x["path"] == "/api/rbac/logs" for x in rest), rest
def test_敏感写操作的说明文字可读(h):
u = h.user("note_user", menus={"board": "ro"})
h.admin.patch(f"/api/rbac/users/{u['id']}", json={"name": "改名了", "active": False})
h.admin.post(f"/api/rbac/users/{u['id']}/revoke")
items = h.admin.get("/api/rbac/logs", params={"limit": 50}).json()["items"]
joined = ";".join(x["detail"] or "" for x in items)
assert "修改账号 note_user:改名、停用" in joined
assert "强制下线 note_user" in joined