783 lines
41 KiB
Python
783 lines
41 KiB
Python
"""角色 × 模块功能完整性矩阵。
|
||
|
||
覆盖 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"]
|