react-native-audio-browser 0.2.0-next.3 → 0.2.0-next.30

package/ios/Tests/PlayingStateTests.swift

@@ -0,0 +1,42 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("Player.playingState")
+@MainActor
+struct PlayingStateTests {
+  private func state(_ playWhenReady: Bool, _ state: PlaybackState) -> PlayingState {
+    Player.playingState(playWhenReady: playWhenReady, state: state)
+  }
+
+  @Test func playingWithIntentInAnActiveState() {
+    #expect(state(true, .playing).playing)
+    #expect(!state(true, .playing).buffering)
+  }
+
+  @Test func bufferingWithIntentWhileLoading() {
+    #expect(state(true, .loading).playing)
+    #expect(state(true, .loading).buffering)
+  }
+
+  @Test func notPlayingWithoutIntent() {
+    #expect(!state(false, .playing).playing)
+  }
+
+  /// .stopped was once missing here, masked only by stop() clearing the intent right after.
+  @Test func notPlayingInTerminalStatesEvenWithIntent() {
+    for terminal in [PlaybackState.none, .stopped, .ended, .error] {
+      #expect(!state(true, terminal).playing, "Expected not playing in \(terminal) despite intent")
+    }
+  }
+
+  @Test func aChangeIsPublishedOnce() {
+    let callbacks = MockPlayerCallbacks()
+    let player = makePlayer()
+    player.callbacks = callbacks
+    player.transition(.avPlayerPlaying)
+    player.setPlayWhenReady(true)
+    player.setPlayWhenReady(true)
+    #expect(callbacks.playingStateChanges.count == 1)
+  }
+}

package/ios/Tests/QueueManagerTests.swift

@@ -9,16 +9,6 @@ private func tracks(_ ids: String...) -> [Track] {
   ids.map { Track(id: $0) }
 }
 
-/// A delegate that records every `queueDidChangeTracks` callback.
-@MainActor
-private final class DelegateSpy: QueueManagerDelegate {
-  var calls: [[Track]] = []
-
-  func queueDidChangeTracks(_ tracks: [Track]) {
-    calls.append(tracks)
-  }
-}
-
 // MARK: - Navigation: next()
 
 @Suite("next()")
@@ -74,6 +64,87 @@ struct NextTests {
     #expect(q.currentIndex == 0)
   }
 
+  /// The start track must be first in the shuffle order, not wherever the permutation put it —
+  /// otherwise auto-advance ends the queue as soon as it is reached (#96).
+  @Test func shuffle_startTrackLeadsTheOrder() {
+    for start in 0 ..< 6 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e", "f"), initialIndex: start)
+      q.shuffleEnabled = true
+
+      #expect(q.shuffleOrder.isFirst(start))
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+      #expect(q.previousTracks.isEmpty)
+    }
+  }
+
+  /// Same hazard on enabling shuffle mid-queue: the existing order has the current track wherever
+  /// it landed, so without re-pinning, turning shuffle on can immediately report end-of-queue.
+  @Test func shuffle_enablingMidQueueLeadsFromCurrent() {
+    for start in 0 ..< 6 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e", "f"))
+      _ = try? q.skipTo(start)
+
+      q.shuffleEnabled = true
+
+      #expect(q.shuffleOrder.isFirst(start))
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+    }
+  }
+
+  /// Re-pinning happens on enable only — flipping it off and on again must not renege on the
+  /// order mid-listen, and a redundant `= true` must not reshuffle under the listener.
+  @Test func shuffle_redundantEnableKeepsTheOrder() {
+    let q = QueueManager()
+    q.setQueue(tracks("a", "b", "c", "d", "e", "f"))
+    q.shuffleEnabled = true
+    let order = q.shuffleOrder.shuffled
+
+    q.shuffleEnabled = true
+    #expect(q.shuffleOrder.shuffled == order)
+
+    q.shuffleEnabled = false
+    #expect(q.shuffleOrder.shuffled == order)
+  }
+
+  /// A queue reorder permutes positions, not identities, so it must leave the
+  /// shuffled playback order alone. Re-inserting at a random shuffle position
+  /// would silently reshuffle under the listener.
+  @Test func shuffle_moveKeepsThePlaybackOrder() {
+    for target in 0 ..< 5 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e"))
+      q.shuffleEnabled = true
+      let before = q.shuffleOrder.shuffled.map { q.tracks[$0].id }
+
+      _ = try? q.move(fromIndex: 0, toIndex: target)
+
+      #expect(q.shuffleOrder.shuffled.map { q.tracks[$0].id } == before)
+    }
+  }
+
+  /// The same hazard as `shuffle_startTrackLeadsTheOrder`, reached by moving the
+  /// *playing* track: a random re-insert can drop it last in the shuffle order,
+  /// which reads as `isLastInPlaybackOrder` and ends the queue at the next track
+  /// boundary with tracks still unplayed.
+  @Test func shuffle_movingCurrentTrackDoesNotEndTheQueue() {
+    for target in 1 ..< 6 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e", "f"), initialIndex: 0)
+      q.shuffleEnabled = true // pins "a" first in the order
+      #expect(!q.isLastInPlaybackOrder)
+
+      _ = try? q.move(fromIndex: 0, toIndex: target)
+
+      #expect(q.currentTrack?.id == "a")
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+    }
+  }
+
   @Test func shuffle_visitsAllTracks() {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c", "d"))
@@ -257,9 +328,9 @@ struct SetQueueTests {
     #expect(q.queueSourcePath == "/albums/123")
   }
 
-  @Test func returnsTrue() {
+  @Test func changesTracksAndCurrent() {
     let q = QueueManager()
-    #expect(q.setQueue(tracks("a")) == true)
+    #expect(q.setQueue(tracks("a")) == .tracksAndCurrent)
   }
 
   @Test func emptyArray_setsCurrentIndexToZero() {
@@ -292,9 +363,9 @@ struct SetQueueTests {
 @Suite("add()")
 @MainActor
 struct AddTests {
-  @Test func toEmptyQueue_returnsTrue_setsCurrentIndex() {
+  @Test func toEmptyQueue_changesCurrent_setsCurrentIndex() {
     let q = QueueManager()
-    let changed = q.add(tracks("a", "b"))
+    let changed = q.add(tracks("a", "b")).currentTrack
     #expect(changed == true)
     #expect(q.currentIndex == 0)
     #expect(q.tracks.count == 2)
@@ -302,28 +373,28 @@ struct AddTests {
 
   @Test func toEmptyQueue_respectsInitialIndex() {
     let q = QueueManager()
-    let changed = q.add(tracks("a", "b", "c"), initialIndex: 2)
+    let changed = q.add(tracks("a", "b", "c"), initialIndex: 2).currentTrack
     #expect(changed == true)
     #expect(q.currentIndex == 2)
   }
 
-  @Test func toNonEmpty_returnsFalse_currentIndexUnchanged() {
+  @Test func toNonEmpty_keepsCurrent_currentIndexUnchanged() {
     let q = QueueManager()
     q.setQueue(tracks("a"))
-    let changed = q.add(tracks("b", "c"))
+    let changed = q.add(tracks("b", "c")).currentTrack
     #expect(changed == false)
     #expect(q.currentIndex == 0)
     #expect(q.tracks.count == 3)
   }
 
-  @Test func emptyArray_returnsFalse() {
+  @Test func emptyArray_changesNothing() {
     let q = QueueManager()
-    #expect(q.add([]) == false)
+    #expect(q.add([]) == .none)
   }
 
   @Test func toEmptyQueue_clampsInitialIndex() {
     let q = QueueManager()
-    let changed = q.add(tracks("a", "b"), initialIndex: 99)
+    let changed = q.add(tracks("a", "b"), initialIndex: 99).currentTrack
     #expect(changed == true)
     #expect(q.currentIndex == 1)
   }
@@ -336,6 +407,25 @@ struct AddTests {
     #expect(q.tracks[2].id == "c")
     #expect(q.tracks[3].id == "d")
   }
+
+  /// Filling an empty queue must pin the start track to the head of the shuffle
+  /// order, exactly as `setQueue` does — `insert(at:count:)` places new indices
+  /// at random positions, so without the pin the start track can land last and
+  /// the queue reports end-of-queue as soon as it finishes. `shuffleEnabled`'s
+  /// didSet only re-pins on the off→on edge, so shuffle-already-on gets nothing
+  /// from it.
+  @Test func toEmptyQueue_withShuffleAlreadyOn_startTrackLeadsTheOrder() {
+    for start in 0 ..< 6 {
+      let q = QueueManager()
+      q.shuffleEnabled = true
+      q.add(tracks("a", "b", "c", "d", "e", "f"), initialIndex: start)
+
+      #expect(q.shuffleOrder.isFirst(start))
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+      #expect(q.previousTracks.isEmpty)
+    }
+  }
 }
 
 // MARK: - Mutations: addAt()
@@ -346,7 +436,7 @@ struct AddAtTests {
   @Test func beforeCurrent_shiftsCurrentIndex() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
-    let changed = try q.addAt(tracks("x", "y"), at: 0)
+    let changed = try q.addAt(tracks("x", "y"), at: 0).currentTrack
     #expect(changed == false)
     #expect(q.currentIndex == 3) // was 1, shifted by 2
     #expect(q.tracks.count == 5)
@@ -355,19 +445,31 @@ struct AddAtTests {
   @Test func afterCurrent_currentIndexUnchanged() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
-    let changed = try q.addAt(tracks("x"), at: 2)
+    let changed = try q.addAt(tracks("x"), at: 2).currentTrack
     #expect(changed == false)
     #expect(q.currentIndex == 0)
     #expect(q.tracks.count == 4)
   }
 
-  @Test func toEmptyQueue_returnsTrue() throws {
+  @Test func toEmptyQueue_changesCurrent() throws {
     let q = QueueManager()
-    let changed = try q.addAt(tracks("a"), at: 0)
+    let changed = try q.addAt(tracks("a"), at: 0).currentTrack
     #expect(changed == true)
     #expect(q.currentIndex == 0)
   }
 
+  /// Same pinning requirement as `add()` into an empty queue — see its twin.
+  @Test func toEmptyQueue_withShuffleAlreadyOn_startTrackLeadsTheOrder() throws {
+    let q = QueueManager()
+    q.shuffleEnabled = true
+    try q.addAt(tracks("a", "b", "c", "d", "e", "f"), at: 0)
+
+    #expect(q.shuffleOrder.isFirst(0))
+    #expect(!q.isLastInPlaybackOrder)
+    #expect(q.nextTracks.count == 5)
+    #expect(q.previousTracks.isEmpty)
+  }
+
   @Test func invalidIndex_throws() {
     let q = QueueManager()
     q.setQueue(tracks("a"))
@@ -384,16 +486,16 @@ struct AddAtTests {
     }
   }
 
-  @Test func emptyArray_returnsFalse() throws {
+  @Test func emptyArray_changesNothing() throws {
     let q = QueueManager()
     q.setQueue(tracks("a"))
-    #expect(try q.addAt([], at: 0) == false)
+    #expect(try q.addAt([], at: 0) == .none)
   }
 
   @Test func singleExistingTrack_insertBeforeCurrent_shifts() throws {
     let q = QueueManager()
     q.setQueue(tracks("a"))
-    let changed = try q.addAt(tracks("x"), at: 0)
+    let changed = try q.addAt(tracks("x"), at: 0).currentTrack
     #expect(changed == false)
     // The pointer follows the playing track — the old `tracks.count > 1`
     // guard silently swapped currentTrack to the inserted track while the
@@ -406,7 +508,7 @@ struct AddAtTests {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
     // currentIndex >= index (1 >= 1) triggers the shift
-    let changed = try q.addAt(tracks("x"), at: 1)
+    let changed = try q.addAt(tracks("x"), at: 1).currentTrack
     #expect(changed == false)
     #expect(q.currentIndex == 2)
     // "b" should still be the current track
@@ -417,7 +519,7 @@ struct AddAtTests {
     let q = QueueManager()
     q.setQueue(tracks("a", "b"))
     // index == tracks.count is the valid append boundary
-    let changed = try q.addAt(tracks("x"), at: 2)
+    let changed = try q.addAt(tracks("x"), at: 2).currentTrack
     #expect(changed == false)
     #expect(q.tracks.count == 3)
     #expect(q.tracks[2].id == "x")
@@ -430,29 +532,29 @@ struct AddAtTests {
 @Suite("remove()")
 @MainActor
 struct RemoveTests {
-  @Test func currentTrack_returnsTrue_wrapsIndex() throws {
+  @Test func currentTrack_changesCurrent_wrapsIndex() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 2)
-    let changed = try q.remove(2)
+    let changed = try q.remove(2).currentTrack
     #expect(changed == true)
     // After removing index 2, tracks has 2 items, currentIndex wraps: 2 % 2 = 0
     #expect(q.currentIndex == 0)
     #expect(q.tracks.count == 2)
   }
 
-  @Test func beforeCurrent_adjustsIndex_returnsFalse() throws {
+  @Test func beforeCurrent_adjustsIndex_keepsCurrent() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 2)
-    let changed = try q.remove(0)
+    let changed = try q.remove(0).currentTrack
     #expect(changed == false)
     #expect(q.currentIndex == 1) // was 2, decremented
     #expect(q.tracks.count == 2)
   }
 
-  @Test func afterCurrent_returnsFalse() throws {
+  @Test func afterCurrent_keepsCurrent() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
-    let changed = try q.remove(2)
+    let changed = try q.remove(2).currentTrack
     #expect(changed == false)
     #expect(q.currentIndex == 0)
     #expect(q.tracks.count == 2)
@@ -461,7 +563,7 @@ struct RemoveTests {
   @Test func lastRemaining_currentIndexBecomesMinusOne() throws {
     let q = QueueManager()
     q.setQueue(tracks("a"))
-    let changed = try q.remove(0)
+    let changed = try q.remove(0).currentTrack
     #expect(changed == true)
     #expect(q.currentIndex == -1)
     #expect(q.tracks.isEmpty)
@@ -493,7 +595,7 @@ struct RemoveTests {
   @Test func currentAtMiddle_wrapsCorrectly() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
-    let changed = try q.remove(1)
+    let changed = try q.remove(1).currentTrack
     #expect(changed == true)
     // 1 % 2 = 1, pointing to what was "c"
     #expect(q.currentIndex == 1)
@@ -503,7 +605,7 @@ struct RemoveTests {
   @Test func currentAtZero_staysAtZero() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"))
-    let changed = try q.remove(0)
+    let changed = try q.remove(0).currentTrack
     #expect(changed == true)
     // 0 % 2 = 0
     #expect(q.currentIndex == 0)
@@ -531,16 +633,16 @@ struct MoveTests {
   @Test func currentTrack_pointerFollows() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
-    let changed = try q.move(fromIndex: 0, toIndex: 2)
+    let changed = try q.move(fromIndex: 0, toIndex: 2).currentTrack
     #expect(changed == false)
     #expect(q.currentIndex == 2)
     #expect(q.currentTrack?.id == "a")
   }
 
-  @Test func nonCurrent_returnsFalse() throws {
+  @Test func nonCurrent_keepsCurrent() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
-    let changed = try q.move(fromIndex: 1, toIndex: 2)
+    let changed = try q.move(fromIndex: 1, toIndex: 2).currentTrack
     #expect(changed == false)
     #expect(q.currentIndex == 0)
   }
@@ -555,7 +657,7 @@ struct MoveTests {
   @Test func nonCurrent_acrossCurrent_keepsPointerOnSameTrack() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
-    let changed = try q.move(fromIndex: 0, toIndex: 2)
+    let changed = try q.move(fromIndex: 0, toIndex: 2).currentTrack
     #expect(changed == false)
     // [a,b,c] → [b,c,a]; "b" is now index 0.
     #expect(q.currentTrack?.id == "b")
@@ -565,7 +667,7 @@ struct MoveTests {
   @Test func nonCurrent_acrossCurrentBackwards_keepsPointerOnSameTrack() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
-    let changed = try q.move(fromIndex: 2, toIndex: 0)
+    let changed = try q.move(fromIndex: 2, toIndex: 0).currentTrack
     #expect(changed == false)
     // [a,b,c] → [c,a,b]; "b" is now index 2.
     #expect(q.currentTrack?.id == "b")
@@ -575,7 +677,7 @@ struct MoveTests {
   @Test func toIndexBeyondCount_clampsPointerToo() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
-    let changed = try q.move(fromIndex: 0, toIndex: 99)
+    let changed = try q.move(fromIndex: 0, toIndex: 99).currentTrack
     #expect(changed == false)
     // remove(0): [b, c], insert at min(2, 99)=2: [b, c, a]
     #expect(q.tracks[2].id == "a")
@@ -607,19 +709,19 @@ struct MoveTests {
 @Suite("clear()")
 @MainActor
 struct ClearTests {
-  @Test func withTracks_returnsTrue_resetsToMinusOne() {
+  @Test func withTracks_changesCurrent_resetsToMinusOne() {
     let q = QueueManager()
     q.setQueue(tracks("a", "b"))
-    let changed = q.clear()
+    let changed = q.clear().currentTrack
     #expect(changed == true)
     #expect(q.currentIndex == -1)
     #expect(q.tracks.isEmpty)
     #expect(q.queueSourcePath == nil)
   }
 
-  @Test func alreadyEmpty_returnsFalse() {
+  @Test func alreadyEmpty_changesNothing() {
     let q = QueueManager()
-    #expect(q.clear() == false)
+    #expect(q.clear() == .none)
   }
 
   /// clear() and removeUpcomingTracks() were the only mutations not
@@ -645,10 +747,10 @@ struct ClearTests {
 @Suite("replace & removeUpcomingTracks")
 @MainActor
 struct OtherMutationTests {
-  @Test func replace_updatesTrackAtIndex() {
+  @Test func replace_updatesTrackAtIndex() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"))
-    q.replace(1, Track(id: "B"))
+    try q.replace(1, Track(id: "B"))
     #expect(q.tracks[1].id == "B")
   }
 
@@ -692,10 +794,10 @@ struct OtherMutationTests {
     #expect(q.tracks[0].id == "a")
   }
 
-  @Test func replace_currentTrack_reflectsInCurrentTrack() {
+  @Test func replace_currentTrack_reflectsInCurrentTrack() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
-    q.replace(1, Track(id: "B"))
+    try q.replace(1, Track(id: "B"))
     #expect(q.currentTrack?.id == "B")
     #expect(q.currentIndex == 1)
   }
@@ -767,13 +869,13 @@ struct ComputedPropertyTests {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c", "d"))
     q.shuffleEnabled = true
-    let nextFromProp = q.nextTracks.map(\.id)
+    let nextFromProp = q.nextTracks.map { $0.id! }
     // Navigate forward only as many times as nextTracks reports
     // (nextTracks does not include wrapped tracks)
     var nextFromNav: [String] = []
     for _ in 0 ..< nextFromProp.count {
       _ = q.next()
-      nextFromNav.append(q.currentTrack!.id)
+      nextFromNav.append(q.currentTrack!.id!)
     }
     #expect(nextFromProp == nextFromNav)
   }
@@ -786,12 +888,12 @@ struct ComputedPropertyTests {
     for _ in 0 ..< 3 {
       _ = q.next()
     }
-    let prevFromProp = q.previousTracks.map(\.id)
+    let prevFromProp = q.previousTracks.map { $0.id! }
     // Navigate backward the same number of times
     var prevFromNav: [String] = []
     for _ in 0 ..< prevFromProp.count {
       _ = q.previous()
-      prevFromNav.insert(q.currentTrack!.id, at: 0)
+      prevFromNav.insert(q.currentTrack!.id!, at: 0)
     }
     #expect(prevFromProp == prevFromNav)
   }
@@ -829,95 +931,74 @@ struct ComputedPropertyTests {
   }
 }
 
-// MARK: - Delegate
+// MARK: - QueueChange
 
-@Suite("delegate")
+@Suite("QueueChange")
 @MainActor
-struct DelegateTests {
-  @Test func queueDidChangeTracks_firesOnSetQueue() {
+struct QueueChangeTests {
+  @Test func setQueue_changesTracksAndCurrent() {
+    #expect(QueueManager().setQueue(tracks("a", "b")) == .tracksAndCurrent)
+  }
+
+  @Test func addToEmpty_changesTracksAndCurrent() {
+    #expect(QueueManager().add(tracks("a")) == .tracksAndCurrent)
+  }
+
+  @Test func addToNonEmpty_changesTracksOnly() {
+    let q = QueueManager()
+    q.setQueue(tracks("a"))
+    #expect(q.add(tracks("b")) == .tracksOnly)
+  }
+
+  @Test func addAt_changesTracksOnly() throws {
     let q = QueueManager()
-    let spy = DelegateSpy()
-    q.delegate = spy
     q.setQueue(tracks("a", "b"))
-    #expect(spy.calls.count == 1)
-    #expect(spy.calls[0].count == 2)
+    #expect(try q.addAt(tracks("x"), at: 1) == .tracksOnly)
+    #expect(q.tracks.count == 3)
   }
 
-  @Test func queueDidChangeTracks_firesOnAdd() {
+  @Test func removeCurrent_changesTracksAndCurrent() throws {
     let q = QueueManager()
-    let spy = DelegateSpy()
-    q.delegate = spy
-    q.add(tracks("a"))
-    #expect(spy.calls.count == 1)
+    q.setQueue(tracks("a", "b"))
+    #expect(try q.remove(0) == .tracksAndCurrent)
   }
 
-  @Test func queueDidChangeTracks_firesOnRemove() throws {
+  @Test func removeOther_changesTracksOnly() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b"))
-    let spy = DelegateSpy()
-    q.delegate = spy
-    try q.remove(1)
-    #expect(spy.calls.count == 1)
-    #expect(spy.calls[0].count == 1)
+    #expect(try q.remove(1) == .tracksOnly)
   }
 
-  @Test func queueDidChangeTracks_firesOnClear() {
+  @Test func clear_changesTracksAndCurrent() {
     let q = QueueManager()
     q.setQueue(tracks("a"))
-    let spy = DelegateSpy()
-    q.delegate = spy
-    q.clear()
-    #expect(spy.calls.count == 1)
-    #expect(spy.calls[0].isEmpty)
+    #expect(q.clear() == .tracksAndCurrent)
+    #expect(q.tracks.isEmpty)
   }
 
-  @Test func queueDidChangeTracks_firesOnMove() throws {
+  @Test func moveCurrent_changesTracksOnly() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"))
-    let spy = DelegateSpy()
-    q.delegate = spy
-    try q.move(fromIndex: 0, toIndex: 2)
-    #expect(spy.calls.count == 1)
+    #expect(try q.move(fromIndex: 0, toIndex: 2) == .tracksOnly)
   }
 
-  @Test func queueDidChangeTracks_firesOnReplace() {
+  @Test func replaceCurrent_changesTracksOnly() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b"))
-    let spy = DelegateSpy()
-    q.delegate = spy
-    q.replace(0, Track(id: "A"))
-    #expect(spy.calls.count == 1)
+    #expect(try q.replace(0, Track(id: "A")) == .tracksOnly)
   }
 
-  @Test func queueDidChangeTracks_firesOnRemoveUpcomingTracks() {
+  @Test func removeUpcomingTracks_changesTracksOnly() {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
-    let spy = DelegateSpy()
-    q.delegate = spy
-    q.removeUpcomingTracks()
-    #expect(spy.calls.count == 1)
-    #expect(spy.calls[0].count == 1)
-  }
-
-  @Test func queueDidChangeTracks_firesOnAddAt() throws {
-    let q = QueueManager()
-    q.setQueue(tracks("a", "b"))
-    let spy = DelegateSpy()
-    q.delegate = spy
-    try q.addAt(tracks("x"), at: 1)
-    #expect(spy.calls.count == 1)
-    #expect(spy.calls[0].count == 3)
+    #expect(q.removeUpcomingTracks() == .tracksOnly)
+    #expect(q.tracks.count == 1)
   }
 
-  @Test func queueDidChangeTracks_doesNotFireOnNavigation() throws {
+  @Test func removeUpcomingTracks_atEnd_changesNothing() {
     let q = QueueManager()
-    q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
-    let spy = DelegateSpy()
-    q.delegate = spy
-    _ = q.next()
-    _ = q.previous()
-    try q.skipTo(2)
-    #expect(spy.calls.isEmpty)
+    q.setQueue(tracks("a", "b"), initialIndex: 1)
+    #expect(q.removeUpcomingTracks() == .none)
   }
 }