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

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

@@ -1,7 +1,9 @@
 package com.audiobrowser.browser
 
-import com.audiobrowser.TestFixtures.imageRowItem
+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
@@ -17,14 +19,14 @@ import org.robolectric.RobolectricTestRunner
 /**
  * Navigation and queue-expansion glue.
  *
- * [BrowserManager.expandQueueFromContextualUrl] is the seam between the page a listener tapped in
+ * [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-URL parsing) and
+ * Robolectric is required for `android.net.Uri` (contextual-path parsing) and
  * `android.util.LruCache` (the content cache).
  */
 @RunWith(RobolectricTestRunner::class)
@@ -46,11 +48,20 @@ class BrowserManagerTest {
     browserManager.config =
       BrowserConfig(
         routes =
-          arrayOf(staticRoute(path, resolvedTrack(url = path, children = arrayOf(*children)))),
+          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
@@ -100,28 +111,30 @@ class BrowserManagerTest {
 
     val resolved = browserManager.navigate("/library")
 
-    assertEquals(listOf("A", "B"), resolved.children?.map { it.title })
-    // The tap target: a child's url is rewritten to point back at this page plus its own id.
+    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(contextual("/library", "a"), contextual("/library", "b")),
-      resolved.children?.map { it.url },
+      listOf(
+        BrowserPathHelper.build("/library", "a", 0),
+        BrowserPathHelper.build("/library", "b", 1),
+      ),
+      resolved.flattenedChildren?.map { it.path },
     )
     assertEquals("/library", browserManager.getPath())
   }
 
-  // MARK: - expandQueueFromContextualUrl
+  // MARK: - expandQueueFromContextualPath
 
   @Test
-  fun `expandQueueFromContextualUrl scopes the queue to the tapped section`() = runBlocking {
-    servePage(
+  fun `expandQueueFromContextualPath scopes the queue to the tapped section`() = runBlocking {
+    serveSections(
       "/home",
-      track(src = "a", groupTitle = "Recent"),
-      track(src = "b", groupTitle = "Recent"),
-      track(src = "c", groupTitle = "Popular"),
-      track(src = "d", groupTitle = "Popular"),
+      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.expandQueueFromContextualUrl(contextual("/home", "c"))
+    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)
@@ -130,97 +143,262 @@ class BrowserManagerTest {
   }
 
   @Test
-  fun `expandQueueFromContextualUrl indexes the tapped track within its section`() = runBlocking {
-    servePage(
+  fun `expandQueueFromContextualPath indexes the tapped track within its section`() = runBlocking {
+    serveSections(
       "/home",
-      track(src = "a", groupTitle = "Recent"),
-      track(src = "b", groupTitle = "Popular"),
-      track(src = "c", groupTitle = "Popular"),
+      section(title = "Recent", children = arrayOf(track(src = "a"))),
+      section(title = "Popular", children = arrayOf(track(src = "b"), track(src = "c"))),
     )
 
     val (queue, index) =
-      requireNotNull(browserManager.expandQueueFromContextualUrl(contextual("/home", "c")))
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "c")))
 
     assertEquals(listOf("b", "c"), queue.map { it.src })
     assertEquals(1, index)
   }
 
   @Test
-  fun `expandQueueFromContextualUrl returns null when the id has vanished from the page`() =
+  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 stored url points at a track the page no longer lists — the page changed under a
+      // 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.expandQueueFromContextualUrl(contextual("/home", "gone")))
+      assertNull(browserManager.expandQueueFromContextualPath(contextual("/home", "gone")))
     }
 
   @Test
-  fun `expandQueueFromContextualUrl returns null for a non-contextual url`() = runBlocking {
+  fun `expandQueueFromContextualPath returns null for a non-contextual path`() = runBlocking {
     servePage("/home", track(src = "a"))
 
-    assertNull(browserManager.expandQueueFromContextualUrl("/home"))
+    assertNull(browserManager.expandQueueFromContextualPath("/home"))
   }
 
   @Test
-  fun `expandQueueFromContextualUrl returns null when the page has no children`() = runBlocking {
+  fun `expandQueueFromContextualPath returns null when the page has no children`() = runBlocking {
     browserManager.config =
-      BrowserConfig(routes = arrayOf(staticRoute("/home", resolvedTrack(url = "/home"))))
+      BrowserConfig(routes = arrayOf(staticRoute("/home", resolvedTrack(path = "/home"))))
 
-    assertNull(browserManager.expandQueueFromContextualUrl(contextual("/home", "a")))
+    assertNull(browserManager.expandQueueFromContextualPath(contextual("/home", "a")))
   }
 
   @Test
-  fun `expandQueueFromContextualUrl expands an image row into its items`() = runBlocking {
-    servePage(
+  fun `expandQueueFromContextualPath scopes a rail section to its own tiles`() = runBlocking {
+    serveSections(
       "/home",
-      track(
+      section(
         title = "Most Played",
-        src = null,
-        imageRow = arrayOf(imageRowItem("r1"), imageRowItem("r2")),
+        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")),
       ),
-      track(src = "a"),
+      section(children = arrayOf(track(src = "a"))),
     )
 
     val (queue, index) =
-      requireNotNull(browserManager.expandQueueFromContextualUrl(contextual("/home", "r2")))
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "r2")))
 
-    // A tile tap queues its row, not the list rows beside it.
+    // 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 `expandQueueFromContextualUrl drops unplayable siblings`() = runBlocking {
-    servePage(
+  fun `expandQueueFromContextualPath drops unplayable siblings`() = runBlocking {
+    serveSections(
       "/home",
-      track(src = "a", groupTitle = "Mixed"),
-      // A browsable row sitting inside the same section — no src, so not queueable.
-      track(src = null, groupTitle = "Mixed").copy(url = "/sub"),
-      track(src = "b", groupTitle = "Mixed"),
+      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.expandQueueFromContextualUrl(contextual("/home", "b")))
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "b")))
 
     assertEquals(listOf("a", "b"), queue.map { it.src })
     assertEquals(1, index)
   }
 
   @Test
-  fun `expandQueueFromContextualUrl honours singleTrack`() = runBlocking {
+  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(src = "a", groupTitle = "Recent"),
-      track(src = "b", groupTitle = "Recent"),
-      singleTrack = true,
+      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.expandQueueFromContextualUrl(contextual("/home", "b")))
+      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)
+  }
+}