755 lines
24 KiB
Python
755 lines
24 KiB
Python
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
|
||
"""
|
||
规则执行演示脚本
|
||
|
||
本脚本演示如何使用增强后的规则库执行API测试，包括性能规则、安全规则、RESTful设计规则和错误处理规则的执行。
|
||
脚本模拟了一系列API请求和响应场景，并使用规则执行引擎验证这些场景是否符合预定义的规则。
|
||
"""
|
||
|
||
import time
|
||
import json
|
||
import logging
|
||
import argparse
|
||
from dataclasses import dataclass, asdict
|
||
from typing import Dict, List, Any, Optional
|
||
import requests
|
||
from urllib.parse import urlparse
|
||
|
||
# 配置日志
|
||
logging.basicConfig(
|
||
level=logging.INFO,
|
||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
|
||
)
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
# ------------------ 模拟 API 调用相关类 ------------------
|
||
|
||
@dataclass
|
||
class APIRequest:
|
||
"""API请求类，用于构建和发送API请求"""
|
||
method: str
|
||
url: str
|
||
headers: Optional[Dict[str, str]] = None
|
||
params: Optional[Dict[str, Any]] = None
|
||
json_data: Optional[Any] = None
|
||
body: Optional[Any] = None
|
||
data: Optional[Dict[str, Any]] = None
|
||
|
||
|
||
@dataclass
|
||
class APIResponse:
|
||
"""API响应类，用于存储API响应结果"""
|
||
status_code: int
|
||
headers: Dict[str, str]
|
||
content: str
|
||
elapsed_time: float
|
||
json_content: Optional[Dict[str, Any]] = None
|
||
request: Optional[APIRequest] = None
|
||
|
||
def __post_init__(self):
|
||
if self.content and (self.headers.get('Content-Type', '').startswith('application/json') or
|
||
self.content.strip().startswith('{')):
|
||
try:
|
||
self.json_content = json.loads(self.content)
|
||
except json.JSONDecodeError:
|
||
self.json_content = None
|
||
|
||
|
||
class APICaller:
|
||
"""API调用器，用于发送API请求并获取响应"""
|
||
|
||
def call_api(self, request: APIRequest) -> APIResponse:
|
||
"""模拟调用API，返回响应结果"""
|
||
logger.info(f"发送 {request.method} 请求到 {request.url}")
|
||
|
||
# 这里只是模拟，实际项目中应使用真实的HTTP请求
|
||
# 根据URL创建不同的模拟响应
|
||
start_time = time.time()
|
||
|
||
# 模拟不同的API响应场景
|
||
if "users" in request.url:
|
||
response = self._mock_user_api_response(request)
|
||
elif "slow" in request.url:
|
||
# 模拟慢响应
|
||
time.sleep(0.6) # 模拟600ms响应时间
|
||
response = self._mock_slow_api_response(request)
|
||
elif "error" in request.url:
|
||
# 模拟错误响应
|
||
response = self._mock_error_api_response(request)
|
||
elif "http://" in request.url:
|
||
# 模拟HTTP响应（非HTTPS）
|
||
response = self._mock_http_api_response(request)
|
||
else:
|
||
# 默认响应
|
||
response = self._mock_default_api_response(request)
|
||
|
||
elapsed_time = time.time() - start_time
|
||
response.elapsed_time = elapsed_time
|
||
response.request = request
|
||
|
||
return response
|
||
|
||
def _mock_user_api_response(self, request: APIRequest) -> APIResponse:
|
||
"""模拟用户API响应"""
|
||
headers = {
|
||
'Content-Type': 'application/json',
|
||
'X-Request-ID': '12345',
|
||
'X-Rate-Limit-Remaining': '1000'
|
||
}
|
||
content = json.dumps({
|
||
"id": 123,
|
||
"name": "Test User",
|
||
"email": "user@example.com",
|
||
"created_at": "2023-01-01T00:00:00Z",
|
||
"status": "active"
|
||
})
|
||
return APIResponse(
|
||
status_code=200,
|
||
headers=headers,
|
||
content=content,
|
||
elapsed_time=0.1
|
||
)
|
||
|
||
def _mock_slow_api_response(self, request: APIRequest) -> APIResponse:
|
||
"""模拟慢响应API"""
|
||
headers = {
|
||
'Content-Type': 'application/json',
|
||
'X-Request-ID': '54321',
|
||
'X-Rate-Limit-Remaining': '999'
|
||
}
|
||
content = json.dumps({
|
||
"id": 456,
|
||
"name": "Test User",
|
||
"email": "slow@example.com",
|
||
"created_at": "2023-01-02T00:00:00Z",
|
||
"status": "active",
|
||
"data": [1, 2, 3, 4, 5] * 100 # 添加一些数据使响应大一些
|
||
})
|
||
return APIResponse(
|
||
status_code=200,
|
||
headers=headers,
|
||
content=content,
|
||
elapsed_time=0.6 # 模拟600ms响应时间
|
||
)
|
||
|
||
def _mock_error_api_response(self, request: APIRequest) -> APIResponse:
|
||
"""模拟错误响应API"""
|
||
headers = {
|
||
'Content-Type': 'application/json',
|
||
'X-Request-ID': '67890'
|
||
}
|
||
# 标准错误响应格式
|
||
content = json.dumps({
|
||
"code": "user_not_found",
|
||
"message": "User not found",
|
||
"details": {
|
||
"resource": "User",
|
||
"id": request.params.get("id", "unknown") if request.params else "unknown"
|
||
}
|
||
})
|
||
return APIResponse(
|
||
status_code=404,
|
||
headers=headers,
|
||
content=content,
|
||
elapsed_time=0.05
|
||
)
|
||
|
||
def _mock_http_api_response(self, request: APIRequest) -> APIResponse:
|
||
"""模拟HTTP（非HTTPS）API响应"""
|
||
headers = {
|
||
'Content-Type': 'application/json',
|
||
'X-Request-ID': '13579'
|
||
}
|
||
content = json.dumps({
|
||
"message": "This is an insecure HTTP response",
|
||
"timestamp": time.time()
|
||
})
|
||
return APIResponse(
|
||
status_code=200,
|
||
headers=headers,
|
||
content=content,
|
||
elapsed_time=0.08
|
||
)
|
||
|
||
def _mock_default_api_response(self, request: APIRequest) -> APIResponse:
|
||
"""模拟默认API响应"""
|
||
headers = {
|
||
'Content-Type': 'application/json',
|
||
'X-Request-ID': '24680'
|
||
}
|
||
content = json.dumps({
|
||
"message": "Default response",
|
||
"method": request.method,
|
||
"path": urlparse(request.url).path,
|
||
"timestamp": time.time()
|
||
})
|
||
return APIResponse(
|
||
status_code=200,
|
||
headers=headers,
|
||
content=content,
|
||
elapsed_time=0.03
|
||
)
|
||
|
||
|
||
# ------------------ 规则模型类 ------------------
|
||
|
||
@dataclass
|
||
class RuleResult:
|
||
"""规则执行结果类"""
|
||
rule_id: str
|
||
rule_name: str
|
||
is_valid: bool
|
||
message: str
|
||
details: Optional[Dict[str, Any]] = None
|
||
category: Optional[str] = None
|
||
severity: Optional[str] = None
|
||
|
||
|
||
class RuleCategory:
|
||
"""规则类别枚举"""
|
||
PERFORMANCE = "Performance"
|
||
SECURITY = "Security"
|
||
API_DESIGN = "APIDesign"
|
||
ERROR_HANDLING = "ErrorHandling"
|
||
GENERAL = "General"
|
||
|
||
|
||
class RuleLifecycle:
|
||
"""规则生命周期枚举"""
|
||
REQUEST_PREPARATION = "RequestPreparation"
|
||
REQUEST_EXECUTION = "RequestExecution"
|
||
RESPONSE_VALIDATION = "ResponseValidation"
|
||
POST_VALIDATION = "PostValidation"
|
||
ANY_STAGE = "AnyStage"
|
||
|
||
|
||
class RuleScope:
|
||
"""规则作用域枚举"""
|
||
REQUEST_URL = "RequestURL"
|
||
REQUEST_HEADERS = "RequestHeaders"
|
||
REQUEST_PARAMS = "RequestParams"
|
||
REQUEST_BODY = "RequestBody"
|
||
RESPONSE_STATUS = "ResponseStatus"
|
||
RESPONSE_HEADERS = "ResponseHeaders"
|
||
RESPONSE_BODY = "ResponseBody"
|
||
RESPONSE_TIME = "ResponseTime"
|
||
SECURITY = "Security"
|
||
PERFORMANCE = "Performance"
|
||
ANY_SCOPE = "AnyScope"
|
||
|
||
|
||
class TargetType:
|
||
"""规则目标类型枚举"""
|
||
API_REQUEST = "APIRequest"
|
||
API_RESPONSE = "APIResponse"
|
||
ANY = "Any"
|
||
|
||
|
||
@dataclass
|
||
class BaseRule:
|
||
"""基础规则类"""
|
||
id: str
|
||
name: str
|
||
description: str
|
||
category: str = RuleCategory.GENERAL
|
||
version: str = "1.0.0"
|
||
severity: str = "warning"
|
||
is_enabled: bool = True
|
||
tags: List[str] = None
|
||
target_type: str = TargetType.ANY
|
||
lifecycle: str = RuleLifecycle.ANY_STAGE
|
||
scope: str = RuleScope.ANY_SCOPE
|
||
|
||
def __post_init__(self):
|
||
if self.tags is None:
|
||
self.tags = []
|
||
|
||
def to_dict(self) -> Dict[str, Any]:
|
||
"""将规则转换为字典"""
|
||
return asdict(self)
|
||
|
||
def validate(self, context: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""验证逻辑，由子类实现"""
|
||
raise NotImplementedError("子类必须实现validate方法")
|
||
|
||
|
||
@dataclass
|
||
class PerformanceRule(BaseRule):
|
||
"""性能规则类"""
|
||
category: str = RuleCategory.PERFORMANCE
|
||
target_type: str = TargetType.API_RESPONSE
|
||
lifecycle: str = RuleLifecycle.RESPONSE_VALIDATION
|
||
scope: str = RuleScope.RESPONSE_TIME
|
||
threshold: float = 500.0 # 默认阈值500毫秒
|
||
metric: str = "response_time"
|
||
unit: str = "ms"
|
||
|
||
def validate(self, context: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""验证API响应时间是否超过阈值"""
|
||
response = context.get('api_response')
|
||
if not response:
|
||
return {
|
||
'is_valid': False,
|
||
'message': '缺少API响应对象',
|
||
'details': {}
|
||
}
|
||
|
||
response_time = response.elapsed_time * 1000 # 转换为毫秒
|
||
|
||
if response_time > self.threshold:
|
||
return {
|
||
'is_valid': False,
|
||
'message': f'响应时间 {response_time:.2f}ms 超过阈值 {self.threshold}ms',
|
||
'details': {
|
||
'actual_time': response_time,
|
||
'threshold': self.threshold,
|
||
'unit': self.unit
|
||
}
|
||
}
|
||
|
||
return {
|
||
'is_valid': True,
|
||
'message': f'响应时间 {response_time:.2f}ms 在阈值 {self.threshold}ms 内',
|
||
'details': {
|
||
'actual_time': response_time,
|
||
'threshold': self.threshold,
|
||
'unit': self.unit
|
||
}
|
||
}
|
||
|
||
|
||
@dataclass
|
||
class SecurityRule(BaseRule):
|
||
"""安全规则类"""
|
||
category: str = RuleCategory.SECURITY
|
||
target_type: str = TargetType.API_REQUEST
|
||
lifecycle: str = RuleLifecycle.REQUEST_PREPARATION
|
||
scope: str = RuleScope.SECURITY
|
||
check_type: str = "transport_security" # 传输安全检查
|
||
expected_value: str = "https" # 期望值为https
|
||
|
||
def validate(self, context: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""验证API请求是否使用了HTTPS协议"""
|
||
request = context.get('api_request')
|
||
if not request:
|
||
return {
|
||
'is_valid': False,
|
||
'message': '缺少API请求对象',
|
||
'details': {}
|
||
}
|
||
|
||
url = str(request.url)
|
||
|
||
if not url.startswith('https://'):
|
||
return {
|
||
'is_valid': False,
|
||
'message': 'API请求必须使用HTTPS协议',
|
||
'details': {
|
||
'current_url': url,
|
||
'expected_protocol': 'https'
|
||
}
|
||
}
|
||
|
||
return {
|
||
'is_valid': True,
|
||
'message': 'API请求使用了HTTPS协议',
|
||
'details': {
|
||
'url': url
|
||
}
|
||
}
|
||
|
||
|
||
@dataclass
|
||
class RESTfulDesignRule(BaseRule):
|
||
"""RESTful设计规则类"""
|
||
category: str = RuleCategory.API_DESIGN
|
||
target_type: str = TargetType.API_REQUEST
|
||
lifecycle: str = RuleLifecycle.REQUEST_PREPARATION
|
||
scope: str = RuleScope.REQUEST_URL
|
||
design_aspect: str = "URL设计"
|
||
pattern: str = r"^/api/v\d+/[a-z0-9-]+(/[a-z0-9-]+)*$"
|
||
|
||
def validate(self, context: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""验证API URL是否符合RESTful设计规范"""
|
||
import re
|
||
|
||
request = context.get('api_request')
|
||
if not request:
|
||
return {
|
||
'is_valid': False,
|
||
'message': '缺少API请求对象',
|
||
'details': {}
|
||
}
|
||
|
||
url = str(request.url)
|
||
|
||
# 解析URL，获取路径部分
|
||
parsed_url = urlparse(url)
|
||
path = parsed_url.path
|
||
|
||
# 使用正则表达式验证路径
|
||
if not re.match(self.pattern, path):
|
||
return {
|
||
'is_valid': False,
|
||
'message': 'API URL不符合RESTful设计规范',
|
||
'details': {
|
||
'current_path': path,
|
||
'expected_pattern': self.pattern,
|
||
'suggestion': '路径应该遵循 /api/v{version}/{资源}[/{id}] 格式'
|
||
}
|
||
}
|
||
|
||
return {
|
||
'is_valid': True,
|
||
'message': 'API URL符合RESTful设计规范',
|
||
'details': {
|
||
'path': path
|
||
}
|
||
}
|
||
|
||
|
||
@dataclass
|
||
class ErrorHandlingRule(BaseRule):
|
||
"""错误处理规则类"""
|
||
category: str = RuleCategory.ERROR_HANDLING
|
||
target_type: str = TargetType.API_RESPONSE
|
||
lifecycle: str = RuleLifecycle.RESPONSE_VALIDATION
|
||
scope: str = RuleScope.RESPONSE_BODY
|
||
error_code: str = "*" # 匹配所有错误码
|
||
expected_status: int = -1 # 不验证状态码
|
||
|
||
def validate(self, context: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""验证API错误响应是否符合标准格式"""
|
||
response = context.get('api_response')
|
||
if not response:
|
||
return {
|
||
'is_valid': False,
|
||
'message': '缺少API响应对象',
|
||
'details': {}
|
||
}
|
||
|
||
# 只检查4xx和5xx状态码的响应
|
||
if response.status_code < 400:
|
||
return {
|
||
'is_valid': True,
|
||
'message': '非错误响应，跳过验证',
|
||
'details': {
|
||
'status_code': response.status_code
|
||
}
|
||
}
|
||
|
||
# 确保响应包含JSON内容
|
||
if not response.json_content:
|
||
return {
|
||
'is_valid': False,
|
||
'message': '错误响应不是有效的JSON格式',
|
||
'details': {
|
||
'status_code': response.status_code,
|
||
'content_type': response.headers.get('Content-Type', '未知')
|
||
}
|
||
}
|
||
|
||
# 检查错误响应的必要字段
|
||
required_fields = ['code', 'message']
|
||
missing_fields = [field for field in required_fields if field not in response.json_content]
|
||
|
||
if missing_fields:
|
||
return {
|
||
'is_valid': False,
|
||
'message': '错误响应缺少必要字段',
|
||
'details': {
|
||
'missing_fields': missing_fields,
|
||
'required_fields': required_fields,
|
||
'response': response.json_content
|
||
}
|
||
}
|
||
|
||
return {
|
||
'is_valid': True,
|
||
'message': '错误响应符合标准格式',
|
||
'details': {
|
||
'status_code': response.status_code,
|
||
'error_code': response.json_content.get('code'),
|
||
'error_message': response.json_content.get('message')
|
||
}
|
||
}
|
||
|
||
|
||
# ------------------ 规则执行引擎 ------------------
|
||
|
||
class RuleExecutor:
|
||
"""规则执行引擎"""
|
||
|
||
def __init__(self, rules: List[BaseRule] = None):
|
||
self.rules = rules or []
|
||
|
||
def add_rule(self, rule: BaseRule):
|
||
"""添加规则"""
|
||
self.rules.append(rule)
|
||
|
||
def execute_rule(self, rule: BaseRule, context: Dict[str, Any]) -> RuleResult:
|
||
"""执行单个规则"""
|
||
logger.info(f"执行规则 '{rule.name}' (ID: {rule.id})")
|
||
|
||
try:
|
||
result = rule.validate(context)
|
||
|
||
# 构建规则执行结果
|
||
rule_result = RuleResult(
|
||
rule_id=rule.id,
|
||
rule_name=rule.name,
|
||
is_valid=result.get('is_valid', False),
|
||
message=result.get('message', ''),
|
||
details=result.get('details', {}),
|
||
category=rule.category,
|
||
severity=rule.severity
|
||
)
|
||
|
||
# 记录执行结果
|
||
log_level = logging.INFO if rule_result.is_valid else logging.WARNING
|
||
logger.log(log_level, f"规则 '{rule.name}' 结果: {'通过' if rule_result.is_valid else '失败'} - {rule_result.message}")
|
||
|
||
return rule_result
|
||
|
||
except Exception as e:
|
||
# 记录执行异常
|
||
logger.error(f"执行规则 '{rule.name}' 时发生异常: {str(e)}", exc_info=True)
|
||
|
||
# 返回异常结果
|
||
return RuleResult(
|
||
rule_id=rule.id,
|
||
rule_name=rule.name,
|
||
is_valid=False,
|
||
message=f"规则执行异常: {str(e)}",
|
||
details={'exception': str(e)},
|
||
category=rule.category,
|
||
severity=rule.severity
|
||
)
|
||
|
||
def execute_rules_for_lifecycle(self, lifecycle: str, context: Dict[str, Any]) -> List[RuleResult]:
|
||
"""执行特定生命周期阶段的所有规则"""
|
||
logger.info(f"执行 {lifecycle} 阶段的规则")
|
||
|
||
# 筛选符合生命周期的规则
|
||
lifecycle_rules = [rule for rule in self.rules if rule.lifecycle == lifecycle or rule.lifecycle == RuleLifecycle.ANY_STAGE]
|
||
|
||
# 执行筛选出的规则
|
||
results = []
|
||
for rule in lifecycle_rules:
|
||
result = self.execute_rule(rule, context)
|
||
results.append(result)
|
||
|
||
# 统计执行结果
|
||
passed = sum(1 for result in results if result.is_valid)
|
||
failed = len(results) - passed
|
||
logger.info(f"{lifecycle} 阶段规则执行完成: {passed} 条通过, {failed} 条失败")
|
||
|
||
return results
|
||
|
||
def execute_all_rules(self, context: Dict[str, Any]) -> List[RuleResult]:
|
||
"""执行所有规则"""
|
||
logger.info(f"执行所有规则")
|
||
|
||
results = []
|
||
for rule in self.rules:
|
||
result = self.execute_rule(rule, context)
|
||
results.append(result)
|
||
|
||
# 统计执行结果
|
||
passed = sum(1 for result in results if result.is_valid)
|
||
failed = len(results) - passed
|
||
logger.info(f"所有规则执行完成: {passed} 条通过, {failed} 条失败")
|
||
|
||
return results
|
||
|
||
|
||
# ------------------ 演示函数 ------------------
|
||
|
||
def create_demo_rules() -> List[BaseRule]:
|
||
"""创建演示用的规则"""
|
||
rules = []
|
||
|
||
# 添加性能规则
|
||
performance_rule = PerformanceRule(
|
||
id="response-time-max-500ms",
|
||
name="响应时间不超过500毫秒",
|
||
description="验证API响应时间不超过500毫秒",
|
||
threshold=500,
|
||
metric="response_time",
|
||
unit="ms"
|
||
)
|
||
rules.append(performance_rule)
|
||
|
||
# 添加安全规则
|
||
security_rule = SecurityRule(
|
||
id="https-only-rule",
|
||
name="HTTPS强制使用规则",
|
||
description="验证API是否只使用HTTPS协议",
|
||
severity="error",
|
||
check_type="transport_security",
|
||
expected_value="https"
|
||
)
|
||
rules.append(security_rule)
|
||
|
||
# 添加RESTful设计规则
|
||
restful_rule = RESTfulDesignRule(
|
||
id="restful-url-pattern",
|
||
name="RESTful URL设计规则",
|
||
description="验证API URL是否符合RESTful设计规范",
|
||
pattern=r"^/api/v\d+/[a-z0-9-]+(/[a-z0-9-]+)*$"
|
||
)
|
||
rules.append(restful_rule)
|
||
|
||
# 添加错误处理规则
|
||
error_rule = ErrorHandlingRule(
|
||
id="standard-error-response",
|
||
name="标准错误响应格式规则",
|
||
description="验证API错误响应是否符合标准格式",
|
||
error_code="*"
|
||
)
|
||
rules.append(error_rule)
|
||
|
||
return rules
|
||
|
||
|
||
def demo_rule_execution():
|
||
"""演示规则执行过程"""
|
||
logger.info("开始规则执行演示")
|
||
|
||
# 创建规则
|
||
rules = create_demo_rules()
|
||
|
||
# 创建规则执行引擎
|
||
executor = RuleExecutor(rules)
|
||
|
||
# 创建API调用器
|
||
api_caller = APICaller()
|
||
|
||
# === 场景1: 正常响应场景 ===
|
||
logger.info("\n=== 场景1: 正常响应场景 ===")
|
||
|
||
# 创建API请求
|
||
request1 = APIRequest(
|
||
method="GET",
|
||
url="https://api.example.com/api/v1/users/123",
|
||
headers={"Content-Type": "application/json"}
|
||
)
|
||
|
||
# 执行请求准备阶段的规则
|
||
context1 = {"api_request": request1}
|
||
prep_results1 = executor.execute_rules_for_lifecycle(RuleLifecycle.REQUEST_PREPARATION, context1)
|
||
|
||
# 发送API请求
|
||
response1 = api_caller.call_api(request1)
|
||
|
||
# 执行响应验证阶段的规则
|
||
context1["api_response"] = response1
|
||
resp_results1 = executor.execute_rules_for_lifecycle(RuleLifecycle.RESPONSE_VALIDATION, context1)
|
||
|
||
# === 场景2: 慢响应场景 ===
|
||
logger.info("\n=== 场景2: 慢响应场景 ===")
|
||
|
||
# 创建API请求
|
||
request2 = APIRequest(
|
||
method="GET",
|
||
url="https://api.example.com/api/v1/users/slow",
|
||
headers={"Content-Type": "application/json"}
|
||
)
|
||
|
||
# 执行请求准备阶段的规则
|
||
context2 = {"api_request": request2}
|
||
prep_results2 = executor.execute_rules_for_lifecycle(RuleLifecycle.REQUEST_PREPARATION, context2)
|
||
|
||
# 发送API请求
|
||
response2 = api_caller.call_api(request2)
|
||
|
||
# 执行响应验证阶段的规则
|
||
context2["api_response"] = response2
|
||
resp_results2 = executor.execute_rules_for_lifecycle(RuleLifecycle.RESPONSE_VALIDATION, context2)
|
||
|
||
# === 场景3: 错误响应场景 ===
|
||
logger.info("\n=== 场景3: 错误响应场景 ===")
|
||
|
||
# 创建API请求
|
||
request3 = APIRequest(
|
||
method="GET",
|
||
url="https://api.example.com/api/v1/users/error",
|
||
headers={"Content-Type": "application/json"},
|
||
params={"id": "999"}
|
||
)
|
||
|
||
# 执行请求准备阶段的规则
|
||
context3 = {"api_request": request3}
|
||
prep_results3 = executor.execute_rules_for_lifecycle(RuleLifecycle.REQUEST_PREPARATION, context3)
|
||
|
||
# 发送API请求
|
||
response3 = api_caller.call_api(request3)
|
||
|
||
# 执行响应验证阶段的规则
|
||
context3["api_response"] = response3
|
||
resp_results3 = executor.execute_rules_for_lifecycle(RuleLifecycle.RESPONSE_VALIDATION, context3)
|
||
|
||
# === 场景4: 非HTTPS场景 ===
|
||
logger.info("\n=== 场景4: 非HTTPS场景 ===")
|
||
|
||
# 创建API请求
|
||
request4 = APIRequest(
|
||
method="GET",
|
||
url="http://api.example.com/api/v1/users/123",
|
||
headers={"Content-Type": "application/json"}
|
||
)
|
||
|
||
# 执行请求准备阶段的规则
|
||
context4 = {"api_request": request4}
|
||
prep_results4 = executor.execute_rules_for_lifecycle(RuleLifecycle.REQUEST_PREPARATION, context4)
|
||
|
||
# 发送API请求
|
||
response4 = api_caller.call_api(request4)
|
||
|
||
# 执行响应验证阶段的规则
|
||
context4["api_response"] = response4
|
||
resp_results4 = executor.execute_rules_for_lifecycle(RuleLifecycle.RESPONSE_VALIDATION, context4)
|
||
|
||
# === 场景5: 不符合RESTful设计的URL ===
|
||
logger.info("\n=== 场景5: 不符合RESTful设计的URL ===")
|
||
|
||
# 创建API请求
|
||
request5 = APIRequest(
|
||
method="GET",
|
||
url="https://api.example.com/getUserInfo?id=123",
|
||
headers={"Content-Type": "application/json"}
|
||
)
|
||
|
||
# 执行请求准备阶段的规则
|
||
context5 = {"api_request": request5}
|
||
prep_results5 = executor.execute_rules_for_lifecycle(RuleLifecycle.REQUEST_PREPARATION, context5)
|
||
|
||
# 发送API请求
|
||
response5 = api_caller.call_api(request5)
|
||
|
||
# 执行响应验证阶段的规则
|
||
context5["api_response"] = response5
|
||
resp_results5 = executor.execute_rules_for_lifecycle(RuleLifecycle.RESPONSE_VALIDATION, context5)
|
||
|
||
logger.info("\n演示完成")
|
||
|
||
|
||
def main():
|
||
"""主函数"""
|
||
parser = argparse.ArgumentParser(description='规则执行演示脚本')
|
||
parser.add_argument('--log-level', choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'], default='INFO',
|
||
help='日志级别')
|
||
args = parser.parse_args()
|
||
|
||
# 设置日志级别
|
||
logging.getLogger().setLevel(getattr(logging, args.log_level))
|
||
|
||
# 执行演示
|
||
demo_rule_execution()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main() |