react-native-audio-browser 0.2.0-next.81 → 0.2.0-next.82

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -8,7 +8,7 @@ private func makeLoading(
8
8
  live: Bool = false,
9
9
  ) throws -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
10
10
  let engine = MockPlayerEngine()
11
- let player = makePlayer(engine: engine, retries: false)
11
+ let player = makePlayer(engine: engine)
12
12
  let callbacks = MockPlayerCallbacks()
13
13
  player.callbacks = callbacks
14
14
  try player.setQueue([Track(id: "t1", src: src, title: "T", live: live)])
@@ -31,7 +31,7 @@ private func makePlaying(live: Bool = false) throws -> (Player, MockPlayerEngine
31
31
  @MainActor
32
32
  private func makeStalling(givesUp: Bool = false) throws -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
33
33
  let engine = MockPlayerEngine()
34
- let player = makePlayer(engine: engine, retry: makeRetryLoop(givesUp: givesUp), retries: nil)
34
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(givesUp: givesUp))
35
35
  player.retry.stallTimeout = .milliseconds(10)
36
36
  let callbacks = MockPlayerCallbacks()
37
37
  player.callbacks = callbacks
@@ -45,6 +45,23 @@ private func makeStalling(givesUp: Bool = false) throws -> (Player, MockPlayerEn
45
45
  return (player, engine, callbacks)
46
46
  }
47
47
 
48
+ /// A live stream that loaded and waits to play, its retry loop on a virtual clock.
49
+ @MainActor
50
+ private func makeVirtual(online: Bool = true) throws -> (Player, MockPlayerEngine, MockPlayerCallbacks, VirtualClock) {
51
+ let clock = VirtualClock()
52
+ let retry = RetryLoop(online: online, clock: clock)
53
+ retry.updatePolicy(from: .first(true))
54
+ let engine = MockPlayerEngine()
55
+ let player = makePlayer(engine: engine, retry: retry)
56
+ let callbacks = MockPlayerCallbacks()
57
+ player.callbacks = callbacks
58
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T", live: true)], playWhenReady: true)
59
+ engine.hasItem = true
60
+ engine.hasLoadedAsset = true
61
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
62
+ return (player, engine, callbacks, clock)
63
+ }
64
+
48
65
  @Suite("Player - seeking")
49
66
  @MainActor
50
67
  struct PlayerSeekingTests {
@@ -95,7 +112,7 @@ struct PlayerSeekingTests {
95
112
 
96
113
  @Test func aCompletionFromBeforeAReloadIsDropped() throws {
97
114
  let engine = MockPlayerEngine()
98
- let player = makePlayer(engine: engine, retries: false)
115
+ let player = makePlayer(engine: engine)
99
116
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
100
117
  engine.seekResult = nil
101
118
  engine.hasItem = true
@@ -114,7 +131,7 @@ struct PlayerSeekingTests {
114
131
 
115
132
  @Test func aStartSeekCutShortWaitsForTheNextItem() throws {
116
133
  let engine = MockPlayerEngine()
117
- let player = makePlayer(engine: engine, retries: false)
134
+ let player = makePlayer(engine: engine)
118
135
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
119
136
  engine.seekResult = nil
120
137
  engine.hasItem = true
@@ -130,7 +147,7 @@ struct PlayerSeekingTests {
130
147
  /// A media-load retry passes no position, so the start in flight is what it resumes from.
131
148
  @Test func aReloadThatDoesNotResumeKeepsTheStartInFlight() throws {
132
149
  let engine = MockPlayerEngine()
133
- let player = makePlayer(engine: engine, retries: false)
150
+ let player = makePlayer(engine: engine)
134
151
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
135
152
  engine.seekResult = nil
136
153
  engine.hasItem = true
@@ -146,7 +163,7 @@ struct PlayerSeekingTests {
146
163
 
147
164
  @Test func aMediaServicesResetDuringTheLoadKeepsTheStart() throws {
148
165
  let engine = MockPlayerEngine()
149
- let player = makePlayer(engine: engine, retries: false)
166
+ let player = makePlayer(engine: engine)
150
167
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
151
168
 
152
169
  player.mediaServicesWereReset()
@@ -158,7 +175,7 @@ struct PlayerSeekingTests {
158
175
 
159
176
  @Test func aPlayRightAfterAStopDuringTheStartSeekStartsOver() throws {
160
177
  let engine = MockPlayerEngine()
161
- let player = makePlayer(engine: engine, retries: false)
178
+ let player = makePlayer(engine: engine)
162
179
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
163
180
  engine.seekResult = nil
164
181
  engine.hasItem = true
@@ -174,7 +191,7 @@ struct PlayerSeekingTests {
174
191
 
175
192
  @Test func theLiveEdgeDuringALoadWaitsForTheStartSeek() throws {
176
193
  let engine = MockPlayerEngine()
177
- let player = makePlayer(engine: engine, retries: false)
194
+ let player = makePlayer(engine: engine)
178
195
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.m3u8", title: "T", live: true)], startPositionMs: 25000)
179
196
  engine.seekResult = nil
180
197
  engine.hasItem = true
@@ -220,7 +237,6 @@ struct PlayerEngineEventTests {
220
237
  @Test func aFailedLoadPrimesNowPlayingOncePerLoad() throws {
221
238
  let (player, engine, _) = try makeLoading()
222
239
  player.setPlayWhenReady(true)
223
- player.retry.shouldRetry = { true }
224
240
  engine.emit(.loadFailed(URLError(.timedOut)))
225
241
  engine.emit(.loadFailed(URLError(.timedOut)))
226
242
  #expect(engine.primeCount == 1)
@@ -286,18 +302,15 @@ struct PlayerEngineEventTests {
286
302
  #expect(player.state == .ended)
287
303
 
288
304
  let (live, liveEngine, _) = try makePlaying(live: true)
289
- live.retry.shouldRetry = { true }
290
305
  liveEngine.emit(.playedToEnd)
291
306
  await live.retry.pendingTask?.value
292
307
  #expect(live.state == .loading)
293
308
  #expect(liveEngine.resolveAndLoadCalls.count == 2)
294
- #expect(live.retry.attempts == 1)
295
309
  }
296
310
 
297
311
  /// AVPlayer pauses an item at its end, so a seek within its window would leave it silent.
298
312
  @Test func aLiveEndReconnectsEvenWithASeekableWindow() async throws {
299
313
  let (player, engine, _) = try makePlaying(live: true)
300
- player.retry.shouldRetry = { true }
301
314
  engine.liveEdge = 120
302
315
  engine.emit(.playedToEnd)
303
316
  await player.retry.pendingTask?.value
@@ -310,34 +323,30 @@ struct PlayerEngineEventTests {
310
323
  player.retry.updatePolicy(from: .second(RetryConfig(
311
324
  maxRetries: 3, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
312
325
  )))
313
- player.retry.shouldRetry = { true }
314
326
  for _ in 0 ..< 20 where player.state != .error {
315
327
  engine.emit(.playedToEnd)
316
328
  await player.retry.pendingTask?.value
329
+ engine.hasLoadedAsset = true
317
330
  engine.emit(.itemPrepared(likelyToKeepUp: true))
318
331
  }
319
- #expect(engine.resolveAndLoadCalls.count == 4)
332
+ // The first connection played, so its end starts the count: four that deliver nothing follow.
333
+ #expect(engine.resolveAndLoadCalls.count == 5)
320
334
  #expect(player.state == .error)
321
335
  #expect(player.errorStatus.error == .playbackStalled)
322
336
  #expect(callbacks.errorEvents.count == 1)
323
337
  }
324
338
 
325
- /// Each reconnect plays long enough to refill the budget, as a stream closing once an hour does.
326
- @Test func liveEndsFarApartNeverSpendTheBudget() async throws {
339
+ /// A connection that delivered audio starts `maxRetries`' count over (docs/adr/0014).
340
+ @Test func liveEndsBetweenAudioNeverSpendMaxRetries() async throws {
327
341
  let (player, engine, callbacks) = try makePlaying(live: true)
328
342
  player.retry.updatePolicy(from: .second(RetryConfig(
329
343
  maxRetries: 1, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
330
344
  )))
331
- player.retry.shouldRetry = { true }
332
- player.retry.healthyPlaybackDuration = .milliseconds(10)
333
345
  for _ in 0 ..< 5 {
334
346
  engine.emit(.playedToEnd)
335
347
  await player.retry.pendingTask?.value
336
- #expect(player.retry.attempts == 1)
337
348
  engine.emit(.itemPrepared(likelyToKeepUp: true))
338
349
  player.transition(.avPlayerPlaying)
339
- await player.retry.healthyPlaybackTask?.value
340
- #expect(player.retry.attempts == 0)
341
350
  }
342
351
  #expect(engine.resolveAndLoadCalls.count == 6)
343
352
  #expect(player.state == .playing)
@@ -357,7 +366,6 @@ struct PlayerEngineEventTests {
357
366
  /// The engine stops observing an item on a reload; a played-to-end it delivered late is stale.
358
367
  @Test func aPlayedToEndDuringALoadIsIgnored() throws {
359
368
  let (player, engine, _) = try makePlaying(live: true)
360
- player.retry.shouldRetry = { true }
361
369
  player.reloadResolving(startFromCurrentTime: false)
362
370
  #expect(player.state == .loading)
363
371
  engine.emit(.playedToEnd)
@@ -416,7 +424,12 @@ struct PlayerRecoveringTests {
416
424
  }
417
425
 
418
426
  @Test func aStallWithNoFailureEndsInPlaybackStalledOnceTheBudgetIsSpent() async throws {
419
- let (player, _, callbacks) = try makeStalling(givesUp: true)
427
+ let (player, engine, callbacks) = try makeStalling(givesUp: true)
428
+ await player.retry.stallTask?.value
429
+ await player.retry.pendingTask?.value
430
+ // The stalled connection had played, so even `maxRetries: 0` reconnects it once.
431
+ #expect(engine.resolveAndLoadCalls.count == 2)
432
+ player.transition(.avPlayerWaiting)
420
433
  await player.retry.stallTask?.value
421
434
  await player.retry.pendingTask?.value
422
435
  #expect(player.state == .error)
@@ -528,34 +541,138 @@ struct PlayerRecoveringTests {
528
541
  #expect(engine.resolveAndLoadCalls.count == 1)
529
542
  }
530
543
 
531
- @Test func theNetworkReturningReconnectsAStalledStream_throughTheRetryLoop() async throws {
532
- let (player, engine, _) = try makePlaying()
533
- player.retry.shouldRetry = { true }
544
+ @Test func theDeadlineEndsASilentLoadInOneError_droppingTheConnectInFlight() async throws {
545
+ let clock = VirtualClock()
546
+ let retry = RetryLoop(clock: clock)
547
+ retry.updatePolicy(from: .first(true))
548
+ let engine = MockPlayerEngine()
549
+ let player = makePlayer(engine: engine, retry: retry)
550
+ let callbacks = MockPlayerCallbacks()
551
+ player.callbacks = callbacks
552
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
553
+ let cancels = engine.cancelLoadingCount, stops = engine.stopObservingItemCount
554
+
555
+ await clock.run(until: 119_999)
556
+ #expect(player.state == .loading)
557
+ await clock.run(until: 120_000)
558
+
559
+ #expect(player.state == .error)
560
+ #expect(player.errorStatus.error == .playbackStalled)
561
+ #expect(callbacks.errorEvents.count == 1)
562
+ #expect(engine.cancelLoadingCount == cancels + 1)
563
+ #expect(engine.stopObservingItemCount == stops + 1)
564
+ }
565
+
566
+ /// The error pauses AVPlayer, and an item still connecting can report late: neither the pause,
567
+ /// nor its playing, nor its failure takes the state out of .error.
568
+ @Test func aTerminalErrorHoldsAgainstTheAVPlayersLateEvents() async throws {
569
+ let (player, engine, callbacks) = try makeStalling(givesUp: true)
570
+ engine.emit(.failed(URLError(.badURL), httpStatusCode: nil))
571
+ #expect(player.state == .error)
572
+ let loads = engine.resolveAndLoadCalls.count
573
+
574
+ engine.emit(.timeControlStatus(.paused, waitingForNoItem: false))
575
+ engine.emit(.timeControlStatus(.playing, waitingForNoItem: false))
576
+ engine.emit(.audioDidStart)
577
+ engine.emit(.failed(NSError(domain: "AVFoundationErrorDomain", code: -11800), httpStatusCode: nil))
578
+ await player.retry.pendingTask?.value
579
+
580
+ #expect(player.state == .error)
581
+ #expect(player.errorStatus.error == .playbackFailed)
582
+ #expect(callbacks.errorEvents.count == 1)
583
+ #expect(player.retry.pendingTask == nil)
584
+ #expect(engine.resolveAndLoadCalls.count == loads)
585
+ }
586
+
587
+ /// The stalled connection ends with the network, before its return reaches the loop, so it
588
+ /// grows no backoff: only the 1 s floor applies, long past.
589
+ @Test func theNetworkReturningReconnectsAStalledStreamAtOnce() async throws {
590
+ let (player, engine, _, clock) = try makeVirtual(online: false)
534
591
  player.transition(.avPlayerWaiting)
535
592
  #expect(player.state == .buffering)
593
+ await clock.run(until: 5_000)
594
+
536
595
  player.networkStatusDidChange(isOnline: true)
537
- await player.retry.pendingTask?.value
596
+ await clock.run(until: 5_000)
597
+
538
598
  #expect(engine.resolveAndLoadCalls.count == 2)
539
- #expect(player.retry.attempts == 1)
540
599
  }
541
600
 
542
- @Test func aFlappingConnectionEndsInATerminalErrorOnceTheBudgetIsSpent() async throws {
601
+ @Test func playbackThatStopsWithNoFailureEndsAtTheDeadline() async throws {
602
+ let (player, _, callbacks, clock) = try makeVirtual()
603
+ player.transition(.avPlayerPlaying)
604
+ await clock.run(until: 10_000)
605
+ player.transition(.avPlayerWaiting)
606
+
607
+ await clock.run(until: 129_999)
608
+ #expect(player.state == .buffering)
609
+ await clock.run(until: 130_000)
610
+ #expect(player.state == .error)
611
+ #expect(player.errorStatus.error == .playbackStalled)
612
+ #expect(callbacks.errorEvents.count == 1)
613
+ }
614
+
615
+ @Test func aRetryNowKeepsTheSilenceDeadline() async throws {
616
+ let (player, _, _, clock) = try makeVirtual()
617
+ await clock.run(until: 60_000)
618
+ player.retryNow()
619
+
620
+ await clock.run(until: 119_999)
621
+ #expect(player.state != .error)
622
+ await clock.run(until: 120_000)
623
+ #expect(player.state == .error)
624
+ }
625
+
626
+ @Test func hasPlayedSurvivesAPark_aRetryNowAndAMediaReset() async throws {
627
+ let engine = MockPlayerEngine()
628
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
629
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
630
+ engine.hasItem = true
631
+ engine.hasLoadedAsset = true
632
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
633
+ player.transition(.avPlayerPlaying)
634
+ #expect(player.retry.hasPlayed)
635
+
636
+ engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
637
+ player.pause()
638
+ #expect(player.state == .paused)
639
+ player.play()
640
+ player.retryNow()
641
+ player.mediaServicesWereReset()
642
+
643
+ #expect(player.retry.hasPlayed)
644
+ player.retry.cancel()
645
+ }
646
+
647
+ @Test func aRateChangeInAnErrorLeavesTheAbandonedItemPaused() throws {
648
+ let (player, engine, _) = try makePlaying()
649
+ engine.emit(.failed(URLError(.badURL), httpStatusCode: nil))
650
+ #expect(player.state == .error)
651
+ #expect(player.playWhenReady)
652
+
653
+ player.rate = 1.5
654
+
655
+ #expect(engine.rates.last?.rate == 1.5)
656
+ #expect(engine.rates.last?.playing == false)
657
+ }
658
+
659
+ /// `maxRetries` counts connections in a row that delivered nothing; one that plays between
660
+ /// flaps starts it over, and only the silence deadline bounds it (docs/adr/0014).
661
+ @Test func aFlappingConnectionThatPlaysBetweenKeepsReconnecting() async throws {
543
662
  let (player, engine, callbacks) = try makePlaying()
544
663
  player.retry.updatePolicy(from: .second(RetryConfig(
545
664
  maxRetries: 2, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
546
665
  )))
547
- player.retry.shouldRetry = { true }
548
- for flap in 1 ... 3 {
666
+ for _ in 1 ... 5 {
549
667
  player.transition(.avPlayerWaiting)
550
668
  player.networkStatusDidChange(isOnline: true)
551
669
  await player.retry.pendingTask?.value
552
- if flap == 3 { break }
553
670
  engine.emit(.itemPrepared(likelyToKeepUp: true))
554
671
  player.transition(.avPlayerPlaying)
555
672
  }
556
- #expect(engine.resolveAndLoadCalls.count == 3)
557
- #expect(player.state == .error)
558
- #expect(callbacks.errorEvents.count == 1)
673
+ #expect(engine.resolveAndLoadCalls.count == 6)
674
+ #expect(player.state == .playing)
675
+ #expect(callbacks.errorEvents.isEmpty)
559
676
  }
560
677
 
561
678
  @Test func theNetworkReturningWithRetryOffLeavesTheStallToAVPlayer() throws {
@@ -578,7 +695,7 @@ struct PlayerRecoveringTests {
578
695
 
579
696
  @Test func theNetworkReturningDuringABackoffLeavesTheReloadToTheRetry() async throws {
580
697
  let engine = MockPlayerEngine()
581
- let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05), retries: nil)
698
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
582
699
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")])
583
700
  player.play()
584
701
  player.transition(.avPlayerWaiting)
@@ -606,7 +723,6 @@ struct PlayerRecoveringTests {
606
723
 
607
724
  @Test func theNetworkReturningReRendersBeforeReconnecting() async throws {
608
725
  let (player, engine, _) = try makePlaying()
609
- player.retry.shouldRetry = { true }
610
726
  player.transition(.avPlayerWaiting)
611
727
  var order: [String] = []
612
728
  engine.onSeamCall = { order.append($0) }
@@ -623,21 +739,20 @@ struct PlayerRecoveringTests {
623
739
  let (player, engine, _) = try makePlaying()
624
740
  engine.emit(.audioDidStart)
625
741
  let first = player.load
626
- #expect(first?.hasPlayed == true)
742
+ #expect(player.retry.hasPlayed)
627
743
 
628
744
  engine.emit(.unplayable)
629
745
  #expect(player.state == .error)
630
746
  player.play()
631
747
 
632
748
  #expect(player.load?.id != first?.id)
633
- #expect(player.load?.hasPlayed == false)
749
+ #expect(!player.retry.hasPlayed)
634
750
  #expect(player.load?.primedNowPlaying == false)
635
751
  #expect(engine.recreateCount == 1)
636
752
  }
637
753
 
638
754
  @Test func aRetryKeepsItsLoad() async throws {
639
755
  let (player, engine, _) = try makePlaying()
640
- player.retry.shouldRetry = { true }
641
756
  let first = player.load
642
757
  engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
643
758
  await player.retry.pendingTask?.value
@@ -647,7 +762,6 @@ struct PlayerRecoveringTests {
647
762
 
648
763
  @Test func aRetryAfterTheAVPlayerItselfFailedReloadsOnANewOne_inTheSameLoad() async throws {
649
764
  let (player, engine, _) = try makePlaying()
650
- player.retry.shouldRetry = { true }
651
765
  engine.emit(.audioDidStart)
652
766
  let first = player.load
653
767
  engine.playerFailed = true
@@ -658,12 +772,12 @@ struct PlayerRecoveringTests {
658
772
  #expect(engine.recreateCount == 1)
659
773
  #expect(engine.resolveAndLoadCalls.count == 2)
660
774
  #expect(player.load?.id == first?.id)
661
- #expect(player.load?.hasPlayed == true)
775
+ #expect(player.retry.hasPlayed)
662
776
  }
663
777
 
664
778
  @Test func aMediaServicesResetDuringABackoffReloadsOnce() async throws {
665
779
  let engine = MockPlayerEngine()
666
- let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05), retries: nil)
780
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
667
781
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
668
782
  engine.hasItem = true
669
783
  engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
@@ -774,7 +888,7 @@ struct PlayerReviewRegressionTests {
774
888
  @Test func aRestartFromAnErrorDuringTheStartSeekKeepsTheStart() throws {
775
889
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
776
890
  let engine = MockPlayerEngine()
777
- let player = makePlayer(engine: engine, retries: false)
891
+ let player = makePlayer(engine: engine)
778
892
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
779
893
  engine.seekResult = nil
780
894
  engine.hasItem = true
@@ -794,7 +908,7 @@ struct PlayerReviewRegressionTests {
794
908
 
795
909
  @Test func aSeekInAnErrorDuringTheStartSeekReplacesTheStart() throws {
796
910
  let engine = MockPlayerEngine()
797
- let player = makePlayer(engine: engine, retries: false)
911
+ let player = makePlayer(engine: engine)
798
912
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
799
913
  engine.seekResult = nil
800
914
  engine.hasItem = true
@@ -884,7 +998,7 @@ struct PlayerReviewRegressionTests {
884
998
 
885
999
  @Test func aStartPositionIsSavedWithTheTrackChange() throws {
886
1000
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
887
- let player = makePlayer(retries: false)
1001
+ let player = makePlayer()
888
1002
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "A")], startPositionMs: 30000)
889
1003
  let saved = PlaybackPersistence(defaults: UserDefaults(suiteName: "PlayerTests")!) { nil }.load()
890
1004
  #expect(saved?.positionMs == 30000)
@@ -920,7 +1034,7 @@ struct PlayerReviewRegressionTests {
920
1034
  @Test func playingSavesPeriodically() async throws {
921
1035
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
922
1036
  let engine = MockPlayerEngine()
923
- let player = makePlayer(engine: engine, retries: false, saveInterval: .milliseconds(10))
1037
+ let player = makePlayer(engine: engine, saveInterval: .milliseconds(10))
924
1038
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
925
1039
  engine.hasItem = true
926
1040
  engine.hasLoadedAsset = true
@@ -944,7 +1058,7 @@ struct PlayerReviewRegressionTests {
944
1058
  )
945
1059
  PlaybackPersistence(defaults: defaults) { saved }.save()
946
1060
 
947
- let player = makePlayer(retries: false)
1061
+ let player = makePlayer()
948
1062
  let session = try #require(player.persistedSession())
949
1063
  player.resume(session, queue: nil)
950
1064
  #expect(player.currentTrack?.id == "t1")
@@ -962,12 +1076,11 @@ struct PlayerReviewRegressionTests {
962
1076
  positionMs: nil, repeatMode: "off", shuffleEnabled: false, playbackSpeed: 1,
963
1077
  )
964
1078
  PlaybackPersistence(defaults: defaults) { saved }.save()
965
- #expect(makePlayer(retries: false).persistedSession() == nil)
1079
+ #expect(makePlayer().persistedSession() == nil)
966
1080
  }
967
1081
 
968
1082
  @Test func aTrackChangeClearsTheRetryingErrorOfTheTrackItLeaves() async throws {
969
1083
  let (player, engine, callbacks) = try makeLoading()
970
- player.retry.shouldRetry = { true }
971
1084
  player.setPlayWhenReady(true)
972
1085
  engine.emit(.loadFailed(URLError(.timedOut)))
973
1086
  #expect(callbacks.playbackChanges.last?.error != nil)
@@ -11,7 +11,7 @@ private func makeCoordinator() -> (
11
11
  ) {
12
12
  let clock = ManualSleepTimerScheduler()
13
13
  let engine = MockPlayerEngine()
14
- let player = makePlayer(engine: engine, retries: false, sleepTimerScheduler: clock)
14
+ let player = makePlayer(engine: engine, sleepTimerScheduler: clock)
15
15
  let callbacks = MockPlayerCallbacks()
16
16
  player.callbacks = callbacks
17
17
  return (player, engine, callbacks, clock)
@@ -113,6 +113,8 @@ private func makeRetrying() -> (
113
113
  let retryHandler = makeRetryLoop()
114
114
  let engine = MockPlayerEngine()
115
115
  let player = makePlayer(engine: engine, retry: retryHandler)
116
+ // The loop's intent alone, so a test drives the states without the engine calls a play makes.
117
+ retryHandler.playIntentChanged(true)
116
118
  let callbacks = MockPlayerCallbacks()
117
119
  player.callbacks = callbacks
118
120
  return (player, retryHandler, callbacks, engine)
@@ -192,6 +194,8 @@ struct RetryingErrorTests {
192
194
  c.retry.handleError(URLError(.cannotConnectToHost), context: .mediaLoad)
193
195
  await c.retry.pendingTask?.value
194
196
 
197
+ // With no track, the reload starts no connection: the second failure needs one of its own.
198
+ c.retry.connectionStarted()
195
199
  c.retry.handleError(URLError(.cannotConnectToHost), context: .mediaLoad)
196
200
  await c.retry.pendingTask?.value
197
201
 
@@ -254,14 +258,12 @@ struct RetryingErrorTests {
254
258
  maxRetries: 2, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
255
259
  )))
256
260
  let stall = NSError(domain: "CoreMediaErrorDomain", code: -16830)
257
- // One retry spent before the pause; the park refills the budget.
261
+ // One retry spent before the pause; the play after it starts the count over.
258
262
  eh.emit(.failed(stall, httpStatusCode: nil))
259
263
  await c.retry.pendingTask?.value
260
- #expect(c.retry.attempts == 1)
261
264
 
262
265
  c.pause()
263
266
  eh.emit(.failed(stall, httpStatusCode: nil))
264
- #expect(c.retry.attempts == 0)
265
267
  c.play()
266
268
  eh.resolveAndLoadCalls.removeAll()
267
269
 
@@ -394,7 +396,7 @@ struct RetryingErrorTests {
394
396
  @MainActor
395
397
  private func makePlayingWithRetries() throws -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
396
398
  let engine = MockPlayerEngine()
397
- let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05), retries: nil)
399
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
398
400
  let callbacks = MockPlayerCallbacks()
399
401
  player.callbacks = callbacks
400
402
  try startPlaying(player, engine)
@@ -963,69 +965,6 @@ struct NaturalEndPlayIntentTests {
963
965
  }
964
966
  }
965
967
 
966
- // MARK: - Healthy playback refills the retry budget
967
-
968
- /// Sustained playback proves the stream recovered, so the retry budget refills (as on
969
- /// Android); otherwise a long-lived stream loses retry after its first recovered blip.
970
- @Suite("Player - healthy playback resets retry budget")
971
- struct HealthyPlaybackRetryResetTests {
972
- /// A nonzero delay skips the retry, leaving the caller to start one that stays pending.
973
- @MainActor
974
- private func makeAfterOneRetry(delay: TimeInterval = 0) async -> (Player, RetryLoop, MockPlayerEngine) {
975
- let retry = makeRetryLoop(delay: delay)
976
- let engine = MockPlayerEngine()
977
- let player = makePlayer(engine: engine, retry: retry)
978
- if delay == 0 {
979
- retry.handleError(URLError(.timedOut), context: .playback)
980
- await retry.pendingTask?.value
981
- }
982
- return (player, retry, engine)
983
- }
984
-
985
- @Test @MainActor
986
- func sustainedPlayback_resetsRetryBudget() async {
987
- let (player, retry, _) = await makeAfterOneRetry()
988
- #expect(retry.attempts == 1)
989
- retry.healthyPlaybackDuration = .milliseconds(10)
990
-
991
- player.transition(.avPlayerPlaying)
992
- await retry.healthyPlaybackTask?.value
993
-
994
- #expect(retry.attempts == 0)
995
- }
996
-
997
- /// reset() cancels a pending retry: a refill now would silently kill an in-flight reconnect.
998
- @Test @MainActor
999
- func refill_skipsWhileRetryIsPending() async {
1000
- let (player, retry, _) = await makeAfterOneRetry(delay: 1)
1001
- retry.healthyPlaybackDuration = .milliseconds(10)
1002
-
1003
- player.transition(.avPlayerPlaying)
1004
- retry.handleError(URLError(.timedOut), context: .playback)
1005
- await retry.healthyPlaybackTask?.value
1006
-
1007
- #expect(retry.pendingTask != nil)
1008
- retry.cancel()
1009
- }
1010
-
1011
- @Test @MainActor
1012
- func playbackInterruptedBeforeThreshold_doesNotReset() async {
1013
- let (player, retry, engine) = await makeAfterOneRetry()
1014
- engine.hasLoadedAsset = true
1015
- retry.healthyPlaybackDuration = .milliseconds(500)
1016
-
1017
- player.transition(.avPlayerPlaying)
1018
- let refill = retry.healthyPlaybackTask
1019
- player.transition(.avPlayerWaiting)
1020
-
1021
- // Leaving .playing cancels the refill; awaiting the cancelled task reaches, deterministically,
1022
- // the point where it would have fired.
1023
- await refill?.value
1024
-
1025
- #expect(retry.attempts == 1)
1026
- }
1027
- }
1028
-
1029
968
  // MARK: - Sleep Timer Fade
1030
969
 
1031
970
  @Suite("Player - sleep timer fade")
@@ -1373,27 +1312,13 @@ struct LoadTests {
1373
1312
  let (c, eh, _, _) = makeCoordinator()
1374
1313
  try c.setQueue([track("a"), track("b")])
1375
1314
  let first = c.load
1376
- eh.emit(.audioDidStart)
1377
- #expect(c.load?.hasPlayed == true)
1315
+ c.transition(.avPlayerPlaying)
1316
+ #expect(c.retry.hasPlayed)
1378
1317
 
1379
1318
  c.next()
1380
1319
 
1381
1320
  #expect(c.load != nil && c.load?.id != first?.id)
1382
- #expect(c.load?.hasPlayed == false)
1383
- }
1384
-
1385
- /// The healthy-playback refill resets the retry budget mid-play; the load must survive it.
1386
- @Test @MainActor
1387
- func aRetryResetKeepsTheLoad() throws {
1388
- let (c, eh, _, _) = makeCoordinator()
1389
- try c.setQueue([track("a")])
1390
- eh.emit(.audioDidStart)
1391
- let load = c.load
1392
-
1393
- c.retry.reset()
1394
-
1395
- #expect(c.load == load)
1396
- #expect(c.load?.hasPlayed == true)
1321
+ #expect(!c.retry.hasPlayed)
1397
1322
  }
1398
1323
 
1399
1324
  @Test
@@ -1462,6 +1387,7 @@ struct StopCancelsRetryTests {
1462
1387
  let errorHandler = makeRetryLoop(delay: 0.05)
1463
1388
  let engine = MockPlayerEngine()
1464
1389
  let player = makePlayer(engine: engine, retry: errorHandler)
1390
+ errorHandler.playIntentChanged(true)
1465
1391
  let callbacks = MockPlayerCallbacks()
1466
1392
  player.callbacks = callbacks
1467
1393