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

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

@@ -1,19 +1,34 @@
 package com.audiobrowser.browser
 
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import com.audiobrowser.TestFixtures.resolvedTrack
+import com.audiobrowser.TestFixtures.section
+import com.audiobrowser.TestFixtures.staticRoute
+import com.audiobrowser.TestFixtures.track
+import com.audiobrowser.util.BrowserPathHelper
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert.*
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.fail
 import org.junit.Before
 import org.junit.Test
 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.
-
+/**
+ * Navigation and queue-expansion glue.
+ *
+ * [BrowserManager.expandQueueFromContextualPath] is the seam between the page a listener tapped in
+ * and the queue that starts playing. Its two halves are covered on their own — the section logic in
+ * [SectionScopeTest], the caller's single-track fallback in the player tests — but the wiring
+ * between them is what decides whether tapping row 3 of a page resumes the right station, and only
+ * these tests exercise it.
+ *
+ * Routes serve `browseStatic`, the one browse arm that needs neither the JNI bridge nor HTTP.
+ * Robolectric is required for `android.net.Uri` (contextual-path parsing) and
+ * `android.util.LruCache` (the content cache).
+ */
 @RunWith(RobolectricTestRunner::class)
 class BrowserManagerTest {
 
@@ -24,6 +39,31 @@ class BrowserManagerTest {
     browserManager = BrowserManager()
   }
 
+  /** Configures a single static route at [path] serving [children] as its page. */
+  private fun servePage(
+    path: String,
+    vararg children: com.margelo.nitro.audiobrowser.Track,
+    singleTrack: Boolean = false,
+  ) {
+    browserManager.config =
+      BrowserConfig(
+        routes =
+          arrayOf(staticRoute(path, resolvedTrack(path = path, children = arrayOf(*children)))),
+        singleTrack = singleTrack,
+      )
+  }
+
+  /** Configures a single static route at [path] serving [sections] as its page. */
+  private fun serveSections(path: String, vararg sections: com.margelo.nitro.audiobrowser.Section) {
+    browserManager.config =
+      BrowserConfig(
+        routes =
+          arrayOf(staticRoute(path, resolvedTrack(path = path, sections = arrayOf(*sections))))
+      )
+  }
+
+  private fun contextual(path: String, trackId: String) = BrowserPathHelper.build(path, trackId)
+
   @Test
   fun `getPath returns default path initially`() {
     assertEquals("/", browserManager.getPath())
@@ -64,4 +104,301 @@ class BrowserManagerTest {
       } catch (_: ContentNotFoundException) {}
     }
   }
+
+  @Test
+  fun `navigate serves a static route and gives playable children contextual urls`() = runBlocking {
+    servePage("/library", track(src = "a", title = "A"), track(src = "b", title = "B"))
+
+    val resolved = browserManager.navigate("/library")
+
+    assertEquals(listOf("A", "B"), resolved.flattenedChildren?.map { it.title })
+    // The tap target: a child's path is rewritten to point back at this page
+    // plus its own id and page position (the duplicate-identity tie-breaker).
+    assertEquals(
+      listOf(
+        BrowserPathHelper.build("/library", "a", 0),
+        BrowserPathHelper.build("/library", "b", 1),
+      ),
+      resolved.flattenedChildren?.map { it.path },
+    )
+    assertEquals("/library", browserManager.getPath())
+  }
+
+  // MARK: - expandQueueFromContextualPath
+
+  @Test
+  fun `expandQueueFromContextualPath scopes the queue to the tapped section`() = runBlocking {
+    serveSections(
+      "/home",
+      section(title = "Recent", children = arrayOf(track(src = "a"), track(src = "b"))),
+      section(title = "Popular", children = arrayOf(track(src = "c"), track(src = "d"))),
+    )
+
+    val expanded = browserManager.expandQueueFromContextualPath(contextual("/home", "c"))
+
+    // "Popular" only — a page aggregating sections must not leak next/previous across them.
+    val (queue, index) = requireNotNull(expanded)
+    assertEquals(listOf("c", "d"), queue.map { it.src })
+    assertEquals(0, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath indexes the tapped track within its section`() = runBlocking {
+    serveSections(
+      "/home",
+      section(title = "Recent", children = arrayOf(track(src = "a"))),
+      section(title = "Popular", children = arrayOf(track(src = "b"), track(src = "c"))),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "c")))
+
+    assertEquals(listOf("b", "c"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath pins the tapped copy of a duplicate identity`() = runBlocking {
+    // The same src twice in one section (normal for music playlists): the
+    // stamped page index selects the tapped copy, so "next" continues from
+    // there instead of from the first copy.
+    servePage("/playlist", track(src = "a"), track(src = "b"), track(src = "a"), track(src = "c"))
+
+    val (queue, index) =
+      requireNotNull(
+        browserManager.expandQueueFromContextualPath(BrowserPathHelper.build("/playlist", "a", 2))
+      )
+
+    assertEquals(listOf("a", "b", "a", "c"), queue.map { it.src })
+    assertEquals(2, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath scopes a cross-section duplicate to the tapped section`() =
+    runBlocking {
+      // The same identity in a rail section AND the list section below it:
+      // the stamped flat index resolves the tap to the list section.
+      serveSections(
+        "/home",
+        section(
+          title = "Row",
+          style =
+            com.margelo.nitro.audiobrowser.SectionStyle(
+              display = com.margelo.nitro.audiobrowser.StyleDisplay.GRID,
+              artworkRendering = null,
+              gridWrap = false,
+            ),
+          children = arrayOf(track(src = "dup")),
+        ),
+        section(title = "Stations", children = arrayOf(track(src = "dup"), track(src = "b"))),
+      )
+
+      val (queue, index) =
+        requireNotNull(
+          browserManager.expandQueueFromContextualPath(BrowserPathHelper.build("/home", "dup", 1))
+        )
+
+      assertEquals(listOf("dup", "b"), queue.map { it.src })
+      assertEquals(0, index)
+    }
+
+  @Test
+  fun `expandQueueFromContextualPath falls back to the first match on a stale index`() =
+    runBlocking {
+      // The list shifted since the stamp: the child at the index no longer
+      // carries the identity, so resolution ignores the index and falls back
+      // to the first identity match instead of aborting.
+      servePage("/home", track(src = "x"), track(src = "a"), track(src = "b"))
+
+      val (queue, index) =
+        requireNotNull(
+          browserManager.expandQueueFromContextualPath(BrowserPathHelper.build("/home", "a", 0))
+        )
+
+      assertEquals(listOf("x", "a", "b"), queue.map { it.src })
+      assertEquals(1, index)
+    }
+
+  @Test
+  fun `expandQueueFromContextualPath returns null when the id has vanished from the page`() =
+    runBlocking {
+      // The stored path points at a track the page no longer lists — the page changed under a
+      // resumed session. Queueing the current list would resume the wrong station, so expansion
+      // aborts and the caller falls back to the stored single track.
+      servePage("/home", track(src = "a"), track(src = "b"))
+
+      assertNull(browserManager.expandQueueFromContextualPath(contextual("/home", "gone")))
+    }
+
+  @Test
+  fun `expandQueueFromContextualPath returns null for a non-contextual path`() = runBlocking {
+    servePage("/home", track(src = "a"))
+
+    assertNull(browserManager.expandQueueFromContextualPath("/home"))
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath returns null when the page has no children`() = runBlocking {
+    browserManager.config =
+      BrowserConfig(routes = arrayOf(staticRoute("/home", resolvedTrack(path = "/home"))))
+
+    assertNull(browserManager.expandQueueFromContextualPath(contextual("/home", "a")))
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath scopes a rail section to its own tiles`() = runBlocking {
+    serveSections(
+      "/home",
+      section(
+        title = "Most Played",
+        style =
+          com.margelo.nitro.audiobrowser.SectionStyle(
+            display = com.margelo.nitro.audiobrowser.StyleDisplay.GRID,
+            artworkRendering = null,
+            gridWrap = false,
+          ),
+        children = arrayOf(track(src = "r1"), track(src = "r2")),
+      ),
+      section(children = arrayOf(track(src = "a"))),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "r2")))
+
+    // A tile tap queues its section, not the list rows beside it.
+    assertEquals(listOf("r1", "r2"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath drops unplayable siblings`() = runBlocking {
+    serveSections(
+      "/home",
+      section(
+        title = "Mixed",
+        children =
+          arrayOf(
+            track(src = "a"),
+            // A browsable row sitting inside the same section — no src, so not queueable.
+            track(src = null).copy(path = "/sub"),
+            track(src = "b"),
+          ),
+      ),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "b")))
+
+    assertEquals(listOf("a", "b"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `navigate stamps the identity, not the src, into id-bearing children's contextual urls`() =
+    runBlocking {
+      servePage(
+        "/home",
+        track(id = "stable-a", src = "https://s/a.mp3", title = "A"),
+        track(src = "https://s/b.mp3", title = "B"),
+      )
+
+      val resolved = browserManager.navigate("/home")
+
+      // id when non-blank, else src — Track.identity (ADR 0008).
+      assertEquals(
+        listOf(
+          BrowserPathHelper.build("/home", "stable-a", 0),
+          BrowserPathHelper.build("/home", "https://s/b.mp3", 1),
+        ),
+        resolved.flattenedChildren?.map { it.path },
+      )
+    }
+
+  @Test
+  fun `expandQueueFromContextualPath finds the selected index by identity`() = runBlocking {
+    servePage(
+      "/home",
+      track(id = "stable-a", src = "https://s/a.mp3"),
+      track(id = "stable-b", src = "https://s/b.mp3"),
+      track(id = "stable-c", src = "https://s/c.mp3"),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "stable-c")))
+
+    assertEquals(listOf("stable-a", "stable-b", "stable-c"), queue.map { it.id })
+    assertEquals(2, index)
+  }
+
+  @Test
+  fun `getCachedTrack resolves an id-valued trackId through the cache`() = runBlocking {
+    servePage("/home", track(id = "stable-b", src = "https://s/b.mp3", title = "B"))
+    browserManager.navigate("/home")
+
+    // A contextual mediaId whose __trackId is the identity (the id), with a parent path that was
+    // never cached directly — the extract-then-lookup path must find it via the id key.
+    val mediaId = contextual("/elsewhere", "stable-b")
+
+    assertEquals("B", browserManager.getCachedTrack(mediaId)?.title)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath honours singleTrack`() = runBlocking {
+    servePage("/home", track(src = "a"), track(src = "b"), singleTrack = true)
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "b")))
+
+    assertEquals(listOf("b"), queue.map { it.src })
+    assertEquals(0, index)
+  }
+
+  // --- Track.disabled: queue expansion excludes unavailable tracks ---
+
+  @Test
+  fun `expandQueueFromContextualPath excludes disabled tracks`() = runBlocking {
+    servePage(
+      "/home",
+      track(src = "a"),
+      track(src = "unavailable", disabled = true),
+      track(src = "b"),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "b")))
+
+    assertEquals(listOf("a", "b"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath aborts when the tapped track is disabled`() = runBlocking {
+    // A disabled track never plays: with the tapped identity excluded from the
+    // playable list, expansion aborts, and every caller's fallback refuses the
+    // disabled track itself — navigateTrack's guard on tap,
+    // onPlaybackResumption's refusal on resume.
+    servePage("/home", track(src = "a"), track(src = "unavailable", disabled = true))
+
+    assertNull(browserManager.expandQueueFromContextualPath(contextual("/home", "unavailable")))
+  }
+
+  @Test
+  fun `resolveMediaItemsForPlayback refuses a disabled track on the legacy INDEX_UNSET path`() =
+    runBlocking {
+      // Android Auto and Assistant request playback through Media3's legacy
+      // path, which passes C.INDEX_UNSET ("the default item") — the refusal
+      // must cover it, or a stale browse row for a now-disabled track plays.
+      servePage("/home", track(src = "unavailable", disabled = true))
+      browserManager.resolve("/home")
+
+      val item = MediaItem.Builder().setMediaId("unavailable").build()
+
+      try {
+        browserManager.resolveMediaItemsForPlayback(listOf(item), C.INDEX_UNSET, 0)
+        fail("Expected refusal of a disabled track")
+      } catch (expected: IllegalStateException) {
+        // Refused by failing the future: Media3 surfaces an error to the
+        // controller and live playback stays untouched.
+      }
+    }
 }

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

@@ -91,6 +91,44 @@ class BrowserUrlResolutionTest {
     assertEquals("https://api.example.com/artwork/abc", source?.uri)
   }
 
+  @Test
+  fun `resolveArtworkUrl leaves the id token literal for a track without an id`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(path = "/artwork/{id}"),
+      )
+    // The config still runs (no blanket skip); the token stays literal so the resulting request
+    // 404s with a self-describing URL.
+    val source = bm.resolveArtworkUrl(track(artwork = null, id = null))
+    assertEquals("https://api.example.com/artwork/{id}", source?.uri)
+  }
+
+  @Test
+  fun `resolveArtworkUrl treats a blank id like a missing one`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(path = "/artwork/{id}"),
+      )
+    val source = bm.resolveArtworkUrl(track(artwork = null, id = ""))
+    assertEquals("https://api.example.com/artwork/{id}", source?.uri)
+  }
+
+  @Test
+  fun `resolveArtworkUrl leaves the id token literal in header values without an id`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(path = "/artwork", headers = mapOf("x-track" to "{id}")),
+      )
+    val source = bm.resolveArtworkUrl(track(artwork = null, id = null))
+    assertEquals("{id}", source?.headers?.get("x-track"))
+
+    val substituted = bm.resolveArtworkUrl(track(artwork = null, id = "abc"))
+    assertEquals("abc", substituted?.headers?.get("x-track"))
+  }
+
   @Test
   fun `resolveArtworkUrl applies image query params from the image context`() = runTest {
     bm.config =

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

@@ -35,7 +35,7 @@ class JsonArtworkTest {
     // so one unparseable row rejected the whole page rather than losing an image.
     val resolved =
       json.decodeFromString<JsonResolvedTrack>(
-        """{"url":"/favorites","title":"Favorites","children":[
+        """{"path":"/favorites","title":"Favorites","children":[
           {"title":"Playlist","artwork":{"light":"https://e.example/l.png","dark":"https://e.example/d.png"}}
         ]}"""
       )

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

@@ -0,0 +1,91 @@
+package com.audiobrowser.browser
+
+import com.margelo.nitro.audiobrowser.ArtworkRendering
+import com.margelo.nitro.audiobrowser.StyleDisplay
+import kotlinx.serialization.json.Json
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+/** Style blocks on the wire, decoded tolerantly (ADR 0011). */
+class JsonStyleTest {
+  private val json = Json { ignoreUnknownKeys = true }
+
+  @Test
+  fun `decodes a block onto TrackStyle`() {
+    val track =
+      json.decodeFromString<JsonTrack>(
+        """{"title":"X","style":{"display":"grid","artworkRendering":"stencil"}}"""
+      )
+    val style = track.toNitro().style
+    assertEquals(StyleDisplay.GRID, style?.display)
+    assertEquals(ArtworkRendering.STENCIL, style?.artworkRendering)
+  }
+
+  @Test
+  fun `decodes a block onto SectionStyle`() {
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","sections":[
+          {"style":{"display":"grid","gridWrap":false},"children":[{"title":"C","src":"s"}]}
+        ]}"""
+      )
+    val style = resolved.toNitro().sections?.first()?.style
+    assertEquals(StyleDisplay.GRID, style?.display)
+    assertEquals(false, style?.gridWrap)
+  }
+
+  @Test
+  fun `a stale string style decodes as no declaration - never a parse failure`() {
+    // The retired string vocabulary must never kill the page (tolerant
+    // decoding, ADR 0011).
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","style":"rail","children":[
+          {"title":"C","src":"s","style":"grid"}
+        ]}"""
+      )
+    val nitro = resolved.toNitro()
+    assertNull(nitro.style)
+    assertNull(nitro.children?.first()?.style)
+  }
+
+  @Test
+  fun `unknown enum values decode as no declaration`() {
+    // All-unknown declarations collapse to "no block" — one shape for "no
+    // declaration" on every platform.
+    val track =
+      json.decodeFromString<JsonTrack>(
+        """{"title":"X","style":{"display":"carousel","artworkRendering":"embossed","gridWrap":"yes"}}"""
+      )
+    assertNull(track.toNitro().style)
+  }
+
+  @Test
+  fun `an empty block decodes as no declaration`() {
+    val track = json.decodeFromString<JsonTrack>("""{"title":"X","style":{}}""")
+    assertNull(track.toNitro().style)
+  }
+
+  @Test
+  fun `a quoted boolean gridWrap is a wrong-typed field - no declaration`() {
+    // iOS's strict-typed tolerant decode drops a quoted "false"; the lenient
+    // Kotlin mapper must not read it either, or the same payload renders a
+    // teaser shelf on one platform and a wrapping grid on the other.
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","sections":[
+          {"style":{"display":"grid","gridWrap":"false"},"children":[{"title":"C","src":"s"}]}
+        ]}"""
+      )
+    val style = resolved.toNitro().sections?.first()?.style
+    assertEquals(StyleDisplay.GRID, style?.display)
+    assertNull(style?.gridWrap)
+  }
+
+  @Test
+  fun `decodes disabled`() {
+    val track = json.decodeFromString<JsonTrack>("""{"title":"X","src":"s","disabled":true}""")
+    assertEquals(true, track.toNitro().disabled)
+  }
+}