import 'dart:async'; import 'dart:convert'; import 'package:flutter/widgets.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:mornye/services/link/client/link_client_controller.dart'; import 'package:mornye/services/link/client/link_client_discovery.dart'; import 'package:mornye/services/link/client/link_client_pairing.dart'; import 'package:mornye/services/link/client/link_client_session.dart'; import 'package:mornye/services/link/client/link_client_store.dart'; import 'package:mornye/services/link/features/link_phone_options.dart'; import 'package:mornye/services/link/link_client_api.dart'; import 'package:mornye/services/link/link_protocol.dart'; import 'package:mornye/services/local_network_access.dart'; import 'package:mornye/services/network_storage_service.dart'; import 'package:shared_preferences/shared_preferences.dart'; import 'support/link_client_fakes.dart'; Future _started({ bool supported = true, String platform = 'android', bool localNetworkAllowed = true, bool onWifi = true, Stream networkChanges = const Stream.empty(), }) async { final harness = LinkClientHarness( supported: supported, platform: platform, networkChanges: networkChanges, ) ..localNetworkAllowed = localNetworkAllowed ..onWifi = onWifi; addTearDown(harness.container.dispose); await harness.start(); await pumpEventQueue(); return harness; } Future _lifecycle(List states) async { for (final state in states) { TestWidgetsFlutterBinding.instance.handleAppLifecycleStateChanged(state); } await pumpEventQueue(); } void main() { TestWidgetsFlutterBinding.ensureInitialized(); setUp(() { SharedPreferences.setMockInitialValues({}); TestWidgetsFlutterBinding.instance.handleAppLifecycleStateChanged( AppLifecycleState.resumed, ); }); test('remembers what a host announces when pairing and connecting', () async { final harness = await _started(); final base = linkTestTarget('a'); final phone = LinkPairingTarget( address: base.address, info: LinkServerInfo( serverId: base.info.serverId, name: 'Pocket', protocol: base.info.protocol, appVersion: base.info.appVersion, fingerprint: base.info.fingerprint, pairing: true, platform: 'android', features: const [], ), ); final record = await harness.controller.pair(phone, '123456'); await pumpEventQueue(); expect(record.isPhone, isTrue); expect(record.supports(LinkHostFeatures.downloads), isFalse); expect((await LinkClientStore().servers()).single.features, isEmpty); // The host updated meanwhile: its welcome tells the session. final session = harness.sessions.single; session.server = session.server.announced( platform: 'android', features: const [LinkHostFeatures.open], ); session.emit(LinkConnectionState.connected); await pumpEventQueue(); expect(harness.state.servers.single.features, [LinkHostFeatures.open]); expect((await LinkClientStore().servers()).single.features, [ LinkHostFeatures.open, ]); }); test('pairing publishes the first desktop and follows the choice', () async { final harness = await _started(); expect(harness.state.loaded, isTrue); expect(harness.state.activeServerId, isNull); expect(harness.active, isNull); final a = await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); expect(harness.pairing.pins, ['123456']); final device = harness.pairing.devices.single; expect(device.name, 'Test phone'); expect(device.platform, 'android'); expect(device.deviceId, await LinkClientStore().deviceId()); final connection = harness.bridge.connections[a.connectionId]!; expect(connection.protocol, NetworkProtocol.subsonic); expect(connection.subsonicAuth, SubsonicAuth.apiKey); expect(connection.apiKey, 'key-1'); expect(connection.address, 'https://10.0.0.2:47710'); expect(connection.name, 'Desktop a'); expect(connection.trustedCertificateSha256, linkTestFingerprint('a')); expect(harness.bridge.calls, [ 'save ${a.connectionId}', 'source ${a.connectionId}', ]); expect(harness.state.activeServerId, 'a'); expect(harness.sessions, hasLength(1)); final first = harness.sessions.single; expect(harness.active, same(first)); expect(first.apiKey, 'key-1'); expect(first.calls, ['start']); final stored = await LinkClientStore().servers(); expect(stored.single.toJson(), a.toJson()); // A second desktop does not take over. await harness.controller.pair( linkTestTarget('b', host: '10.0.0.3'), '654321', ); await pumpEventQueue(); expect(harness.state.servers.map((s) => s.serverId), ['a', 'b']); expect(harness.sessions, hasLength(1)); expect(harness.active, same(first)); await harness.controller.setActive('b'); await pumpEventQueue(); expect(harness.sessions, hasLength(2)); expect(first.disposed, isTrue); expect(harness.active, same(harness.sessions.last)); expect(harness.active!.server.serverId, 'b'); expect(await LinkClientStore().activeServerId(), 'b'); final b = harness.state.activeServer!; await harness.controller.forget('b', removeLibrary: true); await pumpEventQueue(); expect(harness.state.activeServerId, 'a'); expect(harness.active!.server.serverId, 'a'); expect(harness.sessions[1].disposed, isTrue); expect(harness.bridge.calls.last, 'remove ${b.connectionId}'); await harness.controller.forget('a', removeLibrary: false); await pumpEventQueue(); expect(harness.state.servers, isEmpty); expect(harness.active, isNull); expect(harness.bridge.connections, contains(a.connectionId)); expect(await LinkClientStore().servers(), isEmpty); }); test('re-pairing replaces the key and keeps the connection', () async { final harness = await _started(); final first = await harness.controller.pair(linkTestTarget('a'), '111111'); harness.pairing.key = 'key-2'; final second = await harness.controller.pair( linkTestTarget('a', host: '10.0.0.9'), '222222', ); await pumpEventQueue(); expect(second.connectionId, first.connectionId); expect(harness.state.servers, hasLength(1)); expect(harness.state.servers.single.address, 'https://10.0.0.9:47710'); expect(harness.bridge.connections[first.connectionId]!.apiKey, 'key-2'); expect(harness.sessions.last.apiKey, 'key-2'); expect(harness.sessions.first.disposed, isTrue); expect(harness.active, same(harness.sessions.last)); }); test( 'hiding computer songs keeps all pairings and the active session', () async { final harness = await _started(); final a = await harness.controller.pair(linkTestTarget('a'), '123456'); final b = await harness.controller.pair(linkTestTarget('b'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; final options = harness.container.read(linkPhoneOptionsProvider.notifier); options.setShowComputerSongs(false); await pumpEventQueue(); expect(harness.bridge.librarySources, { a.connectionId: false, b.connectionId: false, }); expect(harness.bridge.connections, hasLength(2)); expect(harness.state.servers, hasLength(2)); expect(harness.active, same(session)); expect(session.disposed, isFalse); expect( harness.container.read(linkPhoneOptionsProvider).shareSongs, isTrue, ); options.setShowComputerSongs(true); await pumpEventQueue(); expect(harness.bridge.librarySources.values, everyElement(isTrue)); expect(harness.active, same(session)); expect(harness.sessions, hasLength(1)); }, ); test( 'saved hidden songs stay hidden through pairing and catalog changes', () async { SharedPreferences.setMockInitialValues({ LinkPhoneOptionsNotifier.showComputerSongsKey: false, }); final harness = await _started(); final record = await harness.controller.pair( linkTestTarget('a'), '123456', ); await pumpEventQueue(); expect(harness.bridge.librarySources, isEmpty); expect(harness.bridge.connections, contains(record.connectionId)); final session = harness.sessions.single; session.emit(LinkConnectionState.connected); session.push({'type': LinkMessageTypes.catalogChanged, 'version': 1}); await Future.delayed( LinkClientController.rescanDelay + const Duration(milliseconds: 200), ); expect( harness.bridge.calls.where((c) => c.startsWith('rescan')), isEmpty, ); expect(harness.active, same(session)); harness.container .read(linkPhoneOptionsProvider.notifier) .setShowComputerSongs(true); await pumpEventQueue(); expect(harness.bridge.librarySources[record.connectionId], isTrue); }, ); test( 'startup hides cached computer songs before starting the session', () async { final record = LinkServerRecord( serverId: 'a', name: 'Desktop a', connectionId: 'connection-a', address: 'https://10.0.0.2:47710', fingerprint: linkTestFingerprint('a'), ); SharedPreferences.setMockInitialValues({ LinkClientStore.serversKey: jsonEncode([record.toJson()]), LinkPhoneOptionsNotifier.showComputerSongsKey: false, }); final harness = LinkClientHarness(); addTearDown(harness.container.dispose); harness.bridge.connections[record.connectionId] = const NetworkConnection( id: 'connection-a', name: 'Desktop a', protocol: NetworkProtocol.subsonic, address: 'https://10.0.0.2:47710', apiKey: 'saved-key', subsonicAuth: SubsonicAuth.apiKey, ); harness.bridge.librarySources[record.connectionId] = true; await harness.start(); expect(harness.bridge.librarySources[record.connectionId], isFalse); expect(harness.active, same(harness.sessions.single)); expect(harness.sessions.single.calls, ['start']); }, ); test('hiding songs waits for an in-flight Library addition', () async { final harness = await _started(); final entered = Completer(); final release = Completer(); harness.bridge.beforeSourceAdd = () { entered.complete(); return release.future; }; final record = await harness.controller.pair(linkTestTarget('a'), '123456'); await entered.future; harness.container .read(linkPhoneOptionsProvider.notifier) .setShowComputerSongs(false); await pumpEventQueue(); release.complete(); await pumpEventQueue(); expect(harness.bridge.librarySources[record.connectionId], isFalse); expect(harness.bridge.connections, contains(record.connectionId)); }); test('hiding songs cancels a pending catalog refresh', () async { final harness = await _started(); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; session.emit(LinkConnectionState.connected); session.push({'type': LinkMessageTypes.catalogChanged, 'version': 1}); await pumpEventQueue(); harness.container .read(linkPhoneOptionsProvider.notifier) .setShowComputerSongs(false); await Future.delayed( LinkClientController.rescanDelay + const Duration(milliseconds: 200), ); expect(harness.bridge.calls.where((c) => c.startsWith('rescan')), isEmpty); }); test('a failed pairing saves nothing', () async { final harness = await _started(); harness.pairing.error = LinkPairingError.badPin; await expectLater( harness.controller.pair(linkTestTarget('a'), '000000'), throwsA( isA().having( (e) => e.error, 'error', LinkPairingError.badPin, ), ), ); expect(harness.state.servers, isEmpty); expect(harness.bridge.calls, isEmpty); expect(harness.active, isNull); }); test('a known manual address reuses the saved pairing and Library', () async { final harness = await _started(); final record = await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; final moved = linkTestTarget('a', host: '192.168.18.5', pairing: false); expect(await harness.controller.reconnectPaired(moved), isTrue); expect(session.server.address, moved.address); expect(harness.state.activeServer!.connectionId, record.connectionId); expect(harness.bridge.connections[record.connectionId]!.apiKey, 'key-1'); expect(harness.pairing.pins, ['123456']); expect(harness.sessions, [session]); expect(harness.bridge.calls.where((call) => call.startsWith('source ')), [ 'source ${record.connectionId}', ]); }); test('a new computer or a refused key still needs pairing', () async { final harness = await _started(); expect( await harness.controller.reconnectPaired(linkTestTarget('a')), isFalse, ); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); harness.sessions.single.emit( LinkConnectionState.disconnected, LinkSessionIssue.unauthorized, ); await pumpEventQueue(); expect( await harness.controller.reconnectPaired( linkTestTarget('a', host: '192.168.18.5'), ), isFalse, ); expect(harness.state.activeServer!.address, 'https://10.0.0.2:47710'); }); test('a known manual address must keep the paired certificate', () async { final harness = await _started(); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final other = linkTestTarget('b', host: '192.168.18.5'); await expectLater( harness.controller.reconnectPaired( LinkPairingTarget( address: other.address, info: LinkServerInfo( serverId: 'a', name: other.info.name, protocol: other.info.protocol, appVersion: other.info.appVersion, fingerprint: other.fingerprint, pairing: false, ), ), ), throwsA( isA().having( (error) => error.error, 'error', LinkPairingError.certificateMismatch, ), ), ); expect(harness.state.activeServer!.address, 'https://10.0.0.2:47710'); expect(harness.sessions.single.calls, ['start']); }); test('a bad address fails before any request', () async { final harness = await _started(); await expectLater( harness.controller.probe('host/path', 47710), throwsA( isA().having( (e) => e.error, 'error', LinkPairingError.invalidAddress, ), ), ); expect(harness.pairing.probes, isEmpty); }); test('stored desktops load with the saved active choice', () async { final records = [ for (final id in ['a', 'b']) LinkServerRecord( serverId: id, name: 'Desktop $id', connectionId: 'connection-$id', address: 'https://10.0.0.2:47710', fingerprint: linkTestFingerprint(id), ), ]; SharedPreferences.setMockInitialValues({ LinkClientStore.serversKey: jsonEncode([ for (final record in records) record.toJson(), ]), LinkClientStore.activeServerKey: 'b', }); final harness = LinkClientHarness(); addTearDown(harness.container.dispose); harness.bridge.connections['connection-b'] = const NetworkConnection( id: 'connection-b', name: 'Desktop b', protocol: NetworkProtocol.subsonic, address: 'https://10.0.0.2:47710', subsonicAuth: SubsonicAuth.apiKey, apiKey: 'stored-key', ); await harness.start(); await pumpEventQueue(); expect(harness.state.servers, hasLength(2)); expect(harness.state.activeServerId, 'b'); expect(harness.sessions.single.apiKey, 'stored-key'); expect(harness.active, same(harness.sessions.single)); // A desktop whose connection was removed elsewhere must pair again. await harness.controller.setActive('a'); await pumpEventQueue(); expect(harness.active, isNull); expect(harness.state.issue, LinkSessionIssue.unauthorized); }); test('state follows the session and discovery follows the desktop', () async { final harness = await _started(); final record = await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; // Disconnected: discovery looks for the desktop. expect(harness.browser.started, 1); expect(harness.state.discovery, LinkDiscoveryStatus.searching); session.emit(LinkConnectionState.connected); await pumpEventQueue(); expect(harness.state.connection, LinkConnectionState.connected); expect(harness.browser.stopped, 1); expect(harness.bridge.reachable[record.connectionId], isTrue); session.emit( LinkConnectionState.disconnected, LinkSessionIssue.unreachable, ); await pumpEventQueue(); expect(harness.state.issue, LinkSessionIssue.unreachable); expect(harness.browser.started, 2); // The desktop's songs fail quickly while it cannot be reached. expect(harness.bridge.reachable[record.connectionId], isFalse); // Seen again at the same address: reconnect at once. harness.browser.resolve('a', '10.0.0.2'); await pumpEventQueue(); expect(session.calls.last, 'reconnect'); // Seen at a new address: the record, connection and session move. harness.browser.resolve('a', '10.0.0.7'); await pumpEventQueue(); expect(harness.state.servers.single.address, 'https://10.0.0.7:47710'); expect( (await LinkClientStore().servers()).single.address, 'https://10.0.0.7:47710', ); expect( harness.bridge.calls.last, 'address ${record.connectionId} https://10.0.0.7:47710', ); expect(session.calls.last, 'update https://10.0.0.7:47710'); }); test('another certificate under a known id is not followed', () async { final harness = await _started(); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; harness.browser.resolve('a', '10.0.0.66', fingerprint: 'cc' * 32); await pumpEventQueue(); expect(harness.state.servers.single.address, 'https://10.0.0.2:47710'); expect(session.calls, ['start']); expect( harness.state.certificateChanged(harness.state.activeServer!), isTrue, ); }); test('iOS pauses in the background without a playback lease', () async { final harness = await _started(platform: 'ios'); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; await _lifecycle([AppLifecycleState.inactive]); expect(session.calls, ['start']); await _lifecycle([AppLifecycleState.hidden, AppLifecycleState.paused]); expect(session.calls, ['start', 'pause']); expect(harness.browser.stopped, 1); await _lifecycle([ AppLifecycleState.hidden, AppLifecycleState.inactive, AppLifecycleState.resumed, ]); expect(session.calls, ['start', 'pause', 'resume', 'reconnect']); expect(harness.browser.started, 2); }); test('the session stays connected in the background when asked', () async { final harness = await _started(platform: 'ios'); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; harness.keepConnected(true); await pumpEventQueue(); await _lifecycle([AppLifecycleState.hidden, AppLifecycleState.paused]); expect(session.calls, ['start']); harness.keepConnected(false); await pumpEventQueue(); expect(session.calls, ['start', 'pause']); harness.keepConnected(true); await pumpEventQueue(); expect(session.calls, ['start', 'pause', 'resume']); await _lifecycle([ AppLifecycleState.hidden, AppLifecycleState.inactive, AppLifecycleState.resumed, ]); harness.keepConnected(false); await pumpEventQueue(); expect(session.calls, ['start', 'pause', 'resume', 'reconnect']); }); test('an idle Android phone remains available after backgrounding', () async { final harness = await _started(); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; session.emit(LinkConnectionState.connected); await pumpEventQueue(); await _lifecycle([AppLifecycleState.hidden, AppLifecycleState.paused]); expect(session.calls, ['start']); expect(harness.state.connection, LinkConnectionState.connected); expect(harness.backgroundConnections, ['Desktop a']); // No playback or transfer lease is needed for the PC to see this phone. harness.keepConnected(true); harness.keepConnected(false); await pumpEventQueue(); expect(session.calls, ['start']); await harness.controller.forget('a', removeLibrary: false); await pumpEventQueue(); expect(harness.backgroundConnections, ['Desktop a', null]); expect(session.disposed, isTrue); }); test( 'Android keeps reconnecting, but a revoked pairing releases work', () async { final harness = await _started(); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; await _lifecycle([AppLifecycleState.hidden, AppLifecycleState.paused]); session.emit( LinkConnectionState.disconnected, LinkSessionIssue.unreachable, ); await pumpEventQueue(); expect(harness.backgroundConnections, ['Desktop a']); expect(session.calls, ['start']); session.emit( LinkConnectionState.disconnected, LinkSessionIssue.unauthorized, ); await pumpEventQueue(); expect(harness.backgroundConnections, ['Desktop a', null]); expect(session.calls.last, 'pause'); }, ); test( 'disposing during a native start releases the eventual service', () async { final starting = Completer(); final harness = LinkClientHarness( updateBackgroundConnection: (name) async { if (name != null) await starting.future; }, ); await harness.start(); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); expect(harness.backgroundConnections, ['Desktop a']); harness.container.dispose(); starting.complete(); await pumpEventQueue(); expect(harness.backgroundConnections, ['Desktop a', null]); }, ); test('catalog.changed rescans the desktop once bursts settle', () async { final harness = await _started(); final record = await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; session.emit(LinkConnectionState.connected); session.push({'type': LinkMessageTypes.catalogChanged, 'version': 1}); session.push({'type': 'player.state'}); session.push({'type': LinkMessageTypes.catalogChanged, 'version': 2}); await pumpEventQueue(); expect(harness.bridge.calls.where((c) => c.startsWith('rescan')), isEmpty); await Future.delayed( LinkClientController.rescanDelay + const Duration(milliseconds: 200), ); expect(harness.bridge.calls.where((c) => c.startsWith('rescan')), [ 'rescan ${record.connectionId}', ]); }); test( 'connecting and reconnecting refresh missed desktop catalog changes', () async { final harness = await _started(); final record = await harness.controller.pair( linkTestTarget('a'), '123456', ); await pumpEventQueue(); final session = harness.sessions.single; session.emit(LinkConnectionState.connected); await Future.delayed( LinkClientController.rescanDelay + const Duration(milliseconds: 200), ); expect(harness.bridge.calls.where((c) => c.startsWith('rescan')), [ 'rescan ${record.connectionId}', ]); // The server may think its push arrived before the old socket disconnected. session.emit(LinkConnectionState.disconnected); await pumpEventQueue(); session.emit(LinkConnectionState.connected); await pumpEventQueue(); session.emit(LinkConnectionState.connected); await Future.delayed( LinkClientController.rescanDelay + const Duration(milliseconds: 200), ); expect(harness.bridge.calls.where((c) => c.startsWith('rescan')), [ 'rescan ${record.connectionId}', 'rescan ${record.connectionId}', ]); }, ); test('a disconnect cancels a pending desktop catalog refresh', () async { final harness = await _started(); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; session.emit(LinkConnectionState.connected); session.push({'type': LinkMessageTypes.catalogChanged, 'version': 1}); await pumpEventQueue(); session.emit(LinkConnectionState.disconnected); await Future.delayed( LinkClientController.rescanDelay + const Duration(milliseconds: 200), ); expect(harness.bridge.calls.where((c) => c.startsWith('rescan')), isEmpty); }); test('a refused permission stops discovery until asked again', () async { final harness = await _started(localNetworkAllowed: false); final release = harness.controller.acquireDiscovery(); addTearDown(release); await pumpEventQueue(); expect(harness.state.discovery, LinkDiscoveryStatus.permissionDenied); expect(harness.browser.started, 0); await expectLater( harness.controller.requestLocalNetworkAccess(), throwsA(isA()), ); harness.localNetworkAllowed = true; await harness.controller.requestLocalNetworkAccess(); await pumpEventQueue(); expect(harness.state.discovery, LinkDiscoveryStatus.searching); expect(harness.browser.started, 1); harness.browser.resolve('b', '10.0.0.3'); await pumpEventQueue(); expect(harness.state.unpaired.single.serverId, 'b'); release(); await pumpEventQueue(); expect(harness.state.discovery, LinkDiscoveryStatus.idle); expect(harness.state.discovered, isEmpty); }); test('the page hears when Wi-Fi is off', () async { final harness = await _started(onWifi: false); harness.controller.acquireDiscovery()(); await pumpEventQueue(); expect(harness.state.localNetworkAvailable, isFalse); }); test('joining Wi-Fi restarts discovery without restarting the app', () async { final changes = StreamController.broadcast(); addTearDown(changes.close); final harness = await _started( onWifi: false, networkChanges: changes.stream, ); final release = harness.controller.acquireDiscovery(); addTearDown(release); await pumpEventQueue(); expect(harness.state.localNetworkAvailable, isFalse); harness.onWifi = true; changes.add(null); await pumpEventQueue(); expect(harness.state.localNetworkAvailable, isTrue); expect(harness.state.discovery, LinkDiscoveryStatus.searching); harness.browser.resolve('b', '192.168.18.5'); await pumpEventQueue(); expect(harness.state.unpaired.single.host, '192.168.18.5'); }); test( 'a new network refreshes a stale browser and disconnected session', () async { final changes = StreamController.broadcast(); addTearDown(changes.close); final harness = await _started(networkChanges: changes.stream); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final started = harness.browser.started; changes.add(null); await pumpEventQueue(); expect(harness.browser.started, started + 1); expect(harness.sessions.single.calls.last, 'reconnect'); }, ); test('returning from Control Centre refreshes discovery', () async { final harness = await _started(); final release = harness.controller.acquireDiscovery(); addTearDown(release); await pumpEventQueue(); final started = harness.browser.started; await _lifecycle([AppLifecycleState.inactive, AppLifecycleState.resumed]); expect(harness.browser.started, started + 1); }); test( 'network changes rediscover a connected desktop at its new IP', () async { final changes = StreamController.broadcast(); addTearDown(changes.close); final harness = await _started(networkChanges: changes.stream); final record = await harness.controller.pair( linkTestTarget('a'), '123456', ); await pumpEventQueue(); final session = harness.sessions.single; session.emit(LinkConnectionState.connected); await pumpEventQueue(); changes.add(null); await pumpEventQueue(); expect(session.calls, ['start']); expect(harness.state.connection, LinkConnectionState.connected); expect(harness.state.discovery, LinkDiscoveryStatus.searching); harness.browser.resolve('a', '192.168.18.5'); await pumpEventQueue(); expect(session.server.address, 'https://192.168.18.5:47710'); expect(harness.state.activeServer!.connectionId, record.connectionId); expect(harness.bridge.connections[record.connectionId]!.apiKey, 'key-1'); expect(harness.pairing.pins, ['123456']); expect(harness.sessions, [session]); expect( (await LinkClientStore().servers()).single.address, 'https://192.168.18.5:47710', ); }, ); testWidgets('network rediscovery ends while a healthy session stays open', ( tester, ) async { final changes = StreamController.broadcast(); addTearDown(changes.close); final harness = LinkClientHarness(networkChanges: changes.stream); addTearDown(harness.container.dispose); await harness.start(); await harness.controller.pair(linkTestTarget('a'), '123456'); await tester.pump(); final session = harness.sessions.single; session.emit(LinkConnectionState.connected); await tester.pump(); changes.add(null); await tester.pump(); expect(harness.state.discovery, LinkDiscoveryStatus.searching); await tester.pump(const Duration(seconds: 31)); expect(harness.state.discovery, LinkDiscoveryStatus.idle); expect(harness.state.connection, LinkConnectionState.connected); expect(session.calls, ['start']); }); testWidgets('an unreachable desktop gets a fresh address resolution', ( tester, ) async { final harness = LinkClientHarness(); addTearDown(harness.container.dispose); await harness.start(); await harness.controller.pair(linkTestTarget('a'), '123456'); await tester.pump(); harness.browser.resolve('a', '10.0.0.2'); await tester.pump(); final started = harness.browser.started; await tester.pump(const Duration(seconds: 16)); await tester.runAsync(pumpEventQueue); await tester.pump(); expect(harness.browser.started, started + 1); harness.browser.resolve('a', '192.168.18.5'); await tester.pump(); expect( harness.sessions.single.server.address, 'https://192.168.18.5:47710', ); harness.sessions.single.emit(LinkConnectionState.connected); await tester.pump(); final connected = harness.browser.started; await tester.pump(const Duration(seconds: 31)); expect(harness.browser.started, connected); }); test( 'background playback rediscovers a desktop after disconnecting', () async { final harness = await _started(); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); final session = harness.sessions.single; session.emit(LinkConnectionState.connected); harness.keepConnected(true); await _lifecycle([AppLifecycleState.hidden, AppLifecycleState.paused]); session.emit( LinkConnectionState.disconnected, LinkSessionIssue.unreachable, ); await pumpEventQueue(); expect(harness.state.discovery, LinkDiscoveryStatus.searching); harness.browser.resolve('a', '192.168.18.5'); await pumpEventQueue(); expect(session.server.address, 'https://192.168.18.5:47710'); }, ); test( 'a failed browser is recreated while the Link page stays open', () async { final harness = await _started(); final release = harness.controller.acquireDiscovery(); addTearDown(release); await pumpEventQueue(); harness.browser.events!.addError(StateError('Bonjour failed')); await pumpEventQueue(); expect(harness.state.discovery, LinkDiscoveryStatus.failed); await Future.delayed( LinkClientController.discoveryRetryDelay + const Duration(milliseconds: 50), ); expect(harness.browser.started, 2); harness.browser.resolve('b', '192.168.18.5'); await pumpEventQueue(); expect(harness.state.unpaired.single.host, '192.168.18.5'); }, ); test('disposing closes the session and discovery', () async { final harness = LinkClientHarness(); await harness.start(); await harness.controller.pair(linkTestTarget('a'), '123456'); await pumpEventQueue(); harness.container.dispose(); await pumpEventQueue(); expect(harness.sessions.single.disposed, isTrue); expect(harness.browser.stopped, 1); }); test('unsupported platforms stay inert', () async { final harness = await _started(supported: false); expect(harness.state.loaded, isTrue); harness.controller.acquireDiscovery(); await harness.controller.requestLocalNetworkAccess(); await pumpEventQueue(); expect(harness.browser.started, 0); expect(harness.active, isNull); final preferences = await SharedPreferences.getInstance(); expect(preferences.getKeys(), isEmpty); }); }