217 lines
11 KiB
Python
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()
|