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

package/ios/Tests/StyleResolverTests.swift

@@ -0,0 +1,132 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+// Resolution semantics (ADR 0011): container properties and `display` resolve
+// by scope override (`section ?? page`), inherited item properties resolve
+// `track ?? section ?? page` — and `display` never inherits onto an item.
+
+@Suite("StyleResolver.sectionStyle")
+struct SectionStyleResolutionTests {
+  @Test func sectionOverridesThePagePerProperty() {
+    let resolved = StyleResolver.sectionStyle(
+      section: SectionStyle(gridWrap: nil, display: .list, artworkRendering: nil),
+      page: SectionStyle(gridWrap: false, display: .grid, artworkRendering: .stencil),
+    )
+    // Declared on the section: wins. Undeclared: the page's scope-wide value.
+    #expect(resolved.display == .list)
+    #expect(resolved.artworkRendering == .stencil)
+    #expect(resolved.gridWrap == false)
+  }
+
+  @Test func aStylelessSectionTakesThePageBlock() {
+    let resolved = StyleResolver.sectionStyle(
+      section: nil,
+      page: SectionStyle(gridWrap: true, display: .grid, artworkRendering: nil),
+    )
+    #expect(resolved.display == .grid)
+    #expect(resolved.gridWrap == true)
+  }
+
+  @Test func noDeclarationsResolveToAnEmptyBlock() {
+    let resolved = StyleResolver.sectionStyle(section: nil, page: nil)
+    #expect(resolved.display == nil)
+    #expect(resolved.artworkRendering == nil)
+    #expect(resolved.gridWrap == nil)
+    #expect(resolved.gridTile == nil)
+  }
+
+  @Test func gridTileResolvesByScopeOverride() {
+    // A page-wide card treatment; one section opts back to plain tiles.
+    let inherited = StyleResolver.sectionStyle(
+      section: nil,
+      page: SectionStyle(gridTile: .card),
+    )
+    #expect(inherited.gridTile == .card)
+    let overridden = StyleResolver.sectionStyle(
+      section: SectionStyle(gridTile: .plain),
+      page: SectionStyle(gridTile: .card),
+    )
+    #expect(overridden.gridTile == .plain)
+    let image = StyleResolver.sectionStyle(
+      section: SectionStyle(gridTile: .image),
+      page: SectionStyle(gridTile: .card),
+    )
+    #expect(image.gridTile == .image)
+  }
+}
+
+@Suite("StyleResolver.trackStyle")
+struct TrackStyleResolutionTests {
+  @Test func trackOverridesTheSectionPerProperty() {
+    let resolved = StyleResolver.trackStyle(
+      track: TrackStyle(display: nil, artworkRendering: .original),
+      section: SectionStyle(gridWrap: nil, display: .grid, artworkRendering: .stencil),
+    )
+    #expect(resolved.artworkRendering == .original)
+  }
+
+  @Test func aStylelessTrackInheritsTheSectionValue() {
+    let resolved = StyleResolver.trackStyle(
+      track: nil,
+      section: SectionStyle(gridWrap: nil, display: nil, artworkRendering: .stencil),
+    )
+    #expect(resolved.artworkRendering == .stencil)
+  }
+
+  @Test func displayNeverInheritsOntoAnItem() {
+    // The track's own `display` is the page promise for the page IT opens;
+    // the section's describes its children's layout. Neither may surface as
+    // the item's resolved display.
+    let resolved = StyleResolver.trackStyle(
+      track: TrackStyle(display: .grid, artworkRendering: nil),
+      section: SectionStyle(gridWrap: nil, display: .grid, artworkRendering: nil),
+    )
+    #expect(resolved.display == nil)
+  }
+
+  @Test func imageShapeInheritsAndOverridesPerItem() {
+    // Section-wide circular (an artists shelf); one album overrides.
+    let inherited = StyleResolver.trackStyle(
+      track: nil,
+      section: SectionStyle(imageShape: .circular),
+    )
+    #expect(inherited.imageShape == .circular)
+    let overridden = StyleResolver.trackStyle(
+      track: TrackStyle(imageShape: .roundedRectangle),
+      section: SectionStyle(imageShape: .circular),
+    )
+    #expect(overridden.imageShape == .roundedRectangle)
+  }
+
+  @Test func accessorySymbolInheritsAndNoneResolvesAsAValue() {
+    let inherited = StyleResolver.trackStyle(
+      track: nil,
+      section: SectionStyle(accessorySymbol: "lock.fill"),
+    )
+    #expect(inherited.accessorySymbol == "lock.fill")
+    // 'none' is the inheritance escape — it must survive resolution intact
+    // (the renderer, not the resolver, maps it to "no accessory").
+    let escaped = StyleResolver.trackStyle(
+      track: TrackStyle(accessorySymbol: "none"),
+      section: SectionStyle(accessorySymbol: "lock.fill"),
+    )
+    #expect(escaped.accessorySymbol == "none")
+  }
+
+  @Test func cardPropertiesInheritAndOverridePerItem() {
+    // Section-wide tint/mode; one card overrides its image mode.
+    let inherited = StyleResolver.trackStyle(
+      track: nil,
+      section: SectionStyle(accessorySymbol: nil, cardTint: "#1e3a8a", cardImage: .background),
+    )
+    #expect(inherited.cardTint == "#1e3a8a")
+    #expect(inherited.cardImage == .background)
+    let overridden = StyleResolver.trackStyle(
+      track: TrackStyle(cardImage: .normal),
+      section: SectionStyle(cardTint: "#1e3a8a", cardImage: .background),
+    )
+    #expect(overridden.cardImage == .normal)
+    #expect(overridden.cardTint == "#1e3a8a")
+  }
+}

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,114 @@ 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 cancelLoadingCount = 0
+  var dropAssetCount = 0
+  var clearItemCount = 0
+  var stopObservingItemCount = 0
+  var recreateCount = 0
+
+  func resolveAndLoad(src: String, track _: Track) { resolveAndLoadCalls.append(src) }
+  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 +140,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 +170,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 +185,7 @@ final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
 
   func playerDidChangeQueue(_ tracks: [Track]) {
     queueChanges.append(tracks)
+    queueAndTrackOrder.append("queue")
   }
 
   func playerDidChangeRepeatMode(_ event: RepeatModeChangedEvent) {
@@ -176,46 +203,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 trackChangedCallCount = 0
-  var trackPlayedToEndCallCount = 0
-  var clearCallCount = 0
 
-  @discardableResult func clear() -> Bool {
-    clearCallCount += 1
-    return true
+  var sleepTimerChanges: [SleepTimerState?] = []
+  func playerDidChangeSleepTimer(_ state: SleepTimerState?) {
+    sleepTimerChanges.append(state)
   }
-
-  func onTrackChanged() { trackChangedCallCount += 1 }
-  func onTrackPlayedToEnd() { trackPlayedToEndCallCount += 1 }
 }
 
-// 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?) -> 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/TabBarEntriesTests.swift

@@ -4,59 +4,59 @@ import Testing
 
 struct TabBarEntriesTests {
   private func tab(
-    _ title: String, url: String, artwork: String? = nil,
-    artworkSource: ImageSource? = nil, artist: String? = nil
+    _ title: String, path: 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
+      id: path, path: path, artwork: artwork.map { .first($0) },
+      artworkSource: artworkSource, title: title, artist: artist,
     )
   }
 
   @Test func identicalListsAreSame() {
-    let tabs = [tab("Explore", url: "/explore"), tab("Browse", url: "/browse")]
+    let tabs = [tab("Explore", path: "/explore"), tab("Browse", path: "/browse")]
     #expect(TabBarEntries.same(tabs, tabs))
   }
 
   @Test func titleChangeDiffers() {
     #expect(
       !TabBarEntries.same(
-        [tab("Explore", url: "/explore")],
-        [tab("Verkennen", url: "/explore")]
+        [tab("Explore", path: "/explore")],
+        [tab("Verkennen", path: "/explore")],
       ))
   }
 
-  @Test func urlChangeDiffers() {
+  @Test func pathChangeDiffers() {
     #expect(
       !TabBarEntries.same(
-        [tab("Explore", url: "/explore")],
-        [tab("Explore", url: "/discover")]
+        [tab("Explore", path: "/explore")],
+        [tab("Explore", path: "/discover")],
       ))
   }
 
   @Test func artworkChangeDiffers() {
     #expect(
       !TabBarEntries.same(
-        [tab("Explore", url: "/explore", artwork: "sf:globe")],
-        [tab("Explore", url: "/explore", artwork: "sf:map")]
+        [tab("Explore", path: "/explore", artwork: "sf:globe")],
+        [tab("Explore", path: "/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"))]
+        [tab("Explore", path: "/explore", artworkSource: ImageSource(uri: "https://a/1.png"))],
+        [tab("Explore", path: "/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")]))
+    let tabs = [tab("Explore", path: "/explore")]
+    #expect(!TabBarEntries.same(tabs, tabs + [tab("Browse", path: "/browse")]))
   }
 
   @Test func nilOldDiffers() {
-    #expect(!TabBarEntries.same(nil, [tab("Explore", url: "/explore")]))
+    #expect(!TabBarEntries.same(nil, [tab("Explore", path: "/explore")]))
   }
 
   @Test func nonRenderedFieldChangeIsSame() {
@@ -64,8 +64,8 @@ struct TabBarEntriesTests {
     // drift without churning the tab bar.
     #expect(
       TabBarEntries.same(
-        [tab("Explore", url: "/explore", artist: "a")],
-        [tab("Explore", url: "/explore", artist: "b")]
+        [tab("Explore", path: "/explore", artist: "a")],
+        [tab("Explore", path: "/explore", artist: "b")],
       ))
   }
 }

package/ios/Tests/TimedMetadataAVFoundationTests.swift

@@ -20,6 +20,48 @@ struct TimedMetadataICYTests {
     #expect(result?.artist == nil)
   }
 
+  private func icyTitle(_ value: String) -> AVMetadataItem {
+    let item = AVMutableMetadataItem()
+    item.key = "StreamTitle" as NSString
+    item.keySpace = .icy
+    item.value = value as NSString
+    return item
+  }
+
+  // "Песня" as windows-1251 bytes, decoded as Latin-1 the way AVFoundation does when it guesses wrong.
+  private let latin1Shaped = "\u{CF}\u{E5}\u{F1}\u{ED}\u{FF}"
+
+  @Test func icyCharset_redecodesLatin1ShapedTitle() {
+    let result = TimedMetadata.from(items: [icyTitle(latin1Shaped)], icyCharset: "windows-1251")
+    #expect(result?.title == "Песня")
+  }
+
+  @Test func icyCharset_leavesAlreadyDecodedTitle() {
+    let result = TimedMetadata.from(items: [icyTitle("Песня")], icyCharset: "windows-1251")
+    #expect(result?.title == "Песня")
+  }
+
+  @Test func icyCharset_leavesAscii() {
+    let result = TimedMetadata.from(items: [icyTitle("Plain Title")], icyCharset: "windows-1251")
+    #expect(result?.title == "Plain Title")
+  }
+
+  @Test func icyCharset_ignoresUnknownCharset() {
+    let result = TimedMetadata.from(items: [icyTitle(latin1Shaped)], icyCharset: "no-such-charset")
+    #expect(result?.title == latin1Shaped)
+  }
+
+  @Test func icyCharset_absent_keepsTitle() {
+    let result = TimedMetadata.from(items: [icyTitle(latin1Shaped)])
+    #expect(result?.title == latin1Shaped)
+  }
+
+  @Test func icyCharset_neverTouchesId3() {
+    let items = [makeMetadataItem(identifier: .id3MetadataTitleDescription, value: latin1Shaped)]
+    let result = TimedMetadata.from(items: items, icyCharset: "windows-1251")
+    #expect(result?.title == latin1Shaped)
+  }
+
   @Test func icyWithoutStreamTitle_returnsNil() {
     let item = AVMutableMetadataItem()
     item.key = "StreamUrl" as NSString