react-native-audio-browser 0.2.0-next.2 → 0.2.0-next.21

package/src/web/__tests__/loadSupersession.test.ts

@@ -0,0 +1,175 @@
+/** @vitest-environment happy-dom */
+
+import { beforeEach, describe, expect, it } from 'vitest'
+import type { Track } from '../../types'
+import {
+  LifecycleHarness,
+  deferredResolver,
+  trackA,
+  trackB
+} from './lifecycleHarness'
+
+/**
+ * What happens to a load that something else takes over from — a newer load,
+ * or a stop. Written before the two generation counters (`Player._loadGeneration`
+ * and `NativeAudioBrowser.currentLoadId`) were unified into one cancellation
+ * token, so they describe the behaviour rather than either mechanism.
+ */
+
+let h: LifecycleHarness
+
+beforeEach(async () => {
+  h = new LifecycleHarness()
+  await h.setup()
+})
+
+describe('a load superseded mid-resolution', () => {
+  it('never hands the stale url to the player', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+
+    h.browser.load(trackA)
+    await h.flush()
+    h.browser.load(trackB)
+    await h.flush()
+    expect(resolver.calls()).toBe(2)
+
+    // the winner resolves first, then the superseded one arrives late
+    resolver.release(2)
+    await h.flush()
+    resolver.release(1)
+    await h.flush()
+
+    expect(h.loadedUrls).toEqual(['https://cdn.example.com/2.mp3'])
+  })
+
+  it('leaves the winner playing', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+    h.browser.setPlayWhenReady(true)
+
+    h.browser.load(trackA)
+    await h.flush()
+    h.browser.load(trackB)
+    await h.flush()
+
+    resolver.release(2)
+    await h.flush()
+    await h.completeLoad()
+    resolver.release(1)
+    await h.flush()
+
+    expect(h.browser.getActiveTrack()?.id).toBe(trackB.id)
+    expect(h.browser.getPlayback().state).toBe('playing')
+  })
+})
+
+describe('a load superseded after its own url resolved', () => {
+  /**
+   * The gap the two generation counters left. Supersession was registered by
+   * the *inner* `super.load()`, which only runs once the URL has resolved — so
+   * a load whose Shaka promise had already settled ran its own success path
+   * even though a newer `load()` had been called first. One token begun at the
+   * call closes it.
+   */
+  it('does not run its callback once a newer load has begun', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+    h.browser.setPlayWhenReady(true)
+
+    const seen: Array<string | undefined> = []
+    h.browser.load(trackA, (track) => seen.push(track.id))
+    await h.flush()
+    resolver.release(1)
+    await h.flush() // super.load(A) has run; its Shaka load is pending
+
+    h.finishLoadOnly() // A's load settles, its .then is queued
+    h.browser.load(trackB) // superseded before that .then runs
+    await h.flush()
+
+    expect(seen).toEqual([])
+  })
+})
+
+describe('a load stopped mid-resolution', () => {
+  it('never hands its url to the player', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+
+    h.browser.load(trackA)
+    await h.flush()
+    h.browser.stop()
+    await h.flush()
+
+    resolver.release(1)
+    await h.flush()
+
+    expect(h.loadedUrls).toEqual([])
+    expect(h.browser.getPlayback().state).toBe('stopped')
+  })
+})
+
+describe('a load stopped while Shaka is loading', () => {
+  it('does not run the load callback, seek, or autoplay', async () => {
+    let loadedCalls = 0
+    h.browser.setPlayWhenReady(true)
+    h.browser.load(trackA, () => {
+      loadedCalls += 1
+    })
+    await h.flush() // player.load() is pending
+
+    h.browser.stop()
+    await h.flush()
+    await h.completeLoad()
+
+    expect(loadedCalls).toBe(0)
+    expect(h.browser.getPlayback().state).toBe('stopped')
+  })
+})
+
+describe('the load that wins', () => {
+  it('runs its callback', async () => {
+    const seen: Array<string | undefined> = []
+    h.browser.load(trackA, (track) => seen.push(track.id))
+    await h.flush()
+    await h.completeLoad()
+
+    expect(seen).toEqual([trackA.id])
+  })
+
+  it('applies a seek that arrived while it was loading', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+
+    h.browser.load(trackA)
+    await h.flush()
+    h.browser.seekTo(30) // captured as pending: the load is still in progress
+    resolver.release(1)
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.currentTime).toBe(30)
+  })
+
+  it('autoplays when the intent is set', async () => {
+    h.browser.setPlayWhenReady(true)
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.browser.getPlayback().state).toBe('playing')
+  })
+
+  it('does not autoplay without the intent', async () => {
+    const paused: Track = {
+      id: 'p',
+      title: 'P',
+      src: 'https://x.example.com/p.mp3'
+    }
+    h.browser.load(paused)
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.browser.getPlayback().state).toBe('ready')
+  })
+})

package/src/web/__tests__/retry.test.ts

@@ -0,0 +1,169 @@
+/** @vitest-environment happy-dom */
+
+import { beforeEach, describe, expect, it } from 'vitest'
+import type { Track } from '../../types'
+import { LifecycleHarness } from './lifecycleHarness'
+
+/**
+ * `retry()` after a failure, and `play()` from the error state — which on
+ * Android are the same operation.
+ *
+ * `retry()` is `player.prepare()` there; `play()` is `playWhenReady = true`
+ * followed by the same `prepare()`, which early-returns unless ExoPlayer is
+ * STATE_IDLE. iOS's `retry()` is `reloadResolving(startFromCurrentTime: true)`,
+ * with the reason in its own comment: "short-lived URLs/tokens may have expired
+ * since the failure".
+ *
+ * Web used to call `shaka.Player.retryStreaming()`, which returns false and
+ * does nothing unless the load mode is MEDIA_SOURCE — so for a progressive
+ * file, the case a signed URL exists for, `retry()` was a silent no-op.
+ *
+ * The point of these tests is the re-resolution: the resolver hands back a
+ * different URL each call, so a retry that replays the cached one is visible as
+ * a stale URL reaching the player.
+ */
+
+let h: LifecycleHarness
+
+/** Its `src` is the unsigned path; the resolver signs it freshly each call. */
+const signed: Track = { id: 'signed', title: 'Signed', src: '/stream/7' }
+
+/** A media resolver that mints a new URL every time it runs. */
+function freshlySigning(): {
+  media: { resolve: () => Promise<{ path: string }> }
+} {
+  let issued = 0
+  return {
+    media: {
+      resolve: () => {
+        issued += 1
+        return Promise.resolve({
+          path: `https://cdn.example.com/${issued}.mp3`
+        })
+      }
+    }
+  }
+}
+
+beforeEach(async () => {
+  h = new LifecycleHarness()
+  await h.setup()
+})
+
+describe('retry re-resolves', () => {
+  it('hands the player a freshly resolved url, not the one that failed', async () => {
+    h.browser.configuration = freshlySigning()
+
+    h.failLoad()
+    h.browser.load(signed)
+    await h.flush()
+    expect(h.loadedUrls).toEqual(['https://cdn.example.com/1.mp3'])
+    expect(h.browser.getPlayback().state).toBe('error')
+
+    h.succeedLoads()
+    h.browser.retry()
+    await h.flush()
+
+    // the retry resolved again rather than replaying the expired url
+    expect(h.loadedUrls).toEqual([
+      'https://cdn.example.com/1.mp3',
+      'https://cdn.example.com/2.mp3'
+    ])
+  })
+
+  it('play() from the error state re-resolves the same way', async () => {
+    h.browser.configuration = freshlySigning()
+
+    h.failLoad()
+    h.browser.load(signed)
+    await h.flush()
+
+    h.succeedLoads()
+    h.browser.play()
+    await h.flush()
+
+    expect(h.loadedUrls[1]).toBe('https://cdn.example.com/2.mp3')
+    // play() also sets the intent; retry() does not
+    expect(h.browser.getPlayWhenReady()).toBe(true)
+  })
+
+  it('retry() does not set the play intent', async () => {
+    h.failLoad()
+    h.browser.load({ id: 'a', title: 'A', src: 'https://x.example.com/a.mp3' })
+    await h.flush()
+
+    h.succeedLoads()
+    h.browser.retry()
+    await h.flush()
+
+    expect(h.browser.getPlayWhenReady()).toBe(false)
+  })
+
+  it('is a no-op on a healthy player, as ExoPlayer.prepare() is', async () => {
+    h.browser.load({ id: 'a', title: 'A', src: 'https://x.example.com/a.mp3' })
+    await h.flush()
+    await h.completeLoad()
+    const before = h.loadedUrls.length
+
+    h.browser.retry()
+    await h.flush()
+
+    expect(h.loadedUrls.length).toBe(before)
+  })
+
+  it('does nothing without a current track', async () => {
+    h.browser.retry()
+    await h.flush()
+
+    expect(h.loadedUrls).toEqual([])
+  })
+})
+
+describe('retry resumes position', () => {
+  it('resumes from where playback failed', async () => {
+    const track: Track = {
+      id: 'a',
+      title: 'A',
+      src: 'https://x.example.com/a.mp3'
+    }
+    h.browser.load(track)
+    await h.flush()
+    await h.completeLoad()
+
+    h.setPosition(42)
+    h.failLoad()
+    h.raiseError()
+    await h.flush()
+
+    h.succeedLoads()
+    h.browser.retry()
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.currentTime).toBe(42)
+  })
+
+  it('does not resume a live stream — a fresh connection is the live edge', async () => {
+    const live: Track = {
+      id: 'live',
+      title: 'Live',
+      src: 'https://x.example.com/live.mp3',
+      live: true
+    }
+    h.browser.load(live)
+    await h.flush()
+    await h.completeLoad()
+
+    h.setPosition(3600)
+    h.raiseError()
+    await h.flush()
+
+    h.browser.retry()
+    await h.flush()
+    await h.completeLoad()
+
+    // seeking to an hour into a connection that no longer exists asks for a
+    // point the new stream does not have
+    expect(h.currentTime).toBe(0)
+  })
+})