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

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

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

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