Initial commit: watch-together phases 0-4 + presence hardening, internet-tested

apps/desktop/test/coord_presence_test.dart

@@ -0,0 +1,59 @@
+import 'dart:async';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:media_kit/media_kit.dart';
+import 'package:sync_relay_core/core.dart';
+import 'package:sync_relay_server/server.dart';
+import 'package:watch_together/src/session/session_coordinator.dart';
+
+Future<void> _poll(
+  FutureOr<bool> Function() cond,
+  String what, {
+  Duration timeout = const Duration(seconds: 15),
+}) async {
+  final deadline = DateTime.now().add(timeout);
+  while (DateTime.now().isBefore(deadline)) {
+    if (await cond()) return;
+    await Future.delayed(const Duration(milliseconds: 200));
+  }
+  fail('timed out waiting for $what');
+}
+
+void main() {
+  test(
+    'dead server clears room state and reconnects instead of freezing',
+    timeout: const Timeout(Duration(minutes: 2)),
+    () async {
+      MediaKit.ensureInitialized();
+      final server = RoomServer(
+          const AppConfig(port: 0, secret: 'presence', name: 'presence'));
+      await server.start();
+      final coord = SessionCoordinator();
+      try {
+        await coord.connect(ConnectParams(
+          host: '127.0.0.1',
+          port: server.boundPort,
+          secret: 'presence',
+          name: 'watcher',
+        ));
+        await coord.playback.player.setVolume(0);
+        await _poll(() => coord.room.peek() != null, 'room state to arrive');
+        expect(coord.reconnecting.peek(), isFalse);
+
+        await server.stop();
+        await _poll(
+          () => coord.reconnecting.peek() == true,
+          'reconnect loop to engage',
+        );
+        await _poll(
+          () => coord.room.peek() == null,
+          'stale room (ghost members) to clear',
+        );
+        coord.cancelReconnect();
+        expect(coord.reconnecting.peek(), isFalse);
+      } finally {
+        await coord.dispose();
+      }
+    },
+  );
+}

apps/desktop/test/media_input_test.dart

@@ -0,0 +1,33 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:watch_together/src/widgets/media_input.dart';
+
+void main() {
+  test('http url routes to linkUrl', () {
+    expect(parseMediaInput('http://example.com/v.mp4'),
+        (mediaPath: '', linkUrl: 'http://example.com/v.mp4'));
+  });
+
+  test('https url routes to linkUrl', () {
+    expect(parseMediaInput('https://example.com/v.mp4'),
+        (mediaPath: '', linkUrl: 'https://example.com/v.mp4'));
+  });
+
+  test('scheme match is case-insensitive and trimmed', () {
+    expect(parseMediaInput('  HTTPS://example.com/v.mp4  '),
+        (mediaPath: '', linkUrl: 'HTTPS://example.com/v.mp4'));
+  });
+
+  test('file path routes to mediaPath', () {
+    expect(parseMediaInput('/home/u/Videos/chiyo.mp4'),
+        (mediaPath: '/home/u/Videos/chiyo.mp4', linkUrl: ''));
+  });
+
+  test('empty input stays empty', () {
+    expect(parseMediaInput('   '), (mediaPath: '', linkUrl: ''));
+  });
+
+  test('non-http scheme stays a path', () {
+    expect(parseMediaInput('ftp://example.com/v.mp4'),
+        (mediaPath: 'ftp://example.com/v.mp4', linkUrl: ''));
+  });
+}

apps/desktop/test/room_diff_test.dart

@@ -0,0 +1,159 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:sync_relay_core/core.dart';
+import 'package:watch_together/src/sync/room_diff.dart';
+
+RoomBroadcast _room({
+  int eventId = 0,
+  String transport = 'held',
+  double position = 10.0,
+  int mediaId = 1,
+}) {
+  final now = DateTime.now().toUtc();
+  return RoomBroadcast(
+    eventId: eventId,
+    transport: transport,
+    position: position,
+    serverTime: now,
+    mediaId: mediaId,
+    members: const [],
+  );
+}
+
+RoomBroadcast _roomWithMembers(List<MemberView> members,
+    {String transport = 'playing'}) {
+  final now = DateTime.now().toUtc();
+  return RoomBroadcast(
+    eventId: 3,
+    transport: transport,
+    position: 10.0,
+    serverTime: now,
+    mediaId: 1,
+    members: members,
+  );
+}
+
+void main() {
+  test('initial diff seeks to room edge and sets transport', () {
+    final diff = RoomDiff();
+    final actions = diff.diff(_room(), 0, DateTime.now().toUtc());
+    expect(actions.whereType<SeekAction>().single.position, closeTo(10.0, 1.0));
+    expect(actions.whereType<TransportAction>().single.playing, isFalse);
+  });
+
+  test('same event small drift does nothing', () {
+    final diff = RoomDiff();
+    final now = DateTime.now().toUtc();
+    diff.diff(_room(), 0, now);
+    final actions = diff.diff(_room(), 10.5, now);
+    expect(actions, isEmpty);
+  });
+
+  test('ahead drift latches slowdown, resets inside 0.1', () {
+    final diff = RoomDiff();
+    final now = DateTime.now().toUtc();
+    diff.diff(_room(), 0, now);
+    var actions = diff.diff(_room(), 13.0, now);
+    expect(actions.whereType<RateAction>().single.rate, 0.95);
+    actions = diff.diff(_room(), 12.0, now);
+    expect(actions, isEmpty);
+    actions = diff.diff(_room(), 10.05, now);
+    expect(actions.whereType<RateAction>().single.rate, 1.0);
+  });
+
+  test('eventId jump seeks and resets rate', () {
+    final diff = RoomDiff();
+    final now = DateTime.now().toUtc();
+    diff.diff(_room(), 0, now);
+    diff.diff(_room(), 13.0, now);
+    final actions =
+        diff.diff(_room(eventId: 1, position: 90.0), 13.0, now);
+    expect(actions.whereType<SeekAction>().single.position, closeTo(90.0, 1.0));
+    expect(actions.whereType<RateAction>().single.rate, 1.0);
+  });
+
+  test('media swap seeks zero and pauses', () {
+    final diff = RoomDiff();
+    final now = DateTime.now().toUtc();
+    diff.diff(_room(transport: 'playing'), 10.0, now);
+    final actions = diff.diff(
+        _room(eventId: 2, transport: 'held', position: 0, mediaId: 2),
+        50.0,
+        now);
+    expect(actions.whereType<SeekAction>().single.position, 0);
+    expect(actions.whereType<TransportAction>().single.playing, isFalse);
+  });
+
+  group('seek debounce while playing', () {
+    RoomBroadcast playing({int eventId = 5, double position = 100.0}) => _room(
+        eventId: eventId, transport: 'playing', position: position);
+
+    test('fresh big drift is swallowed first, seeks after window', () {
+      final diff = RoomDiff();
+      final t0 = DateTime.now().toUtc();
+      diff.diff(playing(), 100.0, t0);
+      var actions = diff.diff(playing(), 120.0, t0);
+      expect(actions.whereType<SeekAction>(), isEmpty,
+          reason: 'user scrub must not be yanked back before detector runs');
+      actions = diff.diff(
+          playing(), 120.0, t0.add(RoomDiff.debounceWindow + const Duration(milliseconds: 100)));
+      expect(actions.whereType<SeekAction>().single.position,
+          closeTo(102.0, 3.0),
+          reason: 'genuine drift still converges after the window');
+    });
+
+    test('new eventId seeks immediately (echo of promoted seek)', () {
+      final diff = RoomDiff();
+      final t0 = DateTime.now().toUtc();
+      diff.diff(playing(), 100.0, t0);
+      diff.diff(playing(), 120.0, t0);
+      final actions = diff.diff(playing(eventId: 6, position: 120.0), 120.0, t0);
+      expect(actions.whereType<SeekAction>().single.position,
+          closeTo(120.0, 2.0));
+    });
+
+    test('held transport debounces the same way (detector promotes)', () {
+      final diff = RoomDiff();
+      final t0 = DateTime.now().toUtc();
+      diff.diff(_room(), 10.0, t0);
+      var actions = diff.diff(_room(), 60.0, t0);
+      expect(actions.whereType<SeekAction>(), isEmpty);
+      actions = diff.diff(_room(), 60.0,
+          t0.add(RoomDiff.debounceWindow + const Duration(milliseconds: 100)));
+      expect(actions.whereType<SeekAction>().single.position,
+          closeTo(10.0, 3.0));
+    });
+  });
+
+  group('local play gate', () {
+    const ready = MemberView(
+        id: 'm1',
+        name: 'a',
+        ready: true,
+        inSet: true,
+        buffered: 9,
+        stale: false);
+    const catchingUp = MemberView(
+        id: 'm2',
+        name: 'b',
+        ready: false,
+        inSet: false,
+        buffered: 0,
+        stale: false);
+    const unreadyInSet = MemberView(
+        id: 'm3',
+        name: 'c',
+        ready: false,
+        inSet: true,
+        buffered: 9,
+        stale: false);
+
+    test('only in-set ready members may follow transport to playing', () {
+      final room = _roomWithMembers([ready, catchingUp, unreadyInSet]);
+      expect(localPlayAllowed(room, 'm1'), isTrue);
+      expect(localPlayAllowed(room, 'm2'), isFalse);
+      expect(localPlayAllowed(room, 'm3'), isFalse);
+      expect(localPlayAllowed(room, 'nope'), isFalse);
+      expect(localPlayAllowed(room, ''), isFalse);
+    });
+  });
+}

apps/desktop/test/sync_playback_e2e_test.dart

@@ -0,0 +1,93 @@
+import 'dart:async';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:media_kit/media_kit.dart';
+import 'package:sync_relay_core/core.dart';
+import 'package:sync_relay_server/server.dart';
+import 'package:watch_together/src/session/session_coordinator.dart';
+
+const _port = 18080;
+const _secret = 'e2e-secret';
+const _mediaPath = '/home/foxyz/Videos/chiyo.mp4';
+
+Future<void> _poll(
+  FutureOr<bool> Function() cond,
+  String what, {
+  Duration timeout = const Duration(seconds: 30),
+}) async {
+  final deadline = DateTime.now().add(timeout);
+  while (DateTime.now().isBefore(deadline)) {
+    if (await cond()) return;
+    await Future.delayed(const Duration(milliseconds: 200));
+  }
+  fail('timed out waiting for $what');
+}
+
+Future<void> _quiet(SessionCoordinator c) async {
+  await c.playback.player.setVolume(0);
+  try {
+    final dynamic platform = c.playback.player.platform;
+    await platform?.setProperty('loop-file', 'inf');
+  } catch (_) {}
+}
+
+void main() {
+  test(
+    'two app coordinators split play on readiness over real server',
+    timeout: const Timeout(Duration(minutes: 4)),
+    () async {
+      MediaKit.ensureInitialized();
+      final server = RoomServer(const AppConfig(
+        port: _port,
+        secret: _secret,
+        name: 'room',
+        mediaPath: _mediaPath,
+      ));
+      await server.start();
+
+      final host = SessionCoordinator();
+      final viewer = SessionCoordinator();
+      try {
+        await host.connect(const ConnectParams(
+          host: '127.0.0.1',
+          port: _port,
+          secret: _secret,
+          name: 'host',
+        ));
+        await viewer.connect(const ConnectParams(
+          host: '127.0.0.1',
+          port: _port,
+          secret: _secret,
+          name: 'viewer',
+        ));
+        await _quiet(host);
+        await _quiet(viewer);
+
+        expect(host.playback.player.state.playing, isFalse,
+            reason: 'media must open paused, not autoplay');
+        expect(viewer.playback.player.state.playing, isFalse);
+
+        await _poll(() => host.room.peek() != null, 'host room state');
+        host.toggleReady();
+        await Future.delayed(const Duration(seconds: 5));
+        expect(host.room.peek()?.transport, 'held',
+            reason: 'one Space with company present must not solo-play');
+        expect(host.playback.player.state.playing, isFalse);
+        expect(viewer.playback.player.state.playing, isFalse);
+
+        viewer.toggleReady();
+        await _poll(
+          () =>
+              host.room.peek()?.transport == 'playing' &&
+              viewer.playback.player.state.playing &&
+              host.playback.player.state.playing,
+          'both players playing once quorum readies',
+        );
+      } finally {
+        await host.dispose();
+        await viewer.dispose();
+        await server.stop();
+      }
+    },
+  );
+}