react-native-audio-browser 0.2.0-next.27 → 0.2.0-next.29

package/ios/Tests/RequestLayerTests.swift

@@ -0,0 +1,112 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+private struct Config: RequestFields, Equatable {
+  var method: String?
+  var path: String?
+  var baseUrl: String?
+  var headers: [String: String]?
+  var query: [String: String]?
+  var body: String?
+  var contentType: String?
+  var userAgent: String?
+
+  init(
+    method: String? = nil,
+    path: String? = nil,
+    baseUrl: String? = nil,
+    headers: [String: String]? = nil,
+    query: [String: String]? = nil,
+    body: String? = nil,
+    contentType: String? = nil,
+    userAgent: String? = nil,
+  ) {
+    self.method = method
+    self.path = path
+    self.baseUrl = baseUrl
+    self.headers = headers
+    self.query = query
+    self.body = body
+    self.contentType = contentType
+    self.userAgent = userAgent
+  }
+}
+
+@Suite("RequestLayer")
+struct RequestLayerTests {
+  @Test func mergeLetsTheOverrideWinFieldByField() {
+    let base = Config(method: "GET", path: "/a", baseUrl: "https://a", userAgent: "base")
+    let merged = RequestLayer.merge(base, Config(path: "/b", userAgent: "over"))
+    #expect(merged == Config(method: "GET", path: "/b", baseUrl: "https://a", userAgent: "over"))
+  }
+
+  @Test func mergeCombinesHeadersAndQueryByKey() {
+    let base = Config(headers: ["A": "1", "B": "1"], query: ["x": "1"])
+    let merged = RequestLayer.merge(base, Config(headers: ["B": "2"], query: ["y": "2"]))
+    #expect(merged.headers == ["A": "1", "B": "2"])
+    #expect(merged.query == ["x": "1", "y": "2"])
+  }
+
+  @Test func anEmptyOverrideChangesNothing() {
+    let base = Config(method: "POST", path: "/a", baseUrl: "https://a", headers: ["A": "1"])
+    #expect(RequestLayer.merge(base, Config()) == base)
+  }
+
+  @Test func applyStaticKeepsTheBasePath() {
+    let base = Config(path: "/page", baseUrl: "https://a")
+    let applied = RequestLayer.applyStatic(Config(path: "/ignored", baseUrl: "https://b"), to: base)
+    #expect(applied == Config(path: "/page", baseUrl: "https://b"))
+  }
+
+  @Test func transformsWinCompletelyInOrder() async throws {
+    let base = Config(path: "/page", baseUrl: "https://a", headers: ["A": "1"])
+    let layer = Config(baseUrl: "https://static")
+    let applied = try await RequestLayer.apply(
+      layer,
+      transforms: [
+        { Config(path: $0.path, baseUrl: "https://first") },
+        { Config(path: $0.path, baseUrl: $0.baseUrl, userAgent: "second") },
+      ],
+      to: base,
+    )
+    #expect(applied == Config(path: "/page", baseUrl: "https://first", userAgent: "second"))
+  }
+
+  @Test func withoutTransformsTheStaticFieldsApply() async throws {
+    let base = Config(path: "/page", baseUrl: "https://a")
+    let applied = try await RequestLayer.apply(Config(baseUrl: "https://b"), transforms: [], to: base)
+    #expect(applied == Config(path: "/page", baseUrl: "https://b"))
+  }
+
+  @Test func aFailingTransformThrows() async {
+    struct Boom: Error {}
+    await #expect(throws: Boom.self) {
+      _ = try await RequestLayer.apply(Config(), transforms: [{ _ in throw Boom() }], to: Config())
+    }
+  }
+
+  @Test func mergeResolvedLetsSyncWin() {
+    let asyncResolved = Config(baseUrl: "https://async", userAgent: "ASYNC")
+    let syncResolved = Config(userAgent: "SYNC")
+    #expect(RequestLayer.mergeResolved(async: Config?.none, sync: nil) == nil)
+    #expect(RequestLayer.mergeResolved(async: asyncResolved, sync: nil) == asyncResolved)
+    #expect(RequestLayer.mergeResolved(async: nil, sync: syncResolved) == syncResolved)
+    #expect(
+      RequestLayer.mergeResolved(async: asyncResolved, sync: syncResolved)
+        == Config(baseUrl: "https://async", userAgent: "SYNC"),
+    )
+  }
+
+  @Test func buildUrlJoinsBaseUrlPathAndQuery() {
+    #expect(RequestLayer.buildUrl(Config(path: "/a", baseUrl: "https://host")) == "https://host/a")
+    #expect(RequestLayer.buildUrl(Config(baseUrl: "https://host"), defaultPath: "/d") == "https://host/d")
+    #expect(RequestLayer.buildUrl(Config(path: "/a", baseUrl: "https://host", query: ["q": "x"])) == "https://host/a?q=x")
+  }
+
+  @Test func mergeDictsIsNilSafe() {
+    #expect(RequestLayer.mergeDicts(nil, nil) == nil)
+    #expect(RequestLayer.mergeDicts(["a": "1"], nil) == ["a": "1"])
+    #expect(RequestLayer.mergeDicts(nil, ["b": "2"]) == ["b": "2"])
+  }
+}

package/ios/Tests/RetryLoopTests.swift

@@ -0,0 +1,270 @@
+import AVFoundation
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+private final class MockNetworkStatus: NetworkStatusProviding, @unchecked Sendable {
+  var isOnline: Bool
+  init(isOnline: Bool) { self.isOnline = isOnline }
+}
+
+/// The two duration budgets: a never-played load gives up fast while online; a
+/// load that produced audio — or a device that is offline — keeps the full
+/// recovery budget. Timing-based: budgets are configured in single-digit
+/// milliseconds so one executed backoff (~1s) exhausts them.
+@Suite("RetryLoop budgets")
+@MainActor
+struct RetryLoopBudgetTests {
+  /// Returns the mock too — `networkMonitor` is weak, the test must keep it alive.
+  private func makeManager(
+    firstConnectMs: Double,
+    maxMs: Double = 120_000,
+    online: Bool,
+  ) -> (RetryLoop, MockNetworkStatus) {
+    let manager = RetryLoop()
+    manager.updatePolicy(from: .second(RetryConfig(
+      maxRetries: nil,
+      maxRetryDurationMs: maxMs,
+      firstConnectMaxRetryDurationMs: firstConnectMs,
+    )))
+    let network = MockNetworkStatus(isOnline: online)
+    manager.networkMonitor = network
+    return (manager, network)
+  }
+
+  /// A dead-on-arrival stream: the first attempt runs, and the budget refuses
+  /// a later one. Budgets are checked before AND after each backoff wait, so
+  /// the test budget must exceed the first backoff (~1s) for attempt one to
+  /// execute, and be exceeded by the cumulative ~2.5s before attempt two ends.
+  /// 1800ms sits ~800ms clear of the first backoff (sleep overshoot on a loaded
+  /// machine only widens the passing margins, never shrinks them into failure).
+  @Test func neverPlayedLoad_givesUpAfterFirstConnectBudget() async {
+    let (manager, network) = makeManager(firstConnectMs: 1800, online: true)
+    _ = network
+
+    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
+    #expect(await manager.attemptRetry(startFromCurrentTime: false) == false)
+  }
+
+  /// The same failure timeline on a load that has produced audio keeps
+  /// retrying: only the recovery budget applies.
+  @Test func playedLoad_ignoresTheFirstConnectBudget() async {
+    let (manager, network) = makeManager(firstConnectMs: 500, online: true)
+    _ = network
+    manager.hasPlayed = { true }
+
+    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
+    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
+  }
+
+  /// Offline failures must not burn the first-connect budget (a station tapped
+  /// in a tunnel parks for connectivity); the budget's clock starts at the
+  /// first failure observed online, so a dead station still gets a fast
+  /// verdict after restoration.
+  @Test func offlineTime_doesNotBurnTheFirstConnectBudget() async {
+    // 4s: well above the ~2.3s backoff of the first online attempt (the ladder
+    // kept climbing while offline), well below the ~5.6s cumulative after it.
+    let (manager, network) = makeManager(firstConnectMs: 4000, online: false)
+
+    // Offline: the short budget never engages, attempts keep running.
+    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
+    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
+
+    // Connectivity returns: the short clock starts now — one more attempt
+    // runs, then the budget is spent.
+    network.isOnline = true
+    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
+    #expect(await manager.attemptRetry(startFromCurrentTime: false) == false)
+  }
+}
+
+// MARK: - handleError
+
+@Suite("RetryLoop.handleError")
+@MainActor
+struct RetryLoopHandleErrorTests {
+  /// What the loop reported and did, in order.
+  final class Record {
+    var retrying: [TrackPlayerError.PlaybackError] = []
+    var errors: [TrackPlayerError.PlaybackError] = []
+    var reloads: [Bool] = []
+  }
+
+  private func makeLoop(retries: Bool = true, delay: TimeInterval = 0) -> (RetryLoop, Record) {
+    let loop = makeRetryLoop(retries: retries, delay: delay)
+    let record = Record()
+    loop.onRetryingError = { record.retrying.append($0) }
+    loop.onError = { record.errors.append($0) }
+    loop.onRetry = { record.reloads.append($0) }
+    return (loop, record)
+  }
+
+  @Test func aNonRetryableErrorSurfacesAtOnce() {
+    let (loop, record) = makeLoop()
+    loop.handleError(URLError(.badURL), context: .playback)
+    #expect(record.errors == [.playbackFailed])
+    #expect(record.retrying.isEmpty)
+    #expect(loop.pendingTask == nil)
+  }
+
+  /// A disabled policy makes every error terminal: no advisory, no retry task, even for a
+  /// retryable failure, which is still classified.
+  @Test func aDisabledPolicySurfacesAtOnce() {
+    let (loop, record) = makeLoop()
+    loop.updatePolicy(from: nil)
+    loop.handleError(URLError(.notConnectedToInternet), context: .mediaLoad)
+    #expect(record.errors == [.notConnectedToInternet])
+    #expect(record.retrying.isEmpty)
+    #expect(loop.pendingTask == nil)
+  }
+
+  /// Also pins that a finished retry clears its handle: session release waits on it.
+  @Test func aRetryableErrorReloadsFromTheContextsPosition() async {
+    let (loop, record) = makeLoop()
+    loop.handleError(URLError(.timedOut), context: .playback)
+    #expect(loop.pendingTask != nil)
+    await loop.pendingTask?.value
+    loop.handleError(URLError(.timedOut), context: .mediaLoad)
+    await loop.pendingTask?.value
+
+    #expect(record.reloads == [true, false])
+    #expect(record.errors.isEmpty)
+    #expect(loop.pendingTask == nil)
+    #expect(loop.attempts == 2)
+  }
+
+  /// The advisory goes out before the backoff, carrying the classification a terminal report
+  /// would.
+  @Test func theAdvisoryPrecedesTheRetry() async {
+    let (loop, record) = makeLoop()
+    loop.handleError(URLError(.cannotConnectToHost), context: .mediaLoad)
+    #expect(record.retrying == [.hostUnreachable])
+    #expect(record.reloads.isEmpty)
+    await loop.pendingTask?.value
+    #expect(record.errors.isEmpty)
+  }
+
+  @Test func givingUpReportsTheAdvisoryThenTheTerminalError() async {
+    let (loop, record) = makeLoop(retries: false)
+    loop.handleError(URLError(.cannotConnectToHost), context: .mediaLoad)
+    await loop.pendingTask?.value
+    #expect(record.retrying == [.hostUnreachable])
+    #expect(record.errors == [.hostUnreachable])
+  }
+
+  /// A cancelled retry stays silent: a track change or a stop cancels it, and surfacing its
+  /// failure would flip the new track or the stop to .error.
+  @Test func aCancelledRetryStaysSilent() async {
+    let (loop, record) = makeLoop(delay: 0.05)
+    loop.handleError(URLError(.timedOut), context: .playback)
+    let task = loop.pendingTask
+    loop.cancel()
+    #expect(loop.pendingTask == nil)
+    await task?.value
+    #expect(record.errors.isEmpty)
+    #expect(record.reloads.isEmpty)
+  }
+
+  /// A second failure replaces the retry in flight, which neither reports nor reloads.
+  @Test func aNewFailureReplacesTheRetryInFlight() async {
+    let (loop, record) = makeLoop(delay: 0.02)
+    loop.handleError(URLError(.timedOut), context: .playback)
+    let first = loop.pendingTask
+    loop.handleError(URLError(.timedOut), context: .playback)
+    let second = loop.pendingTask
+    await first?.value
+    await second?.value
+    #expect(record.reloads == [true])
+    #expect(record.errors.isEmpty)
+  }
+
+  @Test func theHTTPStatusReachesTheReport() async {
+    let (loop, record) = makeLoop(retries: false)
+    loop.handleError(nil, context: .playback, httpStatusCode: 404)
+    loop.handleError(URLError(.badURL), context: .playback, httpStatusCode: 503)
+    await loop.pendingTask?.value
+    #expect(record.errors == [.httpStatus(404), .httpStatus(503)])
+  }
+
+  /// An unclassifiable failure, retried and given up on, reports the context's fallback.
+  @Test func givingUpOnAnOpaqueFailureReportsTheFallback() async {
+    let (loop, record) = makeLoop(retries: false)
+    loop.handleError(NSError(domain: "CoreMediaErrorDomain", code: -12939), context: .mediaLoad)
+    await loop.pendingTask?.value
+    #expect(record.errors == [.failedToLoadKeyValue])
+  }
+
+  @Test func resetRefillsTheBudgets() async {
+    let (loop, _) = makeLoop()
+    loop.handleError(URLError(.timedOut), context: .playback)
+    await loop.pendingTask?.value
+    #expect(loop.attempts == 1)
+    loop.reset()
+    #expect(loop.attempts == 0)
+  }
+
+  @Test func resetDropsTheRetryInFlightSilently() async {
+    let (loop, record) = makeLoop(delay: 0.02)
+    loop.handleError(URLError(.timedOut), context: .playback)
+    let task = loop.pendingTask
+    loop.reset()
+    #expect(loop.pendingTask == nil)
+    await task?.value
+    #expect(record.errors.isEmpty)
+    #expect(record.reloads.isEmpty)
+  }
+
+  /// A loop whose backoff waits until cancelled, reporting when it starts waiting.
+  private func makeWaitingLoop() -> (RetryLoop, Record, () -> Bool) {
+    var waiting = false
+    let loop = RetryLoop(sleep: { _ in
+      await MainActor.run { waiting = true }
+      try await Task.sleep(for: .seconds(60))
+    })
+    loop.updatePolicy(from: .first(true))
+    loop.shouldRetry = { true }
+    let record = Record()
+    loop.onError = { record.errors.append($0) }
+    loop.onRetry = { record.reloads.append($0) }
+    return (loop, record, { waiting })
+  }
+
+  @Test func aCancelDuringTheBackoffStaysSilent() async {
+    let (loop, record, isWaiting) = makeWaitingLoop()
+    loop.handleError(URLError(.timedOut), context: .playback)
+    let task = loop.pendingTask
+    while !isWaiting() {
+      await Task.yield()
+    }
+    loop.cancel()
+    await task?.value
+    #expect(record.errors.isEmpty)
+    #expect(record.reloads.isEmpty)
+  }
+
+  /// A cancel that lands as the backoff completes (the sleep itself returning normally) still
+  /// stops the reload.
+  @Test func aCancelAsTheBackoffEndsStopsTheReload() async {
+    let holder = LoopHolder()
+    let loop = RetryLoop(sleep: { _ in
+      await holder.loop?.cancel()
+    })
+    holder.loop = loop
+    loop.updatePolicy(from: .first(true))
+    loop.shouldRetry = { true }
+    let record = Record()
+    loop.onError = { record.errors.append($0) }
+    loop.onRetry = { record.reloads.append($0) }
+    loop.handleError(URLError(.timedOut), context: .playback)
+    let task = loop.pendingTask
+    await task?.value
+    #expect(record.reloads.isEmpty)
+    #expect(record.errors.isEmpty)
+  }
+}
+
+@MainActor
+private final class LoopHolder {
+  weak var loop: RetryLoop?
+}

package/ios/Tests/Support/TestTypes.swift

@@ -1,6 +1,3 @@
-// This file is intentionally empty — mock types live in
-// Model/NitroTypeStubs.swift (part of the AudioBrowserTestable target).
-
 @testable import AudioBrowserTestable
 import AVFoundation
 
@@ -28,94 +25,116 @@ func makeMetadataItem(
   return item
 }
 
-// MARK: - Mock PlaybackEffectHandler
+// MARK: - Mock PlayerEngine
 
 @MainActor
-final class MockPlaybackEffectHandler: PlaybackEffectHandler {
-  // Playback control
-  var startPlaybackCallCount = 0
-  var pausePlaybackCallCount = 0
-  var setTimePitchCallCount = 0
-
-  func startPlayback() { startPlaybackCallCount += 1 }
-  func pausePlayback() { pausePlaybackCallCount += 1 }
-  func setTimePitchingAlgorithmForCurrentItem() { setTimePitchCallCount += 1 }
+final class MockPlayerEngine: PlayerEngine {
+  var onEvent: (@MainActor (EngineEvent) -> Void)?
 
-  // Player volume
-  var volume: Float = 1
+  /// Reports `event` as the media stack would.
+  func emit(_ event: EngineEvent) {
+    onEvent?(event)
+  }
 
-  // AVPlayer state queries
+  // The current item
+  var hasItem = false
+  var hasLoadedAsset = false
   var currentTime: Double = 0
   var duration: Double = 0
   var bufferedPosition: Double = 0
-  var hasLoadedAsset: Bool = false
-
-  // Item management
-  var clearCurrentItemCallCount = 0
-  var stopObservingCurrentItemCallCount = 0
-
-  func clearCurrentItem() { clearCurrentItemCallCount += 1 }
-  func stopObservingCurrentItem() { stopObservingCurrentItemCallCount += 1 }
-
-  // Track loading
-  var loadTrackCalls: [String] = []
-  var loadTrackTracks: [Track] = []
-  var reloadTrackCalls: [Bool] = []
-  var unloadTrackCallCount = 0
-  var cancelMediaLoadingCallCount = 0
+  var resumePosition: Double?
+  var liveEdge: Double?
+  var isPlaybackLikelyToKeepUp = false
+  var isAirPlayRoute = false
+  var volume: Float = 1
 
-  func loadTrack(src: String, track: Track) {
-    loadTrackCalls.append(src)
-    loadTrackTracks.append(track)
+  // Loading
+  var resolveAndLoadCalls: [String] = []
+  var loadResolvedCount = 0
+  var cancelLoadingCount = 0
+  var dropAssetCount = 0
+  var clearItemCount = 0
+  var stopObservingItemCount = 0
+  var recreateCount = 0
+
+  func resolveAndLoad(src: String, track _: Track) { resolveAndLoadCalls.append(src) }
+  func loadResolved() { loadResolvedCount += 1 }
+  func cancelLoading() { cancelLoadingCount += 1 }
+  func dropAsset() { dropAssetCount += 1 }
+  func clearItem() { clearItemCount += 1 }
+  func stopObservingItem() { stopObservingItemCount += 1 }
+  func recreate() { recreateCount += 1 }
+
+  // Transport
+  var startPlaybackCallCount = 0
+  var pausePlaybackCallCount = 0
+  var setTimePitchCallCount = 0
+  var rates: [(rate: Float, playing: Bool)] = []
+  var seekCalls: [Double] = []
+  /// What a seek completes with; nil leaves it in flight until `completeSeeks`.
+  var seekResult: Bool? = true
+
+  func play() { startPlaybackCallCount += 1 }
+  func pause() { pausePlaybackCallCount += 1 }
+  func setRate(_ rate: Float, playing: Bool) { rates.append((rate, playing)) }
+  private var seeksInFlight: [@MainActor (Bool) -> Void] = []
+
+  func seek(to seconds: Double, completion: @escaping @MainActor (Bool) -> Void) {
+    seekCalls.append(seconds)
+    if let seekResult { completion(seekResult) } else { seeksInFlight.append(completion) }
+  }
+
+  /// Lands the seeks left in flight while `seekResult` was nil.
+  func completeSeeks(_ finished: Bool) {
+    let pending = seeksInFlight
+    seeksInFlight = []
+    for completion in pending {
+      completion(finished)
+    }
   }
 
-  func reloadTrack(startFromCurrentTime: Bool) { reloadTrackCalls.append(startFromCurrentTime) }
-  func unloadTrack() { unloadTrackCallCount += 1 }
-  func cancelMediaLoading() { cancelMediaLoadingCallCount += 1 }
-
-  // Seek operations
-  var seekToStartCallCount = 0
-  var replayCurrentTrackCallCount = 0
+  func applyTimePitchAlgorithm() { setTimePitchCallCount += 1 }
 
-  func seekToStart() { seekToStartCallCount += 1 }
-  func replayCurrentTrack() { replayCurrentTrackCallCount += 1 }
-
-  // Now Playing
+  // Now playing and remote commands
+  var primeCount = 0
   var loadNowPlayingMetadataCalls: [Track] = []
   var clearNowPlayingCallCount = 0
-  var updateNowPlayingStateCalls: [Bool] = []
-
-  func loadNowPlayingMetadata(for track: Track) {
-    loadNowPlayingMetadataCalls.append(track)
-  }
-
-  func clearNowPlaying() { clearNowPlayingCallCount += 1 }
-  func updateNowPlayingState(playWhenReady: Bool) {
-    updateNowPlayingStateCalls.append(playWhenReady)
-  }
-
-  // Remote commands
   var updateRemoteRepeatModeCalls: [RepeatMode] = []
   var updateRemoteShuffleModeCalls: [Bool] = []
-
-  func updateRemoteRepeatMode(_ mode: RepeatMode) {
-    updateRemoteRepeatModeCalls.append(mode)
-  }
-
-  func updateRemoteShuffleMode(_ enabled: Bool) {
-    updateRemoteShuffleModeCalls.append(enabled)
-  }
-
   var updateSkipAvailabilityCalls: [(canNext: Bool, canPrevious: Bool)] = []
+
+  func primeNowPlaying() { primeCount += 1 }
+  func loadNowPlayingMetadata(for track: Track) { loadNowPlayingMetadataCalls.append(track) }
+  func clearNowPlaying() { clearNowPlayingCallCount += 1 }
+  func updateRemoteRepeatMode(_ mode: RepeatMode) { updateRemoteRepeatModeCalls.append(mode) }
+  func updateRemoteShuffleMode(_ enabled: Bool) { updateRemoteShuffleModeCalls.append(enabled) }
   func updateSkipAvailability(canNext: Bool, canPrevious: Bool) {
     updateSkipAvailabilityCalls.append((canNext, canPrevious))
   }
 }
 
-// MARK: - Mock PlaybackCoordinatorCallbacks
+/// A Player over `engine` whose retries reload while `retries` and otherwise give up, keeping
+/// its resume snapshot out of the app's defaults.
+@MainActor
+func makePlayer(
+  engine: MockPlayerEngine = MockPlayerEngine(),
+  retry: RetryLoop = makeRetryLoop(),
+  retries: Bool = true,
+  sleepTimer: SleepTimerManager = SleepTimerManager(scheduler: ManualSleepTimerScheduler()),
+  saveInterval: Duration = .seconds(5),
+) -> Player {
+  let player = Player(
+    engine: engine, retry: retry, sleepTimerManager: sleepTimer,
+    persistenceDefaults: UserDefaults(suiteName: "PlayerTests")!, persistenceSaveInterval: saveInterval,
+  )
+  retry.shouldRetry = { retries }
+  return player
+}
+
+// MARK: - Mock PlayerCallbacks
 
 @MainActor
-final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
+final class MockPlayerCallbacks: PlayerCallbacks {
   var playbackChanges: [Playback] = []
   var activeTrackChanges: [PlaybackActiveTrackChangedEvent] = []
   var progressUpdates: [PlaybackProgressUpdatedEvent] = []
@@ -123,18 +142,25 @@ final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
   var playingStateChanges: [PlayingState] = []
   var queueEndedEvents: [PlaybackQueueEndedEvent] = []
   var queueChanges: [[Track]] = []
+  /// The order in which the queue and active-track callbacks arrived.
+  var queueAndTrackOrder: [String] = []
   var repeatModeChanges: [RepeatModeChangedEvent] = []
   var shuffleEnabledChanges: [Bool] = []
   var errorEvents: [PlaybackErrorEvent] = []
   var playbackIntervalFiredCount = 0
   var releaseSessionCount = 0
 
+  /// The order playback, intent and playing-state changes arrived in.
+  var publishOrder: [String] = []
+
   func playerDidChangePlayback(_ playback: Playback) {
+    publishOrder.append("playback")
     playbackChanges.append(playback)
   }
 
   func playerDidChangeActiveTrack(_ event: PlaybackActiveTrackChangedEvent) {
     activeTrackChanges.append(event)
+    queueAndTrackOrder.append("activeTrack")
   }
 
   func playerDidUpdateProgress(_ event: PlaybackProgressUpdatedEvent) {
@@ -146,10 +172,12 @@ final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
   }
 
   func playerDidChangePlayWhenReady(_ playWhenReady: Bool) {
+    publishOrder.append("playWhenReady")
     playWhenReadyChanges.append(playWhenReady)
   }
 
   func playerDidChangePlayingState(_ state: PlayingState) {
+    publishOrder.append("playingState")
     playingStateChanges.append(state)
   }
 
@@ -159,6 +187,7 @@ final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
 
   func playerDidChangeQueue(_ tracks: [Track]) {
     queueChanges.append(tracks)
+    queueAndTrackOrder.append("queue")
   }
 
   func playerDidChangeRepeatMode(_ event: RepeatModeChangedEvent) {
@@ -176,53 +205,23 @@ final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
   func playerShouldReleaseSession() {
     releaseSessionCount += 1
   }
-}
-
-// MARK: - Mock SleepTimerHandling
 
-@MainActor
-final class MockSleepTimerHandling: SleepTimerHandling {
-  var onComplete: (() -> Void)?
-  var onFadeStart: ((_ duration: TimeInterval) -> Void)?
-  var onFadeCancel: (() -> Void)?
-  var onChanged: ((SleepTimerState) -> Void)?
-  var trackChangedCallCount = 0
-  var trackPlayedToEndCallCount = 0
-  var clearCallCount = 0
-
-  @discardableResult func clear() -> Bool {
-    clearCallCount += 1
-    return true
-  }
-
-  func onTrackChanged() { trackChangedCallCount += 1 }
-  func onTrackPlayedToEnd() { trackPlayedToEndCallCount += 1 }
-
-  // Consumer-facing surface — unused by the coordinator tests, present only to
-  // satisfy the protocol. Add recorders alongside the tests that need them.
-  func get() -> SleepTimerState? { nil }
-  func set(seconds _: TimeInterval, fadeDuration _: TimeInterval?) {}
-  func setToEndOfTrack() {}
+  var sleepTimerChanges: [SleepTimerState?] = []
+  func playerDidChangeSleepTimer(_ state: SleepTimerState?) {
+    sleepTimerChanges.append(state)
+  }
 }
 
-// MARK: - Mock RetryHandling
+// MARK: - RetryLoop
 
+/// A RetryLoop for tests: enabled, with an instant backoff unless `delay`, whose attempts reload
+/// while `retries` and otherwise give up, as an exhausted budget does.
 @MainActor
-final class MockRetryHandling: RetryHandling {
-  var isEnabled = true
-  var hasPlayed = false
-  var isRetryableResult = false
-  var attemptRetryResult = false
-  var attemptRetryDelayNs: UInt64 = 0
-  var resetCallCount = 0
-
-  func isRetryable(_: Error?, httpStatusCode _: Int?) -> Bool { isRetryableResult }
-  func attemptRetry(startFromCurrentTime _: Bool) async -> Bool {
-    if attemptRetryDelayNs > 0 {
-      try? await Task.sleep(nanoseconds: attemptRetryDelayNs)
-    }
-    return attemptRetryResult
-  }
-
-  func reset() { resetCallCount += 1 }
+func makeRetryLoop(retries: Bool = true, delay: TimeInterval = 0) -> RetryLoop {
+  let loop = RetryLoop(sleep: { _ in
+    if delay > 0 { try await Task.sleep(for: .seconds(delay)) }
+  })
+  loop.updatePolicy(from: .first(true))
+  loop.shouldRetry = { retries }
+  return loop
 }

package/ios/Tests/TrackIdTemplateTests.swift

@@ -2,7 +2,7 @@
 import Testing
 
 /// `{id}` template substitution used by artwork URL resolution
-/// (BrowserManager+URLResolution.substituteTrackId). A track without a non-blank id must leave
+/// (RequestPipeline.substituteTrackId). A track without a non-blank id must leave
 /// the token LITERALLY in place — never substitute an empty string, never skip — so the
 /// resulting request 404s with a self-describing URL (the resolver logs a warning keyed off
 /// `containsToken`). Mirrors Android's `substituteTrackId` / `configContainsIdToken`.