1412 lines
53 KiB
Python
1412 lines
53 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
iOS 自动化测试启动脚本
|
||
|
||
与 start.py 不同，此脚本直接通过 bundle_id 参数指定被测应用，
|
||
无需通过列表选择。适用于 iOS 自动化测试场景。
|
||
|
||
使用示例:
|
||
python start_ios.py -bundle_id com.example.app
|
||
python start_ios.py -bundle_id com.example.app -wda_url http://localhost:8100
|
||
python start_ios.py -bundle_id com.example.app -timeout 1800 -policy memory_guided
|
||
"""
|
||
|
||
import os
|
||
import argparse
|
||
import csv
|
||
import sys
|
||
import time
|
||
import subprocess
|
||
from pathlib import Path
|
||
from datetime import datetime
|
||
from dataclasses import dataclass, asdict
|
||
from typing import Optional, List, Dict, Tuple
|
||
|
||
# 找到项目根目录
|
||
ROOT = Path(__file__).resolve().parent
|
||
# 确保根目录在Python路径中
|
||
if str(ROOT) not in sys.path:
|
||
sys.path.insert(0, str(ROOT))
|
||
|
||
# 导入统一的日志配置模块
|
||
from logging_config import setup_logging, get_logger
|
||
|
||
# 导入 DroidBot
|
||
from DroidBot.droidbot import DroidBot
|
||
from DroidBot.guiagent_core.decision_maker import GuiAgentDecisionMaker
|
||
|
||
# 导入异常类
|
||
try:
|
||
from DroidBot.exceptions import FATAL_EXCEPTIONS, WDA_RECOVERABLE_EXCEPTIONS
|
||
from DroidBot.platforms.ios.wda.exceptions import WDAStuckError
|
||
# WDA_EXCEPTIONS 用于 run_test 中单独捕获 WDA 连接异常
|
||
WDA_EXCEPTIONS = WDA_RECOVERABLE_EXCEPTIONS + (WDAStuckError,)
|
||
except ImportError:
|
||
FATAL_EXCEPTIONS = (KeyboardInterrupt, SystemExit)
|
||
WDA_EXCEPTIONS = ()
|
||
WDAStuckError = None
|
||
|
||
|
||
def load_env_variables():
|
||
"""从 .env 文件加载环境变量到系统环境中"""
|
||
env_file = ROOT / ".env"
|
||
if not env_file.exists():
|
||
print(f"[WARN] .env 文件不存在: {env_file}")
|
||
return
|
||
|
||
try:
|
||
with open(env_file, 'r', encoding='utf-8') as f:
|
||
for line in f:
|
||
line = line.strip()
|
||
# 跳过空行和注释
|
||
if not line or line.startswith('#'):
|
||
continue
|
||
# 解析 KEY=VALUE 格式
|
||
if '=' in line:
|
||
key, value = line.split('=', 1)
|
||
key = key.strip()
|
||
value = value.strip()
|
||
# 设置到环境变量
|
||
os.environ[key] = value
|
||
print(f"[INFO] 已从 .env 加载环境变量")
|
||
except Exception as e:
|
||
print(f"[WARN] 加载 .env 文件失败: {e}")
|
||
|
||
|
||
def setup_iphone_proxy():
|
||
"""调用 fix_proxy.sh 脚本为 iPhone 设置代理网络"""
|
||
import subprocess
|
||
|
||
# 确保已加载环境变量
|
||
if 'SUDO' not in os.environ:
|
||
print("[WARN] SUDO 环境变量未设置，尝试从 .env 加载...")
|
||
load_env_variables()
|
||
|
||
# fix_proxy.sh 脚本路径
|
||
script_path = ROOT / "utils_ios" / "scripts" / "fix_proxy.sh"
|
||
|
||
if not script_path.exists():
|
||
print(f"[ERROR] fix_proxy.sh 脚本不存在: {script_path}")
|
||
return False
|
||
|
||
print(f"\n{'='*50}")
|
||
print("[INFO] 正在为 iPhone 设置代理网络...")
|
||
print(f"{'='*50}\n")
|
||
|
||
try:
|
||
# 执行脚本，传递环境变量
|
||
result = subprocess.run(
|
||
['bash', str(script_path)],
|
||
env=os.environ.copy(), # 传递包含 SUDO 的环境变量
|
||
capture_output=True,
|
||
text=True,
|
||
timeout=30
|
||
)
|
||
|
||
# 打印输出
|
||
if result.stdout:
|
||
print(result.stdout)
|
||
if result.stderr:
|
||
print(result.stderr, file=sys.stderr)
|
||
|
||
if result.returncode == 0:
|
||
print("[SUCCESS] iPhone 代理设置完成\n")
|
||
return True
|
||
else:
|
||
print(f"[ERROR] 代理设置失败，退出码: {result.returncode}\n")
|
||
return False
|
||
except subprocess.TimeoutExpired:
|
||
print("[ERROR] 代理设置超时\n")
|
||
return False
|
||
except Exception as e:
|
||
print(f"[ERROR] 执行 fix_proxy.sh 失败: {e}\n")
|
||
return False
|
||
|
||
|
||
# 状态码定义 (符合 Linux 惯例)
|
||
EXIT_SUCCESS = 0
|
||
EXIT_ERROR_USER = 1
|
||
EXIT_WDA_ERROR = 2
|
||
EXIT_WDA_STUCK = 6 # WDA 卡死且多次恢复失败
|
||
EXIT_NETWORK_ERROR = 3
|
||
EXIT_ERROR_GENERAL = 5
|
||
|
||
|
||
@dataclass
|
||
class TaskResult:
|
||
"""单次测试任务的执行结果"""
|
||
status: str # "SUCCESS" | "FAILED" | "INTERRUPTED"
|
||
exit_code: int # 退出码
|
||
error_reason: str # 错误原因（成功时为空字符串）
|
||
droidbot_steps: int # DroidBot 执行步数
|
||
guiagent_steps: int # GuiAgent 执行步数
|
||
total_steps: int # 总步数
|
||
duration_seconds: float # 执行耗时（秒）
|
||
test_timestamp: str = "" # 测试目录名中的时间戳（%Y%m%d_%H%M%S），与输出目录名对应
|
||
|
||
|
||
class IOSBatchStatistics:
|
||
"""iOS 批量测试统计管理器"""
|
||
|
||
def __init__(self, output_dir: str):
|
||
self.output_dir = output_dir
|
||
self.start_time = datetime.now()
|
||
self.records = [] # 存储所有测试记录
|
||
self.csv_filepath = None
|
||
|
||
def add_record(self, index: int, app_name: str, raw_app_name: str, app_id: str,
|
||
bundle_id: str, result: TaskResult):
|
||
"""添加一条测试记录"""
|
||
# 优先使用目录名中的时间戳，保持与输出目录一一对应；格式转换 %Y%m%d_%H%M%S -> %Y-%m-%d %H:%M:%S
|
||
if result.test_timestamp:
|
||
timestamp_str = result.test_timestamp
|
||
else:
|
||
timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
self.records.append({
|
||
"index": index,
|
||
"app_name": app_name,
|
||
"raw_app_name": raw_app_name,
|
||
"app_id": app_id,
|
||
"bundle_id": bundle_id,
|
||
"status": result.status,
|
||
"exit_code": result.exit_code,
|
||
"error_reason": result.error_reason,
|
||
"droidbot_steps": result.droidbot_steps,
|
||
"guiagent_steps": result.guiagent_steps,
|
||
"total_steps": result.total_steps,
|
||
"duration_seconds": round(result.duration_seconds, 2),
|
||
"timestamp": timestamp_str
|
||
})
|
||
|
||
def add_skip_record(self, index: int, app_name: str, raw_app_name: str, app_id: str, reason: str):
|
||
"""添加一条跳过记录（安装失败等）"""
|
||
self.records.append({
|
||
"index": index,
|
||
"app_name": app_name,
|
||
"raw_app_name": raw_app_name,
|
||
"app_id": app_id,
|
||
"bundle_id": "",
|
||
"status": "SKIPPED",
|
||
"exit_code": -1,
|
||
"error_reason": reason,
|
||
"droidbot_steps": 0,
|
||
"guiagent_steps": 0,
|
||
"total_steps": 0,
|
||
"duration_seconds": 0,
|
||
"timestamp": datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
})
|
||
|
||
def add_fail_record(self, index: int, app_name: str, raw_app_name: str, app_id: str, reason: str):
|
||
"""添加一条失败记录（应用不可用、付费应用等永久性失败，不应重试）"""
|
||
self.records.append({
|
||
"index": index,
|
||
"app_name": app_name,
|
||
"raw_app_name": raw_app_name,
|
||
"app_id": app_id,
|
||
"bundle_id": "",
|
||
"status": "FAILED",
|
||
"exit_code": -1,
|
||
"error_reason": reason,
|
||
"droidbot_steps": 0,
|
||
"guiagent_steps": 0,
|
||
"total_steps": 0,
|
||
"duration_seconds": 0,
|
||
"timestamp": datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
})
|
||
|
||
def save_csv(self):
|
||
"""保存统计结果到 CSV 文件（每次调用覆盖写入）"""
|
||
os.makedirs(self.output_dir, exist_ok=True)
|
||
filename = f"ios_batch_result_{self.start_time.strftime('%Y%m%d_%H%M%S')}.csv"
|
||
filepath = os.path.join(str(Path(self.output_dir).parent), filename)
|
||
|
||
fieldnames = ["index", "app_name", "raw_app_name", "app_id", "bundle_id", "status",
|
||
"exit_code", "error_reason", "droidbot_steps",
|
||
"guiagent_steps", "total_steps", "duration_seconds",
|
||
"timestamp"]
|
||
|
||
with open(filepath, 'w', newline='', encoding='utf-8') as f:
|
||
writer = csv.DictWriter(f, fieldnames=fieldnames)
|
||
writer.writeheader()
|
||
writer.writerows(self.records)
|
||
|
||
self.csv_filepath = filepath
|
||
print(f"[INFO] 批量统计结果已保存到: {filepath}")
|
||
return filepath
|
||
|
||
def print_summary(self):
|
||
"""打印批量测试摘要"""
|
||
total = len(self.records)
|
||
success = sum(1 for r in self.records if r["status"] == "SUCCESS")
|
||
failed = sum(1 for r in self.records if r["status"] == "FAILED")
|
||
skipped = sum(1 for r in self.records if r["status"] == "SKIPPED")
|
||
interrupted = sum(1 for r in self.records if r["status"] == "INTERRUPTED")
|
||
total_duration = sum(r["duration_seconds"] for r in self.records)
|
||
|
||
print(f"\n{'='*60}")
|
||
print(f" iOS 批量测试摘要")
|
||
print(f"{'='*60}")
|
||
print(f" 总数: {total}")
|
||
print(f" 成功: {success} | 失败: {failed} | 跳过: {skipped} | 中断: {interrupted}")
|
||
print(f" 总耗时: {total_duration:.1f} 秒 ({total_duration/3600:.1f} 小时)")
|
||
if self.csv_filepath:
|
||
print(f" 结果文件: {self.csv_filepath}")
|
||
print(f"{'='*60}\n")
|
||
|
||
|
||
class TeeOutput:
|
||
"""将输出同时写入控制台和文件，包括标准输出、标准错误和所有logging输出"""
|
||
def __init__(self, file_path):
|
||
self.file_path = file_path
|
||
self.file = open(file_path, 'w', encoding='utf-8', buffering=1) # 行缓冲
|
||
self.stdout = sys.stdout
|
||
self.stderr = sys.stderr
|
||
self.log_handler = None
|
||
|
||
def write(self, message):
|
||
try:
|
||
self.stdout.write(message)
|
||
self.file.write(message)
|
||
except Exception:
|
||
pass # 忽略写入错误，防止程序崩溃
|
||
|
||
def flush(self):
|
||
try:
|
||
self.stdout.flush()
|
||
self.file.flush()
|
||
except Exception:
|
||
pass
|
||
|
||
def fileno(self):
|
||
"""返回文件描述符，使某些库兼容"""
|
||
return self.stdout.fileno()
|
||
|
||
def isatty(self):
|
||
"""检查是否为终端"""
|
||
return self.stdout.isatty()
|
||
|
||
def setup_logging(self, debug_mode: bool = False):
|
||
"""设置根日志记录器，捕获所有logging模块输出到文件和终端"""
|
||
import logging
|
||
root_logger = logging.getLogger()
|
||
# debug_mode 时将根 logger 降到 DEBUG，否则保持 INFO
|
||
root_level = logging.DEBUG if debug_mode else logging.INFO
|
||
root_logger.setLevel(root_level)
|
||
|
||
# 文件处理器：始终捕获所有级别
|
||
self.log_handler = logging.FileHandler(self.file_path, mode='a', encoding='utf-8')
|
||
self.log_handler.setLevel(logging.DEBUG)
|
||
file_formatter = logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
|
||
self.log_handler.setFormatter(file_formatter)
|
||
root_logger.addHandler(self.log_handler)
|
||
|
||
# 终端处理器：debug_mode 时输出 DEBUG，否则只输出 INFO 及以上（避免重复添加）
|
||
if not any(isinstance(h, logging.StreamHandler) and not isinstance(h, logging.FileHandler)
|
||
for h in root_logger.handlers):
|
||
stream_handler = logging.StreamHandler()
|
||
stream_handler.setLevel(logging.DEBUG if debug_mode else logging.INFO)
|
||
stream_formatter = logging.Formatter('%(asctime)s %(levelname)-8s %(message)s',
|
||
datefmt='%H:%M:%S')
|
||
stream_handler.setFormatter(stream_formatter)
|
||
root_logger.addHandler(stream_handler)
|
||
|
||
# 抑制第三方库的 DEBUG 日志（即使 debug_mode 开启也不输出）
|
||
from logging_config import THIRD_PARTY_LOGGERS
|
||
for logger_name in THIRD_PARTY_LOGGERS:
|
||
logging.getLogger(logger_name).setLevel(logging.WARNING)
|
||
|
||
def close(self):
|
||
"""清理资源"""
|
||
import logging
|
||
if self.log_handler:
|
||
logging.getLogger().removeHandler(self.log_handler)
|
||
self.log_handler.close()
|
||
self.log_handler = None
|
||
if self.file and not self.file.closed:
|
||
self.file.close()
|
||
|
||
def __enter__(self):
|
||
return self
|
||
|
||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||
self.close()
|
||
return False
|
||
|
||
|
||
class IOSTestConfig:
|
||
"""iOS 测试配置参数"""
|
||
|
||
# --- 默认配置 ---
|
||
DEFAULT_WDA_URL: str = "http://localhost:8100"
|
||
DEFAULT_POLICY: str = "memory_guided"
|
||
DEFAULT_TIMEOUT: int = 3600
|
||
DEFAULT_EVENT_INTERVAL: int = 1
|
||
DEFAULT_EVENT_COUNT: int = 10000
|
||
|
||
# --- 输出配置 ---
|
||
OUTPUT_BASE_DIR: str = "./output/ios_test"
|
||
|
||
# --- 日志配置 ---
|
||
LOG_LEVEL: str = "DEBUG"
|
||
|
||
|
||
class IOSTestRunner:
|
||
"""iOS 测试执行器"""
|
||
|
||
def __init__(self, config: IOSTestConfig):
|
||
self.config = config
|
||
|
||
def run_test(self, bundle_id: str, wda_url: str, policy: str,
|
||
timeout: int, event_interval: int, event_count: int,
|
||
cv_mode: bool, debug_mode: bool, enable_guiagent: bool,
|
||
keep_app: bool, random_input: bool,
|
||
output_dir: str = None, model_name: str = "iOS",
|
||
wda_health_monitor=None) -> TaskResult:
|
||
"""执行 iOS 测试任务，返回 TaskResult"""
|
||
print(f"\n{'='*50}")
|
||
print(f"[INFO] 准备测试 iOS 应用: {bundle_id}")
|
||
print(f"[INFO] WDA URL: {wda_url}")
|
||
print(f"[INFO] 测试策略: {policy}")
|
||
print(f"[INFO] 超时时间: {timeout} 秒")
|
||
|
||
start_time = time.time()
|
||
ret_code = EXIT_ERROR_GENERAL
|
||
status = "FAILED"
|
||
error_reason = ""
|
||
|
||
# 重置全局步数计数器，确保每轮任务独立统计
|
||
GuiAgentDecisionMaker.total_steps = 0
|
||
|
||
# 初始化步数统计，确保 finally 块中能访问到
|
||
droidbot_steps = 0
|
||
guiagent_steps = 0
|
||
total_steps = 0
|
||
user_interrupted = False # 追踪用户中断，用于向上传递
|
||
|
||
# 生成带时间戳的输出目录
|
||
if output_dir is None:
|
||
# 格式: ./output/BundleId_ModelName_YYYYMMDD_HHMMSS
|
||
# 将 bundle_id 中的点替换为下划线
|
||
sanitized_bundle_id = bundle_id.replace('.', '_').replace(' ', '_')
|
||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
folder_name = f"{sanitized_bundle_id}_{model_name}_{timestamp}"
|
||
output_dir = os.path.join(self.config.OUTPUT_BASE_DIR, folder_name)
|
||
|
||
# 将日志目录写入 .env 文件（使用全局独立的 agent_logs 目录）
|
||
agent_log_dir = os.path.join(ROOT, "output", "agent_logs")
|
||
env_path = os.path.join(ROOT, "GuiAgent", ".env")
|
||
if os.path.exists(env_path):
|
||
with open(env_path, "r", encoding="utf-8") as f:
|
||
lines = f.readlines()
|
||
|
||
with open(env_path, "w", encoding="utf-8") as f:
|
||
found = False
|
||
for line in lines:
|
||
if line.startswith("AGENT_LOG_DIR="):
|
||
f.write(f"AGENT_LOG_DIR={agent_log_dir}\n")
|
||
found = True
|
||
else:
|
||
f.write(line)
|
||
if not found:
|
||
f.write(f"AGENT_LOG_DIR={agent_log_dir}\n")
|
||
else:
|
||
os.makedirs(os.path.dirname(env_path), exist_ok=True)
|
||
with open(env_path, "w", encoding="utf-8") as f:
|
||
f.write(f"AGENT_LOG_DIR={agent_log_dir}\n")
|
||
|
||
# 确保目录存在
|
||
os.makedirs(output_dir, exist_ok=True)
|
||
print(f"[INFO] 输出目录已创建: {output_dir}")
|
||
|
||
cmd_log_path = os.path.join(output_dir, "cmd_output.txt")
|
||
|
||
# ====== 配置 logging ======
|
||
# 使用统一的日志配置模块
|
||
import logging
|
||
|
||
setup_logging(
|
||
level=logging.DEBUG if debug_mode else logging.INFO,
|
||
log_file=None, # 日志文件通过TeeOutput处理
|
||
debug_mode=debug_mode
|
||
)
|
||
|
||
# 确保所有相关模块都使用正确的日志等级
|
||
logging_level = logging.DEBUG if debug_mode else logging.INFO
|
||
for logger_name in ['DroidBot', 'IOSDevice', 'InputEventManager', 'MemoryGuidedPolicy']:
|
||
logging.getLogger(logger_name).setLevel(logging_level)
|
||
|
||
if debug_mode:
|
||
print(f"[INFO] Debug 模式已启用，DroidBot 相关日志等级设置为 DEBUG，第三方库设置为 WARNING")
|
||
# ====== logging 配置完成 ======
|
||
|
||
# 直接调用 DroidBot（支持断点调试）
|
||
print(f"[INFO] 启动 DroidBot（函数调用模式，支持断点调试）")
|
||
print(f"{'='*50}\n")
|
||
|
||
# 设置输出重定向
|
||
tee = TeeOutput(cmd_log_path)
|
||
old_stdout = sys.stdout
|
||
old_stderr = sys.stderr
|
||
sys.stdout = tee
|
||
sys.stderr = tee
|
||
tee.setup_logging(debug_mode=debug_mode) # 设置日志处理器，捕获所有logging模块输出
|
||
|
||
try:
|
||
droidbot = DroidBot(
|
||
package_name=bundle_id,
|
||
device_serial=None, # iOS 不需要
|
||
is_emulator=False,
|
||
output_dir=output_dir,
|
||
policy_name=policy,
|
||
random_input=random_input,
|
||
event_interval=event_interval,
|
||
timeout=timeout,
|
||
event_count=event_count,
|
||
cv_mode=cv_mode,
|
||
debug_mode=debug_mode,
|
||
keep_app=keep_app,
|
||
keep_env=False,
|
||
profiling_method=None,
|
||
grant_perm=False,
|
||
enable_accessibility_hard=False,
|
||
humanoid=None,
|
||
ignore_ad=False,
|
||
replay_output=None,
|
||
enable_guiagent=enable_guiagent,
|
||
platform="ios",
|
||
wda_url=wda_url,
|
||
)
|
||
|
||
# 注入 WDA 健康监控（如果提供）
|
||
if wda_health_monitor and hasattr(droidbot, 'device'):
|
||
droidbot.device.set_health_monitor(wda_health_monitor)
|
||
|
||
droidbot.start()
|
||
ret_code = EXIT_SUCCESS
|
||
status = "SUCCESS"
|
||
error_reason = ""
|
||
|
||
# 统计步数
|
||
droidbot_steps = droidbot.input_manager.total_exploring_steps
|
||
guiagent_steps = GuiAgentDecisionMaker.total_steps
|
||
total_steps = droidbot_steps + guiagent_steps
|
||
|
||
print(f"\n[SUCCESS] iOS 测试任务完成: {bundle_id}")
|
||
|
||
except KeyboardInterrupt:
|
||
print(f"\n[WARN] 用户手动中断测试: {bundle_id}")
|
||
ret_code = EXIT_ERROR_USER
|
||
status = "INTERRUPTED"
|
||
error_reason = "用户手动中断"
|
||
user_interrupted = True # 标记需要向上传递中断
|
||
except WDA_EXCEPTIONS as e:
|
||
import traceback
|
||
# 区分 WDAStuckError（多次恢复失败）和普通 WDA 异常
|
||
if WDAStuckError and isinstance(e, WDAStuckError):
|
||
print(f"\n[ERROR] WDA 卡死且恢复失败: {e}")
|
||
print(traceback.format_exc())
|
||
ret_code = EXIT_WDA_STUCK
|
||
status = "FAILED"
|
||
error_reason = f"WDA 卡死恢复失败: {e}"
|
||
else:
|
||
print(f"\n[ERROR] WDA 连接异常: {e}")
|
||
print(traceback.format_exc())
|
||
ret_code = EXIT_WDA_ERROR
|
||
status = "FAILED"
|
||
error_reason = f"WDA 连接异常: {e}"
|
||
except Exception as e:
|
||
import traceback
|
||
print(f"\n[ERROR] DroidBot 执行异常: {e}")
|
||
print(traceback.format_exc())
|
||
ret_code = EXIT_ERROR_GENERAL
|
||
status = "FAILED"
|
||
error_reason = f"执行异常: {e}"
|
||
finally:
|
||
# 尝试获取步数（即使异常也尽量获取）
|
||
try:
|
||
guiagent_steps = GuiAgentDecisionMaker.total_steps
|
||
except Exception:
|
||
pass
|
||
total_steps = droidbot_steps + guiagent_steps
|
||
|
||
print(f"[INFO] DroidBot 步数: {droidbot_steps}")
|
||
print(f"[INFO] GUI Agent 步数: {guiagent_steps}")
|
||
print(f"[INFO] 总步数: {total_steps}")
|
||
|
||
# 恢复原来的stdout/stderr
|
||
sys.stdout = old_stdout
|
||
sys.stderr = old_stderr
|
||
tee.close()
|
||
|
||
end_time = time.time()
|
||
duration = end_time - start_time
|
||
hours, rem = divmod(duration, 3600)
|
||
minutes, seconds = divmod(rem, 60)
|
||
time_str = f"{int(hours)}小时 {int(minutes)}分 {int(seconds)}秒"
|
||
print(f"[INFO] 任务耗时: {time_str}\n")
|
||
|
||
if os.path.exists(output_dir):
|
||
try:
|
||
time_file_path = os.path.join(output_dir, "time_cost.txt")
|
||
with open(time_file_path, "w", encoding="utf-8") as f:
|
||
f.write(f"Test Duration: {time_str}\n")
|
||
f.write(f"Start Time: {datetime.fromtimestamp(start_time).strftime('%Y-%m-%d %H:%M:%S')}\n")
|
||
f.write(f"End Time: {datetime.fromtimestamp(end_time).strftime('%Y-%m-%d %H:%M:%S')}\n")
|
||
except Exception as e:
|
||
print(f"[ERROR] 无法记录耗时文件: {e}")
|
||
|
||
result = TaskResult(
|
||
status=status,
|
||
exit_code=ret_code,
|
||
error_reason=error_reason,
|
||
droidbot_steps=droidbot_steps,
|
||
guiagent_steps=guiagent_steps,
|
||
total_steps=total_steps,
|
||
duration_seconds=duration
|
||
)
|
||
|
||
# 如果是用户中断，返回结果后重新抛出异常，让上层能够捕获并退出
|
||
if user_interrupted:
|
||
raise KeyboardInterrupt(result)
|
||
|
||
return result
|
||
|
||
|
||
def parse_args():
|
||
"""解析命令行参数"""
|
||
parser = argparse.ArgumentParser(
|
||
description="iOS 自动化测试启动脚本",
|
||
formatter_class=argparse.RawTextHelpFormatter
|
||
)
|
||
|
||
# 必需参数
|
||
parser.add_argument("-bundle_id", action="store", dest="bundle_id",
|
||
default="com.apple.AppStore",
|
||
help="被测 iOS 应用的 Bundle ID (默认: com.apple.AppStore)")
|
||
|
||
# WDA 配置
|
||
parser.add_argument("-wda_url", action="store", dest="wda_url",
|
||
default=IOSTestConfig.DEFAULT_WDA_URL,
|
||
help=f"WDA Server URL (默认: {IOSTestConfig.DEFAULT_WDA_URL})")
|
||
|
||
# 测试配置
|
||
parser.add_argument("-policy", action="store", dest="policy",
|
||
default=IOSTestConfig.DEFAULT_POLICY,
|
||
help=f"测试策略 (默认: {IOSTestConfig.DEFAULT_POLICY})\n"
|
||
"支持的策略:\n"
|
||
" \"none\" -- 不发送事件，用户手动操作\n"
|
||
" \"memory_guided\" -- 内存引导的探索策略\n"
|
||
" \"manual\" -- 手动控制设备")
|
||
|
||
parser.add_argument("-timeout", action="store", dest="timeout", type=int,
|
||
default=IOSTestConfig.DEFAULT_TIMEOUT,
|
||
help=f"超时时间（秒）(默认: {IOSTestConfig.DEFAULT_TIMEOUT})")
|
||
|
||
parser.add_argument("-interval", action="store", dest="interval", type=int,
|
||
default=IOSTestConfig.DEFAULT_EVENT_INTERVAL,
|
||
help=f"事件间隔时间（秒）(默认: {IOSTestConfig.DEFAULT_EVENT_INTERVAL})")
|
||
|
||
parser.add_argument("-count", action="store", dest="count", type=int,
|
||
default=IOSTestConfig.DEFAULT_EVENT_COUNT,
|
||
help=f"事件总数 (默认: {IOSTestConfig.DEFAULT_EVENT_COUNT})")
|
||
|
||
# 输出配置
|
||
parser.add_argument("-o", action="store", dest="output_dir",
|
||
help="输出目录 (默认: 自动生成带时间戳的目录)")
|
||
|
||
# 模式开关
|
||
parser.add_argument("-cv", action="store_true", dest="cv_mode",
|
||
help="启用 CV 模式（使用 OmniParser 进行 UI 识别）")
|
||
|
||
parser.add_argument("-debug", action="store_true", dest="debug_mode",
|
||
help="启用调试模式")
|
||
|
||
parser.add_argument("-enable_guiagent", action="store_true", dest="enable_guiagent",
|
||
help="启用 GuiAgent 进行智能 UI 交互")
|
||
|
||
parser.add_argument("-keep_app", action="store_true", dest="keep_app",
|
||
help="测试后保留应用状态")
|
||
|
||
parser.add_argument("-random", action="store_true", dest="random_input",
|
||
help="在输入事件中添加随机性")
|
||
|
||
# 额外配置
|
||
parser.add_argument("-model", action="store", dest="model_name", default="iOS",
|
||
help="模型名称，用于输出目录命名 (默认: iOS)")
|
||
|
||
# Fastbot 模式
|
||
parser.add_argument("-fastbot", action="store_true", dest="fastbot_mode",
|
||
help="启用 Fastbot 测试模式（不使用 DroidBot）")
|
||
|
||
parser.add_argument("-duration", action="store", dest="duration", type=int,
|
||
default=None,
|
||
help="Fastbot 测试持续时间（秒）(默认: 使用 timeout 值)")
|
||
|
||
parser.add_argument("-throttle", action="store", dest="throttle", type=int,
|
||
default=1000,
|
||
help="Fastbot 事件间隔（毫秒）(默认: 1000)")
|
||
|
||
parser.add_argument("-udid", action="store", dest="udid",
|
||
help="设备 UDID（可选，默认使用第一个设备）")
|
||
|
||
parser.add_argument("-fastbot_port", action="store", dest="fastbot_port", type=int,
|
||
default=9197,
|
||
help="Fastbot 状态监控端口 (默认: 9197)")
|
||
|
||
# 应用安装和登录
|
||
parser.add_argument("-install_app", action="store", dest="install_app_id",
|
||
help="从 App Store 安装应用 (提供 app_id)")
|
||
|
||
parser.add_argument("-enable_login", action="store_true", dest="enable_login",
|
||
help="启用 Apple ID 登录和权限处理")
|
||
|
||
parser.add_argument("-skip_onboarding", action="store_true", dest="skip_onboarding",
|
||
default=True,
|
||
help="跳过应用引导页 (默认开启)")
|
||
|
||
# 批量测试参数
|
||
parser.add_argument("-batch", action="store_true", dest="batch_mode",
|
||
help="启用批量测试模式，从CSV文件加载应用列表")
|
||
|
||
parser.add_argument("-app_list", action="store", dest="app_list",
|
||
default=str(ROOT / "output" / "ios" / "app_magic_summary_apple_no_google.csv"),
|
||
help="应用列表CSV文件路径 (默认: output/ios/app_magic_summary_apple_no_google.csv)")
|
||
|
||
parser.add_argument("-start_index", action="store", dest="start_index", type=int,
|
||
default=0,
|
||
help="批量测试起始索引 (默认: 0)，用于断点续测")
|
||
|
||
parser.add_argument("-batch_count", action="store", dest="batch_count", type=int,
|
||
default=0,
|
||
help="批量测试数量 (默认: 0=全部)")
|
||
|
||
parser.add_argument("-enable_pcap", action="store_true", dest="enable_pcap",
|
||
help="启用 pcap 抓包")
|
||
|
||
|
||
return parser.parse_args()
|
||
|
||
|
||
def get_app_info_from_csv(app_id: str, csv_file: str = "appstore_mapping.csv") -> dict:
|
||
"""从CSV映射文件中读取应用信息（bundle_id 和 app_name）
|
||
|
||
从后往前读取，以最新的记录为准。
|
||
|
||
Returns:
|
||
dict: {'bundle_id': str, 'app_name': str}，未找到时返回空 dict
|
||
"""
|
||
import csv
|
||
if not os.path.exists(csv_file):
|
||
return {}
|
||
|
||
try:
|
||
with open(csv_file, 'r', encoding='utf-8') as f:
|
||
reader = csv.DictReader(f)
|
||
rows = list(reader)
|
||
|
||
# 从后往前遍历，以最新记录为准
|
||
for row in reversed(rows):
|
||
if row.get('app_id', '').strip() == app_id:
|
||
return {
|
||
'bundle_id': row.get('bundle_id', '').strip(),
|
||
'app_name': row.get('app_name', '').strip(),
|
||
}
|
||
except Exception as e:
|
||
print(f"[WARN] 读取CSV映射失败: {e}")
|
||
|
||
return {}
|
||
|
||
|
||
def get_bundle_id_from_csv(app_id: str, csv_file: str = "appstore_mapping.csv") -> Optional[str]:
|
||
"""从CSV映射文件中读取bundle_id（兼容旧接口）"""
|
||
info = get_app_info_from_csv(app_id, csv_file)
|
||
return info.get('bundle_id') or None
|
||
|
||
|
||
def load_apps_from_csv(csv_path: str, start_index: int = 0,
|
||
count: int = 0,
|
||
index_set: set = None) -> List[Dict[str, str]]:
|
||
"""从 iOS 应用列表 CSV 中加载 app_id 和 app_name
|
||
|
||
每条记录包含 'index' 字段（CSV 中去掉表头后的 0-based 行号），
|
||
该值是每个应用的唯一编号，与 batch_result CSV 中的 index 列一一对应。
|
||
|
||
Args:
|
||
csv_path: CSV 文件路径
|
||
start_index: 起始索引（0-based），当 index_set 为 None 时生效
|
||
count: 加载数量，0 表示全部，当 index_set 为 None 时生效
|
||
index_set: 若指定，则只加载行号在此集合中的应用（忽略 start_index/count）
|
||
|
||
Returns:
|
||
包含 index、app_id、name 的字典列表，顺序与 CSV 一致
|
||
"""
|
||
apps = []
|
||
try:
|
||
with open(csv_path, 'r', encoding='utf-8-sig') as f:
|
||
reader = csv.DictReader(f)
|
||
for i, row in enumerate(reader):
|
||
if index_set is not None:
|
||
# 精确加载指定行
|
||
if i not in index_set:
|
||
continue
|
||
else:
|
||
if i < start_index:
|
||
continue
|
||
if count > 0 and len(apps) >= count:
|
||
break
|
||
app_id = row.get('App_ID', '').strip()
|
||
name = row.get('Name', '').strip()
|
||
if app_id:
|
||
apps.append({'index': i, 'app_id': app_id, 'name': name})
|
||
except FileNotFoundError:
|
||
print(f"[ERROR] 应用列表文件不存在: {csv_path}")
|
||
except Exception as e:
|
||
print(f"[ERROR] 读取应用列表失败: {e}")
|
||
|
||
return apps
|
||
|
||
|
||
def start_pcap(bundle_id: str, udid: str, output_dir: str,
|
||
ios_executable: str = None, app_id: str = None, app_name: str = None, raw_app_name: str = None) -> Optional[subprocess.Popen]:
|
||
"""启动 pcap 抓包
|
||
|
||
Args:
|
||
bundle_id: 应用的 Bundle ID
|
||
udid: 设备 UDID
|
||
output_dir: 输出目录，pcap 文件保存路径
|
||
ios_executable: go-ios 可执行文件路径
|
||
|
||
Returns:
|
||
抓包进程对象，失败返回 None
|
||
"""
|
||
if ios_executable is None:
|
||
sys.path.insert(0, str(ROOT / "utils_ios" / "go_ios"))
|
||
from go_ios_runner import get_ios_executable
|
||
ios_executable = get_ios_executable()
|
||
|
||
os.makedirs(output_dir, exist_ok=True)
|
||
pcap_file = os.path.join(output_dir, "capture.pcap")
|
||
|
||
try:
|
||
cmd = [
|
||
ios_executable, "pcap",
|
||
f"--bundle={bundle_id}",
|
||
f"--udid={udid}",
|
||
f"--output={output_dir}",
|
||
"--allmark",
|
||
f"--appid={app_id}",
|
||
f"--appname={app_name}",
|
||
f"--rawappname={raw_app_name}",
|
||
]
|
||
print(f"[INFO] 启动抓包: {' '.join(cmd)}")
|
||
process = subprocess.Popen(
|
||
cmd,
|
||
stdout=subprocess.DEVNULL,
|
||
stderr=subprocess.DEVNULL
|
||
)
|
||
print(f"[SUCCESS] 抓包已启动 (PID: {process.pid})")
|
||
return process
|
||
except Exception as e:
|
||
print(f"[WARN] 启动抓包失败: {e}")
|
||
return None
|
||
|
||
|
||
def stop_pcap(process: Optional[subprocess.Popen]):
|
||
"""停止 pcap 抓包进程"""
|
||
if process and process.poll() is None:
|
||
try:
|
||
process.terminate()
|
||
process.wait(timeout=5)
|
||
print("[INFO] 抓包已停止")
|
||
except Exception:
|
||
process.kill()
|
||
print("[WARN] 抓包进程被强制终止")
|
||
|
||
|
||
def check_app_installed(bundle_id: str, udid: Optional[str] = None,
|
||
ssh_host: Optional[str] = None,
|
||
go_ios: str = 'ios') -> bool:
|
||
"""
|
||
检查应用是否已安装
|
||
|
||
Args:
|
||
bundle_id: 应用的 Bundle ID
|
||
udid: 设备 UDID
|
||
ssh_host: SSH主机地址
|
||
go_ios: go-ios 可执行文件路径
|
||
|
||
Returns:
|
||
应用是否已安装
|
||
"""
|
||
import subprocess
|
||
|
||
try:
|
||
base_cmd = [go_ios, "apps", "--list"]
|
||
if udid:
|
||
base_cmd.extend(["--udid", udid])
|
||
|
||
if ssh_host:
|
||
cmd = ["ssh", ssh_host, " ".join(base_cmd)]
|
||
else:
|
||
cmd = base_cmd
|
||
|
||
result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
|
||
if result.returncode != 0:
|
||
return False
|
||
|
||
# 检查 bundle_id 是否在输出中
|
||
for line in result.stdout.strip().split('\n'):
|
||
if line.strip() and line.split()[0] == bundle_id:
|
||
return True
|
||
|
||
return False
|
||
except Exception as e:
|
||
print(f"[WARN] 检查应用安装状态失败: {e}")
|
||
return False
|
||
|
||
|
||
def handle_app_installation(wda_url: str, app_id: str, udid: Optional[str] = None, health_monitor=None) -> Tuple[Optional[str], str]:
|
||
"""
|
||
处理应用安装
|
||
|
||
Returns:
|
||
Tuple[Optional[str], str]: (成功安装后的 bundle_id, 失败原因说明)
|
||
"""
|
||
print(f"\n{'='*50}")
|
||
print(f"[INFO] 开始安装应用: {app_id}")
|
||
print(f"{'='*50}\n")
|
||
|
||
# 导入安装器
|
||
sys.path.insert(0, str(ROOT / "DroidBot" / "platforms" / "ios"))
|
||
from package_init.ios_appstore_installer import install_from_appstore
|
||
|
||
# 执行安装
|
||
success, reason = install_from_appstore(
|
||
server_url=wda_url,
|
||
app_id=app_id,
|
||
timeout=600,
|
||
udid=udid,
|
||
ssh_host=None,
|
||
go_ios='ios',
|
||
alert_strategy="allow",
|
||
health_monitor=health_monitor
|
||
)
|
||
|
||
if not success:
|
||
print(f"[ERROR] 应用安装失败: {reason}")
|
||
return None, reason
|
||
|
||
print("[SUCCESS] 应用安装成功")
|
||
|
||
# 从CSV读取bundle_id（使用与安装器相同的路径）
|
||
# 注意：安装器内部会将纯数字 app_id 格式化为 id{app_id} 保存到 CSV
|
||
csv_file = os.path.join(ROOT, "output", "ios", "appstore_mapping.csv")
|
||
bundle_id = get_bundle_id_from_csv(app_id, csv_file)
|
||
if not bundle_id and app_id.isdigit():
|
||
# 尝试带 id 前缀的格式（安装器保存时使用的格式）
|
||
bundle_id = get_bundle_id_from_csv(f"id{app_id}", csv_file)
|
||
if bundle_id:
|
||
print(f"[INFO] 从CSV获取到 Bundle ID: {bundle_id}")
|
||
return bundle_id, ""
|
||
else:
|
||
print("[WARN] 无法从CSV获取Bundle ID，请手动指定")
|
||
return None, "无法从CSV获取Bundle ID"
|
||
|
||
|
||
def handle_apple_id_login(wda_url: str, bundle_id: str, skip_onboarding: bool = True) -> bool:
|
||
"""
|
||
处理Apple ID登录和权限
|
||
|
||
Returns:
|
||
是否成功
|
||
"""
|
||
print(f"\n{'='*50}")
|
||
print(f"[INFO] 开始处理Apple ID登录和权限")
|
||
print(f"[INFO] Bundle ID: {bundle_id}")
|
||
print(f"{'='*50}\n")
|
||
|
||
# 导入登录器
|
||
from utils_ios.package_init.ios_appleid_signer import sign_with_appleid
|
||
|
||
# 执行登录
|
||
success = sign_with_appleid(
|
||
server_url=wda_url,
|
||
bundle_id=bundle_id,
|
||
alert_strategy="allow",
|
||
skip_onboarding=skip_onboarding,
|
||
timeout=120,
|
||
try_login=True
|
||
)
|
||
|
||
if success:
|
||
print("[SUCCESS] Apple ID登录和权限处理完成")
|
||
else:
|
||
print("[WARN] Apple ID登录和权限处理未完全成功")
|
||
|
||
return success
|
||
|
||
|
||
def setup_infrastructure(args):
|
||
"""启动基础设施：tunnel、端口转发、WDA、代理网络、设备解锁
|
||
|
||
Returns:
|
||
(runner, udid) 元组，失败时 sys.exit(1)
|
||
"""
|
||
sys.path.insert(0, str(ROOT / "utils_ios"))
|
||
from go_ios import go_ios_runner
|
||
GoIOSRunner = go_ios_runner.GoIOSRunner
|
||
|
||
udid = args.udid or "00008101-0016601022C0001E"
|
||
runner = GoIOSRunner(udid=udid, wda_url=args.wda_url)
|
||
|
||
print("[INFO] 正在启动 WDA 基础设施...")
|
||
if not runner.start_infrastructure(wda_port=8100, use_tunnel=True, tunnel_sudo_password=os.getenv("SUDO")):
|
||
print("[ERROR] WDA 基础设施启动失败")
|
||
sys.exit(1)
|
||
|
||
print("[INFO] WDA 基础设施已启动，等待稳定...")
|
||
time.sleep(3)
|
||
|
||
# 设置 iPhone 代理网络
|
||
setup_iphone_proxy()
|
||
|
||
# 启动 WDA
|
||
print("[INFO] 正在启动 WDA...")
|
||
wda_process = runner.start_wda(port=8100)
|
||
print(f"[SUCCESS] WDA 已启动 (PID: {wda_process.pid})")
|
||
time.sleep(3)
|
||
# 等待 WDA 就绪后再操作设备
|
||
sys.path.insert(0, str(ROOT / "DroidBot" / "platforms" / "ios"))
|
||
from wda import Client as WDAClient, USBClient as WDAUSBClient
|
||
# 根据 wda_url 格式选择连接方式
|
||
if args.wda_url and args.wda_url.startswith("http:"):
|
||
c = WDAClient(args.wda_url)
|
||
else:
|
||
c = WDAUSBClient(udid=args.wda_url or udid or "")
|
||
print("[INFO] 等待 WDA 就绪...")
|
||
if not c.wait_ready(timeout=30):
|
||
print("[WARN] WDA 未就绪，继续尝试...")
|
||
|
||
# 解锁设备
|
||
try:
|
||
if c.locked():
|
||
print("[INFO] 设备已锁定，正在解锁...")
|
||
c.unlock()
|
||
time.sleep(1)
|
||
else:
|
||
print("[INFO] 设备未锁定")
|
||
except Exception as e:
|
||
print(f"[WARN] 设备解锁失败: {e}")
|
||
|
||
return runner, udid
|
||
|
||
|
||
def install_app_and_get_bundle_id(app_id: str, wda_url: str,
|
||
udid: str, health_monitor=None) -> Tuple[Optional[str], str]:
|
||
"""安装应用并获取 bundle_id
|
||
|
||
流程：CSV缓存查找 → 检查已安装 → 执行安装
|
||
|
||
Returns:
|
||
Tuple[Optional[str], str]: (bundle_id, 失败原因) 失败时 bundle_id 为 None
|
||
"""
|
||
csv_file = os.path.join(ROOT, "output", "ios", "appstore_mapping.csv")
|
||
|
||
# 1. 先从 CSV 查找是否有记录（兼容 id 前缀格式）
|
||
cached_bundle_id = get_bundle_id_from_csv(app_id, csv_file)
|
||
if not cached_bundle_id and app_id.isdigit():
|
||
cached_bundle_id = get_bundle_id_from_csv(f"id{app_id}", csv_file)
|
||
|
||
if cached_bundle_id:
|
||
print(f"[INFO] 从CSV找到记录: {app_id} -> {cached_bundle_id}")
|
||
|
||
# 2. 检查应用是否已安装
|
||
if check_app_installed(cached_bundle_id, udid=udid):
|
||
print(f"[SUCCESS] 应用已安装，跳过安装步骤: {cached_bundle_id}")
|
||
return cached_bundle_id, ""
|
||
else:
|
||
print(f"[INFO] 应用未安装，开始安装: {app_id}")
|
||
else:
|
||
print(f"[INFO] CSV中无记录，开始安装: {app_id}")
|
||
|
||
# 3. 执行安装
|
||
installed_bundle_id, reason = handle_app_installation(
|
||
wda_url=wda_url,
|
||
app_id=app_id,
|
||
udid=udid,
|
||
health_monitor=health_monitor
|
||
)
|
||
|
||
if installed_bundle_id:
|
||
print(f"[INFO] 安装成功，Bundle ID: {installed_bundle_id}")
|
||
else:
|
||
print(f"[ERROR] 安装失败: {app_id} - {reason}")
|
||
|
||
return installed_bundle_id, reason
|
||
|
||
|
||
def run_batch_mode(args):
|
||
"""批量测试模式主逻辑"""
|
||
print(f"\n{'='*60}")
|
||
print(f" iOS 批量测试模式")
|
||
print(f"{'='*60}")
|
||
print(f"[INFO] 应用列表: {args.app_list}")
|
||
print(f"[INFO] 起始索引: {args.start_index}")
|
||
print(f"[INFO] 批量数量: {args.batch_count or '全部'}")
|
||
|
||
# 1. 加载应用列表
|
||
apps = load_apps_from_csv(
|
||
csv_path=args.app_list,
|
||
start_index=args.start_index,
|
||
count=args.batch_count
|
||
)
|
||
|
||
if not apps:
|
||
print("[ERROR] 应用列表为空，退出")
|
||
sys.exit(1)
|
||
|
||
print(f"[INFO] 共加载 {len(apps)} 个应用")
|
||
|
||
# 2. 初始化批量统计
|
||
batch_output_dir = os.path.join(ROOT, "output")
|
||
stats = IOSBatchStatistics(batch_output_dir)
|
||
|
||
# 3. 启动基础设施（tunnel、端口转发、WDA、代理）
|
||
runner, udid = setup_infrastructure(args)
|
||
|
||
# 4. 初始化测试配置和运行器
|
||
config = IOSTestConfig()
|
||
test_runner = IOSTestRunner(config)
|
||
|
||
# 4b. 初始化 WDA 健康监控（用于卡死检测与异步恢复）
|
||
from utils_ios.wda_health import WDAHealthMonitor
|
||
wda_health_monitor = WDAHealthMonitor(
|
||
wda_url=args.wda_url,
|
||
go_ios_runner=runner
|
||
)
|
||
print("[INFO] WDA 健康监控已初始化")
|
||
|
||
# 5. 获取 go-ios 可执行文件路径（用于抓包）
|
||
ios_executable = runner.ios_executable
|
||
|
||
# 6. 遍历应用列表，逐个测试
|
||
try:
|
||
for idx, app_info in enumerate(apps):
|
||
app_id = app_info['app_id']
|
||
app_name = app_info['name']
|
||
real_index = app_info['index'] # CSV 中的 0-based 唯一行号
|
||
|
||
print(f"\n{'#'*60}")
|
||
print(f" [index={real_index}] ({idx+1}/{len(apps)}) {app_name}")
|
||
print(f" App ID: {app_id}")
|
||
print(f"{'#'*60}")
|
||
|
||
# 6a. 安装应用并获取 bundle_id
|
||
bundle_id = install_app_and_get_bundle_id(
|
||
app_id=app_id,
|
||
wda_url=args.wda_url,
|
||
udid=udid
|
||
)
|
||
|
||
if not bundle_id:
|
||
print(f"[SKIP] 跳过 {app_name}: 安装失败")
|
||
stats.add_skip_record(real_index, app_name, app_name, app_id, "安装失败")
|
||
stats.save_csv()
|
||
continue
|
||
|
||
# 6b. 处理Apple ID登录（如果启用）
|
||
if args.enable_login:
|
||
handle_apple_id_login(
|
||
wda_url=args.wda_url,
|
||
bundle_id=bundle_id,
|
||
skip_onboarding=args.skip_onboarding
|
||
)
|
||
|
||
# 6c. 启动抓包（如果启用）
|
||
pcap_process = None
|
||
if args.enable_pcap:
|
||
pcap_output_dir = os.path.join(
|
||
config.OUTPUT_BASE_DIR,
|
||
f"{bundle_id.replace('.', '_')}_iOS_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
|
||
)
|
||
pcap_process = start_pcap(
|
||
bundle_id=bundle_id,
|
||
udid=udid,
|
||
output_dir=pcap_output_dir,
|
||
ios_executable=ios_executable
|
||
)
|
||
|
||
# 6d. 执行测试
|
||
try:
|
||
result = test_runner.run_test(
|
||
bundle_id=bundle_id,
|
||
wda_url=args.wda_url,
|
||
policy=args.policy,
|
||
timeout=args.timeout,
|
||
event_interval=args.interval,
|
||
event_count=args.count,
|
||
cv_mode=args.cv_mode,
|
||
debug_mode=args.debug_mode,
|
||
enable_guiagent=args.enable_guiagent,
|
||
keep_app=False, # 批量模式不保留应用
|
||
random_input=args.random_input,
|
||
model_name=args.model_name,
|
||
wda_health_monitor=wda_health_monitor
|
||
)
|
||
stats.add_record(real_index, app_name, app_id, bundle_id, result)
|
||
print(f"[RESULT] {app_name}: {result.status} "
|
||
f"(步数: {result.total_steps}, 耗时: {result.duration_seconds:.1f}s)")
|
||
|
||
except KeyboardInterrupt as e:
|
||
# run_test 中用户中断会抛出 KeyboardInterrupt(TaskResult)
|
||
if e.args and isinstance(e.args[0], TaskResult):
|
||
result = e.args[0]
|
||
stats.add_record(real_index, app_name, app_id, bundle_id, result)
|
||
else:
|
||
stats.add_skip_record(real_index, app_name, app_name, app_id, "用户中断")
|
||
# 用户中断时保存结果并退出整个批量循环
|
||
print(f"\n[WARN] 用户中断，停止批量测试")
|
||
stats.save_csv()
|
||
stats.print_summary()
|
||
raise # 重新抛出，让外层处理
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] 测试 {app_name} 异常: {e}")
|
||
stats.add_skip_record(real_index, app_name, app_name, app_id, f"异常: {e}")
|
||
|
||
finally:
|
||
# 停止抓包
|
||
stop_pcap(pcap_process)
|
||
|
||
# 6e. 实时保存 CSV
|
||
stats.save_csv()
|
||
|
||
except KeyboardInterrupt:
|
||
print("\n[WARN] 批量测试被用户中断")
|
||
finally:
|
||
# 7. 打印最终摘要
|
||
stats.save_csv()
|
||
stats.print_summary()
|
||
|
||
# 8. 清理基础设施
|
||
print("[INFO] 正在清理资源...")
|
||
runner.stop_all()
|
||
print("[INFO] 清理完成")
|
||
|
||
|
||
def main():
|
||
"""主函数"""
|
||
args = parse_args()
|
||
|
||
# 加载环境变量（包括 SUDO）
|
||
load_env_variables()
|
||
|
||
print("--- iOS 自动化测试脚本启动 ---")
|
||
|
||
# ====== 批量测试模式 ======
|
||
if args.batch_mode:
|
||
run_batch_mode(args)
|
||
return
|
||
|
||
print(f"[INFO] Bundle ID: {args.bundle_id}")
|
||
|
||
# 判断运行模式
|
||
if args.fastbot_mode:
|
||
# Fastbot 模式
|
||
print(f"[INFO] 运行模式: Fastbot")
|
||
|
||
# 如果未指定 duration，使用 timeout
|
||
test_duration = args.duration if args.duration else args.timeout
|
||
print(f"[INFO] Duration: {test_duration}s, Throttle: {args.throttle}ms, Timeout: {args.timeout}s")
|
||
print(f"[INFO] UDID: {args.udid or 'auto'}")
|
||
|
||
# Import Fastbot runner
|
||
import sys
|
||
sys.path.insert(0, str(ROOT / "DroidBot" / "platforms" / "ios"))
|
||
from utils_ios.go_ios.go_ios_runner import GoIOSRunner
|
||
import time
|
||
import requests
|
||
|
||
udid = args.udid or "00008101-0016601022C0001E" # Default UDID
|
||
runner = GoIOSRunner(udid=udid, wda_url="http://localhost:8100")
|
||
|
||
try:
|
||
# 启动基础设施
|
||
print("[INFO] 正在启动基础设施...")
|
||
if not runner.start_infrastructure(wda_port=8100, fastbot_port=args.fastbot_port):
|
||
print("[ERROR] 基础设施启动失败")
|
||
sys.exit(1)
|
||
|
||
print("[INFO] 基础设施已启动，等待稳定...")
|
||
time.sleep(3)
|
||
|
||
# 设置 iPhone 代理网络
|
||
setup_iphone_proxy()
|
||
|
||
# 等待 WDA 就绪后再操作设备
|
||
from wda import Client as WDAClient, USBClient as WDAUSBClient
|
||
# Fastbot 模式中使用 UDID 连接
|
||
c = WDAUSBClient(udid=udid)
|
||
print("[INFO] 等待 WDA 就绪...")
|
||
if not c.wait_ready(timeout=30):
|
||
print("[WARN] WDA 未就绪，继续尝试...")
|
||
|
||
# 解锁设备
|
||
try:
|
||
if c.locked():
|
||
print("[INFO] 设备已锁定，正在解锁...")
|
||
c.unlock()
|
||
time.sleep(1)
|
||
else:
|
||
print("[INFO] 设备未锁定")
|
||
except Exception as e:
|
||
print(f"[WARN] 设备解锁失败: {e}")
|
||
|
||
# 处理应用安装（如果指定）
|
||
if args.install_app_id:
|
||
bundle_id = install_app_and_get_bundle_id(
|
||
app_id=args.install_app_id,
|
||
wda_url="http://localhost:8100",
|
||
udid=udid
|
||
)
|
||
if bundle_id:
|
||
args.bundle_id = bundle_id
|
||
elif not args.bundle_id or args.bundle_id == "com.apple.AppStore":
|
||
print("[ERROR] 安装失败且未指定Bundle ID，无法继续")
|
||
sys.exit(1)
|
||
|
||
|
||
# 处理Apple ID登录（如果启用）
|
||
if args.enable_login:
|
||
handle_apple_id_login(
|
||
wda_url="http://localhost:8100",
|
||
bundle_id=args.bundle_id,
|
||
skip_onboarding=args.skip_onboarding
|
||
)
|
||
|
||
# 启动 Fastbot
|
||
print(f"[INFO] 正在启动 Fastbot 测试...")
|
||
fastbot_process = runner.start_fastbot(
|
||
target_bundle_id=args.bundle_id,
|
||
duration=test_duration,
|
||
throttle=args.throttle
|
||
)
|
||
print(f"[SUCCESS] Fastbot 已启动 (PID: {fastbot_process.pid})")
|
||
|
||
# 监控状态（使用 timeout 作为总时长限制）
|
||
print(f"[INFO] 开始监控 Fastbot 状态 (端口 {args.fastbot_port})...")
|
||
status_url = f"http://127.0.0.1:{args.fastbot_port}/status"
|
||
last_status = None
|
||
start_time = time.time()
|
||
check_interval = 5 # 每5秒检查一次
|
||
|
||
while True:
|
||
# 检查是否超时
|
||
elapsed = time.time() - start_time
|
||
if elapsed >= args.timeout:
|
||
print(f"[WARN] 已达到超时时间 ({args.timeout}s)，停止监控")
|
||
fastbot_process.terminate()
|
||
break
|
||
|
||
# 检查进程是否结束
|
||
if fastbot_process.poll() is not None:
|
||
print(f"[INFO] Fastbot 进程已结束 (退出码: {fastbot_process.returncode}, 耗时: {elapsed:.1f}s)")
|
||
break
|
||
|
||
try:
|
||
response = requests.get(status_url, timeout=2)
|
||
if response.status_code == 200:
|
||
data = response.json()
|
||
running = data.get("runingStatus", False)
|
||
|
||
if running != last_status:
|
||
if running:
|
||
print(f"[STATUS] Fastbot 正在运行 ✓ (已运行 {elapsed:.1f}s / {args.timeout}s)")
|
||
else:
|
||
print(f"[STATUS] Fastbot 已停止 (耗时: {elapsed:.1f}s)")
|
||
break
|
||
last_status = running
|
||
elif running:
|
||
# 每30秒打印一次进度
|
||
if int(elapsed) % 30 == 0 and int(elapsed) > 0:
|
||
remaining = args.timeout - elapsed
|
||
print(f"[STATUS] Fastbot 运行中... (已运行 {elapsed:.1f}s, 剩余 {remaining:.1f}s)")
|
||
except requests.RequestException:
|
||
pass # Silently ignore connection errors
|
||
except KeyboardInterrupt:
|
||
print(f"\n[WARN] 用户中断测试 (已运行 {elapsed:.1f}s)")
|
||
fastbot_process.terminate()
|
||
break
|
||
|
||
time.sleep(check_interval)
|
||
|
||
# 等待进程完全结束
|
||
fastbot_process.wait()
|
||
total_elapsed = time.time() - start_time
|
||
print(f"[INFO] Fastbot 测试完成 (总耗时: {total_elapsed:.1f}s)")
|
||
|
||
except KeyboardInterrupt:
|
||
print("\n[WARN] 用户中断测试")
|
||
finally:
|
||
print("[INFO] 正在清理资源...")
|
||
runner.stop_all()
|
||
print("[INFO] 清理完成")
|
||
|
||
else:
|
||
# DroidBot 模式（单个应用）
|
||
print(f"[INFO] 运行模式: DroidBot")
|
||
print(f"[INFO] WDA URL: {args.wda_url}")
|
||
|
||
# 初始化WDA（如果需要）
|
||
if args.wda_url.startswith("http://localhost") or args.wda_url.startswith("http://127.0.0.1"):
|
||
runner, udid = setup_infrastructure(args)
|
||
else:
|
||
udid = args.udid
|
||
|
||
# 处理应用安装（如果指定）
|
||
if args.install_app_id:
|
||
bundle_id = install_app_and_get_bundle_id(
|
||
app_id=args.install_app_id,
|
||
wda_url=args.wda_url,
|
||
udid=udid or "00008101-0016601022C0001E"
|
||
)
|
||
if bundle_id:
|
||
args.bundle_id = bundle_id
|
||
elif not args.bundle_id or args.bundle_id == "com.apple.AppStore":
|
||
print("[ERROR] 安装失败且未指定Bundle ID，无法继续")
|
||
sys.exit(1)
|
||
|
||
|
||
# 处理Apple ID登录（如果启用）
|
||
if args.enable_login:
|
||
handle_apple_id_login(
|
||
wda_url=args.wda_url,
|
||
bundle_id=args.bundle_id,
|
||
skip_onboarding=args.skip_onboarding
|
||
)
|
||
|
||
# 初始化配置与运行器
|
||
config = IOSTestConfig()
|
||
test_runner = IOSTestRunner(config)
|
||
|
||
# 执行测试
|
||
test_runner.run_test(
|
||
bundle_id=args.bundle_id,
|
||
wda_url=args.wda_url,
|
||
policy=args.policy,
|
||
timeout=args.timeout,
|
||
event_interval=args.interval,
|
||
event_count=args.count,
|
||
cv_mode=args.cv_mode,
|
||
debug_mode=args.debug_mode,
|
||
enable_guiagent=args.enable_guiagent,
|
||
keep_app=args.keep_app,
|
||
random_input=args.random_input,
|
||
output_dir=args.output_dir,
|
||
model_name=args.model_name
|
||
)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|