113 行
4.9 KiB
Python
113 行
4.9 KiB
Python
# -*- coding: utf-8 -*-
|
|
from __future__ import annotations
|
|
|
|
import dataclasses
|
|
from pathlib import Path
|
|
import sys
|
|
import unittest
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
if str(ROOT) not in sys.path:
|
|
sys.path.insert(0, str(ROOT))
|
|
|
|
from p4_capabilities import (
|
|
P4_CAPABILITY_BY_ID,
|
|
P4_CAPABILITY_REGISTRY,
|
|
SAFE_EVENT_ID_RE,
|
|
is_exact_p4_management_command,
|
|
parse_p4_management_command,
|
|
)
|
|
|
|
|
|
PERSON_ID = "person_0123456789abcdef01234567"
|
|
IDENTITY_KEY = "ops-origin-v1:" + ("a" * 64)
|
|
EVENT_ID = "ledger:2026/07+owner@a.b-1"
|
|
|
|
|
|
class P4CapabilityTests(unittest.TestCase):
|
|
def test_exact_registered_forms_accept_only_stable_targets(self) -> None:
|
|
cases = [
|
|
(f"/放出 {PERSON_ID}", "p4.owner_release", PERSON_ID, "person_id", None),
|
|
(f"/放出 {IDENTITY_KEY}", "p4.owner_release", IDENTITY_KEY, "p0_identity_key", None),
|
|
(f"/误判 {PERSON_ID}", "p4.owner_misjudgment", PERSON_ID, "person_id", None),
|
|
(f"/误判 {IDENTITY_KEY} {EVENT_ID}", "p4.owner_misjudgment", IDENTITY_KEY, "p0_identity_key", EVENT_ID),
|
|
]
|
|
for payload, capability_id, target, target_kind, event_id in cases:
|
|
with self.subTest(payload=payload):
|
|
parsed = parse_p4_management_command(payload)
|
|
self.assertIsNotNone(parsed)
|
|
assert parsed is not None
|
|
self.assertEqual(parsed.capability_id, capability_id)
|
|
self.assertEqual(parsed.target, target)
|
|
self.assertEqual(parsed.target_kind, target_kind)
|
|
self.assertEqual(parsed.event_id, event_id)
|
|
self.assertTrue(is_exact_p4_management_command(payload))
|
|
|
|
def test_registry_metadata_is_immutable_and_explicitly_not_self_service(self) -> None:
|
|
self.assertEqual(
|
|
tuple(capability.capability_id for capability in P4_CAPABILITY_REGISTRY),
|
|
("p4.owner_release", "p4.owner_misjudgment"),
|
|
)
|
|
self.assertEqual(set(P4_CAPABILITY_BY_ID), {"p4.owner_release", "p4.owner_misjudgment"})
|
|
|
|
for capability in P4_CAPABILITY_REGISTRY:
|
|
with self.subTest(capability_id=capability.capability_id):
|
|
self.assertEqual(capability.group, "p4_affinity_confinement")
|
|
self.assertTrue(capability.tool.startswith("owner_"))
|
|
self.assertTrue(capability.sensitivity.startswith("owner_only_"))
|
|
self.assertTrue(capability.requires_owner_authorization)
|
|
self.assertFalse(capability.self_service_allowed)
|
|
self.assertEqual(capability.execution_mode, "shadow_advisory_only")
|
|
with self.assertRaises(dataclasses.FrozenInstanceError):
|
|
capability.tool = "unsafe" # type: ignore[misc]
|
|
|
|
with self.assertRaises(TypeError):
|
|
P4_CAPABILITY_BY_ID["p4.appeal"] = P4_CAPABILITY_REGISTRY[0] # type: ignore[index]
|
|
self.assertIsNone(parse_p4_management_command(f"/申诉 {PERSON_ID}"))
|
|
self.assertIsNone(parse_p4_management_command(f"/appeal {PERSON_ID}"))
|
|
|
|
def test_malformed_mixed_or_nonpure_payload_never_matches(self) -> None:
|
|
cases: list[object] = [
|
|
None,
|
|
1,
|
|
"",
|
|
"/放出",
|
|
"/误判",
|
|
f"/放出 {PERSON_ID} ",
|
|
f" /放出 {PERSON_ID}",
|
|
f"/放出 {PERSON_ID}",
|
|
f"/放出\t{PERSON_ID}",
|
|
f"/放出 {PERSON_ID}\n",
|
|
f"请放出 /放出 {PERSON_ID}",
|
|
f"/放出 {PERSON_ID} 谢谢",
|
|
f"/误判 {PERSON_ID} {EVENT_ID} 请立即执行",
|
|
f"/误判 {PERSON_ID} {EVENT_ID} extra",
|
|
f"/误判 {PERSON_ID}\n{EVENT_ID}",
|
|
f"/误判 {PERSON_ID} {EVENT_ID}",
|
|
f"/未知 {PERSON_ID}",
|
|
"/放出 alice",
|
|
"/放出 12345678",
|
|
"/放出 person_0123456789abcdef0123456g",
|
|
"/放出 person_0123456789abcdef012345678",
|
|
"/放出 ops-origin-v1:" + ("A" * 64),
|
|
f"/误判 {PERSON_ID} _bad-event",
|
|
f"/误判 {PERSON_ID} bad event",
|
|
f"/误判 {PERSON_ID} " + ("a" * 129),
|
|
f"/放出 {PERSON_ID}; /误判 {PERSON_ID}",
|
|
]
|
|
for payload in cases:
|
|
with self.subTest(payload=payload):
|
|
self.assertIsNone(parse_p4_management_command(payload))
|
|
self.assertFalse(is_exact_p4_management_command(payload))
|
|
|
|
def test_event_id_grammar_matches_the_p4_engine_safe_identifier_contract(self) -> None:
|
|
self.assertIsNotNone(SAFE_EVENT_ID_RE.fullmatch(EVENT_ID))
|
|
self.assertIsNotNone(SAFE_EVENT_ID_RE.fullmatch("A"))
|
|
self.assertIsNotNone(SAFE_EVENT_ID_RE.fullmatch("a" * 128))
|
|
self.assertIsNone(SAFE_EVENT_ID_RE.fullmatch("a" * 129))
|
|
self.assertIsNone(SAFE_EVENT_ID_RE.fullmatch("_starts_wrong"))
|
|
self.assertIsNone(SAFE_EVENT_ID_RE.fullmatch("has whitespace"))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|