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

package/ios/Tests/CarPlayArtworkResolverTests.swift

@@ -2,395 +2,99 @@ import Testing
 
 @testable import AudioBrowserTestable
 
-// MARK: - SF Symbol Detection
-
-@Suite("SF symbol artwork")
-struct SFSymbolTests {
-  @Test func sfSymbolArtwork_returnsSfSymbolAction() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "sf:heart.fill",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+@Suite("CarPlayArtworkResolver")
+struct CarPlayArtworkResolverTests {
+  private func action(
+    artwork: String? = nil,
+    artworkSource: ArtworkResolvedImage? = nil,
+    resolved: ArtworkResolvedImage? = nil,
+    stencil: Bool = false,
+  ) -> ArtworkLoadAction {
+    CarPlayArtworkResolver.action(
+      artwork: artwork, artworkSource: artworkSource, resolved: resolved, stencil: stencil, width: 40, height: 40,
     )
-    #expect(action == .sfSymbol(artwork: "sf:heart.fill", width: 40, height: 40))
   }
 
-  @Test func sfSymbolWithParams_returnsSfSymbolAction() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "sf:play.circle?bg=#000&fg=#fff",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 24, targetHeight: 24,
-      displayScale: 3.0,
-      urlResolver: nil,
-    )
-    #expect(action == .sfSymbol(artwork: "sf:play.circle?bg=#000&fg=#fff", width: 24, height: 24))
+  private func image(_ uri: String, headers: [String: String]? = nil) -> ArtworkResolvedImage {
+    ArtworkResolvedImage(uri: uri, headers: headers)
   }
 
-  @Test func sfSymbolTakesPriorityOverUrlResolver() async {
-    var resolverCalled = false
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "sf:music.note",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in
-        resolverCalled = true
-        return ArtworkResolvedImage(uri: "https://example.com/img.jpg", headers: nil)
-      },
+  @Test func anSFSymbolRendersAndIsNotResolved() {
+    #expect(!CarPlayArtworkResolver.needsResolve(artwork: "sf:star.fill?fg=#fff"))
+    #expect(CarPlayArtworkResolver.needsResolve(artwork: "https://example.com/a.jpg"))
+    #expect(CarPlayArtworkResolver.needsResolve(artwork: nil))
+    #expect(
+      action(artwork: "sf:star.fill?fg=#fff", resolved: image("https://example.com/r.jpg"))
+        == .sfSymbol(artwork: "sf:star.fill?fg=#fff", width: 40, height: 40),
     )
-    #expect(action == .sfSymbol(artwork: "sf:music.note", width: 40, height: 40))
-    #expect(!resolverCalled)
   }
 
-  @Test func sfSymbolInArtworkSource_usedAsFallback() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: nil,
-      artworkSourceUri: "sf:star.fill",
-      stencil: false,
-      targetWidth: 20, targetHeight: 20,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .sfSymbol(artwork: "sf:star.fill", width: 20, height: 20))
+  @Test func anSFSymbolArtworkSourceRendersAsTheFallback() {
+    #expect(action(artworkSource: image("sf:star.fill")) == .sfSymbol(artwork: "sf:star.fill", width: 40, height: 40))
   }
-}
-
-// MARK: - No Artwork
 
-@Suite("no artwork")
-struct NoArtworkTests {
-  @Test func noArtworkOrSource_returnsNone() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: nil,
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .none)
+  @Test func nothingToLoadIsNone() {
+    #expect(action() == .none)
   }
 
-  @Test func noArtworkOrSource_withResolver_returnsNone() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: nil,
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in nil },
+  @Test func theResolvedURLIsFetchedWithItsHeaders() {
+    #expect(
+      action(artwork: "https://example.com/a.jpg", resolved: image("https://cdn.example.com/r.jpg", headers: ["A": "1"]))
+        == .fetch(uri: "https://cdn.example.com/r.jpg", headers: ["A": "1"], shouldTint: false, isSvg: false),
     )
-    #expect(action == .none)
   }
-}
-
-// MARK: - URL Resolution
 
-@Suite("URL resolution")
-struct URLResolutionTests {
-  @Test func resolvedUrl_returnsFetchWithHeaders() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { pixelWidth, pixelHeight in
-        #expect(pixelWidth == 80)
-        #expect(pixelHeight == 80)
-        return ArtworkResolvedImage(
-          uri: "https://cdn.example.com/art_80x80.jpg",
-          headers: ["Authorization": "Bearer token"],
-        )
-      },
+  @Test func withoutAResolvedURLTheArtworkIsFetched() {
+    #expect(
+      action(artwork: "https://example.com/a.jpg")
+        == .fetch(uri: "https://example.com/a.jpg", headers: nil, shouldTint: false, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://cdn.example.com/art_80x80.jpg",
-      headers: ["Authorization": "Bearer token"],
-      shouldTint: false,
-      isSvg: false,
-    ))
   }
 
-  @Test func resolvedUrl_noHeaders_returnsFetchWithNilHeaders() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 24, targetHeight: 24,
-      displayScale: 3.0,
-      urlResolver: { _, _ in
-        ArtworkResolvedImage(uri: "https://cdn.example.com/resized.jpg", headers: nil)
-      },
+  @Test func anInvalidResolvedURLFallsBackToTheArtwork() {
+    #expect(
+      action(artwork: "https://example.com/a.jpg", resolved: image(""))
+        == .fetch(uri: "https://example.com/a.jpg", headers: nil, shouldTint: false, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://cdn.example.com/resized.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
   }
 
-  @Test func resolverReturnsNil_fallsBackToDirect() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in nil },
+  @Test func withoutArtworkTheArtworkSourceIsFetchedWithItsHeaders() {
+    #expect(
+      action(artworkSource: image("https://example.com/s.jpg", headers: ["Authorization": "Bearer t"]))
+        == .fetch(uri: "https://example.com/s.jpg", headers: ["Authorization": "Bearer t"], shouldTint: false, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://example.com/art.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
   }
 
-  @Test func resolvedInvalidUrl_fallsBackToDirect() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/fallback.jpg",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in
-        // Return an invalid URI that URL(string:) would reject
-        ArtworkResolvedImage(uri: "", headers: nil)
-      },
+  @Test func artworkWinsOverArtworkSourceWithoutItsHeaders() {
+    #expect(
+      action(
+        artwork: "https://example.com/a.jpg",
+        artworkSource: image("https://example.com/s.jpg", headers: ["Authorization": "Bearer t"]),
+      ) == .fetch(uri: "https://example.com/a.jpg", headers: nil, shouldTint: false, isSvg: false),
     )
-    // Should fall back to direct artwork URL
-    #expect(action == .fetch(
-      uri: "https://example.com/fallback.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
   }
 
-  @Test func displayScale_appliedToPixelDimensions() async {
-    var receivedWidth: Double?
-    var receivedHeight: Double?
-    _ = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 50, targetHeight: 30,
-      displayScale: 2.5,
-      urlResolver: { w, h in
-        receivedWidth = w
-        receivedHeight = h
-        return ArtworkResolvedImage(uri: "https://cdn.example.com/art.jpg", headers: nil)
-      },
-    )
-    #expect(receivedWidth == 125) // 50 * 2.5
-    #expect(receivedHeight == 75) // 30 * 2.5
+  @Test func anInvalidDirectURLIsNone() {
+    #expect(action(artwork: "") == .none)
   }
-}
-
-// MARK: - Direct Fallback
 
-@Suite("direct fallback")
-struct DirectFallbackTests {
-  @Test func noResolver_usesArtworkUrl() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/artwork.png",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+  @Test func anSVGPathIsMarkedCaseInsensitively() {
+    #expect(action(artwork: "https://example.com/i.svg") == .fetch(uri: "https://example.com/i.svg", headers: nil, shouldTint: false, isSvg: true))
+    #expect(action(artwork: "https://example.com/i.SVG") == .fetch(uri: "https://example.com/i.SVG", headers: nil, shouldTint: false, isSvg: true))
+    #expect(
+      action(resolved: image("https://cdn.example.com/i.svg"))
+        == .fetch(uri: "https://cdn.example.com/i.svg", headers: nil, shouldTint: false, isSvg: true),
     )
-    #expect(action == .fetch(
-      uri: "https://example.com/artwork.png",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
   }
 
-  @Test func noArtwork_usesArtworkSourceUri() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: nil,
-      artworkSourceUri: "https://example.com/source.jpg",
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+  @Test func aStencilTints() {
+    #expect(
+      action(artwork: "https://example.com/a.png", stencil: true)
+        == .fetch(uri: "https://example.com/a.png", headers: nil, shouldTint: true, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://example.com/source.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
-  }
-
-  @Test func artworkPreferredOverArtworkSource() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/artwork.jpg",
-      artworkSourceUri: "https://example.com/source.jpg",
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/artwork.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
-  }
-
-  @Test func invalidDirectUrl_returnsNone() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .none)
-  }
-}
-
-// MARK: - SVG Detection
-
-@Suite("SVG detection")
-struct SVGDetectionTests {
-  @Test func svgExtension_setsIsSvgTrue() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/icon.svg",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/icon.svg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: true,
-    ))
-  }
-
-  @Test func svgUppercase_setsIsSvgTrue() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/icon.SVG",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/icon.SVG",
-      headers: nil,
-      shouldTint: false,
-      isSvg: true,
-    ))
-  }
-
-  @Test func resolvedSvgUrl_setsIsSvgTrue() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in
-        ArtworkResolvedImage(uri: "https://cdn.example.com/icon.svg", headers: nil)
-      },
-    )
-    #expect(action == .fetch(
-      uri: "https://cdn.example.com/icon.svg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: true,
-    ))
-  }
-
-  @Test func nonSvg_setsIsSvgFalse() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/photo.jpg",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/photo.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
-  }
-}
-
-// MARK: - Tinting
-
-@Suite("tinting")
-struct TintingTests {
-  @Test func stencilTrue_setsShouldTint() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/icon.png",
-      artworkSourceUri: nil,
-      stencil: true,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/icon.png",
-      headers: nil,
-      shouldTint: true,
-      isSvg: false,
-    ))
-  }
-
-  @Test func stencilFalse_doesNotTint() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/photo.jpg",
-      artworkSourceUri: nil,
-      stencil: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/photo.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
-  }
-
-  @Test func tintingPreservedThroughResolver() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/icon.png",
-      artworkSourceUri: nil,
-      stencil: true,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in
-        ArtworkResolvedImage(uri: "https://cdn.example.com/icon.png", headers: nil)
-      },
+    #expect(
+      action(resolved: image("https://cdn.example.com/r.png"), stencil: true)
+        == .fetch(uri: "https://cdn.example.com/r.png", headers: nil, shouldTint: true, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://cdn.example.com/icon.png",
-      headers: nil,
-      shouldTint: true,
-      isSvg: false,
-    ))
   }
 }

package/ios/Tests/DeferredSeekTests.swift

@@ -0,0 +1,70 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("DeferredSeek")
+struct DeferredSeekTests {
+  @Test func startsIdle() {
+    let seek = DeferredSeek()
+    #expect(seek.state == .idle)
+    #expect(seek.target == nil)
+    #expect(!seek.defersReady)
+  }
+
+  @Test func aCaptureDefersReadyUntilItLands() {
+    var seek = DeferredSeek()
+    seek.capture(30)
+    #expect(seek.defersReady)
+    #expect(seek.begin() == 30)
+    #expect(seek.state == .inFlight(30))
+    #expect(seek.defersReady)
+    #expect(seek.land() == .done)
+    #expect(seek.state == .idle)
+    #expect(!seek.defersReady)
+  }
+
+  @Test func theLatestCaptureWins() {
+    var seek = DeferredSeek()
+    seek.capture(10)
+    seek.capture(20)
+    #expect(seek.target == 20)
+  }
+
+  @Test func beginHandsOutOnlyAPendingTarget() {
+    var seek = DeferredSeek()
+    #expect(seek.begin() == nil)
+    seek.capture(15)
+    #expect(seek.begin() == 15)
+    #expect(seek.begin() == nil)
+    #expect(seek.target == 15)
+  }
+
+  /// A target captured while a seek is in flight is issued when that seek lands, and only its
+  /// own landing makes the load ready.
+  @Test func aCaptureInFlightIsReissuedOnLanding() {
+    var seek = DeferredSeek()
+    seek.capture(10)
+    _ = seek.begin()
+    seek.capture(50)
+    #expect(seek.state == .pending(50))
+    #expect(seek.land() == .reseek(50))
+    #expect(seek.state == .inFlight(50))
+    #expect(seek.land() == .done)
+  }
+
+  /// A seek issued while playing, not deferred, lands as nothing to do.
+  @Test func aLandingWithNothingInFlightIsNone() {
+    var seek = DeferredSeek()
+    #expect(seek.land() == .none)
+  }
+
+  @Test func resetDropsTheTargetAndInvalidatesSeeksInFlight() {
+    var seek = DeferredSeek()
+    seek.capture(10)
+    _ = seek.begin()
+    let issuedAgainst = seek.generation
+    seek.reset()
+    #expect(seek.state == .idle)
+    #expect(seek.generation != issuedAgainst)
+  }
+}

package/ios/Tests/EmitterTests.swift

@@ -120,3 +120,32 @@ struct ListenerCountTests {
     #expect(emitter.listenerCount == 0)
   }
 }
+
+// MARK: - subscribe
+
+@Suite("subscribe")
+struct SubscribeTests {
+  @Test func receivesUntilCancelled() {
+    let emitter = Emitter<Int>()
+    var received: [Int] = []
+    let subscription = emitter.subscribe { received.append($0) }
+    emitter.emit(1)
+    subscription.cancel()
+    emitter.emit(2)
+    #expect(received == [1])
+    #expect(emitter.listenerCount == 0)
+  }
+
+  @Test func releasingTheSubscriptionRemovesTheListener() {
+    let emitter = Emitter<Int>()
+    var received: [Int] = []
+    do {
+      let subscription = emitter.subscribe { received.append($0) }
+      emitter.emit(1)
+      _ = subscription
+    }
+    emitter.emit(2)
+    #expect(received == [1])
+    #expect(emitter.listenerCount == 0)
+  }
+}

package/ios/Tests/GenerationMemoTests.swift

@@ -0,0 +1,121 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+@MainActor
+@Suite("GenerationMemo")
+struct GenerationMemoTests {
+  struct Failure: Error {}
+
+  /// A computation that suspends until `release()`, counting its runs.
+  @MainActor
+  final class Gate {
+    var runs = 0
+    var input = 0
+    private var waiters: [CheckedContinuation<Void, Never>] = []
+
+    func run() async -> Int {
+      runs += 1
+      let input = input
+      await withCheckedContinuation { waiters.append($0) }
+      return input
+    }
+
+    func release() {
+      let pending = waiters
+      waiters = []
+      for waiter in pending {
+        waiter.resume()
+      }
+    }
+
+    /// Yields until `count` runs have started, recording an issue rather than hanging when they
+    /// never do.
+    func waitForRuns(_ count: Int, sourceLocation: SourceLocation = #_sourceLocation) async {
+      for _ in 0 ..< 1000 where runs < count {
+        await Task.yield()
+      }
+      if runs < count {
+        Issue.record("expected \(count) runs, saw \(runs)", sourceLocation: sourceLocation)
+        release()
+      }
+    }
+  }
+
+  @Test func concurrentCallersShareOneComputation() async throws {
+    let memo = GenerationMemo<Int>()
+    let gate = Gate()
+    gate.input = 1
+    let first = Task { try await memo.value { await gate.run() } }
+    let second = Task { try await memo.value { await gate.run() } }
+    await gate.waitForRuns(1)
+    gate.release()
+    #expect(try await first.value == 1)
+    #expect(try await second.value == 1)
+    #expect(gate.runs == 1)
+  }
+
+  @Test func keepsTheValueWithinAGeneration() async throws {
+    let memo = GenerationMemo<Int>()
+    _ = try await memo.value { 1 }
+    #expect(try await memo.value { 2 } == 1)
+  }
+
+  @Test func invalidateComputesAgain() async throws {
+    let memo = GenerationMemo<Int>()
+    _ = try await memo.value { 1 }
+    memo.invalidate()
+    #expect(try await memo.value { 2 } == 2)
+  }
+
+  @Test func aResultThatLandsAfterAnInvalidationIsRecomputed() async throws {
+    let memo = GenerationMemo<Int>()
+    let gate = Gate()
+    gate.input = 1
+    let result = Task { try await memo.value { await gate.run() } }
+    await gate.waitForRuns(1)
+    gate.input = 2
+    memo.invalidate()
+    gate.release()
+    await gate.waitForRuns(2)
+    gate.release()
+    #expect(try await result.value == 2)
+  }
+
+  @Test func aFailureIsNotKept() async throws {
+    let memo = GenerationMemo<Int>()
+    await #expect(throws: Failure.self) { try await memo.value { throw Failure() } }
+    #expect(try await memo.value { 3 } == 3)
+  }
+
+  @Test func aFailureThatLandsAfterAnInvalidationIsRetried() async throws {
+    let memo = GenerationMemo<Int>()
+    let gate = Gate()
+    let result = Task {
+      try await memo.value {
+        let input = await gate.run()
+        if input == 0 { throw Failure() }
+        return input
+      }
+    }
+    await gate.waitForRuns(1)
+    gate.input = 4
+    memo.invalidate()
+    gate.release()
+    await gate.waitForRuns(2)
+    gate.release()
+    #expect(try await result.value == 4)
+  }
+
+  @Test func aCancelledCallerStopsRetrying() async throws {
+    let memo = GenerationMemo<Int>()
+    let gate = Gate()
+    let result = Task { try await memo.value { await gate.run() } }
+    await gate.waitForRuns(1)
+    memo.invalidate()
+    result.cancel()
+    gate.release()
+    await #expect(throws: CancellationError.self) { try await result.value }
+    #expect(gate.runs == 1)
+  }
+}