react-native-audio-browser 0.2.0-next.2 → 0.2.0-next.20

package/ios/Tests/StyleResolverTests.swift

@@ -0,0 +1,127 @@
+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)
+    #expect(resolved.gridTile == nil)
+  }
+
+  @Test func gridTileResolvesByScopeOverride() {
+    // A page-wide card treatment; one section opts back to plain tiles.
+    let inherited = StyleResolver.sectionStyle(
+      section: nil,
+      page: SectionStyle(gridTile: .card),
+    )
+    #expect(inherited.gridTile == .card)
+    let overridden = StyleResolver.sectionStyle(
+      section: SectionStyle(gridTile: .plain),
+      page: SectionStyle(gridTile: .card),
+    )
+    #expect(overridden.gridTile == .plain)
+  }
+}
+
+@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)
+  }
+
+  @Test func imageShapeInheritsAndOverridesPerItem() {
+    // Section-wide circular (an artists shelf); one album overrides.
+    let inherited = StyleResolver.trackStyle(
+      track: nil,
+      section: SectionStyle(imageShape: .circular),
+    )
+    #expect(inherited.imageShape == .circular)
+    let overridden = StyleResolver.trackStyle(
+      track: TrackStyle(imageShape: .roundedRectangle),
+      section: SectionStyle(imageShape: .circular),
+    )
+    #expect(overridden.imageShape == .roundedRectangle)
+  }
+
+  @Test func accessorySymbolInheritsAndNoneResolvesAsAValue() {
+    let inherited = StyleResolver.trackStyle(
+      track: nil,
+      section: SectionStyle(accessorySymbol: "lock.fill"),
+    )
+    #expect(inherited.accessorySymbol == "lock.fill")
+    // 'none' is the inheritance escape — it must survive resolution intact
+    // (the renderer, not the resolver, maps it to "no accessory").
+    let escaped = StyleResolver.trackStyle(
+      track: TrackStyle(accessorySymbol: "none"),
+      section: SectionStyle(accessorySymbol: "lock.fill"),
+    )
+    #expect(escaped.accessorySymbol == "none")
+  }
+
+  @Test func cardPropertiesInheritAndOverridePerItem() {
+    // Section-wide tint/mode; one card overrides its image mode.
+    let inherited = StyleResolver.trackStyle(
+      track: nil,
+      section: SectionStyle(accessorySymbol: nil, cardTint: "#1e3a8a", cardImage: .background),
+    )
+    #expect(inherited.cardTint == "#1e3a8a")
+    #expect(inherited.cardImage == .background)
+    let overridden = StyleResolver.trackStyle(
+      track: TrackStyle(cardImage: .normal),
+      section: SectionStyle(cardTint: "#1e3a8a", cardImage: .background),
+    )
+    #expect(overridden.cardImage == .normal)
+    #expect(overridden.cardTint == "#1e3a8a")
+  }
+}

package/ios/Tests/Support/TestTypes.swift

@@ -185,6 +185,7 @@ final class MockSleepTimerHandling: SleepTimerHandling {
   var onComplete: (() -> Void)?
   var onFadeStart: ((_ duration: TimeInterval) -> Void)?
   var onFadeCancel: (() -> Void)?
+  var onChanged: ((SleepTimerState) -> Void)?
   var trackChangedCallCount = 0
   var trackPlayedToEndCallCount = 0
   var clearCallCount = 0
@@ -196,6 +197,12 @@ final class MockSleepTimerHandling: SleepTimerHandling {
 
   func onTrackChanged() { trackChangedCallCount += 1 }
   func onTrackPlayedToEnd() { trackPlayedToEndCallCount += 1 }
+
+  // Consumer-facing surface — unused by the coordinator tests, present only to
+  // satisfy the protocol. Add recorders alongside the tests that need them.
+  func get() -> SleepTimerState? { nil }
+  func set(seconds _: TimeInterval, fadeDuration _: TimeInterval?) {}
+  func setToEndOfTrack() {}
 }
 
 // MARK: - Mock RetryHandling
@@ -209,7 +216,7 @@ final class MockRetryHandling: RetryHandling {
   var attemptRetryDelayNs: UInt64 = 0
   var resetCallCount = 0
 
-  func isRetryable(_: Error?) -> Bool { isRetryableResult }
+  func isRetryable(_: Error?, httpStatusCode _: Int?) -> Bool { isRetryableResult }
   func attemptRetry(startFromCurrentTime _: Bool) async -> Bool {
     if attemptRetryDelayNs > 0 {
       try? await Task.sleep(nanoseconds: attemptRetryDelayNs)

package/ios/Tests/TabBarEntriesTests.swift

@@ -4,59 +4,59 @@ import Testing
 
 struct TabBarEntriesTests {
   private func tab(
-    _ title: String, url: String, artwork: String? = nil,
-    artworkSource: ImageSource? = nil, artist: 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/TimedMetadataAVFoundationTests.swift

@@ -20,6 +20,48 @@ struct TimedMetadataICYTests {
     #expect(result?.artist == nil)
   }
 
+  private func icyTitle(_ value: String) -> AVMetadataItem {
+    let item = AVMutableMetadataItem()
+    item.key = "StreamTitle" as NSString
+    item.keySpace = .icy
+    item.value = value as NSString
+    return item
+  }
+
+  // "Песня" as windows-1251 bytes, decoded as Latin-1 the way AVFoundation does when it guesses wrong.
+  private let latin1Shaped = "\u{CF}\u{E5}\u{F1}\u{ED}\u{FF}"
+
+  @Test func icyCharset_redecodesLatin1ShapedTitle() {
+    let result = TimedMetadata.from(items: [icyTitle(latin1Shaped)], icyCharset: "windows-1251")
+    #expect(result?.title == "Песня")
+  }
+
+  @Test func icyCharset_leavesAlreadyDecodedTitle() {
+    let result = TimedMetadata.from(items: [icyTitle("Песня")], icyCharset: "windows-1251")
+    #expect(result?.title == "Песня")
+  }
+
+  @Test func icyCharset_leavesAscii() {
+    let result = TimedMetadata.from(items: [icyTitle("Plain Title")], icyCharset: "windows-1251")
+    #expect(result?.title == "Plain Title")
+  }
+
+  @Test func icyCharset_ignoresUnknownCharset() {
+    let result = TimedMetadata.from(items: [icyTitle(latin1Shaped)], icyCharset: "no-such-charset")
+    #expect(result?.title == latin1Shaped)
+  }
+
+  @Test func icyCharset_absent_keepsTitle() {
+    let result = TimedMetadata.from(items: [icyTitle(latin1Shaped)])
+    #expect(result?.title == latin1Shaped)
+  }
+
+  @Test func icyCharset_neverTouchesId3() {
+    let items = [makeMetadataItem(identifier: .id3MetadataTitleDescription, value: latin1Shaped)]
+    let result = TimedMetadata.from(items: items, icyCharset: "windows-1251")
+    #expect(result?.title == latin1Shaped)
+  }
+
   @Test func icyWithoutStreamTitle_returnsNil() {
     let item = AVMutableMetadataItem()
     item.key = "StreamUrl" as NSString

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)
+  }
+}