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

package/ios/Tests/SectionPresentationTests.swift

@@ -0,0 +1,61 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+// The (resolved style, platform capability) → rendered-form mapping (ADR
+// 0011): degradation drops decorations before layout, and the one layout drop
+// is a wrapping grid on a platform without a wrapping tile container.
+
+@Suite("SectionPresentation")
+struct SectionPresentationTests {
+  private func style(display: StyleDisplay?, gridWrap: Bool? = nil) -> SectionStyle {
+    SectionStyle(gridWrap: gridWrap, display: display, artworkRendering: nil)
+  }
+
+  @Test func noStyleRendersAList() {
+    #expect(SectionPresentation(for: nil, supportsWrappingGrid: true) == .list)
+    #expect(SectionPresentation(for: nil, supportsWrappingGrid: false) == .list)
+  }
+
+  @Test func listDisplayRendersAList() {
+    #expect(SectionPresentation(for: style(display: .list), supportsWrappingGrid: true) == .list)
+  }
+
+  @Test func wrappingGridNeedsTheWrappingContainer() {
+    #expect(
+      SectionPresentation(for: style(display: .grid), supportsWrappingGrid: true) == .wrappingGrid)
+    // The one layout drop: a wrapping grid has nowhere to go but a list —
+    // every item stays reachable instead of truncating at an unknowable width.
+    #expect(SectionPresentation(for: style(display: .grid), supportsWrappingGrid: false) == .list)
+  }
+
+  @Test func singleLineGridRendersOnEveryOS() {
+    // gridWrap: false is the legacy image row's own shape, so it never
+    // degrades — declaring it INCREASES pre-26 fidelity.
+    #expect(
+      SectionPresentation(for: style(display: .grid, gridWrap: false), supportsWrappingGrid: true)
+        == .singleLineRow)
+    #expect(
+      SectionPresentation(for: style(display: .grid, gridWrap: false), supportsWrappingGrid: false)
+        == .singleLineRow)
+  }
+
+  @Test func explicitWrapTrueBehavesLikeTheDefault() {
+    #expect(
+      SectionPresentation(for: style(display: .grid, gridWrap: true), supportsWrappingGrid: true)
+        == .wrappingGrid)
+    #expect(
+      SectionPresentation(for: style(display: .grid, gridWrap: true), supportsWrappingGrid: false)
+        == .list)
+  }
+
+  @Test func gridWrapIsInertOnLists() {
+    // Declaring a decoration never changes the layout you'd get without it.
+    #expect(
+      SectionPresentation(for: style(display: .list, gridWrap: false), supportsWrappingGrid: true)
+        == .list)
+    #expect(
+      SectionPresentation(for: style(display: nil, gridWrap: false), supportsWrappingGrid: true)
+        == .list)
+  }
+}

package/ios/Tests/SectionScopeTests.swift

@@ -2,81 +2,113 @@
 import Testing
 
 struct SectionScopeTests {
-  private func track(_ src: String, group: String? = nil) -> Track {
-    Track(id: src, src: src, groupTitle: group)
+  private func track(_ src: String, id: String? = nil) -> Track {
+    Track(id: id ?? src, src: src)
   }
 
-  private func runSrcs(_ section: SectionScope.Section?) -> [String?]? {
-    guard case let .run(tracks) = section else { return nil }
-    return tracks.map(\.src)
+  private func section(_ title: String? = nil, _ tracks: [Track]) -> Section {
+    Section(title: title, children: tracks)
   }
 
-  private func imageRowSrcs(_ section: SectionScope.Section?) -> [String?]? {
-    guard case let .imageRow(items) = section else { return nil }
-    return items.map(\.src)
+  private func srcs(_ scoped: SectionScope.Scoped?) -> [String?]? {
+    scoped.map { $0.section.children.map(\.src) }
   }
 
-  @Test func scopesToTheContiguousGroupTitleRun() {
-    let children = [
-      track("a", group: "First"),
-      track("b", group: "First"),
-      track("c", group: "Second"),
-      track("d", group: "Second"),
-      track("e"),
+  // Two sections sharing an identity — the duplicate-heavy shape the flat
+  // model had to disambiguate by precedence; sections + the stamped flat
+  // index make it exact.
+  private var sections: [Section] {
+    [
+      section("First", [track("dup"), track("x")]),
+      section("Second", [track("y"), track("dup"), track("z")]),
     ]
-    #expect(runSrcs(SectionScope.section(of: children, containing: "c")) == ["c", "d"])
-    #expect(runSrcs(SectionScope.section(of: children, containing: "a")) == ["a", "b"])
   }
 
-  @Test func ungroupedItemsFormTheirOwnRun() {
-    let children = [
-      track("a", group: "First"),
-      track("b"),
-      track("c"),
-      track("d", group: "Second"),
-    ]
-    #expect(runSrcs(SectionScope.section(of: children, containing: "b")) == ["b", "c"])
+  @Test func fallsBackToTheFirstSectionContainingTheIdentity() {
+    let scoped = SectionScope.scoped(in: sections, containing: "dup")
+    #expect(srcs(scoped) == ["dup", "x"])
+    #expect(scoped?.tappedOffset == nil)
   }
 
-  @Test func identicalTitlesInSeparateRunsStaySeparate() {
-    let children = [
-      track("a", group: "Same"),
-      track("x", group: "Other"),
-      track("b", group: "Same"),
-    ]
-    #expect(runSrcs(SectionScope.section(of: children, containing: "a")) == ["a"])
+  @Test func flatIndexPinsTheTappedSection() {
+    // Flat index 3 = second section, offset 1.
+    let scoped = SectionScope.scoped(in: sections, containing: "dup", tappedIndex: 3)
+    #expect(srcs(scoped) == ["y", "dup", "z"])
+    #expect(scoped?.tappedOffset == 1)
   }
 
-  @Test func findsTheIdInsideAnImageRow() {
-    let items = [
-      ImageRowItem(src: "s1", title: "One"),
-      ImageRowItem(src: "s2", title: "Two"),
-    ]
-    var row = Track(id: "row", title: "Most Played")
-    row.imageRow = items
-    let children = [row, track("a")]
-    #expect(imageRowSrcs(SectionScope.section(of: children, containing: "s2")) == ["s1", "s2"])
+  @Test func flatIndexPinsTheExactCopyWithinASection() {
+    let playlist = [section(nil, [track("a"), track("b"), track("a"), track("c")])]
+    let scoped = SectionScope.scoped(in: playlist, containing: "a", tappedIndex: 2)
+    #expect(scoped?.tappedOffset == 2)
+  }
+
+  @Test func staleIndexFallsBackToTheFirstIdentityMatch() {
+    // The child at the stamped index no longer carries the tapped identity
+    // (the list shifted) — resolution ignores the index and pins nothing.
+    let scoped = SectionScope.scoped(in: sections, containing: "dup", tappedIndex: 1)
+    #expect(srcs(scoped) == ["dup", "x"])
+    #expect(scoped?.tappedOffset == nil)
   }
 
-  @Test func unknownIdReturnsNil() {
-    #expect(SectionScope.section(of: [track("a")], containing: "zz") == nil)
+  @Test func outOfRangeIndexIsIgnored() {
+    let scoped = SectionScope.scoped(in: sections, containing: "dup", tappedIndex: 99)
+    #expect(srcs(scoped) == ["dup", "x"])
+    #expect(scoped?.tappedOffset == nil)
   }
 
-  // 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 func imageRowWinsOverAFlatListDuplicate() {
-    var row = Track(id: "row", title: "Row")
-    row.imageRow = [ImageRowItem(src: "dup", title: "Dup")]
-    let children = [row, track("dup"), track("b")]
-    #expect(imageRowSrcs(SectionScope.section(of: children, containing: "dup")) == ["dup"])
+  @Test func vanishedIdentityReturnsNil() {
+    #expect(SectionScope.scoped(in: sections, containing: "gone") == nil)
   }
 
-  @Test func duplicateSrcAcrossRunsResolvesToTheEarlierRun() {
+  // MARK: - Identity (id when non-blank, else src)
+
+  @Test func matchesChildByIdWhenSrcDiffers() {
     let children = [
-      track("dup", group: "First"),
-      track("x", group: "Second"),
-      track("dup", group: "Second"),
+      Track(id: "stable-a", src: "https://cdn.example/a?token=1"),
+      Track(id: "stable-b", src: "https://cdn.example/b?token=2"),
     ]
-    #expect(runSrcs(SectionScope.section(of: children, containing: "dup")) == ["dup"])
+    let scoped = SectionScope.scoped(in: [section(nil, children)], containing: "stable-b")
+    #expect(srcs(scoped) == ["https://cdn.example/a?token=1", "https://cdn.example/b?token=2"])
+  }
+
+  @Test func blankIdFallsBackToSrc() {
+    let children = [Track(id: "", src: "s1"), Track(id: "", src: "s2")]
+    let scoped = SectionScope.scoped(in: [section(nil, children)], containing: "s2")
+    #expect(srcs(scoped) == ["s1", "s2"])
+  }
+
+  // MARK: - Page shape helpers
+
+  @Test func childrenSugarNormalizesToOneUntitledSection() {
+    let page = ResolvedTrack(path: "/p", children: [track("a"), track("b")], title: "P")
+    let sections = page.normalizedSections
+    #expect(sections?.count == 1)
+    #expect(sections?.first?.title == nil)
+    #expect(sections?.first?.children.map(\.src) == ["a", "b"])
+  }
+
+  @Test func sectionsWinOverChildren() {
+    let page = ResolvedTrack(
+      path: "/p",
+      sections: [section("S", [track("a")])],
+      children: [track("zzz")],
+      title: "P",
+    )
+    #expect(page.normalizedSections?.count == 1)
+    #expect(page.normalizedSections?.first?.title == "S")
+  }
+
+  @Test func flattenedChildrenConcatenateInSectionOrder() {
+    let page = ResolvedTrack(
+      path: "/p",
+      sections: [section("A", [track("a1"), track("a2")]), section(nil, [track("b1")])],
+      title: "P",
+    )
+    #expect(page.flattenedChildren?.map(\.src) == ["a1", "a2", "b1"])
+  }
+
+  @Test func childlessPageHasNoSections() {
+    #expect(ResolvedTrack(path: "/p", title: "P").normalizedSections == nil)
   }
 }

package/ios/Tests/StyleResolverTests.swift

@@ -0,0 +1,67 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+// Resolution semantics (ADR 0011): container properties and `display` resolve
+// by scope override (`section ?? page`), inherited item properties resolve
+// `track ?? section ?? page` — and `display` never inherits onto an item.
+
+@Suite("StyleResolver.sectionStyle")
+struct SectionStyleResolutionTests {
+  @Test func sectionOverridesThePagePerProperty() {
+    let resolved = StyleResolver.sectionStyle(
+      section: SectionStyle(gridWrap: nil, display: .list, artworkRendering: nil),
+      page: SectionStyle(gridWrap: false, display: .grid, artworkRendering: .stencil),
+    )
+    // Declared on the section: wins. Undeclared: the page's scope-wide value.
+    #expect(resolved.display == .list)
+    #expect(resolved.artworkRendering == .stencil)
+    #expect(resolved.gridWrap == false)
+  }
+
+  @Test func aStylelessSectionTakesThePageBlock() {
+    let resolved = StyleResolver.sectionStyle(
+      section: nil,
+      page: SectionStyle(gridWrap: true, display: .grid, artworkRendering: nil),
+    )
+    #expect(resolved.display == .grid)
+    #expect(resolved.gridWrap == true)
+  }
+
+  @Test func noDeclarationsResolveToAnEmptyBlock() {
+    let resolved = StyleResolver.sectionStyle(section: nil, page: nil)
+    #expect(resolved.display == nil)
+    #expect(resolved.artworkRendering == nil)
+    #expect(resolved.gridWrap == nil)
+  }
+}
+
+@Suite("StyleResolver.trackStyle")
+struct TrackStyleResolutionTests {
+  @Test func trackOverridesTheSectionPerProperty() {
+    let resolved = StyleResolver.trackStyle(
+      track: TrackStyle(display: nil, artworkRendering: .original),
+      section: SectionStyle(gridWrap: nil, display: .grid, artworkRendering: .stencil),
+    )
+    #expect(resolved.artworkRendering == .original)
+  }
+
+  @Test func aStylelessTrackInheritsTheSectionValue() {
+    let resolved = StyleResolver.trackStyle(
+      track: nil,
+      section: SectionStyle(gridWrap: nil, display: nil, artworkRendering: .stencil),
+    )
+    #expect(resolved.artworkRendering == .stencil)
+  }
+
+  @Test func displayNeverInheritsOntoAnItem() {
+    // The track's own `display` is the page promise for the page IT opens;
+    // the section's describes its children's layout. Neither may surface as
+    // the item's resolved display.
+    let resolved = StyleResolver.trackStyle(
+      track: TrackStyle(display: .grid, artworkRendering: nil),
+      section: SectionStyle(gridWrap: nil, display: .grid, artworkRendering: nil),
+    )
+    #expect(resolved.display == nil)
+  }
+}

package/ios/Tests/TabBarEntriesTests.swift

@@ -4,59 +4,59 @@ import Testing
 
 struct TabBarEntriesTests {
   private func tab(
-    _ title: String, url: String, artwork: String? = nil,
+    _ title: String, path: String, artwork: String? = nil,
     artworkSource: ImageSource? = nil, artist: String? = nil,
   ) -> Track {
     Track(
-      id: url, url: url, title: title, artist: artist, artwork: artwork.map { .first($0) },
-      artworkSource: artworkSource,
+      id: path, path: path, artwork: artwork.map { .first($0) },
+      artworkSource: artworkSource, title: title, artist: artist,
     )
   }
 
   @Test func identicalListsAreSame() {
-    let tabs = [tab("Explore", url: "/explore"), tab("Browse", url: "/browse")]
+    let tabs = [tab("Explore", path: "/explore"), tab("Browse", path: "/browse")]
     #expect(TabBarEntries.same(tabs, tabs))
   }
 
   @Test func titleChangeDiffers() {
     #expect(
       !TabBarEntries.same(
-        [tab("Explore", url: "/explore")],
-        [tab("Verkennen", url: "/explore")],
+        [tab("Explore", path: "/explore")],
+        [tab("Verkennen", path: "/explore")],
       ))
   }
 
-  @Test func urlChangeDiffers() {
+  @Test func pathChangeDiffers() {
     #expect(
       !TabBarEntries.same(
-        [tab("Explore", url: "/explore")],
-        [tab("Explore", url: "/discover")],
+        [tab("Explore", path: "/explore")],
+        [tab("Explore", path: "/discover")],
       ))
   }
 
   @Test func artworkChangeDiffers() {
     #expect(
       !TabBarEntries.same(
-        [tab("Explore", url: "/explore", artwork: "sf:globe")],
-        [tab("Explore", url: "/explore", artwork: "sf:map")],
+        [tab("Explore", path: "/explore", artwork: "sf:globe")],
+        [tab("Explore", path: "/explore", artwork: "sf:map")],
       ))
   }
 
   @Test func artworkSourceUriChangeDiffers() {
     #expect(
       !TabBarEntries.same(
-        [tab("Explore", url: "/explore", artworkSource: ImageSource(uri: "https://a/1.png"))],
-        [tab("Explore", url: "/explore", artworkSource: ImageSource(uri: "https://a/2.png"))],
+        [tab("Explore", path: "/explore", artworkSource: ImageSource(uri: "https://a/1.png"))],
+        [tab("Explore", path: "/explore", artworkSource: ImageSource(uri: "https://a/2.png"))],
       ))
   }
 
   @Test func countChangeDiffers() {
-    let tabs = [tab("Explore", url: "/explore")]
-    #expect(!TabBarEntries.same(tabs, tabs + [tab("Browse", url: "/browse")]))
+    let tabs = [tab("Explore", path: "/explore")]
+    #expect(!TabBarEntries.same(tabs, tabs + [tab("Browse", path: "/browse")]))
   }
 
   @Test func nilOldDiffers() {
-    #expect(!TabBarEntries.same(nil, [tab("Explore", url: "/explore")]))
+    #expect(!TabBarEntries.same(nil, [tab("Explore", path: "/explore")]))
   }
 
   @Test func nonRenderedFieldChangeIsSame() {
@@ -64,8 +64,8 @@ struct TabBarEntriesTests {
     // drift without churning the tab bar.
     #expect(
       TabBarEntries.same(
-        [tab("Explore", url: "/explore", artist: "a")],
-        [tab("Explore", url: "/explore", artist: "b")],
+        [tab("Explore", path: "/explore", artist: "a")],
+        [tab("Explore", path: "/explore", artist: "b")],
       ))
   }
 }

package/ios/Tests/TrackIdTemplateTests.swift

@@ -0,0 +1,67 @@
+@testable import AudioBrowserTestable
+import Testing
+
+/// `{id}` template substitution used by artwork URL resolution
+/// (BrowserManager+URLResolution.substituteTrackId). A track without a non-blank id must leave
+/// the token LITERALLY in place — never substitute an empty string, never skip — so the
+/// resulting request 404s with a self-describing URL (the resolver logs a warning keyed off
+/// `containsToken`). Mirrors Android's `substituteTrackId` / `configContainsIdToken`.
+struct TrackIdTemplateTests {
+  // MARK: substitution with an id
+
+  @Test func substitutesTokenInString() {
+    #expect(TrackIdTemplate.substitute("/artwork/{id}", id: "abc") == "/artwork/abc")
+  }
+
+  @Test func substitutesEveryOccurrence() {
+    #expect(TrackIdTemplate.substitute("/{id}/art/{id}.png", id: "x") == "/x/art/x.png")
+  }
+
+  @Test func substitutesTokenInDictionaryValues() {
+    let subbed = TrackIdTemplate.substitute(["x-track": "{id}", "plain": "v"], id: "abc")
+    #expect(subbed == ["x-track": "abc", "plain": "v"])
+  }
+
+  @Test func valueWithoutTokenIsUnchanged() {
+    #expect(TrackIdTemplate.substitute("/artwork/static.png", id: "abc") == "/artwork/static.png")
+  }
+
+  // MARK: token left literal without an id
+
+  @Test func nilIdLeavesTokenLiteral() {
+    #expect(TrackIdTemplate.substitute("/artwork/{id}", id: nil) == "/artwork/{id}")
+  }
+
+  @Test func blankIdLeavesTokenLiteral() {
+    #expect(TrackIdTemplate.substitute("/artwork/{id}", id: "") == "/artwork/{id}")
+  }
+
+  @Test func nilIdLeavesDictionaryValuesLiteral() {
+    #expect(TrackIdTemplate.substitute(["x-track": "{id}"], id: nil) == ["x-track": "{id}"])
+  }
+
+  @Test func nilValuePassesThrough() {
+    #expect(TrackIdTemplate.substitute(String?.none, id: "abc") == nil)
+    #expect(TrackIdTemplate.substitute([String: String]?.none, id: nil) == nil)
+  }
+
+  // MARK: unfilled-token detection (drives the single warning)
+
+  @Test func detectsUnfilledTokenInString() {
+    #expect(TrackIdTemplate.containsToken("/artwork/{id}"))
+    #expect(!TrackIdTemplate.containsToken("/artwork/abc"))
+    #expect(!TrackIdTemplate.containsToken(String?.none))
+  }
+
+  @Test func detectsUnfilledTokenInDictionaryValues() {
+    #expect(TrackIdTemplate.containsToken(["x-track": "{id}"]))
+    #expect(!TrackIdTemplate.containsToken(["x-track": "abc"]))
+    #expect(!TrackIdTemplate.containsToken([String: String]?.none))
+  }
+
+  @Test func substitutionThenDetectionNeverBothMatch() {
+    // With an id, substitution clears the token, so no warning fires.
+    let subbed = TrackIdTemplate.substitute("/artwork/{id}", id: "abc")
+    #expect(!TrackIdTemplate.containsToken(subbed))
+  }
+}

package/ios/Tests/TrackIdentityTests.swift

@@ -0,0 +1,20 @@
+@testable import AudioBrowserTestable
+import Testing
+
+struct TrackIdentityTests {
+  @Test func idWinsOverSrc() {
+    #expect(Track(id: "stable", src: "https://cdn.example/stream").identity == "stable")
+  }
+
+  @Test func blankIdFallsBackToSrc() {
+    #expect(Track(id: "", src: "https://cdn.example/stream").identity == "https://cdn.example/stream")
+  }
+
+  @Test func nilIdFallsBackToSrc() {
+    #expect(Track(src: "https://cdn.example/stream").identity == "https://cdn.example/stream")
+  }
+
+  @Test func neitherIdNorSrcHasNoIdentity() {
+    #expect(Track(path: "/browse/only").identity == nil)
+  }
+}