react-native-audio-browser 0.0.1 → 0.1.0-next.1

package/ios/Tests/PlaybackCoordinatorTests.swift

@@ -0,0 +1,486 @@
+import Testing
+@testable import AudioBrowserTestable
+
+/// Helper to build a coordinator with mocks for testing.
+@MainActor
+private func makeCoordinator() -> (
+  coordinator: PlaybackCoordinator,
+  effectHandler: MockPlaybackEffectHandler,
+  callbacks: MockPlaybackCoordinatorCallbacks,
+  sleepTimer: MockSleepTimerHandling
+) {
+  let retryHandler = MockRetryHandling()
+  let errorHandler = PlaybackErrorHandler(retryHandler: retryHandler)
+  let sleepTimer = MockSleepTimerHandling()
+  let coordinator = PlaybackCoordinator(errorHandler: errorHandler, sleepTimerManager: sleepTimer)
+  let effectHandler = MockPlaybackEffectHandler()
+  let callbacks = MockPlaybackCoordinatorCallbacks()
+  coordinator.effectHandler = effectHandler
+  coordinator.callbacks = callbacks
+  return (coordinator, effectHandler, callbacks, sleepTimer)
+}
+
+/// Helper to load a track into the coordinator's queue so it has a currentTrack.
+@MainActor
+private func loadTrack(
+  _ coordinator: PlaybackCoordinator,
+  id: String = "t1",
+  src: String? = "https://example.com/audio.mp3",
+  title: String = "Test Track"
+) {
+  let track = Track(id: id, src: src, title: title)
+  coordinator.setQueue([track])
+}
+
+// MARK: - Transition + Side Effects
+
+@Suite("PlaybackCoordinator - transition + side effects")
+struct TransitionTests {
+  @Test @MainActor
+  func toReady_startsPlayback_whenPlayWhenReady() {
+    let (c, eh, _, _) = makeCoordinator()
+    loadTrack(c)
+    c.playWhenReady = true
+    eh.startPlaybackCallCount = 0  // reset from playWhenReady setter
+
+    c.transition(.bufferingSufficient)
+
+    #expect(c.state == .ready)
+    #expect(eh.startPlaybackCallCount == 1)
+  }
+
+  @Test @MainActor
+  func toReady_doesNotStart_whenNotPlayWhenReady() {
+    let (c, eh, _, _) = makeCoordinator()
+    loadTrack(c)
+    c.transition(.bufferingSufficient)
+
+    #expect(c.state == .ready)
+    #expect(eh.startPlaybackCallCount == 0)
+  }
+
+  @Test @MainActor
+  func toLoading_setsTimePitchAlgorithm() {
+    let (c, eh, _, _) = makeCoordinator()
+
+    c.transition(.trackLoading)
+
+    #expect(c.state == .loading)
+    #expect(eh.setTimePitchCallCount == 1)
+  }
+
+  @Test @MainActor
+  func toError_setsPlaybackError() {
+    let (c, _, _, _) = makeCoordinator()
+
+    c.transition(.errorOccurred(.playbackFailed))
+
+    #expect(c.state == .error)
+    #expect(c.playbackError == .playbackFailed)
+  }
+
+  @Test @MainActor
+  func leavingError_clearsPlaybackError() {
+    let (c, _, _, _) = makeCoordinator()
+    c.transition(.errorOccurred(.playbackFailed))
+    #expect(c.playbackError == .playbackFailed)
+
+    c.transition(.trackLoading)
+
+    #expect(c.state == .loading)
+    #expect(c.playbackError == nil)
+  }
+
+  @Test @MainActor
+  func errorToError_updatesAndEmits() {
+    let (c, _, cb, _) = makeCoordinator()
+    c.transition(.errorOccurred(.playbackFailed))
+    cb.playbackChanges.removeAll()
+    cb.errorEvents.removeAll()
+
+    c.transition(.errorOccurred(.notConnectedToInternet))
+
+    // State stays .error but error is updated
+    #expect(c.state == .error)
+    #expect(c.playbackError == .notConnectedToInternet)
+    #expect(cb.playbackChanges.count == 1)
+    #expect(cb.errorEvents.count == 1)
+  }
+
+  @Test @MainActor
+  func activeStates_updateNowPlayingValues() {
+    let (c, eh, _, _) = makeCoordinator()
+    eh.hasLoadedAsset = true
+    eh.duration = 120
+    eh.currentTime = 30
+
+    c.transition(.trackLoading)
+    #expect(eh.updateNowPlayingValuesCalls.count == 1)
+
+    c.transition(.bufferingSufficient)
+    #expect(eh.updateNowPlayingValuesCalls.count == 2)
+  }
+}
+
+// MARK: - emitStateChange
+
+@Suite("PlaybackCoordinator - emitStateChange")
+struct EmitStateChangeTests {
+  @Test @MainActor
+  func alwaysEmits_playerDidChangePlayback() {
+    let (c, _, cb, _) = makeCoordinator()
+
+    c.transition(.trackLoading)
+
+    #expect(cb.playbackChanges.count == 1)
+    #expect(cb.playbackChanges.first?.state == .loading)
+  }
+
+  @Test @MainActor
+  func emitsErrorCallback_onEnterError() {
+    let (c, _, cb, _) = makeCoordinator()
+
+    c.transition(.errorOccurred(.playbackFailed))
+
+    #expect(cb.errorEvents.count == 1)
+  }
+
+  @Test @MainActor
+  func emitsErrorCallback_onLeaveError() {
+    let (c, _, cb, _) = makeCoordinator()
+    c.transition(.errorOccurred(.playbackFailed))
+    cb.errorEvents.removeAll()
+
+    c.transition(.trackLoading)
+
+    #expect(cb.errorEvents.count == 1)
+    #expect(cb.errorEvents.first?.error == nil) // error cleared
+  }
+
+  @Test @MainActor
+  func emitsQueueEnded_onEndedAndLastTrack() {
+    let (c, eh, cb, _) = makeCoordinator()
+    loadTrack(c)
+    eh.currentTime = 42
+    cb.queueEndedEvents.removeAll()
+
+    c.transition(.trackEndedNaturally)
+
+    #expect(cb.queueEndedEvents.count == 1)
+    #expect(cb.queueEndedEvents.first?.position == 42)
+    #expect(cb.queueEndedEvents.first?.track == 0)
+  }
+}
+
+// MARK: - Observer Guards
+
+@Suite("PlaybackCoordinator - observer guards")
+struct ObserverGuardTests {
+  @Test @MainActor
+  func timeControlStatus_paused_nearTrackEnd_ignored() {
+    let (c, eh, cb, _) = makeCoordinator()
+    c.transition(.avPlayerPlaying)
+    cb.playbackChanges.removeAll()
+    eh.hasLoadedAsset = true
+    eh.currentTime = 99.8
+    eh.duration = 100
+
+    c.avPlayerDidChangeTimeControlStatus(.paused)
+
+    // State should remain .playing — the pause near track end is ignored
+    #expect(c.state == .playing)
+  }
+
+  @Test @MainActor
+  func timeControlStatus_paused_noAsset_transitionsToNone() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.avPlayerPlaying)
+    eh.hasLoadedAsset = false
+    eh.currentTime = 0
+    eh.duration = 0
+
+    c.avPlayerDidChangeTimeControlStatus(.paused)
+
+    #expect(c.state == .none)
+  }
+
+  @Test @MainActor
+  func timeControlStatus_paused_withAsset_notPlayWhenReady_transitionsToPaused() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.avPlayerPlaying)
+    eh.hasLoadedAsset = true
+    eh.currentTime = 10
+    eh.duration = 100
+    c.playWhenReady = false
+
+    c.avPlayerDidChangeTimeControlStatus(.paused)
+
+    #expect(c.state == .paused)
+  }
+
+  @Test @MainActor
+  func timeControlStatus_paused_withAsset_playWhenReady_ignored() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.avPlayerPlaying)
+    eh.hasLoadedAsset = true
+    eh.currentTime = 10
+    eh.duration = 100
+    c.playWhenReady = true
+
+    c.avPlayerDidChangeTimeControlStatus(.paused)
+
+    // playWhenReady is true — pause is ignored (likely buffering/seeking)
+    #expect(c.state == .playing)
+  }
+
+  @Test @MainActor
+  func timeControlStatus_ignored_duringLoading() {
+    let (c, _, cb, _) = makeCoordinator()
+    c.transition(.trackLoading)
+    cb.playbackChanges.removeAll()
+
+    c.avPlayerDidChangeTimeControlStatus(.paused)
+
+    #expect(c.state == .loading)
+    #expect(cb.playbackChanges.isEmpty)
+  }
+
+  @Test @MainActor
+  func waiting_noAsset_ignored() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.avPlayerPlaying)
+    eh.hasLoadedAsset = false
+
+    c.avPlayerDidChangeTimeControlStatus(.waitingToPlayAtSpecifiedRate)
+
+    #expect(c.state == .playing)  // unchanged
+  }
+
+  @Test @MainActor
+  func waiting_withAsset_transitionsToBuffering() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.avPlayerPlaying)
+    eh.hasLoadedAsset = true
+
+    c.avPlayerDidChangeTimeControlStatus(.waitingToPlayAtSpecifiedRate)
+
+    #expect(c.state == .buffering)
+  }
+
+  @Test @MainActor
+  func playbackLikelyToKeepUp_false_ignored() {
+    let (c, _, cb, _) = makeCoordinator()
+    c.transition(.trackLoading)
+    cb.playbackChanges.removeAll()
+
+    c.avItemDidUpdatePlaybackLikelyToKeepUp(false)
+
+    #expect(c.state == .loading)
+    #expect(cb.playbackChanges.isEmpty)
+  }
+
+  @Test @MainActor
+  func playbackLikelyToKeepUp_true_transitionsToReady() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.trackLoading)
+    eh.hasLoadedAsset = true
+
+    c.avItemDidUpdatePlaybackLikelyToKeepUp(true)
+
+    #expect(c.state == .ready)
+  }
+
+  @Test @MainActor
+  func audioDidStart_ignored_duringLoading() {
+    let (c, _, _, _) = makeCoordinator()
+    c.transition(.trackLoading)
+
+    c.audioDidStart()
+
+    #expect(c.state == .loading)
+  }
+
+  @Test @MainActor
+  func audioDidStart_transitionsToPlaying() {
+    let (c, _, _, _) = makeCoordinator()
+    c.transition(.bufferingSufficient)
+
+    c.audioDidStart()
+
+    #expect(c.state == .playing)
+  }
+}
+
+// MARK: - playWhenReady
+
+@Suite("PlaybackCoordinator - playWhenReady")
+struct PlayWhenReadyTests {
+  @Test @MainActor
+  func true_fromError_triggersReload() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.errorOccurred(.playbackFailed))
+
+    c.playWhenReady = true
+
+    #expect(eh.reloadTrackCalls.count == 1)
+    #expect(eh.reloadTrackCalls.first == true) // startFromCurrentTime for error
+  }
+
+  @Test @MainActor
+  func true_fromStopped_triggersReload() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.stopped)
+
+    c.playWhenReady = true
+
+    #expect(eh.reloadTrackCalls.count == 1)
+    #expect(eh.reloadTrackCalls.first == false) // startFromCurrentTime for stopped
+  }
+
+  @Test @MainActor
+  func true_notLoading_startsPlayback() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.bufferingSufficient) // .ready state
+
+    c.playWhenReady = true
+
+    #expect(eh.startPlaybackCallCount >= 1)
+  }
+
+  @Test @MainActor
+  func false_notLoading_pausesPlayback() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.avPlayerPlaying)
+    c.playWhenReady = true
+    eh.pausePlaybackCallCount = 0
+
+    c.playWhenReady = false
+
+    #expect(eh.pausePlaybackCallCount == 1)
+  }
+
+  @Test @MainActor
+  func noOp_duringLoading() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.transition(.trackLoading)
+    eh.startPlaybackCallCount = 0
+    eh.pausePlaybackCallCount = 0
+
+    c.playWhenReady = true
+
+    // During loading, should NOT call start/pause
+    #expect(eh.startPlaybackCallCount == 0)
+    #expect(eh.pausePlaybackCallCount == 0)
+  }
+
+  @Test @MainActor
+  func emitsCallback_onChange() {
+    let (c, _, cb, _) = makeCoordinator()
+
+    c.playWhenReady = true
+
+    #expect(cb.playWhenReadyChanges.count == 1)
+    #expect(cb.playWhenReadyChanges.first == true)
+  }
+}
+
+// MARK: - handleCurrentTrackChanged
+
+@Suite("PlaybackCoordinator - handleCurrentTrackChanged")
+struct HandleCurrentTrackChangedTests {
+  @Test @MainActor
+  func clearsError_beforeTransition() {
+    let (c, eh, _, _) = makeCoordinator()
+    eh.hasLoadedAsset = true
+    c.transition(.errorOccurred(.playbackFailed))
+    #expect(c.playbackError != nil)
+
+    loadTrack(c)
+
+    // After loading a track, the error should be cleared
+    #expect(c.playbackError == nil)
+  }
+
+  @Test @MainActor
+  func preservesPlayWhenReady_acrossLoading() {
+    let (c, _, _, _) = makeCoordinator()
+    c.playWhenReady = true
+
+    loadTrack(c)
+
+    #expect(c.playWhenReady == true)
+    #expect(c.state == .loading)
+  }
+
+  @Test @MainActor
+  func nilSrc_transitionsToError() {
+    let (c, _, cb, _) = makeCoordinator()
+
+    let track = Track(id: "t1", src: nil, title: "No Source")
+    c.setQueue([track])
+
+    #expect(c.state == .error)
+    #expect(c.playbackError == .invalidSourceUrl("nil"))
+    #expect(cb.errorEvents.count >= 1)
+  }
+
+  @Test @MainActor
+  func emitsActiveTrackChangedEvent() {
+    let (c, _, cb, _) = makeCoordinator()
+
+    loadTrack(c)
+
+    #expect(cb.activeTrackChanges.count == 1)
+    let event = cb.activeTrackChanges.first!
+    #expect(event.lastIndex == nil) // first track, no previous
+    #expect(event.index == 0)
+    #expect(event.track?.id == "t1")
+  }
+}
+
+// MARK: - handleTrackDidPlayToEndTime
+
+@Suite("PlaybackCoordinator - handleTrackDidPlayToEndTime")
+struct HandleTrackDidPlayToEndTimeTests {
+  @Test @MainActor
+  func repeatTrack_replays() {
+    let (c, eh, _, _) = makeCoordinator()
+    loadTrack(c)
+    c.repeatMode = .track
+
+    c.handleTrackDidPlayToEndTime()
+
+    // replay delegates to effectHandler.replayCurrentTrack (seek to 0 + play)
+    #expect(eh.replayCurrentTrackCallCount == 1)
+  }
+
+  @Test @MainActor
+  func lastTrack_noRepeat_transitionsToEnded() {
+    let (c, eh, cb, _) = makeCoordinator()
+    _ = eh // retain weak effectHandler
+    loadTrack(c)
+    c.repeatMode = .off
+
+    c.handleTrackDidPlayToEndTime()
+
+    #expect(c.state == .ended)
+    #expect(cb.queueEndedEvents.count >= 1)
+  }
+
+  @Test @MainActor
+  func midQueue_advancesToNext() {
+    let (c, _, cb, _) = makeCoordinator()
+    let tracks = [
+      Track(id: "t1", src: "https://example.com/1.mp3", title: "Track 1"),
+      Track(id: "t2", src: "https://example.com/2.mp3", title: "Track 2"),
+    ]
+    c.setQueue(tracks)
+    cb.activeTrackChanges.removeAll()
+
+    c.handleTrackDidPlayToEndTime()
+
+    #expect(c.currentIndex == 1)
+    #expect(cb.activeTrackChanges.count == 1)
+    #expect(cb.activeTrackChanges.first?.track?.id == "t2")
+  }
+}

package/ios/Tests/PlaybackErrorHandlerTests.swift

@@ -0,0 +1,213 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+// MARK: - Mock RetryHandler
+
+@MainActor
+private final class MockRetryHandler: RetryHandling {
+  var retryableErrors: Set<Int> = []
+  var attemptRetryResult = false
+  var attemptRetryCallCount = 0
+  var lastStartFromCurrentTime: Bool?
+  var resetCallCount = 0
+
+  func isRetryable(_ error: Error?) -> Bool {
+    guard let error else { return false }
+    let code = (error as NSError).code
+    return retryableErrors.contains(code)
+  }
+
+  func attemptRetry(startFromCurrentTime: Bool) async -> Bool {
+    attemptRetryCallCount += 1
+    lastStartFromCurrentTime = startFromCurrentTime
+    return attemptRetryResult
+  }
+
+  func reset() {
+    resetCallCount += 1
+  }
+}
+
+// MARK: - Error Classification
+
+@Suite("PlaybackErrorHandler.classify")
+@MainActor
+struct ClassifyTests {
+  @Test func internetError_returnsNotConnectedToInternet() {
+    let error = URLError(.notConnectedToInternet)
+    let result = PlaybackErrorHandler.classify(error: error, fallback: .playbackFailed)
+    #expect(result == .notConnectedToInternet)
+  }
+
+  @Test func internetError_ignoresFallback() {
+    let error = URLError(.notConnectedToInternet)
+    let result = PlaybackErrorHandler.classify(error: error, fallback: .failedToLoadKeyValue)
+    #expect(result == .notConnectedToInternet)
+  }
+
+  @Test func otherError_returnsFallback_playbackFailed() {
+    let error = URLError(.timedOut)
+    let result = PlaybackErrorHandler.classify(error: error, fallback: .playbackFailed)
+    #expect(result == .playbackFailed)
+  }
+
+  @Test func otherError_returnsFallback_failedToLoadKeyValue() {
+    let error = URLError(.timedOut)
+    let result = PlaybackErrorHandler.classify(error: error, fallback: .failedToLoadKeyValue)
+    #expect(result == .failedToLoadKeyValue)
+  }
+
+  @Test func nilError_returnsFallback() {
+    let result = PlaybackErrorHandler.classify(error: nil, fallback: .playbackFailed)
+    #expect(result == .playbackFailed)
+  }
+}
+
+// MARK: - PlaybackErrorContext
+
+@Suite("PlaybackErrorContext")
+@MainActor
+struct ContextTests {
+  @Test func playbackContext_startFromCurrentTimeTrue() {
+    #expect(PlaybackErrorContext.playback.startFromCurrentTime == true)
+  }
+
+  @Test func playbackContext_fallbackIsPlaybackFailed() {
+    #expect(PlaybackErrorContext.playback.fallbackError == .playbackFailed)
+  }
+
+  @Test func mediaLoadContext_startFromCurrentTimeFalse() {
+    #expect(PlaybackErrorContext.mediaLoad.startFromCurrentTime == false)
+  }
+
+  @Test func mediaLoadContext_fallbackIsFailedToLoadKeyValue() {
+    #expect(PlaybackErrorContext.mediaLoad.fallbackError == .failedToLoadKeyValue)
+  }
+}
+
+// MARK: - handleError
+
+@Suite("handleError")
+@MainActor
+struct HandleErrorTests {
+  @Test func nonRetryableError_surfacesImmediately() {
+    let mock = MockRetryHandler()
+    let handler = PlaybackErrorHandler(retryHandler: mock)
+    var surfacedError: TrackPlayerError.PlaybackError?
+    handler.onError = { surfacedError = $0 }
+
+    let error = URLError(.badURL)
+    handler.handleError(error, context: .playback)
+
+    #expect(surfacedError == .playbackFailed)
+    #expect(mock.attemptRetryCallCount == 0)
+  }
+
+  @Test func nonRetryableInternetError_classifiesCorrectly() {
+    let mock = MockRetryHandler()
+    // Not in retryableErrors set, so isRetryable returns false
+    let handler = PlaybackErrorHandler(retryHandler: mock)
+    var surfacedError: TrackPlayerError.PlaybackError?
+    handler.onError = { surfacedError = $0 }
+
+    let error = URLError(.notConnectedToInternet)
+    handler.handleError(error, context: .mediaLoad)
+
+    // Even though not retryable, classify should detect the internet error
+    #expect(surfacedError == .notConnectedToInternet)
+  }
+
+  @Test func retryableError_triggersRetry() async {
+    let mock = MockRetryHandler()
+    mock.retryableErrors = [URLError.Code.timedOut.rawValue]
+    mock.attemptRetryResult = true
+    let handler = PlaybackErrorHandler(retryHandler: mock)
+    var surfacedError: TrackPlayerError.PlaybackError?
+    handler.onError = { surfacedError = $0 }
+
+    let error = URLError(.timedOut)
+    handler.handleError(error, context: .playback)
+
+    // Wait for the retry task to complete
+    await handler.pendingRetryTask?.value
+
+    #expect(mock.attemptRetryCallCount == 1)
+    #expect(mock.lastStartFromCurrentTime == true)
+    // Retry succeeded, no error surfaced
+    #expect(surfacedError == nil)
+  }
+
+  @Test func retryExhausted_surfacesClassifiedError() async {
+    let mock = MockRetryHandler()
+    mock.retryableErrors = [URLError.Code.timedOut.rawValue]
+    mock.attemptRetryResult = false
+    let handler = PlaybackErrorHandler(retryHandler: mock)
+    var surfacedError: TrackPlayerError.PlaybackError?
+    handler.onError = { surfacedError = $0 }
+
+    let error = URLError(.timedOut)
+    handler.handleError(error, context: .mediaLoad)
+
+    await handler.pendingRetryTask?.value
+
+    #expect(mock.attemptRetryCallCount == 1)
+    #expect(mock.lastStartFromCurrentTime == false)
+    #expect(surfacedError == .failedToLoadKeyValue)
+  }
+
+  @Test func retryExhausted_internetError_classifiesCorrectly() async {
+    let mock = MockRetryHandler()
+    mock.retryableErrors = [URLError.Code.notConnectedToInternet.rawValue]
+    mock.attemptRetryResult = false
+    let handler = PlaybackErrorHandler(retryHandler: mock)
+    var surfacedError: TrackPlayerError.PlaybackError?
+    handler.onError = { surfacedError = $0 }
+
+    let error = URLError(.notConnectedToInternet)
+    handler.handleError(error, context: .mediaLoad)
+
+    await handler.pendingRetryTask?.value
+
+    // This is the bug fix: previously mediaLoad non-retryable path
+    // would always return .failedToLoadKeyValue
+    #expect(surfacedError == .notConnectedToInternet)
+  }
+}
+
+// MARK: - cancelPendingRetry
+
+@Suite("cancelPendingRetry")
+@MainActor
+struct CancelTests {
+  @Test func cancelClearsPendingTask() async {
+    let mock = MockRetryHandler()
+    mock.retryableErrors = [URLError.Code.timedOut.rawValue]
+    mock.attemptRetryResult = true
+    let handler = PlaybackErrorHandler(retryHandler: mock)
+
+    let error = URLError(.timedOut)
+    handler.handleError(error, context: .playback)
+
+    #expect(handler.pendingRetryTask != nil)
+    handler.cancelPendingRetry()
+    #expect(handler.pendingRetryTask == nil)
+  }
+}
+
+// MARK: - resetRetry
+
+@Suite("resetRetry")
+@MainActor
+struct ErrorHandlerResetTests {
+  @Test func resetCancelsAndResetsHandler() {
+    let mock = MockRetryHandler()
+    let handler = PlaybackErrorHandler(retryHandler: mock)
+
+    handler.resetRetry()
+
+    #expect(handler.pendingRetryTask == nil)
+    #expect(mock.resetCallCount == 1)
+  }
+}