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

package/ios/Tests/ReadyValueTests.swift

@@ -0,0 +1,73 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@MainActor
+@Suite("ReadyValue")
+struct ReadyValueTests {
+  final class Source {
+    var value: Int?
+  }
+
+  @Test func returnsAtOnceWhenTheProviderHasAValue() async {
+    let ready = ReadyValue<Int> { 7 }
+    #expect(await ready.wait() == 7)
+  }
+
+  @Test func resumesEveryWaiterOnCheck() async {
+    let source = Source()
+    let ready = ReadyValue { source.value }
+    let first = Task { await ready.wait() }
+    let second = Task { await ready.wait() }
+    while ready.waiterCount < 2 {
+      await Task.yield()
+    }
+    ready.check()
+    #expect(ready.waiterCount == 2)
+    source.value = 3
+    ready.check()
+    #expect(await first.value == 3)
+    #expect(await second.value == 3)
+    #expect(ready.waiterCount == 0)
+  }
+
+  @Test func followsTheProviderWithoutAReset() async {
+    let source = Source()
+    source.value = 1
+    let ready = ReadyValue { source.value }
+    #expect(await ready.wait() == 1)
+    source.value = 2
+    #expect(await ready.wait() == 2)
+  }
+
+  @Test func timesOutWithNilAndDropsTheWaiter() async {
+    let ready = ReadyValue<Int> { nil }
+    #expect(await ready.wait(timeout: .milliseconds(10)) == nil)
+    #expect(ready.waiterCount == 0)
+  }
+
+  @Test func aCancelledWaiterGetsNilAndIsDropped() async {
+    let ready = ReadyValue<Int> { nil }
+    let waiter = Task { await ready.wait() }
+    while ready.waiterCount < 1 {
+      await Task.yield()
+    }
+    waiter.cancel()
+    #expect(await waiter.value == nil)
+    while ready.waiterCount > 0 {
+      await Task.yield()
+    }
+    #expect(ready.waiterCount == 0)
+  }
+
+  @Test func aWaiterCancelledBeforeWaitingGetsNil() async {
+    let ready = ReadyValue<Int> { nil }
+    let waiter = Task {
+      withUnsafeCurrentTask { $0?.cancel() }
+      return await ready.wait()
+    }
+    #expect(await waiter.value == nil)
+    #expect(ready.waiterCount == 0)
+  }
+}

package/ios/Tests/RemoteCommandControllerTests.swift

@@ -0,0 +1,152 @@
+import Foundation
+import MediaPlayer
+import Testing
+
+@testable import AudioBrowserTestable
+
+/// Exercises the controller against the real `MPRemoteCommandCenter`.
+///
+/// `MPRemoteCommandCenter`'s `init()` is unavailable, so `shared()` — a
+/// process-wide singleton — is the only center available. The suite is
+/// `.serialized` because of that shared state, and every test resets the
+/// commands it touches through `reset()`.
+@Suite("RemoteCommandController", .serialized)
+@MainActor
+struct RemoteCommandControllerTests {
+  final class SpyCallbacks: RemoteCommandCallbacks {
+    var events: [String] = []
+    func remotePlay() { events.append("play") }
+    func remotePause() { events.append("pause") }
+    func remoteStop() { events.append("stop") }
+    func remotePlayPause() { events.append("playPause") }
+    func remoteNext() { events.append("next") }
+    func remotePrevious() { events.append("previous") }
+    func remoteJumpForward(interval: Double) { events.append("jumpForward:\(interval)") }
+    func remoteJumpBackward(interval: Double) { events.append("jumpBackward:\(interval)") }
+    func remoteSeek(position: Double) { events.append("seek:\(position)") }
+    func remoteChangeRepeatMode(mode: RepeatMode) { events.append("repeat:\(mode)") }
+    func remoteChangeShuffleMode(enabled: Bool) { events.append("shuffle:\(enabled)") }
+    func remoteChangePlaybackRate(rate: Float) { events.append("rate:\(rate)") }
+  }
+
+  /// Clears every command on the shared center so a test starts from a known
+  /// state regardless of what ran before it.
+  private func makeController() -> (RemoteCommandController, SpyCallbacks) {
+    let center = MPRemoteCommandCenter.shared()
+    let reset = RemoteCommandController(remoteCommandCenter: center)
+    reset.enable(commands: RemoteCommand.all())
+    reset.disableAll()
+
+    let spy = SpyCallbacks()
+    return (RemoteCommandController(remoteCommandCenter: center, callbacks: spy), spy)
+  }
+
+  /// The reported bug: a changed jump interval used to disable the very command
+  /// it had just re-enabled, removing the skip button from the lock screen,
+  /// Control Center and CarPlay while `enabledCommands` still reported it on.
+  @Test func changedJumpIntervalKeepsCommandEnabled() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [
+      .play, .skipForward(preferredIntervals: [15]), .skipBackward(preferredIntervals: [15]),
+    ])
+    #expect(center.skipForwardCommand.isEnabled)
+
+    controller.enable(commands: [
+      .play, .skipForward(preferredIntervals: [30]), .skipBackward(preferredIntervals: [30]),
+    ])
+
+    #expect(center.skipForwardCommand.isEnabled)
+    #expect(center.skipBackwardCommand.isEnabled)
+    #expect(center.skipForwardCommand.preferredIntervals == [30])
+    #expect(center.skipBackwardCommand.preferredIntervals == [30])
+  }
+
+  @Test func changedPlaybackRatesKeepCommandEnabled() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.changePlaybackRate(supportedPlaybackRates: [1.0])])
+    controller.enable(commands: [.changePlaybackRate(supportedPlaybackRates: [1.0, 1.5, 2.0])])
+
+    #expect(center.changePlaybackRateCommand.isEnabled)
+    #expect(center.changePlaybackRateCommand.supportedPlaybackRates == [1.0, 1.5, 2.0])
+  }
+
+  @Test func removedCommandIsDisabledAndUntargeted() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .pause, .next])
+    #expect(center.nextTrackCommand.isEnabled)
+
+    controller.enable(commands: [.play, .pause])
+
+    #expect(!center.nextTrackCommand.isEnabled)
+    #expect(center.playCommand.isEnabled)
+  }
+
+  @Test func disableAllClearsEveryTarget() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .pause, .skipForward(preferredIntervals: [15])])
+    controller.disableAll()
+
+    #expect(!center.playCommand.isEnabled)
+    #expect(!center.pauseCommand.isEnabled)
+    #expect(!center.skipForwardCommand.isEnabled)
+  }
+
+  /// Next/previous follow `skipAvailability` when refreshed and whenever they are enabled.
+  @Test func skipAvailabilityAppliesOnRefreshAndEnable() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+    var availability = (canNext: true, canPrevious: true)
+    controller.skipAvailability = { availability }
+
+    controller.enable(commands: [.next, .previous])
+    #expect(center.nextTrackCommand.isEnabled)
+
+    availability = (false, true)
+    controller.refreshSkipAvailability()
+    #expect(!center.nextTrackCommand.isEnabled)
+    #expect(center.previousTrackCommand.isEnabled)
+
+    controller.enable(commands: [.next, .previous, .play])
+
+    #expect(!center.nextTrackCommand.isEnabled)
+    #expect(center.previousTrackCommand.isEnabled)
+  }
+
+  /// The command targets must not capture the controller strongly, or every player
+  /// instance leaks one across JS reloads.
+  @Test func doesNotRetainItselfThroughHandlers() {
+    weak var weakController: RemoteCommandController?
+    autoreleasepool {
+      let (controller, _) = makeController()
+      controller.enable(commands: RemoteCommand.all())
+      controller.disableAll()
+      weakController = controller
+    }
+    #expect(weakController == nil)
+  }
+
+  @Test func shuffleAndRepeatStateSurviveCommandCenterSwitch() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.changeShuffleMode, .changeRepeatMode])
+    controller.updateShuffleMode(true)
+    controller.updateRepeatMode(.queue)
+
+    // Same center — switchCommandCenter no-ops, but the restore path is the
+    // interesting part: state is re-applied from the stored values.
+    controller.switchCommandCenter(center)
+
+    #expect(center.changeShuffleModeCommand.currentShuffleType == .items)
+    #expect(center.changeRepeatModeCommand.currentRepeatType == .all)
+    #expect(center.changeShuffleModeCommand.isEnabled)
+  }
+}

package/ios/Tests/RemoteCommandTests.swift

@@ -0,0 +1,65 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("RemoteCommand")
+struct RemoteCommandTests {
+  @Test func removedCommandsAreDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.play, .pause, .next, .previous],
+      replacedBy: [.play, .pause],
+    )
+    #expect(toDisable.map(\.key) == ["nextTrack", "previousTrack"])
+  }
+
+  @Test func retainedCommandsAreNotDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.play, .pause],
+      replacedBy: [.play, .pause, .stop],
+    )
+    #expect(toDisable.isEmpty)
+  }
+
+  /// A changed jump interval is the same command with a new associated value —
+  /// diffing by `==` would report it as removed and disable the button that the
+  /// update had just re-enabled.
+  @Test func changedJumpIntervalIsNotDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.skipForward(preferredIntervals: [15]), .skipBackward(preferredIntervals: [15])],
+      replacedBy: [.skipForward(preferredIntervals: [30]), .skipBackward(preferredIntervals: [30])],
+    )
+    #expect(toDisable.isEmpty)
+  }
+
+  @Test func changedPlaybackRatesAreNotDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.changePlaybackRate(supportedPlaybackRates: [1.0])],
+      replacedBy: [.changePlaybackRate(supportedPlaybackRates: [1.0, 1.5, 2.0])],
+    )
+    #expect(toDisable.isEmpty)
+  }
+
+  @Test func everyCommandIsDisabledWhenNoneRemain() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: RemoteCommand.all(),
+      replacedBy: [],
+    )
+    #expect(toDisable.count == RemoteCommand.all().count)
+  }
+
+  /// `key` is the identity the diff above compares; two cases sharing a key would
+  /// disable each other.
+  @Test func keysAreUnique() {
+    let all = RemoteCommand.all()
+    #expect(Set(all.map(\.key)).count == all.count)
+  }
+
+  @Test func droppedJumpCommandIsStillDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.play, .skipForward(preferredIntervals: [15])],
+      replacedBy: [.play],
+    )
+    #expect(toDisable.map(\.key) == ["skipForward"])
+  }
+}

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/ResolvedTrackCopyingTests.swift

@@ -3,17 +3,18 @@ import Testing
 @testable import AudioBrowserTestable
 
 private func makeResolvedTrack(
-  url: String = "/test",
+  path: String = "/test",
   title: String = "Test Track",
 ) -> ResolvedTrack {
   ResolvedTrack(
-    url: url,
+    path: path,
+    style: nil,
+    sections: nil,
     children: nil,
     carPlaySiriListButton: nil,
     src: nil,
     artwork: nil,
     artworkSource: nil,
-    artworkCarPlayTinted: nil,
     title: title,
     subtitle: nil,
     artist: nil,
@@ -21,25 +22,24 @@ private func makeResolvedTrack(
     description: nil,
     genre: nil,
     duration: nil,
-    style: nil,
-    childrenStyle: nil,
+    disabled: nil,
     favorited: nil,
-    groupTitle: nil,
     live: nil,
-    imageRow: nil,
+    icyCharset: nil,
   )
 }
 
 private func makeFullResolvedTrack() -> ResolvedTrack {
   ResolvedTrack(
-    url: "/original",
-    children: [Track(id: "t1", url: "/t1")],
+    path: "/original",
+    style: SectionStyle(gridWrap: false, display: .grid, artworkRendering: .stencil),
+    sections: [Section(title: "Group A", style: nil, path: nil, children: [])],
+    children: [Track(id: "t1", path: "/t1")],
     carPlaySiriListButton: .top,
     id: "original-id",
     src: "src.mp3",
     artwork: .first("art.jpg"),
     artworkSource: ImageSource(uri: "resolved-art.jpg"),
-    artworkCarPlayTinted: true,
     title: "Original Title",
     subtitle: "Original Subtitle",
     artist: "Original Artist",
@@ -47,12 +47,10 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
     description: "Original Description",
     genre: "Rock",
     duration: 180.0,
-    style: .list,
-    childrenStyle: .grid,
+    disabled: false,
     favorited: true,
-    groupTitle: "Group A",
     live: false,
-    imageRow: [ImageRowItem(title: "Row 1")],
+    icyCharset: nil,
   )
 }
 
@@ -64,12 +62,12 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
   #expect(copy == original)
 }
 
-// MARK: - non-optional fields (url, title)
+// MARK: - non-optional fields (path, title)
 
-@Test func copyingOverridesUrl() {
-  let original = makeResolvedTrack(url: "/old")
-  let copy = original.copying(url: "/new")
-  #expect(copy.url == "/new")
+@Test func copyingOverridesPath() {
+  let original = makeResolvedTrack(path: "/old")
+  let copy = original.copying(path: "/new")
+  #expect(copy.path == "/new")
   #expect(copy.title == "Test Track")
 }
 
@@ -77,14 +75,14 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
   let original = makeResolvedTrack(title: "Old")
   let copy = original.copying(title: "New")
   #expect(copy.title == "New")
-  #expect(copy.url == "/test")
+  #expect(copy.path == "/test")
 }
 
 // MARK: - optional fields: set value
 
 @Test func copyingOverridesChildren() {
   let original = makeResolvedTrack()
-  let children = [Track(id: "c1", url: "/c1"), Track(id: "c2", url: "/c2")]
+  let children = [Track(id: "c1", path: "/c1"), Track(id: "c2", path: "/c2")]
   let copy = original.copying(children: children)
   #expect(copy.children?.count == 2)
   #expect(copy.children?[0].id == "c1")
@@ -135,8 +133,14 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
 
 @Test func copyingOverridesStyle() {
   let original = makeResolvedTrack()
-  let copy = original.copying(style: .grid)
-  #expect(copy.style == .grid)
+  let copy = original.copying(style: SectionStyle(gridWrap: nil, display: .grid, artworkRendering: nil))
+  #expect(copy.style?.display == .grid)
+}
+
+@Test func copyingOverridesDisabled() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(disabled: true)
+  #expect(copy.disabled == true)
 }
 
 @Test func copyingOverridesFavorited() {
@@ -157,11 +161,13 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
   #expect(copy.carPlaySiriListButton == .bottom)
 }
 
-@Test func copyingOverridesImageRow() {
+@Test func copyingOverridesSections() {
   let original = makeResolvedTrack()
-  let items = [ImageRowItem(title: "Item 1"), ImageRowItem(title: "Item 2")]
-  let copy = original.copying(imageRow: items)
-  #expect(copy.imageRow == items)
+  let sections = [
+    Section(title: "A", style: nil, path: nil, children: [Track(id: "c1", src: "c1")]),
+  ]
+  let copy = original.copying(sections: sections)
+  #expect(copy.sections == sections)
 }
 
 // MARK: - optional fields: set to nil via .some(nil)
@@ -206,13 +212,13 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
 @Test func copyingOverridesMultipleFields() {
   let original = makeResolvedTrack()
   let copy = original.copying(
-    url: "/updated",
+    path: "/updated",
     title: "Updated Title",
     artist: "New Artist",
     duration: 240.0,
     favorited: true,
   )
-  #expect(copy.url == "/updated")
+  #expect(copy.path == "/updated")
   #expect(copy.title == "Updated Title")
   #expect(copy.artist == "New Artist")
   #expect(copy.duration == 240.0)
@@ -230,23 +236,21 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
   let copy = original.copying(title: "Changed Only Title")
   #expect(copy.title == "Changed Only Title")
   // All other fields unchanged
-  #expect(copy.url == "/original")
+  #expect(copy.path == "/original")
   #expect(copy.children?.count == 1)
   #expect(copy.carPlaySiriListButton == .top)
   #expect(copy.src == "src.mp3")
   #expect(copy.artwork?.url == "art.jpg")
   #expect(copy.artworkSource == ImageSource(uri: "resolved-art.jpg"))
-  #expect(copy.artworkCarPlayTinted == true)
   #expect(copy.subtitle == "Original Subtitle")
   #expect(copy.artist == "Original Artist")
   #expect(copy.album == "Original Album")
   #expect(copy.description == "Original Description")
   #expect(copy.genre == "Rock")
   #expect(copy.duration == 180.0)
-  #expect(copy.style == .list)
-  #expect(copy.childrenStyle == .grid)
+  #expect(copy.style == SectionStyle(gridWrap: false, display: .grid, artworkRendering: .stencil))
+  #expect(copy.disabled == false)
   #expect(copy.favorited == true)
-  #expect(copy.groupTitle == "Group A")
+  #expect(copy.sections?.first?.title == "Group A")
   #expect(copy.live == false)
-  #expect(copy.imageRow == [ImageRowItem(title: "Row 1")])
 }