react-native-audio-browser 0.1.1 → 0.2.0-next.2

package/ios/Tests/SleepTimerManagerTests.swift

@@ -0,0 +1,107 @@
+@testable import AudioBrowserTestable
+import Foundation
+import Testing
+
+// Timing tests drive a ManualSleepTimerScheduler rather than the main queue:
+// every deadline below is virtual, so nothing races the real clock.
+
+@Suite("SleepTimerManager - fade scheduling")
+struct SleepTimerManagerTests {
+  @Test @MainActor
+  func fadeFiresBeforeDeadline_completionDoesNotEmitFadeCancel() {
+    let clock = ManualSleepTimerScheduler()
+    let manager = SleepTimerManager(scheduler: clock)
+    var fadeStarts: [TimeInterval] = []
+    var completes = 0
+    var cancels = 0
+    manager.onFadeStart = { fadeStarts.append($0) }
+    manager.onComplete = { completes += 1 }
+    manager.set(seconds: 0.3, fadeDuration: 0.15)
+    // Attach after set() — replacing a timer emits a defensive onFadeCancel.
+    manager.onFadeCancel = { cancels += 1 }
+
+    clock.advance(to: 0.05) // before the fade window
+    #expect(fadeStarts.isEmpty)
+    #expect(manager.get() != nil)
+
+    clock.advance(to: 0.22) // inside the fade window
+    #expect(fadeStarts == [0.15])
+    #expect(completes == 0)
+
+    clock.advance(to: 0.4) // past the deadline
+    #expect(completes == 1)
+    #expect(cancels == 0)
+    #expect(manager.get() == nil)
+  }
+
+  @Test @MainActor
+  func fadeLongerThanTimer_clampsAndStartsImmediately() {
+    let clock = ManualSleepTimerScheduler()
+    let manager = SleepTimerManager(scheduler: clock)
+    var fadeStarts: [TimeInterval] = []
+    manager.onFadeStart = { fadeStarts.append($0) }
+
+    manager.set(seconds: 0.2, fadeDuration: 5)
+
+    clock.advance(to: 0.1) // fade should have begun
+    #expect(fadeStarts == [0.2])
+  }
+
+  @Test @MainActor
+  func clear_emitsFadeCancel_andCancelsScheduledFade() {
+    let clock = ManualSleepTimerScheduler()
+    let manager = SleepTimerManager(scheduler: clock)
+    var fadeStarts = 0
+    manager.set(seconds: 0.2, fadeDuration: 0.15)
+    var cancels = 0
+    manager.onFadeStart = { _ in fadeStarts += 1 }
+    manager.onFadeCancel = { cancels += 1 }
+
+    #expect(manager.clear())
+    #expect(cancels == 1)
+
+    clock.advance(to: 0.3) // well past the would-be deadline
+    #expect(fadeStarts == 0)
+  }
+
+  @Test @MainActor
+  func replacingTimer_emitsFadeCancel() {
+    let manager = SleepTimerManager(scheduler: ManualSleepTimerScheduler())
+    manager.set(seconds: 60, fadeDuration: 10)
+    var cancels = 0
+    manager.onFadeCancel = { cancels += 1 }
+
+    manager.set(seconds: 30)
+
+    #expect(cancels == 1)
+  }
+
+  @Test @MainActor
+  func switchingToEndOfTrack_emitsFadeCancel() {
+    let manager = SleepTimerManager(scheduler: ManualSleepTimerScheduler())
+    manager.set(seconds: 60, fadeDuration: 10)
+    var cancels = 0
+    manager.onFadeCancel = { cancels += 1 }
+
+    manager.setToEndOfTrack()
+
+    #expect(cancels == 1)
+    #expect(manager.get() == .third(SleepTimerEndOfTrack(sleepWhenPlayedToEnd: true)))
+  }
+
+  @Test @MainActor
+  func noFadeDuration_schedulesNoFade() {
+    let clock = ManualSleepTimerScheduler()
+    let manager = SleepTimerManager(scheduler: clock)
+    var fadeStarts = 0
+    var completes = 0
+    manager.onFadeStart = { _ in fadeStarts += 1 }
+    manager.onComplete = { completes += 1 }
+
+    manager.set(seconds: 0.1)
+
+    clock.advance(to: 0.2)
+    #expect(fadeStarts == 0)
+    #expect(completes == 1)
+  }
+}

package/ios/Tests/Support/ManualSleepTimerScheduler.swift

@@ -0,0 +1,47 @@
+@testable import AudioBrowserTestable
+import Foundation
+
+/// A job handed back by `ManualSleepTimerScheduler`.
+private final class ManualJob: SleepTimerJob {
+  nonisolated(unsafe) var isCancelled = false
+  func cancel() { isCancelled = true }
+}
+
+/// Deterministic stand-in for the main-queue scheduler: jobs fire only when the
+/// test advances the clock, so an assertion can never lose a race against a
+/// real deadline on a loaded CI runner.
+@MainActor
+final class ManualSleepTimerScheduler: SleepTimerScheduling {
+  private struct Entry {
+    let deadline: TimeInterval
+    let job: ManualJob
+    let work: @MainActor () -> Void
+  }
+
+  private var entries: [Entry] = []
+  private(set) var now: TimeInterval = 0
+
+  func schedule(
+    after delay: TimeInterval,
+    _ work: @escaping @Sendable @MainActor () -> Void,
+  ) -> any SleepTimerJob {
+    let job = ManualJob()
+    entries.append(Entry(deadline: now + delay, job: job, work: work))
+    return job
+  }
+
+  /// Moves the virtual clock to `time`, firing every due job in deadline order.
+  /// Jobs run one at a time so a job that schedules or cancels another (the
+  /// fade landing before completion) sees the same ordering it would in
+  /// production.
+  func advance(to time: TimeInterval) {
+    now = time
+    while let next = entries
+      .filter({ !$0.job.isCancelled && $0.deadline <= now })
+      .min(by: { $0.deadline < $1.deadline })
+    {
+      entries.removeAll { $0.job === next.job }
+      next.work()
+    }
+  }
+}

package/ios/Tests/Support/TestTypes.swift

@@ -1,8 +1,8 @@
 // This file is intentionally empty — mock types live in
 // Model/NitroTypeStubs.swift (part of the AudioBrowserTestable target).
 
-import AVFoundation
 @testable import AudioBrowserTestable
+import AVFoundation
 
 /// Creates an AVMetadataItem with the specified properties for testing.
 func makeMetadataItem(
@@ -10,7 +10,7 @@ func makeMetadataItem(
   commonKey: AVMetadataKey? = nil,
   keySpace: AVMetadataKeySpace? = nil,
   key: String? = nil,
-  value: String
+  value: String,
 ) -> AVMetadataItem {
   let item = AVMutableMetadataItem()
   if let identifier {
@@ -41,6 +41,9 @@ final class MockPlaybackEffectHandler: PlaybackEffectHandler {
   func pausePlayback() { pausePlaybackCallCount += 1 }
   func setTimePitchingAlgorithmForCurrentItem() { setTimePitchCallCount += 1 }
 
+  // Player volume
+  var volume: Float = 1
+
   // AVPlayer state queries
   var currentTime: Double = 0
   var duration: Double = 0
@@ -56,11 +59,16 @@ final class MockPlaybackEffectHandler: PlaybackEffectHandler {
 
   // Track loading
   var loadTrackCalls: [String] = []
+  var loadTrackTracks: [Track] = []
   var reloadTrackCalls: [Bool] = []
   var unloadTrackCallCount = 0
   var cancelMediaLoadingCallCount = 0
 
-  func loadTrack(src: String) { loadTrackCalls.append(src) }
+  func loadTrack(src: String, track: Track) {
+    loadTrackCalls.append(src)
+    loadTrackTracks.append(track)
+  }
+
   func reloadTrack(startFromCurrentTime: Bool) { reloadTrackCalls.append(startFromCurrentTime) }
   func unloadTrack() { unloadTrackCallCount += 1 }
   func cancelMediaLoading() { cancelMediaLoadingCallCount += 1 }
@@ -73,27 +81,18 @@ final class MockPlaybackEffectHandler: PlaybackEffectHandler {
   func replayCurrentTrack() { replayCurrentTrackCallCount += 1 }
 
   // Now Playing
-  var updateNowPlayingValuesCalls: [(duration: Double, rate: Float, currentTime: Double)] = []
-  var updateNowPlayingStateCalls: [Bool] = []
-  var loadNowPlayingMetadataCalls: [(track: Track, rate: Float)] = []
-  var resetNowPlayingValuesCallCount = 0
+  var loadNowPlayingMetadataCalls: [Track] = []
   var clearNowPlayingCallCount = 0
-  var setNowPlayingCurrentTimeCalls: [Double] = []
+  var updateNowPlayingStateCalls: [Bool] = []
 
-  func updateNowPlayingValues(duration: Double, rate: Float, currentTime: Double) {
-    updateNowPlayingValuesCalls.append((duration, rate, currentTime))
+  func loadNowPlayingMetadata(for track: Track) {
+    loadNowPlayingMetadataCalls.append(track)
   }
+
+  func clearNowPlaying() { clearNowPlayingCallCount += 1 }
   func updateNowPlayingState(playWhenReady: Bool) {
     updateNowPlayingStateCalls.append(playWhenReady)
   }
-  func loadNowPlayingMetadata(for track: Track, rate: Float) {
-    loadNowPlayingMetadataCalls.append((track, rate))
-  }
-  func resetNowPlayingValues() { resetNowPlayingValuesCallCount += 1 }
-  func clearNowPlaying() { clearNowPlayingCallCount += 1 }
-  func setNowPlayingCurrentTime(seconds: Double) {
-    setNowPlayingCurrentTimeCalls.append(seconds)
-  }
 
   // Remote commands
   var updateRemoteRepeatModeCalls: [RepeatMode] = []
@@ -102,9 +101,15 @@ final class MockPlaybackEffectHandler: PlaybackEffectHandler {
   func updateRemoteRepeatMode(_ mode: RepeatMode) {
     updateRemoteRepeatModeCalls.append(mode)
   }
+
   func updateRemoteShuffleMode(_ enabled: Bool) {
     updateRemoteShuffleModeCalls.append(enabled)
   }
+
+  var updateSkipAvailabilityCalls: [(canNext: Bool, canPrevious: Bool)] = []
+  func updateSkipAvailability(canNext: Bool, canPrevious: Bool) {
+    updateSkipAvailabilityCalls.append((canNext, canPrevious))
+  }
 }
 
 // MARK: - Mock PlaybackCoordinatorCallbacks
@@ -121,37 +126,56 @@ final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
   var repeatModeChanges: [RepeatModeChangedEvent] = []
   var shuffleEnabledChanges: [Bool] = []
   var errorEvents: [PlaybackErrorEvent] = []
+  var playbackIntervalFiredCount = 0
+  var releaseSessionCount = 0
 
   func playerDidChangePlayback(_ playback: Playback) {
     playbackChanges.append(playback)
   }
+
   func playerDidChangeActiveTrack(_ event: PlaybackActiveTrackChangedEvent) {
     activeTrackChanges.append(event)
   }
+
   func playerDidUpdateProgress(_ event: PlaybackProgressUpdatedEvent) {
     progressUpdates.append(event)
   }
+
+  func playerDidFirePlaybackInterval() {
+    playbackIntervalFiredCount += 1
+  }
+
   func playerDidChangePlayWhenReady(_ playWhenReady: Bool) {
     playWhenReadyChanges.append(playWhenReady)
   }
+
   func playerDidChangePlayingState(_ state: PlayingState) {
     playingStateChanges.append(state)
   }
+
   func playerDidEndQueue(_ event: PlaybackQueueEndedEvent) {
     queueEndedEvents.append(event)
   }
+
   func playerDidChangeQueue(_ tracks: [Track]) {
     queueChanges.append(tracks)
   }
+
   func playerDidChangeRepeatMode(_ event: RepeatModeChangedEvent) {
     repeatModeChanges.append(event)
   }
+
   func playerDidChangeShuffleEnabled(_ enabled: Bool) {
     shuffleEnabledChanges.append(enabled)
   }
+
   func playerDidError(_ event: PlaybackErrorEvent) {
     errorEvents.append(event)
   }
+
+  func playerShouldReleaseSession() {
+    releaseSessionCount += 1
+  }
 }
 
 // MARK: - Mock SleepTimerHandling
@@ -159,8 +183,16 @@ final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
 @MainActor
 final class MockSleepTimerHandling: SleepTimerHandling {
   var onComplete: (() -> Void)?
+  var onFadeStart: ((_ duration: TimeInterval) -> Void)?
+  var onFadeCancel: (() -> 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 }
@@ -170,11 +202,20 @@ final class MockSleepTimerHandling: SleepTimerHandling {
 
 @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: Error?) -> Bool { isRetryableResult }
-  func attemptRetry(startFromCurrentTime: Bool) async -> Bool { attemptRetryResult }
+  func isRetryable(_: Error?) -> Bool { isRetryableResult }
+  func attemptRetry(startFromCurrentTime _: Bool) async -> Bool {
+    if attemptRetryDelayNs > 0 {
+      try? await Task.sleep(nanoseconds: attemptRetryDelayNs)
+    }
+    return attemptRetryResult
+  }
+
   func reset() { resetCallCount += 1 }
 }

package/ios/Tests/TabBarEntriesTests.swift

@@ -0,0 +1,71 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+struct TabBarEntriesTests {
+  private func tab(
+    _ title: String, url: String, artwork: String? = nil,
+    artworkSource: ImageSource? = nil, artist: String? = nil
+  ) -> Track {
+    Track(
+      id: url, url: url, title: title, artist: artist, artwork: artwork.map { .first($0) },
+      artworkSource: artworkSource
+    )
+  }
+
+  @Test func identicalListsAreSame() {
+    let tabs = [tab("Explore", url: "/explore"), tab("Browse", url: "/browse")]
+    #expect(TabBarEntries.same(tabs, tabs))
+  }
+
+  @Test func titleChangeDiffers() {
+    #expect(
+      !TabBarEntries.same(
+        [tab("Explore", url: "/explore")],
+        [tab("Verkennen", url: "/explore")]
+      ))
+  }
+
+  @Test func urlChangeDiffers() {
+    #expect(
+      !TabBarEntries.same(
+        [tab("Explore", url: "/explore")],
+        [tab("Explore", url: "/discover")]
+      ))
+  }
+
+  @Test func artworkChangeDiffers() {
+    #expect(
+      !TabBarEntries.same(
+        [tab("Explore", url: "/explore", artwork: "sf:globe")],
+        [tab("Explore", url: "/explore", artwork: "sf:map")]
+      ))
+  }
+
+  @Test func artworkSourceUriChangeDiffers() {
+    #expect(
+      !TabBarEntries.same(
+        [tab("Explore", url: "/explore", artworkSource: ImageSource(uri: "https://a/1.png"))],
+        [tab("Explore", url: "/explore", artworkSource: ImageSource(uri: "https://a/2.png"))]
+      ))
+  }
+
+  @Test func countChangeDiffers() {
+    let tabs = [tab("Explore", url: "/explore")]
+    #expect(!TabBarEntries.same(tabs, tabs + [tab("Browse", url: "/browse")]))
+  }
+
+  @Test func nilOldDiffers() {
+    #expect(!TabBarEntries.same(nil, [tab("Explore", url: "/explore")]))
+  }
+
+  @Test func nonRenderedFieldChangeIsSame() {
+    // Only fields the tab bar renders are compared; other track fields may
+    // drift without churning the tab bar.
+    #expect(
+      TabBarEntries.same(
+        [tab("Explore", url: "/explore", artist: "a")],
+        [tab("Explore", url: "/explore", artist: "b")]
+      ))
+  }
+}

package/ios/Tests/TrackSelectorTests.swift

@@ -7,8 +7,8 @@ import Testing
 @MainActor
 private final class BrowserMock: TrackSelectionBrowser {
   var trackLoadHandlerResult = false
-  var expandQueueResult: (tracks: [Track], selectedIndex: Int)? = nil
-  var expandQueueError: Error? = nil
+  var expandQueueResult: (tracks: [Track], selectedIndex: Int)?
+  var expandQueueError: Error?
 
   // Record calls for verification
   var trackLoadEvents: [TrackLoadEvent] = []
@@ -31,7 +31,7 @@ private final class BrowserMock: TrackSelectionBrowser {
 @MainActor
 private final class PlayerMock: TrackSelectionPlayer {
   var tracks: [Track] = []
-  var queueSourcePath: String? = nil
+  var queueSourcePath: String?
 }
 
 private enum MockError: Error {
@@ -57,7 +57,7 @@ struct BrowsableTrackTests {
     let (selector, _, player) = makeSelector()
     let track = Track(id: "t1", url: "/some/path")
     let result = await selector.select(track: track, player: player)
-    guard case .browse(let url) = result else {
+    guard case let .browse(url) = result else {
       Issue.record("expected .browse, got \(result)")
       return
     }
@@ -90,11 +90,11 @@ struct PlayableTrackTests {
     let (selector, browser, player) = makeSelector()
     let track = Track(id: "t1", src: "https://example.com/audio.mp3")
     let result = await selector.select(track: track, player: player)
-    guard case .play(let intent) = result else {
+    guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case .loadTrack(let loaded) = intent else {
+    guard case let .loadTrack(loaded) = intent else {
       Issue.record("expected .loadTrack, got \(intent)")
       return
     }
@@ -135,11 +135,11 @@ struct ContextualUrlQueueReuseTests {
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
     let result = await selector.select(track: track, player: player)
-    guard case .play(let intent) = result else {
+    guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case .skipTo(let index) = intent else {
+    guard case let .skipTo(index) = intent else {
       Issue.record("expected .skipTo, got \(intent)")
       return
     }
@@ -189,11 +189,11 @@ struct ContextualUrlExpansionTests {
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
     let result = await selector.select(track: track, player: player)
-    guard case .play(let intent) = result else {
+    guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case .setQueue(let tracks, let startIndex, let sourcePath) = intent else {
+    guard case let .setQueue(tracks, startIndex, sourcePath) = intent else {
       Issue.record("expected .setQueue, got \(intent)")
       return
     }
@@ -213,7 +213,7 @@ struct ContextualUrlExpansionTests {
 
     browser.expandQueueResult = (
       tracks: [Track(id: "a", src: "song.mp3")],
-      selectedIndex: 0
+      selectedIndex: 0,
     )
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
@@ -234,11 +234,11 @@ struct ContextualUrlExpansionTests {
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
     let result = await selector.select(track: track, player: player)
-    guard case .play(let intent) = result else {
+    guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case .loadTrack(let loaded) = intent else {
+    guard case let .loadTrack(loaded) = intent else {
       Issue.record("expected .loadTrack, got \(intent)")
       return
     }
@@ -255,11 +255,11 @@ struct ContextualUrlExpansionTests {
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
     let result = await selector.select(track: track, player: player)
-    guard case .play(let intent) = result else {
+    guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case .loadTrack(let loaded) = intent else {
+    guard case let .loadTrack(loaded) = intent else {
       Issue.record("expected .loadTrack, got \(intent)")
       return
     }