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

package/android/src/test/java/com/audiobrowser/browser/BrowserManagerLayerResolutionTest.kt

@@ -0,0 +1,141 @@
+package com.audiobrowser.browser
+
+import com.margelo.nitro.audiobrowser.TransformableRequestConfig
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * Tests the request/browse layer resolution + caching introduced for resolver thunks.
+ *
+ * These tests exercise [BrowserManager.ensureLayersResolved]'s generation guard via the STATIC
+ * layer path (`config.request` / `config.browse`, with the resolver thunks null). The guard is the
+ * core of the per-content-generation caching: a static layer is resolved once and cached until the
+ * generation bumps (config-set or [BrowserManager.clearContentCache], which runs from
+ * `invalidateAllContent`), after which it is re-resolved.
+ *
+ * NOTE (gap): a test that proves a *resolver thunk* (`config.requestResolver`) is invoked exactly
+ * once per generation is not included here. The resolver returns a Nitro `Promise<Variant<...>>`,
+ * and constructing/awaiting a real Nitro `Promise` requires the JNI bridge (`Promise.initHybrid()`
+ * / `nativeResolve` are `external`), which is unavailable in a JVM/Robolectric unit test. The
+ * generation-guard logic those tests would assert (resolve-once-per-generation, re-resolve after a
+ * bump, no in-flight cache) is identical for the static and resolver paths — `resolveLayer` only
+ * differs in how it produces the `TransformableRequestConfig` — so the guard is fully covered here.
+ * The resolver-await path is covered by the TS/web-stub tests and on iOS.
+ */
+class BrowserManagerLayerResolutionTest {
+
+  private lateinit var browserManager: BrowserManager
+
+  @Before
+  fun setup() {
+    browserManager = BrowserManager()
+  }
+
+  private fun staticConfig(path: String): TransformableRequestConfig =
+    TransformableRequestConfig(
+      transform = null,
+      transformSync = null,
+      method = null,
+      path = path,
+      baseUrl = null,
+      headers = null,
+      query = null,
+      body = null,
+      contentType = null,
+      userAgent = null,
+    )
+
+  @Test
+  fun `ensureLayersResolved caches static layers and is a no-op within a generation`() = runTest {
+    val request = staticConfig("/request")
+    val browse = staticConfig("/browse")
+    browserManager.config = BrowserConfig(request = request, browse = browse)
+
+    // First resolution: nothing cached yet (resolvedLayerGeneration starts at -1).
+    val genAfterConfigSet = browserManager.layerGenerationForTest
+    assertEquals(-1, browserManager.resolvedLayerGenerationForTest)
+
+    browserManager.ensureLayersResolved()
+
+    assertEquals(genAfterConfigSet, browserManager.resolvedLayerGenerationForTest)
+    assertSame(request, browserManager.resolvedRequestLayerForTest)
+    assertSame(browse, browserManager.resolvedBrowseLayerForTest)
+
+    // Second call in the same generation is a no-op: the cached layers are untouched.
+    browserManager.ensureLayersResolved()
+    assertEquals(genAfterConfigSet, browserManager.resolvedLayerGenerationForTest)
+    assertSame(request, browserManager.resolvedRequestLayerForTest)
+  }
+
+  @Test
+  fun `clearContentCache bumps the generation so layers re-resolve`() = runTest {
+    val request1 = staticConfig("/v1")
+    browserManager.config = BrowserConfig(request = request1)
+    browserManager.ensureLayersResolved()
+    val firstGen = browserManager.resolvedLayerGenerationForTest
+    assertSame(request1, browserManager.resolvedRequestLayerForTest)
+
+    // invalidateAllContent() routes through clearContentCache(): bump the generation.
+    browserManager.clearContentCache()
+    assertEquals(firstGen + 1, browserManager.layerGenerationForTest)
+    // Cache is now stale: the resolved generation no longer matches.
+    assertEquals(firstGen, browserManager.resolvedLayerGenerationForTest)
+
+    // Swap the underlying config (the resolver/static layer can change between generations)
+    // WITHOUT bumping generation again via the setter — emulate the resolver returning a new value
+    // by re-resolving against a fresh config set, which itself bumps once.
+    val request2 = staticConfig("/v2")
+    val genBeforeSet = browserManager.layerGenerationForTest
+    browserManager.config = BrowserConfig(request = request2)
+    assertEquals(genBeforeSet + 1, browserManager.layerGenerationForTest)
+
+    browserManager.ensureLayersResolved()
+    assertEquals(
+      browserManager.layerGenerationForTest,
+      browserManager.resolvedLayerGenerationForTest,
+    )
+    assertSame(request2, browserManager.resolvedRequestLayerForTest)
+  }
+
+  @Test
+  fun `setting config bumps the generation each time`() = runTest {
+    val gen0 = browserManager.layerGenerationForTest
+    browserManager.config = BrowserConfig(request = staticConfig("/a"))
+    val gen1 = browserManager.layerGenerationForTest
+    browserManager.config = BrowserConfig(request = staticConfig("/b"))
+    val gen2 = browserManager.layerGenerationForTest
+
+    assertEquals(gen0 + 1, gen1)
+    assertEquals(gen1 + 1, gen2)
+  }
+
+  @Test
+  fun `ensureLayersResolved with no layers caches nulls but marks the generation resolved`() =
+    runTest {
+      browserManager.config = BrowserConfig()
+      browserManager.ensureLayersResolved()
+
+      assertNull(browserManager.resolvedRequestLayerForTest)
+      assertNull(browserManager.resolvedBrowseLayerForTest)
+      assertEquals(
+        browserManager.layerGenerationForTest,
+        browserManager.resolvedLayerGenerationForTest,
+      )
+    }
+
+  @Test
+  fun `only the request layer is configured`() = runTest {
+    val request = staticConfig("/only-request")
+    browserManager.config = BrowserConfig(request = request)
+    browserManager.ensureLayersResolved()
+
+    assertNotNull(browserManager.resolvedRequestLayerForTest)
+    assertSame(request, browserManager.resolvedRequestLayerForTest)
+    assertNull(browserManager.resolvedBrowseLayerForTest)
+  }
+}

package/android/src/test/java/com/audiobrowser/browser/BrowserManagerTest.kt

@@ -8,6 +8,10 @@ import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 
 // TODO: Most tests disabled — BrowserConfig API changed (routes is now Array<NativeRouteEntry>).
+// When revived, add expandQueueFromContextualUrl glue tests: found id → its
+// SectionScope section as the queue; vanished id → null (single-track
+// fallback). The section logic and the caller fallback are covered
+// (SectionScopeTest, TrackSelectorTests); the wiring between them is not.
 // Tests that used BrowserSource/BrowserList need to be rewritten.
 
 @RunWith(RobolectricTestRunner::class)

package/android/src/test/java/com/audiobrowser/browser/BrowserUrlResolutionTest.kt

@@ -0,0 +1,177 @@
+package com.audiobrowser.browser
+
+import com.audiobrowser.TestFixtures.artworkConfig
+import com.audiobrowser.TestFixtures.mediaConfig
+import com.audiobrowser.TestFixtures.track
+import com.audiobrowser.TestFixtures.transformableConfig
+import com.margelo.nitro.audiobrowser.ImageContext
+import com.margelo.nitro.audiobrowser.ImageQueryParams
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * Tests browser/BrowserUrlResolution.kt — media/artwork URL resolution owned by BrowserManager (the
+ * Kotlin analog of iOS BrowserManager+URLResolution.swift). Static configs only (Nitro Promises are
+ * JNI-backed; see file-top note in BrowserManagerLayerResolutionTest).
+ */
+class BrowserUrlResolutionTest {
+
+  private lateinit var bm: BrowserManager
+
+  @Before
+  fun setup() {
+    bm = BrowserManager()
+  }
+
+  @Test
+  fun `resolveMediaUrl returns null when neither media nor request layer is configured`() =
+    runTest {
+      bm.config = BrowserConfig()
+      assertNull(bm.resolveMediaUrl("https://cdn.example.com/a.mp3"))
+    }
+
+  @Test
+  fun `resolveMediaUrl applies the request layer to a relative src`() = runTest {
+    bm.config = BrowserConfig(request = transformableConfig(baseUrl = "https://api.example.com"))
+    val resolved = bm.resolveMediaUrl("/stream/123")
+    assertEquals("https://api.example.com", resolved?.baseUrl)
+    assertEquals("/stream/123", resolved?.path)
+  }
+
+  @Test
+  fun `resolveMediaUrl merges static media config over the request layer`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        media =
+          mediaConfig(baseUrl = "https://media.example.com", headers = mapOf("x-token" to "abc")),
+      )
+    val resolved = bm.resolveMediaUrl("/stream/123")
+    assertEquals("https://media.example.com", resolved?.baseUrl)
+    assertEquals("abc", resolved?.headers?.get("x-token"))
+    assertEquals("/stream/123", resolved?.path)
+  }
+
+  @Test
+  fun `resolveArtworkUrl returns original artwork untouched when no artwork config`() = runTest {
+    bm.config = BrowserConfig()
+    val source = bm.resolveArtworkUrl(track(artwork = "https://img.example.com/a.png"))
+    assertEquals("https://img.example.com/a.png", source?.uri)
+  }
+
+  @Test
+  fun `resolveArtworkUrl returns null when no config and no artwork`() = runTest {
+    bm.config = BrowserConfig()
+    assertNull(bm.resolveArtworkUrl(track(artwork = null)))
+  }
+
+  @Test
+  fun `resolveArtworkUrl layers request and artwork config over the track artwork`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(query = mapOf("sig" to "xyz")),
+      )
+    val source = bm.resolveArtworkUrl(track(artwork = "/art/1.png"))
+    assertEquals("https://api.example.com/art/1.png?sig=xyz", source?.uri)
+  }
+
+  @Test
+  fun `resolveArtworkUrl substitutes the id token`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(path = "/artwork/{id}"),
+      )
+    val source = bm.resolveArtworkUrl(track(artwork = null, id = "abc"))
+    assertEquals("https://api.example.com/artwork/abc", source?.uri)
+  }
+
+  @Test
+  fun `resolveArtworkUrl applies image query params from the image context`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(imageQueryParams = ImageQueryParams(width = "w", height = "h")),
+      )
+    val source =
+      bm.resolveArtworkUrl(
+        track(artwork = "/art/1.png"),
+        perRouteConfig = null,
+        imageContext = ImageContext(256.0, 256.0),
+      )
+    assertTrue(source!!.uri.contains("w=256"))
+    assertTrue(source.uri.contains("h=256"))
+  }
+
+  @Test
+  fun `displayArtworkSource re-resolves a registered uri with the display size`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(imageQueryParams = ImageQueryParams(width = "w", height = "h")),
+      )
+    val t = track(artwork = "/art/1.png")
+    val browseTime = bm.resolveArtworkUrl(t) // no size at browse time
+    bm.artworkResolutions.register(browseTime!!.uri, t, null)
+
+    val displayTime = bm.displayArtworkSource(browseTime.uri, ImageContext(512.0, 512.0))
+    assertTrue(displayTime!!.uri.contains("w=512"))
+    assertTrue(displayTime.uri.contains("h=512"))
+  }
+
+  @Test
+  fun `displayArtworkSource returns null for an unknown uri`() = runTest {
+    bm.config = BrowserConfig()
+    assertNull(bm.displayArtworkSource("https://img/unknown.png", ImageContext(512.0, 512.0)))
+  }
+
+  @Test
+  fun `displayArtworkSource entries without a per-route config use the current global config`() =
+    runTest {
+      // Register under config A (entry stores perRouteConfig = null for the global
+      // fallback) and replace the global config: display-time must resolve through
+      // the NEW config, not a pinned old one. Note the config setter clears the
+      // registry, so re-register after the swap as a browse under config B would.
+      bm.config =
+        BrowserConfig(
+          request = transformableConfig(baseUrl = "https://api.example.com"),
+          artwork = artworkConfig(query = mapOf("sig" to "old")),
+        )
+      val t = track(artwork = "/art/1.png")
+      val browseTime = bm.resolveArtworkUrl(t)!!
+
+      bm.config =
+        BrowserConfig(
+          request = transformableConfig(baseUrl = "https://api.example.com"),
+          artwork = artworkConfig(query = mapOf("sig" to "new")),
+        )
+      bm.artworkResolutions.register(browseTime.uri, t, null)
+
+      val displayTime = bm.displayArtworkSource(browseTime.uri, null)
+      assertTrue(displayTime!!.uri, displayTime.uri.contains("sig=new"))
+    }
+
+  @Test
+  fun `unattributedArtworkSource keeps the uri and adds static headers`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(headers = mapOf("x-auth" to "key")),
+        artwork = artworkConfig(headers = mapOf("x-art" to "1")),
+      )
+    val source = bm.unattributedArtworkSource("https://img.example.com/a.png?sig=1")
+    assertEquals("https://img.example.com/a.png?sig=1", source?.uri)
+    assertEquals("key", source?.headers?.get("x-auth"))
+    assertEquals("1", source?.headers?.get("x-art"))
+  }
+
+  @Test
+  fun `unattributedArtworkSource returns null when there are no static headers`() = runTest {
+    bm.config = BrowserConfig()
+    assertNull(bm.unattributedArtworkSource("https://img/x.png"))
+  }
+}

package/android/src/test/java/com/audiobrowser/browser/JsonArtworkTest.kt

@@ -0,0 +1,54 @@
+package com.audiobrowser.browser
+
+import com.margelo.nitro.audiobrowser.Variant_String_ArtworkVariants
+import kotlinx.serialization.json.Json
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class JsonArtworkTest {
+  private val json = Json { ignoreUnknownKeys = true }
+
+  @Test
+  fun `decodes a single url`() {
+    val track = json.decodeFromString<JsonTrack>("""{"title":"X","artwork":"https://e.example/a.png"}""")
+    assertEquals(
+      Variant_String_ArtworkVariants.First("https://e.example/a.png"),
+      track.toNitro().artwork,
+    )
+  }
+
+  @Test
+  fun `decodes a per-appearance pair and takes dark`() {
+    val track =
+      json.decodeFromString<JsonTrack>(
+        """{"title":"X","artwork":{"light":"https://e.example/l.png","dark":"https://e.example/d.png"}}"""
+      )
+    val artwork = track.toNitro().artwork
+    assertEquals("https://e.example/d.png", artwork?.asSecondOrNull()?.dark)
+    assertEquals("https://e.example/l.png", artwork?.asSecondOrNull()?.light)
+  }
+
+  @Test
+  fun `decodes a pair nested in children`() {
+    // The shape that shipped broken: a container decodes its children eagerly,
+    // so one unparseable row rejected the whole page rather than losing an image.
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"url":"/favorites","title":"Favorites","children":[
+          {"title":"Playlist","artwork":{"light":"https://e.example/l.png","dark":"https://e.example/d.png"}}
+        ]}"""
+      )
+    assertEquals(
+      "https://e.example/d.png",
+      resolved.toNitro().children?.first()?.artwork?.asSecondOrNull()?.dark,
+    )
+  }
+
+  @Test
+  fun `round trips both shapes`() {
+    for (artwork in listOf(JsonArtwork.Single("a.png"), JsonArtwork.Variants("l.png", "d.png"))) {
+      val encoded = json.encodeToString(JsonTrack(title = "X", artwork = artwork))
+      assertEquals(artwork, json.decodeFromString<JsonTrack>(encoded).artwork)
+    }
+  }
+}

package/android/src/test/java/com/audiobrowser/browser/SectionScopeTest.kt

@@ -0,0 +1,96 @@
+package com.audiobrowser.browser
+
+import com.audiobrowser.TestFixtures.imageRowItem
+import com.audiobrowser.TestFixtures.track
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class SectionScopeTest {
+
+  @Test
+  fun `scopes to the contiguous groupTitle run`() {
+    val children =
+      listOf(
+        track(id = "a", src = "a", groupTitle = "First"),
+        track(id = "b", src = "b", groupTitle = "First"),
+        track(id = "c", src = "c", groupTitle = "Second"),
+        track(id = "d", src = "d", groupTitle = "Second"),
+        track(id = "e", src = "e"),
+      )
+
+    val section = SectionScope.section(children, "c") as SectionScope.Section.Run
+    assertEquals(listOf("c", "d"), section.tracks.map { it.src })
+
+    val first = SectionScope.section(children, "a") as SectionScope.Section.Run
+    assertEquals(listOf("a", "b"), first.tracks.map { it.src })
+  }
+
+  @Test
+  fun `ungrouped items form their own run`() {
+    val children =
+      listOf(
+        track(src = "a", groupTitle = "First"),
+        track(src = "b"),
+        track(src = "c"),
+        track(src = "d", groupTitle = "Second"),
+      )
+
+    val section = SectionScope.section(children, "b") as SectionScope.Section.Run
+    assertEquals(listOf("b", "c"), section.tracks.map { it.src })
+  }
+
+  @Test
+  fun `identical titles in separate runs stay separate`() {
+    val children =
+      listOf(
+        track(src = "a", groupTitle = "Same"),
+        track(src = "x", groupTitle = "Other"),
+        track(src = "b", groupTitle = "Same"),
+      )
+
+    val section = SectionScope.section(children, "a") as SectionScope.Section.Run
+    assertEquals(listOf("a"), section.tracks.map { it.src })
+  }
+
+  @Test
+  fun `finds the id inside an image row`() {
+    val items = arrayOf(imageRowItem("s1"), imageRowItem("s2"))
+    val row = track(title = "Most Played", src = null, imageRow = items)
+    val children = listOf(row, track(src = "a"))
+
+    val section =
+      SectionScope.section(children, "s2") as SectionScope.Section.ImageRow
+    assertEquals(listOf("s1", "s2"), section.items.map { it.src })
+  }
+
+  @Test
+  fun `unknown id returns null`() {
+    assertNull(SectionScope.section(listOf(track(src = "a")), "zz"))
+  }
+
+  // Pins the documented precedence: sections are located by src, and an id
+  // present in both an image row and the flat list resolves to the row.
+  @Test
+  fun `image row wins over a flat-list duplicate`() {
+    val row = track(title = "Row", src = null, imageRow = arrayOf(imageRowItem("dup")))
+    val children = listOf(row, track(src = "dup"), track(src = "b"))
+
+    val section =
+      SectionScope.section(children, "dup") as SectionScope.Section.ImageRow
+    assertEquals(listOf("dup"), section.items.map { it.src })
+  }
+
+  @Test
+  fun `duplicate src across runs resolves to the earlier run`() {
+    val children =
+      listOf(
+        track(src = "dup", groupTitle = "First"),
+        track(src = "x", groupTitle = "Second"),
+        track(src = "dup", groupTitle = "Second"),
+      )
+
+    val section = SectionScope.section(children, "dup") as SectionScope.Section.Run
+    assertEquals(listOf("dup"), section.tracks.map { it.src })
+  }
+}

package/android/src/test/java/com/audiobrowser/browser/SimpleRouterTest.kt

@@ -109,8 +109,7 @@ class SimpleRouterTest {
 
   @Test
   fun `works with parameters before tail wildcard`() {
-    val result =
-      router.findBestMatch("/api/v1/users/list", mapOf("/api/{version}/**" to true))
+    val result = router.findBestMatch("/api/v1/users/list", mapOf("/api/{version}/**" to true))
     assertNotNull(result)
     assertEquals(mapOf("version" to "v1", "tail" to "users/list"), result!!.second.params)
   }

package/android/src/test/java/com/audiobrowser/http/RequestConfigBuilderTest.kt

@@ -1,5 +1,7 @@
 package com.audiobrowser.http
 
+import com.audiobrowser.TestFixtures.mediaConfig
+import com.audiobrowser.TestFixtures.transformableConfig
 import com.margelo.nitro.audiobrowser.HttpMethod
 import com.margelo.nitro.audiobrowser.RequestConfig
 import kotlinx.coroutines.test.runTest
@@ -237,4 +239,74 @@ class RequestConfigBuilderTest {
 
     assertEquals("https://api.example.com/albums", result.url) // No query string
   }
+
+  // Run-both composition: the sync/async split replaced the old ambiguous variant.
+
+  @Test
+  fun `composeResolved merges async then sync with sync winning`() {
+    val async =
+      RequestConfig(null, null, "https://async.example.com", null, null, null, null, "ASYNC")
+    val sync = RequestConfig(null, null, null, null, null, null, null, "SYNC")
+
+    val merged = RequestConfigBuilder.composeResolved(async, sync)
+
+    assertEquals("SYNC", merged?.userAgent) // sync wins
+    assertEquals("https://async.example.com", merged?.baseUrl) // async's baseUrl survives
+  }
+
+  @Test
+  fun `composeResolved returns the single present side, or null for neither`() {
+    val cfg = RequestConfig(null, null, null, null, null, null, null, "ONLY")
+
+    assertEquals("ONLY", RequestConfigBuilder.composeResolved(cfg, null)?.userAgent)
+    assertEquals("ONLY", RequestConfigBuilder.composeResolved(null, cfg)?.userAgent)
+    assertNull(RequestConfigBuilder.composeResolved(null, null))
+  }
+
+  @Test
+  fun `mergeConfig MediaRequestConfig static fields merge over base and preserve callbacks`() =
+    runTest {
+      val base =
+        RequestConfig(
+          method = null,
+          path = "/stream.mp3",
+          baseUrl = "https://media.example.com",
+          headers = mapOf("x-base" to "1"),
+          query = null,
+          body = null,
+          contentType = null,
+          userAgent = "base-ua",
+        )
+      val override = mediaConfig(headers = mapOf("x-media" to "2"), query = mapOf("token" to "abc"))
+      val merged = RequestConfigBuilder.mergeConfig(base, override)
+      assertEquals("/stream.mp3", merged.path)
+      assertEquals("https://media.example.com", merged.baseUrl)
+      assertEquals("1", merged.headers?.get("x-base"))
+      assertEquals("2", merged.headers?.get("x-media"))
+      assertEquals("abc", merged.query?.get("token"))
+      assertEquals("base-ua", merged.userAgent)
+    }
+
+  // Request-Config Layer rule (mirrors iOS applyLayer and the web stub): a
+  // layer's static `path` never overrides the base path — the path is carried
+  // from the base; only a Transform may change it.
+
+  @Test
+  fun `mergeConfig TransformableRequestConfig carries the base path over a static layer path`() =
+    runTest {
+      val base =
+        RequestConfig(null, "/navigated", "https://api.example.com", null, null, null, null, null)
+      val layer = transformableConfig(path = "/static-layer-path")
+      val merged = RequestConfigBuilder.mergeConfig(base, layer, emptyMap())
+      assertEquals("/navigated", merged.path)
+    }
+
+  @Test
+  fun `mergeConfig MediaRequestConfig carries the base path over a static media path`() = runTest {
+    val base =
+      RequestConfig(null, "/stream/123", "https://api.example.com", null, null, null, null, null)
+    val media = mediaConfig(path = "/static-media-path")
+    val merged = RequestConfigBuilder.mergeConfig(base, media)
+    assertEquals("/stream/123", merged.path)
+  }
 }