v2.54.1 — Queue zeigt echte Wiedergabe-Reihenfolge (inkl. Shuffle), aktuelles Lied markiert

test/player_service_test.dart

@@ -1,4 +1,5 @@
 import 'package:flutter_test/flutter_test.dart';
+import 'package:melo_app/config/app_config.dart';
 import 'package:melo_app/models/song.dart';
 import 'package:melo_app/services/player_service.dart';
 
@@ -18,6 +19,9 @@ void main() {
     p.setWiederholmodus(Wiederholmodus.aus);
     p.cancelSleepTimer();
     p.setWarteschlange([]);
+    // spiele() mit ungültiger Quelle loggt einen Fehler — ohne Netzwerk-Send
+    // (sonst versucht der Test einen echten HTTP-Post an den Log-Server).
+    AppConfig.sendeDiagnosedaten = false;
   });
 
   group('Warteschlange', () {
@@ -200,6 +204,98 @@ void main() {
     });
   });
 
+  group('Wiedergabe-Reihenfolge (Queue zeigt echte Reihenfolge)', () {
+    test('normal: aktueller Song zuerst, dann der Rest der Warteschlange', () {
+      final p = PlayerService();
+      p.setWarteschlange(
+          [_song(1, 'A'), _song(2, 'B'), _song(3, 'C'), _song(4, 'D')],
+          startIndex: 1);
+      // NICHT die Bibliotheks-Liste [1,2,3,4] — sondern ab dem aktuellen Song
+      expect(p.wiedergabeReihenfolge.map((s) => s.id).toList(), [2, 3, 4]);
+    });
+
+    test('shuffle: folgt der Zufallsreihenfolge ab der aktuellen Position', () {
+      final p = PlayerService();
+      p.setWarteschlange([for (var i = 1; i <= 5; i++) _song(i, 'S$i')]);
+      p.setZufallsmodus(true);
+      final vorher = p.wiedergabeReihenfolge;
+      expect(vorher.length, 5);
+      expect(vorher.first.id, 1); // aktueller Song zuerst
+      expect(vorher.map((s) => s.id).toSet(), {1, 2, 3, 4, 5});
+      // Der erste kommende Eintrag ist exakt der, den naechsterIndex() spielt
+      // (naechsterIndex liefert Queue-Indizes, daher über die Warteschlange vergleichen)
+      final naechster = p.naechsterIndex();
+      expect(p.warteschlange[naechster!].id, vorher[1].id);
+    });
+
+    test('shuffle nach Songwechsel: beginnt mit dem neuen aktuellen Song', () {
+      final p = PlayerService();
+      p.setWarteschlange([for (var i = 1; i <= 5; i++) _song(i, 'S$i')]);
+      p.setZufallsmodus(true);
+      final naechster = p.naechsterIndex()!;
+      p.spiele(p.warteschlange[naechster]); // Shuffle-Position wird synchronisiert
+      final reihenfolge = p.wiedergabeReihenfolge;
+      expect(reihenfolge.first.id, p.warteschlange[naechster].id);
+      // Der beim Mischen ausgeschlossene Song (Index 0 / id 1) taucht erst
+      // wieder auf, wenn er manuell gewählt wird — der Rest der Rotation
+      // (4 Songs) ist vollständig enthalten
+      expect(reihenfolge.length, 4);
+      expect(reihenfolge.map((s) => s.id).toSet(), {2, 3, 4, 5});
+    });
+
+    test('shuffle mit Einzel-Song-Queue: nur der aktuelle Song', () {
+      final p = PlayerService();
+      p.setWarteschlange([_song(1, 'A')]);
+      p.setZufallsmodus(true);
+      expect(p.wiedergabeReihenfolge.map((s) => s.id).toList(), [1]);
+    });
+
+    test('verschieben (normal): ändert Wiedergabe-Reihenfolge und Queue', () {
+      final p = PlayerService();
+      p.setWarteschlange(
+          [_song(1, 'A'), _song(2, 'B'), _song(3, 'C'), _song(4, 'D')],
+          startIndex: 1);
+      p.verschiebeInWiedergabeReihenfolge(2, 1); // D vor C ziehen
+      expect(p.wiedergabeReihenfolge.map((s) => s.id).toList(), [2, 4, 3]);
+      expect(p.warteschlange.map((s) => s.id).toList(), [1, 2, 4, 3]);
+      expect(p.aktuellerIndex, 1); // aktueller Song bleibt an Position 0
+    });
+
+    test('verschieben (shuffle): ändert Zufallsreihenfolge, nicht die Queue', () {
+      final p = PlayerService();
+      p.setWarteschlange([for (var i = 1; i <= 5; i++) _song(i, 'S$i')]);
+      p.setZufallsmodus(true);
+      final vorher = p.wiedergabeReihenfolge;
+      p.verschiebeInWiedergabeReihenfolge(4, 1); // letzten vor den ersten Kommenden
+      final nachher = p.wiedergabeReihenfolge;
+      expect(nachher.length, vorher.length);
+      expect(nachher.map((s) => s.id).toSet(), vorher.map((s) => s.id).toSet());
+      expect(nachher[1].id, vorher[4].id);
+      expect(nachher[2].id, vorher[1].id);
+      // Bibliotheks-Queue bleibt unangetastet (Shuffle-Liste ist die Wiedergabe)
+      expect(p.warteschlange.map((s) => s.id).toList(), [1, 2, 3, 4, 5]);
+      // Der verschobene Song wird wirklich als Nächstes gespielt
+      final naechster = p.naechsterIndex();
+      expect(p.warteschlange[naechster!].id, nachher[1].id);
+    });
+
+    test('Position 0 (aktueller Song) kann nicht verschoben werden', () {
+      final p = PlayerService();
+      p.setWarteschlange([_song(1, 'A'), _song(2, 'B'), _song(3, 'C')]);
+      p.verschiebeInWiedergabeReihenfolge(0, 2); // von = aktueller Song → No-op
+      expect(p.warteschlange.map((s) => s.id).toList(), [1, 2, 3]);
+      // „Vor" den aktuellen Song ziehen landet auf Position 1 (danach)
+      p.verschiebeInWiedergabeReihenfolge(2, 0);
+      expect(p.warteschlange.map((s) => s.id).toList(), [1, 3, 2]);
+    });
+
+    test('leere Warteschlange: No-op', () {
+      final p = PlayerService();
+      p.verschiebeInWiedergabeReihenfolge(1, 2);
+      expect(p.wiedergabeReihenfolge, isEmpty);
+    });
+  });
+
   group('Sleep-Timer', () {
     test('setSleepTimer aktiviert + Restzeit vorhanden', () {
       final p = PlayerService();

test/widget_test.dart

@@ -1,12 +1,64 @@
 import 'package:flutter_test/flutter_test.dart';
 import 'package:flutter/material.dart';
+import 'package:melo_app/models/song.dart';
 import 'package:melo_app/screens/login_screen.dart';
+import 'package:melo_app/services/player_service.dart';
+import 'package:melo_app/widgets/warteschlange_sheet.dart';
+
+Song _song(int id, String titel) => Song(
+  id: id,
+  titel: titel,
+  kuenstler: 'Künstler $id',
+  dauerSekunden: 100,
+  dateiPfad: '',
+);
 
 void main() {
+  setUp(() {
+    // PlayerService ist ein Singleton — Zustand vor jedem Test zurücksetzen
+    final p = PlayerService();
+    p.setZufallsmodus(false);
+    p.setWiederholmodus(Wiederholmodus.aus);
+    p.cancelSleepTimer();
+    p.setWarteschlange([]);
+  });
+
   testWidgets('LoginScreen zeigt Anmelde-Felder', (WidgetTester tester) async {
     await tester.pumpWidget(const MaterialApp(home: LoginScreen()));
     await tester.pumpAndSettle();
     // Prüft dass was gerendert wird (kein Crash)
     expect(find.byType(TextField), findsWidgets);
   });
+
+  testWidgets('WarteschlangeSheet zeigt echte Wiedergabe-Reihenfolge',
+      (WidgetTester tester) async {
+    final p = PlayerService();
+    p.setWarteschlange(
+        [_song(1, 'Aktuell'), _song(2, 'Naechster'), _song(3, 'Danach')],
+        startIndex: 1);
+    await tester.pumpWidget(
+        const MaterialApp(home: Scaffold(body: WarteschlangeSheet())));
+    await tester.pump();
+
+    // Aktueller Song oben, deutlich markiert (▶ + „Jetzt spielt"-Chip)
+    expect(find.text('Jetzt spielt'), findsOneWidget);
+    expect(find.byIcon(Icons.play_arrow), findsOneWidget);
+    // Echte Reihenfolge: aktueller Song zuerst, dann die nächsten Lieder
+    expect(find.text('Naechster'), findsOneWidget);
+    expect(find.text('Danach'), findsOneWidget);
+    // Kopfzeile zählt die Wiedergabe-Reihenfolge (nicht die Bibliothek)
+    expect(find.text('2 Titel'), findsOneWidget);
+  });
+
+  testWidgets('WarteschlangeSheet zeigt Wiederholung-Hinweis bei Repeat',
+      (WidgetTester tester) async {
+    final p = PlayerService();
+    p.setWarteschlange([_song(1, 'A'), _song(2, 'B'), _song(3, 'C')]);
+    p.setWiederholmodus(Wiederholmodus.playlist);
+    await tester.pumpWidget(
+        const MaterialApp(home: Scaffold(body: WarteschlangeSheet())));
+    await tester.pump();
+
+    expect(find.textContaining('Wiederholung aktiv'), findsOneWidget);
+  });
 }