接口测试是确保API可靠性的关键环节。本指南将展示如何使用Python原生库构建一个高效、可维护的接口测试框架。
"""
高效接口测试框架 - 原生Python实现
"""
import json
import time
import logging
import inspect
from datetime import datetime
from typing import Dict, Any, List, Optional, Callable, Union
from dataclasses import dataclass, field, asdict
from enum import Enum
import csv
import yaml
import hmac
import hashlib
import base64
from urllib.parse import urlencode
import random
import string
# 配置日志系统
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler(f'api_test_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'),
logging.StreamHandler()
]
)
logger = logging.getLogger(__name__)
class HTTPMethod(Enum):
"""HTTP方法枚举"""
GET = "GET"
POST = "POST"
PUT = "PUT"
DELETE = "DELETE"
PATCH = "PATCH"
class TestStatus(Enum):
"""测试状态枚举"""
PASS = "PASS"
FAIL = "FAIL"
SKIP = "SKIP"
ERROR = "ERROR"
@dataclass
class TestCase:
"""测试用例数据类"""
name: str
endpoint: str
method: HTTPMethod
headers: Dict[str, str] = field(default_factory=dict)
params: Dict[str, Any] = field(default_factory=dict)
data: Union[Dict[str, Any], str, None] = None
expected_status: int = 200
expected_response: Optional[Dict[str, Any]] = None
validation_rules: List[Callable] = field(default_factory=list)
timeout: int = 30
description: str = ""
dependencies: List[str] = field(default_factory=list)
def to_dict(self) -> Dict[str, Any]:
"""转换为字典"""
result = asdict(self)
result['method'] = self.method.value
return result
@dataclass
class TestResult:
"""测试结果数据类"""
test_case: TestCase
status: TestStatus
response_time: float
response_status: Optional[int] = None
response_data: Optional[Dict[str, Any]] = None
error_message: Optional[str] = None
assertion_results: List[Dict[str, Any]] = field(default_factory=list)
timestamp: datetime = field(default_factory=datetime.now)
def is_success(self) -> bool:
"""判断测试是否成功"""
return self.status == TestStatus.PASS
class APIClient:
"""HTTP客户端封装类"""
def __init__(self, base_url: str, default_headers: Optional[Dict[str, str]] = None):
self.base_url = base_url.rstrip('/')
self.default_headers = default_headers or {}
self.session = self._create_session()
def _create_session(self):
"""创建请求会话"""
import http.client
return http.client
def _make_request(self, test_case: TestCase) -> Dict[str, Any]:
"""执行HTTP请求"""
import urllib.request
import urllib.error
import socket
url = f"{self.base_url}/{test_case.endpoint.lstrip('/')}"
# 处理查询参数
if test_case.params:
query_string = urlencode(test_case.params)
url = f"{url}?{query_string}"
# 准备请求数据
request_data = None
headers = {**self.default_headers, **test_case.headers}
if test_case.data:
if isinstance(test_case.data, dict):
request_data = json.dumps(test_case.data).encode('utf-8')
headers['Content-Type'] = 'application/json'
elif isinstance(test_case.data, str):
request_data = test_case.data.encode('utf-8')
headers['Content-Type'] = 'application/x-www-form-urlencoded'
# 创建请求对象
req = urllib.request.Request(
url,
data=request_data,
headers=headers,
method=test_case.method.value
)
start_time = time.time()
response_data = None
status_code = None
error_msg = None
try:
# 设置超时
socket.setdefaulttimeout(test_case.timeout)
# 发送请求
with urllib.request.urlopen(req) as response:
status_code = response.getcode()
response_body = response.read().decode('utf-8')
# 尝试解析JSON响应
try:
response_data = json.loads(response_body) if response_body else {}
except json.JSONDecodeError:
response_data = {"raw_response": response_body}
except urllib.error.HTTPError as e:
status_code = e.code
response_body = e.read().decode('utf-8') if e.read() else ""
try:
response_data = json.loads(response_body) if response_body else {}
except:
response_data = {"error": str(e)}
error_msg = f"HTTP Error: {e.code} - {e.reason}"
except urllib.error.URLError as e:
error_msg = f"URL Error: {str(e)}"
except socket.timeout:
error_msg = f"Request timeout after {test_case.timeout} seconds"
except Exception as e:
error_msg = f"Unexpected error: {str(e)}"
response_time = time.time() - start_time
return {
"status_code": status_code,
"data": response_data,
"response_time": response_time,
"error": error_msg
}
def execute(self, test_case: TestCase) -> Dict[str, Any]:
"""执行测试用例"""
logger.info(f"Executing: {test_case.name} [{test_case.method.value} {test_case.endpoint}]")
return self._make_request(test_case)
class Validator:
"""响应验证器"""
@staticmethod
def validate_status_code(actual: int, expected: int) -> Dict[str, Any]:
"""验证状态码"""
success = actual == expected
return {
"name": "status_code_validation",
"success": success,
"expected": expected,
"actual": actual,
"message": f"Status code {'matches' if success else 'does not match'}"
}
@staticmethod
def validate_json_path(response: Dict[str, Any], json_path: str, expected_value: Any) -> Dict[str, Any]:
"""验证JSON路径值"""
from functools import reduce
import operator
try:
keys = json_path.split('.')
actual = reduce(operator.getitem, keys, response)
success = actual == expected_value
return {
"name": f"json_path_{json_path}",
"success": success,
"expected": expected_value,
"actual": actual,
"message": f"JSON path '{json_path}' {'matches' if success else 'does not match'}"
}
except (KeyError, TypeError):
return {
"name": f"json_path_{json_path}",
"success": False,
"expected": expected_value,
"actual": None,
"message": f"JSON path '{json_path}' not found"
}
@staticmethod
def validate_response_time(response_time: float, max_time: float) -> Dict[str, Any]:
"""验证响应时间"""
success = response_time <= max_time
return {
"name": "response_time_validation",
"success": success,
"expected": f"≤{max_time}s",
"actual": f"{response_time:.3f}s",
"message": f"Response time {'acceptable' if success else 'too slow'}"
}
@staticmethod
def validate_schema(response: Dict[str, Any], schema: Dict[str, Any]) -> Dict[str, Any]:
"""简单模式验证"""
# 简化的模式验证实现
errors = []
def check_type(value, expected_type):
type_map = {
"string": str,
"integer": int,
"number": (int, float),
"boolean": bool,
"array": list,
"object": dict
}
if expected_type in type_map:
expected = type_map[expected_type]
if not isinstance(value, expected):
return False
return True
for field_name, field_schema in schema.items():
if field_name not in response:
if field_schema.get("required", False):
errors.append(f"Missing required field: {field_name}")
else:
if "type" in field_schema:
if not check_type(response[field_name], field_schema["type"]):
errors.append(f"Field '{field_name}' has wrong type")
success = len(errors) == 0
return {
"name": "schema_validation",
"success": success,
"errors": errors,
"message": f"Schema validation {'passed' if success else 'failed'}"
}
class TestRunner:
"""测试运行器"""
def __init__(self, client: APIClient):
self.client = client
self.validator = Validator()
self.results: List[TestResult] = []
self.test_cases: Dict[str, TestCase] = {}
def add_test_case(self, test_case: TestCase):
"""添加测试用例"""
self.test_cases[test_case.name] = test_case
def load_test_cases_from_yaml(self, file_path: str):
"""从YAML文件加载测试用例"""
with open(file_path, 'r', encoding='utf-8') as f:
data = yaml.safe_load(f)
for test_data in data.get('test_cases', []):
test_case = TestCase(
name=test_data['name'],
endpoint=test_data['endpoint'],
method=HTTPMethod(test_data['method']),
headers=test_data.get('headers', {}),
params=test_data.get('params', {}),
data=test_data.get('data'),
expected_status=test_data.get('expected_status', 200),
expected_response=test_data.get('expected_response'),
timeout=test_data.get('timeout', 30),
description=test_data.get('description', ''),
dependencies=test_data.get('dependencies', [])
)
self.add_test_case(test_case)
def run_test(self, test_case: TestCase) -> TestResult:
"""运行单个测试用例"""
logger.info(f"Starting test: {test_case.name}")
# 检查依赖
for dep in test_case.dependencies:
if dep in self.test_cases:
dep_result = next((r for r in self.results if r.test_case.name == dep), None)
if not dep_result or not dep_result.is_success():
return TestResult(
test_case=test_case,
status=TestStatus.SKIP,
response_time=0,
error_message=f"Skipped due to failed dependency: {dep}"
)
# 执行请求
response = self.client.execute(test_case)
# 验证响应
assertion_results = []
# 验证状态码
status_validation = self.validator.validate_status_code(
response['status_code'],
test_case.expected_status
)
assertion_results.append(status_validation)
# 验证响应时间（假设最大5秒）
time_validation = self.validator.validate_response_time(
response['response_time'],
5.0
)
assertion_results.append(time_validation)
# 执行自定义验证规则
for validation_rule in test_case.validation_rules:
try:
result = validation_rule(response['data'])
if isinstance(result, dict):
assertion_results.append(result)
except Exception as e:
assertion_results.append({
"name": "custom_validation",
"success": False,
"error": str(e),
"message": "Custom validation failed"
})
# 确定测试状态
all_passed = all(r.get("success", False) for r in assertion_results)
status = TestStatus.PASS if all_passed else TestStatus.FAIL
if response['error'] and status != TestStatus.FAIL:
status = TestStatus.ERROR
# 创建测试结果
test_result = TestResult(
test_case=test_case,
status=status,
response_time=response['response_time'],
response_status=response['status_code'],
response_data=response['data'],
error_message=response['error'],
assertion_results=assertion_results
)
self.results.append(test_result)
logger.info(f"Test {test_case.name} completed with status: {status.value}")
return test_result
def run_all_tests(self) -> List[TestResult]:
"""运行所有测试用例"""
logger.info(f"Starting test run with {len(self.test_cases)} test cases")
self.results.clear()
for name, test_case in self.test_cases.items():
self.run_test(test_case)
return self.results
def generate_report(self, output_format: str = "console") -> str:
"""生成测试报告"""
total = len(self.results)
passed = sum(1 for r in self.results if r.status == TestStatus.PASS)
failed = sum(1 for r in self.results if r.status == TestStatus.FAIL)
errors = sum(1 for r in self.results if r.status == TestStatus.ERROR)
skipped = sum(1 for r in self.results if r.status == TestStatus.SKIP)
if output_format == "html":
return self._generate_html_report(total, passed, failed, errors, skipped)
else:
return self._generate_console_report(total, passed, failed, errors, skipped)
def _generate_console_report(self, total, passed, failed, errors, skipped) -> str:
"""生成控制台报告"""
report_lines = [
"\n" + "=" * 60,
"API TEST REPORT",
"=" * 60,
f"Total Tests: {total}",
f"Passed: {passed} ({passed/total*100:.1f}%)",
f"Failed: {failed}",
f"Errors: {errors}",
f"Skipped: {skipped}",
"-" * 60
]
for result in self.results:
status_icon = "✓" if result.status == TestStatus.PASS else "✗"
report_lines.append(
f"{status_icon} {result.test_case.name:30} "
f"{result.status.value:6} "
f"{result.response_time:.3f}s "
f"[{result.response_status or 'N/A'}]"
)
if result.status != TestStatus.PASS and result.error_message:
report_lines.append(f" Error: {result.error_message}")
for assertion in result.assertion_results:
if not assertion.get("success", False):
report_lines.append(f" Failed: {assertion.get('message', 'Unknown assertion')}")
report_lines.append("=" * 60)
return "\n".join(report_lines)
def _generate_html_report(self, total, passed, failed, errors, skipped) -> str:
"""生成HTML报告"""
import html
rows = ""
for result in self.results:
status_color = {
TestStatus.PASS: "green",
TestStatus.FAIL: "red",
TestStatus.ERROR: "orange",
TestStatus.SKIP: "gray"
}.get(result.status, "black")
rows += f"""
<tr>
<td>{html.escape(result.test_case.name)}</td>
<td style="color:{status_color}">{result.status.value}</td>
<td>{result.response_time:.3f}s</td>
<td>{result.response_status or 'N/A'}</td>
<td>{html.escape(result.error_message or '')}</td>
</tr>
"""
html_report = f"""
<!DOCTYPE html>
<html>
<head>
<title>API Test Report</title>
<style>
body {{ font-family: Arial, sans-serif; margin: 20px; }}
table {{ border-collapse: collapse; width: 100%; margin-top: 20px; }}
th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
th {{ background-color: #f2f2f2; }}
.summary {{ background-color: #f9f9f9; padding: 15px; border-radius: 5px; }}
</style>
</head>
<body>
<h1>API Test Report</h1>
<div class="summary">
<p><strong>Total Tests:</strong> {total}</p>
<p><strong>Passed:</strong> {passed} ({passed/total*100:.1f}%)</p>
<p><strong>Failed:</strong> {failed}</p>
<p><strong>Errors:</strong> {errors}</p>
<p><strong>Skipped:</strong> {skipped}</p>
</div>
<table>
<tr>
<th>Test Case</th>
<th>Status</th>
<th>Response Time</th>
<th>Status Code</th>
<th>Error Message</th>
</tr>
{rows}
</table>
</body>
</html>
"""
# 保存HTML报告
filename = f"test_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html"
with open(filename, 'w', encoding='utf-8') as f:
f.write(html_report)
return f"HTML report saved to {filename}"
class DataGenerator:
"""测试数据生成器"""
@staticmethod
def generate_string(length: int = 10) -> str:
"""生成随机字符串"""
return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
@staticmethod
def generate_email() -> str:
"""生成随机邮箱"""
return f"test_{DataGenerator.generate_string(8)}@example.com"
@staticmethod
def generate_number(min_val: int = 1, max_val: int = 1000) -> int:
"""生成随机数字"""
return random.randint(min_val, max_val)
@staticmethod
def load_test_data(file_path: str) -> List[Dict[str, Any]]:
"""从CSV或JSON文件加载测试数据"""
if file_path.endswith('.csv'):
with open(file_path, 'r', encoding='utf-8') as f:
reader = csv.DictReader(f)
return list(reader)
elif file_path.endswith('.json'):
with open(file_path, 'r', encoding='utf-8') as f:
return json.load(f)
else:
raise ValueError("Unsupported file format")
# ==================== 使用示例 ====================
def example_usage():
"""使用示例"""
# 1. 创建API客户端
client = APIClient(
base_url="https://jsonplaceholder.typicode.com",
default_headers={
"User-Agent": "APITestFramework/1.0",
"Accept": "application/json"
}
)
# 2. 创建测试运行器
runner = TestRunner(client)
# 3. 创建测试用例
# 示例1: GET请求测试
get_test = TestCase(
name="get_posts",
endpoint="/posts/1",
method=HTTPMethod.GET,
expected_status=200,
description="获取单篇帖子"
)
# 添加自定义验证规则
def validate_post_structure(response):
required_fields = ["id", "title", "body", "userId"]
missing = [field for field in required_fields if field not in response]
return {
"name": "post_structure_validation",
"success": len(missing) == 0,
"missing_fields": missing,
"message": "Post structure validation"
}
get_test.validation_rules.append(validate_post_structure)
# 示例2: POST请求测试
post_test = TestCase(
name="create_post",
endpoint="/posts",
method=HTTPMethod.POST,
headers={"Content-Type": "application/json"},
data={
"title": "Test Post",
"body": "This is a test post",
"userId": 1
},
expected_status=201,
description="创建新帖子"
)
# 示例3: 带参数的GET请求
param_test = TestCase(
name="filter_posts",
endpoint="/posts",
method=HTTPMethod.GET,
params={"userId": 1},
expected_status=200,
description="根据用户ID过滤帖子"
)
# 4. 添加测试用例到运行器
runner.add_test_case(get_test)
runner.add_test_case(post_test)
runner.add_test_case(param_test)
# 5. 运行所有测试
results = runner.run_all_tests()
# 6. 生成报告
print(runner.generate_report("console"))
# 7. 统计结果
success_count = sum(1 for r in results if r.is_success())
print(f"\nTest Execution Complete: {success_count}/{len(results)} passed")
return results
def advanced_features_demo():
"""高级功能演示"""
# 1. 数据驱动测试示例
def create_user_test_case(user_data):
"""动态创建测试用例"""
return TestCase(
name=f"create_user_{user_data['id']}",
endpoint="/users",
method=HTTPMethod.POST,
data=user_data,
expected_status=201
)
# 2. 认证测试示例
class AuthAPIClient(APIClient):
"""带认证的API客户端"""
def __init__(self, base_url, api_key, api_secret):
super().__init__(base_url)
self.api_key = api_key
self.api_secret = api_secret
def _sign_request(self, method, endpoint, params=None, data=None):
"""生成请求签名"""
timestamp = str(int(time.time()))
message = f"{method}{endpoint}{timestamp}"
if params:
message += urlencode(sorted(params.items()))
if data:
if isinstance(data, dict):
message += json.dumps(data, sort_keys=True)
else:
message += str(data)
signature = hmac.new(
self.api_secret.encode(),
message.encode(),
hashlib.sha256
).hexdigest()
return {
"X-API-Key": self.api_key,
"X-Timestamp": timestamp,
"X-Signature": signature
}
def execute(self, test_case: TestCase) -> Dict[str, Any]:
"""重写execute方法添加认证头"""
auth_headers = self._sign_request(
test_case.method.value,
test_case.endpoint,
test_case.params,
test_case.data
)
test_case.headers = {**test_case.headers, **auth_headers}
return super().execute(test_case)
# 3. 性能测试示例
def performance_test(client, endpoint, iterations=100):
"""性能测试函数"""
times = []
test_case = TestCase(
name="performance_test",
endpoint=endpoint,
method=HTTPMethod.GET
)
for i in range(iterations):
start = time.time()
client.execute(test_case)
times.append(time.time() - start)
avg_time = sum(times) / len(times)
p95 = sorted(times)[int(len(times) * 0.95)]
print(f"Performance results for {endpoint}:")
print(f" Average: {avg_time:.3f}s")
print(f" 95th percentile: {p95:.3f}s")
print(f" Min: {min(times):.3f}s")
print(f" Max: {max(times):.3f}s")
return times
class TestConfig:
"""测试配置管理"""
def __init__(self, config_file="test_config.yaml"):
self.config_file = config_file
self.config = self._load_config()
def _load_config(self):
"""加载配置文件"""
default_config = {
"base_url": "http://localhost:8000",
"environment": "development",
"timeout": 30,
"retry_count": 3,
"log_level": "INFO",
"report_format": "html"
}
try:
with open(self.config_file, 'r') as f:
user_config = yaml.safe_load(f) or {}
return {**default_config, **user_config}
except FileNotFoundError:
logger.warning(f"Config file {self.config_file} not found, using defaults")
return default_config
def get(self, key, default=None):
"""获取配置值"""
return self.config.get(key, default)
if __name__ == "__main__":
print("API Testing Framework Demo")
print("=" * 50)
# 运行示例测试
results = example_usage()
# 保存结果到JSON文件
with open("test_results.json", "w") as f:
json.dump([asdict(r) for r in results], f, indent=2, default=str)
print("\nResults saved to test_results.json")test_config.yaml)base_url: "https://api.example.com"
environment: "staging"
timeout: 30
retry_count: 3
log_level: "INFO"
report_format: "html"
auth:
api_key: "${API_KEY}"
api_secret: "${API_SECRET}"
endpoints:
users: "/api/v1/users"
posts: "/api/v1/posts"
comments: "/api/v1/comments"test_cases.yaml)test_cases:
- name: "get_all_users"
endpoint: "/api/v1/users"
method: "GET"
expected_status: 200
validation_rules:
- validate_user_list_structure
description: "获取所有用户列表"
- name: "create_new_user"
endpoint: "/api/v1/users"
method: "POST"
headers:
Content-Type: "application/json"
data:
name: "John Doe"
email: "john@example.com"
age: 30
expected_status: 201
validation_rules:
- validate_user_creation_response
description: "创建新用户"
- name: "update_user"
endpoint: "/api/v1/users/1"
method: "PUT"
data:
name: "Jane Doe"
email: "jane@example.com"
expected_status: 200
dependencies:
- "create_new_user"
description: "更新用户信息"# tests/
# ├── conftest.py # 共享测试配置
# ├── test_users.py # 用户相关测试
# ├── test_products.py # 产品相关测试
# └── data/ # 测试数据
# ├── users.csv
# └── products.json# ci_test.py
import sys
def main():
"""CI/CD集成入口点"""
config = TestConfig()
client = APIClient(config.get("base_url"))
runner = TestRunner(client)
# 加载测试用例
runner.load_test_cases_from_yaml("test_cases.yaml")
# 运行测试
results = runner.run_all_tests()
# 生成报告
report = runner.generate_report(config.get("report_format"))
print(report)
# 确定CI/CD流程是否通过
passed = all(r.is_success() for r in results)
sys.exit(0 if passed else 1)
if __name__ == "__main__":
main()class TestDataFactory:
"""测试数据工厂"""
@staticmethod
def create_user_data(**overrides):
"""创建用户测试数据"""
base_data = {
"name": DataGenerator.generate_string(8),
"email": DataGenerator.generate_email(),
"age": DataGenerator.generate_number(18, 65),
"active": True
}
return {**base_data, **overrides}
@staticmethod
def create_product_data(**overrides):
"""创建产品测试数据"""
base_data = {
"name": f"Product_{DataGenerator.generate_string(6)}",
"price": round(random.uniform(10, 1000), 2),
"stock": DataGenerator.generate_number(0, 1000),
"category": random.choice(["electronics", "clothing", "books"])
}
return {**base_data, **overrides}import asyncio
import aiohttp
class AsyncAPIClient:
"""异步API客户端"""
async def execute_async(self, test_case: TestCase):
"""异步执行测试用例"""
async with aiohttp.ClientSession() as session:
async with session.request(
method=test_case.method.value,
url=f"{self.base_url}/{test_case.endpoint}",
headers=test_case.headers,
params=test_case.params,
json=test_case.data if isinstance(test_case.data, dict) else None,
timeout=test_case.timeout
) as response:
return {
"status_code": response.status,
"data": await response.json(),
"response_time": response.elapsed.total_seconds()
}这个原生Python接口测试框架提供了：
完整的测试生命周期管理 灵活的验证机制 多种报告格式支持 易于扩展的架构 丰富的测试数据生成 CI/CD友好设计通过遵循本指南，您可以构建出高效、可靠且易于维护的接口测试解决方案，完全使用Python原生库，无需依赖外部测试框架。
