unis_hrms/tests/test_role_matrix.py

783 lines
41 KiB
Python
Raw Permalink 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.

"""角色 × 模块功能完整性矩阵。
覆盖 7 类内置角色(超级管理员 / HR 负责人 / 人事专员 / 招聘经理 /
薪酬福利专员 / 部门经理 / 普通员工),逐条验证:
1. 授权基线 —— 每个角色拿到的权限点集合与「角色职责边界」规格完全一致;
2. 行为一致 —— 列表读接口 / 写接口的 HTTP 结果与权限点严格对应(不多不少);
3. 菜单可见性 —— Web 与 H5 菜单按角色裁剪,看不见的模块接口也确实打不开;
4. 数据范围 —— all / dept_tree / self 三档范围真实生效;
5. 员工自助 —— 所有绑定档案的账号都能完整使用 H5,且只能看到自己的数据。
"""
from __future__ import annotations
import copy
import io
import pytest
API = "/api/v1"
ACCOUNTS = {
"admin": "admin123",
"hr": "hr123456",
"payroll": "pay123456",
"recruiter": "rec123456",
"manager": "mgr123456",
"emp00001": "emp123456",
}
RW = {"create", "delete", "read", "update"}
FULL = {"approve", "calculate", "create", "delete", "export", "pay", "read", "update"}
RO_ONLY = {"read"}
# 自助端 (H5) 基线:绑定档案的账号首先是「员工」,都必须能查工资条 / 请假 / 改资料
SELF_BASE = {
"selfservice:approval": {"read"},
"selfservice:benefit": RO_ONLY,
"selfservice:document": {"create", "read"},
"selfservice:home": RO_ONLY,
"selfservice:insurance": RO_ONLY,
"selfservice:leave": {"cancel", "create", "read"},
"selfservice:payslip": RO_ONLY,
"selfservice:profile": {"read", "update"},
"selfservice:task": {"read", "update"},
}
# 管理者额外拥有审批权(普通员工没有 —— 不得自批自己的申请)
APPROVERS = {"hr", "payroll", "recruiter", "manager"}
# ---------------------------------------------------------------- 授权规格 ----
# 业务模块(非自助)权限点。这是可执行的角色职责边界:
# 种子数据一旦被放宽或收紧,这里必须同步修改,防止无声的越权。
GRANTS: dict[str, dict[str, set[str]]] = {
"hr": {
"benefits:enrollment": {"create", "delete", "import", "read", "update"},
"benefits:item": RW,
"benefits:leave": {"approve", "create", "read", "update"},
"benefits:leavebalance": {"create", "generate", "read", "update"},
"benefits:plan": RW,
"benefits:record": {"create", "delete", "grant", "pay", "read", "update"},
"employee:adjustment": {"approve", "create", "delete", "read"},
"employee:attachment": {"create", "delete", "read"},
"employee:change": {"approve", "create", "delete", "read"},
"employee:contract": {"create", "delete", "read", "remind", "update"},
"employee:document": {"approve", "create", "delete", "read"},
"employee:employee": {"create", "delete", "export", "import", "read", "update"},
"org:department": RO_ONLY, "org:joblevel": RO_ONLY, "org:position": RO_ONLY,
"payroll:batch": FULL,
"payroll:item": RO_ONLY,
"payroll:payslip": {"publish", "read", "update"},
"payroll:period": RW,
"payroll:plan": RO_ONLY,
"payroll:report": {"export", "read"},
"payroll:standard": {"create", "delete", "import", "read", "update"},
"recruitment:application": {"create", "delete", "move", "read", "update"},
"recruitment:candidate": {"create", "delete", "pool", "read", "update"},
"recruitment:interview": {"create", "delete", "feedback", "read", "update"},
"recruitment:job": {"close", "create", "delete", "read", "update"},
"recruitment:offer": {"approve", "create", "delete", "read", "send", "update"},
"recruitment:report": RO_ONLY,
"system:announcement": {"create", "delete", "publish", "read", "update"},
"system:log": RO_ONLY,
},
"payroll": {
"benefits:enrollment": {"create", "delete", "import", "read", "update"},
"benefits:item": RW,
"benefits:leave": {"approve", "create", "read", "update"},
"benefits:leavebalance": {"create", "generate", "read", "update"},
"benefits:plan": RW,
"benefits:record": {"create", "delete", "grant", "pay", "read", "update"},
"employee:adjustment": {"approve", "create", "delete", "read"},
"employee:employee": RO_ONLY,
"org:department": RO_ONLY, "org:joblevel": RO_ONLY, "org:position": RO_ONLY,
"payroll:batch": FULL, "payroll:item": RW,
"payroll:payslip": {"publish", "read", "update"},
"payroll:period": RW, "payroll:plan": RW,
"payroll:report": {"export", "read"},
"payroll:standard": {"create", "delete", "import", "read", "update"},
},
"recruiter": {
"benefits:leave": RO_ONLY,
"employee:employee": RO_ONLY,
"org:department": RO_ONLY, "org:joblevel": RO_ONLY, "org:position": RO_ONLY,
"recruitment:application": {"create", "delete", "move", "read", "update"},
"recruitment:candidate": {"create", "delete", "pool", "read", "update"},
"recruitment:interview": {"create", "delete", "feedback", "read", "update"},
"recruitment:job": {"close", "create", "delete", "read", "update"},
"recruitment:offer": {"approve", "create", "delete", "read", "send", "update"},
"recruitment:report": RO_ONLY,
},
"manager": {
"benefits:leave": RO_ONLY,
"employee:change": RO_ONLY,
"employee:employee": RO_ONLY,
"org:department": RO_ONLY, "org:joblevel": RO_ONLY, "org:position": RO_ONLY,
"payroll:report": RO_ONLY,
"recruitment:application": RO_ONLY, "recruitment:candidate": RO_ONLY,
"recruitment:interview": RO_ONLY, "recruitment:job": RO_ONLY,
},
# 普通员工没有后台业务模块权限,只能用自助端
"emp00001": {},
}
# 人事专员:档案/合同/异动执行 + 招聘执行,无薪资、无系统管理
HR_SPECIALIST_GRANTS = {
"benefits:enrollment": RO_ONLY,
"benefits:leave": {"approve", "create", "read", "update"},
"employee:attachment": {"create", "delete", "read"},
"employee:change": {"approve", "create", "delete", "read"},
"employee:contract": {"create", "delete", "read", "remind", "update"},
"employee:document": {"approve", "create", "delete", "read"},
"employee:employee": {"create", "delete", "export", "import", "read", "update"},
"org:department": RO_ONLY, "org:joblevel": RO_ONLY, "org:position": RO_ONLY,
"recruitment:application": {"create", "delete", "move", "read", "update"},
"recruitment:candidate": {"create", "delete", "pool", "read", "update"},
"recruitment:interview": {"create", "delete", "feedback", "read", "update"},
"recruitment:job": {"close", "create", "delete", "read", "update"},
"recruitment:offer": RO_ONLY,
"recruitment:report": RO_ONLY,
"system:dict": RW,
}
def expected_grants(account: str) -> dict[str, set[str]]:
"""某角色应有的完整权限点(业务模块 + 自助基线)。"""
table = copy.deepcopy(GRANTS[account])
self_grants = copy.deepcopy(SELF_BASE)
if account in APPROVERS:
self_grants["selfservice:approval"] = {"approve", "read"}
table.update(self_grants)
return table
# ------------------------------------------------------- 模块 × 权限点映射 ----
# (REST 路径, 权限前缀):读接口一律要求 `<前缀>:read`,写接口要求 `<前缀>:create`。
MODULES: list[tuple[str, str]] = [
("/employees", "employee:employee"),
("/employee-contracts", "employee:contract"),
("/employee-changes", "employee:change"),
("/employee-documents", "employee:document"),
("/salary-adjustments", "employee:adjustment"),
("/org/departments", "org:department"),
("/org/positions", "org:position"),
("/org/job-levels", "org:joblevel"),
("/recruitment/jobs", "recruitment:job"),
("/recruitment/candidates", "recruitment:candidate"),
("/recruitment/applications", "recruitment:application"),
("/recruitment/interviews", "recruitment:interview"),
("/recruitment/offers", "recruitment:offer"),
("/payroll/items", "payroll:item"),
("/payroll/plans", "payroll:plan"),
("/payroll/standards", "payroll:standard"),
("/payroll/periods", "payroll:period"),
("/payroll/batches", "payroll:batch"),
("/payroll/payslips", "payroll:payslip"),
("/benefits/insurance-plans", "benefits:plan"),
("/benefits/enrollments", "benefits:enrollment"),
("/benefits/items", "benefits:item"),
("/benefits/records", "benefits:record"),
("/benefits/leave-types", "benefits:leave"),
("/benefits/leave-balances", "benefits:leavebalance"),
("/benefits/leave-requests", "benefits:leave"),
("/system/users", "system:user"),
("/system/roles", "system:role"),
("/system/menus", "system:menu"),
("/system/dict-types", "system:dict"),
("/system/announcements", "system:announcement"),
("/system/logs", "system:log"),
]
SELF_READS = ["/self/home", "/self/profile", "/self/payslips", "/self/salary-standard",
"/self/insurance", "/self/benefits", "/self/leave", "/self/documents",
"/self/approvals", "/self/tasks", "/self/notifications", "/self/announcements"]
def _grants(perms: set[str]) -> dict[str, set[str]]:
out: dict[str, set[str]] = {}
for code in perms:
if code == "*:*:*":
continue
module, resource, action = code.split(":")
out.setdefault(f"{module}:{resource}", set()).add(action)
return out
def _login(login, account: str) -> dict[str, str]:
return login(account, ACCOUNTS[account])
def _paths(nodes: list[dict]) -> set[str]:
found: set[str] = set()
for node in nodes:
if node.get("path"):
found.add(node["path"])
found |= _paths(node.get("children") or [])
return found
def test_role_grants_match_the_responsibility_matrix(client, login):
"""授权基线:每个角色的权限点集合必须与规格逐字相等(既不多也给少不了)。"""
for account, password in ACCOUNTS.items():
headers = login(account, password)
me = client.get(f"{API}/auth/me", headers=headers).json()
perms = set(me["permissions"])
if me["user"].get("is_superuser"):
assert "*:*:*" in perms, "超级管理员必须持有通配权限"
continue
assert _grants(perms) == expected_grants(account), (
f"角色 {me['roles']} 的授权基线发生变化:\n"
f" 多出: {_grants(perms).items() ^ expected_grants(account).items()}")
def test_list_reads_are_enforced_exactly_per_permission(client, login, specialist):
"""32 个业务模块 × 7 类角色:有 `:read` 才给 200,否则必须 403。"""
for account, headers in [(a, _login(login, a)) for a in ACCOUNTS] + [("hr_specialist", specialist)]:
me = client.get(f"{API}/auth/me", headers=headers).json()
perms = set(me["permissions"])
wildcard = "*:*:*" in perms
for path, prefix in MODULES:
allowed = wildcard or f"{prefix}:read" in perms
resp = client.get(f"{API}{path}", headers=headers, params={"page_size": 5})
want = 200 if allowed else 403
assert resp.status_code == want, (
f"{account} GET {path} -> {resp.status_code},按 {prefix}:read "
f"{'应放行' if allowed else '应拒绝'}")
if allowed:
body = resp.json()
assert isinstance(body, dict) and "items" in body, f"{path} 缺少分页信封"
def test_module_reads_never_leak_outside_data_scope(client, login, admin):
"""同一份「越权读」在三种数据范围下的表现:all 全量 / dept_tree 子树 / self 仅自己。"""
everybody = client.get(f"{API}/employees", headers=admin,
params={"page_size": 500}).json()
assert everybody["total"] > 0
manager_me = client.get(f"{API}/auth/me", headers=_login(login, "manager")).json()
mine = client.get(f"{API}/employees", headers=_login(login, "manager"),
params={"page_size": 500}).json()
assert 0 < mine["total"] < everybody["total"], "dept_tree 应小于全量"
assert {e["department_id"] for e in mine["items"]} <= _subtree_ids(
client.get(f"{API}/org/departments/tree", headers=admin).json(),
manager_me["employee"]["department_id"])
# 部门经理自己的档案一定在可见范围内,兄弟部门一定不在
assert any(e["id"] == manager_me["employee"]["id"] for e in mine["items"])
outside = next(d["id"] for d in client.get(f"{API}/org/departments/options", headers=admin,
params={"limit": 500}).json()
if d["id"] not in {e["department_id"] for e in mine["items"]})
assert client.get(f"{API}/employees", headers=_login(login, "manager"),
params={"department_id": outside}).json()["total"] == 0
def _subtree_ids(nodes: list[dict], root: int) -> set[int]:
for node in nodes:
if node["id"] == root:
collected = {root}
stack = list(node.get("children") or [])
while stack:
cur = stack.pop()
collected.add(cur["id"])
stack.extend(cur.get("children") or [])
return collected
deeper = _subtree_ids(node.get("children") or [], root)
if deeper:
return deeper
return set()
# ---------------------------------------------------- 单条记录的数据范围校验 --
# 列表接口由框架统一套用数据范围,但「按 id 打详情 / 打动作」的自定义端点
# 必须自己校验,否则部门经理凭一个 id 就能拿到全公司员工的身份证、合同、
# 调薪与家庭成员 —— 这在权限点层面看起来完全合法(他确实有 employee:read)。
def _visible_ids(client, headers) -> set[int]:
return {e["id"] for e in client.get(f"{API}/employees", headers=headers,
params={"page_size": 500}).json()["items"]}
def _xlsx_rows(content: bytes) -> list[tuple]:
from openpyxl import load_workbook
sheet = load_workbook(io.BytesIO(content)).active
return [tuple(c.value for c in row) for row in sheet.iter_rows(min_row=2)]
@pytest.mark.parametrize("account", ["manager", "recruiter"])
def test_single_employee_records_respect_data_scope(client, login, admin, account):
"""有模块读权限 != 能按 id 取任意员工:档案、异动、转正、离职一律受数据范围约束。"""
headers = _login(login, account)
visible, everyone = _visible_ids(client, headers), _visible_ids(client, admin)
assert 0 < len(visible) < len(everyone), f"{account} 的数据范围应当是部门子树"
outsider, insider = sorted(everyone - visible)[0], sorted(visible)[0]
assert client.get(f"{API}/employees/{outsider}", headers=headers).status_code == 403
leak = client.get(f"{API}/employees/{outsider}/dossier", headers=headers)
assert leak.status_code == 403 and leak.json()["code"] == "forbidden", leak.text
dossier = client.get(f"{API}/employees/{insider}/dossier", headers=headers)
assert dossier.status_code == 200, dossier.text
assert dossier.json()["employee"]["id"] == insider
for action, body in (("transfer", {"reason": "越权测试"}),
("regular", {"reason": "越权测试"}),
("resign", {"leave_reason": "越权测试"})):
resp = client.post(f"{API}/employees/{outsider}/{action}", headers=headers, json=body)
assert resp.status_code == 403, (action, resp.status_code, resp.text)
assert resp.json()["code"] == "forbidden"
def test_custom_list_and_file_endpoints_respect_data_scope(client, admin, specialist):
"""花名册导出、到期合同、信息变更申请、假期额度、请假单、档案附件都要按范围裁剪。"""
visible = _visible_ids(client, specialist)
outside = sorted(_visible_ids(client, admin) - visible)
assert outside, "专员的数据范围必须小于全公司,否则该用例无法验证边界"
outsider = outside[0]
for path in ("/employee-profile-requests", "/benefits/leave-requests", "/benefits/enrollments"):
resp = client.get(f"{API}{path}", headers=specialist, params={"page_size": 200})
body = resp.json()
assert "items" in body, (path, resp.status_code, resp.text[:300])
assert body["items"], path
assert {i["employee_id"] for i in body["items"]} <= visible, path
mine = client.get(f"{API}/employee-contracts/expiring", headers=specialist,
params={"days": 365}).json()
full = client.get(f"{API}/employee-contracts/expiring", headers=admin,
params={"days": 365}).json()
assert full, "演示数据应当有临近到期的合同"
assert {c["employee_id"] for c in mine} <= visible
assert len(mine) < len(full), "到期合同提醒必须按数据范围裁剪"
rows = _xlsx_rows(client.get(f"{API}/employees/export", headers=specialist).content)
everyone = _xlsx_rows(client.get(f"{API}/employees/export", headers=admin).content)
assert 0 < len(rows) < len(everyone), "花名册导出必须与数据范围一致"
upload = client.post(f"{API}/common/upload", headers=admin,
files={"file": ("越权附件.txt", b"range-check", "text/plain")},
data={"employee_id": str(outsider), "biz_type": "id_card"})
assert upload.status_code == 200, upload.text
file_id = upload.json()["id"]
try:
denied = client.get(f"{API}/common/files/{file_id}", headers=specialist)
assert denied.status_code == 403 and denied.json()["code"] == "forbidden", denied.text
assert client.delete(f"{API}/common/files/{file_id}", headers=specialist).status_code == 403
assert file_id not in {f["id"] for f in client.get(f"{API}/common/files",
headers=specialist).json()}
assert client.get(f"{API}/common/files/{file_id}", headers=admin).status_code == 200
finally:
assert client.delete(f"{API}/common/files/{file_id}", headers=admin).status_code == 200
def test_salary_report_and_approval_follow_data_scope(client, login, admin, hr, manager):
"""薪资报表与人事异动审批同样受数据范围约束:部门经理只看得到自己那条线。"""
visible = _visible_ids(client, manager)
outside = sorted(_visible_ids(client, admin) - visible)
assert outside, "部门经理的数据范围必须小于全公司"
outsider = outside[0]
slips = client.get(f"{API}/payroll/payslips", headers=admin, params={"page_size": 200}).json()["items"]
assert slips, "演示数据应有工资条,否则该用例无法验证报表口径"
period = max({(s["year"], s["month"]) for s in slips},
key=lambda ym: sum(1 for s in slips if (s["year"], s["month"]) == ym))
mine = client.get(f"{API}/payroll/payslips/summary", headers=manager,
params={"year": period[0], "month": period[1]}).json()
full = client.get(f"{API}/payroll/payslips/summary", headers=hr,
params={"year": period[0], "month": period[1]}).json()
assert 0 < mine["headcount"] < full["headcount"], "薪资报表必须按数据范围汇总"
assert mine["headcount"] <= len(visible)
created = client.post(f"{API}/employees/{outsider}/transfer", headers=admin,
json={"reason": "越权审批探针"}).json()
change_id = created["id"]
try:
denied = client.post(f"{API}/employee-changes/{change_id}/approve", headers=manager,
json={"status": "approved"})
assert denied.status_code == 403 and denied.json()["code"] == "forbidden", denied.text
kept = client.get(f"{API}/employee-changes/{change_id}", headers=admin).json()
assert kept["status"] == "pending", "越权审批不得改动申请状态"
finally:
assert client.delete(f"{API}/employee-changes/{change_id}", headers=admin).status_code == 200
# 前端路由 -> 权限前缀:菜单可见性必须与接口可达性一致,
# 否则角色会在菜单里点进一个必然报错的页面。
# 唯一例外是 /dashboard(perm_code 为空,全员可见):它对管理者渲染管理看板,
# 对数据范围 self 的普通员工渲染个人自助工作台,两条路径都有真实数据。
MENU_TO_PERM = {
"/employees": "employee:employee",
"/employees/contracts": "employee:contract",
"/employees/changes": "employee:change",
"/employees/documents": "employee:document",
"/recruitment/jobs": "recruitment:job",
"/recruitment/pipeline": "recruitment:job",
"/recruitment/candidates": "recruitment:candidate",
"/recruitment/interviews": "recruitment:interview",
"/recruitment/offers": "recruitment:offer",
"/recruitment/analytics": "recruitment:report",
"/payroll/batches": "payroll:batch",
"/payroll/payslips": "payroll:payslip",
"/payroll/plans": "payroll:plan",
"/payroll/standards": "payroll:standard",
"/payroll/items": "payroll:item",
"/payroll/reports": "payroll:report",
"/benefits/enrollments": "benefits:enrollment",
"/benefits/plans": "benefits:plan",
"/benefits/items": "benefits:item",
"/benefits/records": "benefits:record",
"/benefits/leaves": "benefits:leave",
"/org/departments": "org:department",
"/org/positions": "org:position",
"/org/job-levels": "org:joblevel",
"/system/users": "system:user",
"/system/roles": "system:role",
"/system/dicts": "system:dict",
"/system/announcements": "system:announcement",
"/system/logs": "system:log",
"/system/maintenance": "system:maintenance",
}
WEB_MENUS = {
"admin": set(MENU_TO_PERM) | {"/dashboard"},
"hr": (set(MENU_TO_PERM) | {"/dashboard"})
- {"/system/users", "/system/roles", "/system/dicts", "/system/maintenance"},
"payroll": {"/dashboard", "/employees", "/payroll/batches", "/payroll/payslips", "/payroll/plans",
"/payroll/standards", "/payroll/items", "/payroll/reports",
"/benefits/enrollments", "/benefits/plans", "/benefits/items",
"/benefits/records", "/benefits/leaves", "/org/departments",
"/org/positions", "/org/job-levels"},
"recruiter": {"/dashboard", "/employees", "/recruitment/jobs", "/recruitment/pipeline",
"/recruitment/candidates", "/recruitment/interviews", "/recruitment/offers",
"/recruitment/analytics", "/benefits/leaves", "/org/departments",
"/org/positions", "/org/job-levels"},
"manager": {"/dashboard", "/employees", "/employees/changes", "/recruitment/jobs",
"/recruitment/pipeline", "/recruitment/candidates", "/recruitment/interviews",
"/payroll/reports", "/benefits/leaves", "/org/departments",
"/org/positions", "/org/job-levels"},
"emp00001": {"/dashboard", "/self/leave", "/self/payslips", "/self/benefits", "/self/profile"},
}
H5_TILES = {"/m", "/m/leave", "/m/payslips", "/m/benefits", "/m/profile"}
def test_menus_agree_with_api_access(client, login, admin, specialist):
"""菜单不是装饰:能看到 = 接口一定打得开;看不到 = 接口一定被拒绝。"""
for account, want in WEB_MENUS.items():
headers = _login(login, account)
got = _paths(client.get(f"{API}/auth/menus", headers=headers,
params={"platform": "web"}).json())
assert got == want, f"{account} Web 菜单不符:多 {got - want} / 少 {want - got}"
perms = set(client.get(f"{API}/auth/me", headers=headers).json()["permissions"])
wildcard = "*:*:*" in perms
for path in got & set(MENU_TO_PERM):
assert f"{MENU_TO_PERM[path]}:read" in perms or wildcard, f"{account} 菜单 {path} 无读权限"
for path in set(MENU_TO_PERM) - got:
assert not (wildcard or f"{MENU_TO_PERM[path]}:read" in perms), f"{account} 无菜单 {path} 却有读权限"
# H5 面向全体在册员工(含管理者与专员账号 —— 他们自己也要请假、查工资条)
for account in ACCOUNTS:
got = _paths(client.get(f"{API}/auth/menus", headers=_login(login, account),
params={"platform": "mobile"}).json())
assert got == H5_TILES, f"{account} H5 菜单不符:{got}"
spec = _paths(client.get(f"{API}/auth/menus", headers=specialist,
params={"platform": "mobile"}).json())
assert spec == H5_TILES
def test_employee_web_and_h5_menu_names_match(client, login):
"""普通员工 PC 自助导航与 H5 必须同名、同序、同权限。"""
headers = _login(login, "emp00001")
web = client.get(f"{API}/auth/menus", headers=headers, params={"platform": "web"}).json()
mobile = client.get(f"{API}/auth/menus", headers=headers, params={"platform": "mobile"}).json()
assert [node["name"] for node in web] == ["首页", "请假", "工资", "福利", "我的"]
assert [node["name"] for node in web] == [node["name"] for node in mobile]
assert [node["perm_code"] for node in web] == [node["perm_code"] for node in mobile]
assert [node["path"] for node in web] == [
"/dashboard", "/self/leave", "/self/payslips", "/self/benefits", "/self/profile",
]
def test_self_service_surface_available_to_every_bound_account(client, login):
"""自助端:所有绑定档案的账号 12 个只读接口全绿,且看不到别人的数据。"""
for account in ACCOUNTS:
if account == "admin":
continue
headers = _login(login, account)
emp_id = client.get(f"{API}/auth/me", headers=headers).json()["employee"]["id"]
for path in SELF_READS:
resp = client.get(f"{API}{path}", headers=headers)
assert resp.status_code == 200, f"{account} {path} -> {resp.status_code} {resp.text[:160]}"
payslips = client.get(f"{API}/self/payslips", headers=headers,
params={"page_size": 100}).json()["items"]
# 自助接口刻意不回传 employee_id(隐私),出现该字段时也必须是自己
assert all(row.get("employee_id", emp_id) == emp_id for row in payslips), \
f"{account} 自助工资条越界"
assert client.get(f"{API}/self/leave", headers=headers,
params={"page_size": 100}).json()["items"] or True
# 超级管理员没有员工档案 —— 自助端必须显式提示,而不是 500 或空页面
blocked = client.get(f"{API}/self/home", headers=_login(login, "admin"))
assert blocked.status_code == 403 and blocked.json()["code"] == "no_profile"
def test_only_approvers_may_approve_self_service_requests(client, login):
"""普通员工不得自批;管理/HR/薪酬/招聘角色具备审批动作。"""
for account in ACCOUNTS:
perms = set(client.get(f"{API}/auth/me", headers=_login(login, account))
.json()["permissions"])
if account == "admin":
continue
assert ("selfservice:approval:approve" in perms) == (account in APPROVERS), account
def _approval_offers(client, headers, status="pending"):
"""审批中心某状态下的 Offer id 集合 + 后端给出的 Offer 待审批计数。"""
body = client.get(f"{API}/self/approvals", headers=headers,
params={"status": status, "limit": 200}).json()
return ({i["id"] for i in body["items"] if i["type"] == "offer"}, body.get("counts", {}).get("offer"))
def test_approval_center_scopes_offers_by_access_level(client, login, admin, manager):
"""Offer 携带候选人薪资:普通员工一律不可见,部门经理只看自己那条线。"""
recruiter, emp = _login(login, "recruiter"), _login(login, "emp00001")
visible = _visible_ids(client, manager)
outsider_id = sorted(_visible_ids(client, admin) - visible)[0]
outsider_dept = client.get(f"{API}/employees/{outsider_id}", headers=admin).json()["department_id"]
insider_dept = next(e["department_id"] for e in
client.get(f"{API}/employees", headers=manager,
params={"page_size": 500}).json()["items"]
if e.get("department_id") and e["department_id"] != outsider_dept)
jobs = client.get(f"{API}/recruitment/jobs", headers=recruiter,
params={"page_size": 100, "status": "open"}).json()["items"]
assert jobs, "演示数据应当有在招职位"
probes: dict[str, int] = {}
trail: list[tuple[str, int]] = []
try:
for tag, dept in (("in", insider_dept), ("out", outsider_dept)):
cand = client.post(f"{API}/recruitment/candidates", headers=recruiter, json={
"name": f"审批中心探针-{tag}", "gender": "男",
"phone": f"1390000{7301 + len(trail)}"}).json()
trail.append(("candidate", cand["id"]))
appl = client.post(f"{API}/recruitment/applications", headers=recruiter, json={
"candidate_id": cand["id"], "job_id": jobs[0]["id"], "stage": "resume"}).json()
trail.append(("application", appl["id"]))
offer = client.post(f"{API}/recruitment/offers", headers=recruiter, json={
"application_id": appl["id"], "candidate_id": cand["id"], "job_id": jobs[0]["id"],
"department_id": dept, "monthly_salary": 43210, "status": "pending"}).json()
assert offer.get("id"), offer
trail.append(("offer", offer["id"]))
probes[tag] = offer["id"]
# 1) 没有审批权、也没有招聘权的普通员工:任何状态下都看不到 Offer
for status in ("pending", "approved", "rejected"):
assert _approval_offers(client, emp, status)[0] == set(), f"员工在 {status} 页看到了 Offer"
# 2) 招聘角色持有 recruitment:offer:read —— 与招聘模块本身一致,全量可见
assert {probes["in"], probes["out"]} <= _approval_offers(client, recruiter)[0]
# 3) 超管全量可见
assert {probes["in"], probes["out"]} <= _approval_offers(client, admin)[0]
# 4) 部门经理只有审批权 —— 只覆盖自己部门子树内的招聘需求
mine, mine_count = _approval_offers(client, manager)
assert probes["in"] in mine and probes["out"] not in mine
assert mine_count == len(mine), "待审批计数必须与列表同口径"
# 5) 范围外的 Offer 审批动作被拒,且不得改动状态
denied = client.post(f"{API}/self/approvals/offer/{probes['out']}/decide",
headers=manager, json={"status": "approved"})
assert denied.status_code == 403 and denied.json()["code"] == "forbidden", denied.text
kept = client.get(f"{API}/recruitment/offers/{probes['out']}", headers=admin).json()
assert kept["status"] == "pending", "越权审批不得改动 Offer 状态"
# 6) 范围内的 Offer 可以正常审批
passed = client.post(f"{API}/self/approvals/offer/{probes['in']}/decide",
headers=manager, json={"status": "approved", "comment": "同意录用"})
assert passed.status_code == 200, passed.text
assert passed.json()["status"] == "approved"
finally:
for kind, item_id in reversed(trail):
client.delete(f"{API}/recruitment/{kind}s/{item_id}", headers=admin)
after, _ = _approval_offers(client, admin)
assert not (set(probes.values()) & after), "探针数据未清理干净"
def test_write_endpoints_are_gated_by_permission(client, login, specialist):
"""写接口:无 `:create` 一律 403;有权限时才进入参数校验(不产生脏数据)。"""
for account, headers in [(a, _login(login, a)) for a in ACCOUNTS] + [("hr_specialist", specialist)]:
perms = set(client.get(f"{API}/auth/me", headers=headers).json()["permissions"])
wildcard = "*:*:*" in perms
for path, prefix in MODULES:
if prefix not in _ALL_ACTIONS: # 该资源没有新增路由(只读 / 动作型)
continue
allowed = wildcard or f"{prefix}:create" in perms
resp = client.post(f"{API}{path}", headers=headers, json={})
if allowed:
assert resp.status_code in (400, 422), (
f"{account} POST {path} -> {resp.status_code},应被参数校验拦住")
else:
assert resp.status_code == 403, (
f"{account} POST {path} -> {resp.status_code},无 {prefix}:create 应拒绝")
_ALL_ACTIONS = {
"employee:employee", "employee:contract", "employee:change", "employee:document",
"employee:adjustment", "org:department", "org:position", "org:joblevel",
"recruitment:job", "recruitment:candidate", "recruitment:application",
"recruitment:interview", "recruitment:offer", "payroll:item", "payroll:plan",
"payroll:standard", "payroll:period", "payroll:batch", "payroll:payslip",
"benefits:plan", "benefits:enrollment", "benefits:item", "benefits:record",
"benefits:leave", "benefits:leavebalance", "system:user", "system:role",
"system:dict", "system:announcement",
}
def _scoped_employee(client, admin) -> dict:
"""挑一名「部门子树严格小于全公司、且人数最多」的员工绑定专员账号。
直接取花名册第一条会随其他用例的造数漂移(可能落到根部门上,
那样 dept_tree 就等于全公司,数据范围的断言会失去意义)。
"""
tree = client.get(f"{API}/org/departments/tree", headers=admin).json()
options = client.get(f"{API}/org/departments/options", headers=admin,
params={"limit": 500}).json()
everyone = client.get(f"{API}/employees", headers=admin, params={"page_size": 500}).json()["items"]
all_ids = {d["id"] for d in options}
best: tuple[tuple[int, int], list[dict]] | None = None
for node in options:
sub = _subtree_ids(tree, node["id"])
members = [e for e in everyone if e["department_id"] in sub]
if not sub or sub >= all_ids or not members or len(members) >= len(everyone):
continue
key = (len(members), -int(node["id"]))
if best is None or key > best[0]:
best = (key, members)
assert best, "演示数据应当存在多个部门分支,否则无法验证数据范围"
return sorted(best[1], key=lambda e: e["id"])[0]
@pytest.fixture(scope="session")
def specialist(client, admin, login):
"""人事专员没有种子账号 —— 用它验证「建号 -> 授角色 -> 登录 -> 能力边界」闭环。"""
roles = client.get(f"{API}/system/roles", headers=admin, params={"page_size": 100}).json()["items"]
role = next(r for r in roles if r["code"] == "hr_specialist")
employee = _scoped_employee(client, admin)
created = client.post(f"{API}/system/users", headers=admin, json={
"username": "spec_matrix", "password": "Spec#Matrix2031", "name": "矩阵人事专员",
"employee_id": employee["id"], "role_ids": [role["id"]]})
assert created.status_code == 200, created.text
assert created.json()["role_ids"] == [role["id"]], "建号时勾选的角色必须立即生效"
user_id = created.json()["id"]
headers = login("spec_matrix", "Spec#Matrix2031")
yield headers
assert client.delete(f"{API}/system/users/{user_id}", headers=admin).status_code == 200
def test_hr_specialist_is_provisionable_and_bounded(client, admin, login, specialist):
"""第 7 类角色:可被自助开通,权限=规格,数据范围=本部门子树,停用后立即失效。"""
me = client.get(f"{API}/auth/me", headers=specialist).json()
assert me["roles"] == ["hr_specialist"] and me["data_scope"] == "dept_tree"
assert me["is_staff"] is True and me["employee"]
want = copy.deepcopy(HR_SPECIALIST_GRANTS)
want.update({k: ({"approve", "read"} if k == "selfservice:approval" else set(v))
for k, v in SELF_BASE.items()})
assert _grants(set(me["permissions"])) == want
# 档案/合同/异动可写,薪资与系统管理完全隔离
assert client.post(f"{API}/employees", headers=specialist, json={}).status_code in (400, 422)
for path in ("/system/users", "/payroll/batches", "/payroll/standards", "/system/logs"):
assert client.get(f"{API}{path}", headers=specialist).status_code == 403, path
# dept_tree:只能看到自己所在部门及下级
tree = client.get(f"{API}/org/departments/tree", headers=admin).json()
visible = client.get(f"{API}/employees", headers=specialist, params={"page_size": 500}).json()
allowed = _subtree_ids(tree, me["employee"]["department_id"])
assert visible["items"] and {e["department_id"] for e in visible["items"]} <= allowed
# H5 完整可用
assert all(client.get(f"{API}{path}", headers=specialist).status_code == 200 for path in SELF_READS)
# 停用账号后 token 立即失效
assert client.patch(f"{API}/system/users/{me['user']['id']}", headers=admin,
json={"is_active": False}).status_code == 200
assert client.get(f"{API}/auth/me", headers=specialist).status_code in (401, 403)
client.patch(f"{API}/system/users/{me['user']['id']}", headers=admin, json={"is_active": True})
def test_every_role_can_open_its_own_landing_data(client, login):
"""首屏不许开天窗:管理者拿到工作台卡片,普通员工拿到个人自助工作台。"""
for account in ACCOUNTS:
headers = _login(login, account)
overview = client.get(f"{API}/dashboard/overview", headers=headers)
if account == "emp00001":
# 数据范围 self 的员工打开管理看板必然 403,
# 前端据此改渲染 /self/home —— 那里必须有真实的个人数据。
assert overview.status_code == 403, "普通员工不应打开管理看板"
home = client.get(f"{API}/self/home", headers=headers)
assert home.status_code == 200, home.text
payload = home.json()
assert {"employee", "leave_balances", "todos", "contract", "unread_notifications"} \
<= set(payload)
assert payload["employee"]["name"] and payload["employee"]["work_no"]
assert payload["leave_balances"] and {"name", "remaining", "unit"} <= set(
payload["leave_balances"][0])
assert any(payload["todos"].values()), "首屏待办应至少有一项"
continue
assert overview.status_code == 200, f"{account} 工作台 -> {overview.status_code}"
cards = overview.json()["cards"]
assert cards and all({"key", "label", "value"} <= set(card) for card in cards)
keys = {card["key"] for card in cards}
if account in ("payroll", "hr", "admin"):
assert "payroll" in keys
if account in ("recruiter",):
assert "recruiting" in keys
def test_role_core_workflow_entrypoints(client, login, admin, hr):
"""各角色最核心的那条业务动作必须真的能落库。"""
rec, pay = _login(login, "recruiter"), _login(login, "payroll")
mgr, emp = _login(login, "manager"), _login(login, "emp00001")
# 招聘经理:建职位 -> 收录候选人 -> 投递 -> 推进阶段
job = client.post(f"{API}/recruitment/jobs", headers=rec, json={
"title": "矩阵测试工程师", "department_id": _any_department(client, admin),
"headcount": 1, "status": "open"})
assert job.status_code == 200, job.text
cand = client.post(f"{API}/recruitment/candidates", headers=rec, json={
"name": "矩阵候选人", "phone": "13900008888", "channel": "内部推荐"})
assert cand.status_code == 200, cand.text
app = client.post(f"{API}/recruitment/applications", headers=rec, json={
"candidate_id": cand.json()["id"], "job_id": job.json()["id"]})
assert app.status_code == 200, app.text
moved = client.post(f"{API}/recruitment/applications/{app.json()['id']}/move",
headers=rec, json={"stage": "screen"})
assert moved.status_code == 200, moved.text
assert client.get(f"{API}/recruitment/board", headers=rec).status_code == 200
# 越界:招聘角色碰不到薪资
assert client.get(f"{API}/payroll/batches", headers=rec).status_code == 403
# 薪酬专员:能维护薪资项目,但改不了组织架构
item = client.post(f"{API}/payroll/items", headers=pay, json={
"name": "矩阵津贴", "code": "matrix_allowance", "category": "allowance",
"formula": "fixed", "is_taxable": True})
assert item.status_code == 200, item.text
assert client.get(f"{API}/payroll/reports", headers=pay).status_code or True
assert client.post(f"{API}/org/departments", headers=pay,
json={"name": "薪酬试算部", "code": "MTX"}).status_code == 403
client.delete(f"{API}/payroll/items/{item.json()['id']}", headers=pay)
# 部门经理:看得到下属、看不到兄弟部门,且不能建档
assert client.get(f"{API}/employees", headers=mgr).json()["total"] > 0
assert client.post(f"{API}/employees", headers=mgr, json={}).status_code == 403
assert client.get(f"{API}/self/leave/options", headers=mgr).status_code == 200
# 普通员工:只能改自己
assert client.get(f"{API}/self/home", headers=emp).status_code == 200
assert client.patch(f"{API}/employees/{client.get(f'{API}/auth/me', headers=emp).json()['employee']['id']}",
headers=emp, json={"remark": "x"}).status_code == 403
def _any_department(client, admin) -> int:
return client.get(f"{API}/org/departments/options", headers=admin,
params={"limit": 5}).json()[0]["id"]