import pytest
from apitest.models.test_models import TestCase, HTTPMethod, PerformanceMetrics
from apitest.core.validation_engine import ValidationEngine
from apitest.models.exceptions import ValidationException


class TestValidationEngine:
    """测试ValidationEngine验证引擎"""

    @pytest.fixture
    def validation_engine(self):
        """创建验证引擎实例"""
        return ValidationEngine()

    def test_validate_status_code_success(self, validation_engine):
        """测试状态码验证成功"""
        test_case = TestCase(
            id="TC001",
            name="测试状态码",
            description="测试状态码验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "status_code", "value": 200}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"message": "success"},
            {}
        )
        
        assert passed == True
        assert error == ""

    def test_validate_status_code_failure(self, validation_engine):
        """测试状态码验证失败"""
        test_case = TestCase(
            id="TC001",
            name="测试状态码",
            description="测试状态码验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "status_code", "value": 200}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            404,
            {"message": "not found"},
            {}
        )
        
        assert passed == False
        assert "状态码验证失败" in error

    def test_validate_contains_success(self, validation_engine):
        """测试包含验证成功"""
        test_case = TestCase(
            id="TC002",
            name="测试包含",
            description="测试包含验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "contains", "value": "success"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"message": "operation success"},
            {}
        )
        
        assert passed == True
        assert error == ""

    def test_validate_contains_failure(self, validation_engine):
        """测试包含验证失败"""
        test_case = TestCase(
            id="TC002",
            name="测试包含",
            description="测试包含验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "contains", "value": "error"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"message": "operation success"},
            {}
        )
        
        assert passed == False
        assert "包含验证失败" in error

    def test_validate_contains_with_field(self, validation_engine):
        """测试字段包含验证"""
        test_case = TestCase(
            id="TC003",
            name="测试字段包含",
            description="测试字段包含验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "contains", "field": "message", "value": "success"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"message": "operation success"},
            {}
        )
        
        assert passed == True

    def test_validate_equals_success(self, validation_engine):
        """测试相等验证成功"""
        test_case = TestCase(
            id="TC004",
            name="测试相等",
            description="测试相等验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "equals", "field": "status", "value": "ok"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"status": "ok"},
            {}
        )
        
        assert passed == True

    def test_validate_equals_failure(self, validation_engine):
        """测试相等验证失败"""
        test_case = TestCase(
            id="TC004",
            name="测试相等",
            description="测试相等验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "equals", "field": "status", "value": "ok"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"status": "error"},
            {}
        )
        
        assert passed == False
        assert "相等验证失败" in error

    def test_validate_json_path_success(self, validation_engine):
        """测试JSON路径验证成功"""
        test_case = TestCase(
            id="TC005",
            name="测试JSON路径",
            description="测试JSON路径验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "json_path", "path": "data.user.name", "value": "John"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"data": {"user": {"name": "John"}}},
            {}
        )
        
        assert passed == True

    def test_validate_json_path_failure(self, validation_engine):
        """测试JSON路径验证失败"""
        test_case = TestCase(
            id="TC005",
            name="测试JSON路径",
            description="测试JSON路径验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "json_path", "path": "data.user.name", "value": "Jane"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"data": {"user": {"name": "John"}}},
            {}
        )
        
        assert passed == False
        assert "JSON路径验证失败" in error

    def test_validate_regex_success(self, validation_engine):
        """测试正则表达式验证成功"""
        test_case = TestCase(
            id="TC006",
            name="测试正则表达式",
            description="测试正则表达式验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "regex", "field": "email", "pattern": r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"email": "test@example.com"},
            {}
        )
        
        assert passed == True

    def test_validate_regex_failure(self, validation_engine):
        """测试正则表达式验证失败"""
        test_case = TestCase(
            id="TC006",
            name="测试正则表达式",
            description="测试正则表达式验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "regex", "field": "email", "pattern": r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"email": "invalid-email"},
            {}
        )
        
        assert passed == False
        assert "正则表达式验证失败" in error

    def test_validate_header_success(self, validation_engine):
        """测试响应头验证成功"""
        test_case = TestCase(
            id="TC007",
            name="测试响应头",
            description="测试响应头验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "header", "name": "Content-Type", "value": "application/json"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {},
            {"Content-Type": "application/json"}
        )
        
        assert passed == True

    def test_validate_header_not_found(self, validation_engine):
        """测试响应头不存在"""
        test_case = TestCase(
            id="TC007",
            name="测试响应头",
            description="测试响应头验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "header", "name": "X-Custom-Header"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {},
            {"Content-Type": "application/json"}
        )
        
        assert passed == False
        assert "响应头中未找到" in error

    def test_validate_schema_success(self, validation_engine):
        """测试结构验证成功"""
        test_case = TestCase(
            id="TC008",
            name="测试结构",
            description="测试结构验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "schema", "schema": {"name": "str", "age": "int"}}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"name": "John", "age": 30},
            {}
        )
        
        assert passed == True

    def test_validate_schema_failure(self, validation_engine):
        """测试结构验证失败"""
        test_case = TestCase(
            id="TC008",
            name="测试结构",
            description="测试结构验证",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "schema", "schema": {"name": "str", "age": "int"}}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"name": "John", "age": "thirty"},
            {}
        )
        
        assert passed == False
        assert "字段 age 类型错误" in error

    def test_validate_performance_success(self, validation_engine):
        """测试性能验证成功"""
        from datetime import datetime
        performance = PerformanceMetrics(
            timestamp=datetime.now(),
            response_time=1000,
            request_size=100,
            response_size=200
        )
        
        passed, error = validation_engine.validate_performance(performance, 5000)
        
        assert passed == True
        assert error == ""

    def test_validate_performance_failure(self, validation_engine):
        """测试性能验证失败"""
        from datetime import datetime
        performance = PerformanceMetrics(
            timestamp=datetime.now(),
            response_time=6000,
            request_size=100,
            response_size=200
        )
        
        passed, error = validation_engine.validate_performance(performance, 5000)
        
        assert passed == False
        assert "响应时间超过阈值" in error

    def test_validate_multiple_validations(self, validation_engine):
        """测试多个验证规则"""
        test_case = TestCase(
            id="TC009",
            name="测试多验证",
            description="测试多个验证规则",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[
                {"type": "status_code", "value": 200},
                {"type": "contains", "value": "success"},
                {"type": "equals", "field": "status", "value": "ok"}
            ]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"status": "ok", "message": "operation success"},
            {}
        )
        
        assert passed == True

    def test_validate_multiple_validations_failure(self, validation_engine):
        """测试多个验证规则（其中一个失败）"""
        test_case = TestCase(
            id="TC009",
            name="测试多验证",
            description="测试多个验证规则",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[
                {"type": "status_code", "value": 200},
                {"type": "contains", "value": "error"},
                {"type": "equals", "field": "status", "value": "ok"}
            ]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"status": "ok", "message": "operation success"},
            {}
        )
        
        assert passed == False
        assert "包含验证失败" in error

    def test_validate_no_validations(self, validation_engine):
        """测试无验证规则"""
        test_case = TestCase(
            id="TC010",
            name="测试无验证",
            description="测试无验证规则",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={}
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"message": "success"},
            {}
        )
        
        assert passed == True
        assert error == ""

    def test_validate_unsupported_type(self, validation_engine):
        """测试不支持的验证类型"""
        test_case = TestCase(
            id="TC011",
            name="测试不支持的类型",
            description="测试不支持的验证类型",
            module="test",
            endpoint="/api/test",
            method=HTTPMethod.GET,
            headers={},
            validations=[{"type": "unsupported_type"}]
        )
        
        passed, error = validation_engine.validate_response(
            test_case,
            200,
            {"message": "success"},
            {}
        )
        
        assert passed == False
        assert "不支持的验证类型" in error