react-native-audio-browser 0.2.0-next.17 → 0.2.0-next.19

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

@@ -0,0 +1,195 @@
+/** @vitest-environment happy-dom */
+
+import { beforeEach, describe, expect, it } from 'vitest'
+import type { Track } from '../../types'
+import { LifecycleHarness, trackA, trackB } from './lifecycleHarness'
+
+/**
+ * The edges the main lifecycle recordings miss, each one a bug the hoisted
+ * load path introduced or exposed. All were reproduced before being fixed;
+ * reverting any fix fails the test that names it.
+ */
+
+let h: LifecycleHarness
+
+beforeEach(async () => {
+  h = new LifecycleHarness()
+  await h.setup()
+})
+
+describe('a load superseded while still in flight', () => {
+  /**
+   * The eager `unload()` aborts the in-flight `player.load()`, and Shaka
+   * rejects an aborted load with LOAD_INTERRUPTED (7000). Unless the stale
+   * load is abandoned first, its own `catch` reports that as a playback
+   * error — an error banner on every fast track switch.
+   */
+  it('does not report the interrupted load as an error', async () => {
+    h.browser.setPlayWhenReady(true)
+    h.browser.load(trackA)
+    await h.flush() // player.load(A) is now pending
+    h.clear()
+
+    h.browser.load(trackB)
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.recorded).not.toContain('state:error')
+    expect(h.recorded.some((r) => r.startsWith('error:'))).toBe(false)
+    expect(h.browser.getPlayback().state).toBe('playing')
+  })
+})
+
+describe('a track end that does not advance the queue', () => {
+  /**
+   * Suppressing `ended` mid-queue is only safe when a load takes over the
+   * state. The sleep timer set to end-of-track pauses instead, and its
+   * `element.pause()` is a no-op on an already-ended element — so nothing
+   * moved the state and the player sat reporting `playing` with silence.
+   */
+  it('reports ended when the sleep timer stops instead of advancing', async () => {
+    h.browser.setQueue([trackA, trackB])
+    h.browser.setPlayWhenReady(true)
+    h.browser.skip(0)
+    await h.flush()
+    await h.completeLoad()
+    h.browser.setSleepTimerToEndOfTrack()
+    h.clear()
+
+    h.endTrack()
+    await h.flush()
+
+    expect(h.browser.getPlayback().state).toBe('ended')
+  })
+
+  it('still suppresses ended when the queue does advance', async () => {
+    h.browser.setQueue([trackA, trackB])
+    h.browser.setPlayWhenReady(true)
+    h.browser.skip(0)
+    await h.flush()
+    await h.completeLoad()
+    h.clear()
+
+    h.endTrack()
+    await h.flush()
+
+    expect(h.recorded).not.toContain('state:ended')
+  })
+})
+
+describe('loading after a stop', () => {
+  /**
+   * `dispatch()` drops every event while `_isStopped`, to keep Shaka's
+   * teardown noise off the stopped state. The `trackLoading` raised when
+   * `load()` is called was caught by that too, so the resolution window
+   * reported `stopped` rather than `loading` on the stop → play path.
+   */
+  it('reports loading while the url resolves', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+    h.browser.stop()
+    await h.flush()
+
+    h.browser.play()
+
+    expect(h.browser.getPlayback().state).toBe('loading')
+  })
+})
+
+describe('the remembered resume position', () => {
+  /**
+   * `onError` also runs for a *load* failure, where the element was just torn
+   * down and reads 0. Recording that overwrote the real position, so a retry
+   * that failed cost the place a later one would have resumed from.
+   */
+  it('survives a retry that also fails', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+
+    h.setPosition(42)
+    h.raiseError()
+    await h.flush()
+
+    h.failLoad()
+    h.browser.retry()
+    await h.flush()
+
+    h.succeedLoads()
+    h.browser.retry()
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.currentTime).toBe(42)
+  })
+
+  it('is not applied to a different track', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+    h.setPosition(42)
+    h.raiseError()
+    await h.flush()
+
+    // a different track becomes current, then fails at the very start
+    h.browser.load(trackB)
+    await h.flush()
+    await h.completeLoad()
+    h.raiseError()
+    await h.flush()
+
+    h.browser.retry()
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.currentTime).toBe(0)
+  })
+})
+
+describe('re-preparing the current item', () => {
+  /**
+   * ExoPlayer's `prepare()` does not re-fire `onMediaItemTransition` for an
+   * unchanged item, so neither should a retry: a consumer that resets on a
+   * track change would have its UI wiped every time one ran. The
+   * `lastTrack === track` payload was the tell.
+   */
+  it('does not announce a transition on retry', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+    h.raiseError()
+    await h.flush()
+    h.clear()
+
+    h.browser.retry()
+    await h.flush()
+
+    expect(h.recorded).not.toContain('activeTrack')
+    expect(h.recorded).not.toContain('nowPlaying')
+  })
+
+  it('still announces when the track actually changes', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+    h.clear()
+
+    h.browser.load(trackB)
+    await h.flush()
+
+    expect(h.recorded).toContain('activeTrack')
+  })
+
+  it('announces the first load of all', async () => {
+    const fresh: Track = {
+      id: 'f',
+      title: 'F',
+      src: 'https://x.example.com/f.mp3'
+    }
+    h.browser.load(fresh)
+    await h.flush()
+
+    expect(h.recorded).toContain('activeTrack')
+  })
+})

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)
+  })
+})

package/src/web/browser/BrowserManager.ts

@@ -345,6 +345,9 @@ export class BrowserManager {
    * results (no contextual URLs), like the native `makeSearchResult`.
    * Matches Android's BrowserManager.search() which bypasses resolve() entirely.
    *
+   * A failed search propagates, so `navigate` turns it into a navigation error
+   * the way it does a failed browse resolve.
+   *
    * @param searchPath The search path (format: /__search?q=query)
    * @returns ResolvedTrack containing search results as one untitled section
    */
@@ -379,17 +382,9 @@ export class BrowserManager {
     }
     // Handle request config-based search via the shared layered fetch.
     else if (searchRoute.searchConfig) {
-      try {
-        searchResults = await this.fetchSearchResults(
-          searchRoute.searchConfig,
-          {
-            q: query
-          }
-        )
-      } catch (error) {
-        console.error('Search failed:', error)
-        return undefined
-      }
+      searchResults = await this.fetchSearchResults(searchRoute.searchConfig, {
+        q: query
+      })
     }
 
     // Search callbacks should return fresh tracks without contextual paths (like Android)
@@ -408,10 +403,13 @@ export class BrowserManager {
   private async transformArtworkForContent(
     content: ResolvedTrack
   ): Promise<ResolvedTrack> {
+    // No short-circuit on a missing artwork config: Android gates per *track*
+    // (`artworkConfig == null && track.artwork == null`), so a track carrying a
+    // plain `artwork` URL still gets an `artworkSource`. Returning early here
+    // meant an app with no `artwork` block never populated the field at all —
+    // `resolveArtworkSourceAsync` already handles the no-config case the way
+    // `resolveArtworkUrl` does on Android.
     const artworkConfig = this._configuration.artwork
-    if (!artworkConfig) {
-      return content
-    }
     // The shared request layer applies to artwork too — use the resolved layer
     // (resolver result or static config) so a resolver-only config still works.
     await this.ensureLayersResolved()
@@ -531,6 +529,24 @@ export class BrowserManager {
     return undefined
   }
 
+  /**
+   * Ensures the request layer is resolved for the current generation and
+   * returns it — the resolver's result when a `requestResolver` is configured,
+   * else the static `request`.
+   *
+   * Consumers outside the browse path (media URL building, artwork) must reach
+   * the request layer through this rather than reading `configuration.request`,
+   * or a resolver-only config silently loses its baseUrl, headers and transform
+   * exactly where a credential is needed. Mirrors Android's
+   * `BrowserManager.resolvedRequestConfig()`, which carries the same warning.
+   */
+  async resolvedRequestConfig(): Promise<
+    TransformableRequestConfig | undefined
+  > {
+    await this.ensureLayersResolved()
+    return this._resolvedRequest
+  }
+
   /**
    * Ensures the request/browse layer configs are resolved for the current
    * generation. Any present resolver is invoked once per generation and the
@@ -728,8 +744,9 @@ export class BrowserManager {
 
     // Transform artwork URLs on tabs via the async resolver so the shared
     // request layer (incl. its transform) applies, matching content/search.
+    // Gated per track inside the resolver, as on Android — see
+    // `transformArtworkForContent`.
     const artworkConfig = this._configuration.artwork
-    if (!artworkConfig) return tabs
     // Resolved request layer (resolver or static), matching content/search.
     await this.ensureLayersResolved()
     const requestConfig = this._resolvedRequest

package/src/web/browser/SearchManager.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi } from 'vitest'
+import type { NativeBrowserConfiguration } from '../../types/browser-native'
+import type { HttpClient } from '../http/HttpClient'
+import { BrowserManager } from './BrowserManager'
+import { FavoriteManager } from './FavoriteManager'
+import { NavigationErrorManager } from './NavigationErrorManager'
+import { SearchManager } from './SearchManager'
+
+/**
+ * Builds a SearchManager over a BrowserManager whose HTTP client answers every
+ * request with `respond` — a resolved body or a rejection.
+ */
+function makeSearchManager(
+  respond: () => Promise<unknown>,
+  route: NonNullable<NativeBrowserConfiguration['routes']>[number] = {
+    path: '__search__',
+    searchConfig: { baseUrl: 'https://api.example.com' }
+  }
+): SearchManager {
+  const httpClient = {
+    executeRequest: vi.fn().mockImplementation(respond)
+  } as unknown as HttpClient
+  const browserManager = new BrowserManager(
+    httpClient,
+    new FavoriteManager(),
+    new NavigationErrorManager()
+  )
+  browserManager.configuration = { routes: [route] }
+  return new SearchManager(browserManager)
+}
+
+const httpError = (): Error => {
+  const error = new Error('HTTP 500: Internal Server Error') as Error & {
+    code: string
+    statusCode: number
+  }
+  error.code = 'http-error'
+  error.statusCode = 500
+  return error
+}
+
+describe('SearchManager', () => {
+  it('rejects when the search request fails', async () => {
+    const manager = makeSearchManager(() => Promise.reject(httpError()))
+    await expect(
+      manager.search({ query: 'jazz', reference: 'unknown' })
+    ).rejects.toThrow('HTTP 500: Internal Server Error')
+  })
+
+  it('resolves [] when the search found nothing', async () => {
+    const manager = makeSearchManager(() => Promise.resolve({ children: [] }))
+    await expect(
+      manager.search({ query: 'jazz', reference: 'unknown' })
+    ).resolves.toEqual([])
+  })
+
+  it('resolves the matching tracks', async () => {
+    const manager = makeSearchManager(() =>
+      Promise.resolve({ children: [{ title: 'Jazz FM', src: 'https://s/1' }] })
+    )
+    await expect(
+      manager.search({ query: 'jazz', reference: 'unknown' })
+    ).resolves.toEqual([{ title: 'Jazz FM', src: 'https://s/1' }])
+  })
+
+  it('propagates a rejecting search callback', async () => {
+    const manager = makeSearchManager(() => Promise.resolve([]), {
+      path: '__search__',
+      searchCallback: () => Promise.reject(new Error('callback exploded'))
+    })
+    await expect(
+      manager.search({ query: 'jazz', reference: 'unknown' })
+    ).rejects.toThrow('callback exploded')
+  })
+})