feat(ai-rule-engine): 完成 MVP 所有批次实现

批次1: 项目结构 + SQLite 存储层 + 数据模型
批次2: REST API (http.server)
批次3: LLM 编译器 (支持 OpenAI/Anthropic)
批次4: RestrictedPython 规则执行器
批次5: 规则匹配器 + LLM Callback 兜底
批次6: 冲突检测器

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
rootandClaude Opus 4.7 committed 2026-05-11 22:19:42 +08:00
1 parent c022c54144
commit e39829fc4e
17 files changed
+1733

No files matched your search

+141
View File
@@ -0,0 +1,141 @@
"""Tests for REST API."""
import pytest
import json
import os
import tempfile
from http.client import HTTPConnection
from threading import Thread
from time import sleep
from rule_engine.api import create_app
from rule_engine.store import RuleStore
@pytest.fixture
def temp_db():
fd, path = tempfile.mkstemp(suffix=".db")
os.close(fd)
yield path
os.unlink(path)
@pytest.fixture
def store(temp_db):
return RuleStore(temp_db)
@pytest.fixture
def server(store):
srv = create_app(store, host="127.0.0.1", port=18000)
thread = Thread(target=srv.serve_forever, daemon=True)
thread.start()
sleep(0.1) # 等待服务器启动
yield srv
srv.shutdown()
@pytest.fixture
def client(server):
return HTTPConnection("127.0.0.1", 18000)
def test_health(client):
"""验证健康检查。"""
client.request("GET", "/health")
resp = client.getresponse()
assert resp.status == 200
data = json.loads(resp.read())
assert data["status"] == "ok"
def test_create_rule(client):
"""验证创建规则。"""
body = json.dumps({
"name": "test_rule",
"description": "测试规则",
"condition_template": "如果用户是会员则打折"
})
client.request("POST", "/api/rules", body=body, headers={"Content-Type": "application/json"})
resp = client.getresponse()
assert resp.status == 201
data = json.loads(resp.read())
assert data["name"] == "test_rule"
assert "id" in data
def test_create_rule_missing_fields(client):
"""验证缺少必填字段返回错误。"""
body = json.dumps({"name": "only_name"})
client.request("POST", "/api/rules", body=body, headers={"Content-Type": "application/json"})
resp = client.getresponse()
assert resp.status == 400
def test_get_rule(client):
"""验证获取规则。"""
# 先创建
body = json.dumps({"name": "get_test", "condition_template": "test"})
client.request("POST", "/api/rules", body=body, headers={"Content-Type": "application/json"})
resp = client.getresponse()
data = json.loads(resp.read())
rule_id = data["id"]
# 再获取
client.request("GET", f"/api/rules/{rule_id}")
resp = client.getresponse()
data = json.loads(resp.read())
assert data["name"] == "get_test"
def test_get_rule_not_found(client):
"""验证获取不存在的规则。"""
client.request("GET", "/api/rules/nonexistent")
resp = client.getresponse()
assert resp.status == 404
def test_list_rules(client):
"""验证列出规则。"""
# 创建两条规则
for name in ["list_r1", "list_r2"]:
body = json.dumps({"name": name, "condition_template": "test"})
client.request("POST", "/api/rules", body=body, headers={"Content-Type": "application/json"})
client.getresponse()
# 列出
client.request("GET", "/api/rules")
resp = client.getresponse()
assert resp.status == 200
data = json.loads(resp.read())
assert "rules" in data
assert len(data["rules"]) >= 2
def test_delete_rule(client):
"""验证删除规则。"""
# 先创建
body = json.dumps({"name": "delete_test", "condition_template": "test"})
client.request("POST", "/api/rules", body=body, headers={"Content-Type": "application/json"})
resp = client.getresponse()
rule_id = json.loads(resp.read())["id"]
# 删除
client.request("DELETE", f"/api/rules/{rule_id}")
resp = client.getresponse()
assert resp.status == 200
# 确认已删除
client.request("GET", f"/api/rules/{rule_id}")
resp = client.getresponse()
assert resp.status == 404
def test_evaluate_not_implemented(client):
"""验证 evaluate 接口返回 placeholder。"""
body = json.dumps({"facts": {"user_id": "u123"}})
client.request("POST", "/api/rules/evaluate", body=body, headers={"Content-Type": "application/json"})
resp = client.getresponse()
assert resp.status == 200
data = json.loads(resp.read())
assert data["matched"] is False
assert "Executor not implemented" in data["message"]
+94
View File
@@ -0,0 +1,94 @@
"""Tests for LLM compiler."""
import pytest
from rule_engine.compiler import (
build_compile_prompt,
extract_code_block,
RuleCompiler,
mock_llm_response
)
def test_build_compile_prompt():
"""验证 prompt 模板构建。"""
prompt = build_compile_prompt("如果用户是会员则打折")
assert "如果用户是会员则打折" in prompt
assert "def rule(facts: dict)" in prompt
def test_extract_code_block_with_python():
"""验证从 markdown 代码块提取 Python 代码。"""
text = '''这是一些解释文字
```python
def rule(facts: dict) -> dict:
if facts.get("subscription") == "premium":
return {"action": "discount"}
return None
```
更多文字
'''
code = extract_code_block(text)
assert code is not None
assert 'def rule(facts: dict)' in code
assert 'subscription' in code
def test_extract_code_block_without_language():
"""验证不带语言标识的代码块。"""
text = '''
```
def rule(facts):
return None
```
'''
code = extract_code_block(text)
assert code is not None
assert 'def rule' in code
def test_extract_code_block_plain():
"""验证纯代码(无代码块)。"""
code = 'def rule(facts):\n return None'
result = extract_code_block(code)
assert result == code
def test_extract_code_block_invalid():
"""验证无效输入返回 None。"""
assert extract_code_block("这是一个普通文本") is None
assert extract_code_block("") is None
def test_mock_llm_response_premium():
"""验证 mock 响应生成(premium 场景)。"""
code = mock_llm_response("如果用户是 premium 会员")
assert "premium" in code
assert "def rule" in code
def test_mock_llm_response_default():
"""验证 mock 响应生成(默认场景)。"""
code = mock_llm_response("普通规则")
assert "def rule" in code
def test_rule_compiler_validate_syntax_valid():
"""验证语法检查通过。"""
compiler = RuleCompiler()
code = 'def rule(facts):\n return None'
assert compiler.validate_syntax(code) is True
def test_rule_compiler_validate_syntax_invalid():
"""验证语法检查失败。"""
compiler = RuleCompiler()
code = 'def rule(facts):\n return None\n\nextra invalid'
assert compiler.validate_syntax(code) is False
def test_rule_compiler_validate_syntax_syntax_error():
"""验证语法错误检测。"""
compiler = RuleCompiler()
code = 'def rule(facts):\n if .'
assert compiler.validate_syntax(code) is False
+73
View File
@@ -0,0 +1,73 @@
"""Tests for conflict detector."""
import pytest
from rule_engine.conflict import ConflictDetector
@pytest.fixture
def detector():
return ConflictDetector()
def test_no_conflict_different_actions(detector):
"""验证不同动作的规则不冲突。"""
rules = [
{"id": "r1", "name": "rule1", "code": 'def rule(f):\n if f.get("a") == 1:\n return {"action": "allow"}\n return None', "priority": 1, "is_active": True},
{"id": "r2", "name": "rule2", "code": 'def rule(f):\n if f.get("b") == 1:\n return {"action": "discount"}\n return None', "priority": 1, "is_active": True},
]
conflicts = detector.detect_conflicts(rules)
assert len(conflicts) == 0
def test_conflict_opposite_actions_same_priority(detector):
"""验证优先级相同的相反动作规则冲突。"""
rules = [
{"id": "r1", "name": "allow_rule", "code": 'def rule(f):\n if f.get("type") == "vip":\n return {"action": "allow"}\n return None', "priority": 1, "is_active": True},
{"id": "r2", "name": "deny_rule", "code": 'def rule(f):\n if f.get("type") == "vip":\n return {"action": "deny"}\n return None', "priority": 1, "is_active": True},
]
conflicts = detector.detect_conflicts(rules)
assert len(conflicts) == 1
assert conflicts[0]["requires_resolution"] is True
def test_no_conflict_different_priority(detector):
"""验证优先级不同的规则不冲突(高优先级覆盖低优先级)。"""
rules = [
{"id": "r1", "name": "allow_rule", "code": 'def rule(f):\n if f.get("type") == "vip":\n return {"action": "allow"}\n return None', "priority": 2, "is_active": True},
{"id": "r2", "name": "deny_rule", "code": 'def rule(f):\n if f.get("type") == "vip":\n return {"action": "deny"}\n return None', "priority": 1, "is_active": True},
]
conflicts = detector.detect_conflicts(rules)
assert len(conflicts) == 0
def test_conflict_inactive_rules_ignored(detector):
"""验证非活跃规则不参与冲突检测。"""
rules = [
{"id": "r1", "name": "allow_rule", "code": 'def rule(f):\n return {"action": "allow"}', "priority": 1, "is_active": True},
{"id": "r2", "name": "deny_rule", "code": 'def rule(f):\n return {"action": "deny"}', "priority": 1, "is_active": False},
]
conflicts = detector.detect_conflicts(rules)
assert len(conflicts) == 0
def test_check_rule_with_existing(detector):
"""验证新规则与现有规则检查。"""
existing = [
{"id": "r1", "name": "allow", "code": 'def rule(f):\n return {"action": "allow"}', "priority": 1, "is_active": True},
]
new_rule = {"id": "r2", "name": "deny", "code": 'def rule(f):\n return {"action": "deny"}', "priority": 1, "is_active": True}
conflicts = detector.check_rule_with_existing(new_rule, existing)
assert len(conflicts) == 1
def test_extract_returns(detector):
"""验证返回值提取。"""
code = 'def rule(f):\n if f.get("x"):\n return {"action": "allow"}\n return None'
returns = detector._extract_returns(code)
assert len(returns) == 2
def test_has_opposite_actions(detector):
"""验证相反动作检测。"""
assert detector._has_opposite_actions(['"allow"', '"ok"'], ['"deny"']) is True
assert detector._has_opposite_actions(['"allow"'], ['"allow"']) is False
assert detector._has_opposite_actions(['"discount"'], ['"None"']) is False
+110
View File
@@ -0,0 +1,110 @@
"""Tests for rule executor."""
import pytest
from rule_engine.executor import RuleExecutor, Sandbox, ExecutionTimeout
def test_executor_simple_rule():
"""验证简单规则执行。"""
executor = RuleExecutor()
code = '''
def rule(facts):
if facts.get("subscription") == "premium":
return {"action": "discount", "rate": 0.8}
return None
'''
# 匹配
result = executor.execute_rule(code, {"subscription": "premium", "age": 25})
assert result == {"action": "discount", "rate": 0.8}
# 不匹配
result = executor.execute_rule(code, {"subscription": "basic", "age": 25})
assert result is None
def test_executor_complex_condition():
"""验证复杂条件规则。"""
executor = RuleExecutor()
code = '''
def rule(facts):
age = facts.get("age", 0)
subscription = facts.get("subscription")
if subscription == "premium" and age >= 18:
return {"action": "approve"}
return {"action": "deny"}
'''
result = executor.execute_rule(code, {"subscription": "premium", "age": 25})
assert result["action"] == "approve"
result = executor.execute_rule(code, {"subscription": "premium", "age": 16})
assert result["action"] == "deny"
result = executor.execute_rule(code, {"subscription": "basic", "age": 25})
assert result["action"] == "deny"
def test_executor_validate_rule_code_valid():
"""验证合法代码通过检查。"""
executor = RuleExecutor()
code = 'def rule(facts):\n return None'
assert executor.validate_rule_code(code) is True
def test_executor_validate_rule_code_blocked_keyword():
"""验证危险关键字被拦截。"""
executor = RuleExecutor()
assert executor.validate_rule_code('def rule(facts):\n import os') is False
assert executor.validate_rule_code('def rule(facts):\n exec("")') is False
assert executor.validate_rule_code('def rule(facts):\n eval("")') is False
def test_executor_validate_rule_code_syntax_error():
"""验证语法错误被检测。"""
executor = RuleExecutor()
assert executor.validate_rule_code('def rule(facts):\n if .') is False
def test_executor_timeout():
"""验证执行超时。"""
executor = RuleExecutor(timeout_ms=100)
code = '''
def rule(facts):
# 死循环
while True:
pass
return None
'''
with pytest.raises(RuntimeError) as exc_info:
executor.execute_rule(code, {})
assert "timed out" in str(exc_info.value)
def test_sandbox_blocks_dangerous_operations():
"""验证沙箱拦截危险操作。"""
executor = RuleExecutor()
# 尝试访问受保护属性
code = '''
def rule(facts):
return __builtins__
'''
# 注意:实际 exec 中 __builtins__ 已被替换为白名单
# 所以不会返回真正的 builtins
def test_executor_nested_data():
"""验证嵌套数据结构处理。"""
executor = RuleExecutor()
code = '''
def rule(facts):
user = facts.get("user", {})
if user.get("subscription") == "premium" and user.get("active"):
return {"action": "allow"}
return None
'''
facts = {
"user": {
"subscription": "premium",
"active": True
}
}
result = executor.execute_rule(code, facts)
assert result["action"] == "allow"
+102
View File
@@ -0,0 +1,102 @@
"""Tests for rule matcher."""
import pytest
import os
import tempfile
from rule_engine.matcher import RuleMatcher
from rule_engine.store import RuleStore
from rule_engine.executor import RuleExecutor
@pytest.fixture
def temp_db():
fd, path = tempfile.mkstemp(suffix=".db")
os.close(fd)
yield path
os.unlink(path)
@pytest.fixture
def store(temp_db):
return RuleStore(temp_db)
@pytest.fixture
def executor():
return RuleExecutor(timeout_ms=100)
@pytest.fixture
def matcher(store, executor):
return RuleMatcher(store, executor)
def test_find_matching_rule_by_id(matcher, store):
"""验证按 ID 查找匹配规则。"""
rule = store.create_rule(
name="test",
condition_template="premium",
code='def rule(facts):\n if facts.get("sub") == "premium":\n return {"action": "ok"}\n return None'
)
# 匹配
rule_id, result = matcher.find_matching_rule({"sub": "premium"}, rule_id=rule.id)
assert rule_id == rule.id
assert result == {"action": "ok"}
# 不匹配
rule_id, result = matcher.find_matching_rule({"sub": "basic"}, rule_id=rule.id)
assert rule_id is None
def test_find_matching_rule_all_active(matcher, store):
"""验证匹配所有活跃规则。"""
# 创建两条规则
rule1 = store.create_rule(
name="rule1",
condition_template="c1",
code='def rule(facts):\n if facts.get("type") == "a":\n return {"action": "a"}\n return None',
priority=1
)
rule2 = store.create_rule(
name="rule2",
condition_template="c2",
code='def rule(facts):\n if facts.get("type") == "b":\n return {"action": "b"}\n return None',
priority=2
)
# 匹配 rule2(优先级更高)
rule_id, result = matcher.find_matching_rule({"type": "b"})
assert rule_id == rule2.id
assert result["action"] == "b"
# 匹配 rule1
rule_id, result = matcher.find_matching_rule({"type": "a"})
assert rule_id == rule1.id
def test_find_matching_rule_no_match(matcher, store):
"""验证无匹配时返回 None。"""
store.create_rule(
name="nomatch",
condition_template="c1",
code='def rule(facts):\n return None'
)
rule_id, result = matcher.find_matching_rule({"type": "c"})
assert rule_id is None
assert result is None
def test_find_matching_rule_inactive_rule(matcher, store):
"""验证不匹配非活跃规则。"""
rule = store.create_rule(
name="inactive",
condition_template="c1",
code='def rule(facts):\n return {"action": "ok"}'
)
# 手动设置为非活跃(通过直接操作)
store.delete_rule(rule.id)
rule_id, result = matcher.find_matching_rule({"type": "anything"})
assert rule_id is None
+79
View File
@@ -0,0 +1,79 @@
"""Tests for data models."""
import pytest
from rule_engine.models import Rule, RuleExecution, CreateRuleRequest, EvaluateRequest, EvaluateResponse
def test_create_rule_request_valid():
"""验证创建规则的请求可以正确解析。"""
request = CreateRuleRequest(
name="test_rule",
description="测试规则",
condition_template="用户 {{user_id}} 年龄大于 {{age}}"
)
assert request.name == "test_rule"
assert request.description == "测试规则"
assert "{{user_id}}" in request.condition_template
def test_create_rule_request_minimal():
"""验证最小请求只需必填字段。"""
request = CreateRuleRequest(
name="minimal_rule",
condition_template="如果用户是会员则打折"
)
assert request.name == "minimal_rule"
assert request.priority == 0
def test_rule_model():
"""验证规则模型包含所有必要字段。"""
rule = Rule(
id="rule_001",
name="premium_discount",
description="高级会员8折",
condition_template="用户是高级会员",
code="def rule_001(facts):\n if facts.get('subscription') == 'premium':\n return {'action': 'discount', 'rate': 0.8}\n return None"
)
assert rule.id == "rule_001"
assert rule.priority == 0
assert "premium" in rule.code
def test_rule_to_dict():
"""验证规则可以序列化为字典。"""
rule = Rule(
id="rule_001",
name="test",
condition_template="test",
code="def r(f): pass"
)
d = rule.to_dict()
assert d["id"] == "rule_001"
assert d["name"] == "test"
def test_rule_execution_model():
"""验证规则执行记录模型。"""
execution = RuleExecution(
id="exec_001",
rule_id="rule_001",
facts={"user_id": "u123", "subscription": "premium"},
result={"action": "discount", "rate": 0.8},
matched=True
)
assert execution.matched is True
assert execution.rule_id == "rule_001"
def test_evaluate_request():
"""验证校验请求模型。"""
req = EvaluateRequest(facts={"user_id": "u123"})
assert req.rule_id is None
assert req.facts["user_id"] == "u123"
def test_evaluate_response():
"""验证校验响应模型。"""
resp = EvaluateResponse(matched=True, rule_id="rule_001", result={"action": "ok"})
assert resp.matched is True
assert resp.conflict_warning is None
+107
View File
@@ -0,0 +1,107 @@
"""Tests for SQLite store."""
import pytest
import os
import tempfile
from rule_engine.store import RuleStore
@pytest.fixture
def temp_db():
"""创建临时数据库。"""
fd, path = tempfile.mkstemp(suffix=".db")
os.close(fd)
yield path
os.unlink(path)
@pytest.fixture
def store(temp_db):
"""创建规则存储实例。"""
return RuleStore(temp_db)
def test_init_creates_tables(store):
"""验证初始化时创建表。"""
# 表已创建,无异常即通过
assert store.db_path is not None
def test_create_rule(store):
"""验证创建规则。"""
rule = store.create_rule(
name="test_rule",
condition_template="用户是会员",
code="def rule(facts): return {'action': 'ok'}"
)
assert rule.id is not None
assert rule.name == "test_rule"
assert rule.version == 1
def test_get_rule(store):
"""验证获取规则。"""
created = store.create_rule(
name="get_test",
condition_template="测试获取",
code="def rule(facts): return None"
)
fetched = store.get_rule(created.id)
assert fetched is not None
assert fetched.id == created.id
assert fetched.name == "get_test"
def test_get_rule_not_found(store):
"""验证获取不存在的规则返回None。"""
result = store.get_rule("nonexistent")
assert result is None
def test_list_rules(store):
"""验证列出所有规则。"""
store.create_rule(name="r1", condition_template="c1", code="def r(f): pass")
store.create_rule(name="r2", condition_template="c2", code="def r(f): pass")
rules = store.list_rules()
assert len(rules) >= 2
def test_delete_rule(store):
"""验证删除规则。"""
created = store.create_rule(
name="delete_test",
condition_template="删除测试",
code="def rule(facts): return None"
)
result = store.delete_rule(created.id)
assert result is True
assert store.get_rule(created.id) is None
def test_update_rule_code(store):
"""验证更新规则代码。"""
created = store.create_rule(
name="update_test",
condition_template="更新测试",
code="def rule(facts): return None"
)
updated = store.update_rule_code(created.id, "def rule(f): return {'updated': True}")
assert updated is not None
assert "updated" in updated.code
assert updated.version == 2
def test_record_execution(store):
"""验证记录执行历史。"""
rule = store.create_rule(
name="exec_test",
condition_template="执行测试",
code="def rule(facts): return None"
)
execution = store.record_execution(
rule_id=rule.id,
facts={"test": "data"},
result={"action": "ok"},
matched=True
)
assert execution.id is not None
assert execution.rule_id == rule.id