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

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,40 @@ 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
+
65
+ /// A live stream connecting, its retry loop on a virtual clock; the engine reports `previousBuffered`
66
+ /// from the item the connect replaces until the test prepares one.
67
+ @MainActor
68
+ private func makeConnecting(
69
+ playWhenReady: Bool = true,
70
+ previousBuffered: Double = 0,
71
+ ) throws -> (Player, MockPlayerEngine, VirtualClock) {
72
+ let clock = VirtualClock()
73
+ let retry = RetryLoop(clock: clock)
74
+ retry.updatePolicy(from: .first(true))
75
+ let engine = MockPlayerEngine()
76
+ engine.bufferedPosition = previousBuffered
77
+ let player = makePlayer(engine: engine, retry: retry)
78
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T", live: true)], playWhenReady: playWhenReady)
79
+ return (player, engine, clock)
80
+ }
81
+
48
82
  @Suite("Player - seeking")
49
83
  @MainActor
50
84
  struct PlayerSeekingTests {
@@ -95,7 +129,7 @@ struct PlayerSeekingTests {
95
129
 
96
130
  @Test func aCompletionFromBeforeAReloadIsDropped() throws {
97
131
  let engine = MockPlayerEngine()
98
- let player = makePlayer(engine: engine, retries: false)
132
+ let player = makePlayer(engine: engine)
99
133
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
100
134
  engine.seekResult = nil
101
135
  engine.hasItem = true
@@ -114,7 +148,7 @@ struct PlayerSeekingTests {
114
148
 
115
149
  @Test func aStartSeekCutShortWaitsForTheNextItem() throws {
116
150
  let engine = MockPlayerEngine()
117
- let player = makePlayer(engine: engine, retries: false)
151
+ let player = makePlayer(engine: engine)
118
152
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
119
153
  engine.seekResult = nil
120
154
  engine.hasItem = true
@@ -130,7 +164,7 @@ struct PlayerSeekingTests {
130
164
  /// A media-load retry passes no position, so the start in flight is what it resumes from.
131
165
  @Test func aReloadThatDoesNotResumeKeepsTheStartInFlight() throws {
132
166
  let engine = MockPlayerEngine()
133
- let player = makePlayer(engine: engine, retries: false)
167
+ let player = makePlayer(engine: engine)
134
168
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
135
169
  engine.seekResult = nil
136
170
  engine.hasItem = true
@@ -146,7 +180,7 @@ struct PlayerSeekingTests {
146
180
 
147
181
  @Test func aMediaServicesResetDuringTheLoadKeepsTheStart() throws {
148
182
  let engine = MockPlayerEngine()
149
- let player = makePlayer(engine: engine, retries: false)
183
+ let player = makePlayer(engine: engine)
150
184
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
151
185
 
152
186
  player.mediaServicesWereReset()
@@ -158,7 +192,7 @@ struct PlayerSeekingTests {
158
192
 
159
193
  @Test func aPlayRightAfterAStopDuringTheStartSeekStartsOver() throws {
160
194
  let engine = MockPlayerEngine()
161
- let player = makePlayer(engine: engine, retries: false)
195
+ let player = makePlayer(engine: engine)
162
196
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
163
197
  engine.seekResult = nil
164
198
  engine.hasItem = true
@@ -174,7 +208,7 @@ struct PlayerSeekingTests {
174
208
 
175
209
  @Test func theLiveEdgeDuringALoadWaitsForTheStartSeek() throws {
176
210
  let engine = MockPlayerEngine()
177
- let player = makePlayer(engine: engine, retries: false)
211
+ let player = makePlayer(engine: engine)
178
212
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.m3u8", title: "T", live: true)], startPositionMs: 25000)
179
213
  engine.seekResult = nil
180
214
  engine.hasItem = true
@@ -220,7 +254,6 @@ struct PlayerEngineEventTests {
220
254
  @Test func aFailedLoadPrimesNowPlayingOncePerLoad() throws {
221
255
  let (player, engine, _) = try makeLoading()
222
256
  player.setPlayWhenReady(true)
223
- player.retry.shouldRetry = { true }
224
257
  engine.emit(.loadFailed(URLError(.timedOut)))
225
258
  engine.emit(.loadFailed(URLError(.timedOut)))
226
259
  #expect(engine.primeCount == 1)
@@ -286,18 +319,15 @@ struct PlayerEngineEventTests {
286
319
  #expect(player.state == .ended)
287
320
 
288
321
  let (live, liveEngine, _) = try makePlaying(live: true)
289
- live.retry.shouldRetry = { true }
290
322
  liveEngine.emit(.playedToEnd)
291
323
  await live.retry.pendingTask?.value
292
324
  #expect(live.state == .loading)
293
325
  #expect(liveEngine.resolveAndLoadCalls.count == 2)
294
- #expect(live.retry.attempts == 1)
295
326
  }
296
327
 
297
328
  /// AVPlayer pauses an item at its end, so a seek within its window would leave it silent.
298
329
  @Test func aLiveEndReconnectsEvenWithASeekableWindow() async throws {
299
330
  let (player, engine, _) = try makePlaying(live: true)
300
- player.retry.shouldRetry = { true }
301
331
  engine.liveEdge = 120
302
332
  engine.emit(.playedToEnd)
303
333
  await player.retry.pendingTask?.value
@@ -310,34 +340,30 @@ struct PlayerEngineEventTests {
310
340
  player.retry.updatePolicy(from: .second(RetryConfig(
311
341
  maxRetries: 3, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
312
342
  )))
313
- player.retry.shouldRetry = { true }
314
343
  for _ in 0 ..< 20 where player.state != .error {
315
344
  engine.emit(.playedToEnd)
316
345
  await player.retry.pendingTask?.value
346
+ engine.hasLoadedAsset = true
317
347
  engine.emit(.itemPrepared(likelyToKeepUp: true))
318
348
  }
319
- #expect(engine.resolveAndLoadCalls.count == 4)
349
+ // The first connection played, so its end starts the count: four that deliver nothing follow.
350
+ #expect(engine.resolveAndLoadCalls.count == 5)
320
351
  #expect(player.state == .error)
321
352
  #expect(player.errorStatus.error == .playbackStalled)
322
353
  #expect(callbacks.errorEvents.count == 1)
323
354
  }
324
355
 
325
- /// Each reconnect plays long enough to refill the budget, as a stream closing once an hour does.
326
- @Test func liveEndsFarApartNeverSpendTheBudget() async throws {
356
+ /// A connection that delivered audio starts `maxRetries`' count over (docs/adr/0014).
357
+ @Test func liveEndsBetweenAudioNeverSpendMaxRetries() async throws {
327
358
  let (player, engine, callbacks) = try makePlaying(live: true)
328
359
  player.retry.updatePolicy(from: .second(RetryConfig(
329
360
  maxRetries: 1, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
330
361
  )))
331
- player.retry.shouldRetry = { true }
332
- player.retry.healthyPlaybackDuration = .milliseconds(10)
333
362
  for _ in 0 ..< 5 {
334
363
  engine.emit(.playedToEnd)
335
364
  await player.retry.pendingTask?.value
336
- #expect(player.retry.attempts == 1)
337
365
  engine.emit(.itemPrepared(likelyToKeepUp: true))
338
366
  player.transition(.avPlayerPlaying)
339
- await player.retry.healthyPlaybackTask?.value
340
- #expect(player.retry.attempts == 0)
341
367
  }
342
368
  #expect(engine.resolveAndLoadCalls.count == 6)
343
369
  #expect(player.state == .playing)
@@ -357,7 +383,6 @@ struct PlayerEngineEventTests {
357
383
  /// The engine stops observing an item on a reload; a played-to-end it delivered late is stale.
358
384
  @Test func aPlayedToEndDuringALoadIsIgnored() throws {
359
385
  let (player, engine, _) = try makePlaying(live: true)
360
- player.retry.shouldRetry = { true }
361
386
  player.reloadResolving(startFromCurrentTime: false)
362
387
  #expect(player.state == .loading)
363
388
  engine.emit(.playedToEnd)
@@ -416,7 +441,12 @@ struct PlayerRecoveringTests {
416
441
  }
417
442
 
418
443
  @Test func aStallWithNoFailureEndsInPlaybackStalledOnceTheBudgetIsSpent() async throws {
419
- let (player, _, callbacks) = try makeStalling(givesUp: true)
444
+ let (player, engine, callbacks) = try makeStalling(givesUp: true)
445
+ await player.retry.stallTask?.value
446
+ await player.retry.pendingTask?.value
447
+ // The stalled connection had played, so even `maxRetries: 0` reconnects it once.
448
+ #expect(engine.resolveAndLoadCalls.count == 2)
449
+ player.transition(.avPlayerWaiting)
420
450
  await player.retry.stallTask?.value
421
451
  await player.retry.pendingTask?.value
422
452
  #expect(player.state == .error)
@@ -463,8 +493,91 @@ struct PlayerRecoveringTests {
463
493
 
464
494
  @Test func aTrackChangeEndsTheStallWatch() throws {
465
495
  let (player, _, _) = try makeStalling()
496
+ let stallWatch = player.retry.stallTask
466
497
  try player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
467
- #expect(player.retry.stallTask == nil)
498
+ #expect(stallWatch?.isCancelled == true)
499
+ }
500
+
501
+ @Test func aConnectThatSendsNothingIsReplacedAfterTheTimeout() async throws {
502
+ let (player, engine, clock) = try makeConnecting()
503
+ await clock.run(until: 30_999)
504
+ #expect(engine.resolveAndLoadCalls.count == 1)
505
+ await clock.run(until: 31_000)
506
+ #expect(engine.resolveAndLoadCalls.count == 2)
507
+ #expect(player.state == .loading)
508
+ }
509
+
510
+ /// The item it replaces had buffered further than the new one has yet.
511
+ @Test func aSlowConnectThatKeepsReceivingDataIsKept() async throws {
512
+ let (player, engine, clock) = try makeConnecting(previousBuffered: 50)
513
+ engine.hasItem = true
514
+ engine.bufferedPosition = 1
515
+ engine.emit(.itemPrepared(likelyToKeepUp: false))
516
+ for atMs in stride(from: 20_000, through: 100_000, by: 20_000) {
517
+ clock.at(atMs) { engine.bufferedPosition += 1 }
518
+ }
519
+ await clock.run(until: 100_000)
520
+ #expect(player.state == .loading)
521
+ #expect(engine.resolveAndLoadCalls.count == 1)
522
+ }
523
+
524
+ /// A stall's reconnect: the stalled item stays in the engine, still buffering, while the new
525
+ /// connect sends nothing.
526
+ @Test func theItemAConnectReplacesBufferingOnIsNoProgress() async throws {
527
+ let (player, engine, _, clock) = try makeVirtual()
528
+ engine.bufferedPosition = 50
529
+ player.transition(.avPlayerPlaying)
530
+ await clock.run(until: 10_000)
531
+ player.transition(.avPlayerWaiting)
532
+ await clock.run(until: 40_000)
533
+ #expect(engine.resolveAndLoadCalls.count == 2)
534
+
535
+ for atMs in stride(from: 45_000, through: 70_000, by: 5_000) {
536
+ clock.at(atMs) { engine.bufferedPosition += 1 }
537
+ }
538
+ await clock.run(until: 70_000)
539
+ await clock.run(until: 71_000)
540
+ #expect(engine.resolveAndLoadCalls.count == 3)
541
+ }
542
+
543
+ @Test func aPauseDuringAConnectHoldsItPastTheTimeout() async throws {
544
+ let (player, engine, clock) = try makeConnecting()
545
+ await clock.run(until: 10_000)
546
+ player.pause()
547
+ await clock.run(until: 200_000)
548
+ #expect(engine.resolveAndLoadCalls.count == 1)
549
+ #expect(player.load?.reloadOnPlay == false)
550
+ #expect(player.state == .loading)
551
+ }
552
+
553
+ @Test func withRetryOffASilentConnectIsTerminalAtTheTimeout() async throws {
554
+ let (player, engine, clock) = try makeConnecting()
555
+ player.retry.updatePolicy(from: nil)
556
+ await clock.run(until: 29_999)
557
+ #expect(player.state == .loading)
558
+ await clock.run(until: 30_000)
559
+ #expect(player.state == .error)
560
+ #expect(player.errorStatus.error == .playbackStalled)
561
+ #expect(engine.resolveAndLoadCalls.count == 1)
562
+ }
563
+
564
+ @Test func aPlayWhileConnectingWatchesTheConnect() async throws {
565
+ let (player, engine, clock) = try makeConnecting(playWhenReady: false)
566
+ await clock.run(until: 10_000)
567
+ player.play()
568
+ await clock.run(until: 41_000)
569
+ #expect(engine.resolveAndLoadCalls.count == 2)
570
+ }
571
+
572
+ /// Ready and waiting for AVPlayer to start: its waiting is a stall, watched in .buffering.
573
+ @Test func aConnectThatIsReadyIsNoLongerWatched() async throws {
574
+ let (player, engine, clock) = try makeConnecting()
575
+ engine.hasItem = true
576
+ engine.hasLoadedAsset = true
577
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
578
+ #expect(player.state == .ready)
579
+ await clock.run(until: 100_000)
580
+ #expect(engine.resolveAndLoadCalls.count == 1)
468
581
  }
469
582
 
470
583
  /// A link slower than the bitrate rebuffers for longer than the timeout, and a reload would
@@ -528,34 +641,147 @@ struct PlayerRecoveringTests {
528
641
  #expect(engine.resolveAndLoadCalls.count == 1)
529
642
  }
530
643
 
531
- @Test func theNetworkReturningReconnectsAStalledStream_throughTheRetryLoop() async throws {
532
- let (player, engine, _) = try makePlaying()
533
- player.retry.shouldRetry = { true }
644
+ @Test func theDeadlineEndsASilentLoadInOneError_droppingTheConnectInFlight() async throws {
645
+ let clock = VirtualClock()
646
+ let retry = RetryLoop(clock: clock)
647
+ retry.updatePolicy(from: .first(true))
648
+ let engine = MockPlayerEngine()
649
+ let player = makePlayer(engine: engine, retry: retry)
650
+ let callbacks = MockPlayerCallbacks()
651
+ player.callbacks = callbacks
652
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
653
+ // The watch replaces the silent connect at 30 s, 1 s after it gives up on it; that failure
654
+ // brings the deadline to 42 s.
655
+ await clock.run(until: 31_000)
656
+ #expect(engine.resolveAndLoadCalls.count == 2)
657
+ let cancels = engine.cancelLoadingCount, stops = engine.stopObservingItemCount
658
+
659
+ await clock.run(until: 41_999)
660
+ #expect(player.state == .loading)
661
+ await clock.run(until: 42_000)
662
+
663
+ #expect(player.state == .error)
664
+ #expect(player.errorStatus.error == .playbackStalled)
665
+ #expect(callbacks.errorEvents.count == 1)
666
+ #expect(engine.cancelLoadingCount == cancels + 1)
667
+ #expect(engine.stopObservingItemCount == stops + 1)
668
+ }
669
+
670
+ /// The error pauses AVPlayer, and an item still connecting can report late: neither the pause,
671
+ /// nor its playing, nor its failure takes the state out of .error.
672
+ @Test func aTerminalErrorHoldsAgainstTheAVPlayersLateEvents() async throws {
673
+ let (player, engine, callbacks) = try makeStalling(givesUp: true)
674
+ engine.emit(.failed(URLError(.badURL), httpStatusCode: nil))
675
+ #expect(player.state == .error)
676
+ let loads = engine.resolveAndLoadCalls.count
677
+
678
+ engine.emit(.timeControlStatus(.paused, waitingForNoItem: false))
679
+ engine.emit(.timeControlStatus(.playing, waitingForNoItem: false))
680
+ engine.emit(.audioDidStart)
681
+ engine.emit(.failed(NSError(domain: "AVFoundationErrorDomain", code: -11800), httpStatusCode: nil))
682
+ await player.retry.pendingTask?.value
683
+
684
+ #expect(player.state == .error)
685
+ #expect(player.errorStatus.error == .playbackFailed)
686
+ #expect(callbacks.errorEvents.count == 1)
687
+ #expect(player.retry.pendingTask == nil)
688
+ #expect(engine.resolveAndLoadCalls.count == loads)
689
+ }
690
+
691
+ /// The stalled connection ends with the network, before its return reaches the loop, so it
692
+ /// grows no backoff: only the 1 s floor applies, long past.
693
+ @Test func theNetworkReturningReconnectsAStalledStreamAtOnce() async throws {
694
+ let (player, engine, _, clock) = try makeVirtual(online: false)
534
695
  player.transition(.avPlayerWaiting)
535
696
  #expect(player.state == .buffering)
697
+ await clock.run(until: 5_000)
698
+
536
699
  player.networkStatusDidChange(isOnline: true)
537
- await player.retry.pendingTask?.value
700
+ await clock.run(until: 5_000)
701
+
538
702
  #expect(engine.resolveAndLoadCalls.count == 2)
539
- #expect(player.retry.attempts == 1)
540
703
  }
541
704
 
542
- @Test func aFlappingConnectionEndsInATerminalErrorOnceTheBudgetIsSpent() async throws {
705
+ /// The watch replaces the stall at 40 s at once, having played, then each silent connect 30 s
706
+ /// after it starts, 1 s and then 1.5 s later: the deadline still falls 120 s into the silence.
707
+ @Test func playbackThatStopsWithNoFailureEndsAtTheDeadline() async throws {
708
+ let (player, engine, callbacks, clock) = try makeVirtual()
709
+ player.transition(.avPlayerPlaying)
710
+ await clock.run(until: 10_000)
711
+ player.transition(.avPlayerWaiting)
712
+
713
+ await clock.run(until: 129_999)
714
+ #expect(player.state == .loading)
715
+ #expect(engine.resolveAndLoadCalls.count == 4)
716
+ await clock.run(until: 130_000)
717
+ #expect(player.state == .error)
718
+ #expect(player.errorStatus.error == .playbackStalled)
719
+ #expect(callbacks.errorEvents.count == 1)
720
+ }
721
+
722
+ @Test func aRetryNowKeepsTheSilenceDeadline() async throws {
723
+ let (player, _, _, clock) = try makeVirtual()
724
+ // Its watch would end the reload's connect first.
725
+ player.retry.stallTimeout = .seconds(600)
726
+ await clock.run(until: 60_000)
727
+ player.retryNow()
728
+
729
+ await clock.run(until: 119_999)
730
+ #expect(player.state != .error)
731
+ await clock.run(until: 120_000)
732
+ #expect(player.state == .error)
733
+ }
734
+
735
+ @Test func hasPlayedSurvivesAPark_aRetryNowAndAMediaReset() async throws {
736
+ let engine = MockPlayerEngine()
737
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
738
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
739
+ engine.hasItem = true
740
+ engine.hasLoadedAsset = true
741
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
742
+ player.transition(.avPlayerPlaying)
743
+ #expect(player.retry.hasPlayed)
744
+
745
+ engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
746
+ player.pause()
747
+ #expect(player.state == .paused)
748
+ player.play()
749
+ player.retryNow()
750
+ player.mediaServicesWereReset()
751
+
752
+ #expect(player.retry.hasPlayed)
753
+ player.retry.cancel()
754
+ }
755
+
756
+ @Test func aRateChangeInAnErrorLeavesTheAbandonedItemPaused() throws {
757
+ let (player, engine, _) = try makePlaying()
758
+ engine.emit(.failed(URLError(.badURL), httpStatusCode: nil))
759
+ #expect(player.state == .error)
760
+ #expect(player.playWhenReady)
761
+
762
+ player.rate = 1.5
763
+
764
+ #expect(engine.rates.last?.rate == 1.5)
765
+ #expect(engine.rates.last?.playing == false)
766
+ }
767
+
768
+ /// `maxRetries` counts connections in a row that delivered nothing; one that plays between
769
+ /// flaps starts it over, and only the silence deadline bounds it (docs/adr/0014).
770
+ @Test func aFlappingConnectionThatPlaysBetweenKeepsReconnecting() async throws {
543
771
  let (player, engine, callbacks) = try makePlaying()
544
772
  player.retry.updatePolicy(from: .second(RetryConfig(
545
773
  maxRetries: 2, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
546
774
  )))
547
- player.retry.shouldRetry = { true }
548
- for flap in 1 ... 3 {
775
+ for _ in 1 ... 5 {
549
776
  player.transition(.avPlayerWaiting)
550
777
  player.networkStatusDidChange(isOnline: true)
551
778
  await player.retry.pendingTask?.value
552
- if flap == 3 { break }
553
779
  engine.emit(.itemPrepared(likelyToKeepUp: true))
554
780
  player.transition(.avPlayerPlaying)
555
781
  }
556
- #expect(engine.resolveAndLoadCalls.count == 3)
557
- #expect(player.state == .error)
558
- #expect(callbacks.errorEvents.count == 1)
782
+ #expect(engine.resolveAndLoadCalls.count == 6)
783
+ #expect(player.state == .playing)
784
+ #expect(callbacks.errorEvents.isEmpty)
559
785
  }
560
786
 
561
787
  @Test func theNetworkReturningWithRetryOffLeavesTheStallToAVPlayer() throws {
@@ -578,7 +804,7 @@ struct PlayerRecoveringTests {
578
804
 
579
805
  @Test func theNetworkReturningDuringABackoffLeavesTheReloadToTheRetry() async throws {
580
806
  let engine = MockPlayerEngine()
581
- let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05), retries: nil)
807
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
582
808
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")])
583
809
  player.play()
584
810
  player.transition(.avPlayerWaiting)
@@ -606,7 +832,6 @@ struct PlayerRecoveringTests {
606
832
 
607
833
  @Test func theNetworkReturningReRendersBeforeReconnecting() async throws {
608
834
  let (player, engine, _) = try makePlaying()
609
- player.retry.shouldRetry = { true }
610
835
  player.transition(.avPlayerWaiting)
611
836
  var order: [String] = []
612
837
  engine.onSeamCall = { order.append($0) }
@@ -623,21 +848,20 @@ struct PlayerRecoveringTests {
623
848
  let (player, engine, _) = try makePlaying()
624
849
  engine.emit(.audioDidStart)
625
850
  let first = player.load
626
- #expect(first?.hasPlayed == true)
851
+ #expect(player.retry.hasPlayed)
627
852
 
628
853
  engine.emit(.unplayable)
629
854
  #expect(player.state == .error)
630
855
  player.play()
631
856
 
632
857
  #expect(player.load?.id != first?.id)
633
- #expect(player.load?.hasPlayed == false)
858
+ #expect(!player.retry.hasPlayed)
634
859
  #expect(player.load?.primedNowPlaying == false)
635
860
  #expect(engine.recreateCount == 1)
636
861
  }
637
862
 
638
863
  @Test func aRetryKeepsItsLoad() async throws {
639
864
  let (player, engine, _) = try makePlaying()
640
- player.retry.shouldRetry = { true }
641
865
  let first = player.load
642
866
  engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
643
867
  await player.retry.pendingTask?.value
@@ -647,7 +871,6 @@ struct PlayerRecoveringTests {
647
871
 
648
872
  @Test func aRetryAfterTheAVPlayerItselfFailedReloadsOnANewOne_inTheSameLoad() async throws {
649
873
  let (player, engine, _) = try makePlaying()
650
- player.retry.shouldRetry = { true }
651
874
  engine.emit(.audioDidStart)
652
875
  let first = player.load
653
876
  engine.playerFailed = true
@@ -658,12 +881,12 @@ struct PlayerRecoveringTests {
658
881
  #expect(engine.recreateCount == 1)
659
882
  #expect(engine.resolveAndLoadCalls.count == 2)
660
883
  #expect(player.load?.id == first?.id)
661
- #expect(player.load?.hasPlayed == true)
884
+ #expect(player.retry.hasPlayed)
662
885
  }
663
886
 
664
887
  @Test func aMediaServicesResetDuringABackoffReloadsOnce() async throws {
665
888
  let engine = MockPlayerEngine()
666
- let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05), retries: nil)
889
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
667
890
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
668
891
  engine.hasItem = true
669
892
  engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
@@ -774,7 +997,7 @@ struct PlayerReviewRegressionTests {
774
997
  @Test func aRestartFromAnErrorDuringTheStartSeekKeepsTheStart() throws {
775
998
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
776
999
  let engine = MockPlayerEngine()
777
- let player = makePlayer(engine: engine, retries: false)
1000
+ let player = makePlayer(engine: engine)
778
1001
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
779
1002
  engine.seekResult = nil
780
1003
  engine.hasItem = true
@@ -794,7 +1017,7 @@ struct PlayerReviewRegressionTests {
794
1017
 
795
1018
  @Test func aSeekInAnErrorDuringTheStartSeekReplacesTheStart() throws {
796
1019
  let engine = MockPlayerEngine()
797
- let player = makePlayer(engine: engine, retries: false)
1020
+ let player = makePlayer(engine: engine)
798
1021
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
799
1022
  engine.seekResult = nil
800
1023
  engine.hasItem = true
@@ -884,7 +1107,7 @@ struct PlayerReviewRegressionTests {
884
1107
 
885
1108
  @Test func aStartPositionIsSavedWithTheTrackChange() throws {
886
1109
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
887
- let player = makePlayer(retries: false)
1110
+ let player = makePlayer()
888
1111
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "A")], startPositionMs: 30000)
889
1112
  let saved = PlaybackPersistence(defaults: UserDefaults(suiteName: "PlayerTests")!) { nil }.load()
890
1113
  #expect(saved?.positionMs == 30000)
@@ -920,7 +1143,7 @@ struct PlayerReviewRegressionTests {
920
1143
  @Test func playingSavesPeriodically() async throws {
921
1144
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
922
1145
  let engine = MockPlayerEngine()
923
- let player = makePlayer(engine: engine, retries: false, saveInterval: .milliseconds(10))
1146
+ let player = makePlayer(engine: engine, saveInterval: .milliseconds(10))
924
1147
  try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
925
1148
  engine.hasItem = true
926
1149
  engine.hasLoadedAsset = true
@@ -944,7 +1167,7 @@ struct PlayerReviewRegressionTests {
944
1167
  )
945
1168
  PlaybackPersistence(defaults: defaults) { saved }.save()
946
1169
 
947
- let player = makePlayer(retries: false)
1170
+ let player = makePlayer()
948
1171
  let session = try #require(player.persistedSession())
949
1172
  player.resume(session, queue: nil)
950
1173
  #expect(player.currentTrack?.id == "t1")
@@ -962,12 +1185,11 @@ struct PlayerReviewRegressionTests {
962
1185
  positionMs: nil, repeatMode: "off", shuffleEnabled: false, playbackSpeed: 1,
963
1186
  )
964
1187
  PlaybackPersistence(defaults: defaults) { saved }.save()
965
- #expect(makePlayer(retries: false).persistedSession() == nil)
1188
+ #expect(makePlayer().persistedSession() == nil)
966
1189
  }
967
1190
 
968
1191
  @Test func aTrackChangeClearsTheRetryingErrorOfTheTrackItLeaves() async throws {
969
1192
  let (player, engine, callbacks) = try makeLoading()
970
- player.retry.shouldRetry = { true }
971
1193
  player.setPlayWhenReady(true)
972
1194
  engine.emit(.loadFailed(URLError(.timedOut)))
973
1195
  #expect(callbacks.playbackChanges.last?.error != nil)