465 lines
16 KiB
Dart
465 lines
16 KiB
Dart
import 'package:fake_async/fake_async.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:plezy/watch_together/models/playback_state.dart';
|
|
import 'package:plezy/watch_together/models/sync_message.dart';
|
|
import 'package:plezy/watch_together/models/watch_session.dart';
|
|
import 'package:plezy/watch_together/services/watch_together_controller.dart';
|
|
|
|
import '../test_helpers/watch_together_fakes.dart';
|
|
|
|
const _epochMs = 1000000;
|
|
|
|
/// Two live controllers (host + guest) bridged by an in-memory relay.
|
|
class _Room {
|
|
_Room(this.async, {ControlMode controlMode = ControlMode.hostOnly}) {
|
|
hostService = hub.register('host');
|
|
guestService = hub.register('guest');
|
|
|
|
host = WatchTogetherController(
|
|
peerService: hostService,
|
|
session: WatchSession(
|
|
sessionId: 'ROOM1',
|
|
role: SessionRole.host,
|
|
controlMode: controlMode,
|
|
state: SessionState.connected,
|
|
hostPeerId: 'host',
|
|
),
|
|
nowMs: nowMs,
|
|
);
|
|
guest = WatchTogetherController(
|
|
peerService: guestService,
|
|
session: WatchSession(
|
|
sessionId: 'ROOM1',
|
|
role: SessionRole.guest,
|
|
controlMode: controlMode,
|
|
state: SessionState.connected,
|
|
hostPeerId: 'host',
|
|
),
|
|
nowMs: nowMs,
|
|
);
|
|
|
|
hostPlayer = FakeSyncPlayer(position: const Duration(minutes: 2));
|
|
guestPlayer = FakeSyncPlayer(position: Duration.zero);
|
|
|
|
guest.announceJoin('Guest');
|
|
host.announceJoin('Host');
|
|
async.flushMicrotasks();
|
|
}
|
|
|
|
final FakeAsync async;
|
|
final hub = FakeRelayHub();
|
|
late final HubPeerService hostService;
|
|
late final HubPeerService guestService;
|
|
late final WatchTogetherController host;
|
|
late final WatchTogetherController guest;
|
|
late final FakeSyncPlayer hostPlayer;
|
|
late final FakeSyncPlayer guestPlayer;
|
|
|
|
int nowMs() => _epochMs + async.elapsed.inMilliseconds;
|
|
|
|
PlaybackState lastHostState() => hostService.outgoingLog.lastWhere((m) => m.type == SyncMessageType.state).state!;
|
|
|
|
void hostStartsMedia({String ratingKey = 'rk1', bool hasFirstFrame = false}) {
|
|
host.attachPlayer(
|
|
hostPlayer,
|
|
ratingKey: ratingKey,
|
|
serverId: 'srv',
|
|
mediaTitle: 'Ep',
|
|
hasFirstFrame: hasFirstFrame,
|
|
);
|
|
host.setCurrentMedia(ratingKey: ratingKey, serverId: 'srv', mediaTitle: 'Ep');
|
|
async.flushMicrotasks();
|
|
}
|
|
|
|
void guestJoinsMedia({String ratingKey = 'rk1'}) {
|
|
guest.attachPlayer(guestPlayer, ratingKey: ratingKey, serverId: 'srv');
|
|
async.flushMicrotasks();
|
|
}
|
|
|
|
void bothBecomeReady() {
|
|
hostPlayer.emitPlaybackRestart();
|
|
guestPlayer.emitPlaybackRestart();
|
|
async.flushMicrotasks();
|
|
}
|
|
|
|
void dispose() {
|
|
host.dispose();
|
|
guest.dispose();
|
|
hub.dispose();
|
|
}
|
|
}
|
|
|
|
void main() {
|
|
test('full flow: join, media dispatch, load, one simultaneous start — no loops', () {
|
|
fakeAsync((async) {
|
|
final mediaDispatches = <String>[];
|
|
final room = _Room(async);
|
|
room.guest.onMediaStateReceived = (rk, sid, title) => mediaDispatches.add(rk);
|
|
|
|
// Host opens media; guest hears about it from the loading state even
|
|
// though the host hasn't finished loading (joiners load in parallel).
|
|
room.hostStartsMedia();
|
|
expect(mediaDispatches, ['rk1']);
|
|
|
|
// Guest loads FIRST (the original bug scenario).
|
|
room.guestJoinsMedia();
|
|
room.guestPlayer.emitPlaybackRestart();
|
|
async.flushMicrotasks();
|
|
async.elapse(const Duration(seconds: 4));
|
|
|
|
// While the host loads, the guest must never have been told to play.
|
|
expect(room.guestPlayer.state.playing, isFalse);
|
|
expect(room.guestPlayer.commandLog.where((c) => c == 'play'), isEmpty);
|
|
|
|
// Host finishes loading → scheduled start lands on both simultaneously.
|
|
room.hostPlayer.emitPlaybackRestart();
|
|
async.flushMicrotasks();
|
|
final state = room.lastHostState();
|
|
expect(state.phase, PlaybackPhase.playing);
|
|
final delay = state.anchorHostTimeMs - room.nowMs();
|
|
expect(delay, greaterThan(0));
|
|
|
|
async.elapse(Duration(milliseconds: delay - 50));
|
|
expect(room.hostPlayer.state.playing, isFalse);
|
|
expect(room.guestPlayer.state.playing, isFalse);
|
|
async.elapse(const Duration(milliseconds: 100));
|
|
expect(room.hostPlayer.state.playing, isTrue);
|
|
expect(room.guestPlayer.state.playing, isTrue);
|
|
|
|
// And the guest was aligned to the host's anchor position.
|
|
expect((room.guestPlayer.state.position.inMilliseconds - state.anchorPositionMs).abs(), lessThanOrEqualTo(500));
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('episode switch: state arriving during the guest detach gap is not lost', () {
|
|
fakeAsync((async) {
|
|
final mediaDispatches = <String>[];
|
|
final room = _Room(async);
|
|
room.guest.onMediaStateReceived = (rk, sid, title) => mediaDispatches.add(rk);
|
|
|
|
room.hostStartsMedia();
|
|
room.guestJoinsMedia();
|
|
room.bothBecomeReady();
|
|
final delay = room.lastHostState().anchorHostTimeMs - room.nowMs();
|
|
async.elapse(Duration(milliseconds: delay + 100));
|
|
expect(room.guestPlayer.state.playing, isTrue);
|
|
|
|
// Guest detaches (reload gap) — and ONLY THEN the host switches media.
|
|
room.guest.detachPlayer();
|
|
async.flushMicrotasks();
|
|
room.host.setCurrentMedia(ratingKey: 'rk2', serverId: 'srv', mediaTitle: 'Ep 2');
|
|
room.host.detachPlayer();
|
|
room.host.attachPlayer(room.hostPlayer, ratingKey: 'rk2', serverId: 'srv', mediaTitle: 'Ep 2');
|
|
async.flushMicrotasks();
|
|
|
|
// The guest controller was detached but session-scoped routing caught
|
|
// the new epoch.
|
|
expect(mediaDispatches, contains('rk2'));
|
|
|
|
// Guest re-attaches for the new episode; both load; room starts again.
|
|
room.guest.attachPlayer(room.guestPlayer, ratingKey: 'rk2', serverId: 'srv');
|
|
async.flushMicrotasks();
|
|
room.bothBecomeReady();
|
|
final resume = room.lastHostState();
|
|
expect(resume.phase, PlaybackPhase.playing);
|
|
expect(resume.ratingKey, 'rk2');
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('hostOnly: forged control requests are dropped at the controller', () {
|
|
fakeAsync((async) {
|
|
final room = _Room(async);
|
|
room.hostStartsMedia();
|
|
room.guestJoinsMedia();
|
|
room.bothBecomeReady();
|
|
final delay = room.lastHostState().anchorHostTimeMs - room.nowMs();
|
|
async.elapse(Duration(milliseconds: delay + 100));
|
|
expect(room.hostPlayer.state.playing, isTrue);
|
|
|
|
room.guestService.sendTo(
|
|
'host',
|
|
SyncMessage.control(const ControlRequest(kind: ControlRequestKind.pause), peerId: 'guest'),
|
|
);
|
|
async.elapse(const Duration(seconds: 1));
|
|
|
|
expect(room.hostPlayer.state.playing, isTrue); // Ignored.
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('anyone-mode: guest control requests round-trip through the host', () {
|
|
fakeAsync((async) {
|
|
final room = _Room(async, controlMode: ControlMode.anyone);
|
|
room.hostStartsMedia();
|
|
room.guestJoinsMedia();
|
|
room.bothBecomeReady();
|
|
final delay = room.lastHostState().anchorHostTimeMs - room.nowMs();
|
|
async.elapse(Duration(milliseconds: delay + 100));
|
|
|
|
// Guest presses pause → request → host applies → state pauses guest too.
|
|
room.guestPlayer.emitPlaying(false);
|
|
async.flushMicrotasks();
|
|
expect(room.hostPlayer.state.playing, isFalse);
|
|
final paused = room.lastHostState();
|
|
expect(paused.phase, PlaybackPhase.paused);
|
|
expect(paused.actorPeerId, 'guest');
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('anyone-mode: invalid controls are rejected and the queue continues', () {
|
|
fakeAsync((async) {
|
|
final room = _Room(async, controlMode: ControlMode.anyone);
|
|
final actions = <(String, PlaybackActionHint)>[];
|
|
room.host.onRemoteAction = (peer, hint) => actions.add((peer, hint));
|
|
room.hostStartsMedia();
|
|
room.guestJoinsMedia();
|
|
room.bothBecomeReady();
|
|
final delay = room.lastHostState().anchorHostTimeMs - room.nowMs();
|
|
async.elapse(Duration(milliseconds: delay + 100));
|
|
room.hostPlayer.commandLog.clear();
|
|
final statesBefore = room.hostService.outgoingLog
|
|
.where((message) => message.type == SyncMessageType.state)
|
|
.length;
|
|
final stateBefore = room.lastHostState();
|
|
|
|
SyncMessage wireControl(ControlRequest request) {
|
|
return SyncMessage.fromJson(SyncMessage.control(request, peerId: 'forged-peer').toJson());
|
|
}
|
|
|
|
room.guestService.sendTo(
|
|
'host',
|
|
wireControl(
|
|
ControlRequest(kind: ControlRequestKind.seek, positionMs: room.hostPlayer.state.duration.inMilliseconds + 1),
|
|
),
|
|
);
|
|
room.guestService.sendTo(
|
|
'host',
|
|
wireControl(const ControlRequest(kind: ControlRequestKind.rate, rate: 4.000001)),
|
|
);
|
|
async.flushMicrotasks();
|
|
|
|
expect(room.hostPlayer.commandLog, isEmpty);
|
|
expect(actions, isEmpty);
|
|
expect(
|
|
room.hostService.outgoingLog.where((message) => message.type == SyncMessageType.state),
|
|
hasLength(statesBefore),
|
|
);
|
|
expect(room.lastHostState().seq, stateBefore.seq);
|
|
expect(room.lastHostState().anchorPositionMs, stateBefore.anchorPositionMs);
|
|
expect(room.lastHostState().rate, stateBefore.rate);
|
|
|
|
room.guestService.sendTo(
|
|
'host',
|
|
wireControl(const ControlRequest(kind: ControlRequestKind.seek, positionMs: 600000)),
|
|
);
|
|
async.flushMicrotasks();
|
|
room.guestService.sendTo('host', wireControl(const ControlRequest(kind: ControlRequestKind.rate, rate: 0.25)));
|
|
async.flushMicrotasks();
|
|
|
|
expect(room.hostPlayer.commandLog, ['seek:600000', 'rate:0.25']);
|
|
expect(actions, [('guest', PlaybackActionHint.seek), ('guest', PlaybackActionHint.rate)]);
|
|
final acceptedStates = room.hostService.outgoingLog
|
|
.where((message) => message.type == SyncMessageType.state)
|
|
.skip(statesBefore)
|
|
.map((message) => message.state!)
|
|
.toList();
|
|
expect(acceptedStates, hasLength(2));
|
|
expect(acceptedStates[0].anchorPositionMs, 600000);
|
|
expect(acceptedStates[0].actionHint, PlaybackActionHint.seek);
|
|
expect(acceptedStates[0].actorPeerId, 'guest');
|
|
expect(acceptedStates[1].rate, 0.25);
|
|
expect(acceptedStates[1].actionHint, PlaybackActionHint.rate);
|
|
expect(acceptedStates[1].actorPeerId, 'guest');
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('guest controller starts clock-sync pings automatically', () {
|
|
fakeAsync((async) {
|
|
final room = _Room(async);
|
|
// The guest's clock-sync burst starts immediately and sends pings
|
|
// through its relay-backed peer service.
|
|
async.elapse(const Duration(seconds: 2));
|
|
final pings = room.guestService.outgoingLog.where((m) => m.type == SyncMessageType.ping);
|
|
expect(pings, isNotEmpty);
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('v2 peers are flagged and never gate the start', () {
|
|
fakeAsync((async) {
|
|
final needsUpdate = <String>[];
|
|
final room = _Room(async);
|
|
room.host.onPeerNeedsUpdate = needsUpdate.add;
|
|
|
|
// A sync-protocol-2 client joins on its own connection. The relay
|
|
// stamps the sender ID, so it must really connect as itself.
|
|
final legacyService = room.hub.register('legacy');
|
|
legacyService.sendTo(
|
|
'host',
|
|
SyncMessage(
|
|
type: SyncMessageType.join,
|
|
timestamp: room.nowMs(),
|
|
peerId: 'legacy',
|
|
displayName: 'Old App',
|
|
isHost: false,
|
|
version: 2,
|
|
),
|
|
);
|
|
async.flushMicrotasks();
|
|
expect(needsUpdate, ['legacy']);
|
|
|
|
room.hostStartsMedia();
|
|
room.guestJoinsMedia();
|
|
room.bothBecomeReady();
|
|
// The legacy peer never reports status, yet the room starts.
|
|
expect(room.lastHostState().phase, PlaybackPhase.playing);
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('versionless legacy peers are flagged and never gate the start', () {
|
|
fakeAsync((async) {
|
|
final needsUpdate = <String>[];
|
|
final room = _Room(async);
|
|
room.host.onPeerNeedsUpdate = needsUpdate.add;
|
|
|
|
final versionlessService = room.hub.register('versionless');
|
|
versionlessService.sendTo(
|
|
'host',
|
|
SyncMessage(
|
|
type: SyncMessageType.join,
|
|
timestamp: room.nowMs(),
|
|
peerId: 'versionless',
|
|
displayName: 'Old App',
|
|
isHost: false,
|
|
),
|
|
);
|
|
async.flushMicrotasks();
|
|
expect(needsUpdate, ['versionless']);
|
|
|
|
room.hostStartsMedia();
|
|
room.guestJoinsMedia();
|
|
room.bothBecomeReady();
|
|
expect(room.lastHostState().phase, PlaybackPhase.playing);
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('guest reconnect re-requests state and the host answers directly', () {
|
|
fakeAsync((async) {
|
|
final room = _Room(async);
|
|
room.hostStartsMedia();
|
|
room.guestJoinsMedia();
|
|
room.bothBecomeReady();
|
|
final statesBefore = room.guestService.outgoingLog.length;
|
|
|
|
room.guest.onReconnected();
|
|
async.flushMicrotasks();
|
|
|
|
// Status + requestState went out; host replied with a targeted state.
|
|
final outgoing = room.guestService.outgoingLog.skip(statesBefore);
|
|
expect(outgoing.where((m) => m.type == SyncMessageType.status), isNotEmpty);
|
|
expect(outgoing.where((m) => m.type == SyncMessageType.requestState), isNotEmpty);
|
|
final targeted = room.hostService.outgoingLog.where((m) => m.type == SyncMessageType.state);
|
|
expect(targeted, isNotEmpty);
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('only relay-stamped state from the declared host reaches guest reconciliation', () {
|
|
fakeAsync((async) {
|
|
final room = _Room(async);
|
|
final mediaDispatches = <String>[];
|
|
room.guest.onMediaStateReceived = (ratingKey, serverId, title) => mediaDispatches.add(ratingKey);
|
|
const state = PlaybackState(
|
|
seq: 10,
|
|
ratingKey: 'relay-authority',
|
|
serverId: 'srv',
|
|
mediaTitle: 'Authorized',
|
|
phase: PlaybackPhase.loading,
|
|
anchorPositionMs: 0,
|
|
anchorHostTimeMs: _epochMs,
|
|
rate: 1,
|
|
controlMode: ControlMode.hostOnly,
|
|
);
|
|
final unprivileged = room.hub.register('unprivileged');
|
|
|
|
// The fake relay overwrites the payload claim with the connection's
|
|
// routing ID, just like the production relay envelope parser.
|
|
unprivileged.broadcast(SyncMessage.state(state, peerId: 'host'));
|
|
async.flushMicrotasks();
|
|
expect(mediaDispatches, isEmpty);
|
|
|
|
room.hostService.broadcast(SyncMessage.state(state, peerId: 'host'));
|
|
async.flushMicrotasks();
|
|
expect(mediaDispatches, ['relay-authority']);
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('fake relay rejects duplicate routing IDs instead of replacing authority', () async {
|
|
final hub = FakeRelayHub();
|
|
hub.register('reserved');
|
|
|
|
expect(() => hub.register('reserved'), throwsStateError);
|
|
|
|
await hub.dispose();
|
|
});
|
|
|
|
group('hostExitedPlayer routing', () {
|
|
test('rides the ordered queue: never overtakes states sent before it', () {
|
|
fakeAsync((async) {
|
|
final room = _Room(async);
|
|
final log = <String>[];
|
|
room.guest.onMediaStateReceived = (rk, sid, title) => log.add('state:$rk');
|
|
room.guest.onHostExitedPlayer = () => log.add('hostExit');
|
|
|
|
// Host starts media, then exits the player — wire order matters.
|
|
room.hostStartsMedia();
|
|
room.hostService.broadcast(SyncMessage.hostExitedPlayer(peerId: 'host'));
|
|
async.flushMicrotasks();
|
|
|
|
expect(log, isNotEmpty);
|
|
expect(log.first, 'state:rk1');
|
|
expect(log.last, 'hostExit');
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('is ignored when forged by a non-host peer', () {
|
|
fakeAsync((async) {
|
|
final room = _Room(async);
|
|
var hostExits = 0;
|
|
room.guest.onHostExitedPlayer = () => hostExits++;
|
|
|
|
final evil = room.hub.register('evil');
|
|
evil.broadcast(SyncMessage.hostExitedPlayer(peerId: 'evil'));
|
|
async.flushMicrotasks();
|
|
|
|
expect(hostExits, 0);
|
|
room.dispose();
|
|
});
|
|
});
|
|
|
|
test('the host itself never reacts to a hostExitedPlayer echo', () {
|
|
fakeAsync((async) {
|
|
final room = _Room(async);
|
|
var hostExits = 0;
|
|
room.host.onHostExitedPlayer = () => hostExits++;
|
|
|
|
// A confused/malicious guest sends the message; the host must not
|
|
// tear down its own epoch.
|
|
room.guestService.broadcast(SyncMessage.hostExitedPlayer(peerId: 'guest'));
|
|
async.flushMicrotasks();
|
|
|
|
expect(hostExits, 0);
|
|
room.dispose();
|
|
});
|
|
});
|
|
});
|
|
}
|