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

package/android/src/test/java/com/audiobrowser/player/NowPlayingUpdaterTest.kt

@@ -1,442 +0,0 @@
-package com.audiobrowser.player
-
-import com.audiobrowser.TestFixtures.track
-import com.margelo.nitro.audiobrowser.FormatNowPlayingParams
-import com.margelo.nitro.audiobrowser.NowPlayingMetadata
-import com.margelo.nitro.audiobrowser.NowPlayingUpdate
-import com.margelo.nitro.audiobrowser.PlaybackError
-import com.margelo.nitro.audiobrowser.PlaybackState
-import com.margelo.nitro.audiobrowser.StallReason
-import com.margelo.nitro.audiobrowser.Track
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.test.advanceTimeBy
-import kotlinx.coroutines.test.runCurrent
-import kotlinx.coroutines.test.runTest
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-
-/**
- * Tests the Now Playing rendering pipeline through a fake [NowPlayingSurface]: the flash >
- * override > formatter > track precedence, the publish dedupe, the stale-result guards (render
- * generation + track-id keying), timed-metadata reruns, the once-per-track artwork keying, and the
- * flash revert timing — all previously untestable inside Player.kt.
- */
-class NowPlayingUpdaterTest {
-
-  private class FakeSurface : NowPlayingSurface {
-    override var currentIndex: Int? = 0
-    override var currentTrack: Track? = null
-    override var playbackState: PlaybackState = PlaybackState.PLAYING
-    override var playbackError: PlaybackError? = null
-    override var playWhenReady: Boolean = true
-    override var isRebuffering: Boolean = false
-    override var isOnline: Boolean = true
-    override var hasNowPlayingArtworkConfig: Boolean = false
-
-    data class Stamp(
-      val index: Int,
-      val trackTitle: String,
-      val title: String?,
-      val secondary: String?,
-      val album: String?,
-    )
-
-    val stamps = mutableListOf<Stamp>()
-    val artworkStamps = mutableListOf<Pair<Int, String>>()
-    val emitted = mutableListOf<NowPlayingMetadata>()
-    var artworkResolveCount = 0
-    var artworkResult: String? = null
-
-    override fun stampFields(
-      index: Int,
-      track: Track,
-      title: String?,
-      secondaryLine: String?,
-      album: String?,
-    ) {
-      stamps.add(Stamp(index, track.title, title, secondaryLine, album))
-    }
-
-    override fun stampArtwork(index: Int, track: Track, uri: String) {
-      artworkStamps.add(index to uri)
-    }
-
-    override suspend fun resolveNowPlayingArtwork(track: Track, sizePx: Double): String? {
-      artworkResolveCount += 1
-      return artworkResult
-    }
-
-    override fun emitNowPlayingChanged(metadata: NowPlayingMetadata) {
-      emitted.add(metadata)
-    }
-  }
-
-  private fun update(title: String? = null, artist: String? = null, album: String? = null) =
-    NowPlayingUpdate(title = title, artist = artist, album = album)
-
-  // MARK: precedence
-
-  @Test
-  fun `renders track fields by default`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station", artist = "Place") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-
-    updater.render()
-
-    assertEquals(listOf(FakeSurface.Stamp(0, "Station", "Station", "Place", null)), surface.stamps)
-    assertEquals(1, surface.emitted.size)
-  }
-
-  @Test
-  fun `override wins per-field over the track`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station", artist = "Place") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-
-    updater.updateNowPlaying(update(title = "Song"))
-
-    assertEquals("Song", surface.stamps.last().title)
-    assertEquals("Place", surface.stamps.last().secondary) // falls back per-field
-    assertEquals("Song", updater.getNowPlaying()?.title)
-  }
-
-  @Test
-  fun `flash outranks the override and getNowPlaying reflects it`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    updater.updateNowPlaying(update(title = "Song"))
-
-    updater.flashNowPlaying(update(title = "Premium required"), durationMs = 3000.0)
-
-    assertEquals("Premium required", surface.stamps.last().title)
-    assertEquals("Premium required", updater.getNowPlaying()?.title)
-  }
-
-  @Test
-  fun `disabled updater stamps raw track fields ignoring overrides`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station") }
-    val updater = NowPlayingUpdater(surface, backgroundScope).apply { enabled = false }
-    updater.updateNowPlaying(update(title = "Song"))
-
-    assertEquals("Station", surface.stamps.last().title)
-  }
-
-  // MARK: dedupe
-
-  @Test
-  fun `identical fields are not re-stamped`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-
-    updater.render()
-    updater.render()
-    updater.render()
-
-    assertEquals(1, surface.stamps.size)
-  }
-
-  @Test
-  fun `a new track with identical text still publishes`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Same", src = "https://s/1.mp3") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    updater.render()
-
-    surface.currentTrack = track("Same", src = "https://s/2.mp3")
-    updater.render()
-
-    assertEquals(2, surface.stamps.size)
-  }
-
-  // MARK: flash revert timing
-
-  @Test
-  fun `flash reverts after its duration and re-renders the live fields`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-
-    updater.flashNowPlaying(update(title = "Flash!"), durationMs = 300.0)
-    runCurrent()
-    assertEquals("Flash!", surface.stamps.last().title)
-
-    advanceTimeBy(301)
-    runCurrent()
-    assertEquals("Station", surface.stamps.last().title)
-    assertEquals("Station", updater.getNowPlaying()?.title)
-  }
-
-  @Test
-  fun `clearNowPlayingFlash reverts immediately`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    updater.flashNowPlaying(update(title = "Flash!"), durationMs = 60_000.0)
-    runCurrent()
-
-    updater.clearNowPlayingFlash()
-
-    assertEquals("Station", surface.stamps.last().title)
-  }
-
-  // MARK: formatter
-
-  @Test
-  fun `formatter result customizes the fields after the default stamp`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station", artist = "Place") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    updater.formatter = { update(title = "Live Song") }
-
-    updater.render()
-    runCurrent()
-
-    assertEquals(listOf("Station", "Live Song"), surface.stamps.map { it.title })
-    assertEquals("Place", surface.stamps.last().secondary) // per-field fallback
-  }
-
-  @Test
-  fun `formatter params carry surface state`() = runTest {
-    var seen: FormatNowPlayingParams? = null
-    val surface =
-      FakeSurface().apply {
-        currentTrack = track("Station")
-        playbackState = PlaybackState.BUFFERING
-        isRebuffering = true
-        playWhenReady = false
-      }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    updater.formatter = { params ->
-      seen = params
-      null
-    }
-
-    updater.render()
-    runCurrent()
-
-    assertEquals(false, seen?.playWhenReady)
-    assertEquals(StallReason.BUFFERING, seen?.stalled)
-  }
-
-  @Test
-  fun `a stall while offline is classified as offline`() = runTest {
-    var seen: FormatNowPlayingParams? = null
-    val surface =
-      FakeSurface().apply {
-        currentTrack = track("Station")
-        playbackState = PlaybackState.BUFFERING
-        isRebuffering = true
-        isOnline = false
-      }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    updater.formatter = { params ->
-      seen = params
-      null
-    }
-
-    updater.render()
-    runCurrent()
-
-    assertEquals(StallReason.OFFLINE, seen?.stalled)
-  }
-
-  @Test
-  fun `no stall when not rebuffering`() = runTest {
-    var seen: FormatNowPlayingParams? = null
-    val surface =
-      FakeSurface().apply {
-        currentTrack = track("Station")
-        playbackState = PlaybackState.PLAYING
-      }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    updater.formatter = { params ->
-      seen = params
-      null
-    }
-
-    updater.render()
-    runCurrent()
-
-    assertEquals(null, seen?.stalled)
-  }
-
-  @Test
-  fun `a stale formatter result is dropped after a newer render`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    val gate = CompletableDeferred<Unit>()
-    updater.formatter = {
-      gate.await()
-      update(title = "Stale")
-    }
-
-    updater.render() // launches the gated formatter
-    updater.flashNowPlaying(update(title = "Flash!"), durationMs = 60_000.0) // newer generation
-    runCurrent()
-    gate.complete(Unit) // stale formatter completes after the flash
-    runCurrent()
-
-    assertEquals("Flash!", surface.stamps.last().title)
-    assertTrue(surface.stamps.none { it.title == "Stale" })
-  }
-
-  @Test
-  fun `the formatter is not invoked while a flash is active`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    var invocations = 0
-    updater.formatter = {
-      invocations += 1
-      null
-    }
-    updater.flashNowPlaying(update(title = "Flash!"), durationMs = 60_000.0)
-    runCurrent()
-
-    updater.render() // e.g. a playback-state change mid-flash
-    runCurrent()
-
-    assertEquals(0, invocations)
-  }
-
-  @Test
-  fun `a formatter result for a previous track is dropped`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("A", src = "https://s/a.mp3") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    val gate = CompletableDeferred<Unit>()
-    updater.formatter = {
-      gate.await()
-      update(title = "For A")
-    }
-
-    updater.render()
-    surface.currentTrack = track("B", src = "https://s/b.mp3") // fast skip
-    gate.complete(Unit)
-    runCurrent()
-
-    assertTrue(surface.stamps.none { it.title == "For A" })
-  }
-
-  @Test
-  fun `a throwing formatter leaves the default fields`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    updater.formatter = { error("boom") }
-
-    updater.render()
-    runCurrent()
-
-    assertEquals("Station", surface.stamps.last().title)
-  }
-
-  // MARK: timed metadata
-
-  @Test
-  fun `timed metadata re-runs the formatter and clears on track change`() = runTest {
-    val surface = FakeSurface().apply { currentTrack = track("Station") }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    val seenTimed = mutableListOf<String?>()
-    updater.formatter = { params ->
-      seenTimed.add(params.timedMetadata?.title)
-      null
-    }
-    val timed =
-      com.margelo.nitro.audiobrowser.TimedMetadata(
-        title = "Song X",
-        artist = null,
-        album = null,
-        date = null,
-        genre = null,
-      )
-
-    updater.onTimedMetadataReceived(timed)
-    runCurrent()
-    assertEquals("Song X", seenTimed.last())
-
-    updater.clearOverride() // track change clears timed metadata
-    updater.render()
-    runCurrent()
-    assertNull(seenTimed.last())
-  }
-
-  // MARK: artwork keying
-
-  @Test
-  fun `artwork resolves once per track id and stamps the playing item`() = runTest {
-    val surface =
-      FakeSurface().apply {
-        currentTrack = track("Station", id = "abc")
-        hasNowPlayingArtworkConfig = true
-        artworkResult = "https://img/abc.png"
-      }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-
-    updater.render()
-    runCurrent()
-    updater.updateNowPlaying(update(title = "Song")) // re-render, same track
-    runCurrent()
-
-    assertEquals(1, surface.artworkResolveCount)
-    assertEquals(listOf(0 to "https://img/abc.png"), surface.artworkStamps)
-  }
-
-  @Test
-  fun `artwork re-resolves for a new track id and skips without an id`() = runTest {
-    val surface =
-      FakeSurface().apply {
-        currentTrack = track("A", id = "a")
-        hasNowPlayingArtworkConfig = true
-        artworkResult = "https://img/a.png"
-      }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-    updater.render()
-    runCurrent()
-
-    surface.currentTrack = track("B", id = "b", src = "https://s/b.mp3")
-    updater.render()
-    runCurrent()
-    assertEquals(2, surface.artworkResolveCount)
-
-    surface.currentTrack = track("C", id = null, src = "https://s/c.mp3")
-    updater.render()
-    runCurrent()
-    assertEquals(2, surface.artworkResolveCount) // no id → no resolve
-  }
-
-  @Test
-  fun `artwork keying resets when the config disappears so the same track re-resolves later`() =
-    runTest {
-      val surface =
-        FakeSurface().apply {
-          currentTrack = track("A", id = "a")
-          hasNowPlayingArtworkConfig = true
-          artworkResult = "https://img/a.png"
-        }
-      val updater = NowPlayingUpdater(surface, backgroundScope)
-      updater.render()
-      runCurrent()
-      assertEquals(1, surface.artworkResolveCount)
-
-      surface.hasNowPlayingArtworkConfig = false
-      updater.updateNowPlaying(update(title = "x")) // re-render without config resets the keying
-      runCurrent()
-
-      surface.hasNowPlayingArtworkConfig = true
-      updater.updateNowPlaying(update(title = "y"))
-      runCurrent()
-      assertEquals(2, surface.artworkResolveCount)
-    }
-
-  @Test
-  fun `a stale artwork result is not stamped after a track change`() = runTest {
-    val surface =
-      FakeSurface().apply {
-        currentTrack = track("A", id = "a")
-        hasNowPlayingArtworkConfig = true
-        artworkResult = "https://img/a.png"
-      }
-    val updater = NowPlayingUpdater(surface, backgroundScope)
-
-    updater.render() // schedules the artwork resolve
-    surface.currentTrack = track("B", id = "b", src = "https://s/b.mp3") // skip before it lands
-    runCurrent()
-
-    assertTrue(surface.artworkStamps.isEmpty())
-  }
-}

package/android/src/test/java/com/audiobrowser/player/PlaybackErrorClassifierTest.kt

@@ -1,190 +0,0 @@
-package com.audiobrowser.player
-
-import androidx.media3.common.PlaybackException
-import androidx.media3.datasource.DataSpec
-import androidx.media3.datasource.HttpDataSource.InvalidResponseCodeException
-import com.margelo.nitro.audiobrowser.PlaybackErrorKind
-import java.io.IOException
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-
-// Robolectric: building the DataSpec that InvalidResponseCodeException requires goes through
-// android.net.Uri, which is unimplemented on a bare JVM.
-@RunWith(RobolectricTestRunner::class)
-class PlaybackErrorClassifierTest {
-  private fun exception(errorCode: Int, cause: Throwable? = null) =
-    PlaybackException("test", cause, errorCode)
-
-  private fun httpException(responseCode: Int) =
-    InvalidResponseCodeException(
-      responseCode,
-      null,
-      IOException("bad status"),
-      emptyMap(),
-      DataSpec.Builder().setUri("https://example.test/stream").build(),
-      ByteArray(0),
-    )
-
-  // MARK: - Offline
-
-  /**
-   * ExoPlayer reports a dead radio and a dead wifi connection with the same codes, so an offline
-   * device must win over whatever the code says — this is the one classification the error itself
-   * can never carry.
-   */
-  @Test
-  fun `offline device outranks the error code`() {
-    val error = exception(PlaybackException.ERROR_CODE_IO_BAD_HTTP_STATUS, httpException(404))
-    assertEquals(PlaybackErrorKind.OFFLINE, PlaybackErrorClassifier.classify(error, online = false))
-  }
-
-  // MARK: - HTTP status
-
-  @Test
-  fun `http status is recovered from the cause chain`() {
-    val error = exception(PlaybackException.ERROR_CODE_IO_BAD_HTTP_STATUS, httpException(503))
-    assertEquals(503, PlaybackErrorClassifier.responseCode(error))
-    assertEquals(
-      PlaybackErrorKind.SERVER_ERROR,
-      PlaybackErrorClassifier.classify(error, online = true),
-    )
-  }
-
-  /** media3 nests the response exception under wrapper exceptions rather than as a direct cause. */
-  @Test
-  fun `http status is recovered when nested deeper in the chain`() {
-    val nested = IOException("loading failed", httpException(404))
-    val error = exception(PlaybackException.ERROR_CODE_IO_BAD_HTTP_STATUS, nested)
-    assertEquals(
-      PlaybackErrorKind.NOT_FOUND,
-      PlaybackErrorClassifier.classify(error, online = true),
-    )
-  }
-
-  @Test
-  fun `no response code when the failure was not an http response`() {
-    val error = exception(PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED)
-    assertNull(PlaybackErrorClassifier.responseCode(error))
-  }
-
-  @Test
-  fun `http statuses map to kinds`() {
-    val expectations =
-      listOf(
-        404 to PlaybackErrorKind.NOT_FOUND,
-        410 to PlaybackErrorKind.NOT_FOUND,
-        401 to PlaybackErrorKind.REJECTED,
-        403 to PlaybackErrorKind.REJECTED,
-        429 to PlaybackErrorKind.REJECTED,
-        500 to PlaybackErrorKind.SERVER_ERROR,
-        503 to PlaybackErrorKind.SERVER_ERROR,
-        302 to PlaybackErrorKind.UNKNOWN,
-      )
-    for ((status, expected) in expectations) {
-      assertEquals("HTTP $status", expected, PlaybackErrorClassifier.kindForHttpStatus(status))
-    }
-  }
-
-  /**
-   * A recovered status must win over the code-based mapping: `ERROR_CODE_IO_BAD_HTTP_STATUS` alone
-   * says only "non-2xx", which would land in UNKNOWN and lose the dead-station signal.
-   */
-  @Test
-  fun `recovered status outranks the error code mapping`() {
-    val error = exception(PlaybackException.ERROR_CODE_IO_BAD_HTTP_STATUS, httpException(404))
-    assertEquals(
-      PlaybackErrorKind.NOT_FOUND,
-      PlaybackErrorClassifier.classify(error, online = true),
-    )
-  }
-
-  // MARK: - Error codes
-
-  @Test
-  fun `error codes map to kinds`() {
-    val expectations =
-      listOf(
-        PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED to PlaybackErrorKind.UNREACHABLE,
-        PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_TIMEOUT to PlaybackErrorKind.UNREACHABLE,
-        PlaybackException.ERROR_CODE_TIMEOUT to PlaybackErrorKind.UNREACHABLE,
-        PlaybackException.ERROR_CODE_IO_FILE_NOT_FOUND to PlaybackErrorKind.NOT_FOUND,
-        PlaybackException.ERROR_CODE_IO_NO_PERMISSION to PlaybackErrorKind.REJECTED,
-        PlaybackException.ERROR_CODE_NOT_AVAILABLE_IN_REGION to PlaybackErrorKind.REJECTED,
-        PlaybackException.ERROR_CODE_DRM_LICENSE_ACQUISITION_FAILED to PlaybackErrorKind.REJECTED,
-        PlaybackException.ERROR_CODE_IO_INVALID_HTTP_CONTENT_TYPE to PlaybackErrorKind.UNPLAYABLE,
-        PlaybackException.ERROR_CODE_PARSING_CONTAINER_MALFORMED to PlaybackErrorKind.UNPLAYABLE,
-        PlaybackException.ERROR_CODE_DECODING_FAILED to PlaybackErrorKind.UNPLAYABLE,
-        PlaybackException.ERROR_CODE_AUDIO_TRACK_INIT_FAILED to PlaybackErrorKind.UNPLAYABLE,
-      )
-    for ((code, expected) in expectations) {
-      assertEquals(
-        "error code $code",
-        expected,
-        PlaybackErrorClassifier.classify(exception(code), online = true),
-      )
-    }
-  }
-
-  // MARK: - Retrying load errors
-
-  /**
-   * Load errors are raw IOExceptions from the transport layer; the policy only retries network
-   * ones, so the advisory classification is UNREACHABLE unless the device is offline or the server
-   * actually answered.
-   */
-  @Test
-  fun `retrying transport failure is unreachable`() {
-    val error =
-      PlaybackErrorClassifier.retryingLoadError(IOException("connection refused"), online = true)
-    assertEquals(PlaybackErrorKind.UNREACHABLE, error.kind)
-    assertEquals(true, error.retrying)
-    assertNull(error.statusCode)
-    // Stable across attempts — the raw exception message varies between retries of the
-    // same outage, which would defeat the report dedupe.
-    assertEquals("Could not reach the stream host", error.message)
-  }
-
-  @Test
-  fun `retrying offline failure is offline`() {
-    val error =
-      PlaybackErrorClassifier.retryingLoadError(IOException("connection refused"), online = false)
-    assertEquals(PlaybackErrorKind.OFFLINE, error.kind)
-    assertEquals(true, error.retrying)
-  }
-
-  /** The HTTP status is dug out of the cause chain and mapped through the shared status table. */
-  @Test
-  fun `retrying HTTP failure carries the status`() {
-    val error = PlaybackErrorClassifier.retryingLoadError(httpException(503), online = true)
-    assertEquals(PlaybackErrorKind.SERVER_ERROR, error.kind)
-    assertEquals(503.0, error.statusCode!!, 0.0)
-    assertEquals(true, error.retrying)
-    assertEquals("Server responded with HTTP 503", error.message)
-  }
-
-  /**
-   * Codes that name no cause must stay UNKNOWN. Guessing them into a friendlier bucket would put a
-   * wrong line on the listener's screen and poison the telemetry aggregates that motivated the
-   * classification in the first place.
-   */
-  @Test
-  fun `codes without evidence stay unknown`() {
-    val unevidenced =
-      listOf(
-        PlaybackException.ERROR_CODE_UNSPECIFIED,
-        PlaybackException.ERROR_CODE_IO_UNSPECIFIED,
-        PlaybackException.ERROR_CODE_REMOTE_ERROR,
-        PlaybackException.ERROR_CODE_FAILED_RUNTIME_CHECK,
-      )
-    for (code in unevidenced) {
-      assertEquals(
-        "error code $code",
-        PlaybackErrorKind.UNKNOWN,
-        PlaybackErrorClassifier.classify(exception(code), online = true),
-      )
-    }
-  }
-}