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

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

@@ -1,114 +0,0 @@
-package com.audiobrowser.browser
-
-import com.audiobrowser.TestFixtures.transformableConfig
-import kotlinx.coroutines.test.runTest
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
-import org.junit.Before
-import org.junit.Test
-
-/**
- * Tests [BrowserManager.buildApiRequest] — the single request-building path for browse and search
- * (the Kotlin port of iOS `buildApiRequest`). Static layers only: Nitro Promises
- * (transforms/resolvers) cannot be constructed on the JVM; transform semantics are covered by
- * RequestConfigBuilderTest and the Swift suite.
- */
-class BrowserManagerBuildApiRequestTest {
-
-  private lateinit var bm: BrowserManager
-
-  @Before
-  fun setup() {
-    bm = BrowserManager()
-  }
-
-  @Test
-  fun `layers apply request then kind then route, override-wins`() = runTest {
-    bm.config =
-      BrowserConfig(
-        request =
-          transformableConfig(baseUrl = "https://api.example.com", query = mapOf("a" to "request"))
-      )
-    val request =
-      bm.buildApiRequest(
-        kindConfig = transformableConfig(query = mapOf("a" to "kind", "b" to "kind")),
-        routeConfig = transformableConfig(query = mapOf("b" to "route")),
-        path = "/stations",
-        params = emptyMap(),
-      )
-    assertTrue(request.url, request.url.startsWith("https://api.example.com/stations?"))
-    assertTrue(request.url, request.url.contains("a=kind"))
-    assertTrue(request.url, request.url.contains("b=route"))
-  }
-
-  @Test
-  fun `initialQuery seeds the base so it reaches the final URL`() = runTest {
-    bm.config = BrowserConfig(request = transformableConfig(baseUrl = "https://api.example.com"))
-    val request =
-      bm.buildApiRequest(
-        kindConfig = transformableConfig(query = mapOf("extra" to "1")),
-        routeConfig = null,
-        // The caller seeds the kind's path onto the base (as search does) — a
-        // layer's own static path never applies.
-        path = "/search",
-        params = emptyMap(),
-        initialQuery = mapOf("q" to "jazz", "mode" to "genre"),
-      )
-    assertTrue(request.url, request.url.contains("q=jazz"))
-    assertTrue(request.url, request.url.contains("mode=genre"))
-    assertTrue(request.url, request.url.startsWith("https://api.example.com/search?"))
-  }
-
-  @Test
-  fun `a layer's static path does not override the base path`() = runTest {
-    // Mirrors iOS applyLayer and the web stub: the path is carried from the
-    // base through every Request-Config Layer; only a Transform may change it.
-    bm.config = BrowserConfig(request = transformableConfig(baseUrl = "https://api.example.com"))
-    val request =
-      bm.buildApiRequest(
-        kindConfig = transformableConfig(path = "/kind-path"),
-        routeConfig = transformableConfig(path = "/route-path"),
-        path = "/stations",
-        params = emptyMap(),
-      )
-    assertTrue(request.url, request.url.startsWith("https://api.example.com/stations"))
-  }
-
-  @Test
-  fun `headers merge across layers with later layers winning`() = runTest {
-    bm.config =
-      BrowserConfig(
-        request =
-          transformableConfig(
-            baseUrl = "https://api.example.com",
-            headers = mapOf("x-a" to "request", "x-b" to "request"),
-          )
-      )
-    val request =
-      bm.buildApiRequest(
-        kindConfig = transformableConfig(headers = mapOf("x-b" to "kind")),
-        routeConfig = null,
-        path = "/p",
-        params = emptyMap(),
-      )
-    assertEquals("request", request.headers?.get("x-a"))
-    assertEquals("kind", request.headers?.get("x-b"))
-  }
-
-  @Test
-  fun `missing baseUrl throws ContentNotFoundException`() = runTest {
-    bm.config = BrowserConfig(request = transformableConfig(query = mapOf("a" to "1")))
-    try {
-      bm.buildApiRequest(
-        kindConfig = null,
-        routeConfig = null,
-        path = "/nowhere",
-        params = emptyMap(),
-      )
-      fail("expected ContentNotFoundException")
-    } catch (e: ContentNotFoundException) {
-      assertEquals("/nowhere", e.path)
-    }
-  }
-}

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

@@ -1,141 +0,0 @@
-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/BrowserUrlResolutionTest.kt

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

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

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