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

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

@@ -0,0 +1,40 @@
+package com.audiobrowser.player
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class StuckRecoveryPolicyTest {
+  @Test
+  fun `first stuck event recovers`() {
+    val p = StuckRecoveryPolicy(maxRecoveries = 3)
+    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck())
+  }
+
+  @Test
+  fun `recovers up to max then gives up`() {
+    val p = StuckRecoveryPolicy(maxRecoveries = 3)
+    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 1
+    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 2
+    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 3
+    assertEquals(StuckRecoveryPolicy.Decision.GIVE_UP, p.onStuck()) // 4 -> exhausted
+  }
+
+  @Test
+  fun `give up is sticky and does not self-refill`() {
+    val p = StuckRecoveryPolicy(maxRecoveries = 3)
+    repeat(3) { p.onStuck() }
+    assertEquals(StuckRecoveryPolicy.Decision.GIVE_UP, p.onStuck()) // 4
+    assertEquals(StuckRecoveryPolicy.Decision.GIVE_UP, p.onStuck()) // still GIVE_UP, no refill
+  }
+
+  @Test
+  fun `reset refills the budget`() {
+    val p = StuckRecoveryPolicy(maxRecoveries = 3)
+    repeat(4) { p.onStuck() } // now exhausted
+    p.reset()
+    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 1
+    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 2
+    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 3
+    assertEquals(StuckRecoveryPolicy.Decision.GIVE_UP, p.onStuck()) // 4
+  }
+}

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

@@ -0,0 +1,193 @@
+package com.audiobrowser.player
+
+import android.net.Uri
+import androidx.core.net.toUri
+import androidx.media3.common.C
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.DataSpec
+import androidx.media3.datasource.TransferListener
+import com.margelo.nitro.audiobrowser.MediaRequestConfig
+import java.io.IOException
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class TransformingDataSourceTest {
+
+  // Records the URL each upstream DataSource is actually opened with.
+  private val openedUrls = mutableListOf<String>()
+
+  // When set, the next upstream open() records its URL and then throws (simulating a failed load).
+  private var failNextOpen = false
+
+  private inner class RecordingDataSource(
+    private val responseHeaders: Map<String, List<String>> = emptyMap()
+  ) : DataSource {
+    override fun open(dataSpec: DataSpec): Long {
+      openedUrls.add(dataSpec.uri.toString())
+      if (failNextOpen) {
+        failNextOpen = false
+        throw IOException("simulated load failure")
+      }
+      return C.LENGTH_UNSET.toLong()
+    }
+
+    override fun read(buffer: ByteArray, offset: Int, length: Int): Int = C.RESULT_END_OF_INPUT
+
+    override fun addTransferListener(transferListener: TransferListener) {}
+
+    override fun getUri(): Uri? = null
+
+    override fun getResponseHeaders(): Map<String, List<String>> = responseHeaders
+
+    override fun close() {}
+  }
+
+  private val upstreamFactory = DataSource.Factory { RecordingDataSource() }
+
+  private fun config(baseUrl: String, path: String) =
+    MediaRequestConfig(
+      resolve = null,
+      resolveSync = null,
+      transform = null,
+      transformSync = null,
+      method = null,
+      path = path,
+      baseUrl = baseUrl,
+      headers = null,
+      query = null,
+      body = null,
+      contentType = null,
+      userAgent = null,
+    )
+
+  private fun tokenConfig(token: Int) =
+    MediaRequestConfig(
+      resolve = null,
+      resolveSync = null,
+      transform = null,
+      transformSync = null,
+      method = null,
+      path = "/s.mp3",
+      baseUrl = "https://cdn.example.com",
+      headers = null,
+      query = mapOf("token" to token.toString()),
+      body = null,
+      contentType = null,
+      userAgent = null,
+    )
+
+  @Test
+  fun `a failed media-url load re-resolves the url on the retry (fresh token)`() {
+    // A consumer whose transform mints a short-lived token: each resolve yields a new token. If the
+    // media-URL load fails (e.g. the token expired during a network outage), ExoPlayer's retry must
+    // re-resolve to a fresh token rather than replay the stale cached URL.
+    var resolves = 0
+    val factory = TransformingDataSource.Factory(upstreamFactory) { tokenConfig(++resolves) }
+    val spec = DataSpec("/listen/abc/channel.mp3".toUri())
+
+    // First open records token=1, then fails (simulating an expired URL).
+    failNextOpen = true
+    try {
+      factory.createDataSource().open(spec)
+    } catch (_: IOException) {}
+    // The retry re-opens the same media URL — it must re-resolve to a fresh token.
+    factory.createDataSource().open(spec)
+    // A further re-open without a failure reuses token=2 (the flag is single-shot).
+    factory.createDataSource().open(spec)
+
+    assertEquals(3, openedUrls.size)
+    assertTrue("first open uses token=1, got ${openedUrls[0]}", openedUrls[0].contains("token=1"))
+    assertTrue(
+      "retry re-resolves to token=2, got ${openedUrls[1]}",
+      openedUrls[1].contains("token=2"),
+    )
+    assertTrue(
+      "subsequent open reuses token=2, got ${openedUrls[2]}",
+      openedUrls[2].contains("token=2"),
+    )
+  }
+
+  @Test
+  fun `a failed segment load does not trigger a media re-resolve`() {
+    // A segment/key failure (a different, already-absolute URL) must not refresh the media URL: the
+    // media URL is fine, only a segment hiccuped.
+    var resolves = 0
+    val factory = TransformingDataSource.Factory(upstreamFactory) { tokenConfig(++resolves) }
+
+    val mediaUrl = "/listen/abc/playlist.m3u8".toUri()
+    factory.createDataSource().open(DataSpec(mediaUrl)) // media -> token=1
+    failNextOpen = true
+    try {
+      factory.createDataSource().open(DataSpec("https://cdn.example.com/seg-1.ts".toUri()))
+    } catch (_: IOException) {}
+    // Re-open the media URL: it must still reuse token=1 (the segment failure left it valid).
+    factory.createDataSource().open(DataSpec(mediaUrl))
+
+    assertTrue(
+      "media url stays token=1, got ${openedUrls.last()}",
+      openedUrls.last().contains("token=1"),
+    )
+  }
+
+  @Test
+  fun `re-open of the media url reuses the resolved url, not the relative original`() {
+    // radio.garden's MediaItem URI is a relative path; the transform resolves it to an absolute
+    // URL.
+    val relative = "/listen/abc/channel.mp3"
+    val factory =
+      TransformingDataSource.Factory(upstreamFactory) {
+        config("https://cdn.example.com", "/s.mp3")
+      }
+    val spec = DataSpec(relative.toUri())
+
+    // First open resolves + caches; a re-open (e.g. a retry after a network drop) opens again.
+    factory.createDataSource().open(spec)
+    factory.createDataSource().open(spec)
+
+    assertEquals(2, openedUrls.size)
+    // The regression: the re-open must NOT fall back to the schemeless relative path (which would
+    // route to FileDataSource -> FileNotFoundException). Both opens hit the resolved absolute URL.
+    assertTrue(
+      "expected absolute urls, got $openedUrls",
+      openedUrls.all { it.startsWith("https://") },
+    )
+    assertEquals(openedUrls[0], openedUrls[1])
+  }
+
+  @Test
+  fun `response headers are forwarded from the upstream source`() {
+    // ICY (Shoutcast) song metadata only works if ExoPlayer's ProgressiveMediaPeriod can read the
+    // `icy-metaint` response header back through the data-source chain. A transparent wrapper that
+    // swallows getResponseHeaders() (returning the DataSource default empty map) silently disables
+    // ICY metadata — playback still works, but onMetadata never fires.
+    val icyHeaders = mapOf("icy-metaint" to listOf("16000"), "icy-name" to listOf("Example FM"))
+    val factory =
+      TransformingDataSource.Factory({ RecordingDataSource(icyHeaders) }) {
+        config("https://cdn.example.com", "/s.mp3")
+      }
+    val source = factory.createDataSource()
+    source.open(DataSpec("/listen/abc/channel.mp3".toUri()))
+
+    assertEquals(icyHeaders, source.responseHeaders)
+  }
+
+  @Test
+  fun `absolute segment urls pass through unchanged after the media url is resolved`() {
+    val factory =
+      TransformingDataSource.Factory(upstreamFactory) {
+        config("https://cdn.example.com", "/playlist.m3u8")
+      }
+
+    // Resolve the (relative) media/playlist URL first…
+    factory.createDataSource().open(DataSpec("/listen/abc/playlist.m3u8".toUri()))
+    // …then an already-absolute segment URL must pass through untouched (only headers are reused).
+    val segment = "https://cdn.example.com/segment-1.ts"
+    factory.createDataSource().open(DataSpec(segment.toUri()))
+
+    assertEquals(segment, openedUrls.last())
+  }
+}

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

@@ -0,0 +1,153 @@
+package com.audiobrowser.tls
+
+import java.security.cert.CertPathValidator
+import java.security.cert.CertPathValidatorException
+import java.security.cert.CertificateFactory
+import java.security.cert.PKIXParameters
+import java.security.cert.TrustAnchor
+import java.security.cert.X509Certificate
+import java.util.Date
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.`when`
+
+class AiaCertChaserTest {
+
+  /** A certificate whose AIA extension value is exactly [extensionValue]. */
+  private fun certWithAia(extensionValue: ByteArray): X509Certificate =
+    mock(X509Certificate::class.java).also {
+      `when`(it.getExtensionValue("1.3.6.1.5.5.7.1.1")).thenReturn(extensionValue)
+    }
+
+  @Test(timeout = 5_000)
+  fun `a negative long-form length does not hang the parser`() {
+    // OCTET STRING { SEQUENCE { tag 0x00, long-form length 0xFFFFFFFA = -6 } }.
+    // The length's four bytes shift into a negative Int, so `pos += len` rewinds the
+    // reader by exactly the six bytes it just consumed: the tag is not a SEQUENCE, the
+    // loop `continue`s, and the reader is back where it started with more input to read.
+    val aia =
+      byteArrayOf(
+        0x04,
+        0x08,
+        0x30,
+        0x06,
+        0x00,
+        0x84.toByte(),
+        0xFF.toByte(),
+        0xFF.toByte(),
+        0xFF.toByte(),
+        0xFA.toByte(),
+      )
+
+    assertEquals(emptyList<String>(), AiaCertChaser.extractCaIssuerUrls(certWithAia(aia)))
+  }
+
+  @Test(timeout = 5_000)
+  fun `a length running past the buffer is treated as no AIA`() {
+    // SEQUENCE claiming 0x7F content bytes inside a 2-byte buffer.
+    val aia = byteArrayOf(0x04, 0x04, 0x30, 0x02, 0x30, 0x7F)
+
+    assertEquals(emptyList<String>(), AiaCertChaser.extractCaIssuerUrls(certWithAia(aia)))
+  }
+
+  @Test(timeout = 5_000)
+  fun `truncated DER is treated as no AIA`() {
+    val aia = byteArrayOf(0x04, 0x08, 0x30)
+
+    assertEquals(emptyList<String>(), AiaCertChaser.extractCaIssuerUrls(certWithAia(aia)))
+  }
+
+  @Test
+  fun `extracts CA Issuers URL from real leaf certificate AIA extension`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+
+    val urls = AiaCertChaser.extractCaIssuerUrls(leaf)
+
+    assertEquals(listOf("http://r13.i.lencr.org/"), urls)
+  }
+
+  @Test
+  fun `completeChain appends fetched intermediate when server sends leaf only`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
+    // Fetcher knows only the R13 URL (the leaf's AIA pointer); empty for the root URL.
+    val fetch = { url: String ->
+      if (url == "http://r13.i.lencr.org/") listOf(r13) else emptyList()
+    }
+
+    val completed = AiaCertChaser.completeChain(listOf(leaf), fetch = fetch)
+
+    assertEquals(listOf(leaf, r13), completed)
+  }
+
+  @Test
+  fun `completeChain selects the real issuer from a multi-certificate response`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
+    val unrelated = CertFixtures.cert("isrg-root-x1.pem") // not the leaf's issuer
+
+    // A PKCS#7-style bundle where the genuine issuer is not first must still be selected.
+    val completed =
+      AiaCertChaser.completeChain(listOf(leaf)) {
+        if (it == "http://r13.i.lencr.org/") listOf(unrelated, r13) else emptyList()
+      }
+
+    assertEquals(listOf(leaf, r13), completed)
+  }
+
+  @Test
+  fun `completeChain leaves a self-signed root untouched without fetching`() {
+    val root = CertFixtures.cert("isrg-root-x1.pem")
+    var fetches = 0
+
+    val completed =
+      AiaCertChaser.completeChain(listOf(root)) {
+        fetches++
+        emptyList()
+      }
+
+    assertEquals(listOf(root), completed)
+    assertEquals(0, fetches)
+  }
+
+  @Test
+  fun `completeChain stops when the issuer cannot be fetched`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+
+    val completed = AiaCertChaser.completeChain(listOf(leaf)) { emptyList() }
+
+    assertEquals(listOf(leaf), completed)
+  }
+
+  @Test
+  fun `AIA-completed chain forms a valid PKIX path to the trusted root`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
+    val root = CertFixtures.cert("isrg-root-x1.pem")
+    // Validate as of just after issuance so the fixtures never rot when the leaf expires.
+    val date = Date(leaf.notBefore.time + 86_400_000L)
+
+    // Reproduces the Android bug: the server-sent leaf alone has no path to the trusted root.
+    assertThrows(CertPathValidatorException::class.java) { validatePath(listOf(leaf), root, date) }
+
+    // After AIA chasing splices in R13, the chain validates to the trusted root.
+    val completed =
+      AiaCertChaser.completeChain(listOf(leaf)) {
+        if (it == "http://r13.i.lencr.org/") listOf(r13) else emptyList()
+      }
+    validatePath(completed, root, date) // must not throw
+  }
+
+  /** Validates [chain] (leaf-first, excluding the anchor) against [anchor] as of [date]. */
+  private fun validatePath(chain: List<X509Certificate>, anchor: X509Certificate, date: Date) {
+    val path = CertificateFactory.getInstance("X.509").generateCertPath(chain)
+    val params =
+      PKIXParameters(setOf(TrustAnchor(anchor, null))).apply {
+        isRevocationEnabled = false
+        this.date = date
+      }
+    CertPathValidator.getInstance("PKIX").validate(path, params)
+  }
+}

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

@@ -0,0 +1,186 @@
+package com.audiobrowser.tls
+
+import java.net.Socket
+import java.security.cert.CertificateException
+import java.security.cert.X509Certificate
+import javax.net.ssl.SSLEngine
+import javax.net.ssl.X509ExtendedTrustManager
+import javax.net.ssl.X509TrustManager
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class AiaChasingTrustManagerTest {
+
+  /** Records every chain it is asked to validate; trusts only chains of [trustsChainOfSize]. */
+  private class FakeDelegate(private val trustsChainOfSize: Int) : X509TrustManager {
+    val checkedChainSizes = mutableListOf<Int>()
+
+    override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {
+      checkedChainSizes.add(chain.size)
+      if (chain.size != trustsChainOfSize) {
+        throw CertificateException("Trust anchor for certification path not found.")
+      }
+    }
+
+    override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) = Unit
+
+    override fun getAcceptedIssuers(): Array<X509Certificate> = emptyArray()
+  }
+
+  @Test
+  fun `re-validates the AIA-completed chain when the delegate rejects the leaf-only chain`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
+    val delegate = FakeDelegate(trustsChainOfSize = 2)
+    val tm =
+      AiaChasingTrustManager(delegate) {
+        if (it == "http://r13.i.lencr.org/") listOf(r13) else emptyList()
+      }
+
+    // Must not throw: the leaf-only chain is rejected, AIA fills in R13, the [leaf, R13] chain
+    // passes.
+    tm.checkServerTrusted(arrayOf(leaf), "RSA")
+
+    assertEquals(listOf(1, 2), delegate.checkedChainSizes)
+  }
+
+  @Test
+  fun `rethrows the original failure when no intermediate can be fetched`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val delegate = FakeDelegate(trustsChainOfSize = 2)
+    val tm = AiaChasingTrustManager(delegate) { emptyList() }
+
+    assertThrows(CertificateException::class.java) { tm.checkServerTrusted(arrayOf(leaf), "RSA") }
+
+    // Only the original short chain was checked; no pointless re-validation of an unchanged chain.
+    assertEquals(listOf(1), delegate.checkedChainSizes)
+  }
+
+  @Test
+  fun `does not fetch when the delegate already trusts the presented chain`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val delegate = FakeDelegate(trustsChainOfSize = 1)
+    var fetches = 0
+    val tm =
+      AiaChasingTrustManager(delegate) {
+        fetches++
+        emptyList()
+      }
+
+    tm.checkServerTrusted(arrayOf(leaf), "RSA")
+
+    assertEquals(0, fetches)
+    assertEquals(listOf(1), delegate.checkedChainSizes)
+  }
+
+  // -- the API 24+ variant, which is what the platform actually calls into --
+
+  /**
+   * Stands in for Android's `RootTrustManager` under a per-domain network security config: the
+   * hostname-aware overloads work, and the two-argument one refuses to answer at all.
+   */
+  private class FakeDomainConfigDelegate(private val trustsChainOfSize: Int) :
+    X509ExtendedTrustManager() {
+    val hostnameAwareChecks = mutableListOf<Int>()
+
+    override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) =
+      throw CertificateException(
+        "Domain specific configurations require that hostname aware " +
+          "checkServerTrusted(X509Certificate[], String, String) is used"
+      )
+
+    override fun checkServerTrusted(
+      chain: Array<X509Certificate>,
+      authType: String,
+      socket: Socket?,
+    ) {
+      hostnameAwareChecks.add(chain.size)
+      if (chain.size != trustsChainOfSize) {
+        throw CertificateException("Trust anchor for certification path not found.")
+      }
+    }
+
+    override fun checkServerTrusted(
+      chain: Array<X509Certificate>,
+      authType: String,
+      engine: SSLEngine?,
+    ) = checkServerTrusted(chain, authType, null as Socket?)
+
+    override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) = Unit
+
+    override fun checkClientTrusted(
+      chain: Array<X509Certificate>,
+      authType: String,
+      socket: Socket?,
+    ) = Unit
+
+    override fun checkClientTrusted(
+      chain: Array<X509Certificate>,
+      authType: String,
+      engine: SSLEngine?,
+    ) = Unit
+
+    override fun getAcceptedIssuers(): Array<X509Certificate> = emptyArray()
+  }
+
+  @Test
+  fun `forwards to the hostname-aware overload the platform requires`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
+    val delegate = FakeDomainConfigDelegate(trustsChainOfSize = 2)
+    val tm =
+      AiaChasingExtendedTrustManager(delegate) {
+        if (it == "http://r13.i.lencr.org/") listOf(r13) else emptyList()
+      }
+
+    // The socket overload must reach the delegate's socket overload. Routing it through the
+    // two-argument form instead would throw the domain-config refusal, which is what a plain
+    // X509TrustManager wrapper causes for every connection in the process.
+    tm.checkServerTrusted(arrayOf(leaf), "RSA", null as Socket?)
+
+    assertEquals(listOf(1, 2), delegate.hostnameAwareChecks)
+  }
+
+  @Test
+  fun `the engine overload is hostname-aware too`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val delegate = FakeDomainConfigDelegate(trustsChainOfSize = 1)
+
+    AiaChasingExtendedTrustManager(delegate) { emptyList() }
+      .checkServerTrusted(arrayOf(leaf), "RSA", null as SSLEngine?)
+
+    assertEquals(listOf(1), delegate.hostnameAwareChecks)
+  }
+
+  @Test
+  fun `a delegate without extended overloads still works`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
+    val delegate = FakeDelegate(trustsChainOfSize = 2)
+    val tm =
+      AiaChasingExtendedTrustManager(delegate) {
+        if (it == "http://r13.i.lencr.org/") listOf(r13) else emptyList()
+      }
+
+    tm.checkServerTrusted(arrayOf(leaf), "RSA", null as Socket?)
+
+    assertEquals(listOf(1, 2), delegate.checkedChainSizes)
+  }
+
+  @Test
+  fun `the extended variant does not weaken trust`() {
+    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
+    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
+    // Trusts nothing, whatever the chain.
+    val delegate = FakeDomainConfigDelegate(trustsChainOfSize = -1)
+    val tm = AiaChasingExtendedTrustManager(delegate) { listOf(r13) }
+
+    assertThrows(CertificateException::class.java) {
+      tm.checkServerTrusted(arrayOf(leaf), "RSA", null as Socket?)
+    }
+
+    // The completed chain was offered to the delegate and refused, rather than assumed good.
+    assertEquals(listOf(1, 2), delegate.hostnameAwareChecks)
+  }
+}