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

package/android/src/test/java/com/audiobrowser/tls/CachingCertificateFetcherTest.kt

@@ -0,0 +1,158 @@
+package com.audiobrowser.tls
+
+import java.io.ByteArrayInputStream
+import java.io.InputStream
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class CachingCertificateFetcherTest {
+
+  @Test
+  fun `parses a DER-encoded certificate as served by the CA`() {
+    val certs =
+      CachingCertificateFetcher.parseCertificates(CertFixtures.bytes("letsencrypt-r13.der"))
+
+    assertEquals(1, certs.size)
+    assertEquals("CN=R13,O=Let's Encrypt,C=US", certs.first().subjectX500Principal.name)
+  }
+
+  @Test
+  fun `returns empty for bytes that are not a certificate`() {
+    assertTrue(
+      CachingCertificateFetcher.parseCertificates("not a certificate".toByteArray()).isEmpty()
+    )
+  }
+
+  // -- raw HTTP/1.0 response parsing (the http AIA fetch reads to EOF, then parses) --
+
+  @Test
+  fun `extracts status and body from a content-length response`() {
+    val body = byteArrayOf(0xDE.toByte(), 0xAD.toByte(), 0xBE.toByte(), 0xEF.toByte())
+    val raw =
+      "HTTP/1.1 200 OK\r\nContent-Type: application/pkix-cert\r\nContent-Length: 4\r\n\r\n"
+        .toByteArray(Charsets.ISO_8859_1) + body
+
+    val response = CachingCertificateFetcher.parseHttpResponse(raw)!!
+
+    assertEquals(200, response.status)
+    assertNull(response.location)
+    assertArrayEquals(body, response.body)
+  }
+
+  @Test
+  fun `decodes a chunked body`() {
+    // "DEAD" + "BEEF" split across two chunks, terminated by a zero-length chunk.
+    val raw =
+      ("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" +
+          "4\r\nDEAD\r\n4\r\nBEEF\r\n0\r\n\r\n")
+        .toByteArray(Charsets.ISO_8859_1)
+
+    val response = CachingCertificateFetcher.parseHttpResponse(raw)!!
+
+    assertEquals(200, response.status)
+    assertArrayEquals("DEADBEEF".toByteArray(Charsets.ISO_8859_1), response.body)
+  }
+
+  @Test
+  fun `surfaces the redirect location for a 3xx response`() {
+    val raw =
+      "HTTP/1.1 301 Moved Permanently\r\nLocation: https://ca.example/issuer.crt\r\n\r\n"
+        .toByteArray(Charsets.ISO_8859_1)
+
+    val response = CachingCertificateFetcher.parseHttpResponse(raw)!!
+
+    assertEquals(301, response.status)
+    assertEquals("https://ca.example/issuer.crt", response.location)
+  }
+
+  @Test
+  fun `returns null when the bytes are not an HTTP response`() {
+    assertNull(
+      CachingCertificateFetcher.parseHttpResponse("garbage without a header break".toByteArray())
+    )
+  }
+
+  // -- response cap (the AIA URL, so the host serving it, comes from the presented cert) --
+
+  // -- URL validation (the AIA URL is attacker-supplied text from the presented cert) --
+
+  @Test
+  fun `accepts the URL form CAs actually serve`() {
+    assertTrue(CachingCertificateFetcher.isSafeUrl("http://r13.i.lencr.org/"))
+    assertTrue(CachingCertificateFetcher.isSafeUrl("http://ca.example:8080/issuer.crt?v=2"))
+  }
+
+  @Test
+  fun `rejects a URL carrying CRLF, which would inject request lines`() {
+    // java.net.URL keeps the CRLF in `file`, and the cleartext fetch writes `file` straight
+    // into "GET $path HTTP/1.0\r\n" on a raw socket.
+    assertTrue(!CachingCertificateFetcher.isSafeUrl("http://127.0.0.1:6379/\r\nSET foo bar\r\n"))
+    assertTrue(!CachingCertificateFetcher.isSafeUrl("http://ca.example/a\nX-Injected: 1"))
+  }
+
+  @Test
+  fun `rejects a URL carrying a space, which would split the request line`() {
+    assertTrue(!CachingCertificateFetcher.isSafeUrl("http://ca.example/a b"))
+  }
+
+  @Test
+  fun `reads a response that fits within the cap`() {
+    val body = ByteArray(64) { it.toByte() }
+
+    assertArrayEquals(
+      body,
+      CachingCertificateFetcher.readCapped(ByteArrayInputStream(body), limit = 128),
+    )
+  }
+
+  @Test
+  fun `returns null for a response that exceeds the cap`() {
+    val body = ByteArray(129)
+
+    assertNull(CachingCertificateFetcher.readCapped(ByteArrayInputStream(body), limit = 128))
+  }
+
+  @Test
+  fun `a stream that never ends does not read without bound`() {
+    // Endless: read() always fills the buffer and never signals EOF, the shape a slow-drip
+    // server takes — the per-read timeout never fires because every read succeeds.
+    val endless =
+      object : InputStream() {
+        override fun read() = 0
+
+        override fun read(b: ByteArray, off: Int, len: Int): Int = len
+      }
+
+    assertNull(CachingCertificateFetcher.readCapped(endless, limit = 1 shl 16))
+  }
+
+  @Test
+  fun `a slow drip is cut off by the deadline, not left to exhaust the byte cap`() {
+    // One byte per read, each one landing just inside the socket's read timeout: the byte cap
+    // alone would let this run for a million reads. The clock advances 1s per read, so the
+    // 10s budget must end it after ~10 — far short of the 1 MiB cap.
+    var reads = 0
+    val drip =
+      object : InputStream() {
+        override fun read() = 0
+
+        override fun read(b: ByteArray, off: Int, len: Int): Int {
+          reads++
+          return 1
+        }
+      }
+    var nanos = 0L
+
+    val result =
+      CachingCertificateFetcher.readCapped(drip, budgetMs = 10_000) {
+        nanos += 1_000_000_000
+        nanos
+      }
+
+    assertNull(result)
+    assertTrue("gave up after $reads reads", reads < 20)
+  }
+}

package/android/src/test/java/com/audiobrowser/tls/CertFixtures.kt

@@ -0,0 +1,18 @@
+package com.audiobrowser.tls
+
+import java.security.cert.CertificateFactory
+import java.security.cert.X509Certificate
+
+/** Loads certificate fixtures from `src/test/resources/certs`. */
+object CertFixtures {
+  fun bytes(resource: String): ByteArray =
+    checkNotNull(CertFixtures::class.java.getResourceAsStream("/certs/$resource")) {
+        "Missing test fixture: /certs/$resource"
+      }
+      .use { it.readBytes() }
+
+  fun cert(resource: String): X509Certificate =
+    bytes(resource).inputStream().use {
+      CertificateFactory.getInstance("X.509").generateCertificate(it) as X509Certificate
+    }
+}

package/android/src/test/java/com/audiobrowser/util/ArtworkContentProviderTest.kt

@@ -0,0 +1,163 @@
+package com.audiobrowser.util
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import com.audiobrowser.browser.BrowseArtworkRegistry
+import com.audiobrowser.browser.ResolvedArtwork
+import java.io.File
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class ArtworkContentProviderTest {
+  private lateinit var provider: ArtworkContentProvider
+  private lateinit var registry: BrowseArtworkRegistry
+
+  @Before
+  fun setUp() {
+    provider = Robolectric.setupContentProvider(ArtworkContentProvider::class.java)
+    registry = BrowseArtworkRegistry()
+    val context = RuntimeEnvironment.getApplication()
+
+    // Delete on-disk cache so tests don't bleed into each other via cached files.
+    File(context.cacheDir, ArtworkContentProvider.ARTWORK_SUBDIR).deleteRecursively()
+
+    val fakeBitmap = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888)
+    val loader = CoilArtworkLoader(context, FakeImageLoader(context, fakeBitmap) {})
+    CoilArtworkLoaderHolder.set(
+      ArtworkProviderDeps(loader, registry, CoroutineScope(Dispatchers.IO))
+    )
+  }
+
+  @After
+  fun tearDown() {
+    CoilArtworkLoaderHolder.get()?.let { CoilArtworkLoaderHolder.clearIf(it) }
+    // Clean up any files written during the test.
+    val context = RuntimeEnvironment.getApplication()
+    File(context.cacheDir, ArtworkContentProvider.ARTWORK_SUBDIR).deleteRecursively()
+  }
+
+  private fun uri(token: String) =
+    Uri.parse(ArtworkUris.contentUri(ArtworkUris.authorityFor("com.test"), token))
+
+  @Test
+  fun `getType is png`() {
+    assertEquals("image/png", provider.getType(uri("anything")))
+  }
+
+  @Test
+  fun `openFile returns a readable PNG for a registered http token`() {
+    val token = ArtworkUris.tokenFor("https://cdn/a.png")
+    registry.register(token, ResolvedArtwork("https://cdn/a.png", null, isSvg = false))
+    val pfd = provider.openFile(uri(token), "r")
+    assertNotNull(pfd)
+    val bytes = java.io.FileInputStream(pfd!!.fileDescriptor).readBytes()
+    assertNotNull(BitmapFactory.decodeByteArray(bytes, 0, bytes.size)) // valid image
+  }
+
+  // Prove E-mitigation: file FD has a real stat size (non-negative); a pipe FD would return -1.
+  @Test
+  fun `openFile returns a file-backed seekable FD (statSize non-negative)`() {
+    val token = ArtworkUris.tokenFor("https://cdn/seekable.png")
+    registry.register(token, ResolvedArtwork("https://cdn/seekable.png", null, isSvg = false))
+    val pfd = provider.openFile(uri(token), "r")
+    assertNotNull(pfd)
+    assertTrue("Expected statSize >= 0 for a file FD, got ${pfd!!.statSize}", pfd.statSize >= 0)
+  }
+
+  @Test
+  fun `openFile returns null for an unknown token`() {
+    assertNull(provider.openFile(uri("nope"), "r"))
+  }
+
+  @Test
+  fun `openFile returns null for a non-http registered url`() {
+    val token = ArtworkUris.tokenFor("android.resource://com.test/drawable/ic")
+    registry.register(
+      token,
+      ResolvedArtwork("android.resource://com.test/drawable/ic", null, false),
+    )
+    assertNull(provider.openFile(uri(token), "r"))
+  }
+
+  @Test
+  fun `openFile returns null when holder absent`() {
+    CoilArtworkLoaderHolder.get()?.let { CoilArtworkLoaderHolder.clearIf(it) }
+    val token = ArtworkUris.tokenFor("https://cdn/a.png")
+    registry.register(token, ResolvedArtwork("https://cdn/a.png", null, false))
+    assertNull(provider.openFile(uri(token), "r"))
+  }
+
+  // Fix 2: artwork dir must not grow beyond MAX_CACHE_FILES after producing many distinct tokens.
+  // We override the cap to 5 so the test stays fast (rather than producing 512+ real files).
+  @Test
+  fun `openFile prunes cache to MAX_CACHE_FILES after producing excess entries`() {
+    val testCap = 5
+    ArtworkContentProvider.maxCacheFilesOverride = testCap
+    try {
+      val context = RuntimeEnvironment.getApplication()
+      val artworkDir = File(context.cacheDir, ArtworkContentProvider.ARTWORK_SUBDIR)
+      val produce = testCap + 3 // 8 entries total; should be pruned back to 5
+      repeat(produce) { i ->
+        val url = "https://cdn/prune-$i.png"
+        val token = ArtworkUris.tokenFor(url)
+        registry.register(token, ResolvedArtwork(url, null, isSvg = false))
+        provider.openFile(uri(token), "r")
+      }
+      val pngCount = artworkDir.listFiles { f -> f.isFile && f.name.endsWith(".png") }?.size ?: 0
+      assertTrue(
+        "Expected at most $testCap .png files after producing $produce; got $pngCount",
+        pngCount <= testCap,
+      )
+    } finally {
+      ArtworkContentProvider.maxCacheFilesOverride = null
+    }
+  }
+
+  // Prove D-fix: two openFile calls for the same token → loadCount == 1.
+  // The second call is served from the on-disk file without re-decoding.
+  @Test
+  fun `openFile serves second request from disk cache without re-decoding`() {
+    var loadCount = 0
+    val context = RuntimeEnvironment.getApplication()
+    val fakeBitmap = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888)
+    val countingLoader =
+      CoilArtworkLoader(context, FakeImageLoader(context, fakeBitmap) { loadCount++ })
+    CoilArtworkLoaderHolder.set(
+      ArtworkProviderDeps(countingLoader, registry, CoroutineScope(Dispatchers.IO))
+    )
+
+    val token = ArtworkUris.tokenFor("https://cdn/b.png")
+    registry.register(token, ResolvedArtwork("https://cdn/b.png", null, isSvg = false))
+
+    // First call — decode + write to disk.
+    val pfd1 = provider.openFile(uri(token), "r")
+    assertNotNull(pfd1)
+    val bytes1 = java.io.FileInputStream(pfd1!!.fileDescriptor).readBytes()
+    assertNotNull(BitmapFactory.decodeByteArray(bytes1, 0, bytes1.size))
+
+    // Second call — must come from disk, no second decode.
+    val pfd2 = provider.openFile(uri(token), "r")
+    assertNotNull(pfd2)
+    val bytes2 = java.io.FileInputStream(pfd2!!.fileDescriptor).readBytes()
+    assertNotNull(BitmapFactory.decodeByteArray(bytes2, 0, bytes2.size))
+
+    assertEquals(
+      "Expected exactly one decode; second call should be served from disk",
+      1,
+      loadCount,
+    )
+  }
+}

package/android/src/test/java/com/audiobrowser/util/ArtworkUrisTest.kt

@@ -0,0 +1,34 @@
+package com.audiobrowser.util
+
+import android.net.Uri
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class ArtworkUrisTest {
+  @Test
+  fun `tokenFor is deterministic and opaque`() {
+    val url = "https://cdn.example.com/a.png?sig=abc&x=1"
+    assertEquals(ArtworkUris.tokenFor(url), ArtworkUris.tokenFor(url))
+    // token does not leak the url
+    assert(!ArtworkUris.tokenFor(url).contains("cdn.example.com"))
+  }
+
+  @Test
+  fun `contentUri round-trips through parseToken`() {
+    val authority = ArtworkUris.authorityFor("com.myapp")
+    val token = ArtworkUris.tokenFor("https://cdn.example.com/a.svg")
+    val uri = ArtworkUris.contentUri(authority, token)
+    assertEquals("content://com.myapp.audiobrowser.artwork/art/$token", uri)
+    assertEquals(token, ArtworkUris.parseToken(Uri.parse(uri)))
+  }
+
+  @Test
+  fun `parseToken rejects malformed uris`() {
+    assertNull(ArtworkUris.parseToken(Uri.parse("content://com.myapp.audiobrowser.artwork/nope")))
+    assertNull(ArtworkUris.parseToken(Uri.parse("https://example.com/art/x")))
+  }
+}

package/android/src/test/java/com/audiobrowser/util/BrowserPathHelperTest.kt

@@ -0,0 +1,28 @@
+package com.audiobrowser.util
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BrowserPathHelperTest {
+
+  @Test
+  fun `containsSegment matches a uid as a full path segment`() {
+    val path = "/listen/amsterdam-funk-channel/Gw0LGB8j"
+    assertTrue(BrowserPathHelper.containsSegment(path, "Gw0LGB8j"))
+    assertTrue(BrowserPathHelper.containsSegment(path, "amsterdam-funk-channel"))
+    assertTrue(BrowserPathHelper.containsSegment(path, "listen"))
+    assertTrue(BrowserPathHelper.containsSegment("/listen/x/Gw0LGB8j?hl=en", "Gw0LGB8j"))
+    assertTrue(BrowserPathHelper.containsSegment("/listen/x/Gw0LGB8j#frag", "Gw0LGB8j"))
+  }
+
+  @Test
+  fun `containsSegment rejects partial-segment and missing matches`() {
+    val path = "/listen/amsterdam-funk-channel/Gw0LGB8j"
+    assertFalse(BrowserPathHelper.containsSegment(path, "Gw0LGB8"))
+    assertFalse(BrowserPathHelper.containsSegment(path, "funk"))
+    assertFalse(BrowserPathHelper.containsSegment(path, "msterdam-funk-channe"))
+    assertFalse(BrowserPathHelper.containsSegment(path, "NopeNope"))
+    assertFalse(BrowserPathHelper.containsSegment(path, ""))
+  }
+}

package/android/src/test/java/com/audiobrowser/util/CoilArtworkLoaderHolderTest.kt

@@ -0,0 +1,53 @@
+package com.audiobrowser.util
+
+import android.graphics.Bitmap
+import com.audiobrowser.browser.BrowseArtworkRegistry
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import org.junit.After
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class CoilArtworkLoaderHolderTest {
+  private fun deps() =
+    ArtworkProviderDeps(
+      loader =
+        CoilArtworkLoader(
+          RuntimeEnvironment.getApplication(),
+          FakeImageLoader(
+            RuntimeEnvironment.getApplication(),
+            Bitmap.createBitmap(1, 1, Bitmap.Config.RGB_565),
+          ) {},
+        ),
+      registry = BrowseArtworkRegistry(),
+      scope = CoroutineScope(Dispatchers.Unconfined),
+    )
+
+  @After
+  fun tearDown() =
+    CoilArtworkLoaderHolder.get()?.let { CoilArtworkLoaderHolder.clearIf(it) } ?: Unit
+
+  @Test
+  fun `get returns what was set`() {
+    val d = deps()
+    CoilArtworkLoaderHolder.set(d)
+    assertSame(d, CoilArtworkLoaderHolder.get())
+  }
+
+  @Test
+  fun `clearIf only clears the matching instance`() {
+    val first = deps()
+    val second = deps()
+    CoilArtworkLoaderHolder.set(first)
+    CoilArtworkLoaderHolder.set(second)
+    CoilArtworkLoaderHolder.clearIf(first) // stale instance — must NOT clear
+    assertSame(second, CoilArtworkLoaderHolder.get())
+    CoilArtworkLoaderHolder.clearIf(second)
+    assertNull(CoilArtworkLoaderHolder.get())
+  }
+}

package/android/src/test/java/com/audiobrowser/util/CoilArtworkLoaderTest.kt

@@ -0,0 +1,58 @@
+package com.audiobrowser.util
+
+import android.graphics.Bitmap
+import coil3.network.httpHeaders
+import coil3.request.ImageRequest
+import coil3.size.Dimension
+import coil3.size.Size
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class CoilArtworkLoaderTest {
+  @Test
+  fun `load applies size hint and headers to the request`() = runTest {
+    val context = RuntimeEnvironment.getApplication()
+    var captured: ImageRequest? = null
+    val fakeBitmap = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888)
+    // FakeImageLoader records the request and returns a known bitmap.
+    val imageLoader = FakeImageLoader(context, fakeBitmap) { captured = it }
+
+    val loader = CoilArtworkLoader(context, imageLoader, defaultSizePixels = 512)
+    val bmp =
+      loader.load(
+        finalUrl = "https://cdn.example.com/a.png",
+        headers = mapOf("Authorization" to "Bearer t"),
+        sizeHintPixels = 256,
+        isSvg = false,
+      )
+
+    assertEquals(fakeBitmap, bmp)
+    assertNotNull(captured)
+    // data is the finalUrl
+    assertEquals("https://cdn.example.com/a.png", captured!!.data)
+    // OOM-prevention downsample: .size(256) must have been applied
+    assertEquals(Size(Dimension.Pixels(256), Dimension.Pixels(256)), captured!!.sizeResolver.size())
+    // Custom headers must reach the request via httpHeaders extras
+    assertEquals("Bearer t", captured!!.httpHeaders["Authorization"])
+  }
+
+  @Test
+  fun `load falls back to default size when hint is null`() = runTest {
+    val context = RuntimeEnvironment.getApplication()
+    var captured: ImageRequest? = null
+    val fakeBitmap = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888)
+    val imageLoader = FakeImageLoader(context, fakeBitmap) { captured = it }
+    val loader = CoilArtworkLoader(context, imageLoader, defaultSizePixels = 512)
+    val bmp = loader.load("https://cdn.example.com/a.png", null, null, false)
+    assertEquals(fakeBitmap, bmp)
+    assertNotNull(captured)
+    // When sizeHintPixels is null, defaultSizePixels (512) must be used
+    assertEquals(Size(Dimension.Pixels(512), Dimension.Pixels(512)), captured!!.sizeResolver.size())
+  }
+}

package/android/src/test/java/com/audiobrowser/util/FakeImageLoader.kt

@@ -0,0 +1,57 @@
+package com.audiobrowser.util
+
+import android.content.Context
+import android.graphics.Bitmap
+import coil3.ComponentRegistry
+import coil3.ImageLoader
+import coil3.asImage
+import coil3.disk.DiskCache
+import coil3.memory.MemoryCache
+import coil3.request.Disposable
+import coil3.request.ImageRequest
+import coil3.request.ImageResult
+import coil3.request.SuccessResult
+import kotlinx.coroutines.CompletableDeferred
+
+/**
+ * Minimal [ImageLoader] test double. Records each executed [ImageRequest] via [onRequest] and
+ * returns a [SuccessResult] wrapping [fakeBitmap].
+ */
+class FakeImageLoader(
+  private val context: Context,
+  private val fakeBitmap: Bitmap,
+  private val onRequest: (ImageRequest) -> Unit,
+) : ImageLoader {
+
+  override val defaults: ImageRequest.Defaults = ImageRequest.Defaults.DEFAULT
+
+  override val components: ComponentRegistry = ComponentRegistry()
+
+  override val memoryCache: MemoryCache? = null
+
+  override val diskCache: DiskCache? = null
+
+  override suspend fun execute(request: ImageRequest): ImageResult {
+    onRequest(request)
+    return SuccessResult(image = fakeBitmap.asImage(), request = request)
+  }
+
+  override fun enqueue(request: ImageRequest): Disposable {
+    val deferred =
+      CompletableDeferred<ImageResult>(
+        SuccessResult(image = fakeBitmap.asImage(), request = request)
+      )
+    return object : Disposable {
+      override val isDisposed: Boolean
+        get() = true
+
+      override fun dispose() {}
+
+      override val job = deferred
+    }
+  }
+
+  override fun shutdown() {}
+
+  override fun newBuilder(): ImageLoader.Builder = ImageLoader.Builder(context)
+}

package/android/src/test/java/com/audiobrowser/util/PlayingStateFactoryTest.kt

@@ -0,0 +1,40 @@
+package com.audiobrowser.util
+
+import com.margelo.nitro.audiobrowser.PlaybackState
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Truth table for the PlayingState derivation — the single transition function behind
+ * `onPlaybackPlayingState` (see Player.refreshPlayingState, its only production caller path).
+ */
+class PlayingStateFactoryTest {
+
+  @Test
+  fun `playWhenReady false is never playing nor buffering`() {
+    for (state in PlaybackState.entries) {
+      val derived = PlayingStateFactory.derive(playWhenReady = false, playbackState = state)
+      assertEquals("playing for $state", false, derived.playing)
+      assertEquals("buffering for $state", false, derived.buffering)
+    }
+  }
+
+  @Test
+  fun `playWhenReady true plays except in terminal or empty states`() {
+    val notPlaying =
+      setOf(PlaybackState.ERROR, PlaybackState.ENDED, PlaybackState.NONE, PlaybackState.STOPPED)
+    for (state in PlaybackState.entries) {
+      val derived = PlayingStateFactory.derive(playWhenReady = true, playbackState = state)
+      assertEquals("playing for $state", state !in notPlaying, derived.playing)
+    }
+  }
+
+  @Test
+  fun `buffering only while loading or rebuffering with playWhenReady`() {
+    val buffering = setOf(PlaybackState.LOADING, PlaybackState.BUFFERING)
+    for (state in PlaybackState.entries) {
+      val derived = PlayingStateFactory.derive(playWhenReady = true, playbackState = state)
+      assertEquals("buffering for $state", state in buffering, derived.buffering)
+    }
+  }
+}

package/android/src/test/java/com/audiobrowser/util/RatingFavoritesTest.kt

@@ -0,0 +1,34 @@
+package com.audiobrowser.util
+
+import androidx.media3.common.HeartRating
+import androidx.media3.common.StarRating
+import androidx.media3.common.ThumbRating
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class RatingFavoritesTest {
+  @Test
+  fun `rated heart up maps to favorited true`() {
+    assertEquals(true, RatingFavorites.favoritedFor(HeartRating(true)))
+  }
+
+  @Test
+  fun `rated heart down maps to favorited false`() {
+    assertEquals(false, RatingFavorites.favoritedFor(HeartRating(false)))
+  }
+
+  @Test
+  fun `unrated heart carries no favorite intent`() {
+    assertNull(RatingFavorites.favoritedFor(HeartRating()))
+  }
+
+  @Test
+  fun `non-heart ratings carry no favorite intent`() {
+    assertNull(RatingFavorites.favoritedFor(ThumbRating(true)))
+    assertNull(RatingFavorites.favoritedFor(StarRating(5, 4f)))
+  }
+}