foxyzandClaude Opus 5.5
629be0d9ed
- Status: computed from connection, presence, hold, relay, player facts; no setters (health writes and HealthStatus gone); pill, strip and source line read it; transitions go to the Notifier. - Notifier: noticeFor(event, context) with self presence, alone, window activity, playing and prefs; toasts for joins/leaves/returns/swaps/ Up next adds (with picture)/problems/chat, the rest logged; while sitting out only chat, nudges, starting, Up next (+ joins if chosen); alone no social notices; replayed lines logged; owns its toast timer. - System notifications (flutter_local_notifications: D-Bus on Linux, WinRT on Windows) when the window isn't focused; a click focuses it. - Toasts sit above the control bar and move with it. - Versions: each member's in the members card and avatar tooltip, the server's in the card header; the strip no longer shows it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
423 lines
19 KiB
Dart
423 lines
19 KiB
Dart
import 'dart:typed_data';
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:sync_relay_core/core.dart';
|
|
import 'package:starsync/src/controls/frame.dart';
|
|
import 'package:starsync/src/controls/minimal/style.dart';
|
|
import 'package:starsync/src/controls/minimal/timeline.dart';
|
|
import 'package:starsync/src/session/connection.dart';
|
|
import 'package:starsync/src/session/delivery.dart' show MemberNames;
|
|
import 'package:starsync/src/session/app_events.dart';
|
|
import 'package:starsync/src/session/status.dart';
|
|
import 'package:starsync/src/session/now_playing.dart';
|
|
import 'package:starsync/src/shell/now_playing_title.dart';
|
|
import 'package:starsync/src/shell/session_player.dart';
|
|
import 'package:starsync/src/shell/start_banner.dart';
|
|
import 'package:starsync/src/state/session_state.dart';
|
|
|
|
// The one computed status (each input → text and level), the player's
|
|
// title block, start card and status pill (never a media_kit `Video`).
|
|
|
|
/// A 1x1 transparent PNG.
|
|
final png = Uint8List.fromList(const [
|
|
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, //
|
|
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, 0xC4,
|
|
0x89, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0x63, 0x00, 0x01, 0x00, 0x00,
|
|
0x05, 0x00, 0x01, 0x0D, 0x0A, 0x2D, 0xB4, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE,
|
|
0x42, 0x60, 0x82,
|
|
]);
|
|
|
|
MemberView mv(String id, String name,
|
|
{bool ready = false, bool? inSet, double buffered = 30, bool gone = false, bool away = false}) =>
|
|
MemberView(
|
|
id: id,
|
|
name: name,
|
|
ready: ready,
|
|
inSet: inSet ?? ready,
|
|
buffered: buffered,
|
|
presence: gone ? Presence.gone : away ? Presence.away : Presence.watching);
|
|
|
|
StateBroadcast held(List<MemberView> members,
|
|
{String transport = 'held', double position = 0, int mediaId = 1, MediaRelay? relay}) =>
|
|
StateBroadcast(
|
|
eventId: 1,
|
|
transport: transport,
|
|
position: position,
|
|
serverTime: DateTime.now().toUtc(),
|
|
mediaId: mediaId,
|
|
media: {'name': 'Movie.mkv', 'size': 1, 'duration': 0, if (relay != null) 'relay': relay.toJson()},
|
|
members: members,
|
|
);
|
|
|
|
final _now = DateTime.utc(2026, 1, 1, 12);
|
|
|
|
/// The status of [state] as member [self] sees it, online unless [conn].
|
|
Status st(StateBroadcast? state,
|
|
{MemberView? self,
|
|
ConnState conn = const ConnOnline(),
|
|
String playerError = '',
|
|
String playerFault = '',
|
|
bool ownPlan = false,
|
|
int fetchFailedFor = -1,
|
|
MemberNames? names,
|
|
DateTime? now}) =>
|
|
statusOf(StatusFacts(
|
|
conn: conn,
|
|
state: state,
|
|
selfId: self?.id ?? '',
|
|
playerError: playerError,
|
|
playerFault: playerFault,
|
|
ownPlan: ownPlan,
|
|
fetchFailedFor: fetchFailedFor,
|
|
names: names,
|
|
now: now ?? _now,
|
|
));
|
|
|
|
StatusLine? line(StateBroadcast? state, {MemberView? self, ConnState conn = const ConnOnline(), String playerError = ''}) =>
|
|
st(state, self: self, conn: conn, playerError: playerError).line;
|
|
|
|
void main() {
|
|
final coord = SessionState.instance.coordinator;
|
|
|
|
tearDown(() {
|
|
debugArtBytes = null;
|
|
coord.serverState.value = null;
|
|
coord.playback.alive.value = false;
|
|
});
|
|
|
|
group('status', () {
|
|
final me = mv('me', 'Me', ready: true);
|
|
|
|
test('the connection first: reconnecting, unstable, refused, replaced, connecting', () {
|
|
final r = held([me]);
|
|
for (final (conn, text, level, action) in [
|
|
(const ConnLost(), 'Reconnecting…', StatusLevel.warn, StatusAction.cancel),
|
|
(const ConnReconnecting(2), 'Reconnecting…', StatusLevel.warn, StatusAction.cancel),
|
|
(const ConnUnstable(), 'Connection unstable…', StatusLevel.warn, null),
|
|
(const ConnRefused('secret', 'wrong password'), 'Wrong password', StatusLevel.error, StatusAction.retry),
|
|
(const ConnReplaced(), replacedText, StatusLevel.error, StatusAction.retry),
|
|
(const ConnConnecting(), 'Connecting…', StatusLevel.info, null),
|
|
]) {
|
|
final v = line(r, self: me, conn: conn)!;
|
|
expect((v.text, v.level, v.action), (text, level, action), reason: '$conn');
|
|
}
|
|
// Sitting out does not hide the connection.
|
|
expect(line(held([mv('me', 'Me', away: true)]), self: mv('me', 'Me', away: true), conn: const ConnLost())!.text,
|
|
'Reconnecting…');
|
|
});
|
|
|
|
test('the party line: connecting, reconnecting with the state kept, the ready count', () {
|
|
expect(st(null, conn: const ConnConnecting()).party, 'connecting…');
|
|
final r = held([me, mv('b', 'Bob'), mv('z', 'Zed', gone: true)]);
|
|
expect(st(r, self: me, conn: const ConnLost()).party, 'reconnecting…');
|
|
expect(st(r, self: me).party, 'ready 1/2', reason: 'gone is not counted');
|
|
});
|
|
|
|
test('nothing to say: playing, everyone ready, nothing up', () {
|
|
expect(line(held([me], transport: 'playing'), self: me), isNull);
|
|
expect(line(held([me]), self: me), isNull, reason: 'everyone ready');
|
|
expect(line(null), isNull);
|
|
});
|
|
|
|
test('finished, then whoever is loading', () {
|
|
expect(line(held([me], transport: 'finished'), self: me)!.text, 'Finished · seek back or pick the next video');
|
|
final slow = mv('b', 'Bob', ready: true, buffered: RelayConstants.minBufferSecs / 2);
|
|
final v = line(held([me, slow, mv('c', 'Cleo')]), self: me)!;
|
|
expect(v.kind, StatusKind.loading);
|
|
expect(v.text, 'Bob is loading…');
|
|
expect(v.who.single.id, 'b');
|
|
expect(v.progress, closeTo(0.5, 1e-9));
|
|
final mine = mv('me', 'Me', ready: true, buffered: 0);
|
|
expect(line(held([mine]), self: mine)!.text, 'Loading the video…');
|
|
});
|
|
|
|
test('you, then the others with a ready count', () {
|
|
final notMe = mv('me', 'Me');
|
|
final v = line(held([notMe, mv('b', 'Bob')]), self: notMe)!;
|
|
expect(v.kind, StatusKind.you);
|
|
expect(v.text, "Press Space when you're ready");
|
|
expect(v.action, StatusAction.ready);
|
|
expect(v.self, isTrue);
|
|
final w = line(held([me, mv('b', 'Bob'), mv('m', 'Mika'), mv('z', 'Zed', gone: true), mv('o', 'Ola', away: true)]),
|
|
self: me)!;
|
|
expect(w.kind, StatusKind.waiting);
|
|
expect(w.text, 'Waiting for Bob and Mika', reason: 'nobody waits for who sits out');
|
|
expect(w.detail, '1/3 ready');
|
|
final outMe = mv('me', 'Me', away: true);
|
|
expect(line(held([outMe, mv('b', 'Bob')]), self: outMe), isNull, reason: 'sitting out: the join-back card speaks');
|
|
expect(w.who.map((m) => m.name), ['Bob', 'Mika']);
|
|
});
|
|
|
|
test("can't play: yours with Reload, a broken player too; others' instead of waiting", () {
|
|
var v = line(held([me]), self: me, playerError: 'Not allowed (403)')!;
|
|
expect((v.kind, v.text, v.action, v.level),
|
|
(StatusKind.problem, "Can't play this: Not allowed (403)", StatusAction.reload, StatusLevel.error));
|
|
v = st(held([me]), self: me, playerFault: 'video reload failed: gone').line!;
|
|
expect((v.text, v.action), ('Video reload failed: gone', StatusAction.reload));
|
|
final bob = MemberView(id: 'b', name: 'Bob', ready: false, inSet: false, buffered: 0, error: 'Not allowed (403)');
|
|
v = line(held([me, bob, mv('m', 'Mika', ready: true)]), self: me)!;
|
|
expect((v.kind, v.text, v.action), (StatusKind.cannotPlay, "Bob can't play this: Not allowed (403)", null));
|
|
expect(v.who.single.id, 'b');
|
|
final notMe = mv('me', 'Me');
|
|
v = line(held([notMe, bob]), self: notMe)!;
|
|
expect((v.kind, v.action), (StatusKind.cannotPlay, StatusAction.ready));
|
|
});
|
|
|
|
group('the relay', () {
|
|
final bob = mv('b', 'Bob', ready: true);
|
|
test('the server fetching, then failing', () {
|
|
final r = held([me, bob], relay: const MediaRelay(fetch: true));
|
|
expect((line(r, self: me)!.kind, line(r, self: me)!.text),
|
|
(StatusKind.fetching, 'The server is getting the video…'));
|
|
final failed = st(r, self: me, fetchFailedFor: 1).line!;
|
|
expect((failed.text, failed.level), ("The server couldn't fetch this video", StatusLevel.error));
|
|
});
|
|
|
|
test('waiting for the member passing it on', () {
|
|
final v = line(held([me, bob], relay: const MediaRelay(source: 'b')), self: me)!;
|
|
expect((v.text, v.level), ('Waiting for Bob to pass the video on', StatusLevel.warn));
|
|
expect(line(held([me, bob], relay: const MediaRelay(source: 'b', live: true)), self: me), isNull);
|
|
});
|
|
|
|
test("the source's connection dropped: what the server has, and for how long; even while playing", () {
|
|
final gone = MemberView(id: 'b', name: 'Bob', ready: true, inSet: false, buffered: 30, presence: Presence.gone);
|
|
final since = _now.subtract(const Duration(seconds: 20));
|
|
final r = held([me, gone],
|
|
transport: 'playing',
|
|
relay: MediaRelay(source: 'b', live: true, sourceGone: true, sourceGoneSince: since));
|
|
final v = st(r, self: me);
|
|
expect((v.line!.text, v.line!.level), ("Bob's connection dropped — playing what the server has", StatusLevel.warn));
|
|
expect(v.source!.left, isFalse);
|
|
expect(st(r, self: me, now: _now.add(const Duration(minutes: 2))).line!.text,
|
|
"Bob's connection dropped — playing what the server has (2 min)");
|
|
expect(v.delivery!.title, "Bob's connection dropped — playing what the server has");
|
|
// With its own Jellyfin account this viewer does not read the relay.
|
|
expect(st(r, self: me, ownPlan: true).line, isNull);
|
|
});
|
|
|
|
test('the source left: named from before', () {
|
|
final names = MemberNames()..observe(held([me, bob]));
|
|
final r = held([me], transport: 'playing', relay: const MediaRelay(source: 'b', sourceGone: true));
|
|
final v = st(r, self: me, names: names);
|
|
expect(v.line!.text, 'Bob left — playing what the server has');
|
|
expect(v.source!.left, isTrue);
|
|
});
|
|
|
|
test('the source itself sees none of it', () {
|
|
final r = held([me, bob], relay: const MediaRelay(source: 'me'));
|
|
expect(line(r, self: me), isNull);
|
|
});
|
|
});
|
|
|
|
test('names read as a sentence', () {
|
|
expect(nameList(['Bob']), 'Bob');
|
|
expect(nameList(['Bob', 'Mika']), 'Bob and Mika');
|
|
expect(nameList(['Bob', 'Mika', 'Cleo']), 'Bob, Mika and Cleo');
|
|
expect(nameList(['Bob', 'Mika', 'Cleo', 'Dan', 'Eve']), 'Bob, Mika and 3 others');
|
|
});
|
|
});
|
|
|
|
group('status transitions', () {
|
|
final me = mv('me', 'Me', ready: true);
|
|
final gone = MemberView(id: 'b', name: 'Bob', ready: true, inSet: false, buffered: 30, presence: Presence.gone);
|
|
|
|
test('the source gone a few seconds: one notice; left: another', () {
|
|
final w = StatusWatch();
|
|
final r = held([me, gone],
|
|
transport: 'playing', relay: MediaRelay(source: 'b', live: true, sourceGone: true, sourceGoneSince: _now));
|
|
expect(w.step(st(r, self: me), _now.add(const Duration(seconds: 2))), isEmpty, reason: 'a quick drop says nothing');
|
|
final at = _now.add(sourceDropNotice);
|
|
expect(w.step(st(r, self: me), at).single, isA<RelaySourceDropped>().having((e) => e.name, 'name', 'Bob'));
|
|
expect(w.step(st(r, self: me), at.add(const Duration(seconds: 1))), isEmpty, reason: 'once');
|
|
final names = MemberNames()..observe(r);
|
|
final left = held([me], transport: 'playing', relay: const MediaRelay(source: 'b', sourceGone: true));
|
|
expect(w.step(st(left, self: me, names: names), at).single,
|
|
isA<RelaySourceDropped>().having((e) => e.left, 'left', isTrue));
|
|
});
|
|
|
|
test('starting now: the first start of a media seen held, not a resume or a join mid-way', () {
|
|
final w = StatusWatch();
|
|
expect(w.step(st(held([me], transport: 'playing', mediaId: 7), self: me), _now), isEmpty,
|
|
reason: 'joined while it played');
|
|
w.step(st(held([me]), self: me), _now);
|
|
final started = w.step(st(held([me], transport: 'playing'), self: me), _now);
|
|
expect(started.single, isA<PlaybackStarted>().having((e) => e.title, 'title', isNotEmpty));
|
|
w.step(st(held([me]), self: me), _now);
|
|
expect(w.step(st(held([me], transport: 'playing'), self: me), _now), isEmpty, reason: 'a resume');
|
|
});
|
|
|
|
test('replaced and a restarted server, once each', () {
|
|
final w = StatusWatch();
|
|
w.step(statusOf(StatusFacts(conn: const ConnOnline(), now: _now)), _now);
|
|
expect(w.step(statusOf(StatusFacts(conn: const ConnReplaced(), now: _now)), _now).single, isA<Replaced>());
|
|
expect(w.step(statusOf(StatusFacts(conn: const ConnReplaced(), now: _now)), _now), isEmpty);
|
|
expect(w.step(statusOf(StatusFacts(conn: const ConnOnline(), restarts: 1, now: _now)), _now).single,
|
|
isA<ServerRestarted>());
|
|
expect(w.step(statusOf(StatusFacts(conn: const ConnOnline(), restarts: 1, now: _now)), _now), isEmpty);
|
|
});
|
|
});
|
|
|
|
group('title block', () {
|
|
Widget host(Widget child, {double width = 400}) => MaterialApp(
|
|
home: Scaffold(backgroundColor: Colors.black, body: Center(child: SizedBox(width: width, child: child))),
|
|
);
|
|
const now = NowPlaying(title: 'Frieren', episode: 'S1 E4 · The Land Where Souls Rest', posterHash: 'p');
|
|
|
|
testWidgets('title, episode and a placeholder cover without art', (tester) async {
|
|
await tester.pumpWidget(host(const NowPlayingBlock(now: now)));
|
|
expect(find.text('Frieren'), findsOneWidget);
|
|
expect(find.text('S1 E4 · The Land Where Souls Rest'), findsOneWidget);
|
|
expect(find.byIcon(Icons.movie_outlined), findsOneWidget);
|
|
expect(find.byType(Image), findsNothing);
|
|
final cover = tester.getSize(find.byType(ArtCover));
|
|
expect(cover, const Size(40, 60));
|
|
});
|
|
|
|
testWidgets('the cover image once its bytes are here', (tester) async {
|
|
debugArtBytes = (hash) => hash == 'p' ? png : null;
|
|
await tester.pumpWidget(host(const NowPlayingBlock(now: now)));
|
|
final image = tester.widget<Image>(find.byType(Image));
|
|
expect((image.image as MemoryImage).bytes, png);
|
|
expect(image.gaplessPlayback, isTrue);
|
|
});
|
|
|
|
testWidgets('no cover, no episode: just the title; long titles ellipsize', (tester) async {
|
|
await tester.pumpWidget(host(
|
|
NowPlayingBlock(now: NowPlaying(title: 'A very long title ' * 10), cover: false, compact: true),
|
|
width: 200));
|
|
expect(find.byType(ArtCover), findsNothing);
|
|
expect(find.byKey(const ValueKey('now-playing-episode')), findsNothing);
|
|
expect(tester.takeException(), isNull);
|
|
});
|
|
});
|
|
|
|
testWidgets('start banner: up before playback, fades on play, never back for that media', (tester) async {
|
|
await tester.pumpWidget(const MaterialApp(home: SizedBox(width: 1280, height: 720, child: StartBanner())));
|
|
final card = find.byKey(const ValueKey('start-card-title'));
|
|
expect(card, findsNothing);
|
|
coord.serverState.value = held([mv('a', 'Alex')]);
|
|
await tester.pump();
|
|
expect(card, findsOneWidget);
|
|
expect(find.text(coord.nowPlaying.value!.title), findsWidgets);
|
|
expect(tester.widget<AnimatedOpacity>(find.byKey(const ValueKey('start-banner'))).opacity, 1);
|
|
coord.serverState.value = held([mv('a', 'Alex', ready: true)], transport: 'playing');
|
|
await tester.pump();
|
|
expect(tester.widget<AnimatedOpacity>(find.byKey(const ValueKey('start-banner'))).opacity, 0);
|
|
await tester.pumpAndSettle();
|
|
expect(card, findsNothing);
|
|
// Paused back at the start: still gone.
|
|
coord.serverState.value = held([mv('a', 'Alex')]);
|
|
await tester.pumpAndSettle();
|
|
expect(card, findsNothing);
|
|
// The next media gets its own card.
|
|
coord.serverState.value = held([mv('a', 'Alex')], mediaId: 2);
|
|
await tester.pump();
|
|
expect(card, findsOneWidget);
|
|
// Joined mid-way: none.
|
|
coord.serverState.value = held([mv('a', 'Alex')], mediaId: 3, position: 600);
|
|
await tester.pumpAndSettle();
|
|
expect(card, findsNothing);
|
|
});
|
|
|
|
group('no overflow', () {
|
|
const sizes = [Size(900, 600), Size(2560, 1080)];
|
|
final long = NowPlaying(title: 'An Extremely Long Series Title ' * 4, episode: 'S12 E104 · ${'Episode ' * 20}',
|
|
posterHash: 'p', bannerHash: 'b');
|
|
final crowd = [
|
|
for (var i = 0; i < 9; i++) mv('$i', 'Someone With A Long Name $i'),
|
|
];
|
|
|
|
Future<void> sized(WidgetTester tester, Size size, Widget child) async {
|
|
tester.view.physicalSize = size;
|
|
tester.view.devicePixelRatio = 1;
|
|
addTearDown(tester.view.reset);
|
|
await tester.pumpWidget(MaterialApp(theme: ThemeData.dark(), home: Scaffold(body: child)));
|
|
await tester.pumpAndSettle();
|
|
expect(tester.takeException(), isNull);
|
|
}
|
|
|
|
for (final size in sizes) {
|
|
testWidgets('session player, status pill: ${size.width.toInt()}', (tester) async {
|
|
coord.playback.alive.value = true;
|
|
coord.serverState.value = held(crowd);
|
|
await sized(
|
|
tester,
|
|
size,
|
|
SessionPlayer(
|
|
mode: PlayerMode.full,
|
|
fullscreen: false,
|
|
onExpand: () {},
|
|
onCollapse: () {},
|
|
onClose: () {},
|
|
onToggleFullscreen: () {},
|
|
onToggleChat: () {},
|
|
onChangeVideo: () {},
|
|
onOpenIntegrations: () {},
|
|
onLeave: () {},
|
|
windowControls: false,
|
|
videoBuilder: (context, controls) => const ColoredBox(color: Colors.black),
|
|
),
|
|
);
|
|
expect(find.byKey(const ValueKey('player-status')), findsOneWidget);
|
|
expect(find.textContaining('Waiting for Someone With A Long Name 0'), findsOneWidget);
|
|
});
|
|
|
|
testWidgets('minimal top bar and start card: ${size.width.toInt()}', (tester) async {
|
|
debugArtBytes = (hash) => png;
|
|
await sized(
|
|
tester,
|
|
size,
|
|
Stack(fit: StackFit.expand, children: [
|
|
StartCard(now: long),
|
|
ControlsFrame(
|
|
builder: (context, visible) => Stack(children: [
|
|
Positioned(
|
|
left: 16,
|
|
right: 10,
|
|
top: 0,
|
|
height: 72,
|
|
child: Row(children: [
|
|
Expanded(child: NowPlayingBlock(now: long)),
|
|
for (final i in [Icons.fullscreen, Icons.close])
|
|
MinimalButton(icon: i, tooltip: '', onPressed: () {}),
|
|
]),
|
|
),
|
|
Positioned(
|
|
left: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
child: MinimalTimeline(
|
|
position: Duration.zero,
|
|
duration: const Duration(minutes: 24),
|
|
expanded: visible,
|
|
onSeek: (_) {}),
|
|
),
|
|
]),
|
|
),
|
|
]),
|
|
);
|
|
expect(find.byType(ArtCover), findsNWidgets(2));
|
|
});
|
|
|
|
testWidgets('standard top bar row: ${size.width.toInt()}', (tester) async {
|
|
await sized(
|
|
tester,
|
|
size,
|
|
Align(
|
|
alignment: Alignment.topCenter,
|
|
child: SizedBox(
|
|
height: 72,
|
|
child: Row(children: [
|
|
Expanded(child: NowPlayingBlock(now: long)),
|
|
for (final i in [Icons.video_library_outlined, Icons.chat_bubble_outline, Icons.close_fullscreen])
|
|
IconButton(onPressed: () {}, icon: Icon(i)),
|
|
]),
|
|
),
|
|
),
|
|
);
|
|
});
|
|
}
|
|
});
|
|
}
|