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

package/ios/Tests/LRUCacheTests.swift

@@ -4,6 +4,7 @@ import Testing
 @testable import AudioBrowserTestable
 
 @Suite("LRUCache")
+@MainActor
 struct LRUCacheTests {
   /// A class so the tests can observe release through a weak reference.
   private final class Box {
@@ -49,9 +50,7 @@ struct LRUCacheTests {
     #expect(cache.count == 2)
   }
 
-  /// The nodes form a doubly-linked list. If both directions were strong, adjacent nodes would
-  /// retain each other and clearing would drop only the dictionary and the two ends — the chain,
-  /// and everything it holds, would survive (#96).
+  /// Clearing releases every value the cache held (#96).
   @Test func clearReleasesEveryNode() {
     let cache = LRUCache<String, Box>(maxSize: 10)
     weak var first: Box?
@@ -76,7 +75,7 @@ struct LRUCacheTests {
     #expect(cache.count == 0)
   }
 
-  /// Same cycle, reached by dropping the cache itself rather than clearing it.
+  /// So does dropping the cache itself.
   @Test func droppingTheCacheReleasesEveryNode() {
     weak var first: Box?
     weak var last: Box?
@@ -94,7 +93,7 @@ struct LRUCacheTests {
     #expect(last == nil)
   }
 
-  /// Eviction has always unlinked the node it drops; this pins that down alongside the rest.
+  /// And evicting an entry releases its value.
   @Test func evictionReleasesTheEvictedNode() {
     let cache = LRUCache<String, Box>(maxSize: 1)
     weak var evicted: Box?

package/ios/Tests/MediaLoaderTests.swift

@@ -6,49 +6,28 @@ import Testing
 // MARK: - Test Spy
 
 @MainActor
-private final class MediaLoaderDelegateSpy: MediaLoaderDelegate {
+private final class MediaLoaderSpy {
   var preparedItems: [AVPlayerItem] = []
   var unplayableCount = 0
   var retryableErrors: [Error] = []
   var playbackErrors: [TrackPlayerError.PlaybackError] = []
-  var commonMetadata: [[AVMetadataItem]] = []
-  var chapterMetadata: [[AVTimedMetadataGroup]] = []
-  var timedMetadata: [[AVTimedMetadataGroup]] = []
 
-  func mediaLoaderDidPrepareItem(_ item: AVPlayerItem) {
-    preparedItems.append(item)
-  }
-
-  func mediaLoaderDidFailWithUnplayableTrack() {
-    unplayableCount += 1
-  }
-
-  func mediaLoaderDidFailWithRetryableError(_ error: Error) {
-    retryableErrors.append(error)
-  }
-
-  func mediaLoaderDidFailWithError(_ error: TrackPlayerError.PlaybackError) {
-    playbackErrors.append(error)
-  }
-
-  func mediaLoaderDidReceiveCommonMetadata(_ items: [AVMetadataItem]) {
-    commonMetadata.append(items)
-  }
-
-  func mediaLoaderDidReceiveChapterMetadata(_ groups: [AVTimedMetadataGroup]) {
-    chapterMetadata.append(groups)
-  }
-
-  func mediaLoaderDidReceiveTimedMetadata(_ groups: [AVTimedMetadataGroup]) {
-    timedMetadata.append(groups)
+  func record(_ event: MediaLoader.Event) {
+    switch event {
+    case let .prepared(item): preparedItems.append(item)
+    case .unplayable: unplayableCount += 1
+    case let .failed(error): retryableErrors.append(error)
+    case let .invalidSource(url): playbackErrors.append(.invalidSourceUrl(url))
+    case .commonMetadata, .chapterMetadata, .timedMetadata: break
+    }
   }
 }
 
 @MainActor
-private func makeLoader() -> (MediaLoader, MediaLoaderDelegateSpy) {
+private func makeLoader() -> (MediaLoader, MediaLoaderSpy) {
   let loader = MediaLoader()
-  let spy = MediaLoaderDelegateSpy()
-  loader.delegate = spy
+  let spy = MediaLoaderSpy()
+  loader.onEvent = { spy.record($0) }
   return (loader, spy)
 }
 

package/ios/Tests/ObserverTests.swift

@@ -0,0 +1,88 @@
+import AVFoundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@MainActor
+@Suite("PlayerObserver")
+struct PlayerObserverTests {
+  /// An AVPlayer retains its time observers, so one left registered outlives the observer (#96).
+  @Test func invalidatingRemovesTheBoundaryObserver() {
+    let observer = PlayerObserver(player: AVPlayer()) { _ in }
+    #expect(observer.boundaryObserverToken != nil)
+    observer.invalidate()
+    #expect(observer.boundaryObserverToken == nil)
+  }
+
+  @Test func reportsTheInitialStatus_andNothingOnceInvalidated() async {
+    var events: [PlayerObserver.Event] = []
+    let observer = PlayerObserver(player: AVPlayer()) { events.append($0) }
+    await drain()
+    #expect(events.contains { if case .status = $0 { true } else { false } })
+
+    events = []
+    let late = PlayerObserver(player: AVPlayer()) { events.append($0) }
+    late.invalidate()
+    await drain()
+    #expect(events.isEmpty)
+    _ = observer
+  }
+}
+
+@MainActor
+@Suite("ItemObserver")
+struct ItemObserverTests {
+  private func makeItem() -> AVPlayerItem {
+    AVPlayerItem(url: URL(fileURLWithPath: "/nonexistent.mp3"))
+  }
+
+  @Test func deliversTheItemsNotifications() async {
+    let item = makeItem()
+    var events: [ItemObserver.Event] = []
+    let observer = ItemObserver(item: item) { events.append($0) }
+    NotificationCenter.default.post(name: .AVPlayerItemPlaybackStalled, object: item)
+    NotificationCenter.default.post(name: .AVPlayerItemDidPlayToEndTime, object: item)
+    NotificationCenter.default.post(name: .AVPlayerItemPlaybackStalled, object: makeItem())
+    await drain()
+    #expect(events.map(label) == ["stalled", "playedToEnd"])
+    observer.invalidate()
+  }
+
+  /// A notification posted off the main thread hops to it; one landing after the switch to the
+  /// next item belongs to the old item and is dropped.
+  @Test func dropsADeliveryThatLandsAfterInvalidate() async {
+    let item = makeItem()
+    var events: [ItemObserver.Event] = []
+    let observer = ItemObserver(item: item) { events.append($0) }
+    NotificationCenter.default.post(name: .AVPlayerItemFailedToPlayToEndTime, object: item)
+    observer.invalidate()
+    await drain()
+    #expect(events.isEmpty)
+  }
+
+  @Test func invalidateRemovesTheMetadataOutput() {
+    let item = makeItem()
+    let observer = ItemObserver(item: item) { _ in }
+    #expect(item.outputs.contains { $0 is AVPlayerItemMetadataOutput })
+    observer.invalidate()
+    #expect(!item.outputs.contains { $0 is AVPlayerItemMetadataOutput })
+  }
+
+  private func label(_ event: ItemObserver.Event) -> String {
+    switch event {
+    case .likelyToKeepUp: "likelyToKeepUp"
+    case .failed: "failed"
+    case .playedToEnd: "playedToEnd"
+    case .failedToPlayToEnd: "failedToPlayToEnd"
+    case .stalled: "stalled"
+    case .timedMetadata: "timedMetadata"
+    }
+  }
+}
+
+@MainActor
+private func drain() async {
+  for _ in 0 ..< 20 {
+    await Task.yield()
+  }
+}

package/ios/Tests/PlaybackErrorTests.swift

@@ -0,0 +1,76 @@
+import AVFoundation
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("PlaybackError.kind")
+@MainActor
+struct PlaybackErrorKindTests {
+  @Test func httpStatus_mapsToKind() {
+    // Not parameterized: the generated Nitro enum is not Sendable, so it
+    // cannot cross a `@Test(arguments:)` isolation boundary.
+    let expectations: [(Int, PlaybackErrorKind)] = [
+      // Ordering: these must not be swallowed by the 400...499 arm.
+      (404, .notFound),
+      (410, .notFound),
+      // Range edges.
+      (400, .rejected),
+      (499, .rejected),
+      (500, .serverError),
+      (599, .serverError),
+      (302, .unknown),
+      (600, .unknown),
+    ]
+    for (status, expected) in expectations {
+      #expect(
+        TrackPlayerError.PlaybackError.httpStatus(status).kind == expected,
+        "HTTP \(status)",
+      )
+    }
+  }
+}
+
+@Suite("PlaybackError.toNitroError")
+@MainActor
+struct PlaybackErrorNitroCodeTests {
+  @Test func httpStatus_producesTheFullPayload() {
+    let payload = TrackPlayerError.PlaybackError.httpStatus(404).toNitroError()
+    #expect(payload.kind == .notFound)
+    #expect(payload.code == "http-status")
+    #expect(payload.message == "Server responded with HTTP 404")
+    #expect(payload.statusCode == 404)
+  }
+
+  @Test func nonHttpError_carriesNoStatusCode() {
+    #expect(TrackPlayerError.PlaybackError.playbackStalled.toNitroError().statusCode == nil)
+  }
+
+  /// `retrying` is nil — not false — on a terminal payload, so JS consumers
+  /// see the field only while it means something.
+  @Test func retryingFlag_isNilUnlessSet() {
+    #expect(TrackPlayerError.PlaybackError.hostUnreachable.toNitroError().retrying == nil)
+    #expect(
+      TrackPlayerError.PlaybackError.hostUnreachable.toNitroError(retrying: true).retrying == true,
+    )
+  }
+
+  /// `code` is an untyped wire contract: nothing on either side of the bridge
+  /// catches a typo, and telemetry groups issues by it. Worth an exhaustive
+  /// table even though `kind` is what the UI branches on.
+  @Test func codes_areStable() {
+    let expectations: [(TrackPlayerError.PlaybackError, String)] = [
+      (.failedToLoadKeyValue, "failed-to-load"),
+      (.invalidSourceUrl("nil"), "invalid-source-url"),
+      (.notConnectedToInternet, "not-connected-to-internet"),
+      (.hostUnreachable, "host-unreachable"),
+      (.httpStatus(500), "http-status"),
+      (.playbackFailed, "playback-failed"),
+      (.trackWasUnplayable, "track-unplayable"),
+      (.playbackStalled, "playback-stalled"),
+    ]
+    for (error, expected) in expectations {
+      #expect(error.toNitroError().code == expected, "\(error)")
+    }
+  }
+}

package/ios/Tests/PlaybackFailureTests.swift

@@ -0,0 +1,189 @@
+import AVFoundation
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+private func reported(
+  _ error: Error?, status: Int? = nil, fallback: TrackPlayerError.PlaybackError = .playbackFailed,
+) -> TrackPlayerError.PlaybackError {
+  PlaybackFailure.classify(error, httpStatusCode: status, fallback: fallback).error
+}
+
+private func retryable(_ error: Error?, status: Int? = nil) -> Bool {
+  PlaybackFailure.classify(error, httpStatusCode: status, fallback: .playbackFailed).retryable
+}
+
+private func avError(_ code: AVError.Code) -> NSError {
+  NSError(domain: AVFoundationErrorDomain, code: code.rawValue)
+}
+
+@Suite("PlaybackFailure: the reported error")
+struct PlaybackFailureReportedErrorTests {
+  @Test func noInternet() {
+    #expect(reported(URLError(.notConnectedToInternet)) == .notConnectedToInternet)
+  }
+
+  /// Both fallbacks pin that `fallback` is plumbed, not hardcoded.
+  @Test func anUnclassifiableErrorIsTheFallback() {
+    #expect(reported(URLError(.badURL)) == .playbackFailed)
+    #expect(reported(URLError(.badURL), fallback: .failedToLoadKeyValue) == .failedToLoadKeyValue)
+  }
+
+  /// A TLS failure counts as unreachable: no usable connection was made.
+  @Test(arguments: [URLError.Code.timedOut, .cannotFindHost, .secureConnectionFailed])
+  func aTransportErrorIsHostUnreachable(code: URLError.Code) {
+    #expect(reported(URLError(code)) == .hostUnreachable)
+  }
+
+  /// AVFoundation hands back plain NSErrors in NSURLErrorDomain rather than bridged URLErrors.
+  @Test func anUnbridgedURLDomainErrorIsClassified() {
+    #expect(reported(NSError(domain: NSURLErrorDomain, code: URLError.Code.cannotFindHost.rawValue)) == .hostUnreachable)
+  }
+
+  @Test func anHTTPStatusIsReported() {
+    #expect(reported(nil, status: 404, fallback: .failedToLoadKeyValue) == .httpStatus(404))
+  }
+
+  @Test func aSuccessStatusOrNothingIsTheFallback() {
+    #expect(reported(nil, status: 200, fallback: .failedToLoadKeyValue) == .failedToLoadKeyValue)
+    #expect(reported(nil) == .playbackFailed)
+  }
+
+  /// No response arrived, so a status left in the error log must not outrank the transport error.
+  @Test func aTransportErrorOutranksAStatus() {
+    #expect(reported(URLError(.notConnectedToInternet), status: 500) == .notConnectedToInternet)
+  }
+
+  @Test func anUnclassifiableURLErrorFallsThroughToTheStatus() {
+    #expect(reported(URLError(.badURL), status: 500) == .httpStatus(500))
+  }
+
+  /// The server's answer beats "the decoder choked", a symptom of being handed an error page.
+  @Test func aStatusOutranksUnplayableMedia() {
+    #expect(reported(avError(.fileFormatNotRecognized), status: 404) == .httpStatus(404))
+  }
+
+  @Test(arguments: [
+    AVError.Code.fileFormatNotRecognized, .failedToParse, .decoderNotFound, .decoderTemporarilyUnavailable,
+    .formatUnsupported, .contentIsUnavailable,
+  ])
+  func undecodableMediaIsUnplayable(code: AVError.Code) {
+    #expect(reported(avError(code)) == .trackWasUnplayable)
+  }
+
+  /// In-domain is not enough: `AVError.unknown` tells us nothing.
+  @Test func anUnrelatedAVErrorIsTheFallback() {
+    #expect(reported(avError(.unknown)) == .playbackFailed)
+  }
+}
+
+@Suite("PlaybackFailure: retrying")
+struct PlaybackFailureRetryTests {
+  /// The status, read off the error log, outranks the opaque error.
+  @Test(arguments: [408, 429, 500, 502, 503, 504])
+  func aRetryableStatusRetries(status: Int) {
+    #expect(retryable(NSError(domain: "CoreMediaErrorDomain", code: -12660), status: status))
+  }
+
+  /// A retry cannot conjure content that isn't there, whatever the error says.
+  @Test(arguments: [400, 401, 403, 404, 410, 451])
+  func aPermanentStatusDoesNotRetry(status: Int) {
+    #expect(!retryable(URLError(.timedOut), status: status))
+  }
+
+  @Test func aTransientURLErrorRetries() {
+    #expect(retryable(URLError(.networkConnectionLost)))
+  }
+
+  @Test func aFatalURLErrorDoesNotRetry() {
+    #expect(!retryable(URLError(.badURL)))
+  }
+
+  /// An opaque CoreMedia failure without a status used to be terminal, so a station that dropped
+  /// mid-song never came back on iOS while Android reconnected.
+  @Test func anOpaqueCoreMediaErrorRetries() {
+    #expect(retryable(NSError(domain: "CoreMediaErrorDomain", code: -12939)))
+  }
+
+  /// `AVError.unknown` wraps transport failures, so it stays retryable.
+  @Test func avErrorUnknownRetries() {
+    #expect(retryable(avError(.unknown)))
+  }
+
+  @Test(arguments: [
+    AVError.Code.fileFormatNotRecognized, .failedToParse, .decodeFailed, .decoderNotFound, .formatUnsupported,
+    .contentIsUnavailable, .contentIsProtected, .contentIsNotAuthorized,
+  ])
+  func unusableMediaDoesNotRetry(code: AVError.Code) {
+    #expect(!retryable(avError(code)))
+  }
+
+  /// A failure reported as unplayable is never also retried, except a decoder that is only
+  /// temporarily unavailable.
+  @Test(arguments: [
+    AVError.Code.fileFormatNotRecognized, .failedToParse, .decoderNotFound, .formatUnsupported,
+    .contentIsUnavailable,
+  ])
+  func whatIsReportedUnplayableIsNotRetried(code: AVError.Code) {
+    let classification = PlaybackFailure.classify(avError(code), httpStatusCode: nil, fallback: .playbackFailed)
+    #expect(classification == .init(error: .trackWasUnplayable, retryable: false))
+  }
+
+  @Test func aTemporarilyUnavailableDecoderIsRetried() {
+    #expect(retryable(avError(.decoderTemporarilyUnavailable)))
+  }
+
+  /// AVFoundation wraps the real cause, so the chain of underlying errors is walked.
+  @Test func anUnderlyingURLErrorDecides() {
+    let wrappingFatal = NSError(
+      domain: AVFoundationErrorDomain, code: AVError.unknown.rawValue,
+      userInfo: [NSUnderlyingErrorKey: URLError(.badURL)],
+    )
+    #expect(!retryable(wrappingFatal))
+    let wrappingTransient = NSError(
+      domain: AVFoundationErrorDomain, code: AVError.unknown.rawValue,
+      userInfo: [NSUnderlyingErrorKey: URLError(.dnsLookupFailed)],
+    )
+    #expect(retryable(wrappingTransient))
+  }
+
+  /// The report reads the same chain as the retry decision, so a wrapped cause that stops
+  /// retrying is also what is reported.
+  @Test func aWrappedCauseIsWhatIsReported() {
+    let wrappedUnplayable = NSError(
+      domain: AVFoundationErrorDomain, code: AVError.unknown.rawValue,
+      userInfo: [NSUnderlyingErrorKey: avError(.contentIsUnavailable)],
+    )
+    #expect(!retryable(wrappedUnplayable))
+    #expect(reported(wrappedUnplayable) == .trackWasUnplayable)
+    let wrappedOffline = NSError(
+      domain: AVFoundationErrorDomain, code: AVError.unknown.rawValue,
+      userInfo: [NSUnderlyingErrorKey: URLError(.notConnectedToInternet)],
+    )
+    #expect(reported(wrappedOffline) == .notConnectedToInternet)
+  }
+
+  @Test func nothingToClassifyDoesNotRetry() {
+    #expect(!retryable(nil))
+  }
+}
+
+@Suite("PlaybackFailure.httpStatusCode(fromErrorStatusCodes:)")
+struct ErrorLogStatusTests {
+  /// `errorStatusCode` carries negative OSStatus values in the same field.
+  @Test func skipsNonHttpStatusCodes() {
+    #expect(PlaybackFailure.httpStatusCode(fromErrorStatusCodes: [-12939, -1008]) == nil)
+    #expect(PlaybackFailure.httpStatusCode(fromErrorStatusCodes: [-12939, 404]) == 404)
+  }
+
+  /// A live stream reconnects; older entries describe earlier attempts.
+  @Test func prefersTheNewestInRangeStatus() {
+    #expect(PlaybackFailure.httpStatusCode(fromErrorStatusCodes: [500, 404]) == 404)
+    #expect(PlaybackFailure.httpStatusCode(fromErrorStatusCodes: [404, 500, -12939]) == 500)
+  }
+
+  @Test func nilWhenNothingQualifies() {
+    #expect(PlaybackFailure.httpStatusCode(fromErrorStatusCodes: []) == nil)
+  }
+}

package/ios/Tests/PlaybackPersistenceTests.swift

@@ -0,0 +1,93 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("PlaybackPersistence", .serialized)
+@MainActor
+struct PlaybackPersistenceTests {
+  private func freshDefaults() -> UserDefaults {
+    let suite = "PlaybackPersistenceTests"
+    let d = UserDefaults(suiteName: suite)!
+    d.removePersistentDomain(forName: suite)
+    return d
+  }
+
+  private func sampleTrack() -> JsonTrack {
+    JsonTrack(
+      id: "abc", path: nil, title: "Test FM", subtitle: nil, artwork: nil,
+      artist: "City, Country", albumPath: nil, album: nil, description: nil,
+      genre: nil, duration: nil, src: "/listen/abc/channel.mp3", request: nil,
+      style: JsonStyle(display: "grid", artworkRendering: "stencil"),
+      disabled: false, live: true, icyCharset: "windows-1251",
+    )
+  }
+
+  private func state(positionMs: Double? = nil) -> PersistedPlaybackState {
+    PersistedPlaybackState(
+      track: sampleTrack(), positionMs: positionMs, repeatMode: "off", shuffleEnabled: false, playbackSpeed: 1.0,
+    )
+  }
+
+  @Test func roundTrip_preservesState() {
+    let persistence = PlaybackPersistence(defaults: freshDefaults()) { state() }
+    persistence.save()
+    let loaded = persistence.load()
+    #expect(loaded?.track.src == "/listen/abc/channel.mp3")
+    #expect(loaded?.track.live == true)
+    #expect(loaded?.positionMs == nil)
+    #expect(loaded?.playbackSpeed == 1.0)
+  }
+
+  @Test func load_isNilBeforeAnySave() {
+    #expect(PlaybackPersistence(defaults: freshDefaults()) { state() }.load() == nil)
+  }
+
+  @Test func nothingToResume_keepsThePreviousSave() {
+    let defaults = freshDefaults()
+    var current: PersistedPlaybackState? = state(positionMs: 5000)
+    let persistence = PlaybackPersistence(defaults: defaults) { current }
+    persistence.save()
+    current = nil
+    persistence.save()
+    #expect(persistence.load()?.positionMs == 5000)
+  }
+
+  @Test func anActivePlayIntentSavesPeriodically_andOnceWhenItEnds() async throws {
+    var positionMs = 0.0
+    let persistence = PlaybackPersistence(defaults: freshDefaults(), saveInterval: .milliseconds(10)) {
+      positionMs += 1000
+      return state(positionMs: positionMs)
+    }
+    persistence.playIntentDidChange(active: true)
+    try await Task.sleep(for: .milliseconds(100))
+    #expect((persistence.load()?.positionMs ?? 0) >= 1000)
+
+    persistence.playIntentDidChange(active: false)
+    let stopped = try #require(persistence.load()?.positionMs)
+    try await Task.sleep(for: .milliseconds(50))
+    #expect(persistence.load()?.positionMs == stopped)
+  }
+
+  @Test func aSnapshotOfALiveStreamKeepsNoPosition() {
+    let snapshot = PlaybackPersistence.snapshot(
+      of: Track(src: "s", live: true), state: .playing, position: 12, repeatMode: .off, shuffleEnabled: false,
+      rate: 1,
+    )
+    #expect(snapshot.positionMs == nil)
+  }
+
+  @Test func aSnapshotOfAnEndedTrackResumesFromTheStart() {
+    let ended = PlaybackPersistence.snapshot(
+      of: Track(src: "s"), state: .ended, position: 300, repeatMode: .off, shuffleEnabled: false, rate: 1,
+    )
+    let paused = PlaybackPersistence.snapshot(
+      of: Track(src: "s"), state: .paused, position: 12.5, repeatMode: .track, shuffleEnabled: true, rate: 1.5,
+    )
+    #expect(ended.positionMs == 0)
+    #expect(paused.positionMs == 12500)
+    #expect(paused.repeatMode == RepeatMode.track.stringValue)
+    #expect(paused.shuffleEnabled)
+    #expect(paused.playbackSpeed == 1.5)
+  }
+}