302 lines
14 KiB
Dart
302 lines
14 KiB
Dart
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'dart:io';
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:sync_relay_core/core.dart';
|
|
import 'package:starsync/src/platform/single_instance.dart';
|
|
import 'package:starsync/src/platform/url_scheme.dart';
|
|
import 'package:starsync/src/session/invite.dart';
|
|
import 'package:starsync/src/session/join_offers.dart';
|
|
import 'package:starsync/src/session/navigation.dart' show Place;
|
|
import 'package:starsync/src/session/public_address.dart';
|
|
import 'package:starsync/src/shell/party_strip.dart' show friendInviteLink;
|
|
import 'package:starsync/src/shell/join_offer_card.dart';
|
|
import 'package:starsync/src/state/connect_prefs.dart' show RecentServer;
|
|
|
|
import 'test_graph.dart';
|
|
|
|
// starsync:// invite links, the internet address lookup, the join
|
|
// prompt (links and the clipboard), one app per profile and the link
|
|
// handler's registration values.
|
|
|
|
String health({String name = "Bob's server", String version = '1.3.2', int viewers = 2}) => jsonEncode({
|
|
'ok': true,
|
|
'name': name,
|
|
'proto': RelayConstants.protoMax,
|
|
'protoMin': RelayConstants.protoMin,
|
|
'protoMax': RelayConstants.protoMax,
|
|
'version': version,
|
|
'viewers': viewers,
|
|
});
|
|
|
|
final _graph = testGraph(healthGet: (uri) async => health());
|
|
|
|
void main() {
|
|
test('a friend\'s server: the copied link carries the password you joined with', () {
|
|
final link = friendInviteLink('example.org:6969', "Bob's server", secret: 'hunter2');
|
|
final back = InviteLink.parse(link)!;
|
|
expect([back.host, back.port, back.secret], ['example.org', 6969, 'hunter2']);
|
|
expect(friendInviteLink('example.org:6969', 'Bob'), isNot(contains('pw=')));
|
|
});
|
|
|
|
group('invite link', () {
|
|
test('round trip: address, name and password, which never shows in toString', () {
|
|
const link = InviteLink(host: '203.0.113.7', port: 9000, name: "Bob's server & co", secret: 'p@ss w&rd=1');
|
|
expect(link.uri, startsWith('starsync://203.0.113.7:9000/?name='));
|
|
expect(InviteLink.parse(link.uri), link);
|
|
expect(link.toString(), isNot(contains('p@ss')));
|
|
expect(link.toString(), contains('password'));
|
|
expect(redactLog('opening ${link.uri}'), isNot(contains('w%26rd')));
|
|
});
|
|
|
|
test('bare links, IPv6, the default port; anything else is no link', () {
|
|
expect(InviteLink.parse('starsync://192.168.1.20:8080'), const InviteLink(host: '192.168.1.20', port: 8080));
|
|
expect(const InviteLink(host: '192.168.1.20', port: 8080).uri, 'starsync://192.168.1.20:8080');
|
|
expect(InviteLink.parse('STARSYNC://vps.example.com'), const InviteLink(host: 'vps.example.com', port: 8080));
|
|
const v6 = InviteLink(host: 'fe80::1', port: 8080);
|
|
expect(v6.uri, 'starsync://[fe80::1]:8080');
|
|
expect(InviteLink.parse(v6.uri)?.port, 8080);
|
|
expect(InviteLink.parse('starsync://host:99999'), isNull);
|
|
expect(InviteLink.parse('starsync://'), isNull);
|
|
expect(InviteLink.parse('https://192.168.1.20:8080'), isNull);
|
|
expect(InviteLink.parse('starsync://a b:1'), isNull);
|
|
});
|
|
|
|
test('the invite is just its link, with the password when one is set', () {
|
|
const invite = Invite(host: '192.168.1.20', port: 8080, name: "Bob's server", password: true, version: '1.3.2');
|
|
final link = invite.link(secret: 'hunter2');
|
|
expect(link.uri, 'starsync://192.168.1.20:8080/?name=Bob%27s+server&pw=hunter2');
|
|
expect(inviteIn(link.uri), link);
|
|
expect(link.toString(), isNot(contains('hunter2')));
|
|
expect(const Invite(host: '192.168.1.20', port: 8080).link().uri, 'starsync://192.168.1.20:8080');
|
|
// A 1.3.x app pasting it into the Join card's address.
|
|
expect(addressIn(link.uri), (host: '192.168.1.20', port: '8080'));
|
|
expect(invite.at('203.0.113.7').address, '203.0.113.7:8080');
|
|
});
|
|
|
|
test('found in a text: a link anywhere, an old plain invite, never a bare address', () {
|
|
expect(inviteIn('hey, come watch: starsync://10.0.0.5:8081/?name=Ann see you')?.address, '10.0.0.5:8081');
|
|
expect(inviteIn('Join me on Starsync: 192.168.1.20:8080 (ask me for the password) · Starsync 1.3.0'),
|
|
const InviteLink(host: '192.168.1.20', port: 8080));
|
|
expect(inviteIn('192.168.1.20:8080'), isNull);
|
|
expect(inviteIn('see https://example.com:443/x'), isNull);
|
|
expect(inviteIn('${'x' * 5000} starsync://1.2.3.4:1'), isNull, reason: 'only the start of a long text');
|
|
});
|
|
|
|
test('reach: the internet address first; forwarding when it is the router\'s', () {
|
|
const behindRouter = InviteReach(public: '203.0.113.7', local: ['192.168.1.20', '100.64.1.2']);
|
|
expect(behindRouter.best, '203.0.113.7');
|
|
expect(behindRouter.forwarding, isTrue);
|
|
expect([for (final c in behindRouter.choices) c.kind], [AddressKind.public, AddressKind.lan, AddressKind.vpn]);
|
|
const direct = InviteReach(public: '203.0.113.7', local: ['203.0.113.7']);
|
|
expect(direct.forwarding, isFalse);
|
|
expect(direct.choices.length, 1);
|
|
expect(const InviteReach(local: ['192.168.1.20']).best, '192.168.1.20');
|
|
expect(isPublicIpv4('8.8.8.8'), isTrue);
|
|
for (final ip in ['10.1.2.3', '192.168.0.1', '172.20.0.1', '100.100.1.1', '127.0.0.1', '198.18.0.1', '::1', 'x']) {
|
|
expect(isPublicIpv4(ip), isFalse, reason: ip);
|
|
}
|
|
});
|
|
});
|
|
|
|
group('internet address', () {
|
|
final a = Uri.parse('https://a.test'), b = Uri.parse('https://b.test'), c = Uri.parse('https://c.test');
|
|
|
|
test('the first service with a public address wins; failing, private or odd answers are skipped', () async {
|
|
final asked = <String>[];
|
|
final ip = await lookUpPublicAddress(
|
|
services: [a, b, c],
|
|
get: (uri) async {
|
|
asked.add(uri.host);
|
|
return switch (uri.host) {
|
|
'a.test' => throw const SocketException('blocked'),
|
|
'b.test' => '192.168.1.1\n',
|
|
_ => '203.0.113.7\n',
|
|
};
|
|
},
|
|
);
|
|
expect(ip, '203.0.113.7');
|
|
expect(asked, ['a.test', 'b.test', 'c.test']);
|
|
});
|
|
|
|
test('a slow service is given up on; none answering is no address', () async {
|
|
final ip = await lookUpPublicAddress(
|
|
services: [a, b],
|
|
each: const Duration(milliseconds: 50),
|
|
get: (uri) => uri.host == 'a.test' ? Completer<String>().future : Future.value('203.0.113.9'),
|
|
);
|
|
expect(ip, '203.0.113.9');
|
|
expect(await lookUpPublicAddress(services: [a], get: (_) async => '<html>nope</html>'), isNull);
|
|
});
|
|
});
|
|
|
|
group('join prompt', () {
|
|
final offers = _graph.joinOffers;
|
|
final yours = _graph.yourServer;
|
|
tearDown(() {
|
|
offers.offer.value = null;
|
|
yours.shared.value = null;
|
|
yours.reach.value = null;
|
|
_graph.forms.recents.value = const [];
|
|
});
|
|
|
|
test('a clicked link becomes an offer with what /health says', () async {
|
|
offers.fromArgs(['--whatever', 'starsync://203.0.113.7:8080/?name=Bob']);
|
|
expect(offers.offer.peek()?.source, OfferSource.link);
|
|
expect(offers.offer.peek()?.question, 'Join Bob (203.0.113.7:8080)?');
|
|
await pumpEventQueue();
|
|
final o = offers.offer.peek()!;
|
|
expect(o.question, "Join Bob's server (203.0.113.7:8080)?");
|
|
expect(o.detail, 'Starsync 1.3.2 · 2 watching');
|
|
});
|
|
|
|
test('the clipboard: offered once; Not now and Join both stop it coming back', () async {
|
|
offers.fromClipboard('come: starsync://203.0.113.20:8080');
|
|
expect(offers.offer.peek()?.source, OfferSource.clipboard);
|
|
await offers.dismiss();
|
|
expect(offers.offer.peek(), isNull);
|
|
offers.fromClipboard('something else');
|
|
offers.fromClipboard('come: starsync://203.0.113.20:8080');
|
|
expect(offers.offer.peek(), isNull, reason: 'dismissed');
|
|
|
|
offers.fromClipboard('starsync://203.0.113.21:8080');
|
|
_graph.forms.recents.value = const [RecentServer(host: '203.0.113.21', port: '8080', secret: 'saved')];
|
|
final link = offers.accept();
|
|
expect(link?.secret, 'saved', reason: 'a link without its password takes the saved one');
|
|
offers.fromClipboard('x');
|
|
offers.fromClipboard('starsync://203.0.113.21:8080');
|
|
expect(offers.offer.peek(), isNull, reason: 'joined');
|
|
});
|
|
|
|
test('never your own invite, nor the server you are in, nor plain text', () {
|
|
yours.port.value = 40000;
|
|
addTearDown(() => yours.port.value = null);
|
|
yours.shared.value = const Invite(host: '203.0.113.7', port: 8080);
|
|
yours.reach.value = const InviteReach(public: '203.0.113.7', local: ['192.168.1.20']);
|
|
offers.fromClipboard('starsync://192.168.1.20:8080');
|
|
offers.fromClipboard('starsync://127.0.0.1:40000');
|
|
expect(offers.offer.peek(), isNull);
|
|
// What this app just copied is not offered back to it.
|
|
const copied = 'starsync://198.51.100.4:8080';
|
|
offers.copied(copied);
|
|
offers.fromClipboard(copied);
|
|
expect(offers.offer.peek(), isNull);
|
|
offers.fromClipboard('just some text 10.0.0.1:80');
|
|
expect(offers.offer.peek(), isNull);
|
|
|
|
final nav = _graph.navigation;
|
|
nav.place.value = Place.friend;
|
|
nav.address.value = '198.51.100.9:8080';
|
|
addTearDown(() {
|
|
nav.place.value = Place.none;
|
|
nav.address.value = '';
|
|
});
|
|
offers.fromArgs(['starsync://198.51.100.9:8080']);
|
|
expect(offers.offer.peek(), isNull);
|
|
});
|
|
|
|
testWidgets('the card: the question, Join and Not now', (tester) async {
|
|
var joined = 0;
|
|
await tester.pumpWidget(scoped(
|
|
_graph,
|
|
MaterialApp(
|
|
theme: ThemeData.dark(),
|
|
home: Scaffold(body: JoinOfferCard(offers: offers, onJoin: () => joined++)))));
|
|
expect(find.byKey(const ValueKey('join-offer')), findsNothing);
|
|
offers.offer.value = const JoinOffer(InviteLink(host: '203.0.113.7', port: 8080, name: 'Ann'), OfferSource.clipboard);
|
|
await tester.pumpAndSettle();
|
|
expect(find.text('Join Ann (203.0.113.7:8080)?'), findsOneWidget);
|
|
expect(find.text('Invite on your clipboard · Checking the server…'), findsOneWidget);
|
|
await tester.tap(find.byKey(const ValueKey('join-offer-join')));
|
|
expect(joined, 1);
|
|
await tester.tap(find.byKey(const ValueKey('join-offer-dismiss')));
|
|
await tester.pumpAndSettle();
|
|
expect(find.byKey(const ValueKey('join-offer')), findsNothing);
|
|
});
|
|
});
|
|
|
|
group('one app per profile', () {
|
|
late Directory tmp;
|
|
setUp(() async => tmp = await Directory.systemTemp.createTemp('starsync-instance'));
|
|
tearDown(() async => tmp.delete(recursive: true));
|
|
|
|
test('a second start hands its arguments and token over and ends', () async {
|
|
final first = await InstanceLock.claim(tmp.path);
|
|
expect(first, isNotNull);
|
|
expect(first!.held, isTrue);
|
|
final got = first.handoffs.first;
|
|
int? allowed;
|
|
final second = await InstanceLock.claim(tmp.path,
|
|
args: ['starsync://1.2.3.4:8080/?pw=x'], activation: 'tok', beforeSend: (p) => allowed = p);
|
|
expect(second, isNull, reason: 'handed over');
|
|
expect(allowed, pid);
|
|
final h = await got;
|
|
expect(h.args, ['starsync://1.2.3.4:8080/?pw=x']);
|
|
expect(h.activation, 'tok');
|
|
await first.release();
|
|
});
|
|
|
|
test('each profile folder is its own instance', () async {
|
|
final a = await InstanceLock.claim('${tmp.path}/a');
|
|
final b = await InstanceLock.claim('${tmp.path}/b');
|
|
expect(a?.held, isTrue);
|
|
expect(b?.held, isTrue);
|
|
await a!.release();
|
|
await b!.release();
|
|
});
|
|
|
|
test('a start while the app closes waits and takes over once it is gone', () async {
|
|
final first = (await InstanceLock.claim(tmp.path))!;
|
|
first.closing();
|
|
final second = InstanceLock.claim(tmp.path, retryEvery: const Duration(milliseconds: 20));
|
|
await Future<void>.delayed(const Duration(milliseconds: 150));
|
|
await first.release();
|
|
final taken = await second;
|
|
expect(taken?.held, isTrue);
|
|
await taken!.release();
|
|
});
|
|
|
|
test('a wrong token is refused (nothing handed over)', () async {
|
|
final first = (await InstanceLock.claim(tmp.path))!;
|
|
var handed = false;
|
|
first.handoffs.listen((_) => handed = true);
|
|
final s = await Socket.connect(InternetAddress.loopbackIPv4, first.port!);
|
|
s.writeln(jsonEncode({'token': 'guess', 'args': ['x']}));
|
|
final reply = await utf8.decoder.bind(s).join();
|
|
expect(reply, contains('"ok":false'));
|
|
expect(handed, isFalse);
|
|
s.destroy();
|
|
await first.release();
|
|
});
|
|
|
|
test('no lock and nobody answering: starts anyway after a while', () async {
|
|
final first = (await InstanceLock.claim(tmp.path))!;
|
|
first.closing();
|
|
final started = await InstanceLock.claim(tmp.path,
|
|
retryFor: const Duration(milliseconds: 100),
|
|
closingWait: const Duration(milliseconds: 100),
|
|
retryEvery: const Duration(milliseconds: 20));
|
|
expect(started?.held, isFalse);
|
|
await first.release();
|
|
});
|
|
});
|
|
|
|
group('link handler', () {
|
|
test('Windows: HKCU\\Software\\Classes\\starsync opens starsync.exe with the link', () {
|
|
final v = windowsSchemeValues(r'C:\Apps\Starsync\starsync.exe');
|
|
expect(v.first, (r'Software\Classes\starsync', '', 'URL:Starsync invite'));
|
|
expect(v, contains((r'Software\Classes\starsync', 'URL Protocol', '')));
|
|
expect(v.last, (r'Software\Classes\starsync\shell\open\command', '', r'"C:\Apps\Starsync\starsync.exe" "%1"'));
|
|
});
|
|
|
|
test('an old-named copy points links at starsync next to it', () {
|
|
expect(schemeExecutable(r'C:\S\watch_together.exe', exists: (_) => true), r'C:\S\starsync.exe');
|
|
expect(schemeExecutable(r'C:\S\watch_together.exe', exists: (_) => false), r'C:\S\watch_together.exe');
|
|
expect(schemeExecutable('/opt/s/watch_together', exists: (_) => true), '/opt/s/starsync');
|
|
expect(schemeExecutable('/opt/s/starsync', exists: (_) => true), '/opt/s/starsync');
|
|
});
|
|
});
|
|
}
|