Web测试专属浏览器框架Playwright，全部api接口录制&mock

在web测试过程中可以通过设置代理抓包的方式记录浏览器的所有api接口请求，但是如果想要mock指定接口的返回操作起来还是比较麻烦的，我们可以借助Playwright 脚本打开浏览器并接管浏览器的请求来实现。

原理

使用Playwright 打开浏览器后监听指定规则的api 请求，然后全部写入excel 文件，从而实现api接口请求全录制功能。然后写入的excel文件可以直接复制（字段基本一样）到api_rules.xlsx 这个规则模版，检测到规则模版变化后会自动生效新规则，如果想要mock 一个接口可以先在浏览器里面操作产生excel接口记录，然后直接复制到规则模版里面修改成你想要mock的响应数据即可！

这种mock的主要用处是给测试以及前端开发人员定制“制作”返回数据，比如要查看某个“状态”的订单数据，除了可以直接修改测试数据库，也可以直接写入规则模版想改什么数据就改什么数据，避免产生不必要的脏数据。甚至在后端接口没开发出来之前你可以自己把预期的接口数据类型进行定义，让后端根据你提供的数据定义来做接口！

实现方式

感谢AI 助力生产力的提高，我的想法已经直接让AI 落地开发完成了。这个时代很多琐碎的工作已经不再受限于个人能力，有想法、有创造力才更重要！下面附上成品源码。

API Recorder 程序功能说明书：

  1# API Recorder Excel 使用说明
  2 
  3## 功能概述
  4 
  5基于 Playwright 的 API 记录和 Mock 工具，支持从 Excel 读取规则，实时记录请求/响应到 Excel。
  6 
  7## 核心特性
  8 
  9- **Excel 规则管理**：从 `api_rules.xlsx` 读取 Mock 规则
 10- **实时记录**：API 请求/响应自动写入按日期命名的 Excel 文件
 11- **失败重试**：写入失败自动重试，确保数据不丢失
 12- **异常保护**：程序崩溃时未写入数据保存到独立文件
 13- **控制台请求捕获**：支持捕获浏览器控制台 fetch 请求
 14 
 15## 快速开始
 16 
 17### 1. 安装依赖
 18 
 19```bash
 20pip install playwright openpyxl
 21playwright install
 22```
 23 
 24### 2. 首次运行
 25 
 26```bash
 27python api_recorder_excel.py
 28```
 29 
 30首次运行会自动创建 `api_rules.xlsx` 示例文件。
 31 
 32### 3. 配置规则
 33 
 34编辑 `api_rules.xlsx`：
 35 
 36| 字段 | 说明 | 示例 |
 37|------|------|------|
 38| url_pattern | URL匹配正则 | `/api/user/\d+` |
 39| method | HTTP方法 | GET/POST/* |
 40| mock_response | Mock响应JSON | `{"code":200}` |
 41| status_code | 状态码 | 200 |
 42| delay | 延迟(秒) | 0.5 |
 43| enabled | 是否启用(1/0) | 1 |
 44| priority | 优先级(越小越优先) | 1 |
 45| description | 描述 | Mock用户信息 |
 46| request_params | 请求URL参数 | `id=123&type=1` |
 47| request_body | 请求Body | `{"name":"test"}` |
 48 
 49### 4. 使用流程
 50 
 51```
 52运行程序 → 输入网址 → 浏览器操作 → Ctrl+C结束 → 查看记录
 53```
 54 
 55## 输出文件
 56 
 57| 文件 | 说明 |
 58|------|------|
 59| `api_records_YYYYMMDD.xlsx` | API记录文件（按日期命名，如 `api_records_20260429.xlsx`） |
 60| `failed_records.json` | 失败记录缓存(临时) |
 61| `api_records_failed_*.xlsx` | 异常退出时未写入数据 |
 62| `api_records_failed_*.json` | 备选保存格式 |
 63 
 64## Excel 字段说明
 65 
 66### api_records_YYYYMMDD.xlsx 字段
 67 
 68```
 69url_pattern    - URL模式(如 /api/user/\d+)
 70method         - HTTP方法
 71mock_response  - 响应数据(JSON)
 72status_code    - 状态码
 73delay          - 延迟
 74enabled        - 是否启用(默认0)
 75priority       - 优先级(默认999)
 76description    - 描述
 77request_params - URL参数(key1=value1&key2=value2)
 78request_body   - 请求Body(JSON)
 79```
 80 
 81## 规则匹配逻辑
 82 
 831. 相同 `url_pattern` 按 `priority` 排序，取最小值
 842. 只处理 `enabled=1` 的规则
 853. 匹配规则后返回 Mock 数据，否则转发真实请求
 86 
 87## 数据保护机制
 88 
 89```
 90写入失败 → 加入失败队列 → 下次请求重试 → 重试3次仍失败
 91                                              ↓
 92程序退出时 → 尝试最后写入 → 仍失败则保存到新Excel(带随机文件名)
 93```
 94 
 95## 控制台 Fetch 请求说明
 96 
 97浏览器控制台发起的 `fetch` 请求有以下限制：
 98 
 99| 数据 | 是否可捕获 | 说明 |
100|------|-----------|------|
101| 请求 URL、Method、Headers | ✅ 可以 | 完全支持 |
102| 请求 Body | ✅ 可以 | 正常记录到 Excel |
103| 响应 Body | ⚠️ 受限 | 可能显示 `"_note": "控制台fetch请求的响应无法通过Playwright获取"` |
104 
105**原因**：浏览器消费响应后，Playwright 无法再次读取。这是浏览器安全机制限制，非程序问题。
106 
107## 注意事项
108 
109- 修改 `api_rules.xlsx` 后自动生效(5秒检测间隔)
110- 记录的 `enabled` 默认为 0，需手动改为 1 才能作为规则使用
111- 动态ID会自动替换为 `\d+` 通配符
112- 每天生成新的记录文件，避免单文件数据过多

程序源码：

   1"""
   2Playwright API 记录器和 Mock 工具 - Excel 规则版
   3功能：
   41. 从 Excel 模板读取 Mock 规则
   52. 支持启用/禁用字段
   63. 相同 url_pattern 取第一个或优先级最小的
   74. 实时重新加载规则（修改Excel后自动生效）
   85. API请求和响应实时写入Excel，格式与规则模板一致
   96. 失败记录重试机制，确保数据不丢失
  107. 程序异常退出时保存未写入的失败记录
  118. 记录请求参数和Body
  12 
  13Excel 模板字段：
  14- url_pattern: URL匹配模式（正则表达式）
  15- method: HTTP方法，默认为 *
  16- mock_response: Mock响应JSON字符串
  17- status_code: 状态码，默认为 200
  18- delay: 延迟秒数，默认为 0
  19- enabled: 是否启用，1/0 或 true/false
  20- priority: 优先级，数字越小优先级越高，默认为 999
  21- description: 规则描述
  22- request_params: 请求URL参数
  23- request_body: 请求Body参数
  24 
  25使用方法：
  261. 创建 api_rules.xlsx 文件
  272. 运行: python api_recorder_excel.py
  283. 按 Ctrl+C 结束程序
  294. 查看 api_records.xlsx 获取记录的API数据，可直接复制到规则中使用
  30"""
  31 
  32try:
  33    from playwright.sync_api import sync_playwright, Route
  34except ImportError:
  35    print("错误: 未安装 Playwright 库", flush=True)
  36    print("请运行: pip install playwright && playwright install", flush=True)
  37    exit(1)
  38 
  39try:
  40    import openpyxl
  41    from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
  42except ImportError:
  43    print("错误: 未安装 openpyxl 库", flush=True)
  44    print("请运行: pip install openpyxl", flush=True)
  45    exit(1)
  46 
  47import json
  48import sys
  49import signal
  50import re
  51import time
  52import os
  53import threading
  54import uuid
  55import atexit
  56from datetime import datetime
  57from typing import Dict, List, Optional, Any
  58from dataclasses import dataclass, field
  59from urllib.parse import urlparse, parse_qs
  60 
  61 
  62@dataclass
  63class MockRule:
  64    """Mock 规则数据类"""
  65    url_pattern: str
  66    method: str = "*"
  67    mock_response: Optional[Dict] = None
  68    status_code: int = 200
  69    delay: float = 0
  70    enabled: bool = True
  71    priority: int = 999
  72    description: str = ""
  73    compiled_pattern: Any = field(default=None, repr=False)
  74    
  75    def __post_init__(self):
  76        if self.compiled_pattern is None and self.url_pattern:
  77            try:
  78                self.compiled_pattern = re.compile(self.url_pattern)
  79            except re.error as e:
  80                print(f"[警告] 正则表达式编译失败: {self.url_pattern}, 错误: {e}", flush=True)
  81                self.compiled_pattern = None
  82    
  83    def matches(self, url: str, method: str) -> bool:
  84        """检查请求是否匹配此规则"""
  85        if not self.enabled:
  86            return False
  87        if self.method != "*" and self.method.upper() != method.upper():
  88            return False
  89        if self.compiled_pattern is None:
  90            return False
  91        return bool(self.compiled_pattern.search(url))
  92 
  93 
  94class ExcelRuleLoader:
  95    """Excel 规则加载器"""
  96    
  97    def __init__(self, excel_path: str = "api_rules.xlsx"):
  98        self.excel_path = excel_path
  99        self.last_modified = 0
 100        self.rules: List[MockRule] = []
 101        self._url_pattern_rules: Dict[str, List[MockRule]] = {}  # 按 url_pattern 分组
 102    
 103    def load_rules(self) -> List[MockRule]:
 104        """从 Excel 加载规则"""
 105        if not os.path.exists(self.excel_path):
 106            print(f"[警告] Excel 文件不存在: {self.excel_path}", flush=True)
 107            return []
 108        
 109        try:
 110            # 检查文件是否修改
 111            current_modified = os.path.getmtime(self.excel_path)
 112            if current_modified == self.last_modified and self.rules:
 113                return self.rules
 114            
 115            self.last_modified = current_modified
 116            
 117            # 加载 Excel
 118            wb = openpyxl.load_workbook(self.excel_path)
 119            ws = wb.active
 120            
 121            # 获取表头
 122            headers = [cell.value.strip().lower() if cell.value else "" for cell in ws[1]]
 123            
 124            # 字段映射
 125            field_map = {
 126                'url_pattern': ['url_pattern', 'url pattern', 'url', 'pattern', 'url匹配'],
 127                'method': ['method', '方法', 'http_method'],
 128                'mock_response': ['mock_response', 'mock response', 'response', '响应', 'mock'],
 129                'status_code': ['status_code', 'status code', 'status', '状态码'],
 130                'delay': ['delay', '延迟', '延时'],
 131                'enabled': ['enabled', 'enable', '启用', '是否启用', 'active'],
 132                'priority': ['priority', '优先级', 'priority_level'],
 133                'description': ['description', 'desc', '描述', '说明'],
 134                'request_params': ['request_params', 'params', 'url_params', '请求参数'],
 135                'request_body': ['request_body', 'body', '请求体']
 136            }
 137            
 138            # 找到列索引
 139            col_indices = {}
 140            for field_name, possible_names in field_map.items():
 141                for idx, header in enumerate(headers):
 142                    if header in possible_names:
 143                        col_indices[field_name] = idx
 144                        break
 145            
 146            if 'url_pattern' not in col_indices:
 147                print("[错误] Excel 中未找到 url_pattern 列", flush=True)
 148                return []
 149            
 150            # 读取数据
 151            raw_rules = []
 152            for row_idx, row in enumerate(ws.iter_rows(min_row=2), start=2):
 153                try:
 154                    url_pattern = self._get_cell_value(row[col_indices.get('url_pattern')]) if 'url_pattern' in col_indices else None
 155                    if not url_pattern:
 156                        continue
 157                    
 158                    rule = {
 159                        'url_pattern': url_pattern,
 160                        'method': self._get_cell_value(row[col_indices.get('method')]) if 'method' in col_indices else '*',
 161                        'mock_response': self._parse_json(self._get_cell_value(row[col_indices.get('mock_response')])) if 'mock_response' in col_indices else None,
 162                        'status_code': self._parse_int(self._get_cell_value(row[col_indices.get('status_code')]), 200),
 163                        'delay': self._parse_float(self._get_cell_value(row[col_indices.get('delay')]), 0),
 164                        'enabled': self._parse_bool(self._get_cell_value(row[col_indices.get('enabled')]), True),
 165                        'priority': self._parse_int(self._get_cell_value(row[col_indices.get('priority')]), 999),
 166                        'description': self._get_cell_value(row[col_indices.get('description')]) if 'description' in col_indices else '',
 167                        'request_params': self._get_cell_value(row[col_indices.get('request_params')]) if 'request_params' in col_indices else '',
 168                        'request_body': self._get_cell_value(row[col_indices.get('request_body')]) if 'request_body' in col_indices else ''
 169                    }
 170                    raw_rules.append(rule)
 171                    
 172                except Exception as e:
 173                    print(f"[警告] 读取第 {row_idx} 行时出错: {e}", flush=True)
 174                    continue
 175            
 176            wb.close()
 177            
 178            # 按 url_pattern 分组并选择规则
 179            self._url_pattern_rules = {}
 180            for rule_data in raw_rules:
 181                url_pattern = rule_data['url_pattern']
 182                if url_pattern not in self._url_pattern_rules:
 183                    self._url_pattern_rules[url_pattern] = []
 184                self._url_pattern_rules[url_pattern].append(rule_data)
 185            
 186            # 处理相同 url_pattern 的规则
 187            selected_rules = []
 188            for url_pattern, rules_list in self._url_pattern_rules.items():
 189                # 过滤启用的规则
 190                enabled_rules = [r for r in rules_list if r['enabled']]
 191                if not enabled_rules:
 192                    continue
 193                
 194                # 按优先级排序，取第一个
 195                enabled_rules.sort(key=lambda x: x['priority'])
 196                selected = enabled_rules[0]
 197                
 198                selected_rules.append(MockRule(
 199                    url_pattern=selected['url_pattern'],
 200                    method=selected['method'],
 201                    mock_response=selected['mock_response'],
 202                    status_code=selected['status_code'],
 203                    delay=selected['delay'],
 204                    enabled=selected['enabled'],
 205                    priority=selected['priority'],
 206                    description=selected['description']
 207                ))
 208            
 209            self.rules = selected_rules
 210            print(f"[加载] 从 Excel 加载了 {len(self.rules)} 条规则", flush=True)
 211            
 212            # 显示加载的规则
 213            for i, rule in enumerate(self.rules, 1):
 214                status = "✓" if rule.enabled else "✗"
 215                print(f"  {i}. [{status}] {rule.url_pattern} [{rule.method}] (优先级:{rule.priority})", flush=True)
 216            
 217            return self.rules
 218            
 219        except Exception as e:
 220            print(f"[错误] 加载 Excel 失败: {e}", flush=True)
 221            return self.rules if self.rules else []
 222    
 223    def _get_cell_value(self, cell) -> str:
 224        """获取单元格值"""
 225        if cell is None or cell.value is None:
 226            return ""
 227        value = str(cell.value).strip()
 228        # 处理 Excel 中的布尔值
 229        if value.lower() in ('true', '1', 'yes', '是'):
 230            return 'true'
 231        if value.lower() in ('false', '0', 'no', '否'):
 232            return 'false'
 233        return value
 234    
 235    def _parse_json(self, value: str) -> Optional[Dict]:
 236        """解析 JSON 字符串"""
 237        if not value:
 238            return None
 239        try:
 240            return json.loads(value)
 241        except:
 242            # 尝试作为字符串返回
 243            return {"message": value}
 244    
 245    def _parse_int(self, value: str, default: int) -> int:
 246        """解析整数"""
 247        if not value:
 248            return default
 249        try:
 250            return int(float(value))
 251        except:
 252            return default
 253    
 254    def _parse_float(self, value: str, default: float) -> float:
 255        """解析浮点数"""
 256        if not value:
 257            return default
 258        try:
 259            return float(value)
 260        except:
 261            return default
 262    
 263    def _parse_bool(self, value: str, default: bool) -> bool:
 264        """解析布尔值"""
 265        if not value:
 266            return default
 267        value = value.lower()
 268        return value in ('true', '1', 'yes', '是', '启用', 'enabled')
 269 
 270 
 271class FailedRecord:
 272    """失败记录数据类"""
 273    def __init__(self, url: str, method: str, status_code: int, response_body: Any, 
 274                 post_data: Any = None, request_params: str = "", request_body: str = ""):
 275        self.url = url
 276        self.method = method
 277        self.status_code = status_code
 278        self.response_body = response_body
 279        self.post_data = post_data
 280        self.request_params = request_params
 281        self.request_body = request_body
 282        self.fail_time = datetime.now().isoformat()
 283        self.retry_count = 0
 284    
 285    def to_dict(self) -> Dict:
 286        """转换为字典"""
 287        return {
 288            'url': self.url,
 289            'method': self.method,
 290            'status_code': self.status_code,
 291            'response_body': self.response_body,
 292            'post_data': self.post_data,
 293            'request_params': self.request_params,
 294            'request_body': self.request_body,
 295            'fail_time': self.fail_time,
 296            'retry_count': self.retry_count
 297        }
 298    
 299    @classmethod
 300    def from_dict(cls, data: Dict) -> 'FailedRecord':
 301        """从字典创建"""
 302        record = cls(
 303            url=data['url'],
 304            method=data['method'],
 305            status_code=data['status_code'],
 306            response_body=data['response_body'],
 307            post_data=data.get('post_data'),
 308            request_params=data.get('request_params', ''),
 309            request_body=data.get('request_body', '')
 310        )
 311        record.fail_time = data.get('fail_time', datetime.now().isoformat())
 312        record.retry_count = data.get('retry_count', 0)
 313        return record
 314 
 315 
 316class ExcelRecorder:
 317    """Excel API 记录器 - 带失败重试机制"""
 318    
 319    # 与规则模板一致的表头，增加请求参数和Body字段
 320    HEADERS = ["url_pattern", "method", "mock_response", "status_code", "delay", "enabled", "priority", "description", "request_params", "request_body"]
 321    
 322    def __init__(self, excel_path: str = "api_records.xlsx", failed_records_path: str = "failed_records.json"):
 323        self.excel_path = excel_path
 324        self.failed_records_path = failed_records_path
 325        self.lock = threading.Lock()
 326        self.record_count = 0
 327        self.failed_records: List[FailedRecord] = []  # 失败记录队列
 328        self.max_retry = 3  # 最大重试次数
 329        
 330        # 加载历史失败记录
 331        self._load_failed_records()
 332        
 333        # 初始化 Excel
 334        self._init_excel()
 335        
 336        # 注册退出处理
 337        atexit.register(self._on_exit)
 338    
 339    def _load_failed_records(self):
 340        """加载历史失败记录"""
 341        try:
 342            if os.path.exists(self.failed_records_path):
 343                with open(self.failed_records_path, 'r', encoding='utf-8') as f:
 344                    data = json.load(f)
 345                    for item in data:
 346                        self.failed_records.append(FailedRecord.from_dict(item))
 347                print(f"[恢复] 加载了 {len(self.failed_records)} 条历史失败记录", flush=True)
 348                # 立即尝试写入
 349                self._retry_failed_records()
 350        except Exception as e:
 351            print(f"[警告] 加载历史失败记录失败: {e}", flush=True)
 352    
 353    def _save_failed_records(self):
 354        """保存失败记录到文件"""
 355        try:
 356            data = [r.to_dict() for r in self.failed_records]
 357            with open(self.failed_records_path, 'w', encoding='utf-8') as f:
 358                json.dump(data, f, ensure_ascii=False, indent=2)
 359        except Exception as e:
 360            print(f"[错误] 保存失败记录失败: {e}", flush=True)
 361    
 362    def _on_exit(self):
 363        """程序退出时的处理"""
 364        if self.failed_records:
 365            print(f"\n[退出] 还有 {len(self.failed_records)} 条记录未写入，正在保存...", flush=True)
 366            # 先尝试最后一次写入
 367            self._retry_failed_records()
 368            
 369            # 如果还有失败的，保存到新的 Excel
 370            if self.failed_records:
 371                self._save_failed_to_new_excel()
 372        
 373        # 清理失败记录文件
 374        if os.path.exists(self.failed_records_path):
 375            try:
 376                os.remove(self.failed_records_path)
 377            except:
 378                pass
 379    
 380    def _save_failed_to_new_excel(self):
 381        """将未写入的失败记录保存到新的 Excel 文件"""
 382        try:
 383            # 生成带随机数的文件名
 384            random_suffix = str(uuid.uuid4())[:8]
 385            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
 386            new_filename = f"api_records_failed_{timestamp}_{random_suffix}.xlsx"
 387            
 388            # 创建新工作簿
 389            wb = openpyxl.Workbook()
 390            ws = wb.active
 391            ws.title = "失败记录"
 392            
 393            # 写入表头
 394            ws.append(self.HEADERS)
 395            
 396            # 设置表头样式
 397            header_fill = PatternFill(start_color="C00000", end_color="C00000", fill_type="solid")
 398            header_font = Font(bold=True, color="FFFFFF")
 399            for cell in ws[1]:
 400                cell.fill = header_fill
 401                cell.font = header_font
 402                cell.alignment = Alignment(horizontal="center", vertical="center")
 403            
 404            # 写入失败记录
 405            for failed_record in self.failed_records:
 406                row_data = self._prepare_row_data(
 407                    failed_record.url,
 408                    failed_record.method,
 409                    failed_record.status_code,
 410                    failed_record.response_body,
 411                    failed_record.post_data,
 412                    failed_record.request_params,
 413                    failed_record.request_body
 414                )
 415                ws.append(row_data)
 416            
 417            # 设置列宽
 418            ws.column_dimensions['A'].width = 40  # url_pattern
 419            ws.column_dimensions['B'].width = 10  # method
 420            ws.column_dimensions['C'].width = 50  # mock_response
 421            ws.column_dimensions['D'].width = 12  # status_code
 422            ws.column_dimensions['E'].width = 8   # delay
 423            ws.column_dimensions['F'].width = 10  # enabled
 424            ws.column_dimensions['G'].width = 10  # priority
 425            ws.column_dimensions['H'].width = 25  # description
 426            ws.column_dimensions['I'].width = 40  # request_params
 427            ws.column_dimensions['J'].width = 50  # request_body
 428            
 429            wb.save(new_filename)
 430            wb.close()
 431            
 432            print(f"✓ 未写入记录已保存到: {new_filename}", flush=True)
 433            print(f"  共 {len(self.failed_records)} 条记录", flush=True)
 434            
 435        except Exception as e:
 436            print(f"✗ 保存失败记录到 Excel 失败: {e}", flush=True)
 437            # 最后的备选：保存为 JSON
 438            self._save_failed_as_json()
 439    
 440    def _save_failed_as_json(self):
 441        """将失败记录保存为 JSON（最后备选）"""
 442        try:
 443            random_suffix = str(uuid.uuid4())[:8]
 444            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
 445            json_filename = f"api_records_failed_{timestamp}_{random_suffix}.json"
 446            
 447            data = {
 448                'save_time': datetime.now().isoformat(),
 449                'count': len(self.failed_records),
 450                'records': [r.to_dict() for r in self.failed_records]
 451            }
 452            
 453            with open(json_filename, 'w', encoding='utf-8') as f:
 454                json.dump(data, f, ensure_ascii=False, indent=2)
 455            
 456            print(f"✓ 未写入记录已保存为 JSON: {json_filename}", flush=True)
 457            
 458        except Exception as e:
 459            print(f"✗ 保存失败记录为 JSON 也失败了: {e}", flush=True)
 460    
 461    def _init_excel(self):
 462        """初始化 Excel 文件"""
 463        try:
 464            if os.path.exists(self.excel_path):
 465                # 文件已存在，读取现有记录数
 466                wb = openpyxl.load_workbook(self.excel_path)
 467                ws = wb.active
 468                self.record_count = ws.max_row - 1
 469                wb.close()
 470                print(f"[记录器] 已加载现有记录文件，当前记录数: {self.record_count}", flush=True)
 471            else:
 472                # 创建新文件
 473                wb = openpyxl.Workbook()
 474                ws = wb.active
 475                ws.title = "API记录"
 476                
 477                # 写入表头
 478                ws.append(self.HEADERS)
 479                
 480                # 设置表头样式
 481                header_fill = PatternFill(start_color="4472C4", end_color="4472C4", fill_type="solid")
 482                header_font = Font(bold=True, color="FFFFFF")
 483                for cell in ws[1]:
 484                    cell.fill = header_fill
 485                    cell.font = header_font
 486                    cell.alignment = Alignment(horizontal="center", vertical="center")
 487                
 488                # 设置列宽
 489                ws.column_dimensions['A'].width = 40  # url_pattern
 490                ws.column_dimensions['B'].width = 10  # method
 491                ws.column_dimensions['C'].width = 50  # mock_response
 492                ws.column_dimensions['D'].width = 12  # status_code
 493                ws.column_dimensions['E'].width = 8   # delay
 494                ws.column_dimensions['F'].width = 10  # enabled
 495                ws.column_dimensions['G'].width = 10  # priority
 496                ws.column_dimensions['H'].width = 25  # description
 497                ws.column_dimensions['I'].width = 40  # request_params
 498                ws.column_dimensions['J'].width = 50  # request_body
 499                
 500                wb.save(self.excel_path)
 501                wb.close()
 502                print(f"[记录器] 已创建新的记录文件: {self.excel_path}", flush=True)
 503        except Exception as e:
 504            print(f"[错误] 初始化 Excel 记录器失败: {e}", flush=True)
 505    
 506    def _extract_url_params(self, url: str) -> str:
 507        """提取 URL 查询参数"""
 508        try:
 509            parsed = urlparse(url)
 510            if not parsed.query:
 511                return ""
 512            # 保持 key1=value1&key2=value2 格式
 513            return parsed.query
 514        except:
 515            return ""
 516    
 517    def _format_request_body(self, post_data: Any) -> str:
 518        """格式化请求 Body"""
 519        if not post_data:
 520            return ""
 521        try:
 522            # 如果是 JSON 字符串，尝试格式化
 523            if isinstance(post_data, str):
 524                try:
 525                    parsed = json.loads(post_data)
 526                    return json.dumps(parsed, ensure_ascii=False, separators=(',', ':'))
 527                except:
 528                    return post_data[:500]
 529            elif isinstance(post_data, dict):
 530                return json.dumps(post_data, ensure_ascii=False, separators=(',', ':'))
 531            else:
 532                return str(post_data)[:500]
 533        except:
 534            return str(post_data)[:500]
 535    
 536    def _prepare_row_data(self, url: str, method: str, status_code: int, response_body: Any, 
 537                          post_data: Any = None, request_params: str = "", request_body: str = "") -> List:
 538        """准备行数据"""
 539        # 提取 url_pattern（简化版）
 540        url_pattern = self._extract_url_pattern(url)
 541        
 542        # 格式化响应为 JSON 字符串
 543        if isinstance(response_body, dict):
 544            mock_response = json.dumps(response_body, ensure_ascii=False, separators=(',', ':'))
 545        elif isinstance(response_body, str):
 546            try:
 547                # 尝试解析并重新格式化
 548                parsed = json.loads(response_body)
 549                mock_response = json.dumps(parsed, ensure_ascii=False, separators=(',', ':'))
 550            except:
 551                mock_response = response_body[:500]  # 限制长度
 552        else:
 553            mock_response = str(response_body)[:500]
 554        
 555        # 生成描述
 556        description = f"记录于 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
 557        
 558        # 准备行数据（与规则模板一致）
 559        return [
 560            url_pattern,           # url_pattern
 561            method,                # method
 562            mock_response,         # mock_response
 563            status_code,           # status_code
 564            0,                     # delay
 565            0,                     # enabled (默认禁用，需要手动启用)
 566            999,                   # priority
 567            description,           # description
 568            request_params,        # request_params
 569            request_body           # request_body
 570        ]
 571    
 572    def _write_to_excel(self, row_data: List) -> bool:
 573        """写入单条记录到 Excel"""
 574        try:
 575            wb = openpyxl.load_workbook(self.excel_path)
 576            ws = wb.active
 577            ws.append(row_data)
 578            
 579            # 设置新行的样式
 580            row_num = ws.max_row
 581            for col_num in range(1, len(self.HEADERS) + 1):
 582                cell = ws.cell(row=row_num, column=col_num)
 583                cell.alignment = Alignment(vertical="center", wrap_text=True)
 584                
 585                # 为 mock_response 和 request_body 列设置特定样式
 586                if col_num in [3, 10]:  # mock_response 和 request_body 列
 587                    cell.font = Font(size=9)
 588            
 589            # 设置行高
 590            ws.row_dimensions[row_num].height = 30
 591            
 592            wb.save(self.excel_path)
 593            wb.close()
 594            return True
 595            
 596        except Exception as e:
 597            print(f"[错误] 写入 Excel 失败: {e}", flush=True)
 598            return False
 599    
 600    def _retry_failed_records(self) -> int:
 601        """重试写入失败记录，返回成功写入的数量"""
 602        if not self.failed_records:
 603            return 0
 604        
 605        success_count = 0
 606        still_failed = []
 607        
 608        print(f"[重试] 尝试写入 {len(self.failed_records)} 条历史失败记录...", flush=True)
 609        
 610        for failed_record in self.failed_records:
 611            if failed_record.retry_count >= self.max_retry:
 612                # 超过最大重试次数，保留
 613                still_failed.append(failed_record)
 614                continue
 615            
 616            failed_record.retry_count += 1
 617            row_data = self._prepare_row_data(
 618                failed_record.url,
 619                failed_record.method,
 620                failed_record.status_code,
 621                failed_record.response_body,
 622                failed_record.post_data,
 623                failed_record.request_params,
 624                failed_record.request_body
 625            )
 626            
 627            if self._write_to_excel(row_data):
 628                success_count += 1
 629                self.record_count += 1
 630            else:
 631                still_failed.append(failed_record)
 632        
 633        self.failed_records = still_failed
 634        
 635        if success_count > 0:
 636            print(f"[重试] 成功写入 {success_count} 条，还有 {len(still_failed)} 条失败", flush=True)
 637        
 638        # 保存当前的失败记录
 639        self._save_failed_records()
 640        
 641        return success_count
 642    
 643    def add_record(self, url: str, method: str, status_code: int, response_body: Any, post_data: Any = None):
 644        """添加一条 API 记录（带失败重试机制）"""
 645        with self.lock:
 646            # 先尝试重试历史失败记录
 647            if self.failed_records:
 648                self._retry_failed_records()
 649            
 650            # 提取请求参数和Body
 651            request_params = self._extract_url_params(url)
 652            request_body = self._format_request_body(post_data)
 653            
 654            # 准备当前记录数据
 655            row_data = self._prepare_row_data(url, method, status_code, response_body, post_data, request_params, request_body)
 656            
 657            # 尝试写入当前记录
 658            if self._write_to_excel(row_data):
 659                self.record_count += 1
 660                print(f"[记录] 已保存到 Excel ({self.record_count}): {method} {self._extract_url_pattern(url)}", flush=True)
 661            else:
 662                # 写入失败，添加到失败队列
 663                failed_record = FailedRecord(url, method, status_code, response_body, post_data, request_params, request_body)
 664                self.failed_records.append(failed_record)
 665                self._save_failed_records()
 666                print(f"[失败] 记录写入失败，已加入重试队列 (当前队列: {len(self.failed_records)} 条): {method} {url}", flush=True)
 667    
 668    def _extract_url_pattern(self, url: str) -> str:
 669        """从完整 URL 提取模式"""
 670        # 移除协议和域名部分
 671        pattern = url
 672        
 673        # 移除 http:// 或 https://
 674        if '://' in pattern:
 675            pattern = pattern.split('://', 1)[1]
 676        
 677        # 移除域名部分，保留路径
 678        if '/' in pattern:
 679            pattern = '/' + pattern.split('/', 1)[1]
 680        
 681        # 移除查询参数
 682        if '?' in pattern:
 683            pattern = pattern.split('?', 1)[0]
 684        
 685        # 将动态 ID 替换为通配符
 686        # 例如: /api/user/123 -> /api/user/\d+
 687        pattern = re.sub(r'/\d+', r'/\\d+', pattern)
 688        
 689        return pattern
 690    
 691    def get_stats(self) -> Dict:
 692        """获取统计信息"""
 693        return {
 694            'record_count': self.record_count,
 695            'failed_count': len(self.failed_records),
 696            'failed_records_path': self.failed_records_path if self.failed_records else None
 697        }
 698 
 699 
 700class APIRecorderExcel:
 701    """API 记录器 - Excel 规则版"""
 702 
 703    def __init__(self, rules_excel: str = "api_rules.xlsx", records_excel: str = "api_records.xlsx", listen_new_pages: bool = False):
 704        self.rules_excel = rules_excel
 705        self.records_excel = records_excel
 706        self.rule_loader = ExcelRuleLoader(rules_excel)
 707        self.excel_recorder = ExcelRecorder(records_excel)
 708        self.rules: List[MockRule] = []
 709        self.request_count = 0
 710        self.response_count = 0
 711        self.mock_count = 0
 712        self.running = True
 713        self.last_rule_reload = 0
 714        # 是否监听新标签页
 715        self.listen_new_pages = listen_new_pages
 716        # 请求缓存：用于存储所有请求的body（包括控制台fetch）
 717        self._request_cache: Dict[str, Any] = {}
 718        self._cache_lock = threading.Lock()
 719        # 标记已通过route处理的请求（避免重复记录）
 720        self._routed_requests: set = set()
 721        self._route_lock = threading.Lock()
 722 
 723    def setup_page_listeners(self, page):
 724        """为指定页面设置监听器"""
 725        # 监听所有请求（用于捕获body，包括控制台fetch）
 726        page.on("request", lambda request: self.handle_request(request))
 727 
 728        # 设置路由拦截（用于mock）
 729        page.route("**/*", lambda route: self.handle_route(route))
 730 
 731        # 监听响应
 732        page.on("response", lambda response: self.handle_response(response))
 733 
 734        print(f"[监听] 已为页面设置 API 监听器: {page.url[:60]}...", flush=True)
 735 
 736    def handle_new_page(self, page):
 737        """处理新打开的页面"""
 738        print(f"\n[新页面] 检测到新标签页: {page.url[:60]}...", flush=True)
 739        self.setup_page_listeners(page)
 740    
 741    def reload_rules(self):
 742        """重新加载规则"""
 743        current_time = time.time()
 744        # 每 5 秒检查一次文件修改
 745        if current_time - self.last_rule_reload >= 5:
 746            new_rules = self.rule_loader.load_rules()
 747            if new_rules:
 748                self.rules = new_rules
 749            self.last_rule_reload = current_time
 750    
 751    def _get_request_body(self, request) -> Any:
 752        """获取请求 Body，尝试多种方式"""
 753        try:
 754            # 方式1: 直接获取 post_data
 755            post_data = request.post_data
 756            if post_data:
 757                return post_data
 758            
 759            # 方式2: 获取 post_data_buffer
 760            try:
 761                buffer = request.post_data_buffer
 762                if buffer:
 763                    return buffer.decode('utf-8')
 764            except:
 765                pass
 766            
 767            # 方式3: 获取 post_data_json
 768            try:
 769                json_data = request.post_data_json
 770                if json_data:
 771                    return json_data
 772            except:
 773                pass
 774            
 775            return None
 776        except Exception as e:
 777            print(f"[警告] 获取请求Body失败: {e}", flush=True)
 778            return None
 779    
 780    def _get_cache_key(self, url: str, method: str) -> str:
 781        """生成请求缓存的key"""
 782        return f"{method}:{url}"
 783    
 784    def handle_request(self, request):
 785        """处理请求 - 用于捕获所有请求的body（包括控制台fetch）"""
 786        url = request.url
 787        method = request.method
 788        
 789        # 只处理 API 请求
 790        if not self._is_api_request(url):
 791            return
 792        
 793        # 获取请求body（多种方式尝试）
 794        post_data = self._get_request_body(request)
 795        
 796        # 缓存请求信息
 797        cache_key = self._get_cache_key(url, method)
 798        with self._cache_lock:
 799            self._request_cache[cache_key] = {
 800                'post_data': post_data,
 801                'headers': dict(request.headers),
 802                'timestamp': time.time()
 803            }
 804        
 805        if post_data:
 806            print(f"[请求捕获] {method} {url}", flush=True)
 807            print(f"           Body: {str(post_data)[:100]}...", flush=True)
 808    
 809    def handle_route(self, route):
 810        """处理路由请求"""
 811        request = route.request
 812        url = request.url
 813        method = request.method
 814        post_data = self._get_request_body(request)
 815        headers = request.headers
 816        
 817        # 只处理 API 请求
 818        if not self._is_api_request(url):
 819            route.continue_()
 820            return
 821        
 822        self.request_count += 1
 823        
 824        # 标记此请求已通过route处理
 825        cache_key = self._get_cache_key(url, method)
 826        with self._route_lock:
 827            self._routed_requests.add(cache_key)
 828        
 829        # 检查是否需要重新加载规则
 830        self.reload_rules()
 831        
 832        # 查找匹配的规则
 833        matched_rule = None
 834        for rule in self.rules:
 835            if rule.matches(url, method):
 836                matched_rule = rule
 837                break
 838        
 839        if matched_rule:
 840            # 应用 Mock 规则
 841            if matched_rule.delay > 0:
 842                time.sleep(matched_rule.delay)
 843            
 844            self.mock_count += 1
 845            
 846            print(f"\n[MOCK] {method} {url}", flush=True)
 847            if matched_rule.description:
 848                print(f"       描述: {matched_rule.description}", flush=True)
 849            if post_data:
 850                print(f"       Body: {str(post_data)[:200]}", flush=True)
 851            
 852            try:
 853                response_body = matched_rule.mock_response if matched_rule.mock_response else {"mocked": True}
 854                response_text = json.dumps(response_body, ensure_ascii=False)
 855                
 856                route.fulfill(
 857                    status=matched_rule.status_code,
 858                    content_type="application/json",
 859                    body=response_text
 860                )
 861                
 862                # 记录 Mock 响应到 Excel
 863                self.excel_recorder.add_record(
 864                    url=url,
 865                    method=method,
 866                    status_code=matched_rule.status_code,
 867                    response_body=response_body,
 868                    post_data=post_data
 869                )
 870                
 871                # 清理缓存和标记
 872                with self._cache_lock:
 873                    if cache_key in self._request_cache:
 874                        del self._request_cache[cache_key]
 875                with self._route_lock:
 876                    self._routed_requests.discard(cache_key)
 877                
 878                return
 879            except Exception as e:
 880                print(f"       ✗ Mock 失败: {e}", flush=True)
 881        
 882        # 没有匹配规则，继续正常请求
 883        print(f"\n[请求] {method} {url}", flush=True)
 884        if post_data:
 885            data_str = str(post_data)
 886            print(f"       Body: {data_str[:200]}..." if len(data_str) > 200 else f"       Body: {post_data}", flush=True)
 887        
 888        route.continue_()
 889    
 890    def handle_response(self, response):
 891        """处理响应"""
 892        url = response.url
 893        status = response.status
 894        
 895        if not self._is_api_request(url):
 896            return
 897        
 898        self.response_count += 1
 899        
 900        # 获取请求信息
 901        request = response.request
 902        method = request.method if request else "GET"
 903        
 904        # 获取响应体 - 带错误处理
 905        body_json = None
 906        
 907        # 方式1: 尝试获取响应体
 908        try:
 909            # 检查响应是否可用
 910            if response.ok or status > 0:
 911                body = response.text()
 912                if body:
 913                    try:
 914                        body_json = json.loads(body)
 915                    except:
 916                        body_json = {"response_text": body[:500]}
 917                else:
 918                    body_json = {"_note": "响应体为空"}
 919            else:
 920                body_json = {"_note": f"响应状态: {status}"}
 921        except Exception as e:
 922            error_msg = str(e)
 923            # 针对控制台fetch的特殊处理
 924            if "Target page, context or browser has been closed" in error_msg:
 925                body_json = {"_note": "控制台fetch请求的响应无法通过Playwright获取（浏览器限制）"}
 926            elif "Response body is unavailable for redirect" in error_msg:
 927                body_json = {"_note": "重定向响应，无响应体"}
 928            else:
 929                body_json = {"_note": f"无法获取响应体: {error_msg}"}
 930        
 931        # 获取请求Body（从缓存中获取，包括控制台fetch请求）
 932        post_data = None
 933        cache_key = self._get_cache_key(url, method)
 934        
 935        # 从缓存获取（handle_request中设置，包含所有请求的body）
 936        with self._cache_lock:
 937            if cache_key in self._request_cache:
 938                cached_data = self._request_cache[cache_key]
 939                post_data = cached_data.get('post_data')
 940                # 获取后删除缓存（避免内存泄漏）
 941                del self._request_cache[cache_key]
 942                if post_data:
 943                    print(f"[调试] 从缓存获取到Body: {str(post_data)[:100]}...", flush=True)
 944        
 945        # 备用：尝试直接从 request 获取
 946        if not post_data and request:
 947            post_data = self._get_request_body(request)
 948            if post_data:
 949                print(f"[调试] 从request直接获取到Body: {str(post_data)[:100]}...", flush=True)
 950        
 951        # 记录到 Excel
 952        self.excel_recorder.add_record(
 953            url=url,
 954            method=method,
 955            status_code=status,
 956            response_body=body_json,
 957            post_data=post_data
 958        )
 959        
 960        # 调试信息
 961        body_preview = str(post_data)[:100] if post_data else "无"
 962        print(f"[响应] {method} {status} {url}", flush=True)
 963        print(f"       Body: {body_preview}...", flush=True)
 964    
 965    def _is_api_request(self, url: str) -> bool:
 966        """判断是否为 API 请求"""
 967        api_patterns = [
 968            r"/api/",
 969            r"/ajax/",
 970            r"/rest/",
 971            r"/graphql",
 972            r"\.json$",
 973            r"/v\d+/",
 974            r"/service/"
 975        ]
 976        return any(re.search(pattern, url) for pattern in api_patterns)
 977    
 978    def show_stats(self):
 979        """显示统计信息"""
 980        recorder_stats = self.excel_recorder.get_stats()
 981        
 982        print("\n" + "=" * 70, flush=True)
 983        print("统计信息", flush=True)
 984        print("=" * 70, flush=True)
 985        print(f"总请求数: {self.request_count}", flush=True)
 986        print(f"总响应数: {self.response_count}", flush=True)
 987        print(f"Mock 请求: {self.mock_count}", flush=True)
 988        print(f"成功记录: {recorder_stats['record_count']}", flush=True)
 989        print(f"待重试记录: {recorder_stats['failed_count']}", flush=True)
 990        print(f"记录文件: {self.records_excel}", flush=True)
 991        print(f"规则文件: {self.rules_excel}", flush=True)
 992        if recorder_stats['failed_records_path']:
 993            print(f"失败记录缓存: {recorder_stats['failed_records_path']}", flush=True)
 994        print(flush=True)
 995 
 996 
 997def create_example_rules_excel(excel_path: str = "api_rules.xlsx"):
 998    """创建示例规则 Excel 文件"""
 999    try:
1000        wb = openpyxl.Workbook()
1001        ws = wb.active
1002        ws.title = "Mock规则"
1003        
1004        # 表头（与记录器一致）
1005        headers = ["url_pattern", "method", "mock_response", "status_code", "delay", "enabled", "priority", "description", "request_params", "request_body"]
1006        ws.append(headers)
1007        
1008        # 设置表头样式
1009        header_fill = PatternFill(start_color="70AD47", end_color="70AD47", fill_type="solid")
1010        header_font = Font(bold=True, color="FFFFFF")
1011        for cell in ws[1]:
1012            cell.fill = header_fill
1013            cell.font = header_font
1014            cell.alignment = Alignment(horizontal="center", vertical="center")
1015        
1016        # 示例数据
1017        examples = [
1018            [
1019                r"/api/user/info",
1020                "GET",
1021                '{"code":200,"message":"success","data":{"id":123,"name":"Mock用户"}}',
1022                200,
1023                0.5,
1024                1,
1025                1,
1026                "Mock用户信息",
1027                "",
1028                ""
1029            ],
1030            [
1031                r"/api/auth/login",
1032                "POST",
1033                '{"code":200,"message":"登录成功","data":{"token":"mock_token"}}',
1034                200,
1035                1.0,
1036                1,
1037                2,
1038                "Mock登录接口",
1039                "",
1040                '{"username":"test","password":"123456"}'
1041            ],
1042            [
1043                r"/api/user/info",  # 相同的 url_pattern，但优先级较低，不会被使用
1044                "GET",
1045                '{"code":200,"data":{"id":999,"name":"低优先级"}}',
1046                200,
1047                0,
1048                1,
1049                10,
1050                "低优先级规则（不会被使用）",
1051                "",
1052                ""
1053            ],
1054            [
1055                r"/api/error",
1056                "*",
1057                '{"code":500,"message":"服务器错误"}',
1058                500,
1059                0,
1060                0,  # 禁用
1061                1,
1062                "禁用状态的错误Mock",
1063                "",
1064                ""
1065            ]
1066        ]
1067        
1068        for row in examples:
1069            ws.append(row)
1070        
1071        # 调整列宽
1072        ws.column_dimensions['A'].width = 40
1073        ws.column_dimensions['B'].width = 10
1074        ws.column_dimensions['C'].width = 50
1075        ws.column_dimensions['D'].width = 12
1076        ws.column_dimensions['E'].width = 8
1077        ws.column_dimensions['F'].width = 10
1078        ws.column_dimensions['G'].width = 10
1079        ws.column_dimensions['H'].width = 25
1080        ws.column_dimensions['I'].width = 40
1081        ws.column_dimensions['J'].width = 50
1082        
1083        wb.save(excel_path)
1084        print(f"✓ 已创建示例规则 Excel 文件: {excel_path}", flush=True)
1085        wb.close()
1086        return True
1087        
1088    except Exception as e:
1089        print(f"✗ 创建示例 Excel 失败: {e}", flush=True)
1090        return False
1091 
1092 
1093def main():
1094    """主函数"""
1095    if hasattr(sys.stdout, 'reconfigure'):
1096        sys.stdout.reconfigure(line_buffering=True)
1097    
1098    rules_excel = "api_rules.xlsx"
1099    # 生成带日期的记录文件名，格式: api_records_20250429.xlsx
1100    today_str = datetime.now().strftime('%Y%m%d')
1101    records_excel = f"api_records_{today_str}.xlsx"
1102    
1103    print("=" * 70, flush=True)
1104    print("Playwright API 记录器和 Mock 工具 - Excel 版", flush=True)
1105    print("=" * 70, flush=True)
1106    
1107    # 检查规则 Excel 文件是否存在
1108    if not os.path.exists(rules_excel):
1109        print(f"\n[提示] 未找到 {rules_excel}，正在创建示例文件...", flush=True)
1110        create_example_rules_excel(rules_excel)
1111        print("\n请编辑 api_rules.xlsx 文件添加您的规则，然后重新运行程序。", flush=True)
1112        return
1113    
1114    # 询问是否监听新标签页
1115    print("\n是否启用新标签页 API 监听? (y/n, 直接回车默认 n): ", end="", flush=True)
1116    try:
1117        listen_choice = input().strip().lower()
1118        listen_new_pages = listen_choice in ('y', 'yes', '1', 'true', '是')
1119    except:
1120        listen_new_pages = False
1121 
1122    if listen_new_pages:
1123        print("[配置] 已启用新标签页监听模式", flush=True)
1124    else:
1125        print("[配置] 仅监听首个标签页", flush=True)
1126 
1127    # 创建记录器
1128    recorder = APIRecorderExcel(rules_excel=rules_excel, records_excel=records_excel, listen_new_pages=listen_new_pages)
1129 
1130    # 初始加载规则
1131    recorder.rules = recorder.rule_loader.load_rules()
1132 
1133    print("\n请输入要访问的网址 (直接回车使用默认): ", end="", flush=True)
1134    try:
1135        url = input().strip()
1136        if not url:
1137            url = "https://www.example.com"
1138    except:
1139        url = "https://www.example.com"
1140    
1141    print(f"\n准备启动浏览器，访问: {url}", flush=True)
1142    print(f"[提示] 所有 API 请求和响应将实时记录到 {records_excel}", flush=True)
1143    print("[提示] 记录的格式与规则模板一致，可直接复制到规则中使用", flush=True)
1144    print("[提示] 写入失败时会自动重试，确保数据不丢失", flush=True)
1145    print("=" * 70, flush=True)
1146    
1147    # 设置信号处理
1148    def signal_handler(sig, frame):
1149        print("\n\n[停止] 正在保存...", flush=True)
1150        recorder.running = False
1151    
1152    signal.signal(signal.SIGINT, signal_handler)
1153    
1154    with sync_playwright() as p:
1155        browser = p.chromium.launch(
1156            headless=False,
1157            args=['--disable-web-security']
1158        )
1159        
1160        context = browser.new_context(viewport={'width': 1280, 'height': 800})
1161        page = context.new_page()
1162 
1163        # 为首个页面设置监听器
1164        recorder.setup_page_listeners(page)
1165 
1166        # 如果启用新标签页监听，监听新页面创建事件
1167        if recorder.listen_new_pages:
1168            context.on("page", lambda new_page: recorder.handle_new_page(new_page))
1169            print("[监听] 已启用新标签页自动监听", flush=True)
1170        
1171        try:
1172            print(f"\n[启动] 正在打开 {url}...", flush=True)
1173            page.goto(url, wait_until="networkidle", timeout=60000)
1174            
1175            print("\n[状态] 浏览器已打开，请手动操作...", flush=True)
1176            print("[提示] 按 Ctrl+C 结束程序\n", flush=True)
1177            
1178            # 保持程序运行
1179            while recorder.running:
1180                try:
1181                    page.wait_for_timeout(100)
1182                except:
1183                    break
1184                
1185        except KeyboardInterrupt:
1186            print("\n\n[停止] 检测到 Ctrl+C", flush=True)
1187        except Exception as e:
1188            print(f"\n[错误] 发生异常: {e}", flush=True)
1189        finally:
1190            recorder.show_stats()
1191            
1192            print("\n[关闭] 正在关闭浏览器...", flush=True)
1193            try:
1194                browser.close()
1195            except:
1196                pass
1197            
1198            print("\n" + "=" * 70, flush=True)
1199            print("程序已结束", flush=True)
1200            print(f"✓ API 记录已保存到: {records_excel}", flush=True)
1201            print("=" * 70, flush=True)
1202 
1203 
1204if __name__ == "__main__":
1205    main()

再附上另一个api测试程序（会自动使用上面录制保存的excel 测试）

这个程序可以配合上面的程序操作，比如你录制了一个新建商品的接口，那么在这个API 接口测试工具里面你就可以先在左边选择对应接口，然后在右边直接修改请求body里面的数据，直接发送请求就行（注意接口的Host配置要先改成后端接口的host哦~）

如果上面的API Recorder 程序运行时选择了监听新标签，那么如果你在Playwright打开的浏览器里面打开localhost:5000 这个网址发送的请求也会被记录/mock 下来！当然你也可以使用你日常使用的正常浏览器打开这样就不会被记录了，但是可能测试接口的时候会有跨域问题（API Recorder 这个程序打开的浏览器是配了允许跨域请求的）

   1"""
   2API 接口测试 Web 工具
   3功能：
   41. 读取当天 API 记录 Excel 文件
   52. 展示接口列表
   63. 支持 Host 配置
   74. 点击接口进行请求测试
   8 
   9使用方法：
  101. 先运行 api_recorder_excel.py 记录接口
  112. 运行本程序: python api_tester_web.py
  123. 在浏览器中打开 http://localhost:5000
  134. 配置 Host，选择接口进行测试
  14"""
  15 
  16from flask import Flask, render_template, jsonify, request
  17import openpyxl
  18import os
  19from datetime import datetime
  20import json
  21import requests
  22 
  23app = Flask(__name__)
  24 
  25# 全局配置
  26DEFAULT_HOST = "http://localhost:8080"
  27current_host = DEFAULT_HOST
  28 
  29 
  30def get_today_excel_path():
  31    """获取当天的 Excel 文件路径"""
  32    today_str = datetime.now().strftime('%Y%m%d')
  33    excel_path = f"api_records_{today_str}.xlsx"
  34    return excel_path
  35 
  36 
  37def load_api_records(excel_path=None):
  38    """从 Excel 加载 API 记录"""
  39    if excel_path is None:
  40        excel_path = get_today_excel_path()
  41    
  42    records = []
  43    
  44    if not os.path.exists(excel_path):
  45        return records
  46    
  47    try:
  48        wb = openpyxl.load_workbook(excel_path)
  49        ws = wb.active
  50        
  51        # 获取表头
  52        headers = [cell.value for cell in ws[1]]
  53        
  54        # 读取数据
  55        for row in ws.iter_rows(min_row=2):
  56            record = {}
  57            for idx, cell in enumerate(row):
  58                if idx < len(headers):
  59                    header = headers[idx]
  60                    value = cell.value
  61                    
  62                    # 处理 mock_response 字段，尝试解析为 JSON
  63                    if header == 'mock_response' and value:
  64                        try:
  65                            record[header] = json.loads(value)
  66                        except:
  67                            record[header] = value
  68                    else:
  69                        record[header] = value
  70            
  71            # 只添加有 url_pattern 的记录
  72            if record.get('url_pattern'):
  73                records.append(record)
  74        
  75        wb.close()
  76    except Exception as e:
  77        print(f"[错误] 读取 Excel 失败: {e}")
  78    
  79    return records
  80 
  81 
  82def parse_url_pattern(url_pattern, host):
  83    """将 URL 模式转换为可请求的 URL"""
  84    # 如果 url_pattern 已经是完整 URL，直接返回
  85    if url_pattern.startswith('http://') or url_pattern.startswith('https://'):
  86        return url_pattern
  87    
  88    # 确保 url_pattern 以 / 开头
  89    if not url_pattern.startswith('/'):
  90        url_pattern = '/' + url_pattern
  91    
  92    # 替换正则通配符为实际值（简化处理）
  93    # 例如: /api/user/\d+ -> /api/user/123
  94    import re
  95    url = url_pattern
  96    url = re.sub(r'\\d\+', '1', url)  # \d+ -> 1
  97    url = re.sub(r'\\w\+', 'abc', url)  # \w+ -> abc
  98    url = re.sub(r'\[.*?\]', '', url)  # 移除 [...]
  99    url = re.sub(r'\.', '', url)  # 移除 .
 100    url = re.sub(r'\*', '', url)  # 移除 *
 101    url = re.sub(r'\+', '', url)  # 移除 +
 102    url = re.sub(r'\?', '', url)  # 移除 ?
 103    url = re.sub(r'\\', '', url)  # 移除 \
 104    
 105    # 组合成完整 URL
 106    full_url = host.rstrip('/') + url
 107    
 108    return full_url
 109 
 110 
 111@app.route('/')
 112def index():
 113    """首页"""
 114    return render_template('api_tester.html')
 115 
 116 
 117@app.route('/api/config', methods=['GET', 'POST'])
 118def config():
 119    """获取/设置 Host 配置"""
 120    global current_host
 121    
 122    if request.method == 'POST':
 123        data = request.get_json()
 124        new_host = data.get('host', '').strip()
 125        if new_host:
 126            # 确保 host 以 http:// 或 https:// 开头
 127            if not new_host.startswith(('http://', 'https://')):
 128                new_host = 'http://' + new_host
 129            current_host = new_host
 130            return jsonify({'success': True, 'host': current_host})
 131        return jsonify({'success': False, 'error': 'Invalid host'})
 132    
 133    return jsonify({'host': current_host})
 134 
 135 
 136@app.route('/api/records')
 137def get_records():
 138    """获取 API 记录列表"""
 139    records = load_api_records()
 140    
 141    # 添加生成的测试 URL
 142    for record in records:
 143        url_pattern = record.get('url_pattern', '')
 144        if url_pattern:
 145            record['test_url'] = parse_url_pattern(url_pattern, current_host)
 146    
 147    return jsonify(records)
 148 
 149 
 150@app.route('/api/test', methods=['POST'])
 151def test_api():
 152    """测试 API 接口"""
 153    data = request.get_json()
 154    
 155    url = data.get('url', '')
 156    method = data.get('method', 'GET').upper()
 157    headers = data.get('headers', {})
 158    body = data.get('body', None)
 159    
 160    if not url:
 161        return jsonify({'success': False, 'error': 'URL is required'})
 162    
 163    try:
 164        # 设置默认 headers
 165        default_headers = {
 166            'Content-Type': 'application/json',
 167            'Accept': 'application/json'
 168        }
 169        default_headers.update(headers)
 170        
 171        # 发送请求
 172        start_time = datetime.now()
 173        
 174        if method == 'GET':
 175            response = requests.get(url, headers=default_headers, timeout=30)
 176        elif method == 'POST':
 177            json_body = json.loads(body) if body else None
 178            response = requests.post(url, headers=default_headers, json=json_body, timeout=30)
 179        elif method == 'PUT':
 180            json_body = json.loads(body) if body else None
 181            response = requests.put(url, headers=default_headers, json=json_body, timeout=30)
 182        elif method == 'DELETE':
 183            response = requests.delete(url, headers=default_headers, timeout=30)
 184        elif method == 'PATCH':
 185            json_body = json.loads(body) if body else None
 186            response = requests.patch(url, headers=default_headers, json=json_body, timeout=30)
 187        else:
 188            return jsonify({'success': False, 'error': f'Unsupported method: {method}'})
 189        
 190        end_time = datetime.now()
 191        duration = (end_time - start_time).total_seconds() * 1000  # 毫秒
 192        
 193        # 解析响应
 194        try:
 195            response_body = response.json()
 196        except:
 197            response_body = response.text
 198        
 199        return jsonify({
 200            'success': True,
 201            'status_code': response.status_code,
 202            'duration': round(duration, 2),
 203            'headers': dict(response.headers),
 204            'body': response_body,
 205            'url': response.url
 206        })
 207        
 208    except requests.exceptions.ConnectionError as e:
 209        return jsonify({'success': False, 'error': f'Connection error: {str(e)}'})
 210    except requests.exceptions.Timeout:
 211        return jsonify({'success': False, 'error': 'Request timeout'})
 212    except Exception as e:
 213        return jsonify({'success': False, 'error': str(e)})
 214 
 215 
 216@app.route('/api/history', methods=['GET', 'POST'])
 217def history():
 218    """获取/保存测试历史"""
 219    history_file = 'api_test_history.json'
 220    
 221    if request.method == 'POST':
 222        # 保存测试历史
 223        data = request.get_json()
 224        history_data = []
 225        
 226        if os.path.exists(history_file):
 227            try:
 228                with open(history_file, 'r', encoding='utf-8') as f:
 229                    history_data = json.load(f)
 230            except:
 231                history_data = []
 232        
 233        # 添加时间戳
 234        data['timestamp'] = datetime.now().isoformat()
 235        history_data.append(data)
 236        
 237        # 只保留最近 100 条
 238        history_data = history_data[-100:]
 239        
 240        with open(history_file, 'w', encoding='utf-8') as f:
 241            json.dump(history_data, f, ensure_ascii=False, indent=2)
 242        
 243        return jsonify({'success': True})
 244    
 245    # 获取测试历史
 246    if os.path.exists(history_file):
 247        try:
 248            with open(history_file, 'r', encoding='utf-8') as f:
 249                history_data = json.load(f)
 250            return jsonify(history_data[-50:])  # 返回最近 50 条
 251        except:
 252            pass
 253    
 254    return jsonify([])
 255 
 256 
 257def create_template():
 258    """创建 HTML 模板"""
 259    template_dir = os.path.join(os.path.dirname(__file__), 'templates')
 260    if not os.path.exists(template_dir):
 261        os.makedirs(template_dir)
 262 
 263    template_path = os.path.join(template_dir, 'api_tester.html')
 264 
 265    # 删除旧模板（如果存在），确保使用最新版本
 266    if os.path.exists(template_path):
 267        try:
 268            os.remove(template_path)
 269        except:
 270            pass
 271 
 272    html_content = '''<!DOCTYPE html>
 273<html lang="zh-CN">
 274<head>
 275    <meta charset="UTF-8">
 276    <meta name="viewport" content="width=device-width, initial-scale=1.0">
 277    <title>API 接口测试工具</title>
 278    <style>
 279        * {
 280            margin: 0;
 281            padding: 0;
 282            box-sizing: border-box;
 283        }
 284        
 285        body {
 286            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
 287            background: #f5f7fa;
 288            color: #333;
 289        }
 290        
 291        .header {
 292            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
 293            color: white;
 294            padding: 20px;
 295            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
 296        }
 297        
 298        .header h1 {
 299            font-size: 24px;
 300            margin-bottom: 15px;
 301        }
 302        
 303        .host-config {
 304            display: flex;
 305            align-items: center;
 306            gap: 10px;
 307            flex-wrap: wrap;
 308        }
 309        
 310        .host-config label {
 311            font-weight: 500;
 312        }
 313        
 314        .host-config input {
 315            padding: 8px 12px;
 316            border: none;
 317            border-radius: 4px;
 318            font-size: 14px;
 319            min-width: 300px;
 320        }
 321        
 322        .host-config button {
 323            padding: 8px 20px;
 324            background: #48bb78;
 325            color: white;
 326            border: none;
 327            border-radius: 4px;
 328            cursor: pointer;
 329            font-size: 14px;
 330            transition: background 0.3s;
 331        }
 332        
 333        .host-config button:hover {
 334            background: #38a169;
 335        }
 336        
 337        .container {
 338            max-width: 1400px;
 339            margin: 0 auto;
 340            padding: 20px;
 341            display: grid;
 342            grid-template-columns: 1fr 1fr;
 343            gap: 20px;
 344        }
 345        
 346        @media (max-width: 1024px) {
 347            .container {
 348                grid-template-columns: 1fr;
 349            }
 350        }
 351        
 352        .panel {
 353            background: white;
 354            border-radius: 8px;
 355            box-shadow: 0 2px 8px rgba(0,0,0,0.08);
 356            overflow: hidden;
 357        }
 358        
 359        .panel-header {
 360            background: #f8fafc;
 361            padding: 15px 20px;
 362            border-bottom: 1px solid #e2e8f0;
 363            font-weight: 600;
 364            font-size: 16px;
 365            display: flex;
 366            justify-content: space-between;
 367            align-items: center;
 368        }
 369        
 370        .panel-body {
 371            padding: 20px;
 372            max-height: 600px;
 373            overflow-y: auto;
 374        }
 375        
 376        .api-list {
 377            list-style: none;
 378        }
 379        
 380        .api-item {
 381            border: 1px solid #e2e8f0;
 382            border-radius: 6px;
 383            margin-bottom: 10px;
 384            padding: 12px;
 385            cursor: pointer;
 386            transition: all 0.2s;
 387            position: relative;
 388        }
 389        
 390        .api-item:hover {
 391            border-color: #667eea;
 392            box-shadow: 0 2px 8px rgba(102, 126, 234, 0.15);
 393        }
 394        
 395        .api-item.active {
 396            border-color: #667eea;
 397            background: #f7fafc;
 398        }
 399        
 400        .api-method {
 401            display: inline-block;
 402            padding: 2px 8px;
 403            border-radius: 3px;
 404            font-size: 12px;
 405            font-weight: 600;
 406            margin-right: 8px;
 407        }
 408        
 409        .api-method.GET { background: #48bb78; color: white; }
 410        .api-method.POST { background: #4299e1; color: white; }
 411        .api-method.PUT { background: #ed8936; color: white; }
 412        .api-method.DELETE { background: #f56565; color: white; }
 413        .api-method.PATCH { background: #9f7aea; color: white; }
 414        .api-method.* { background: #718096; color: white; }
 415        
 416        .api-url {
 417            font-family: monospace;
 418            font-size: 13px;
 419            color: #4a5568;
 420            word-break: break-all;
 421        }
 422        
 423        .api-desc {
 424            font-size: 12px;
 425            color: #718096;
 426            margin-top: 4px;
 427        }
 428        
 429        .test-form {
 430            display: flex;
 431            flex-direction: column;
 432            gap: 15px;
 433        }
 434        
 435        .form-group {
 436            display: flex;
 437            flex-direction: column;
 438            gap: 5px;
 439        }
 440        
 441        .form-group label {
 442            font-weight: 500;
 443            font-size: 14px;
 444            color: #4a5568;
 445        }
 446        
 447        .form-group input,
 448        .form-group select,
 449        .form-group textarea {
 450            padding: 10px;
 451            border: 1px solid #e2e8f0;
 452            border-radius: 4px;
 453            font-size: 14px;
 454            font-family: inherit;
 455        }
 456        
 457        .form-group input:focus,
 458        .form-group select:focus,
 459        .form-group textarea:focus {
 460            outline: none;
 461            border-color: #667eea;
 462        }
 463        
 464        .form-group textarea {
 465            min-height: 150px;
 466            resize: vertical;
 467            font-family: monospace;
 468        }
 469        
 470        .form-row {
 471            display: grid;
 472            grid-template-columns: 120px 1fr;
 473            gap: 10px;
 474            align-items: center;
 475        }
 476        
 477        .btn-primary {
 478            padding: 12px 24px;
 479            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
 480            color: white;
 481            border: none;
 482            border-radius: 4px;
 483            cursor: pointer;
 484            font-size: 14px;
 485            font-weight: 500;
 486            transition: opacity 0.3s;
 487        }
 488        
 489        .btn-primary:hover {
 490            opacity: 0.9;
 491        }
 492        
 493        .btn-primary:disabled {
 494            opacity: 0.6;
 495            cursor: not-allowed;
 496        }
 497        
 498        .response-panel {
 499            margin-top: 20px;
 500            border-top: 1px solid #e2e8f0;
 501            padding-top: 20px;
 502        }
 503        
 504        .response-header {
 505            display: flex;
 506            justify-content: space-between;
 507            align-items: center;
 508            margin-bottom: 10px;
 509        }
 510        
 511        .status-badge {
 512            padding: 4px 12px;
 513            border-radius: 12px;
 514            font-size: 12px;
 515            font-weight: 600;
 516        }
 517        
 518        .status-success {
 519            background: #c6f6d5;
 520            color: #22543d;
 521        }
 522        
 523        .status-error {
 524            background: #fed7d7;
 525            color: #742a2a;
 526        }
 527        
 528        .response-body {
 529            background: #f7fafc;
 530            border: 1px solid #e2e8f0;
 531            border-radius: 4px;
 532            padding: 15px;
 533            font-family: monospace;
 534            font-size: 13px;
 535            white-space: pre-wrap;
 536            word-break: break-all;
 537            max-height: 400px;
 538            overflow-y: auto;
 539        }
 540        
 541        .empty-state {
 542            text-align: center;
 543            padding: 40px;
 544            color: #a0aec0;
 545        }
 546        
 547        .loading {
 548            display: inline-block;
 549            width: 20px;
 550            height: 20px;
 551            border: 2px solid #e2e8f0;
 552            border-top-color: #667eea;
 553            border-radius: 50%;
 554            animation: spin 0.8s linear infinite;
 555        }
 556        
 557        @keyframes spin {
 558            to { transform: rotate(360deg); }
 559        }
 560        
 561        .stats {
 562            font-size: 12px;
 563            color: #718096;
 564        }
 565        
 566        .filter-box {
 567            margin-bottom: 15px;
 568        }
 569        
 570        .filter-box input {
 571            width: 100%;
 572            padding: 10px;
 573            border: 1px solid #e2e8f0;
 574            border-radius: 4px;
 575            font-size: 14px;
 576        }
 577    </style>
 578</head>
 579<body>
 580    <div class="header">
 581        <h1>🔧 API 接口测试工具</h1>
 582        <div class="host-config">
 583            <label>Host 配置:</label>
 584            <input type="text" id="hostInput" placeholder="http://localhost:8080" value="">
 585            <button onclick="saveHost()">保存配置</button>
 586            <span id="hostStatus" style="font-size: 12px;"></span>
 587        </div>
 588    </div>
 589    
 590    <div class="container">
 591        <!-- 左侧：接口列表 -->
 592        <div class="panel">
 593            <div class="panel-header">
 594                <span>📋 接口列表</span>
 595                <span class="stats" id="apiCount">加载中...</span>
 596            </div>
 597            <div class="panel-body">
 598                <div class="filter-box">
 599                    <input type="text" id="filterInput" placeholder="🔍 搜索接口..." oninput="filterApis()">
 600                </div>
 601                <ul class="api-list" id="apiList">
 602                    <li class="empty-state">加载中...</li>
 603                </ul>
 604            </div>
 605        </div>
 606        
 607        <!-- 右侧：测试面板 -->
 608        <div class="panel">
 609            <div class="panel-header">
 610                <span>🚀 接口测试</span>
 611            </div>
 612            <div class="panel-body">
 613                <div id="testPanel">
 614                    <div class="empty-state">
 615                        <p>👈 请从左侧选择一个接口进行测试</p>
 616                    </div>
 617                </div>
 618            </div>
 619        </div>
 620    </div>
 621    
 622    <script>
 623        let apiRecords = [];
 624        let currentHost = '';
 625        let selectedApi = null;
 626        const HOST_STORAGE_KEY = 'api_tester_host';
 627        const DEFAULT_HOST = window.location.origin;  // 默认使用当前访问的 host
 628 
 629        // 页面加载时初始化
 630        document.addEventListener('DOMContentLoaded', function() {
 631            loadConfig();
 632            loadApiRecords();
 633        });
 634 
 635        // 从 localStorage 加载 Host
 636        function loadHostFromStorage() {
 637            try {
 638                const savedHost = localStorage.getItem(HOST_STORAGE_KEY);
 639                if (savedHost) {
 640                    return savedHost;
 641                }
 642            } catch (e) {
 643                console.error('读取 localStorage 失败:', e);
 644            }
 645            return null;
 646        }
 647 
 648        // 保存 Host 到 localStorage
 649        function saveHostToStorage(host) {
 650            try {
 651                localStorage.setItem(HOST_STORAGE_KEY, host);
 652            } catch (e) {
 653                console.error('保存到 localStorage 失败:', e);
 654            }
 655        }
 656 
 657        // 加载配置
 658        async function loadConfig() {
 659            // 首先尝试从 localStorage 读取
 660            let host = loadHostFromStorage();
 661 
 662            // 如果 localStorage 没有，使用后端配置的默认值
 663            if (!host) {
 664                try {
 665                    const response = await fetch('/api/config');
 666                    const data = await response.json();
 667                    host = data.host;
 668                } catch (error) {
 669                    console.error('加载后端配置失败:', error);
 670                }
 671            }
 672 
 673            // 如果还是没有，使用当前访问的 host
 674            if (!host) {
 675                host = DEFAULT_HOST;
 676            }
 677 
 678            currentHost = host;
 679            document.getElementById('hostInput').value = currentHost;
 680        }
 681 
 682        // 保存 Host 配置
 683        async function saveHost() {
 684            const hostInput = document.getElementById('hostInput');
 685            const host = hostInput.value.trim();
 686 
 687            if (!host) {
 688                showStatus('请输入有效的 Host', 'error');
 689                return;
 690            }
 691 
 692            // 确保 host 格式正确
 693            let formattedHost = host;
 694            if (!formattedHost.startsWith('http://') && !formattedHost.startsWith('https://')) {
 695                formattedHost = 'http://' + formattedHost;
 696            }
 697 
 698            // 保存到 localStorage
 699            saveHostToStorage(formattedHost);
 700 
 701            // 更新当前 host
 702            currentHost = formattedHost;
 703 
 704            // 同步到后端（可选，保持兼容性）
 705            try {
 706                await fetch('/api/config', {
 707                    method: 'POST',
 708                    headers: { 'Content-Type': 'application/json' },
 709                    body: JSON.stringify({ host: formattedHost })
 710                });
 711            } catch (error) {
 712                console.error('同步到后端失败:', error);
 713            }
 714 
 715            showStatus('✓ 配置已保存', 'success');
 716 
 717            // 刷新接口列表中的测试 URL
 718            loadApiRecords();
 719        }
 720        
 721        // 显示状态信息
 722        function showStatus(message, type) {
 723            const statusEl = document.getElementById('hostStatus');
 724            statusEl.textContent = message;
 725            statusEl.style.color = type === 'success' ? '#48bb78' : '#f56565';
 726            setTimeout(() => {
 727                statusEl.textContent = '';
 728            }, 3000);
 729        }
 730        
 731        // 加载 API 记录
 732        async function loadApiRecords() {
 733            try {
 734                const response = await fetch('/api/records');
 735                apiRecords = await response.json();
 736                renderApiList(apiRecords);
 737            } catch (error) {
 738                console.error('加载 API 记录失败:', error);
 739                document.getElementById('apiList').innerHTML = 
 740                    '<li class="empty-state">加载失败，请检查 Excel 文件是否存在</li>';
 741            }
 742        }
 743        
 744        // 渲染接口列表
 745        function renderApiList(records) {
 746            const listEl = document.getElementById('apiList');
 747            const countEl = document.getElementById('apiCount');
 748            
 749            countEl.textContent = `共 ${records.length} 个接口`;
 750            
 751            if (records.length === 0) {
 752                listEl.innerHTML = '<li class="empty-state">暂无接口记录</li>';
 753                return;
 754            }
 755            
 756            listEl.innerHTML = records.map((record, index) => {
 757                const method = (record.method || '*').toUpperCase();
 758                const url = record.url_pattern || '';
 759                const desc = record.description || '';
 760                const testUrl = record.test_url || '';
 761                
 762                return `
 763                    <li class="api-item ${selectedApi === index ? 'active' : ''}" 
 764                        onclick="selectApi(${index})" 
 765                        data-url="${url.toLowerCase()}">
 766                        <span class="api-method ${method}">${method}</span>
 767                        <span class="api-url">${escapeHtml(url)}</span>
 768                        ${desc ? `<div class="api-desc">${escapeHtml(desc)}</div>` : ''}
 769                    </li>
 770                `;
 771            }).join('');
 772        }
 773        
 774        // 搜索过滤
 775        function filterApis() {
 776            const keyword = document.getElementById('filterInput').value.toLowerCase();
 777            const filtered = apiRecords.filter(record => {
 778                const url = (record.url_pattern || '').toLowerCase();
 779                const method = (record.method || '').toLowerCase();
 780                const desc = (record.description || '').toLowerCase();
 781                return url.includes(keyword) || method.includes(keyword) || desc.includes(keyword);
 782            });
 783            renderApiList(filtered);
 784        }
 785        
 786        // 选择接口
 787        function selectApi(index) {
 788            selectedApi = index;
 789            const record = apiRecords[index];
 790            
 791            // 更新列表样式
 792            document.querySelectorAll('.api-item').forEach((el, i) => {
 793                el.classList.toggle('active', i === index);
 794            });
 795            
 796            // 渲染测试表单
 797            renderTestForm(record);
 798        }
 799        
 800        // 渲染测试表单
 801        function renderTestForm(record) {
 802            const method = (record.method || 'GET').toUpperCase();
 803            const testUrl = record.test_url || '';
 804            const requestBody = record.request_body || '';
 805            
 806            // 尝试格式化请求 body
 807            let formattedBody = '';
 808            if (requestBody) {
 809                try {
 810                    const parsed = JSON.parse(requestBody);
 811                    formattedBody = JSON.stringify(parsed, null, 2);
 812                } catch {
 813                    formattedBody = requestBody;
 814                }
 815            }
 816            
 817            const panelEl = document.getElementById('testPanel');
 818            panelEl.innerHTML = `
 819                <div class="test-form">
 820                    <div class="form-row">
 821                        <label>请求方法</label>
 822                        <select id="testMethod">
 823                            <option value="GET" ${method === 'GET' ? 'selected' : ''}>GET</option>
 824                            <option value="POST" ${method === 'POST' ? 'selected' : ''}>POST</option>
 825                            <option value="PUT" ${method === 'PUT' ? 'selected' : ''}>PUT</option>
 826                            <option value="DELETE" ${method === 'DELETE' ? 'selected' : ''}>DELETE</option>
 827                            <option value="PATCH" ${method === 'PATCH' ? 'selected' : ''}>PATCH</option>
 828                        </select>
 829                    </div>
 830                    
 831                    <div class="form-group">
 832                        <label>请求 URL</label>
 833                        <input type="text" id="testUrl" value="${escapeHtml(testUrl)}" placeholder="http://...">
 834                    </div>
 835                    
 836                    <div class="form-group">
 837                        <label>请求 Headers (JSON 格式)</label>
 838                        <textarea id="testHeaders" placeholder='{"Authorization": "Bearer xxx"}'>{
 839  "Content-Type": "application/json"
 840}</textarea>
 841                    </div>
 842                    
 843                    <div class="form-group">
 844                        <label>请求 Body (JSON 格式)</label>
 845                        <textarea id="testBody" placeholder="{}">${escapeHtml(formattedBody)}</textarea>
 846                    </div>
 847                    
 848                    <div class="btn-group" style="display: flex; gap: 10px;">
 849                        <button class="btn-primary" onclick="sendRequestBackend()" id="sendBtnBackend" style="flex: 1;">
 850                            发送请求（后端）
 851                        </button>
 852                        <button class="btn-primary" onclick="sendRequestFrontend()" id="sendBtnFrontend" style="flex: 1; background: linear-gradient(135deg, #48bb78 0%, #38a169 100%);">
 853                            发送请求（前端）
 854                        </button>
 855                    </div>
 856                    
 857                    <div id="responsePanel" style="display: none;">
 858                        <div class="response-header">
 859                            <span class="status-badge" id="statusBadge"></span>
 860                            <span id="durationBadge"></span>
 861                            <span id="requestModeBadge" style="font-size: 12px; color: #718096; margin-left: 10px;"></span>
 862                        </div>
 863                        <div class="response-body" id="responseBody"></div>
 864                    </div>
 865                </div>
 866            `;
 867        }
 868        
 869        // 获取请求参数
 870        function getRequestParams(useCurrentHost = false) {
 871            let url = document.getElementById('testUrl').value.trim();
 872            const method = document.getElementById('testMethod').value;
 873            const headersText = document.getElementById('testHeaders').value.trim();
 874            const bodyText = document.getElementById('testBody').value.trim();
 875 
 876            if (!url) {
 877                alert('请输入请求 URL');
 878                return null;
 879            }
 880 
 881            // 如果使用当前设置的 Host，替换 URL 中的 Host 部分
 882            if (useCurrentHost && currentHost) {
 883                try {
 884                    const urlObj = new URL(url);
 885                    // 提取路径和查询参数
 886                    const path = urlObj.pathname + urlObj.search;
 887                    // 使用当前设置的 Host 构建新 URL
 888                    url = currentHost.replace(/\/$/, '') + path;
 889                } catch (e) {
 890                    // URL 解析失败，可能是相对路径，直接拼接
 891                    if (!url.startsWith('http')) {
 892                        url = currentHost.replace(/\/$/, '') + (url.startsWith('/') ? url : '/' + url);
 893                    }
 894                }
 895            }
 896 
 897            // 解析 headers
 898            let headers = {};
 899            if (headersText) {
 900                try {
 901                    headers = JSON.parse(headersText);
 902                } catch {
 903                    alert('Headers 格式错误，请使用 JSON 格式');
 904                    return null;
 905                }
 906            }
 907 
 908            return { url, method, headers, bodyText };
 909        }
 910        
 911        // 显示响应结果
 912        function displayResponse(success, statusCode, duration, body, mode) {
 913            const panel = document.getElementById('responsePanel');
 914            const badge = document.getElementById('statusBadge');
 915            const durationEl = document.getElementById('durationBadge');
 916            const modeEl = document.getElementById('requestModeBadge');
 917            const bodyEl = document.getElementById('responseBody');
 918            
 919            panel.style.display = 'block';
 920            
 921            if (success) {
 922                badge.className = 'status-badge status-success';
 923                badge.textContent = `${statusCode} OK`;
 924            } else {
 925                badge.className = 'status-badge status-error';
 926                badge.textContent = statusCode ? `${statusCode} Error` : 'Error';
 927            }
 928            
 929            durationEl.textContent = duration ? `⏱️ ${duration}ms` : '';
 930            modeEl.textContent = mode === 'frontend' ? '(前端请求)' : '(后端请求)';
 931            
 932            if (typeof body === 'object') {
 933                bodyEl.textContent = JSON.stringify(body, null, 2);
 934            } else {
 935                bodyEl.textContent = body || 'No response body';
 936            }
 937        }
 938        
 939        // 后端发送请求
 940        async function sendRequestBackend() {
 941            const params = getRequestParams(true);  // 使用当前设置的 Host
 942            if (!params) return;
 943            
 944            const { url, method, headers, bodyText } = params;
 945            const btn = document.getElementById('sendBtnBackend');
 946            
 947            btn.disabled = true;
 948            btn.innerHTML = '<span class="loading"></span> 请求中...';
 949            
 950            const startTime = Date.now();
 951            
 952            try {
 953                const response = await fetch('/api/test', {
 954                    method: 'POST',
 955                    headers: { 'Content-Type': 'application/json' },
 956                    body: JSON.stringify({
 957                        url: url,
 958                        method: method,
 959                        headers: headers,
 960                        body: bodyText
 961                    })
 962                });
 963                
 964                const data = await response.json();
 965                const duration = Date.now() - startTime;
 966                
 967                if (data.success) {
 968                    displayResponse(true, data.status_code, duration, data.body, 'backend');
 969                } else {
 970                    displayResponse(false, null, duration, data.error || 'Unknown error', 'backend');
 971                }
 972                
 973                // 保存测试历史
 974                saveTestHistory({
 975                    url: url,
 976                    method: method,
 977                    success: data.success,
 978                    status_code: data.status_code,
 979                    mode: 'backend'
 980                });
 981                
 982            } catch (error) {
 983                displayResponse(false, null, Date.now() - startTime, error.message, 'backend');
 984            } finally {
 985                btn.disabled = false;
 986                btn.textContent = '发送请求（后端）';
 987            }
 988        }
 989        
 990        // 前端发送请求
 991        async function sendRequestFrontend() {
 992            const params = getRequestParams(true);  // 使用当前设置的 Host
 993            if (!params) return;
 994            
 995            const { url, method, headers, bodyText } = params;
 996            const btn = document.getElementById('sendBtnFrontend');
 997            
 998            btn.disabled = true;
 999            btn.innerHTML = '<span class="loading"></span> 请求中...';
1000            
1001            const startTime = Date.now();
1002            
1003            try {
1004                // 构建 fetch 选项
1005                const fetchOptions = {
1006                    method: method,
1007                    headers: headers,
1008                    credentials: 'include'  // 携带 cookie
1009                };
1010                
1011                // 添加 body（非 GET 请求）
1012                if (method !== 'GET' && bodyText) {
1013                    // 如果 Content-Type 是 application/json，解析 body 为 JSON
1014                    const contentType = headers['Content-Type'] || headers['content-type'] || '';
1015                    if (contentType.includes('application/json')) {
1016                        try {
1017                            fetchOptions.body = JSON.stringify(JSON.parse(bodyText));
1018                        } catch {
1019                            fetchOptions.body = bodyText;
1020                        }
1021                    } else {
1022                        fetchOptions.body = bodyText;
1023                    }
1024                }
1025                
1026                const response = await fetch(url, fetchOptions);
1027                const duration = Date.now() - startTime;
1028                
1029                // 解析响应 body
1030                let responseBody;
1031                const responseContentType = response.headers.get('content-type') || '';
1032                
1033                if (responseContentType.includes('application/json')) {
1034                    responseBody = await response.json();
1035                } else {
1036                    responseBody = await response.text();
1037                }
1038                
1039                displayResponse(response.ok, response.status, duration, responseBody, 'frontend');
1040                
1041                // 保存测试历史
1042                saveTestHistory({
1043                    url: url,
1044                    method: method,
1045                    success: response.ok,
1046                    status_code: response.status,
1047                    mode: 'frontend'
1048                });
1049                
1050            } catch (error) {
1051                const duration = Date.now() - startTime;
1052                let errorMessage = error.message;
1053                
1054                // 处理常见的跨域错误
1055                if (error.name === 'TypeError' && errorMessage.includes('Failed to fetch')) {
1056                    errorMessage = '请求失败，可能是跨域问题或网络错误\\n' +
1057                                   '1. 确保目标服务器允许跨域请求\\n' +
1058                                   '2. 或者使用【后端发送请求】模式';
1059                }
1060                
1061                displayResponse(false, null, duration, errorMessage, 'frontend');
1062            } finally {
1063                btn.disabled = false;
1064                btn.textContent = '发送请求（前端）';
1065            }
1066        }
1067        
1068        // 保存测试历史
1069        async function saveTestHistory(data) {
1070            try {
1071                await fetch('/api/history', {
1072                    method: 'POST',
1073                    headers: { 'Content-Type': 'application/json' },
1074                    body: JSON.stringify(data)
1075                });
1076            } catch (error) {
1077                console.error('保存历史失败:', error);
1078            }
1079        }
1080        
1081        // HTML 转义
1082        function escapeHtml(text) {
1083            if (!text) return '';
1084            const div = document.createElement('div');
1085            div.textContent = text;
1086            return div.innerHTML;
1087        }
1088    </script>
1089</body>
1090</html>'''
1091    
1092    with open(template_path, 'w', encoding='utf-8') as f:
1093        f.write(html_content)
1094    
1095    print(f"[创建] HTML 模板已创建: {template_path}")
1096 
1097 
1098if __name__ == '__main__':
1099    # 创建模板文件
1100    create_template()
1101    
1102    print("=" * 70)
1103    print("API 接口测试 Web 工具")
1104    print("=" * 70)
1105    print(f"[启动] 正在启动服务...")
1106    print(f"[访问] 请在浏览器中打开: http://localhost:5000")
1107    print(f"[提示] 确保已运行 api_recorder_excel.py 生成了当天的记录文件")
1108    print("=" * 70)
1109    
1110    # 运行 Flask 应用
1111    app.run(host='0.0.0.0', port=5000, debug=True)

染卷不卷'blog

Web测试专属浏览器框架Playwright，全部api接口录制&mock

原理

实现方式

染卷

发表评论取消回复

2026 年 9 月
日	一	二	三	四	五	六
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30

原理

实现方式

染卷

发表评论 取消回复

发表评论取消回复