From 956e3be3808f918923aef3259ea5b28bfc055b03 Mon Sep 17 00:00:00 2001
From: salmonik <raisersoft@proton.me>
Date: Fri, 22 May 2026 17:57:08 +0200
Subject: Fix metadata extraction for symphonia 0.6 and add Albums shuffle mode

---
 tests/playback.rs |   2 ++
 tests/queue.rs    | 105 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 107 insertions(+)

(limited to 'tests')

diff --git a/tests/playback.rs b/tests/playback.rs
index 80ecf58..1513a4d 100644
--- a/tests/playback.rs
+++ b/tests/playback.rs
@@ -127,6 +127,8 @@ fn test_player_set_shuffle() {
     let mut player = Player::new();
     player.set_shuffle(ShuffleMode::All);
     assert_eq!(player.shuffle, ShuffleMode::All);
+    player.set_shuffle(ShuffleMode::Albums);
+    assert_eq!(player.shuffle, ShuffleMode::Albums);
 }
 
 #[test]
diff --git a/tests/queue.rs b/tests/queue.rs
index ccc6e54..2dd9f8c 100644
--- a/tests/queue.rs
+++ b/tests/queue.rs
@@ -286,6 +286,8 @@ fn test_shuffle_modes() {
     assert_eq!(*q.shuffle_mode(), ShuffleMode::All);
     q.set_shuffle(ShuffleMode::Album);
     assert_eq!(*q.shuffle_mode(), ShuffleMode::Album);
+    q.set_shuffle(ShuffleMode::Albums);
+    assert_eq!(*q.shuffle_mode(), ShuffleMode::Albums);
     q.set_shuffle(ShuffleMode::None);
     assert_eq!(*q.shuffle_mode(), ShuffleMode::None);
 }
@@ -486,6 +488,109 @@ fn test_track_no_metadata_fields() {
     assert!(t.album.is_none());
 }
 
+// ---------- Shuffle albums ----------
+
+#[test]
+fn test_shuffle_albums_groups_tracks_by_album() {
+    let mut q = Queue::new();
+    q.push_track(track(
+        "/music/a1.mp3",
+        Some("A1"),
+        Some("Artist"),
+        Some("Album A"),
+    ));
+    q.push_track(track(
+        "/music/a2.mp3",
+        Some("A2"),
+        Some("Artist"),
+        Some("Album A"),
+    ));
+    q.push_track(track(
+        "/music/b1.mp3",
+        Some("B1"),
+        Some("Artist"),
+        Some("Album B"),
+    ));
+    q.push_track(track(
+        "/music/b2.mp3",
+        Some("B2"),
+        Some("Artist"),
+        Some("Album B"),
+    ));
+    q.push_track(track(
+        "/music/c1.mp3",
+        Some("C1"),
+        Some("Artist"),
+        Some("Album C"),
+    ));
+    // Queue: Album A (a1, a2), Album B (b1, b2), Album C (c1)
+
+    q.set_shuffle(ShuffleMode::Albums);
+    q.shuffle_initial(); // full shuffle of everything (as happens at play start)
+
+    let shuffled = q.shuffled_indices().to_vec();
+    assert_eq!(shuffled.len(), 5);
+
+    // Tracks from the same album must appear as a contiguous block
+    let shuffled_tracks: Vec<_> = shuffled.iter().map(|&i| q.track_at(i).unwrap()).collect();
+
+    // Find positions of all tracks
+    let a_positions: Vec<_> = shuffled_tracks
+        .iter()
+        .enumerate()
+        .filter(|(_, t)| t.album.as_deref() == Some("Album A"))
+        .map(|(i, _)| i)
+        .collect();
+    let b_positions: Vec<_> = shuffled_tracks
+        .iter()
+        .enumerate()
+        .filter(|(_, t)| t.album.as_deref() == Some("Album B"))
+        .map(|(i, _)| i)
+        .collect();
+
+    assert_eq!(a_positions.len(), 2, "Album A should have 2 tracks");
+    assert_eq!(b_positions.len(), 2, "Album B should have 2 tracks");
+    assert_eq!(
+        a_positions[1] - a_positions[0],
+        1,
+        "Album A tracks should be contiguous"
+    );
+    assert_eq!(
+        b_positions[1] - b_positions[0],
+        1,
+        "Album B tracks should be contiguous"
+    );
+}
+
+#[test]
+fn test_shuffle_albums_solo_track_forms_own_group() {
+    let mut q = Queue::new();
+    q.push_track(track("/music/x.mp3", Some("X"), None, None));
+    q.push_track(track("/music/y.mp3", Some("Y"), None, Some("Album Y")));
+    q.push_track(track("/music/z.mp3", Some("Z"), None, Some("Album Y")));
+
+    q.set_shuffle(ShuffleMode::Albums);
+    let shuffled = q.shuffled_indices().to_vec();
+    assert_eq!(shuffled.len(), 3);
+
+    // Track without album should form its own group of size 1
+    // Tracks y and z share Album Y and should be adjacent
+    let shuffled_tracks: Vec<_> = shuffled.iter().map(|&i| q.track_at(i).unwrap()).collect();
+    let y_pos = shuffled_tracks
+        .iter()
+        .position(|t| t.title.as_deref() == Some("Y"))
+        .unwrap();
+    let z_pos = shuffled_tracks
+        .iter()
+        .position(|t| t.title.as_deref() == Some("Z"))
+        .unwrap();
+    assert_eq!(
+        (y_pos as isize - z_pos as isize).abs(),
+        1,
+        "tracks from same album must be adjacent"
+    );
+}
+
 // ---------- Shuffle restore ----------
 
 #[test]
-- 
cgit v1.2.3