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

package/ios/Tests/LoadSeekCoordinatorTests.swift

@@ -1,325 +0,0 @@
-import AVFoundation
-import Testing
-
-@testable import AudioBrowserTestable
-
-// MARK: - Helpers
-
-@MainActor
-private final class SeekCompletionSpy: SeekCompletionHandler {
-  var calls: [(seconds: Double, didFinish: Bool)] = []
-  func handleSeekCompleted(to seconds: Double, didFinish: Bool) {
-    calls.append((seconds, didFinish))
-  }
-}
-
-@MainActor
-private func makeCoordinator() -> LoadSeekCoordinator {
-  LoadSeekCoordinator()
-}
-
-// MARK: - Initial State
-
-@Suite("initial state")
-@MainActor
-struct InitialStateTests {
-  @Test func startsIdle() {
-    let c = makeCoordinator()
-    guard case .idle = c.state else {
-      Issue.record("expected .idle, got \(c.state)")
-      return
-    }
-  }
-
-  @Test func pendingTimeIsNil() {
-    let c = makeCoordinator()
-    #expect(c.pendingTime == nil)
-  }
-
-  @Test func shouldDeferReadyTransitionIsFalse() {
-    let c = makeCoordinator()
-    #expect(c.shouldDeferReadyTransition == false)
-  }
-}
-
-// MARK: - Capture
-
-@Suite("capture")
-@MainActor
-struct CaptureTests {
-  @Test func setsStateToPendingSeek() {
-    let c = makeCoordinator()
-    c.capture(position: 42.0)
-    guard case let .pendingSeek(time) = c.state else {
-      Issue.record("expected .pendingSeek, got \(c.state)")
-      return
-    }
-    #expect(time == 42.0)
-  }
-
-  @Test func updatesPendingTime() {
-    let c = makeCoordinator()
-    c.capture(position: 10.0)
-    #expect(c.pendingTime == 10.0)
-  }
-
-  @Test func shouldDeferReadyTransitionBecomesTrue() {
-    let c = makeCoordinator()
-    c.capture(position: 5.0)
-    #expect(c.shouldDeferReadyTransition == true)
-  }
-
-  @Test func supersedesPreviousPendingSeek() {
-    let c = makeCoordinator()
-    c.capture(position: 10.0)
-    c.capture(position: 20.0)
-    #expect(c.pendingTime == 20.0)
-  }
-
-  @Test func overridesSeekInFlight() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    c.capture(position: 10.0)
-    _ = c.executeIfPending(on: player, delegate: nil)
-    // Now in seekInFlight
-    guard case .seekInFlight = c.state else {
-      Issue.record("expected .seekInFlight, got \(c.state)")
-      return
-    }
-    c.capture(position: 30.0)
-    guard case let .pendingSeek(time) = c.state else {
-      Issue.record("expected .pendingSeek, got \(c.state)")
-      return
-    }
-    #expect(time == 30.0)
-  }
-}
-
-// MARK: - executeIfPending
-
-@Suite("executeIfPending")
-@MainActor
-struct ExecuteIfPendingTests {
-  @Test func returnsFalseWhenIdle() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    #expect(c.executeIfPending(on: player, delegate: nil) == false)
-  }
-
-  @Test func returnsTrueWhenPendingSeek() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    c.capture(position: 15.0)
-    #expect(c.executeIfPending(on: player, delegate: nil) == true)
-  }
-
-  @Test func transitionsToSeekInFlight() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    c.capture(position: 15.0)
-    _ = c.executeIfPending(on: player, delegate: nil)
-    guard case let .seekInFlight(time) = c.state else {
-      Issue.record("expected .seekInFlight, got \(c.state)")
-      return
-    }
-    #expect(time == 15.0)
-  }
-
-  @Test func preservesTimeValueThroughTransition() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    c.capture(position: 99.5)
-    _ = c.executeIfPending(on: player, delegate: nil)
-    #expect(c.pendingTime == 99.5)
-  }
-
-  @Test func returnsFalseWhenSeekInFlight() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    c.capture(position: 10.0)
-    _ = c.executeIfPending(on: player, delegate: nil)
-    // Now in seekInFlight — calling again should return false
-    #expect(c.executeIfPending(on: player, delegate: nil) == false)
-  }
-}
-
-// MARK: - seekDidComplete
-
-@Suite("seekDidComplete")
-@MainActor
-struct SeekDidCompleteTests {
-  @Test func fromSeekInFlight_returnsTrue_resetsToIdle() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    c.capture(position: 10.0)
-    _ = c.executeIfPending(on: player, delegate: nil)
-    #expect(c.seekDidComplete(on: player, delegate: nil) == true)
-    guard case .idle = c.state else {
-      Issue.record("expected .idle, got \(c.state)")
-      return
-    }
-  }
-
-  @Test func fromPendingSeek_returnsFalse_reExecutes() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    // Start a seek
-    c.capture(position: 10.0)
-    _ = c.executeIfPending(on: player, delegate: nil)
-    // Queue a new seek while in-flight
-    c.capture(position: 20.0)
-    // Complete the first seek — should re-execute
-    #expect(c.seekDidComplete(on: player, delegate: nil) == false)
-    guard case let .seekInFlight(time) = c.state else {
-      Issue.record("expected .seekInFlight, got \(c.state)")
-      return
-    }
-    #expect(time == 20.0)
-  }
-
-  @Test func fromIdle_returnsFalse() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    #expect(c.seekDidComplete(on: player, delegate: nil) == false)
-  }
-}
-
-// MARK: - Reset
-
-@Suite("reset")
-@MainActor
-struct ResetTests {
-  @Test func clearsFromPendingSeekToIdle() {
-    let c = makeCoordinator()
-    c.capture(position: 10.0)
-    c.reset()
-    guard case .idle = c.state else {
-      Issue.record("expected .idle, got \(c.state)")
-      return
-    }
-    #expect(c.pendingTime == nil)
-  }
-
-  @Test func clearsFromSeekInFlightToIdle() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    c.capture(position: 10.0)
-    _ = c.executeIfPending(on: player, delegate: nil)
-    c.reset()
-    guard case .idle = c.state else {
-      Issue.record("expected .idle, got \(c.state)")
-      return
-    }
-  }
-
-  @Test func noopWhenAlreadyIdle() {
-    let c = makeCoordinator()
-    c.reset()
-    guard case .idle = c.state else {
-      Issue.record("expected .idle, got \(c.state)")
-      return
-    }
-  }
-
-  @Test func invalidatesTheGenerationOfSeeksInFlight() {
-    let c = makeCoordinator()
-    let issuedAgainst = c.generation
-    #expect(c.isCurrentGeneration(issuedAgainst))
-    c.reset()
-    #expect(!c.isCurrentGeneration(issuedAgainst))
-  }
-
-  /// The cross-item race: a seek is in flight when a queue change resets the
-  /// coordinator and captures the new track's start position. The old item's
-  /// cancelled completion (now a stale generation) must be dropped — not
-  /// delivered as a completion that would consume the fresh pending seek.
-  @Test func staleCompletionAfterResetIsDroppedAndKeepsThePendingSeek() async {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-    let spy = SeekCompletionSpy()
-
-    c.capture(position: 10.0)
-    _ = c.executeIfPending(on: player, delegate: spy)
-
-    // Queue change: reset, then capture the new track's start position.
-    c.reset()
-    c.capture(position: 25.0)
-
-    // Let the (immediately-cancelled, itemless) seek completion drain.
-    for _ in 0 ..< 20 { await Task.yield() }
-
-    #expect(spy.calls.isEmpty)
-    #expect(c.pendingTime == 25.0)
-  }
-}
-
-// MARK: - Integration
-
-@Suite("integration")
-@MainActor
-struct IntegrationTests {
-  @Test func fullCycle_capture_execute_complete() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-
-    // Capture
-    c.capture(position: 30.0)
-    #expect(c.shouldDeferReadyTransition == true)
-
-    // Execute
-    let executed = c.executeIfPending(on: player, delegate: nil)
-    #expect(executed == true)
-    guard case .seekInFlight = c.state else {
-      Issue.record("expected .seekInFlight")
-      return
-    }
-
-    // Complete
-    let done = c.seekDidComplete(on: player, delegate: nil)
-    #expect(done == true)
-    guard case .idle = c.state else {
-      Issue.record("expected .idle")
-      return
-    }
-    #expect(c.shouldDeferReadyTransition == false)
-  }
-
-  @Test func overrideDuringInFlight_capture_execute_capture_complete_reExecute() {
-    let c = makeCoordinator()
-    let player = AVPlayer()
-
-    // First seek
-    c.capture(position: 10.0)
-    _ = c.executeIfPending(on: player, delegate: nil)
-    guard case let .seekInFlight(t1) = c.state else {
-      Issue.record("expected .seekInFlight")
-      return
-    }
-    #expect(t1 == 10.0)
-
-    // Override while in-flight
-    c.capture(position: 50.0)
-    guard case let .pendingSeek(t2) = c.state else {
-      Issue.record("expected .pendingSeek")
-      return
-    }
-    #expect(t2 == 50.0)
-
-    // First seek "completes" — should auto re-execute
-    let done = c.seekDidComplete(on: player, delegate: nil)
-    #expect(done == false)
-    guard case let .seekInFlight(t3) = c.state else {
-      Issue.record("expected .seekInFlight after re-execute")
-      return
-    }
-    #expect(t3 == 50.0)
-
-    // Second seek completes
-    let done2 = c.seekDidComplete(on: player, delegate: nil)
-    #expect(done2 == true)
-    guard case .idle = c.state else {
-      Issue.record("expected .idle")
-      return
-    }
-  }
-}

package/ios/Tests/MediaResolveTests.swift

@@ -1,126 +0,0 @@
-import Testing
-
-@testable import AudioBrowserTestable
-
-/// Tests for the media `resolve` layer composition: the variant unwrap (sync vs
-/// async arm) and the override-wins merge that layers the resolved config over
-/// the base. These mirror what `BrowserManager.resolveMediaTrackConfig` +
-/// `mergeRequestConfig` do in production, exercised here against the pure
-/// `MediaResolveComposer` (which the Nitro path delegates to / duplicates).
-@Suite("MediaResolve")
-struct MediaResolveTests {
-  typealias Config = MediaResolveComposer.RequestConfigLike
-
-  // MARK: - Variant unwrap
-
-  @Test("sync (.first) arm yields its config directly")
-  func unwrapSync() async throws {
-    let config = Config(userAgent: "RESOLVED")
-    let result = try await MediaResolveComposer.unwrap(.sync(config))
-    #expect(result == config)
-  }
-
-  @Test("async (.second) arm awaits and yields its config")
-  func unwrapAsync() async throws {
-    let config = Config(userAgent: "RESOLVED-ASYNC")
-    let result = try await MediaResolveComposer.unwrap(
-      .async {
-        // Simulate the Promise<RequestConfig> resolving after a hop.
-        await Task.yield()
-        return config
-      },
-    )
-    #expect(result == config)
-  }
-
-  @Test("async arm propagates errors (rejected promise)")
-  func unwrapAsyncThrows() async {
-    struct Boom: Error {}
-    await #expect(throws: Boom.self) {
-      _ = try await MediaResolveComposer.unwrap(
-        .async { throw Boom() } as MediaResolveComposer.ResolveVariant<Config>,
-      )
-    }
-  }
-
-  // MARK: - Merge as the final layer
-
-  @Test("resolve userAgent overrides base while keeping baseUrl and path")
-  func mergeOverridesUserAgent() {
-    let base = Config(path: "/audio.mp3", baseUrl: "https://base.example.com", userAgent: "BASE")
-    let resolve = Config(userAgent: "RESOLVED")
-
-    let merged = MediaResolveComposer.merge(base: base, override: resolve)
-
-    #expect(merged.userAgent == "RESOLVED")
-    #expect(merged.baseUrl == "https://base.example.com")
-    #expect(merged.path == "/audio.mp3")
-  }
-
-  @Test("async resolve result merges identically once unwrapped")
-  func mergeAfterAsyncUnwrap() async throws {
-    let base = Config(path: "/audio.mp3", baseUrl: "https://base.example.com", userAgent: "BASE")
-    let resolved = try await MediaResolveComposer.unwrap(
-      .async { Config(userAgent: "RESOLVED-ASYNC") },
-    )
-
-    let merged = MediaResolveComposer.merge(base: base, override: resolved)
-
-    #expect(merged.userAgent == "RESOLVED-ASYNC")
-    #expect(merged.baseUrl == "https://base.example.com")
-    #expect(merged.path == "/audio.mp3")
-  }
-
-  @Test("absent resolve is a no-op (base is returned unchanged)")
-  func absentResolveIsNoOp() {
-    let base = Config(path: "/audio.mp3", baseUrl: "https://base.example.com", userAgent: "BASE")
-
-    // Production guards `resolve == nil` and returns base untouched; modelled as
-    // merging an all-nil override, which must leave every field intact.
-    let merged = MediaResolveComposer.merge(base: base, override: Config())
-
-    #expect(merged == base)
-  }
-
-  @Test("headers and query merge per-key with override winning")
-  func mergeDictsPerKey() {
-    let base = Config(
-      headers: ["User-Agent": "BASE", "X-Base": "1"],
-      query: ["a": "1"],
-    )
-    let resolve = Config(
-      headers: ["User-Agent": "RESOLVED", "X-Resolve": "2"],
-      query: ["b": "2"],
-    )
-
-    let merged = MediaResolveComposer.merge(base: base, override: resolve)
-
-    #expect(merged.headers == ["User-Agent": "RESOLVED", "X-Base": "1", "X-Resolve": "2"])
-    #expect(merged.query == ["a": "1", "b": "2"])
-  }
-
-  @Test("mergeDicts is nil-safe on either side")
-  func mergeDictsNilSafe() {
-    #expect(MediaResolveComposer.mergeDicts(nil, nil) == nil)
-    #expect(MediaResolveComposer.mergeDicts(["a": "1"], nil) == ["a": "1"])
-    #expect(MediaResolveComposer.mergeDicts(nil, ["b": "2"]) == ["b": "2"])
-  }
-
-  // MARK: - Run-both resolve composition
-
-  @Test("resolve composition merges async then sync (sync wins); nil when neither")
-  func composeResolved() {
-    // Same `combine` production uses (mergeRequestConfig), here over the test type.
-    let combine: (Config, Config) -> Config = { MediaResolveComposer.merge(base: $0, override: $1) }
-    #expect(MediaResolveComposer.composeResolved(async: nil, sync: nil, combine: combine) == nil)
-
-    let a = Config(baseUrl: "https://async.example.com", userAgent: "ASYNC")
-    let s = Config(userAgent: "SYNC")
-    let merged = MediaResolveComposer.composeResolved(async: a, sync: s, combine: combine)
-    #expect(merged?.userAgent == "SYNC") // sync wins
-    #expect(merged?.baseUrl == "https://async.example.com") // async's baseUrl survives
-
-    #expect(MediaResolveComposer.composeResolved(async: a, sync: nil, combine: combine)?.userAgent == "ASYNC")
-    #expect(MediaResolveComposer.composeResolved(async: nil, sync: s, combine: combine)?.userAgent == "SYNC")
-  }
-}

package/ios/Tests/OnceValueTests.swift

@@ -1,79 +0,0 @@
-import Foundation
-import Testing
-
-@testable import AudioBrowserTestable
-
-@Suite("OnceValue")
-struct OnceValueTests {
-  @Test func waitReturnsImmediatelyWhenAlreadyResolved() async {
-    let once = OnceValue<Int>()
-    once.resolve(7)
-    let value = await once.wait()
-    #expect(value == 7)
-  }
-
-  @Test func waitResumesAllWaitersOnResolve() async {
-    let once = OnceValue<String>()
-    async let first = once.wait()
-    async let second = once.wait()
-    once.resolve("ready")
-    let values = await [first, second]
-    #expect(values == ["ready", "ready"])
-  }
-
-  @Test func checkResolvesViaProvider() async {
-    nonisolated(unsafe) var ready: Int?
-    let once = OnceValue<Int> { ready }
-    once.check()
-    ready = 3
-    once.check()
-    let value = await once.wait()
-    #expect(value == 3)
-  }
-
-  @Test func firstResolveWins() async {
-    let once = OnceValue<Int>()
-    once.resolve(1)
-    once.resolve(2)
-    let value = await once.wait()
-    #expect(value == 1)
-  }
-}
-
-@Suite("OnceValue.wait(timeout:)")
-struct OnceValueTimeoutTests {
-  @Test func returnsValueWhenAlreadyResolved() async {
-    let once = OnceValue<Int>()
-    once.resolve(42)
-    let value = await once.wait(timeout: .milliseconds(50))
-    #expect(value == 42)
-  }
-
-  @Test func returnsValueWhenResolvedDuringWait() async {
-    let once = OnceValue<Int>()
-    Task {
-      try? await Task.sleep(for: .milliseconds(10))
-      once.resolve(42)
-    }
-    let value = await once.wait(timeout: .seconds(5))
-    #expect(value == 42)
-  }
-
-  @Test func returnsNilOnTimeout() async {
-    let once = OnceValue<Int>()
-    let value = await once.wait(timeout: .milliseconds(50))
-    #expect(value == nil)
-  }
-
-  @Test func lateResolveAfterTimeoutIsHarmless() async {
-    let once = OnceValue<Int>()
-    let value = await once.wait(timeout: .milliseconds(20))
-    #expect(value == nil)
-    // The timed-out waiter's continuation is still registered; resolving must
-    // not double-resume it, and fresh waits must see the value.
-    once.resolve(9)
-    try? await Task.sleep(for: .milliseconds(20))
-    let late = await once.wait(timeout: .milliseconds(50))
-    #expect(late == 9)
-  }
-}