astrbot_plugin_private_comp.../tests/test_p4_affinity_confinement.py

233 行
9.4 KiB
Python

# -*- coding: utf-8 -*-
from __future__ import annotations
from copy import deepcopy
from datetime import datetime, timedelta, timezone
from p4_affinity_confinement import (
POLICY_VERSION,
REVIEW_SCHEMA_VERSION,
evaluate_violation_policy,
new_shadow_state,
replay_shadow_events,
settle_shadow_event,
validate_review_result,
)
UTC = timezone.utc
def _at(day: int, hour: int = 0) -> str:
return (datetime(2026, 1, 1, hour, tzinfo=UTC) + timedelta(days=day)).isoformat().replace("+00:00", "Z")
def _review(category: str = "prompt_injection", *, confidence: float = 0.99, flags: list[str] | None = None) -> dict:
return {
"schema_version": REVIEW_SCHEMA_VERSION,
"verdict": "violation",
"category": category,
"confidence": confidence,
"risk_flags": flags or [],
"evidence": [{"message_id": "m-1", "code": "direct_instruction_override"}],
}
def _violation(event_id: str, day: int, review: dict | None = None) -> dict:
return {
"event_id": event_id,
"occurred_at": _at(day),
"kind": "violation",
"policy_version": POLICY_VERSION,
"review": review or _review(),
}
def _positive(event_id: str, day: int, *, group_percent: int = 100) -> dict:
return {
"event_id": event_id,
"occurred_at": _at(day),
"kind": "positive",
"policy_version": POLICY_VERSION,
"positive_category": "reliable_help",
"base_points": 4,
"is_group": group_percent != 100,
"group_affinity_weight_percent": group_percent,
}
def test_review_validation_rejects_executable_or_prose_fields_and_policy_owns_steps():
valid = _review("doxxing")
assert validate_review_result(valid)["valid"] is True
decision = evaluate_violation_policy(valid)
assert decision["steps"] == 3
assert decision["minimum_confinement_days"] == 9
for forbidden in ("severity_steps", "score_delta", "confinement_days", "warning_text", "explanation"):
bad = deepcopy(valid)
bad[forbidden] = 3 if forbidden != "warning_text" else "do not do this"
assert validate_review_result(bad)["valid"] is False
assert evaluate_violation_policy(bad)["steps"] == 0
uncertain = deepcopy(valid)
uncertain["verdict"] = "uncertain"
assert evaluate_violation_policy(uncertain)["steps"] == 0
def test_normal_chat_never_auto_warms_and_inputs_are_not_mutated():
state = new_shadow_state()
event = {"event_id": "normal-1", "occurred_at": _at(0), "kind": "normal"}
state_before, event_before = deepcopy(state), deepcopy(event)
result = settle_shadow_event(state, event)
assert result["outcome"] == "normal_no_settlement"
assert result["state"]["score"] == 0
assert state == state_before
assert event == event_before
duplicate = settle_shadow_event(result["state"], event)
assert duplicate["outcome"] == "idempotent"
assert duplicate["state"] == result["state"]
def test_ordinary_chat_invalid_review_and_owner_events_fail_closed_without_penalty():
state = new_shadow_state()
for event_id in ("greeting", "spam", "disagreement"):
state = settle_shadow_event(state, {
"event_id": event_id,
"occurred_at": _at(0),
"kind": "normal",
})["state"]
assert state["score"] == 0
low_confidence = settle_shadow_event(state, _violation(
"low-confidence",
0,
_review(confidence=0.89),
))
assert low_confidence["outcome"] == "violation_no_penalty"
assert low_confidence["state"]["score"] == 0
owner = settle_shadow_event(low_confidence["state"], {
**_violation("owner-violation", 0),
"is_owner": True,
})
assert owner["outcome"] == "owner_automatic_exempt"
assert owner["state"]["score"] == 0
def test_positive_caps_and_group_weight_are_deterministic():
grouped = settle_shadow_event(new_shadow_state(), _positive("group-1", 0, group_percent=50))
assert grouped["state"]["score"] == 2
assert grouped["details"]["delta"] == 2
state = new_shadow_state()
for event_id in ("daily-1", "daily-2", "daily-3"):
result = settle_shadow_event(state, _positive(event_id, 0))
state = result["state"]
assert state["score"] == 8
assert result["outcome"] == "positive_capped"
# The rolling seven-day cap continues after the daily cap reset.
for day in (1, 2):
for suffix in ("a", "b"):
state = settle_shadow_event(state, _positive(f"week-{day}-{suffix}", day))["state"]
state = settle_shadow_event(state, _positive("week-3-a", 3))["state"]
final = settle_shadow_event(state, _positive("week-3-b", 3))
assert final["state"]["score"] == 30
assert final["details"]["delta"] == 2
def test_three_warnings_and_direct_high_risk_confinement_rounds():
state = new_shadow_state()
for event_id in ("v-1", "v-2", "v-3"):
state = settle_shadow_event(state, _violation(event_id, 0))["state"]
assert state["score"] == -1200
assert state["warning_stage"] == "confinement"
assert state["confinement_round"] == 1
assert state["confinement_duration_days"] == 1
high = settle_shadow_event(new_shadow_state(), _violation("high-1", 0, _review("doxxing")))
assert high["state"]["score"] == -1200
assert high["state"]["confinement_round"] == 1
assert high["state"]["confinement_duration_days"] == 9
def test_expiry_release_prompt_recovery_and_violation_priority():
state = new_shadow_state()
for event_id in ("e-v1", "e-v2", "e-v3"):
state = settle_shadow_event(state, _violation(event_id, 0))["state"]
# Six elapsed days do not skip the one-shot release prompt.
released = settle_shadow_event(state, {"event_id": "normal-release", "occurred_at": _at(7), "kind": "normal"})
assert released["outcome"] == "release_prompt_only"
assert released["state"]["score"] == -800
recovered = settle_shadow_event(released["state"], {"event_id": "normal-recover", "occurred_at": _at(7, 1), "kind": "normal"})
assert recovered["outcome"] == "recovery_settled"
assert recovered["state"]["score"] == 0
assert recovered["state"]["confinement_round"] == 0
# A confirmed violation at the recovery trigger has priority over recovery.
state = new_shadow_state()
for event_id in ("p-v1", "p-v2", "p-v3"):
state = settle_shadow_event(state, _violation(event_id, 0))["state"]
priority = settle_shadow_event(state, _violation("p-v4", 7))
assert priority["outcome"] == "violation_confinement"
assert priority["state"]["score"] == -1200
assert priority["state"]["confinement_round"] == 2
def test_owner_release_and_misjudgment_are_shadow_replay_inputs():
healthy = settle_shadow_event(new_shadow_state(), {
"event_id": "release-healthy", "occurred_at": _at(0), "kind": "owner_release", "actor_is_owner": True,
})
assert healthy["outcome"] == "owner_release_not_confined"
assert healthy["state"]["score"] == 0
assert healthy["state"]["release_prompt_pending"] is False
first = settle_shadow_event(new_shadow_state(), _violation("bad-1", 0, _review("doxxing")))
denied = settle_shadow_event(first["state"], {"event_id": "release-denied", "occurred_at": _at(1), "kind": "owner_release"})
assert denied["outcome"] == "owner_required"
released = settle_shadow_event(denied["state"], {
"event_id": "release-owner", "occurred_at": _at(1), "kind": "owner_release", "actor_is_owner": True,
})
assert released["state"]["score"] == -800
assert released["state"]["confinement_round"] == 1
assert released["state"]["release_prompt_pending"] is True
replayed = settle_shadow_event(first["state"], {
"event_id": "misjudge-1", "occurred_at": _at(1), "kind": "misjudgment",
"actor_is_owner": True, "revoke_event_id": "bad-1",
})
assert replayed["outcome"] == "misjudgment_replayed"
assert replayed["state"]["score"] == 0
assert "bad-1" in replayed["state"]["revoked_event_ids"]
most_recent = settle_shadow_event(first["state"], {
"event_id": "misjudge-most-recent", "occurred_at": _at(1), "kind": "misjudgment",
"actor_is_owner": True,
})
assert most_recent["outcome"] == "misjudgment_replayed"
assert most_recent["state"]["score"] == 0
assert most_recent["state"]["event_log"][-1]["revoke_event_id"] == "bad-1"
normal = settle_shadow_event(new_shadow_state(), {"event_id": "normal-only", "occurred_at": _at(0), "kind": "normal"})
not_violation = settle_shadow_event(normal["state"], {
"event_id": "misjudge-normal", "occurred_at": _at(1), "kind": "misjudgment",
"actor_is_owner": True, "revoke_event_id": "normal-only",
})
assert not_violation["outcome"] == "revoke_target_not_violation"
assert not_violation["state"]["score"] == 0
invalid_target = settle_shadow_event(first["state"], {
"event_id": "misjudge-invalid-target", "occurred_at": _at(1), "kind": "misjudgment",
"actor_is_owner": True, "revoke_event_id": "invalid target",
})
assert invalid_target["outcome"] == "misjudgment_rejected"
assert invalid_target["state"]["score"] == -1200
assert invalid_target["state"]["revoked_event_ids"] == []
via_replay = replay_shadow_events([
_violation("ledger-bad", 0, _review("doxxing")),
{"event_id": "ledger-fix", "occurred_at": _at(1), "kind": "misjudgment", "actor_is_owner": True, "revoke_event_id": "ledger-bad"},
])
assert via_replay["state"]["score"] == 0