@rntp/player 5.0.0-beta.3 → 5.0.0-beta.5

package/ios/tests/CacheProxyServerTests.swift

@@ -0,0 +1,403 @@
+//
+// Copyright (c) Double Symmetry GmbH
+// Commercial use requires a license. See https://rntp.dev/pricing
+//
+
+import XCTest
+@testable import PlayerCore
+
+final class CacheProxyServerTests: XCTestCase {
+  private var cacheDir: URL!
+  private var cache: AudioCache!
+  private var coordinator: DownloadCoordinator!
+  private var proxy: CacheProxyServer!
+
+  override func setUp() {
+    super.setUp()
+    cacheDir = FileManager.default.temporaryDirectory
+      .appendingPathComponent("CacheProxyServerTests-\(UUID().uuidString)", isDirectory: true)
+    cache = AudioCache(maxSizeBytes: 10 * 1024 * 1024, directory: cacheDir)
+    coordinator = DownloadCoordinator(cache: cache)
+    proxy = try! CacheProxyServer(coordinator: coordinator, cache: cache)
+    proxy.start()
+  }
+
+  override func tearDown() {
+    proxy.stop()
+    coordinator.cancelAll()
+    proxy = nil
+    coordinator = nil
+    try? FileManager.default.removeItem(at: cacheDir)
+    super.tearDown()
+  }
+
+  // MARK: - Helpers
+
+  /// Perform a synchronous HTTP GET through the proxy and return (data, response).
+  private func fetch(_ url: URL, timeout: TimeInterval = 10.0) throws -> (Data, HTTPURLResponse) {
+    let expectation = self.expectation(description: "fetch \(url)")
+    var resultData: Data?
+    var resultResponse: HTTPURLResponse?
+    var resultError: Error?
+
+    let task = URLSession.shared.dataTask(with: url) { data, response, error in
+      resultData = data
+      resultResponse = response as? HTTPURLResponse
+      resultError = error
+      expectation.fulfill()
+    }
+    task.resume()
+    wait(for: [expectation], timeout: timeout)
+
+    if let error = resultError { throw error }
+    return (resultData ?? Data(), resultResponse!)
+  }
+
+  // MARK: - 1. Cache miss with Content-Length
+
+  func testCacheMissWithContentLength() throws {
+    let testData = Data(repeating: 0xAA, count: 4096)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let upstreamURL = server.url
+    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
+
+    let (data, response) = try fetch(proxyURL)
+
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertEqual(data, testData, "Proxy should return the full audio data")
+
+    // Verify it was cached
+    let key = cache.cacheKey(for: upstreamURL)
+    // Give a moment for the download completion handler to finalize
+    Thread.sleep(forTimeInterval: 0.5)
+    XCTAssertEqual(cache.cachedBytes(for: key), Int64(testData.count))
+    XCTAssertTrue(cache.isFullyCached(key: key))
+  }
+
+  // MARK: - 2. Cache miss without Content-Length
+
+  func testCacheMissWithoutContentLength() throws {
+    let testData = Data(repeating: 0xBB, count: 2048)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: false, contentType: "audio/aac")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let upstreamURL = server.url
+    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
+
+    let (data, response) = try fetch(proxyURL)
+
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertEqual(data, testData)
+
+    // Content length should be finalized after download completes
+    let key = cache.cacheKey(for: upstreamURL)
+    Thread.sleep(forTimeInterval: 0.5)
+    let info = cache.contentInfo(for: key)
+    XCTAssertNotNil(info)
+    XCTAssertEqual(info?.contentLength, Int64(testData.count),
+                   "Content length should be finalized after download")
+  }
+
+  // MARK: - 3. Cache hit
+
+  func testCacheHitServesFromDisk() throws {
+    let testData = Data(repeating: 0xCC, count: 1024)
+    let fakeURL = URL(string: "https://example.com/cached-track.mp3")!
+    let key = cache.cacheKey(for: fakeURL)
+
+    // Pre-populate cache
+    let info = AudioCache.ContentInfo(
+      contentType: "audio/mpeg",
+      contentLength: Int64(testData.count),
+      isByteRangeAccessSupported: false
+    )
+    cache.storeContentInfo(info, for: key, url: fakeURL)
+    cache.appendData(testData, for: key)
+
+    let proxyURL = proxy.proxyURL(for: fakeURL, headers: nil)
+    let (data, response) = try fetch(proxyURL)
+
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertEqual(data, testData)
+    // Cache hit should include Content-Length
+    let contentLength = response.value(forHTTPHeaderField: "Content-Length")
+    XCTAssertEqual(contentLength, "\(testData.count)")
+  }
+
+  // MARK: - 4. Partial cache + resume
+
+  func testPartialCacheResumesDownload() throws {
+    let testData = Data(repeating: 0xDD, count: 4000)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let upstreamURL = server.url
+    let key = cache.cacheKey(for: upstreamURL)
+
+    // Pre-populate partial cache (first 1000 bytes)
+    let partialData = testData.prefix(1000)
+    let info = AudioCache.ContentInfo(
+      contentType: "audio/mpeg",
+      contentLength: Int64(testData.count),
+      isByteRangeAccessSupported: false
+    )
+    cache.storeContentInfo(info, for: key, url: upstreamURL)
+    cache.appendData(partialData, for: key)
+
+    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
+    let (data, response) = try fetch(proxyURL)
+
+    XCTAssertEqual(response.statusCode, 200)
+    // The proxy should serve the full data (partial cached + remainder from upstream).
+    // Note: LocalAudioServer doesn't support Range requests, so it returns the full file.
+    // The DownloadCoordinator appends only new data beyond what's cached.
+    // However, since LocalAudioServer returns 200 (not 206), the coordinator will
+    // append the full response. The proxy streams whatever is in the cache.
+    // The important thing is the client gets data and no error occurs.
+    XCTAssertGreaterThanOrEqual(data.count, testData.count)
+
+    Thread.sleep(forTimeInterval: 0.5)
+    XCTAssertGreaterThanOrEqual(cache.cachedBytes(for: key), Int64(testData.count))
+  }
+
+  // MARK: - 5. Upstream failure
+
+  func testUpstreamFailureReturns502() throws {
+    // Use a URL that will fail (nothing listening on this port)
+    let badURL = URL(string: "http://localhost:1/nonexistent.mp3")!
+    let proxyURL = proxy.proxyURL(for: badURL, headers: nil)
+
+    let (_, response) = try fetch(proxyURL)
+
+    XCTAssertEqual(response.statusCode, 502, "Should return 502 for upstream failure")
+  }
+
+  // MARK: - 6. Preload then play (shared download)
+
+  func testPreloadThenPlaySharesDownload() throws {
+    let testData = Data(repeating: 0xEE, count: 8000)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let upstreamURL = server.url
+
+    // Start a preload via the coordinator directly
+    let preloadDone = expectation(description: "preload done")
+    coordinator.download(url: upstreamURL, headers: nil) { result in
+      if case .success = result { preloadDone.fulfill() }
+    }
+
+    // Immediately make a proxy request — it should attach to the same download
+    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
+    let (data, response) = try fetch(proxyURL)
+
+    wait(for: [preloadDone], timeout: 10.0)
+
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertEqual(data, testData)
+
+    // Only one download should have been active
+    let key = cache.cacheKey(for: upstreamURL)
+    XCTAssertTrue(cache.isFullyCached(key: key))
+  }
+
+  // MARK: - 7. Large cached file serves completely via serveFromCache
+
+  func testLargeCacheHitServesCompletely() throws {
+    // Simulate a fully-cached podcast file (50MB).
+    // This tests the serveFromCache 64KB chunked send path.
+    let size = 50 * 1024 * 1024
+    let testData = Data(repeating: 0x66, count: size)
+    let url = URL(string: "https://example.com/big-podcast.mp3")!
+    let key = cache.cacheKey(for: url)
+
+    // Pre-populate cache.
+    cache = AudioCache(maxSizeBytes: Int64(size + 1024 * 1024), directory: cacheDir)
+    let info = AudioCache.ContentInfo(
+      contentType: "audio/mpeg",
+      contentLength: Int64(size),
+      isByteRangeAccessSupported: true
+    )
+    cache.storeContentInfo(info, for: key, url: url)
+    cache.appendData(testData, for: key)
+
+    // Re-create proxy with the larger cache.
+    proxy.stop()
+    coordinator = DownloadCoordinator(cache: cache)
+    proxy = try! CacheProxyServer(coordinator: coordinator, cache: cache)
+    proxy.start()
+
+    let proxyURL = proxy.proxyURL(for: url, headers: nil)
+    let (data, response) = try fetch(proxyURL, timeout: 30.0)
+
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertEqual(data.count, size,
+                   "All \(size) bytes should be served from cache (no Content-Length mismatch)")
+  }
+
+  // MARK: - 8. Large file over slow network streams completely
+
+  func testLargeFileOverSlowNetworkStreamsCompletely() throws {
+    // 5MB file with simulated slow network (64KB chunks, 10ms delay each).
+    // This is ~780 chunks taking ~8 seconds — enough to expose races
+    // between the coordinator writing to cache and the proxy reading it.
+    let size = 5 * 1024 * 1024
+    let testData = Data(repeating: 0x55, count: size)
+    let upstream = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg", simulateSlowNetwork: true)
+    )
+    upstream.start()
+    defer { upstream.stop() }
+
+    let upstreamURL = upstream.url
+    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
+    let (data, response) = try fetch(proxyURL, timeout: 30.0)
+
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertEqual(data.count, size,
+                   "All \(size) bytes should be delivered over slow connection")
+
+    let key = cache.cacheKey(for: upstreamURL)
+    XCTAssertTrue(cache.isFullyCached(key: key))
+  }
+
+  // MARK: - 9. Large file streams completely from upstream
+
+  func testLargeFileStreamsCompletely() throws {
+    // Simulate a podcast-sized file (10MB — large enough to expose
+    // chunking race conditions).
+    let testData = Data(repeating: 0x77, count: 10 * 1024 * 1024)
+    let upstream = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    upstream.start()
+    defer { upstream.stop() }
+
+    let upstreamURL = upstream.url
+    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
+    let (data, response) = try fetch(proxyURL, timeout: 30.0)
+
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertEqual(data.count, testData.count,
+                   "All bytes should be delivered (no Content-Length mismatch)")
+
+    let key = cache.cacheKey(for: upstreamURL)
+    XCTAssertTrue(cache.isFullyCached(key: key))
+    XCTAssertEqual(cache.cachedBytes(for: key), Int64(testData.count))
+  }
+
+  // MARK: - 8. Cache hit after full download serves correctly
+
+  func testCacheHitAfterDownload() throws {
+    let testData = Data(repeating: 0x88, count: 512 * 1024)
+    let upstream = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    upstream.start()
+
+    let upstreamURL = upstream.url
+    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
+
+    // First fetch — downloads and caches.
+    let (data1, _) = try fetch(proxyURL)
+    XCTAssertEqual(data1.count, testData.count)
+
+    // Stop upstream — second fetch must come from cache.
+    upstream.stop()
+
+    let (data2, response2) = try fetch(proxyURL)
+    XCTAssertEqual(response2.statusCode, 200)
+    XCTAssertEqual(data2.count, testData.count)
+    XCTAssertEqual(data2, testData, "Cache hit should serve identical data")
+  }
+
+  // MARK: - 10. Preload then play serves from cache
+
+  func testPreloadThenPlayServesFromCache() throws {
+    let testData = Data(repeating: 0x99, count: 4096)
+    let upstream = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    upstream.start()
+    defer { upstream.stop() }
+
+    let upstreamURL = upstream.url
+    let key = cache.cacheKey(for: upstreamURL)
+
+    // Preload via coordinator (simulating TrackPlayer.preload)
+    let preloadDone = expectation(description: "preload complete")
+    coordinator.download(url: upstreamURL, headers: nil, cacheKey: key) { _ in
+      preloadDone.fulfill()
+    }
+    wait(for: [preloadDone], timeout: 5.0)
+
+    XCTAssertTrue(cache.isFullyCached(key: key))
+
+    // Now fetch via proxy (simulating playback) — should be a cache hit
+    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
+    let (data, response) = try fetch(proxyURL)
+
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertEqual(data.count, testData.count)
+  }
+
+  // MARK: - 9. Range request on cache hit serves correct slice
+
+  func testRangeRequestOnCacheHit() throws {
+    let testData = Data((0..<1024).map { UInt8($0 % 256) })
+    let url = URL(string: "https://example.com/range-test.mp3")!
+    let key = cache.cacheKey(for: url)
+
+    // Pre-populate full cache.
+    let info = AudioCache.ContentInfo(
+      contentType: "audio/mpeg",
+      contentLength: Int64(testData.count),
+      isByteRangeAccessSupported: true
+    )
+    cache.storeContentInfo(info, for: key, url: url)
+    cache.appendData(testData, for: key)
+
+    // Request bytes 500-799.
+    let proxyURL = proxy.proxyURL(for: url, headers: nil)
+    var request = URLRequest(url: proxyURL)
+    request.setValue("bytes=500-799", forHTTPHeaderField: "Range")
+
+    let expectation = self.expectation(description: "range fetch")
+    var resultData: Data?
+    var resultResponse: HTTPURLResponse?
+
+    let task = URLSession.shared.dataTask(with: request) { data, response, _ in
+      resultData = data
+      resultResponse = response as? HTTPURLResponse
+      expectation.fulfill()
+    }
+    task.resume()
+    wait(for: [expectation], timeout: 5.0)
+
+    XCTAssertEqual(resultResponse?.statusCode, 206)
+    XCTAssertEqual(resultData?.count, 300)
+    XCTAssertEqual(resultData, testData.subdata(in: 500..<800))
+  }
+}

package/ios/tests/DownloadCoordinatorTests.swift

@@ -0,0 +1,197 @@
+//
+// Copyright (c) Double Symmetry GmbH
+// Commercial use requires a license. See https://rntp.dev/pricing
+//
+
+import XCTest
+@testable import PlayerCore
+
+final class DownloadCoordinatorTests: XCTestCase {
+  private var cacheDir: URL!
+  private var cache: AudioCache!
+  private var coordinator: DownloadCoordinator!
+
+  override func setUp() {
+    super.setUp()
+    cacheDir = FileManager.default.temporaryDirectory
+      .appendingPathComponent("DownloadCoordinatorTests-\(UUID().uuidString)", isDirectory: true)
+    cache = AudioCache(maxSizeBytes: 10 * 1024 * 1024, directory: cacheDir)
+    coordinator = DownloadCoordinator(cache: cache)
+  }
+
+  override func tearDown() {
+    coordinator = nil
+    try? FileManager.default.removeItem(at: cacheDir)
+    super.tearDown()
+  }
+
+  func testDownloadCachesDataAndFinalizesContentLength() throws {
+    let testData = Data(repeating: 0xAB, count: 1000)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let url = server.url
+    let key = cache.cacheKey(for: url)
+    let done = expectation(description: "download complete")
+
+    coordinator.download(url: url, headers: nil) { result in
+      if case .success = result { done.fulfill() }
+    }
+
+    wait(for: [done], timeout: 5.0)
+
+    XCTAssertEqual(cache.cachedBytes(for: key), Int64(testData.count))
+    let info = cache.contentInfo(for: key)
+    XCTAssertNotNil(info)
+    XCTAssertEqual(info?.contentLength, Int64(testData.count))
+  }
+
+  func testDownloadWithoutContentLengthFinalizesOnCompletion() throws {
+    let testData = Data(repeating: 0xCD, count: 500)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: false, contentType: "audio/aac")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let url = server.url
+    let key = cache.cacheKey(for: url)
+    let done = expectation(description: "download complete")
+
+    coordinator.download(url: url, headers: nil) { result in
+      if case .success = result { done.fulfill() }
+    }
+
+    wait(for: [done], timeout: 5.0)
+
+    XCTAssertEqual(cache.cachedBytes(for: key), Int64(testData.count))
+    let info = cache.contentInfo(for: key)
+    XCTAssertNotNil(info)
+    XCTAssertEqual(info?.contentLength, Int64(testData.count),
+                   "Content length should be finalized to actual byte count")
+  }
+
+  func testDuplicateDownloadReusesActiveTask() throws {
+    let testData = Data(repeating: 0xEF, count: 2000)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let url = server.url
+    let key = cache.cacheKey(for: url)
+
+    let done1 = expectation(description: "first subscriber done")
+    let done2 = expectation(description: "second subscriber done")
+
+    coordinator.download(url: url, headers: nil) { _ in done1.fulfill() }
+    coordinator.download(url: url, headers: nil) { _ in done2.fulfill() }
+
+    wait(for: [done1, done2], timeout: 5.0)
+
+    // Data should only be cached once (not duplicated)
+    XCTAssertEqual(cache.cachedBytes(for: key), Int64(testData.count))
+  }
+
+  func testCancellingOneSubscriberDoesNotStopDownload() throws {
+    let testData = Data(repeating: 0x11, count: 1000)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let url = server.url
+    let key = cache.cacheKey(for: url)
+
+    let done = expectation(description: "second subscriber done")
+
+    let token1 = coordinator.download(url: url, headers: nil) { _ in }
+    coordinator.download(url: url, headers: nil) { _ in done.fulfill() }
+    coordinator.cancelDownload(token: token1)
+
+    wait(for: [done], timeout: 5.0)
+    XCTAssertEqual(cache.cachedBytes(for: key), Int64(testData.count))
+  }
+
+  func testCancellingAllSubscribersCancelsDownload() throws {
+    let testData = Data(repeating: 0x22, count: 1000)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let url = server.url
+
+    let token1 = coordinator.download(url: url, headers: nil) { _ in }
+    let token2 = coordinator.download(url: url, headers: nil) { _ in }
+    coordinator.cancelDownload(token: token1)
+    coordinator.cancelDownload(token: token2)
+
+    // Give time for cancellation to propagate
+    Thread.sleep(forTimeInterval: 0.5)
+
+    XCTAssertTrue(coordinator.activeDownloadCount == 0)
+  }
+
+  func testDownloadStopsAtMaxBytes() throws {
+    // Use 200 KB so the slow-network path sends multiple 64 KB chunks,
+    // giving the coordinator a chance to cancel mid-stream.
+    let totalBytes = 200 * 1024
+    let testData = Data(repeating: 0xBB, count: totalBytes)
+    let server = try LocalAudioServer(
+      audioData: testData,
+      options: .init(includeContentLength: true, contentType: "audio/mpeg", simulateSlowNetwork: true)
+    )
+    server.start()
+    defer { server.stop() }
+
+    let url = server.url
+    let key = cache.cacheKey(for: url)
+    // Stop after ~70 KB — well into the second 64 KB chunk but short of the full 200 KB.
+    let maxBytes: Int64 = 70 * 1024
+    let done = expectation(description: "download stopped at limit")
+
+    coordinator.download(url: url, headers: nil, cacheKey: key, maxBytes: maxBytes) { result in
+      if case .success = result { done.fulfill() }
+    }
+
+    wait(for: [done], timeout: 10.0)
+
+    let cached = cache.cachedBytes(for: key)
+    // Should be at least maxBytes but not the full file.
+    // The coordinator checks after each data chunk, so it may slightly overshoot.
+    XCTAssertGreaterThanOrEqual(cached, maxBytes)
+    XCTAssertLessThan(cached, Int64(testData.count),
+                      "Should not have downloaded the full file")
+  }
+
+  func testFullyCachedURLSkipsDownload() throws {
+    let testData = Data(repeating: 0x33, count: 100)
+    let url = URL(string: "https://example.com/cached.mp3")!
+    let key = cache.cacheKey(for: url)
+
+    // Pre-populate cache
+    let info = AudioCache.ContentInfo(contentType: "audio/mpeg", contentLength: 100, isByteRangeAccessSupported: false)
+    cache.storeContentInfo(info, for: key, url: url)
+    cache.appendData(testData, for: key)
+
+    let done = expectation(description: "immediate completion")
+    coordinator.download(url: url, headers: nil) { result in
+      if case .success = result { done.fulfill() }
+    }
+
+    wait(for: [done], timeout: 1.0)
+    XCTAssertEqual(coordinator.activeDownloadCount, 0, "No download should have started")
+  }
+}