pangolin/client/test/unit/connection_watchdog_test.dart

// connection_watchdog_test.dart — 连通看门狗:已连接后探测连续失败时,
// 智能选择自动切到其他节点;手动选定的节点只断开并提示。
import 'dart:async';

import 'package:flutter/widgets.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pangolin_vpn/bridge/vpn_bridge.dart';
import 'package:pangolin_vpn/bridge/vpn_bridge_provider.dart';
import 'package:pangolin_vpn/l10n/strings_zh.dart';
import 'package:pangolin_vpn/models/node.dart';
import 'package:pangolin_vpn/services/connect_api.dart';
import 'package:pangolin_vpn/state/connection_provider.dart';
import 'package:pangolin_vpn/state/nodes_provider.dart';

// 可控假桥:能手动推 VpnStatus,无内部计时器(避免 pending timer)。
class _FakeBridge implements VpnBridge {
  final _status = StreamController<VpnStatus>.broadcast();
  final _stats = StreamController<VpnStatsEvent>.broadcast();
  void emit(VpnStatus s) => _status.add(s);
  @override
  Stream<VpnStatus> get statusStream => _status.stream;
  @override
  Stream<VpnStatsEvent> get statsStream => _stats.stream;
  @override
  Future<void> start(String configJson) async {}
  @override
  Future<void> stop() async {}
  @override
  Future<VpnStatus> getStatus() async => VpnStatus.off;
  @override
  Future<void> selectOutbound(String tag) async {}
  @override
  Future<String> getActiveOutbound() async => 'auto';
  @override
  Future<void> setKillSwitch({required bool on}) async {}
  @override
  void dispose() {
    _status.close();
    _stats.close();
  }
}

// 重连时 fetchConfig 立即抛错,绕开真实网络(不留超时计时器)。
class _FakeConnectApi extends ConnectApi {
  _FakeConnectApi() : super(baseUrl: 'http://test.local', authToken: '');
  @override
  Future<String> fetchConfig({required String nodeId, required String deviceId, bool splitCN = false}) async {
    throw const ConnectApiException(statusCode: 0, messageZh: 'x', messageEn: 'x');
  }
  @override
  void dispose() {}
}

class _StubNodes extends NodesNotifier {
  @override
  Future<List<Node>> build() async => const [
        Node(code: 'HK', nameZh: '香港', nameEn: 'Hong Kong', ping: 20, uuid: 'hk-uuid', host: 'hk', port: 443),
        Node(code: 'JP', nameZh: '东京', nameEn: 'Tokyo', ping: 35, uuid: 'jp-uuid', host: 'jp', port: 443),
      ];
  @override
  Future<void> refresh() async {}
}

void main() {
  const t = StringsZh();

  ProviderContainer makeContainer(_FakeBridge bridge, {required bool healthy}) =>
      ProviderContainer(overrides: [
        vpnBridgeProvider.overrideWithValue(bridge),
        nodesProvider.overrideWith(_StubNodes.new),
        connectApiFactoryProvider.overrideWithValue((_) => _FakeConnectApi()),
        connectionProvider.overrideWith((ref) => ConnectionController(
              ref, ref.watch(vpnBridgeProvider),
              prober: () async => healthy,
            )),
      ]);

  // 驱动到 on,再走 3 个看门狗周期(每个 15s)。
  Future<void> driveOnAndProbe(WidgetTester tester, ProviderContainer c, _FakeBridge bridge) async {
    c.read(nodesProvider); // 触发(异步)节点加载
    await tester.pump(); // 等 valueOrNull 就绪(智能切换要读节点列表)
    c.read(connectionProvider); // 建 controller(订阅状态流)
    bridge.emit(VpnStatus.on);
    await tester.pump();
    expect(c.read(connectionProvider).phase, VpnPhase.on);
    for (var i = 0; i < 3; i++) {
      await tester.pump(const Duration(seconds: 15));
      await tester.pump();
    }
    await tester.pump();
  }

  testWidgets('智能模式:探测连续失败 → 自动切到其他最优节点', (tester) async {
    final bridge = _FakeBridge();
    final c = makeContainer(bridge, healthy: false);
    addTearDown(bridge.dispose);
    addTearDown(c.dispose);
    await tester.pumpWidget(UncontrolledProviderScope(container: c, child: const SizedBox()));
    // 默认即智能选择(selectedNodeCode = AUTO);有效节点取最小延迟 HK,故应切到 JP。
    await driveOnAndProbe(tester, c, bridge);
    expect(c.read(selectedNodeCodeProvider), 'JP', reason: '智能模式应自动切到其他最优节点');
  });

  testWidgets('手动选定节点:探测连续失败 → 断开并提示,不自动换', (tester) async {
    final bridge = _FakeBridge();
    final c = makeContainer(bridge, healthy: false);
    addTearDown(bridge.dispose);
    addTearDown(c.dispose);
    await tester.pumpWidget(UncontrolledProviderScope(container: c, child: const SizedBox()));
    c.read(selectedNodeCodeProvider.notifier).state = 'HK'; // 手动选定 HK
    await driveOnAndProbe(tester, c, bridge);
    expect(c.read(selectedNodeCodeProvider), 'HK', reason: '手动模式不应自动换节点');
    final st = c.read(connectionProvider);
    expect(st.phase, VpnPhase.off, reason: '应断开');
    expect(st.error, t.nodeUnhealthyError, reason: '应给出节点异常提示');
  });

  testWidgets('探测正常:不触发任何动作', (tester) async {
    final bridge = _FakeBridge();
    final c = makeContainer(bridge, healthy: true);
    addTearDown(bridge.dispose);
    addTearDown(c.dispose);
    await tester.pumpWidget(UncontrolledProviderScope(container: c, child: const SizedBox()));
    c.read(selectedNodeCodeProvider.notifier).state = 'HK';
    await driveOnAndProbe(tester, c, bridge);
    expect(c.read(connectionProvider).phase, VpnPhase.on, reason: '健康时应保持连接');
    expect(c.read(selectedNodeCodeProvider), 'HK');
    bridge.emit(VpnStatus.off); // 收尾:停看门狗/计时器,避免 pending timer
    await tester.pump();
  });
}