542 lines
22 KiB
Python
542 lines
22 KiB
Python
"""
|
||
Tests for Slot Validation Service.
|
||
槽位校验服务单元测试
|
||
"""
|
||
|
||
import pytest
|
||
|
||
from app.services.mid.slot_validation_service import (
|
||
SlotValidationService,
|
||
SlotValidationErrorCode,
|
||
ValidationResult,
|
||
SlotValidationError,
|
||
BatchValidationResult,
|
||
)
|
||
|
||
|
||
class TestSlotValidationService:
|
||
"""槽位校验服务测试类"""
|
||
|
||
@pytest.fixture
|
||
def service(self):
|
||
"""创建校验服务实例"""
|
||
return SlotValidationService()
|
||
|
||
@pytest.fixture
|
||
def string_slot_def(self):
|
||
"""字符串类型槽位定义"""
|
||
return {
|
||
"slot_key": "name",
|
||
"type": "string",
|
||
"required": False,
|
||
"validation_rule": None,
|
||
"ask_back_prompt": "请输入您的姓名",
|
||
}
|
||
|
||
@pytest.fixture
|
||
def required_string_slot_def(self):
|
||
"""必填字符串类型槽位定义"""
|
||
return {
|
||
"slot_key": "phone",
|
||
"type": "string",
|
||
"required": True,
|
||
"validation_rule": r"^1[3-9]\d{9}$",
|
||
"ask_back_prompt": "请输入正确的手机号码",
|
||
}
|
||
|
||
@pytest.fixture
|
||
def number_slot_def(self):
|
||
"""数字类型槽位定义"""
|
||
return {
|
||
"slot_key": "age",
|
||
"type": "number",
|
||
"required": False,
|
||
"validation_rule": None,
|
||
"ask_back_prompt": "请输入年龄",
|
||
}
|
||
|
||
@pytest.fixture
|
||
def boolean_slot_def(self):
|
||
"""布尔类型槽位定义"""
|
||
return {
|
||
"slot_key": "is_student",
|
||
"type": "boolean",
|
||
"required": False,
|
||
"validation_rule": None,
|
||
"ask_back_prompt": "是否是学生？",
|
||
}
|
||
|
||
@pytest.fixture
|
||
def enum_slot_def(self):
|
||
"""枚举类型槽位定义"""
|
||
return {
|
||
"slot_key": "grade",
|
||
"type": "enum",
|
||
"required": False,
|
||
"options": ["初一", "初二", "初三", "高一", "高二", "高三"],
|
||
"validation_rule": None,
|
||
"ask_back_prompt": "请选择年级",
|
||
}
|
||
|
||
@pytest.fixture
|
||
def array_enum_slot_def(self):
|
||
"""数组枚举类型槽位定义"""
|
||
return {
|
||
"slot_key": "subjects",
|
||
"type": "array_enum",
|
||
"required": False,
|
||
"options": ["语文", "数学", "英语", "物理", "化学"],
|
||
"validation_rule": None,
|
||
"ask_back_prompt": "请选择学科",
|
||
}
|
||
|
||
@pytest.fixture
|
||
def json_schema_slot_def(self):
|
||
"""JSON Schema 校验槽位定义"""
|
||
return {
|
||
"slot_key": "email",
|
||
"type": "string",
|
||
"required": True,
|
||
"validation_rule": '{"type": "string", "format": "email"}',
|
||
"ask_back_prompt": "请输入有效的邮箱地址",
|
||
}
|
||
|
||
class TestBasicValidation:
|
||
"""基础校验测试"""
|
||
|
||
def test_empty_validation_rule(self, service, string_slot_def):
|
||
"""测试空校验规则（应通过）"""
|
||
string_slot_def["validation_rule"] = None
|
||
result = service.validate_slot_value(string_slot_def, "test")
|
||
assert result.ok is True
|
||
assert result.normalized_value == "test"
|
||
|
||
def test_whitespace_validation_rule(self, service, string_slot_def):
|
||
"""测试空白校验规则（应通过）"""
|
||
string_slot_def["validation_rule"] = " "
|
||
result = service.validate_slot_value(string_slot_def, "test")
|
||
assert result.ok is True
|
||
|
||
def test_no_slot_definition(self, service):
|
||
"""测试无槽位定义（动态槽位）"""
|
||
# 使用最小定义
|
||
minimal_def = {"slot_key": "dynamic_field"}
|
||
result = service.validate_slot_value(minimal_def, "any_value")
|
||
assert result.ok is True
|
||
|
||
class TestRegexValidation:
|
||
"""正则表达式校验测试"""
|
||
|
||
def test_regex_match(self, service, required_string_slot_def):
|
||
"""测试正则匹配成功"""
|
||
result = service.validate_slot_value(
|
||
required_string_slot_def, "13800138000"
|
||
)
|
||
assert result.ok is True
|
||
assert result.normalized_value == "13800138000"
|
||
|
||
def test_regex_mismatch(self, service, required_string_slot_def):
|
||
"""测试正则匹配失败"""
|
||
result = service.validate_slot_value(
|
||
required_string_slot_def, "invalid_phone"
|
||
)
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_REGEX_MISMATCH
|
||
assert result.ask_back_prompt == "请输入正确的手机号码"
|
||
|
||
def test_regex_invalid_pattern(self, service, string_slot_def):
|
||
"""测试非法正则表达式"""
|
||
string_slot_def["validation_rule"] = "[invalid("
|
||
result = service.validate_slot_value(string_slot_def, "test")
|
||
assert result.ok is False
|
||
assert (
|
||
result.error_code
|
||
== SlotValidationErrorCode.SLOT_VALIDATION_RULE_INVALID
|
||
)
|
||
|
||
def test_regex_with_chinese(self, service, string_slot_def):
|
||
"""测试包含中文的正则"""
|
||
string_slot_def["validation_rule"] = r"^[\u4e00-\u9fa5]{2,4}$"
|
||
result = service.validate_slot_value(string_slot_def, "张三")
|
||
assert result.ok is True
|
||
|
||
result = service.validate_slot_value(string_slot_def, "John")
|
||
assert result.ok is False
|
||
|
||
class TestJsonSchemaValidation:
|
||
"""JSON Schema 校验测试"""
|
||
|
||
def test_json_schema_match(self, service):
|
||
"""测试 JSON Schema 匹配成功"""
|
||
slot_def = {
|
||
"slot_key": "config",
|
||
"type": "object",
|
||
"validation_rule": '{"type": "object", "properties": {"name": {"type": "string"}}}',
|
||
}
|
||
result = service.validate_slot_value(slot_def, {"name": "test"})
|
||
assert result.ok is True
|
||
|
||
def test_json_schema_mismatch(self, service):
|
||
"""测试 JSON Schema 匹配失败"""
|
||
slot_def = {
|
||
"slot_key": "count",
|
||
"type": "number",
|
||
"validation_rule": '{"type": "integer", "minimum": 0, "maximum": 100}',
|
||
"ask_back_prompt": "请输入0-100之间的整数",
|
||
}
|
||
result = service.validate_slot_value(slot_def, 150)
|
||
assert result.ok is False
|
||
assert (
|
||
result.error_code == SlotValidationErrorCode.SLOT_JSON_SCHEMA_MISMATCH
|
||
)
|
||
assert result.ask_back_prompt == "请输入0-100之间的整数"
|
||
|
||
def test_json_schema_invalid_json(self, service, string_slot_def):
|
||
"""测试非法 JSON Schema"""
|
||
string_slot_def["validation_rule"] = "{invalid json}"
|
||
result = service.validate_slot_value(string_slot_def, "test")
|
||
assert result.ok is False
|
||
assert (
|
||
result.error_code
|
||
== SlotValidationErrorCode.SLOT_VALIDATION_RULE_INVALID
|
||
)
|
||
|
||
def test_json_schema_array(self, service):
|
||
"""测试数组类型的 JSON Schema"""
|
||
slot_def = {
|
||
"slot_key": "items",
|
||
"type": "array",
|
||
"validation_rule": '{"type": "array", "items": {"type": "string"}}',
|
||
}
|
||
result = service.validate_slot_value(slot_def, ["a", "b", "c"])
|
||
assert result.ok is True
|
||
|
||
result = service.validate_slot_value(slot_def, [1, 2, 3])
|
||
assert result.ok is False
|
||
|
||
class TestRequiredValidation:
|
||
"""必填校验测试"""
|
||
|
||
def test_required_missing_none(self, service, required_string_slot_def):
|
||
"""测试必填字段为 None"""
|
||
result = service.validate_slot_value(
|
||
required_string_slot_def, None
|
||
)
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_REQUIRED_MISSING
|
||
|
||
def test_required_missing_empty_string(self, service, required_string_slot_def):
|
||
"""测试必填字段为空字符串"""
|
||
result = service.validate_slot_value(required_string_slot_def, "")
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_REQUIRED_MISSING
|
||
|
||
def test_required_missing_whitespace(self, service, required_string_slot_def):
|
||
"""测试必填字段为空白字符"""
|
||
result = service.validate_slot_value(required_string_slot_def, " ")
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_REQUIRED_MISSING
|
||
|
||
def test_required_present(self, service, required_string_slot_def):
|
||
"""测试必填字段有值"""
|
||
result = service.validate_slot_value(
|
||
required_string_slot_def, "13800138000"
|
||
)
|
||
assert result.ok is True
|
||
|
||
def test_not_required_empty(self, service, string_slot_def):
|
||
"""测试非必填字段为空"""
|
||
result = service.validate_slot_value(string_slot_def, "")
|
||
assert result.ok is True
|
||
|
||
class TestTypeValidation:
|
||
"""类型校验测试"""
|
||
|
||
def test_string_type(self, service, string_slot_def):
|
||
"""测试字符串类型"""
|
||
result = service.validate_slot_value(string_slot_def, "hello")
|
||
assert result.ok is True
|
||
assert result.normalized_value == "hello"
|
||
|
||
def test_string_type_conversion(self, service, string_slot_def):
|
||
"""测试字符串类型自动转换"""
|
||
result = service.validate_slot_value(string_slot_def, 123)
|
||
assert result.ok is True
|
||
assert result.normalized_value == "123"
|
||
|
||
def test_number_type_integer(self, service, number_slot_def):
|
||
"""测试数字类型 - 整数"""
|
||
result = service.validate_slot_value(number_slot_def, 25)
|
||
assert result.ok is True
|
||
assert result.normalized_value == 25
|
||
|
||
def test_number_type_float(self, service, number_slot_def):
|
||
"""测试数字类型 - 浮点数"""
|
||
result = service.validate_slot_value(number_slot_def, 25.5)
|
||
assert result.ok is True
|
||
assert result.normalized_value == 25.5
|
||
|
||
def test_number_type_string_conversion(self, service, number_slot_def):
|
||
"""测试数字类型 - 字符串转换"""
|
||
result = service.validate_slot_value(number_slot_def, "30")
|
||
assert result.ok is True
|
||
assert result.normalized_value == 30
|
||
|
||
def test_number_type_invalid(self, service, number_slot_def):
|
||
"""测试数字类型 - 无效值"""
|
||
result = service.validate_slot_value(number_slot_def, "not_a_number")
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_TYPE_INVALID
|
||
|
||
def test_number_type_reject_boolean(self, service, number_slot_def):
|
||
"""测试数字类型 - 拒绝布尔值"""
|
||
result = service.validate_slot_value(number_slot_def, True)
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_TYPE_INVALID
|
||
|
||
def test_boolean_type_true(self, service, boolean_slot_def):
|
||
"""测试布尔类型 - True"""
|
||
result = service.validate_slot_value(boolean_slot_def, True)
|
||
assert result.ok is True
|
||
assert result.normalized_value is True
|
||
|
||
def test_boolean_type_false(self, service, boolean_slot_def):
|
||
"""测试布尔类型 - False"""
|
||
result = service.validate_slot_value(boolean_slot_def, False)
|
||
assert result.ok is True
|
||
assert result.normalized_value is False
|
||
|
||
def test_boolean_type_string_true(self, service, boolean_slot_def):
|
||
"""测试布尔类型 - 字符串 true"""
|
||
result = service.validate_slot_value(boolean_slot_def, "true")
|
||
assert result.ok is True
|
||
assert result.normalized_value is True
|
||
|
||
def test_boolean_type_string_yes(self, service, boolean_slot_def):
|
||
"""测试布尔类型 - 字符串 yes/是"""
|
||
result = service.validate_slot_value(boolean_slot_def, "是")
|
||
assert result.ok is True
|
||
assert result.normalized_value is True
|
||
|
||
def test_boolean_type_string_false(self, service, boolean_slot_def):
|
||
"""测试布尔类型 - 字符串 false"""
|
||
result = service.validate_slot_value(boolean_slot_def, "false")
|
||
assert result.ok is True
|
||
assert result.normalized_value is False
|
||
|
||
def test_boolean_type_invalid(self, service, boolean_slot_def):
|
||
"""测试布尔类型 - 无效值"""
|
||
result = service.validate_slot_value(boolean_slot_def, "maybe")
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_TYPE_INVALID
|
||
|
||
def test_enum_type_valid(self, service, enum_slot_def):
|
||
"""测试枚举类型 - 有效值"""
|
||
result = service.validate_slot_value(enum_slot_def, "高一")
|
||
assert result.ok is True
|
||
assert result.normalized_value == "高一"
|
||
|
||
def test_enum_type_invalid(self, service, enum_slot_def):
|
||
"""测试枚举类型 - 无效值"""
|
||
result = service.validate_slot_value(enum_slot_def, "大一")
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_ENUM_INVALID
|
||
|
||
def test_enum_type_not_string(self, service, enum_slot_def):
|
||
"""测试枚举类型 - 非字符串"""
|
||
result = service.validate_slot_value(enum_slot_def, 123)
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_TYPE_INVALID
|
||
|
||
def test_array_enum_type_valid(self, service, array_enum_slot_def):
|
||
"""测试数组枚举类型 - 有效值"""
|
||
result = service.validate_slot_value(
|
||
array_enum_slot_def, ["语文", "数学"]
|
||
)
|
||
assert result.ok is True
|
||
|
||
def test_array_enum_type_invalid_item(self, service, array_enum_slot_def):
|
||
"""测试数组枚举类型 - 无效元素"""
|
||
result = service.validate_slot_value(
|
||
array_enum_slot_def, ["语文", "生物"]
|
||
)
|
||
assert result.ok is False
|
||
assert (
|
||
result.error_code == SlotValidationErrorCode.SLOT_ARRAY_ENUM_INVALID
|
||
)
|
||
|
||
def test_array_enum_type_not_array(self, service, array_enum_slot_def):
|
||
"""测试数组枚举类型 - 非数组"""
|
||
result = service.validate_slot_value(array_enum_slot_def, "语文")
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_TYPE_INVALID
|
||
|
||
def test_array_enum_type_non_string_item(self, service, array_enum_slot_def):
|
||
"""测试数组枚举类型 - 非字符串元素"""
|
||
result = service.validate_slot_value(array_enum_slot_def, ["语文", 123])
|
||
assert result.ok is False
|
||
assert (
|
||
result.error_code == SlotValidationErrorCode.SLOT_ARRAY_ENUM_INVALID
|
||
)
|
||
|
||
class TestBatchValidation:
|
||
"""批量校验测试"""
|
||
|
||
def test_batch_all_valid(self, service, string_slot_def, number_slot_def):
|
||
"""测试批量校验 - 全部通过"""
|
||
slot_defs = [string_slot_def, number_slot_def]
|
||
values = {"name": "张三", "age": 25}
|
||
result = service.validate_slots(slot_defs, values)
|
||
assert result.ok is True
|
||
assert len(result.errors) == 0
|
||
assert result.validated_values["name"] == "张三"
|
||
assert result.validated_values["age"] == 25
|
||
|
||
def test_batch_some_invalid(self, service, string_slot_def, number_slot_def):
|
||
"""测试批量校验 - 部分失败"""
|
||
slot_defs = [string_slot_def, number_slot_def]
|
||
values = {"name": "张三", "age": "not_a_number"}
|
||
result = service.validate_slots(slot_defs, values)
|
||
assert result.ok is False
|
||
assert len(result.errors) == 1
|
||
assert result.errors[0].slot_key == "age"
|
||
|
||
def test_batch_missing_required(
|
||
self, service, required_string_slot_def, string_slot_def
|
||
):
|
||
"""测试批量校验 - 缺失必填字段"""
|
||
slot_defs = [required_string_slot_def, string_slot_def]
|
||
values = {"name": "张三"} # 缺少 phone
|
||
result = service.validate_slots(slot_defs, values)
|
||
assert result.ok is False
|
||
assert len(result.errors) == 1
|
||
assert result.errors[0].slot_key == "phone"
|
||
assert (
|
||
result.errors[0].error_code
|
||
== SlotValidationErrorCode.SLOT_REQUIRED_MISSING
|
||
)
|
||
|
||
def test_batch_undefined_slot(self, service, string_slot_def):
|
||
"""测试批量校验 - 未定义槽位"""
|
||
slot_defs = [string_slot_def]
|
||
values = {"name": "张三", "undefined_field": "value"}
|
||
result = service.validate_slots(slot_defs, values)
|
||
assert result.ok is True
|
||
# 未定义槽位应允许通过
|
||
assert "undefined_field" in result.validated_values
|
||
|
||
class TestCombinedValidation:
|
||
"""组合校验测试（类型 + 正则/JSON Schema）"""
|
||
|
||
def test_type_and_regex_both_pass(self, service):
|
||
"""测试类型和正则都通过"""
|
||
slot_def = {
|
||
"slot_key": "code",
|
||
"type": "string",
|
||
"required": True,
|
||
"validation_rule": r"^[A-Z]{2}\d{4}$",
|
||
}
|
||
result = service.validate_slot_value(slot_def, "AB1234")
|
||
assert result.ok is True
|
||
|
||
def test_type_pass_regex_fail(self, service):
|
||
"""测试类型通过但正则失败"""
|
||
slot_def = {
|
||
"slot_key": "code",
|
||
"type": "string",
|
||
"required": True,
|
||
"validation_rule": r"^[A-Z]{2}\d{4}$",
|
||
}
|
||
result = service.validate_slot_value(slot_def, "ab1234")
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_REGEX_MISMATCH
|
||
|
||
def test_type_fail_no_regex_check(self, service):
|
||
"""测试类型失败时不执行正则校验"""
|
||
slot_def = {
|
||
"slot_key": "code",
|
||
"type": "number",
|
||
"required": True,
|
||
"validation_rule": r"^\d+$",
|
||
}
|
||
result = service.validate_slot_value(slot_def, "not_a_number")
|
||
assert result.ok is False
|
||
assert result.error_code == SlotValidationErrorCode.SLOT_TYPE_INVALID
|
||
|
||
class TestAskBackPrompt:
|
||
"""追问提示语测试"""
|
||
|
||
def test_ask_back_prompt_on_validation_fail(self, service):
|
||
"""测试校验失败时返回 ask_back_prompt"""
|
||
slot_def = {
|
||
"slot_key": "email",
|
||
"type": "string",
|
||
"required": True,
|
||
"validation_rule": r"^[\w\.-]+@[\w\.-]+\.\w+$",
|
||
"ask_back_prompt": "请输入有效的邮箱地址，如 example@domain.com",
|
||
}
|
||
result = service.validate_slot_value(slot_def, "invalid_email")
|
||
assert result.ok is False
|
||
assert result.ask_back_prompt == "请输入有效的邮箱地址，如 example@domain.com"
|
||
|
||
def test_no_ask_back_prompt_on_success(self, service, string_slot_def):
|
||
"""测试校验通过时不返回 ask_back_prompt"""
|
||
result = service.validate_slot_value(string_slot_def, "valid")
|
||
assert result.ok is True
|
||
assert result.ask_back_prompt is None
|
||
|
||
def test_ask_back_prompt_on_required_missing(self, service):
|
||
"""测试必填缺失时返回 ask_back_prompt"""
|
||
slot_def = {
|
||
"slot_key": "name",
|
||
"type": "string",
|
||
"required": True,
|
||
"ask_back_prompt": "请告诉我们您的姓名",
|
||
}
|
||
result = service.validate_slot_value(slot_def, "")
|
||
assert result.ok is False
|
||
assert result.ask_back_prompt == "请告诉我们您的姓名"
|
||
|
||
|
||
class TestSlotValidationErrorCode:
|
||
"""错误码测试"""
|
||
|
||
def test_error_code_values(self):
|
||
"""测试错误码值"""
|
||
assert SlotValidationErrorCode.SLOT_REQUIRED_MISSING == "SLOT_REQUIRED_MISSING"
|
||
assert SlotValidationErrorCode.SLOT_TYPE_INVALID == "SLOT_TYPE_INVALID"
|
||
assert SlotValidationErrorCode.SLOT_REGEX_MISMATCH == "SLOT_REGEX_MISMATCH"
|
||
assert (
|
||
SlotValidationErrorCode.SLOT_JSON_SCHEMA_MISMATCH
|
||
== "SLOT_JSON_SCHEMA_MISMATCH"
|
||
)
|
||
assert (
|
||
SlotValidationErrorCode.SLOT_VALIDATION_RULE_INVALID
|
||
== "SLOT_VALIDATION_RULE_INVALID"
|
||
)
|
||
|
||
|
||
class TestValidationResult:
|
||
"""ValidationResult 测试"""
|
||
|
||
def test_success_result(self):
|
||
"""测试成功结果"""
|
||
result = ValidationResult(ok=True, normalized_value="test")
|
||
assert result.ok is True
|
||
assert result.normalized_value == "test"
|
||
assert result.error_code is None
|
||
assert result.error_message is None
|
||
|
||
def test_failure_result(self):
|
||
"""测试失败结果"""
|
||
result = ValidationResult(
|
||
ok=False,
|
||
error_code="SLOT_REGEX_MISMATCH",
|
||
error_message="格式不正确",
|
||
ask_back_prompt="请重新输入",
|
||
)
|
||
assert result.ok is False
|
||
assert result.error_code == "SLOT_REGEX_MISMATCH"
|
||
assert result.error_message == "格式不正确"
|
||
assert result.ask_back_prompt == "请重新输入"
|