Files
kefu/wechat_rpa/test_basic_role_edit.py
2026-11-16 09:28:25 +08:00

217 lines
11 KiB
Python

"""Editable Group basic role, using synthetic SQLite, identities and signing keys."""
from __future__ import annotations
import json
import os
import secrets
import sqlite3
import subprocess
import sys
import tempfile
import time
import unittest
from pathlib import Path
from unittest import mock
from fastapi.testclient import TestClient
import admin_api
import admin_backend as backend
import group_authorization
import group_sso
import rbac
PASSWORD = "Fixture-Basic-Role-2026!"
KEY = bytes.fromhex("56" * 32)
IDENTITY = {"client_id": "kefu", "gid": "gid_" + "c" * 32,
"source_admin_id": 71, "account": "synthetic-basic",
"name": "合成基础用户", "company_id": 2}
class BasicRoleEditTests(unittest.TestCase):
def setUp(self):
self.directory = tempfile.TemporaryDirectory()
self.addCleanup(self.directory.cleanup)
self.root = Path(self.directory.name)
key_file = self.root / "synthetic.key"
key_file.write_text(KEY.hex(), encoding="ascii")
self.environment = mock.patch.dict(os.environ, {
"ZYT_GROUP_METADATA_KEY_FILE": str(key_file),
"ZYT_GROUP_BASE_URL": "http://127.0.0.1:5173",
"ZYT_GROUP_API_URL": "http://127.0.0.1:8081/adminapi",
"KEFU_PUBLIC_BASE_URL": "http://127.0.0.1:5666",
}, clear=True)
self.environment.start()
self.addCleanup(self.environment.stop)
config = mock.patch.object(backend, "load_initial_config",
return_value=backend.CONFIG_DEFAULTS.copy())
config.start()
self.addCleanup(config.stop)
self.db = backend.Database(self.root / "synthetic.sqlite")
self.db.initialize(PASSWORD)
self.client = TestClient(admin_api.create_app(self.db.path))
self.addCleanup(self.client.close)
def headers(self, user_id=1):
token, _ = self.db.create_token(user_id, "api", "synthetic-session", 3600)
return {"Authorization": "Bearer " + token}
def role(self):
return next(role for role in self.db.roles() if role["code"] == "zyt_basic")
def save(self, permissions, name="集团基础配置", headers=None):
return self.client.post("/api/v2/roles", headers=headers or self.headers(),
json={"code": "zyt_basic", "name": name, "permissions": permissions})
def group_login(self, identity=None):
with mock.patch.object(group_sso, "exchange", return_value=identity or IDENTITY):
response = self.client.post("/api/v2/auth/group/exchange",
json={"code": "C" * 43, "code_verifier": "V" * 43})
self.assertEqual(response.status_code, 200, response.text)
return response.json()
def fixture_actor(self, code, permissions):
self.db.save_role(code, code, permissions, 1, "fixture")
self.db.create_user(code, PASSWORD, code, 1, "fixture")
return self.headers(self.db.authenticate(code, PASSWORD)["id"])
def test_fresh_seed_stays_empty_and_enrollment_still_uses_basic(self):
self.assertEqual(self.role()["permissions"], [])
self.assertTrue(self.role()["builtin"])
user = self.group_login()["user"]
self.assertEqual(user["role"], "zyt_basic")
self.assertEqual(user["permissions"], [])
def test_service_save_and_api_role_writer_can_change_name_and_permissions(self):
self.db.save_role("zyt_basic", "服务层配置", ["config:read"], 1, "fixture")
self.assertEqual(self.role()["name"], "服务层配置")
self.assertEqual(self.role()["permissions"], ["config:read"])
writer = self.fixture_actor("fixture_writer", ["role:write"])
response = self.save(["stats:read"], headers=writer)
self.assertEqual(response.status_code, 200, response.text)
role = next(role for role in response.json()["roles"] if role["code"] == "zyt_basic")
self.assertEqual(role["name"], "集团基础配置")
self.assertEqual(role["permissions"], ["stats:read"])
self.assertTrue(role["builtin"])
def test_readonly_and_create_only_actors_cannot_edit_existing_basic(self):
before = self.role()
for code, permissions in (("fixture_reader", ["role:read"]),
("fixture_creator", ["role:create"]),
("fixture_none", [])):
with self.subTest(code=code):
response = self.save(["stats:read"], headers=self.fixture_actor(code, permissions))
self.assertEqual(response.status_code, 403, response.text)
self.assertEqual(self.role(), before)
self.assertEqual(self.client.post("/api/v2/roles", json={
"code": "zyt_basic", "permissions": ["stats:read"]}).status_code, 401)
def test_existing_group_token_reads_changed_permissions_on_each_request_and_clear(self):
user = self.group_login()
headers = {"Authorization": "Bearer " + user["access_token"]}
self.assertEqual(self.client.get("/api/v2/config", headers=headers).status_code, 403)
for permissions, status_code in ((["config:read"], 200), ([], 403)):
response = self.save(permissions)
self.assertEqual(response.status_code, 200, response.text)
self.assertEqual(self.client.get("/api/v2/me", headers=headers).json()["permissions"], permissions)
self.assertEqual(self.client.get("/api/v2/config", headers=headers).status_code, status_code)
self.assertEqual(self.db.permissions_for_user(user["user"]["id"]), set())
def test_seed_migrate_and_api_restart_retain_name_and_exact_grants_then_empty(self):
for permissions in (["config:read", "stats:read"], []):
response = self.save(permissions, name="已配置的基础角色")
self.assertEqual(response.status_code, 200, response.text)
with self.db.connect() as db:
rbac.seed(db, "reseed")
db.commit()
self.db.migrate()
with TestClient(admin_api.create_app(self.db.path)) as restarted:
response = restarted.get("/api/v2/roles", headers=self.headers())
self.assertEqual(response.status_code, 200, response.text)
role = next(item for item in response.json()["roles"] if item["code"] == "zyt_basic")
self.assertEqual(role["name"], "已配置的基础角色")
self.assertEqual(role["permissions"], permissions)
self.assertTrue(role["builtin"])
def test_legacy_split_migration_does_not_infer_extra_basic_grants(self):
db = sqlite3.connect(":memory:")
self.addCleanup(db.close)
rbac.seed(db, "first")
rbac.grant(db, "zyt_basic", ["user:write"], "configured")
db.execute("DELETE FROM role_permissions WHERE permission_code IN ('user:create','user:status')")
db.execute("INSERT INTO roles VALUES ('legacy_writer','旧写入角色',0,'t','t')")
db.execute("INSERT INTO role_permissions VALUES ('legacy_writer','user:write')")
rbac.seed(db, "upgrade")
self.assertEqual(rbac.permissions_of(db, "zyt_basic"), {"user:write"})
self.assertTrue({"user:create", "user:status"} <= rbac.permissions_of(db, "legacy_writer"))
def test_separate_service_processes_reseed_without_changing_basic_configuration(self):
script = ("import sqlite3,sys,rbac; db=sqlite3.connect(sys.argv[1]); "
"rbac.seed(db,sys.argv[2]); db.commit(); db.close()")
for permissions in (["stats:read"], []):
self.assertEqual(self.save(permissions, name="跨服务保留配置").status_code, 200)
for service in ("api", "gateway", "knowledge-worker"):
result = subprocess.run([sys.executable, "-c", script, str(self.db.path), service],
cwd=Path(rbac.__file__).resolve().parent, capture_output=True, text=True, timeout=30)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(self.role()["name"], "跨服务保留配置")
self.assertEqual(self.role()["permissions"], permissions)
def test_existing_and_new_group_users_inherit_current_basic_configuration(self):
existing = self.group_login()["user"]
with self.db.connect() as db:
original = dict(db.execute("SELECT * FROM users WHERE id=?", (existing["id"],)).fetchone())
self.assertEqual(self.save(["stats:read"]).status_code, 200)
repeated = self.group_login()["user"]
newer = self.group_login({**IDENTITY, "gid": "gid_" + "d" * 32, "source_admin_id": 72})["user"]
self.assertEqual(repeated["id"], existing["id"])
for user in (repeated, newer):
self.assertEqual(user["role"], "zyt_basic")
self.assertEqual(user["permissions"], ["stats:read"])
with self.db.connect() as db:
current = dict(db.execute("SELECT * FROM users WHERE id=?", (existing["id"],)).fetchone())
for field in ("username", "role", "password_salt", "password_digest", "must_change_password", "active"):
self.assertEqual(original[field], current[field])
def test_signed_group_options_project_current_basic_grants_and_revision(self):
user = self.group_login()["user"]
revisions = []
for permissions in ([], ["stats:read"], []):
self.assertEqual(self.save(permissions).status_code, 200)
body = {name: IDENTITY[name] for name in ("client_id", "gid", "source_admin_id", "company_id")}
raw = json.dumps(body, separators=(",", ":")).encode("utf-8")
stamp, nonce = str(int(time.time())), secrets.token_hex(16)
path = group_authorization.OPTIONS_PATH
response = self.client.post("/api/v2" + path, content=raw, headers={
"Content-Type": "application/json", "X-Group-Timestamp": stamp, "X-Group-Nonce": nonce,
"X-Group-Signature": group_authorization.request_signature(KEY, raw, stamp, nonce, path)})
self.assertEqual(response.status_code, 200, response.text)
data = response.json()
self.assertEqual(data["subject"]["user"]["id"], user["id"])
self.assertEqual(data["subject"]["user"]["permissions"], permissions)
basic = next(role for role in data["roles"] if role["code"] == "zyt_basic")
self.assertEqual(basic["name"], "集团基础配置")
self.assertEqual(basic["permissions"], permissions)
revisions.append(data["revision"])
self.assertNotEqual(revisions[0], revisions[1])
self.assertEqual(revisions[0], revisions[2])
def test_admin_power_guard_builtin_delete_and_unknown_permissions_still_hold(self):
before = self.role()
response = self.client.post("/api/v2/roles", headers=self.headers(),
json={"code": "admin", "name": "不应保存", "permissions": []})
self.assertEqual(response.status_code, 400, response.text)
self.assertIn("锁在门外", response.json()["detail"])
self.assertEqual(next(role for role in self.db.roles() if role["code"] == "admin")["name"], "管理员")
for code in ("zyt_basic", "admin", "operator", "viewer"):
response = self.client.delete("/api/v2/roles/" + code, headers=self.headers())
self.assertEqual(response.status_code, 400, response.text)
self.assertIn("内置角色不可删除", response.json()["detail"])
self.assertEqual(self.save(["unknown:permission"]).status_code, 400)
self.assertEqual(self.role(), before)
if __name__ == "__main__":
unittest.main()