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

package/ios/Tests/ResolvedTrackCopyingTests.swift

@@ -0,0 +1,245 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+private func makeResolvedTrack(
+  url: String = "/test",
+  title: String = "Test Track"
+) -> ResolvedTrack {
+  ResolvedTrack(
+    url: url,
+    children: nil,
+    carPlaySiriListButton: nil,
+    src: nil,
+    artwork: nil,
+    artworkSource: nil,
+    artworkCarPlayTinted: nil,
+    title: title,
+    subtitle: nil,
+    artist: nil,
+    album: nil,
+    description: nil,
+    genre: nil,
+    duration: nil,
+    style: nil,
+    childrenStyle: nil,
+    favorited: nil,
+    groupTitle: nil,
+    live: nil,
+    imageRow: nil
+  )
+}
+
+private func makeFullResolvedTrack() -> ResolvedTrack {
+  ResolvedTrack(
+    url: "/original",
+    children: [Track(id: "t1", url: "/t1")],
+    carPlaySiriListButton: .top,
+    src: "src.mp3",
+    artwork: "art.jpg",
+    artworkSource: ImageSource(uri: "resolved-art.jpg"),
+    artworkCarPlayTinted: true,
+    title: "Original Title",
+    subtitle: "Original Subtitle",
+    artist: "Original Artist",
+    album: "Original Album",
+    description: "Original Description",
+    genre: "Rock",
+    duration: 180.0,
+    style: .list,
+    childrenStyle: .grid,
+    favorited: true,
+    groupTitle: "Group A",
+    live: false,
+    imageRow: [ImageRowItem(title: "Row 1")]
+  )
+}
+
+// MARK: - no-op copy
+
+@Test func copyingWithNoArgsPreservesAllFields() {
+  let original = makeFullResolvedTrack()
+  let copy = original.copying()
+  #expect(copy == original)
+}
+
+// MARK: - non-optional fields (url, title)
+
+@Test func copyingOverridesUrl() {
+  let original = makeResolvedTrack(url: "/old")
+  let copy = original.copying(url: "/new")
+  #expect(copy.url == "/new")
+  #expect(copy.title == "Test Track")
+}
+
+@Test func copyingOverridesTitle() {
+  let original = makeResolvedTrack(title: "Old")
+  let copy = original.copying(title: "New")
+  #expect(copy.title == "New")
+  #expect(copy.url == "/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 copy = original.copying(children: children)
+  #expect(copy.children?.count == 2)
+  #expect(copy.children?[0].id == "c1")
+}
+
+@Test func copyingOverridesSrc() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(src: "new-src.mp3")
+  #expect(copy.src == "new-src.mp3")
+}
+
+@Test func copyingOverridesArtwork() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(artwork: "new-art.jpg")
+  #expect(copy.artwork == "new-art.jpg")
+}
+
+@Test func copyingOverridesArtworkSource() {
+  let original = makeResolvedTrack()
+  let source = ImageSource(uri: "new-source.jpg")
+  let copy = original.copying(artworkSource: source)
+  #expect(copy.artworkSource == source)
+}
+
+@Test func copyingOverridesSubtitle() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(subtitle: "New Subtitle")
+  #expect(copy.subtitle == "New Subtitle")
+}
+
+@Test func copyingOverridesArtist() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(artist: "New Artist")
+  #expect(copy.artist == "New Artist")
+}
+
+@Test func copyingOverridesDuration() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(duration: 300.0)
+  #expect(copy.duration == 300.0)
+}
+
+@Test func copyingOverridesStyle() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(style: .grid)
+  #expect(copy.style == .grid)
+}
+
+@Test func copyingOverridesFavorited() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(favorited: true)
+  #expect(copy.favorited == true)
+}
+
+@Test func copyingOverridesLive() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(live: true)
+  #expect(copy.live == true)
+}
+
+@Test func copyingOverridesCarPlaySiriListButton() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(carPlaySiriListButton: .bottom)
+  #expect(copy.carPlaySiriListButton == .bottom)
+}
+
+@Test func copyingOverridesImageRow() {
+  let original = makeResolvedTrack()
+  let items = [ImageRowItem(title: "Item 1"), ImageRowItem(title: "Item 2")]
+  let copy = original.copying(imageRow: items)
+  #expect(copy.imageRow == items)
+}
+
+// MARK: - optional fields: set to nil via .some(nil)
+
+@Test func copyingClearsSrcToNil() {
+  let original = makeFullResolvedTrack()
+  #expect(original.src != nil)
+  let copy = original.copying(src: .some(nil))
+  #expect(copy.src == nil)
+}
+
+@Test func copyingClearsChildrenToNil() {
+  let original = makeFullResolvedTrack()
+  #expect(original.children != nil)
+  let copy = original.copying(children: .some(nil))
+  #expect(copy.children == nil)
+}
+
+@Test func copyingClearsArtworkToNil() {
+  let original = makeFullResolvedTrack()
+  #expect(original.artwork != nil)
+  let copy = original.copying(artwork: .some(nil))
+  #expect(copy.artwork == nil)
+}
+
+@Test func copyingClearsFavoritedToNil() {
+  let original = makeFullResolvedTrack()
+  #expect(original.favorited != nil)
+  let copy = original.copying(favorited: .some(nil))
+  #expect(copy.favorited == nil)
+}
+
+@Test func copyingClearsDurationToNil() {
+  let original = makeFullResolvedTrack()
+  #expect(original.duration != nil)
+  let copy = original.copying(duration: .some(nil))
+  #expect(copy.duration == nil)
+}
+
+// MARK: - multiple fields at once
+
+@Test func copyingOverridesMultipleFields() {
+  let original = makeResolvedTrack()
+  let copy = original.copying(
+    url: "/updated",
+    title: "Updated Title",
+    artist: "New Artist",
+    duration: 240.0,
+    favorited: true
+  )
+  #expect(copy.url == "/updated")
+  #expect(copy.title == "Updated Title")
+  #expect(copy.artist == "New Artist")
+  #expect(copy.duration == 240.0)
+  #expect(copy.favorited == true)
+  // Unchanged fields
+  #expect(copy.src == nil)
+  #expect(copy.artwork == nil)
+  #expect(copy.children == nil)
+}
+
+// MARK: - preserves unmodified fields
+
+@Test func copyingPreservesUnmodifiedFields() {
+  let original = makeFullResolvedTrack()
+  let copy = original.copying(title: "Changed Only Title")
+  #expect(copy.title == "Changed Only Title")
+  // All other fields unchanged
+  #expect(copy.url == "/original")
+  #expect(copy.children?.count == 1)
+  #expect(copy.carPlaySiriListButton == .top)
+  #expect(copy.src == "src.mp3")
+  #expect(copy.artwork == "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.favorited == true)
+  #expect(copy.groupTitle == "Group A")
+  #expect(copy.live == false)
+  #expect(copy.imageRow == [ImageRowItem(title: "Row 1")])
+}

package/ios/Tests/SimpleRouterTests.swift

@@ -0,0 +1,139 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+private struct TestRoute: RouteEntry {
+  let path: String
+}
+
+private func match(_ path: String, _ patterns: [String]) -> (route: TestRoute, match: RouteMatch)? {
+  let router = SimpleRouter()
+  let routes = patterns.map { TestRoute(path: $0) }
+  return router.findBestMatch(path: path, routes: routes)
+}
+
+// MARK: - exact matches
+
+@Test func matchesASimplePath() {
+  let result = match("/artists", ["/artists"])
+  #expect(result != nil)
+  #expect(result!.route.path == "/artists")
+  #expect(result!.match.params.isEmpty)
+}
+
+@Test func matchesMultiSegmentPaths() {
+  let result = match("/artists/top/rated", ["/artists/top/rated"])
+  #expect(result != nil)
+  #expect(result!.route.path == "/artists/top/rated")
+}
+
+@Test func returnsNilWhenNoRouteMatches() {
+  #expect(match("/unknown", ["/artists"]) == nil)
+}
+
+@Test func returnsNilWhenSegmentCountDiffers() {
+  #expect(match("/artists/123", ["/artists"]) == nil)
+}
+
+@Test func returnsNilWhenRoutesAreEmpty() {
+  #expect(match("/artists", []) == nil)
+}
+
+@Test func treatsTrailingSlashesTheSameAsWithout() {
+  let result = match("/artists/", ["/artists"])
+  #expect(result != nil)
+  #expect(result!.route.path == "/artists")
+}
+
+// MARK: - parameter extraction
+
+@Test func extractsASingleParameter() {
+  let result = match("/artists/123", ["/artists/{id}"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["id": "123"])
+}
+
+@Test func extractsMultipleParameters() {
+  let result = match("/artists/123/albums/456", ["/artists/{artistId}/albums/{albumId}"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["artistId": "123", "albumId": "456"])
+}
+
+// MARK: - single wildcard
+
+@Test func matchesAnySingleSegment() {
+  #expect(match("/artists/anything", ["/artists/*"]) != nil)
+}
+
+@Test func doesNotExtractWildcardValueIntoParams() {
+  let result = match("/artists/anything", ["/artists/*"])
+  #expect(result!.match.params.isEmpty)
+}
+
+// MARK: - tail wildcard
+
+@Test func matchesWithNoRemainingSegmentsAndHasNoTailParam() {
+  let result = match("/files", ["/files/**"])
+  #expect(result != nil)
+  #expect(result!.match.params.isEmpty)
+}
+
+@Test func matchesWithRemainingSegmentsAndCapturesTail() {
+  let result = match("/files/a/b/c", ["/files/**"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["tail": "a/b/c"])
+}
+
+@Test func matchesWithASingleRemainingSegment() {
+  let result = match("/files/readme.txt", ["/files/**"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["tail": "readme.txt"])
+}
+
+@Test func returnsNilWhenPrefixSegmentsDoNotMatch() {
+  #expect(match("/other/a/b", ["/files/**"]) == nil)
+}
+
+@Test func worksWithParametersBeforeTailWildcard() {
+  let result = match("/api/v1/users/list", ["/api/{version}/**"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["version": "v1", "tail": "users/list"])
+}
+
+@Test func matchesAnyPathWithBareTailWildcardPattern() {
+  let result = match("/any/path/here", ["/**"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["tail": "any/path/here"])
+}
+
+// MARK: - specificity
+
+@Test func prefersConstantSegmentsOverParameters() {
+  let result = match("/artists/top", ["/artists/{id}", "/artists/top"])
+  #expect(result!.route.path == "/artists/top")
+}
+
+@Test func prefersParametersOverWildcards() {
+  let result = match("/artists/123", ["/artists/*", "/artists/{id}"])
+  #expect(result!.route.path == "/artists/{id}")
+}
+
+@Test func prefersExactMatchOverTailWildcard() {
+  let result = match("/api/v1", ["/api/**", "/api/{version}"])
+  #expect(result!.route.path == "/api/{version}")
+}
+
+@Test func computesCorrectSpecificityForTailWildcardPatterns() {
+  // Regression test for issue #27: specificity must account for
+  // segment types before the ** wildcard.
+  let result = match("/api/v1/users", ["/api/v1/**"])
+  // constant "api" (1000) + constant "v1" (1000) + tail(1) + 3 segments = 2004
+  #expect(result!.match.specificity == 2004)
+}
+
+@Test func prefersConstantPrefixOverParameterPrefixInTailWildcards() {
+  // Second part of issue #27: with correct specificity, the constant
+  // prefix should beat the parameter prefix.
+  let result = match("/api/v1/users", ["/api/{version}/**", "/api/v1/**"])
+  #expect(result!.route.path == "/api/v1/**")
+}

package/ios/Tests/Support/TestTypes.swift

@@ -0,0 +1,180 @@
+// This file is intentionally empty — mock types live in
+// Model/NitroTypeStubs.swift (part of the AudioBrowserTestable target).
+
+import AVFoundation
+@testable import AudioBrowserTestable
+
+/// Creates an AVMetadataItem with the specified properties for testing.
+func makeMetadataItem(
+  identifier: AVMetadataIdentifier? = nil,
+  commonKey: AVMetadataKey? = nil,
+  keySpace: AVMetadataKeySpace? = nil,
+  key: String? = nil,
+  value: String
+) -> AVMetadataItem {
+  let item = AVMutableMetadataItem()
+  if let identifier {
+    item.identifier = identifier
+  }
+  if let commonKey {
+    item.key = commonKey as NSString
+    item.keySpace = keySpace ?? .common
+  }
+  if let key, let keySpace {
+    item.key = key as NSString
+    item.keySpace = keySpace
+  }
+  item.value = value as NSString
+  return item
+}
+
+// MARK: - Mock PlaybackEffectHandler
+
+@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 }
+
+  // AVPlayer state queries
+  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 reloadTrackCalls: [Bool] = []
+  var unloadTrackCallCount = 0
+  var cancelMediaLoadingCallCount = 0
+
+  func loadTrack(src: String) { loadTrackCalls.append(src) }
+  func reloadTrack(startFromCurrentTime: Bool) { reloadTrackCalls.append(startFromCurrentTime) }
+  func unloadTrack() { unloadTrackCallCount += 1 }
+  func cancelMediaLoading() { cancelMediaLoadingCallCount += 1 }
+
+  // Seek operations
+  var seekToStartCallCount = 0
+  var replayCurrentTrackCallCount = 0
+
+  func seekToStart() { seekToStartCallCount += 1 }
+  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 clearNowPlayingCallCount = 0
+  var setNowPlayingCurrentTimeCalls: [Double] = []
+
+  func updateNowPlayingValues(duration: Double, rate: Float, currentTime: Double) {
+    updateNowPlayingValuesCalls.append((duration, rate, currentTime))
+  }
+  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] = []
+  var updateRemoteShuffleModeCalls: [Bool] = []
+
+  func updateRemoteRepeatMode(_ mode: RepeatMode) {
+    updateRemoteRepeatModeCalls.append(mode)
+  }
+  func updateRemoteShuffleMode(_ enabled: Bool) {
+    updateRemoteShuffleModeCalls.append(enabled)
+  }
+}
+
+// MARK: - Mock PlaybackCoordinatorCallbacks
+
+@MainActor
+final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
+  var playbackChanges: [Playback] = []
+  var activeTrackChanges: [PlaybackActiveTrackChangedEvent] = []
+  var progressUpdates: [PlaybackProgressUpdatedEvent] = []
+  var playWhenReadyChanges: [Bool] = []
+  var playingStateChanges: [PlayingState] = []
+  var queueEndedEvents: [PlaybackQueueEndedEvent] = []
+  var queueChanges: [[Track]] = []
+  var repeatModeChanges: [RepeatModeChangedEvent] = []
+  var shuffleEnabledChanges: [Bool] = []
+  var errorEvents: [PlaybackErrorEvent] = []
+
+  func playerDidChangePlayback(_ playback: Playback) {
+    playbackChanges.append(playback)
+  }
+  func playerDidChangeActiveTrack(_ event: PlaybackActiveTrackChangedEvent) {
+    activeTrackChanges.append(event)
+  }
+  func playerDidUpdateProgress(_ event: PlaybackProgressUpdatedEvent) {
+    progressUpdates.append(event)
+  }
+  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)
+  }
+}
+
+// MARK: - Mock SleepTimerHandling
+
+@MainActor
+final class MockSleepTimerHandling: SleepTimerHandling {
+  var onComplete: (() -> Void)?
+  var trackChangedCallCount = 0
+  var trackPlayedToEndCallCount = 0
+
+  func onTrackChanged() { trackChangedCallCount += 1 }
+  func onTrackPlayedToEnd() { trackPlayedToEndCallCount += 1 }
+}
+
+// MARK: - Mock RetryHandling
+
+@MainActor
+final class MockRetryHandling: RetryHandling {
+  var isRetryableResult = false
+  var attemptRetryResult = false
+  var resetCallCount = 0
+
+  func isRetryable(_ error: Error?) -> Bool { isRetryableResult }
+  func attemptRetry(startFromCurrentTime: Bool) async -> Bool { attemptRetryResult }
+  func reset() { resetCallCount += 1 }
+}