react-native-audio-browser 0.2.0-next.32 → 0.2.0-next.33

package/ios/Tests/RequestLayerTests.swift

@@ -109,4 +109,120 @@ struct RequestLayerTests {
     #expect(RequestLayer.mergeDicts(["a": "1"], nil) == ["a": "1"])
     #expect(RequestLayer.mergeDicts(nil, ["b": "2"]) == ["b": "2"])
   }
+
+  @Test func baseSetsOnlyThePath() {
+    #expect(Config.base(path: "/a") == Config(path: "/a"))
+  }
+
+  // MARK: - artwork
+
+  private func artwork(
+    _ artwork: Config = Config(),
+    over base: Config = Config(path: "/art.png"),
+    resolve: (nonisolated(nonsending)() async throws -> Config?)? = nil,
+    trackHasArtwork: Bool = true,
+    sizeQuery: [String: String] = [:],
+    transforms: [nonisolated(nonsending)(Config) async throws -> Config] = [],
+    id: String? = nil,
+  ) async throws -> Config? {
+    try await RequestLayer.artwork(
+      artwork, over: base, resolve: resolve, trackHasArtwork: trackHasArtwork,
+      sizeQuery: sizeQuery, transforms: transforms, id: id,
+    )
+  }
+
+  @Test func artworkStaticFieldsMergeOverTheBasePathIncluded() async throws {
+    let result = try await artwork(
+      Config(path: "/artwork/{id}", baseUrl: "https://img", headers: ["B": "2"]),
+      over: Config(path: "/art.png", baseUrl: "https://api", headers: ["A": "1"]),
+      id: "42",
+    )
+    #expect(result == Config(path: "/artwork/42", baseUrl: "https://img", headers: ["A": "1", "B": "2"]))
+  }
+
+  @Test func theResolvedConfigWinsOverTheStaticFields() async throws {
+    let result = try await artwork(
+      Config(baseUrl: "https://static", userAgent: "static"),
+      resolve: { Config(baseUrl: "https://resolved") },
+    )
+    #expect(result == Config(path: "/art.png", baseUrl: "https://resolved", userAgent: "static"))
+  }
+
+  @Test func aResolverThatProducesNothingKeepsTheTracksArtwork() async throws {
+    let result = try await artwork(Config(baseUrl: "https://img"), resolve: { nil })
+    #expect(result == Config(path: "/art.png", baseUrl: "https://img"))
+  }
+
+  @Test func aResolverThatProducesNothingForATrackWithoutArtworkIsNoArtwork() async throws {
+    let result = try await artwork(
+      Config(path: "/fallback.png"), over: Config(), resolve: { nil }, trackHasArtwork: false,
+    )
+    #expect(result == nil)
+  }
+
+  @Test func theSizeQueryMergesBeforeTheTransformsRun() async throws {
+    var seen: Config?
+    let result = try await artwork(
+      over: Config(path: "/art.png", query: ["v": "1"]),
+      sizeQuery: ["w": "300"],
+      transforms: [{ seen = $0; return $0 }],
+    )
+    #expect(seen?.query == ["v": "1", "w": "300"])
+    #expect(result?.query == ["v": "1", "w": "300"])
+  }
+
+  @Test func anEmptySizeQueryLeavesNoQuery() async throws {
+    #expect(try await artwork()?.query == nil)
+  }
+
+  @Test func transformsRunInOrderBeforeTheIdIsFilled() async throws {
+    let result = try await artwork(
+      transforms: [
+        { Config(path: "/t/{id}", baseUrl: $0.baseUrl) },
+        { Config(path: $0.path, baseUrl: "https://second", headers: ["X-Id": "{id}"], query: ["id": "{id}"]) },
+      ],
+      id: "7",
+    )
+    #expect(result == Config(path: "/t/7", baseUrl: "https://second", headers: ["X-Id": "7"], query: ["id": "7"]))
+  }
+
+  @Test func withoutAnIdTheTokenStays() async throws {
+    let result = try await artwork(Config(path: "/artwork/{id}"), id: nil)
+    #expect(result?.path == "/artwork/{id}")
+    #expect(RequestLayer.hasUnfilledIdToken(result!))
+    #expect(!RequestLayer.hasUnfilledIdToken(Config(path: "/artwork/1")))
+    #expect(RequestLayer.hasUnfilledIdToken(Config(headers: ["X": "{id}"])))
+  }
+
+  @Test func noPathLeftIsNoArtwork() async throws {
+    #expect(try await artwork(over: Config(baseUrl: "https://img")) == nil)
+    #expect(try await artwork(transforms: [{ _ in Config(baseUrl: "https://img") }]) == nil)
+  }
+
+  @Test func sizeQueryNamesTheContextsWholePixels() {
+    let params = ImageQueryParams(width: "w", height: "h")
+    #expect(RequestLayer.sizeQuery(params, ImageContext(width: 300.7, height: 200)) == ["w": "300", "h": "200"])
+    #expect(RequestLayer.sizeQuery(ImageQueryParams(width: "w"), ImageContext(width: 300, height: 200)) == ["w": "300"])
+    #expect(RequestLayer.sizeQuery(params, ImageContext(width: nil, height: 200)) == ["h": "200"])
+    #expect(RequestLayer.sizeQuery(params, nil) == [:])
+    #expect(RequestLayer.sizeQuery(nil, ImageContext(width: 300, height: 200)) == [:])
+  }
+
+  @Test func imageHeadersAddTheUserAgentUnlessAHeaderSetsIt() {
+    #expect(RequestLayer.imageHeaders(Config()) == nil)
+    #expect(RequestLayer.imageHeaders(Config(userAgent: "UA")) == ["User-Agent": "UA"])
+    #expect(RequestLayer.imageHeaders(Config(headers: ["User-Agent": "mine"], userAgent: "UA")) == ["User-Agent": "mine"])
+  }
+
+  @Test func imageHeadersAddTheContentTypeUnlessAHeaderSetsIt() {
+    #expect(RequestLayer.imageHeaders(Config(contentType: "image/png")) == ["Content-Type": "image/png"])
+    #expect(
+      RequestLayer.imageHeaders(Config(headers: ["Content-Type": "mine"], contentType: "image/png"))
+        == ["Content-Type": "mine"],
+    )
+    #expect(
+      RequestLayer.imageHeaders(Config(contentType: "image/png", userAgent: "UA"))
+        == ["Content-Type": "image/png", "User-Agent": "UA"],
+    )
+  }
 }

package/ios/Tests/SearchParamsQueryTests.swift

@@ -0,0 +1,48 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+struct SearchParamsQueryTests {
+  private func params(
+    _ query: String,
+    mode: SearchMode? = nil,
+    genre: String? = nil,
+    artist: String? = nil,
+    album: String? = nil,
+    title: String? = nil,
+    playlist: String? = nil,
+    reference: MediaReference = .unknown,
+  ) -> SearchParams {
+    SearchParams(
+      mode: mode, query: query, genre: genre, artist: artist, album: album,
+      title: title, playlist: playlist, reference: reference,
+    )
+  }
+
+  @Test func aPlainSearchSendsOnlyQ() {
+    #expect(params("jazz").queryParams == ["q": "jazz"])
+  }
+
+  @Test func everySetFilterIsSent() {
+    let all = params(
+      "x", mode: .musicVideo, genre: "g", artist: "a", album: "al", title: "t", playlist: "p", reference: .my,
+    )
+    #expect(all.queryParams == [
+      "q": "x", "mode": "music-video", "genre": "g", "artist": "a", "album": "al",
+      "title": "t", "playlist": "p", "reference": "my",
+    ])
+  }
+
+  @Test func anUnknownReferenceIsNotSent() {
+    #expect(params("x", reference: .unknown).queryParams["reference"] == nil)
+  }
+
+  @Test func theCacheKeyIsSortedAndDelimited() {
+    #expect(params("jazz", genre: "jazz").cacheKey == "genre=jazz\u{1}q=jazz")
+  }
+
+  @Test func searchesWithTheSameQueryButDifferentFiltersHaveDifferentKeys() {
+    #expect(params("jazz").cacheKey != params("jazz", genre: "jazz").cacheKey)
+    #expect(params("a", artist: "b").cacheKey != params("a", album: "b").cacheKey)
+  }
+}

package/ios/Tests/SectionScopeTests.swift

@@ -111,4 +111,57 @@ struct SectionScopeTests {
   @Test func childlessPageHasNoSections() {
     #expect(ResolvedTrack(path: "/p", title: "P").normalizedSections == nil)
   }
+
+  // MARK: - Queue
+
+  private func queue(_ sections: [Section], _ path: String, singleTrack: Bool = false) -> ([String?], Int)? {
+    SectionScope.queue(in: sections, path: path, singleTrack: singleTrack).map { ($0.tracks.map(\.src), $0.selectedIndex) }
+  }
+
+  @Test func queuesThePlayableTracksOfTheTappedSection() {
+    let page = [
+      section("First", [track("a"), Track(id: "off", src: "off", disabled: true), Track(path: "/browse"), track("b")]),
+      section("Second", [track("c")]),
+    ]
+    let result = queue(page, "/p?__trackId=b&__index=3")
+    #expect(result?.0 == ["a", "b"])
+    #expect(result?.1 == 1)
+  }
+
+  @Test func thePinnedCopyIsTheSelectedOne() {
+    let page = [section(nil, [track("a"), track("b"), track("a")])]
+    #expect(queue(page, "/p?__trackId=a&__index=2")?.1 == 2)
+    #expect(queue(page, "/p?__trackId=a")?.1 == 0)
+  }
+
+  @Test func aStaleIndexSelectsTheFirstIdentityMatch() {
+    let page = [section(nil, [track("x"), track("a"), track("a")])]
+    #expect(queue(page, "/p?__trackId=a&__index=0")?.1 == 1)
+  }
+
+  @Test func singleTrackQueuesOnlyTheTappedTrack() {
+    let page = [section(nil, [track("a"), track("b"), track("c")])]
+    let result = queue(page, "/p?__trackId=b&__index=1", singleTrack: true)
+    #expect(result?.0 == ["b"])
+    #expect(result?.1 == 0)
+  }
+
+  @Test func aDisabledTappedTrackQueuesNothing() {
+    let page = [section(nil, [track("a"), Track(id: "off", src: "off", disabled: true)])]
+    #expect(queue(page, "/p?__trackId=off&__index=1") == nil)
+    #expect(queue(page, "/p?__trackId=off") == nil)
+  }
+
+  @Test func aVanishedIdentityOrAPlainPathQueuesNothing() {
+    let page = [section(nil, [track("a")])]
+    #expect(queue(page, "/p?__trackId=gone") == nil)
+    #expect(queue(page, "/p") == nil)
+  }
+
+  @Test func isPlayableNeedsASrcAndNoDisabled() {
+    #expect(Track(src: "s").isPlayable)
+    #expect(Track(src: "s", disabled: false).isPlayable)
+    #expect(!Track(src: "s", disabled: true).isPlayable)
+    #expect(!Track(path: "/p").isPlayable)
+  }
 }

package/ios/Tests/SimpleRouterTests.swift

@@ -7,9 +7,7 @@ private struct TestRoute: RouteEntry {
 }
 
 private func match(_ path: String, _ patterns: [String]) -> (route: TestRoute, match: RouteMatch)? {
-  let router = SimpleRouter()
-  let routes = patterns.map { TestRoute(path: $0) }
-  return router.findBestMatch(path: path, routes: routes)
+  SimpleRouter.findBestMatch(path: path, routes: patterns.map { TestRoute(path: $0) })
 }
 
 // MARK: - exact matches
@@ -137,3 +135,40 @@ private func match(_ path: String, _ patterns: [String]) -> (route: TestRoute, m
   let result = match("/api/v1/users", ["/api/{version}/**", "/api/v1/**"])
   #expect(result!.route.path == "/api/v1/**")
 }
+
+@Test func treatsADoubleStarBeforeTheEndAsAConstant() {
+  #expect(match("/a/**/b", ["/a/**/b"]) != nil)
+  #expect(match("/a/x/b", ["/a/**/b"]) == nil)
+}
+
+@Test func theFirstRouteWinsATie() {
+  let result = match("/artists/123", ["/artists/{id}", "/artists/{name}"])
+  #expect(result!.route.path == "/artists/{id}")
+}
+
+// MARK: - browse route
+
+private func browseRoute(_ path: String, _ patterns: [String]) -> (route: TestRoute, match: RouteMatch)? {
+  SimpleRouter.browseRoute(for: path, in: patterns.map { TestRoute(path: $0) })
+}
+
+@Test func theSpecialRoutesNeverMatchABrowsePath() {
+  #expect(browseRoute("/__tabs__", ["__tabs__", "__search__"]) == nil)
+  #expect(browseRoute("__search__", ["__search__"]) == nil)
+}
+
+@Test func aMatchingRouteWinsOverTheDefault() {
+  let result = browseRoute("/artists/1", ["__default__", "/artists/{id}"])
+  #expect(result!.route.path == "/artists/{id}")
+  #expect(result!.match.params == ["id": "1"])
+}
+
+@Test func withoutAMatchTheDefaultRouteBrowsesThePath() {
+  let result = browseRoute("/a/b", ["/artists", "__default__"])
+  #expect(result!.route.path == "__default__")
+  #expect(result!.match.params == ["path": "/a/b"])
+}
+
+@Test func withoutAMatchOrADefaultThereIsNoBrowseRoute() {
+  #expect(browseRoute("/a/b", ["/artists", "__tabs__"]) == nil)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-browser",
-  "version": "0.2.0-next.32",
+  "version": "0.2.0-next.33",
   "description": "react-native-audio-browser is a react native package built with Nitro",
   "keywords": [
     "react-native",