Files
SpotiFLAC-Mobile/test/link_client_controller_test.dart
zarzet 9b17fd2c61 feat(link): offer only what the Link host announces
Hosts announce their platform and optional features (downloads, opening
links, file changes). The phone remembers them and hides the actions a
host lacks, and shows a phone icon for a phone host. Older hosts that
announce nothing keep every action.
2026-11-17 03:09:29 +07:00

947 lines
34 KiB
Dart

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<LinkClientHarness> _started({
bool supported = true,
String platform = 'android',
bool localNetworkAllowed = true,
bool onWifi = true,
Stream<void> networkChanges = const Stream<void>.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<void> _lifecycle(List<AppLifecycleState> 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<void>.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<void>();
final release = Completer<void>();
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<void>.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<LinkPairingException>().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<LinkPairingException>().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<LinkPairingException>().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<void>();
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<void>.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<void>.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<void>.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<void>.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<LocalNetworkPermissionException>()),
);
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<void>.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<void>.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<void>.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<void>.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<void>.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);
});
}