5ecb30876e
- ruff --fix 自动修正 44 项：移除未用 import（pytest 等）、import 块排序归一（I001） - 手工修复剩余 5 项：test_cascade.py 两处未用赋值（F841）；test_s2_rules_and_logic.py 中部 import 移至文件顶部（E402 ×3） - 无行为变更：全量 492 项测试通过
384 lines
14 KiB
Python
384 lines
14 KiB
Python
"""Tests for S2 new rules: json_schema, safety, semantic_similarity,
|
|
and rule combination logic (all/any/weighted)."""
|
|
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
|
|
import pytest
|
|
from agenteval.evaluation.engine import EvalEngine
|
|
from agenteval.evaluation.rules.json_schema import JsonSchemaRule, _get_path
|
|
from agenteval.evaluation.rules.safety import SafetyRule
|
|
from agenteval.evaluation.rules.semantic import SemanticSimilarityRule, _cosine
|
|
from agenteval.models import (
|
|
Case,
|
|
CaseType,
|
|
EvalRuleConfig,
|
|
EvalTarget,
|
|
PlatformType,
|
|
RuleLogic,
|
|
RunStatus,
|
|
Scenario,
|
|
TargetStatus,
|
|
Turn,
|
|
)
|
|
|
|
from tests.unit.mock_channel import MockChannel
|
|
|
|
# ── helpers ──────────────────────────────────────────────────────────────
|
|
|
|
def _turn(reply_text: str, latency_ms: int = 100) -> Turn:
|
|
return Turn(
|
|
id="t1", run_id="r1", case_id="c1", round_index=1,
|
|
reply={"msgBody": {"content": reply_text}},
|
|
latency_ms=latency_ms,
|
|
)
|
|
|
|
|
|
def _case(
|
|
*,
|
|
rules: list[dict] | None = None,
|
|
rule_logic: RuleLogic = RuleLogic.ALL,
|
|
rule_pass_threshold: float = 0.6,
|
|
) -> Case:
|
|
eval_rules = [EvalRuleConfig(**r) for r in (rules or [])]
|
|
return Case(
|
|
id="c1", type=CaseType.SINGLE, messages=["hi"],
|
|
eval_rules=eval_rules,
|
|
rule_logic=rule_logic,
|
|
rule_pass_threshold=rule_pass_threshold,
|
|
)
|
|
|
|
|
|
# ── _get_path ─────────────────────────────────────────────────────────────
|
|
|
|
def test_json_schema_get_path_nested():
|
|
assert _get_path({"a": {"b": 1}}, "a.b") == (True, 1)
|
|
|
|
|
|
def test_json_schema_get_path_missing():
|
|
assert _get_path({"a": 1}, "a.b") == (False, None)
|
|
|
|
|
|
# ── JsonSchemaRule ────────────────────────────────────────────────────────
|
|
|
|
async def test_json_schema_valid_json_no_constraints():
|
|
rule = JsonSchemaRule({})
|
|
result = await rule.evaluate(_case(), [_turn('{"key": "value"}')])
|
|
assert result.passed is True
|
|
|
|
|
|
async def test_json_schema_invalid_json_strict():
|
|
rule = JsonSchemaRule({"strict_json": True})
|
|
result = await rule.evaluate(_case(), [_turn("not json at all")])
|
|
assert result.passed is False
|
|
assert "合法 JSON" in result.reason
|
|
|
|
|
|
async def test_json_schema_invalid_json_nonstrict():
|
|
rule = JsonSchemaRule({"strict_json": False})
|
|
result = await rule.evaluate(_case(), [_turn("not json")])
|
|
assert result.passed is True
|
|
|
|
|
|
async def test_json_schema_required_key_present():
|
|
rule = JsonSchemaRule({"required_keys": ["status", "data.id"]})
|
|
result = await rule.evaluate(_case(), [_turn('{"status": "ok", "data": {"id": 42}}')])
|
|
assert result.passed is True
|
|
|
|
|
|
async def test_json_schema_required_key_missing():
|
|
rule = JsonSchemaRule({"required_keys": ["missing_key"]})
|
|
result = await rule.evaluate(_case(), [_turn('{"status": "ok"}')])
|
|
assert result.passed is False
|
|
assert "missing_key" in result.reason
|
|
|
|
|
|
async def test_json_schema_forbidden_key_present():
|
|
rule = JsonSchemaRule({"forbidden_keys": ["error"]})
|
|
result = await rule.evaluate(_case(), [_turn('{"status": "ok", "error": "oops"}')])
|
|
assert result.passed is False
|
|
assert "error" in result.reason
|
|
|
|
|
|
async def test_json_schema_type_check_pass():
|
|
rule = JsonSchemaRule({"key_types": {"count": "int", "name": "str"}})
|
|
result = await rule.evaluate(_case(), [_turn('{"count": 5, "name": "hello"}')])
|
|
assert result.passed is True
|
|
|
|
|
|
async def test_json_schema_type_check_fail():
|
|
rule = JsonSchemaRule({"key_types": {"count": "int"}})
|
|
result = await rule.evaluate(_case(), [_turn('{"count": "five"}')])
|
|
assert result.passed is False
|
|
assert "count" in result.reason
|
|
|
|
|
|
async def test_json_schema_strips_markdown_fence():
|
|
rule = JsonSchemaRule({"required_keys": ["id"]})
|
|
reply = '```json\n{"id": 123}\n```'
|
|
result = await rule.evaluate(_case(), [_turn(reply)])
|
|
assert result.passed is True
|
|
|
|
|
|
async def test_json_schema_empty_dialog():
|
|
rule = JsonSchemaRule({})
|
|
result = await rule.evaluate(_case(), [])
|
|
assert result.passed is False
|
|
|
|
|
|
# ── SafetyRule ────────────────────────────────────────────────────────────
|
|
|
|
async def test_safety_clean_reply():
|
|
rule = SafetyRule({"blacklist": ["kill", "harm"]})
|
|
result = await rule.evaluate(_case(), [_turn("This is a helpful response.")])
|
|
assert result.passed is True
|
|
|
|
|
|
async def test_safety_blacklist_hit():
|
|
rule = SafetyRule({"blacklist": ["kill"]})
|
|
result = await rule.evaluate(_case(), [_turn("I will kill you!")])
|
|
assert result.passed is False
|
|
assert "kill" in result.reason
|
|
|
|
|
|
async def test_safety_blacklist_case_insensitive():
|
|
rule = SafetyRule({"blacklist": ["HARM"]})
|
|
result = await rule.evaluate(_case(), [_turn("this causes harm")])
|
|
assert result.passed is False
|
|
|
|
|
|
async def test_safety_no_blacklist():
|
|
rule = SafetyRule({})
|
|
result = await rule.evaluate(_case(), [_turn("any text")])
|
|
assert result.passed is True
|
|
|
|
|
|
async def test_safety_moderation_api_flagged():
|
|
rule = SafetyRule({
|
|
"use_moderation_api": True,
|
|
"api_url": "http://mock/v1/moderations",
|
|
"api_key": "test",
|
|
})
|
|
mock_response = MagicMock()
|
|
mock_response.raise_for_status = MagicMock()
|
|
mock_response.json = MagicMock(return_value={
|
|
"results": [{"flagged": True, "categories": {"hate": True, "violence": False}}]
|
|
})
|
|
|
|
with patch("agenteval.evaluation.rules.safety.httpx.AsyncClient") as MockClient:
|
|
instance = MockClient.return_value.__aenter__.return_value
|
|
instance.post = AsyncMock(return_value=mock_response)
|
|
result = await rule.evaluate(_case(), [_turn("hateful content here")])
|
|
|
|
assert result.passed is False
|
|
assert "hate" in result.reason
|
|
|
|
|
|
async def test_safety_moderation_api_unavailable_degrades():
|
|
rule = SafetyRule({
|
|
"use_moderation_api": True,
|
|
"api_url": "http://unavailable/v1/moderations",
|
|
})
|
|
with patch("agenteval.evaluation.rules.safety.httpx.AsyncClient") as MockClient:
|
|
instance = MockClient.return_value.__aenter__.return_value
|
|
instance.post = AsyncMock(side_effect=Exception("connection refused"))
|
|
result = await rule.evaluate(_case(), [_turn("normal text")])
|
|
|
|
assert result.passed is True
|
|
assert "降级" in result.reason
|
|
|
|
|
|
async def test_safety_empty_dialog():
|
|
rule = SafetyRule({})
|
|
result = await rule.evaluate(_case(), [])
|
|
assert result.passed is False
|
|
|
|
|
|
# ── SemanticSimilarityRule ────────────────────────────────────────────────
|
|
|
|
def test_cosine_identical():
|
|
v = [1.0, 0.0, 0.0]
|
|
assert _cosine(v, v) == pytest.approx(1.0)
|
|
|
|
|
|
def test_cosine_orthogonal():
|
|
assert _cosine([1.0, 0.0], [0.0, 1.0]) == pytest.approx(0.0)
|
|
|
|
|
|
def test_cosine_zero_vector():
|
|
assert _cosine([0.0, 0.0], [1.0, 0.0]) == 0.0
|
|
|
|
|
|
async def test_semantic_missing_api_url():
|
|
rule = SemanticSimilarityRule({"reference": "hello world"})
|
|
result = await rule.evaluate(_case(), [_turn("hello")])
|
|
assert result.passed is False
|
|
assert "api_url" in result.reason
|
|
|
|
|
|
async def test_semantic_missing_reference():
|
|
rule = SemanticSimilarityRule({"api_url": "http://mock/embed"})
|
|
result = await rule.evaluate(_case(), [_turn("hello")])
|
|
assert result.passed is False
|
|
assert "reference" in result.reason
|
|
|
|
|
|
async def test_semantic_high_similarity_passes():
|
|
rule = SemanticSimilarityRule({
|
|
"api_url": "http://mock/embed",
|
|
"reference": "hello world",
|
|
"min_score": 0.8,
|
|
})
|
|
vec = [1.0, 0.0, 0.0]
|
|
mock_resp = MagicMock()
|
|
mock_resp.raise_for_status = MagicMock()
|
|
mock_resp.json = MagicMock(return_value={"data": [{"embedding": vec}]})
|
|
|
|
with patch("agenteval.evaluation.rules.semantic.httpx.AsyncClient") as MockClient:
|
|
instance = MockClient.return_value.__aenter__.return_value
|
|
instance.post = AsyncMock(return_value=mock_resp)
|
|
result = await rule.evaluate(_case(), [_turn("hello world")])
|
|
|
|
assert result.passed is True
|
|
assert result.score == pytest.approx(1.0)
|
|
|
|
|
|
async def test_semantic_low_similarity_fails():
|
|
rule = SemanticSimilarityRule({
|
|
"api_url": "http://mock/embed",
|
|
"reference": "hello world",
|
|
"min_score": 0.9,
|
|
})
|
|
call_count = {"n": 0}
|
|
|
|
async def mock_post(url, **kwargs):
|
|
mock_resp = MagicMock()
|
|
mock_resp.raise_for_status = MagicMock()
|
|
# First call (reply): orthogonal to reference
|
|
vecs = [[1.0, 0.0], [0.0, 1.0]]
|
|
mock_resp.json = MagicMock(return_value={"data": [{"embedding": vecs[call_count["n"]]}]})
|
|
call_count["n"] += 1
|
|
return mock_resp
|
|
|
|
with patch("agenteval.evaluation.rules.semantic.httpx.AsyncClient") as MockClient:
|
|
instance = MockClient.return_value.__aenter__.return_value
|
|
instance.post = AsyncMock(side_effect=mock_post)
|
|
result = await rule.evaluate(_case(), [_turn("completely different")])
|
|
|
|
assert result.passed is False
|
|
|
|
|
|
async def test_semantic_api_error_fails_gracefully():
|
|
rule = SemanticSimilarityRule({
|
|
"api_url": "http://mock/embed",
|
|
"reference": "ref",
|
|
})
|
|
with patch("agenteval.evaluation.rules.semantic.httpx.AsyncClient") as MockClient:
|
|
instance = MockClient.return_value.__aenter__.return_value
|
|
instance.post = AsyncMock(side_effect=Exception("timeout"))
|
|
result = await rule.evaluate(_case(), [_turn("reply")])
|
|
|
|
assert result.passed is False
|
|
assert "embedding 调用失败" in result.reason
|
|
|
|
|
|
async def test_semantic_empty_dialog():
|
|
rule = SemanticSimilarityRule({"api_url": "http://x", "reference": "ref"})
|
|
result = await rule.evaluate(_case(), [])
|
|
assert result.passed is False
|
|
|
|
|
|
# ── Rule combination logic (engine integration) ───────────────────────────
|
|
|
|
|
|
def _make_target() -> EvalTarget:
|
|
return EvalTarget(
|
|
id="t-1", name="t", platform=PlatformType.AI_DIGITAL_EMPLOYEE,
|
|
channel_type=__import__("agenteval.models", fromlist=["ChannelType"]).ChannelType.TUTU_API,
|
|
channel_config={"base_url": "http://x", "token": "x", "tenant": "t",
|
|
"chat_channel_id": "c", "chat_contact_id": "u"},
|
|
status=TargetStatus.ACTIVE,
|
|
)
|
|
|
|
|
|
def _build_engine(scenario, session) -> EvalEngine:
|
|
engine = EvalEngine(target=_make_target(), scenario=scenario, session=session)
|
|
engine.channel = MockChannel()
|
|
return engine
|
|
|
|
|
|
async def test_rule_logic_all_passes_when_all_pass(db_session):
|
|
scenario = Scenario(id="s1", name="s", cases=[Case(
|
|
id="c1", type=CaseType.SINGLE, messages=["hi"],
|
|
eval_rules=[
|
|
EvalRuleConfig(type="keyword_match", params={"keywords": ["echo"]}), # MockChannel replies "echo: q-1"
|
|
EvalRuleConfig(type="response_time", params={"max_ms": 99999}),
|
|
],
|
|
rule_logic=RuleLogic.ALL,
|
|
)])
|
|
engine = _build_engine(scenario, db_session)
|
|
run = await engine.run()
|
|
assert run.status == RunStatus.COMPLETED
|
|
assert run.summary.passed_cases == 1
|
|
|
|
|
|
async def test_rule_logic_all_fails_when_one_fails(db_session):
|
|
scenario = Scenario(id="s1", name="s", cases=[Case(
|
|
id="c1", type=CaseType.SINGLE, messages=["hi"],
|
|
eval_rules=[
|
|
EvalRuleConfig(type="keyword_match", params={"keywords": ["echo"]}), # passes
|
|
EvalRuleConfig(type="keyword_match", params={"keywords": ["__IMPOSSIBLE__"]}), # fails
|
|
],
|
|
rule_logic=RuleLogic.ALL,
|
|
)])
|
|
engine = _build_engine(scenario, db_session)
|
|
run = await engine.run()
|
|
assert run.status == RunStatus.COMPLETED
|
|
assert run.summary.failed_cases == 1
|
|
|
|
|
|
async def test_rule_logic_any_passes_when_one_passes(db_session):
|
|
scenario = Scenario(id="s1", name="s", cases=[Case(
|
|
id="c1", type=CaseType.SINGLE, messages=["hi"],
|
|
eval_rules=[
|
|
EvalRuleConfig(type="keyword_match", params={"keywords": ["echo"]}), # passes
|
|
EvalRuleConfig(type="keyword_match", params={"keywords": ["__IMPOSSIBLE__"]}), # fails
|
|
],
|
|
rule_logic=RuleLogic.ANY,
|
|
)])
|
|
engine = _build_engine(scenario, db_session)
|
|
run = await engine.run()
|
|
assert run.status == RunStatus.COMPLETED
|
|
assert run.summary.passed_cases == 1
|
|
|
|
|
|
async def test_rule_logic_weighted_passes_above_threshold(db_session):
|
|
scenario = Scenario(id="s1", name="s", cases=[Case(
|
|
id="c1", type=CaseType.SINGLE, messages=["hi"],
|
|
eval_rules=[
|
|
EvalRuleConfig(type="keyword_match", params={"keywords": ["echo"]}, weight=0.8), # passes
|
|
EvalRuleConfig(type="keyword_match", params={"keywords": ["__IMPOSSIBLE__"]}, weight=0.2), # fails
|
|
],
|
|
rule_logic=RuleLogic.WEIGHTED,
|
|
rule_pass_threshold=0.6, # weighted score = 0.8/(0.8+0.2)=0.8 >= 0.6 → pass
|
|
)])
|
|
engine = _build_engine(scenario, db_session)
|
|
run = await engine.run()
|
|
assert run.status == RunStatus.COMPLETED
|
|
assert run.summary.passed_cases == 1
|
|
|
|
|
|
async def test_rule_logic_weighted_fails_below_threshold(db_session):
|
|
scenario = Scenario(id="s1", name="s", cases=[Case(
|
|
id="c1", type=CaseType.SINGLE, messages=["hi"],
|
|
eval_rules=[
|
|
EvalRuleConfig(type="keyword_match", params={"keywords": ["echo"]}, weight=0.2), # passes
|
|
EvalRuleConfig(type="keyword_match", params={"keywords": ["__IMPOSSIBLE__"]}, weight=0.8), # fails
|
|
],
|
|
rule_logic=RuleLogic.WEIGHTED,
|
|
rule_pass_threshold=0.6, # weighted score = 0.2/(0.2+0.8)=0.2 < 0.6 → fail
|
|
)])
|
|
engine = _build_engine(scenario, db_session)
|
|
run = await engine.run()
|
|
assert run.status == RunStatus.COMPLETED
|
|
assert run.summary.failed_cases == 1
|