react-native-audio-browser 0.2.0-next.42 → 0.2.0-next.43

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,19 +8,19 @@ import Testing
8
8
  private func makeLoading(
9
9
  src: String? = "https://example.com/a.mp3",
10
10
  live: Bool = false,
11
- ) -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
11
+ ) throws -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
12
12
  let engine = MockPlayerEngine()
13
13
  let player = makePlayer(engine: engine, retries: false)
14
14
  let callbacks = MockPlayerCallbacks()
15
15
  player.callbacks = callbacks
16
- player.setQueue([Track(id: "t1", src: src, title: "T", live: live)])
16
+ try player.setQueue([Track(id: "t1", src: src, title: "T", live: live)])
17
17
  return (player, engine, callbacks)
18
18
  }
19
19
 
20
20
  /// Loaded and playing: the item is in place and audio has started.
21
21
  @MainActor
22
- private func makePlaying(live: Bool = false) -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
23
- let (player, engine, callbacks) = makeLoading(live: live)
22
+ private func makePlaying(live: Bool = false) throws -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
23
+ let (player, engine, callbacks) = try makeLoading(live: live)
24
24
  player.setPlayWhenReady(true)
25
25
  engine.hasItem = true
26
26
  engine.hasLoadedAsset = true
@@ -32,8 +32,8 @@ private func makePlaying(live: Bool = false) -> (Player, MockPlayerEngine, MockP
32
32
  @Suite("Player - seeking")
33
33
  @MainActor
34
34
  struct PlayerSeekingTests {
35
- @Test func aSeekWhileLoadingWaitsForTheItem_andHoldsReadyUntilItLands() {
36
- let (player, engine, _) = makeLoading()
35
+ @Test func aSeekWhileLoadingWaitsForTheItem_andHoldsReadyUntilItLands() throws {
36
+ let (player, engine, _) = try makeLoading()
37
37
  engine.seekResult = nil
38
38
  player.seek(to: 30)
39
39
  #expect(engine.seekCalls.isEmpty)
@@ -45,8 +45,8 @@ struct PlayerSeekingTests {
45
45
  #expect(player.state == .loading)
46
46
  }
47
47
 
48
- @Test func theLoadBecomesReadyWhenTheDeferredSeekLands() {
49
- let (player, engine, _) = makeLoading()
48
+ @Test func theLoadBecomesReadyWhenTheDeferredSeekLands() throws {
49
+ let (player, engine, _) = try makeLoading()
50
50
  player.seek(to: 30)
51
51
  engine.hasItem = true
52
52
  engine.hasLoadedAsset = true
@@ -55,8 +55,8 @@ struct PlayerSeekingTests {
55
55
  #expect(player.state == .ready)
56
56
  }
57
57
 
58
- @Test func seekByWhileLoadingOffsetsTheDeferredTarget() {
59
- let (player, _, _) = makeLoading()
58
+ @Test func seekByWhileLoadingOffsetsTheDeferredTarget() throws {
59
+ let (player, _, _) = try makeLoading()
60
60
  player.seek(to: 30)
61
61
  player.seek(by: 15)
62
62
  #expect(player.deferredSeek.target == 45)
@@ -64,13 +64,13 @@ struct PlayerSeekingTests {
64
64
 
65
65
  /// A completion from before a track change belongs to the old item: it reports false and
66
66
  /// leaves the new track's start position pending.
67
- @Test func aCompletionFromBeforeATrackChangeIsDropped() {
68
- let (player, engine, _) = makePlaying()
67
+ @Test func aCompletionFromBeforeATrackChangeIsDropped() throws {
68
+ let (player, engine, _) = try makePlaying()
69
69
  engine.seekResult = nil
70
70
  var landed: [Bool] = []
71
71
  player.seek(to: 10) { landed.append($0) }
72
72
 
73
- player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")], startPositionMs: 25000)
73
+ try player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")], startPositionMs: 25000)
74
74
  engine.completeSeeks(true)
75
75
 
76
76
  #expect(landed == [false])
@@ -78,8 +78,8 @@ struct PlayerSeekingTests {
78
78
  #expect(player.state == .loading)
79
79
  }
80
80
 
81
- @Test func theLiveEdgeIsTheSeekableWindowsEnd_orAReconnectWithoutOne() {
82
- let (player, engine, _) = makePlaying(live: true)
81
+ @Test func theLiveEdgeIsTheSeekableWindowsEnd_orAReconnectWithoutOne() throws {
82
+ let (player, engine, _) = try makePlaying(live: true)
83
83
  engine.liveEdge = 120
84
84
  player.seekToLiveEdge()
85
85
  #expect(engine.seekCalls == [120])
@@ -94,61 +94,61 @@ struct PlayerSeekingTests {
94
94
  @Suite("Player - engine events")
95
95
  @MainActor
96
96
  struct PlayerEngineEventTests {
97
- @Test func aFailedLoadPrimesNowPlayingOncePerLoad() {
98
- let (player, engine, _) = makeLoading()
97
+ @Test func aFailedLoadPrimesNowPlayingOncePerLoad() throws {
98
+ let (player, engine, _) = try makeLoading()
99
99
  player.setPlayWhenReady(true)
100
100
  player.retry.shouldRetry = { true }
101
101
  engine.emit(.loadFailed(URLError(.timedOut)))
102
102
  engine.emit(.loadFailed(URLError(.timedOut)))
103
103
  #expect(engine.primeCount == 1)
104
104
 
105
- player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
105
+ try player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
106
106
  engine.emit(.loadFailed(URLError(.timedOut)))
107
107
  #expect(engine.primeCount == 2)
108
108
  }
109
109
 
110
- @Test func aFailedLoadWithoutIntentDoesNotPrime() async {
111
- let (player, engine, _) = makeLoading()
110
+ @Test func aFailedLoadWithoutIntentDoesNotPrime() async throws {
111
+ let (player, engine, _) = try makeLoading()
112
112
  engine.emit(.loadFailed(URLError(.timedOut)))
113
113
  await player.retry.pendingTask?.value
114
114
  #expect(engine.primeCount == 0)
115
115
  #expect(player.state == .error)
116
116
  }
117
117
 
118
- @Test func anUnplayableAssetIsTerminal() {
119
- let (player, engine, _) = makeLoading()
118
+ @Test func anUnplayableAssetIsTerminal() throws {
119
+ let (player, engine, _) = try makeLoading()
120
120
  engine.emit(.unplayable)
121
121
  #expect(player.state == .error)
122
122
  #expect(player.errorStatus == .terminal(.trackWasUnplayable, report: 1))
123
123
  }
124
124
 
125
- @Test func anInvalidSourceIsTerminal() {
126
- let (player, engine, _) = makeLoading()
125
+ @Test func anInvalidSourceIsTerminal() throws {
126
+ let (player, engine, _) = try makeLoading()
127
127
  engine.emit(.invalidSource("::"))
128
128
  #expect(player.errorStatus == .terminal(.invalidSourceUrl("::"), report: 1))
129
129
  }
130
130
 
131
- @Test func aPlayerFailureCarriesItsHTTPStatus() {
132
- let (player, engine, _) = makePlaying()
131
+ @Test func aPlayerFailureCarriesItsHTTPStatus() throws {
132
+ let (player, engine, _) = try makePlaying()
133
133
  engine.emit(.failed(nil, httpStatusCode: 404))
134
134
  #expect(player.errorStatus == .terminal(.httpStatus(404), report: 1))
135
135
  }
136
136
 
137
- @Test func aGenuineEndAdvances_aLiveEndReconnects() {
138
- let (player, engine, _) = makePlaying()
137
+ @Test func aGenuineEndAdvances_aLiveEndReconnects() throws {
138
+ let (player, engine, _) = try makePlaying()
139
139
  engine.currentTime = 300
140
140
  engine.duration = 300
141
141
  engine.emit(.playedToEnd)
142
142
  #expect(player.state == .ended)
143
143
 
144
- let (live, liveEngine, _) = makePlaying(live: true)
144
+ let (live, liveEngine, _) = try makePlaying(live: true)
145
145
  liveEngine.emit(.playedToEnd)
146
146
  #expect(live.state == .loading)
147
147
  #expect(liveEngine.resolveAndLoadCalls.count == 2)
148
148
  }
149
149
 
150
- @Test func aStallNudgesPlayback_onlyWithIntent() {
151
- let (player, engine, _) = makePlaying()
150
+ @Test func aStallNudgesPlayback_onlyWithIntent() throws {
151
+ let (player, engine, _) = try makePlaying()
152
152
  engine.startPlaybackCallCount = 0
153
153
  engine.emit(.stalled)
154
154
  #expect(engine.startPlaybackCallCount == 1)
@@ -159,8 +159,8 @@ struct PlayerEngineEventTests {
159
159
  #expect(engine.startPlaybackCallCount == 0)
160
160
  }
161
161
 
162
- @Test func anAirPlayStrandingIsNudged() {
163
- let (player, engine, _) = makePlaying()
162
+ @Test func anAirPlayStrandingIsNudged() throws {
163
+ let (player, engine, _) = try makePlaying()
164
164
  engine.isAirPlayRoute = true
165
165
  engine.emit(.timeControlStatus(.waitingToPlayAtSpecifiedRate, waitingForNoItem: true))
166
166
  engine.startPlaybackCallCount = 0
@@ -173,24 +173,24 @@ struct PlayerEngineEventTests {
173
173
  @Suite("Player - recovering")
174
174
  @MainActor
175
175
  struct PlayerRecoveringTests {
176
- @Test func theNetworkReturningReconnectsAStalledStream() {
177
- let (player, engine, _) = makePlaying()
176
+ @Test func theNetworkReturningReconnectsAStalledStream() throws {
177
+ let (player, engine, _) = try makePlaying()
178
178
  player.transition(.avPlayerWaiting)
179
179
  #expect(player.state == .buffering)
180
180
  player.networkStatusDidChange(isOnline: true)
181
181
  #expect(engine.resolveAndLoadCalls.count == 2)
182
182
  }
183
183
 
184
- @Test func theNetworkReturningLeavesAPausedOrPlayingStreamAlone() {
185
- let (player, engine, _) = makePlaying()
184
+ @Test func theNetworkReturningLeavesAPausedOrPlayingStreamAlone() throws {
185
+ let (player, engine, _) = try makePlaying()
186
186
  player.networkStatusDidChange(isOnline: true)
187
187
  player.pause()
188
188
  player.networkStatusDidChange(isOnline: true)
189
189
  #expect(engine.resolveAndLoadCalls.count == 1)
190
190
  }
191
191
 
192
- @Test func theNetworkGoingReRendersTheStallLineWithoutReconnecting() {
193
- let (player, engine, _) = makePlaying()
192
+ @Test func theNetworkGoingReRendersTheStallLineWithoutReconnecting() throws {
193
+ let (player, engine, _) = try makePlaying()
194
194
  player.transition(.avPlayerWaiting)
195
195
  engine.nowPlayingRenderCount = 0
196
196
 
@@ -200,8 +200,8 @@ struct PlayerRecoveringTests {
200
200
  #expect(engine.resolveAndLoadCalls.count == 1)
201
201
  }
202
202
 
203
- @Test func theNetworkReturningReRendersBeforeReconnecting() {
204
- let (player, engine, _) = makePlaying()
203
+ @Test func theNetworkReturningReRendersBeforeReconnecting() throws {
204
+ let (player, engine, _) = try makePlaying()
205
205
  player.transition(.avPlayerWaiting)
206
206
  var order: [String] = []
207
207
  engine.onSeamCall = { order.append($0) }
@@ -215,8 +215,8 @@ struct PlayerRecoveringTests {
215
215
 
216
216
  /// A restart from a terminal error is a new Load: fresh retry budgets, unproven playback, the
217
217
  /// primer allowed again; a retry within a Load keeps its Load.
218
- @Test func aRestartFromAnErrorBeginsANewLoad() async {
219
- let (player, engine, _) = makePlaying()
218
+ @Test func aRestartFromAnErrorBeginsANewLoad() async throws {
219
+ let (player, engine, _) = try makePlaying()
220
220
  engine.emit(.audioDidStart)
221
221
  let first = player.load
222
222
  #expect(first?.hasPlayed == true)
@@ -231,8 +231,8 @@ struct PlayerRecoveringTests {
231
231
  #expect(engine.recreateCount == 1)
232
232
  }
233
233
 
234
- @Test func aRetryKeepsItsLoad() async {
235
- let (player, engine, _) = makePlaying()
234
+ @Test func aRetryKeepsItsLoad() async throws {
235
+ let (player, engine, _) = try makePlaying()
236
236
  player.retry.shouldRetry = { true }
237
237
  let first = player.load
238
238
  engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
@@ -241,26 +241,26 @@ struct PlayerRecoveringTests {
241
241
  #expect(engine.recreateCount == 0)
242
242
  }
243
243
 
244
- @Test func aMediaServicesResetReloadsOnANewPlayer() {
245
- let (player, engine, _) = makePlaying()
244
+ @Test func aMediaServicesResetReloadsOnANewPlayer() throws {
245
+ let (player, engine, _) = try makePlaying()
246
246
  player.mediaServicesWereReset()
247
247
  #expect(engine.recreateCount == 1)
248
248
  #expect(engine.resolveAndLoadCalls.count == 2)
249
249
  #expect(player.playWhenReady)
250
250
  }
251
251
 
252
- @Test func aStopRewindsAFiniteTrack_notALiveOne() {
253
- let (player, engine, _) = makePlaying()
252
+ @Test func aStopRewindsAFiniteTrack_notALiveOne() throws {
253
+ let (player, engine, _) = try makePlaying()
254
254
  player.stop()
255
255
  #expect(engine.seekCalls == [0])
256
256
 
257
- let (live, liveEngine, _) = makePlaying(live: true)
257
+ let (live, liveEngine, _) = try makePlaying(live: true)
258
258
  live.stop()
259
259
  #expect(liveEngine.seekCalls.isEmpty)
260
260
  }
261
261
 
262
- @Test func aNonPositiveRateIsRefused() {
263
- let (player, engine, _) = makePlaying()
262
+ @Test func aNonPositiveRateIsRefused() throws {
263
+ let (player, engine, _) = try makePlaying()
264
264
  player.rate = 1.5
265
265
  player.rate = 0
266
266
  #expect(player.rate == 1.5)
@@ -268,8 +268,8 @@ struct PlayerRecoveringTests {
268
268
  #expect(engine.rates.last?.playing == true)
269
269
  }
270
270
 
271
- @Test func isStalledNeedsProgressIntentAndAThinBuffer() {
272
- let (player, engine, _) = makePlaying()
271
+ @Test func isStalledNeedsProgressIntentAndAThinBuffer() throws {
272
+ let (player, engine, _) = try makePlaying()
273
273
  engine.currentTime = 10
274
274
  engine.isPlaybackLikelyToKeepUp = false
275
275
  #expect(player.isStalled)
@@ -283,9 +283,9 @@ struct PlayerRecoveringTests {
283
283
  struct PlayerReviewRegressionTests {
284
284
  /// An end-of-track sleep timer drops the intent while still .playing; the snapshot must still
285
285
  /// be rewritten on entering .ended, or a cold resume seeks to the end and re-ends.
286
- @Test func endingWithTheIntentAlreadyOffSavesPositionZero() {
286
+ @Test func endingWithTheIntentAlreadyOffSavesPositionZero() throws {
287
287
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
288
- let (player, engine, _) = makePlaying()
288
+ let (player, engine, _) = try makePlaying()
289
289
  engine.currentTime = 300
290
290
  engine.duration = 300
291
291
  player.pause()
@@ -296,10 +296,10 @@ struct PlayerReviewRegressionTests {
296
296
 
297
297
  /// A track change while paused saves the new track at its start, not at the old item's
298
298
  /// position, which the engine still reports until the new item is prepared.
299
- @Test func skippingWhilePausedSavesTheNewTrackAtItsStart() {
299
+ @Test func skippingWhilePausedSavesTheNewTrackAtItsStart() throws {
300
300
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
301
- let (player, engine, _) = makePlaying()
302
- player.add([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
301
+ let (player, engine, _) = try makePlaying()
302
+ try player.add([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
303
303
  player.pause()
304
304
  engine.currentTime = 1800
305
305
  player.next()
@@ -310,9 +310,9 @@ struct PlayerReviewRegressionTests {
310
310
 
311
311
  /// A reload while paused holds its resume position before the loading transition saves the
312
312
  /// snapshot.
313
- @Test func aRetryWhilePausedSavesWhereItWas() {
313
+ @Test func aRetryWhilePausedSavesWhereItWas() throws {
314
314
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
315
- let (player, engine, _) = makePlaying()
315
+ let (player, engine, _) = try makePlaying()
316
316
  player.pause()
317
317
  engine.currentTime = 120
318
318
  engine.resumePosition = 120
@@ -324,10 +324,10 @@ struct PlayerReviewRegressionTests {
324
324
 
325
325
  /// A skip whose load fails leaves the previous item in the engine: the snapshot and the restart
326
326
  /// from the error start the new track at its start, not at the old one's position.
327
- @Test func aFailedSkipKeepsTheNewTrackAtItsStart() {
327
+ @Test func aFailedSkipKeepsTheNewTrackAtItsStart() throws {
328
328
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
329
- let (player, engine, _) = makePlaying()
330
- player.add([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
329
+ let (player, engine, _) = try makePlaying()
330
+ try player.add([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
331
331
  engine.currentTime = 1800
332
332
  engine.resumePosition = 1800
333
333
  player.next()
@@ -344,10 +344,10 @@ struct PlayerReviewRegressionTests {
344
344
 
345
345
  /// A queue's start position is in the snapshot the track change saves, not only in the next
346
346
  /// periodic save.
347
- @Test func aStartPositionIsSavedWithTheTrackChange() {
347
+ @Test func aStartPositionIsSavedWithTheTrackChange() throws {
348
348
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
349
349
  let player = makePlayer(retries: false)
350
- player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "A")], startPositionMs: 30000)
350
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "A")], startPositionMs: 30000)
351
351
  let saved = PlaybackPersistence(defaults: UserDefaults(suiteName: "PlayerTests")!) { nil }.load()
352
352
  #expect(saved?.positionMs == 30000)
353
353
  #expect(player.deferredSeek.target == 30)
@@ -355,9 +355,9 @@ struct PlayerReviewRegressionTests {
355
355
 
356
356
  /// Play on a track without a source fails as an invalid source; it never reloads the media
357
357
  /// loader's last URL, which belongs to an earlier track.
358
- @Test func playOnATrackWithoutASourceFailsInsteadOfReloading() {
359
- let (player, engine, _) = makePlaying()
360
- player.setQueue([Track(id: "t2", src: nil, title: "No source")])
358
+ @Test func playOnATrackWithoutASourceFailsInsteadOfReloading() throws {
359
+ let (player, engine, _) = try makePlaying()
360
+ try player.setQueue([Track(id: "t2", path: "/no-source", src: nil, title: "No source")])
361
361
  #expect(player.state == .error)
362
362
  let resolves = engine.resolveAndLoadCalls.count
363
363
 
@@ -369,9 +369,9 @@ struct PlayerReviewRegressionTests {
369
369
  }
370
370
 
371
371
  /// While nothing plays, a transition alone rewrites the snapshot.
372
- @Test func anErrorWhilePausedSavesWhereItStopped() {
372
+ @Test func anErrorWhilePausedSavesWhereItStopped() throws {
373
373
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
374
- let (player, engine, _) = makePlaying()
374
+ let (player, engine, _) = try makePlaying()
375
375
  player.pause()
376
376
  engine.currentTime = 42
377
377
  engine.emit(.failed(nil, httpStatusCode: nil))
@@ -385,7 +385,7 @@ struct PlayerReviewRegressionTests {
385
385
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
386
386
  let engine = MockPlayerEngine()
387
387
  let player = makePlayer(engine: engine, retries: false, saveInterval: .milliseconds(10))
388
- player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
388
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
389
389
  engine.hasItem = true
390
390
  engine.hasLoadedAsset = true
391
391
  engine.emit(.itemPrepared(likelyToKeepUp: true))
@@ -432,14 +432,14 @@ struct PlayerReviewRegressionTests {
432
432
 
433
433
  /// A track change while the old track loads with a retrying error publishes the new track's
434
434
  /// loading state without that error.
435
- @Test func aTrackChangeClearsTheRetryingErrorOfTheTrackItLeaves() async {
436
- let (player, engine, callbacks) = makeLoading()
435
+ @Test func aTrackChangeClearsTheRetryingErrorOfTheTrackItLeaves() async throws {
436
+ let (player, engine, callbacks) = try makeLoading()
437
437
  player.retry.shouldRetry = { true }
438
438
  player.setPlayWhenReady(true)
439
439
  engine.emit(.loadFailed(URLError(.timedOut)))
440
440
  #expect(callbacks.playbackChanges.last?.error != nil)
441
441
 
442
- player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
442
+ try player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
443
443
 
444
444
  #expect(callbacks.playbackChanges.last?.state == .loading)
445
445
  #expect(callbacks.playbackChanges.last?.error == nil)
@@ -448,12 +448,12 @@ struct PlayerReviewRegressionTests {
448
448
 
449
449
  /// Leaving an errored track publishes the new track's loading state once, never an error
450
450
  /// state without its error.
451
- @Test func skippingAwayFromAnErrorNeverPublishesAnErrorlessError() {
452
- let (player, engine, callbacks) = makeLoading()
451
+ @Test func skippingAwayFromAnErrorNeverPublishesAnErrorlessError() throws {
452
+ let (player, engine, callbacks) = try makeLoading()
453
453
  engine.emit(.unplayable)
454
454
  callbacks.playbackChanges.removeAll()
455
455
  callbacks.errorEvents.removeAll()
456
- player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
456
+ try player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
457
457
  #expect(!callbacks.playbackChanges.contains { $0.state == .error })
458
458
  #expect(callbacks.errorEvents.count == 1)
459
459
  }