react-native-audio-browser 0.1.1 → 0.2.0-next.2

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

@@ -0,0 +1,442 @@
+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

@@ -0,0 +1,191 @@
+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),
+      )
+    }
+  }
+}