v9.0 Phase3: 网络模拟+设备池+前端5视图 - 786个测试全绿

Phase3新增:
- NetworkSimulator: 7种预设网络环境(perfect/wifi/4g/3g/slow/unstable/offline)
- DevicePoolManager: 设备注册/分配/释放/健康检查/批量分配
- 13个新API端点(网络模拟5+设备池8)
- 前端多端协同页新增5视图页签(网格/时序轴/AI扮演/录制回放/一致性)
- 48个新增测试(NetworkSimulator18+DevicePool30)
- v9.0全部完成: Phase1协调器+Phase2 AI/录制/一致性+Phase3网络/设备池

Author: zcj220

desktop/src/pages/MultiPlayerTestPage.tsx

@@ -1523,4 +1523,139 @@ async def consistency_summary() -> dict:
         """获取一致性检查历史摘要。"""
         return _checker.get_summary()
 
+    # ── 多端协同 Phase3（v9.0）────────────────────
+
+    from src.testing.network_simulator import NetworkSimulator, NetworkConfig, NetworkProfile
+    from src.testing.device_pool import DevicePoolManager, DeviceType, DeviceState
+
+    _network = NetworkSimulator()
+    _device_pool = DevicePoolManager()
+
+    @router.post("/multiplayer/network/enable", tags=["多端协同-网络模拟"])
+    async def enable_network_sim() -> dict:
+        """启用网络模拟。"""
+        _network.enable()
+        return {"enabled": True}
+
+    @router.post("/multiplayer/network/disable", tags=["多端协同-网络模拟"])
+    async def disable_network_sim() -> dict:
+        """禁用网络模拟。"""
+        _network.disable()
+        return {"enabled": False}
+
+    @router.post("/multiplayer/network/profile", tags=["多端协同-网络模拟"])
+    async def set_network_profile(req: dict) -> dict:
+        """设置网络环境预设。
+
+        Body: profile(perfect/wifi/4g/3g/slow/unstable/offline), player_id(可选)
+        """
+        profile = NetworkProfile(req.get("profile", "perfect"))
+        config = NetworkConfig.from_profile(profile)
+        player_id = req.get("player_id")
+        if player_id:
+            _network.set_player(player_id, config)
+        else:
+            _network.set_global(config)
+        _network.enable()
+        return {
+            "profile": profile.value,
+            "player_id": player_id or "全局",
+            "latency_ms": config.latency_ms,
+            "packet_loss": config.packet_loss,
+        }
+
+    @router.post("/multiplayer/network/custom", tags=["多端协同-网络模拟"])
+    async def set_network_custom(req: dict) -> dict:
+        """设置自定义网络条件。
+
+        Body: latency_ms, jitter_ms, packet_loss, bandwidth_kbps, player_id(可选)
+        """
+        config = NetworkConfig(
+            latency_ms=req.get("latency_ms", 0),
+            jitter_ms=req.get("jitter_ms", 0),
+            packet_loss=req.get("packet_loss", 0.0),
+            bandwidth_kbps=req.get("bandwidth_kbps", 0),
+        )
+        player_id = req.get("player_id")
+        if player_id:
+            _network.set_player(player_id, config)
+        else:
+            _network.set_global(config)
+        _network.enable()
+        return {"player_id": player_id or "全局", "config": {
+            "latency_ms": config.latency_ms, "jitter_ms": config.jitter_ms,
+            "packet_loss": config.packet_loss, "bandwidth_kbps": config.bandwidth_kbps,
+        }}
+
+    @router.get("/multiplayer/network/stats", tags=["多端协同-网络模拟"])
+    async def network_stats() -> dict:
+        """获取网络模拟统计。"""
+        return _network.get_stats()
+
+    @router.post("/multiplayer/devices/register", tags=["多端协同-设备池"])
+    async def register_device(req: dict) -> dict:
+        """注册设备到池。
+
+        Body: device_id, device_type(browser/android/ios/desktop/miniprogram), name, capabilities, tags
+        """
+        device = _device_pool.register(
+            device_id=req.get("device_id", ""),
+            device_type=DeviceType(req.get("device_type", "browser")),
+            name=req.get("name", ""),
+            capabilities=req.get("capabilities", {}),
+            tags=req.get("tags", []),
+        )
+        return {"device_id": device.device_id, "type": device.device_type.value, "total": _device_pool.device_count}
+
+    @router.delete("/multiplayer/devices/{device_id}", tags=["多端协同-设备池"])
+    async def unregister_device(device_id: str) -> dict:
+        """注销设备。"""
+        _device_pool.unregister(device_id)
+        return {"device_id": device_id, "total": _device_pool.device_count}
+
+    @router.post("/multiplayer/devices/acquire", tags=["多端协同-设备池"])
+    async def acquire_device(req: dict) -> dict:
+        """为玩家分配设备。
+
+        Body: player_id, device_type(可选), tags(可选)
+        """
+        dtype = DeviceType(req["device_type"]) if "device_type" in req else None
+        device = _device_pool.acquire(req.get("player_id", ""), dtype, req.get("tags"))
+        if device:
+            return {"device_id": device.device_id, "type": device.device_type.value, "assigned_to": device.assigned_to}
+        raise HTTPException(status_code=404, detail="无可用设备")
+
+    @router.post("/multiplayer/devices/release/{device_id}", tags=["多端协同-设备池"])
+    async def release_device(device_id: str) -> dict:
+        """释放设备。"""
+        _device_pool.release(device_id)
+        return {"device_id": device_id, "state": "available"}
+
+    @router.post("/multiplayer/devices/auto-assign", tags=["多端协同-设备池"])
+    async def auto_assign_devices(req: dict) -> dict:
+        """批量自动分配。
+
+        Body: configs: [{player_id, device_type, tags}]
+        """
+        result = _device_pool.auto_assign(req.get("configs", []))
+        return {"assignments": result}
+
+    @router.post("/multiplayer/devices/release-all", tags=["多端协同-设备池"])
+    async def release_all_devices() -> dict:
+        """释放所有在用设备。"""
+        count = _device_pool.release_all()
+        return {"released": count}
+
+    @router.get("/multiplayer/devices/summary", tags=["多端协同-设备池"])
+    async def device_pool_summary() -> dict:
+        """获取设备池摘要。"""
+        return _device_pool.get_summary()
+
+    @router.post("/multiplayer/devices/health-check", tags=["多端协同-设备池"])
+    async def device_health_check(req: dict = None) -> dict:
+        """设备健康检查。"""
+        req = req or {}
+        offline = _device_pool.check_health(req.get("timeout", 60))
+        return {"offline_count": len(offline), "offline_devices": offline}
+
     return router

src/api/routes.py

@@ -0,0 +1,216 @@
+"""
+设备池管理器（v9.0 Phase3）
+
+管理可用测试设备/浏览器实例，支持：设备注册/注销、自动分配、健康检查、并发控制。
+"""
+
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Optional
+
+from loguru import logger
+
+
+class DeviceType(str, Enum):
+    """设备类型。"""
+    BROWSER = "browser"
+    ANDROID = "android"
+    IOS = "ios"
+    DESKTOP = "desktop"
+    MINIPROGRAM = "miniprogram"
+
+
+class DeviceState(str, Enum):
+    """设备状态。"""
+    AVAILABLE = "available"
+    IN_USE = "in_use"
+    OFFLINE = "offline"
+    MAINTENANCE = "maintenance"
+
+
+@dataclass
+class DeviceInfo:
+    """设备信息。"""
+    device_id: str
+    device_type: DeviceType
+    name: str = ""
+    state: DeviceState = DeviceState.AVAILABLE
+    capabilities: dict = field(default_factory=dict)
+    assigned_to: str = ""        # 分配给哪个玩家
+    last_heartbeat: float = 0.0
+    registered_at: float = 0.0
+    tags: list[str] = field(default_factory=list)
+
+
+class DevicePoolManager:
+    """设备池管理器。"""
+
+    def __init__(self, max_devices: int = 20) -> None:
+        self.max_devices = max_devices
+        self._devices: dict[str, DeviceInfo] = {}
+
+    @property
+    def device_count(self) -> int:
+        return len(self._devices)
+
+    @property
+    def available_count(self) -> int:
+        return sum(1 for d in self._devices.values() if d.state == DeviceState.AVAILABLE)
+
+    def register(self, device_id: str, device_type: DeviceType,
+                 name: str = "", capabilities: dict = None, tags: list[str] = None) -> DeviceInfo:
+        """注册设备到池中。"""
+        if len(self._devices) >= self.max_devices:
+            raise ValueError(f"设备池已满 ({self.max_devices})")
+        if device_id in self._devices:
+            raise ValueError(f"设备 {device_id} 已存在")
+
+        device = DeviceInfo(
+            device_id=device_id,
+            device_type=device_type,
+            name=name or device_id,
+            capabilities=capabilities or {},
+            tags=tags or [],
+            registered_at=time.time(),
+            last_heartbeat=time.time(),
+        )
+        self._devices[device_id] = device
+        logger.info("设备注册 | {} | 类型: {} | 池中: {}", device_id, device_type.value, len(self._devices))
+        return device
+
+    def unregister(self, device_id: str) -> None:
+        """从池中注销设备。"""
+        if device_id not in self._devices:
+            raise KeyError(f"设备 {device_id} 不存在")
+        del self._devices[device_id]
+        logger.info("设备注销 | {} | 剩余: {}", device_id, len(self._devices))
+
+    def get(self, device_id: str) -> Optional[DeviceInfo]:
+        return self._devices.get(device_id)
+
+    def acquire(self, player_id: str, device_type: DeviceType = None,
+                tags: list[str] = None) -> Optional[DeviceInfo]:
+        """为玩家分配一个可用设备。
+
+        Args:
+            player_id: 请求设备的玩家
+            device_type: 需要的设备类型（None=任意）
+            tags: 需要匹配的标签（全部匹配）
+        """
+        for device in self._devices.values():
+            if device.state != DeviceState.AVAILABLE:
+                continue
+            if device_type and device.device_type != device_type:
+                continue
+            if tags and not all(t in device.tags for t in tags):
+                continue
+
+            device.state = DeviceState.IN_USE
+            device.assigned_to = player_id
+            logger.info("设备分配 | {} -> {} | 类型: {}", device.device_id, player_id, device.device_type.value)
+            return device
+
+        logger.warning("无可用设备 | 玩家: {} | 类型: {} | 标签: {}", player_id, device_type, tags)
+        return None
+
+    def release(self, device_id: str) -> None:
+        """释放设备，使其可重新分配。"""
+        device = self._devices.get(device_id)
+        if not device:
+            raise KeyError(f"设备 {device_id} 不存在")
+        device.state = DeviceState.AVAILABLE
+        device.assigned_to = ""
+        logger.info("设备释放 | {}", device_id)
+
+    def heartbeat(self, device_id: str) -> None:
+        """更新设备心跳。"""
+        device = self._devices.get(device_id)
+        if device:
+            device.last_heartbeat = time.time()
+
+    def set_state(self, device_id: str, state: DeviceState) -> None:
+        """设置设备状态。"""
+        device = self._devices.get(device_id)
+        if not device:
+            raise KeyError(f"设备 {device_id} 不存在")
+        device.state = state
+
+    def check_health(self, timeout_seconds: float = 60) -> list[str]:
+        """检查设备健康：超过 timeout 无心跳的标记为 offline。返回离线设备ID列表。"""
+        now = time.time()
+        offline = []
+        for device in self._devices.values():
+            if device.state == DeviceState.OFFLINE:
+                continue
+            if now - device.last_heartbeat > timeout_seconds:
+                device.state = DeviceState.OFFLINE
+                offline.append(device.device_id)
+                logger.warning("设备离线 | {} | 最后心跳: {:.0f}s前", device.device_id, now - device.last_heartbeat)
+        return offline
+
+    def list_devices(self, device_type: DeviceType = None,
+                     state: DeviceState = None) -> list[DeviceInfo]:
+        """列出设备（可按类型/状态过滤）。"""
+        devices = list(self._devices.values())
+        if device_type:
+            devices = [d for d in devices if d.device_type == device_type]
+        if state:
+            devices = [d for d in devices if d.state == state]
+        return devices
+
+    def auto_assign(self, player_configs: list[dict]) -> dict[str, Optional[str]]:
+        """批量自动分配设备。
+
+        Args:
+            player_configs: [{"player_id": "p1", "device_type": "browser", "tags": [...]}]
+        Returns:
+            {player_id: device_id or None}
+        """
+        result = {}
+        for cfg in player_configs:
+            pid = cfg.get("player_id", "")
+            dtype = DeviceType(cfg["device_type"]) if "device_type" in cfg else None
+            tags = cfg.get("tags", [])
+            device = self.acquire(pid, dtype, tags)
+            result[pid] = device.device_id if device else None
+        return result
+
+    def release_all(self) -> int:
+        """释放所有在用设备。"""
+        count = 0
+        for device in self._devices.values():
+            if device.state == DeviceState.IN_USE:
+                device.state = DeviceState.AVAILABLE
+                device.assigned_to = ""
+                count += 1
+        return count
+
+    def clear(self) -> None:
+        """清空设备池。"""
+        self._devices.clear()
+
+    def get_summary(self) -> dict:
+        """获取设备池摘要。"""
+        by_type = {}
+        by_state = {}
+        for d in self._devices.values():
+            by_type[d.device_type.value] = by_type.get(d.device_type.value, 0) + 1
+            by_state[d.state.value] = by_state.get(d.state.value, 0) + 1
+        return {
+            "total": len(self._devices),
+            "max": self.max_devices,
+            "available": self.available_count,
+            "by_type": by_type,
+            "by_state": by_state,
+            "devices": [
+                {
+                    "id": d.device_id,
+                    "type": d.device_type.value,
+                    "name": d.name,
+                    "state": d.state.value,
+                    "assigned_to": d.assigned_to,
+                }
+                for d in self._devices.values()
+            ],
+        }