react-native-audio-browser 0.2.0-next.9 → 0.2.0

package/ios/Tests/MediaLoaderAssetOptionsTests.swift

@@ -1,46 +0,0 @@
-import Testing
-
-@testable import AudioBrowserTestable
-
-@Suite("buildAssetOptions")
-struct BuildAssetOptionsTests {
-  private func headerFields(_ options: [String: Any]?) -> [String: String]? {
-    options?["AVURLAssetHTTPHeaderFieldsKey"] as? [String: String]
-  }
-
-  @Test func userAgentOnly_setsUserAgentHeader() {
-    let options = MediaLoader.buildAssetOptions(headers: nil, userAgent: "TestAgent/1.0")
-    #expect(headerFields(options)?["User-Agent"] == "TestAgent/1.0")
-  }
-
-  @Test func userAgentMergedWithHeaders() {
-    let options = MediaLoader.buildAssetOptions(
-      headers: ["X-Test": "1"], userAgent: "TestAgent/1.0",
-    )
-    #expect(headerFields(options)?["X-Test"] == "1")
-    #expect(headerFields(options)?["User-Agent"] == "TestAgent/1.0")
-  }
-
-  @Test func explicitUserAgentHeaderWins() {
-    let options = MediaLoader.buildAssetOptions(
-      headers: ["User-Agent": "Explicit"], userAgent: "TestAgent/1.0",
-    )
-    #expect(headerFields(options)?["User-Agent"] == "Explicit")
-  }
-
-  @Test func headersOnly_nilUserAgent_keepsHeaders() {
-    let options = MediaLoader.buildAssetOptions(headers: ["X-Test": "1"], userAgent: nil)
-    #expect(headerFields(options)?["X-Test"] == "1")
-    #expect(headerFields(options)?["User-Agent"] == nil)
-  }
-
-  @Test func emptyUserAgent_notApplied() {
-    let options = MediaLoader.buildAssetOptions(headers: nil, userAgent: "")
-    #expect(options == nil)
-  }
-
-  @Test func nilUserAgentNilHeaders_returnsNil() {
-    let options = MediaLoader.buildAssetOptions(headers: nil, userAgent: nil)
-    #expect(options == nil)
-  }
-}

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)
-  }
-}

package/ios/Tests/PlaybackStateStoreTests.swift

@@ -1,48 +0,0 @@
-import Foundation
-import Testing
-
-@testable import AudioBrowserTestable
-
-@Suite("PlaybackStateStore", .serialized)
-struct PlaybackStateStoreTests {
-  private func freshDefaults() -> UserDefaults {
-    let suite = "PlaybackStateStoreTests"
-    let d = UserDefaults(suiteName: suite)!
-    d.removePersistentDomain(forName: suite)
-    return d
-  }
-
-  private func sampleTrack() -> JsonTrack {
-    JsonTrack(
-      id: "abc", url: nil, title: "Test FM", subtitle: nil, artwork: nil,
-      artist: "City, Country", albumUrl: nil, album: nil, description: nil,
-      genre: nil, duration: nil, src: "/listen/abc/channel.mp3", request: nil,
-      style: nil, childrenStyle: nil, groupTitle: nil, live: true, imageRow: nil,
-    )
-  }
-
-  @Test func roundTrip_preservesState() {
-    let store = PlaybackStateStore(defaults: freshDefaults())
-    let state = PersistedPlaybackState(
-      track: sampleTrack(), positionMs: nil, repeatMode: "off",
-      shuffleEnabled: false, playbackSpeed: 1.0,
-    )
-    store.save(state)
-    let loaded = store.load()
-    #expect(loaded?.track.src == "/listen/abc/channel.mp3")
-    #expect(loaded?.track.live == true)
-    #expect(loaded?.positionMs == nil)
-    #expect(loaded?.playbackSpeed == 1.0)
-  }
-
-  @Test func load_isNilBeforeAnySave() {
-    #expect(PlaybackStateStore(defaults: freshDefaults()).load() == nil)
-  }
-
-  @Test func clear_removesState() {
-    let store = PlaybackStateStore(defaults: freshDefaults())
-    store.save(PersistedPlaybackState(track: sampleTrack(), positionMs: 5000, repeatMode: "off", shuffleEnabled: false, playbackSpeed: 1.0))
-    store.clear()
-    #expect(store.load() == nil)
-  }
-}

package/ios/Tests/PlaybackTimerTests.swift

@@ -1,55 +0,0 @@
-import XCTest
-
-@testable import AudioBrowserTestable
-
-@MainActor
-final class PlaybackTimerTests: XCTestCase {
-  func testNoTicksUntilIntervalSetAndActive() async throws {
-    var ticks = 0
-    let timer = PlaybackTimer(isActive: { $0 == .playing }) { ticks += 1 }
-    timer.onPlaybackStateChanged(.playing) // no interval yet
-    try await Task.sleep(nanoseconds: 1_200_000_000)
-    XCTAssertEqual(ticks, 0)
-  }
-
-  func testTicksWhenIntervalSetAndActive() async throws {
-    var ticks = 0
-    let timer = PlaybackTimer(isActive: { $0 == .playing }) { ticks += 1 }
-    timer.setInterval(1)
-    timer.onPlaybackStateChanged(.playing)
-    try await Task.sleep(nanoseconds: 2_200_000_000)
-    XCTAssertGreaterThanOrEqual(ticks, 1)
-  }
-
-  func testStopsWhenStateLeavesActive() async throws {
-    var ticks = 0
-    let timer = PlaybackTimer(isActive: { $0 == .playing }) { ticks += 1 }
-    timer.setInterval(1)
-    timer.onPlaybackStateChanged(.playing)
-    timer.onPlaybackStateChanged(.paused)
-    let after = ticks
-    try await Task.sleep(nanoseconds: 1_200_000_000)
-    XCTAssertEqual(ticks, after)
-  }
-
-  func testNilIntervalStops() async throws {
-    var ticks = 0
-    let timer = PlaybackTimer(isActive: { $0 == .playing }) { ticks += 1 }
-    timer.setInterval(1)
-    timer.onPlaybackStateChanged(.playing)
-    timer.setInterval(nil) // off-switch
-    let after = ticks
-    try await Task.sleep(nanoseconds: 1_200_000_000)
-    XCTAssertEqual(ticks, after)
-  }
-
-  func testIsActivePredicateGatesState() async throws {
-    // A "playing-only" predicate must not tick while buffering.
-    var ticks = 0
-    let timer = PlaybackTimer(isActive: { $0 == .playing }) { ticks += 1 }
-    timer.setInterval(1)
-    timer.onPlaybackStateChanged(.buffering)
-    try await Task.sleep(nanoseconds: 1_200_000_000)
-    XCTAssertEqual(ticks, 0)
-  }
-}

package/ios/Tests/PlayingStateManagerTests.swift

@@ -1,57 +0,0 @@
-import Foundation
-import Testing
-
-@testable import AudioBrowserTestable
-
-@Suite("PlayingStateManager")
-struct PlayingStateManagerTests {
-  @MainActor
-  private func makeManager() -> (manager: PlayingStateManager, changes: () -> [PlayingState]) {
-    var recorded: [PlayingState] = []
-    let manager = PlayingStateManager { recorded.append($0) }
-    return (manager, { recorded })
-  }
-
-  @Test @MainActor
-  func playing_whenIntentAndActiveState() {
-    let (m, _) = makeManager()
-    m.update(playWhenReady: true, state: .playing)
-    #expect(m.playing == true)
-    #expect(m.buffering == false)
-  }
-
-  @Test @MainActor
-  func buffering_whenIntentAndLoading() {
-    let (m, _) = makeManager()
-    m.update(playWhenReady: true, state: .loading)
-    #expect(m.playing == true)
-    #expect(m.buffering == true)
-  }
-
-  @Test @MainActor
-  func notPlaying_withoutIntent() {
-    let (m, _) = makeManager()
-    m.update(playWhenReady: false, state: .playing)
-    #expect(m.playing == false)
-  }
-
-  /// Terminal states are not playable regardless of intent. .stopped was
-  /// missing from the exclusion list — masked only by stop() clearing
-  /// playWhenReady right after transitioning, which made the gap latent.
-  @Test @MainActor
-  func notPlaying_inTerminalStates_evenWithIntent() {
-    for state in [PlaybackState.none, .stopped, .ended, .error] {
-      let (m, _) = makeManager()
-      m.update(playWhenReady: true, state: state)
-      #expect(m.playing == false, "Expected not playing in \(state) despite intent")
-    }
-  }
-
-  @Test @MainActor
-  func onChange_firesOnlyOnActualChange() {
-    let (m, changes) = makeManager()
-    m.update(playWhenReady: true, state: .playing)
-    m.update(playWhenReady: true, state: .playing)
-    #expect(changes().count == 1)
-  }
-}

package/ios/Tests/RemoteCommandControllerTests.swift

@@ -1,156 +0,0 @@
-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(controller.commandTargetPointers["skipForward"] != nil)
-    #expect(controller.commandTargetPointers["skipBackward"] != nil)
-    #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(controller.commandTargetPointers["changePlaybackRate"] != nil)
-    #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(controller.commandTargetPointers["nextTrack"] == nil)
-    #expect(center.playCommand.isEnabled)
-    #expect(controller.commandTargetPointers["play"] != nil)
-  }
-
-  @Test func disableAllClearsEveryTarget() {
-    let (controller, _) = makeController()
-    let center = MPRemoteCommandCenter.shared()
-
-    controller.enable(commands: [.play, .pause, .skipForward(preferredIntervals: [15])])
-    controller.disableAll()
-
-    #expect(controller.commandTargetPointers.isEmpty)
-    #expect(!center.playCommand.isEnabled)
-    #expect(!center.pauseCommand.isEnabled)
-    #expect(!center.skipForwardCommand.isEnabled)
-  }
-
-  /// Re-enabling the same set must not accumulate handlers: `enableRemoteCommand`
-  /// removes the previous target before adding the new one.
-  @Test func reEnablingKeepsOneTargetPerCommand() {
-    let (controller, _) = makeController()
-
-    controller.enable(commands: [.play, .pause])
-    let first = controller.commandTargetPointers["play"]
-    controller.enable(commands: [.play, .pause])
-    let second = controller.commandTargetPointers["play"]
-
-    #expect(controller.commandTargetPointers.count == 2)
-    #expect(first as AnyObject? !== second as AnyObject?)
-  }
-
-  /// `setSkipAvailability` greys out next/previous when the queue has nowhere to
-  /// go, and the state must survive a later `enable(commands:)`.
-  @Test func skipAvailabilitySurvivesReEnable() {
-    let (controller, _) = makeController()
-    let center = MPRemoteCommandCenter.shared()
-
-    controller.enable(commands: [.next, .previous])
-    controller.setSkipAvailability(canNext: false, canPrevious: true)
-    #expect(!center.nextTrackCommand.isEnabled)
-    #expect(center.previousTrackCommand.isEnabled)
-
-    controller.enable(commands: [.next, .previous, .play])
-
-    #expect(!center.nextTrackCommand.isEnabled)
-    #expect(center.previousTrackCommand.isEnabled)
-  }
-
-  @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)
-    #expect(controller.commandTargetPointers["changeShuffleMode"] != nil)
-  }
-}

package/ios/Tests/RemoteCommandTests.swift

@@ -1,67 +0,0 @@
-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 used both for the diff above and for the
-  /// `commandTargetPointers` slot each command's handler lives in. Two cases
-  /// sharing a key would silently share one slot: enabling one would remove the
-  /// other's handler.
-  @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"])
-  }
-}