react-native-audio-browser 0.2.0-next.42 → 0.2.0-next.44
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.
- package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +2 -2
- package/android/src/test/java/com/audiobrowser/player/PlayerInvalidTrackTest.kt +67 -0
- package/ios/CarPlay/MediaIntentPlayback.swift +1 -1
- package/ios/HybridAudioBrowser+Player.swift +4 -4
- package/ios/Model/TrackPlayerError.swift +4 -0
- package/ios/Player/Player.swift +31 -16
- package/ios/Tests/ArtworkFreshnessTests.swift +67 -0
- package/ios/Tests/PlayerInvalidTrackTests.swift +65 -0
- package/ios/Tests/PlayerPolicyTests.swift +78 -78
- package/ios/Tests/PlayerTests.swift +109 -109
- package/ios/Util/ArtworkFreshness.swift +42 -0
- package/ios/Util/ArtworkImageFetcher.swift +92 -11
- package/package.json +1 -1
|
@@ -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
|
}
|