react-native-queue-player 1.0.0

package/android/src/test/java/com/margelo/nitro/queueplayer/MediaItemMapperTest.kt

@@ -0,0 +1,145 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.util.UnstableApi
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * Coverage for [MediaItemMapper]. Robolectric is required because
+ * [MediaMetadata.setArtworkUri] reads `Uri.parse` which depends on
+ * Android's Uri parser shadow.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class MediaItemMapperTest {
+
+  private fun item(
+    id: String = "i1",
+    title: String = "Title",
+    subtitle: String? = null,
+    artworkUrl: String? = null,
+    playable: Boolean = false,
+    hasChildren: Boolean? = null
+  ) = BrowseItem(
+    id = id,
+    title = title,
+    subtitle = subtitle,
+    artworkUrl = artworkUrl,
+    playable = playable,
+    hasChildren = hasChildren
+  )
+
+  @Test
+  fun `playable-only item maps to IS_PLAYABLE music`() {
+    val media = MediaItemMapper.toMediaItem(item(playable = true))
+    assertEquals("i1", media.mediaId)
+    assertEquals(true, media.mediaMetadata.isPlayable)
+    assertEquals(false, media.mediaMetadata.isBrowsable)
+    assertEquals(MediaMetadata.MEDIA_TYPE_MUSIC, media.mediaMetadata.mediaType)
+  }
+
+  @Test
+  fun `browsable-only item maps to IS_BROWSABLE folder`() {
+    val media = MediaItemMapper.toMediaItem(item(playable = false, hasChildren = true))
+    assertEquals(false, media.mediaMetadata.isPlayable)
+    assertEquals(true, media.mediaMetadata.isBrowsable)
+    assertEquals(MediaMetadata.MEDIA_TYPE_FOLDER_MIXED, media.mediaMetadata.mediaType)
+  }
+
+  @Test
+  fun `both flags set defensively maps to mixed type`() {
+    // Consumer error per the BrowseItem contract, but the mapper
+    // shouldn't crash — pick a defensive mediaType that lets
+    // Media3 controllers render whichever side they support.
+    val media = MediaItemMapper.toMediaItem(item(playable = true, hasChildren = true))
+    assertEquals(true, media.mediaMetadata.isPlayable)
+    assertEquals(true, media.mediaMetadata.isBrowsable)
+    assertEquals(MediaMetadata.MEDIA_TYPE_MIXED, media.mediaMetadata.mediaType)
+  }
+
+  @Test
+  fun `neither flag set maps to non-tappable mixed`() {
+    val media = MediaItemMapper.toMediaItem(item(playable = false, hasChildren = false))
+    assertEquals(false, media.mediaMetadata.isPlayable)
+    assertEquals(false, media.mediaMetadata.isBrowsable)
+    assertEquals(MediaMetadata.MEDIA_TYPE_MIXED, media.mediaMetadata.mediaType)
+  }
+
+  @Test
+  fun `null hasChildren is treated as not browsable`() {
+    val media = MediaItemMapper.toMediaItem(item(playable = true, hasChildren = null))
+    assertEquals(true, media.mediaMetadata.isPlayable)
+    assertEquals(false, media.mediaMetadata.isBrowsable)
+  }
+
+  @Test
+  fun `subtitle is propagated when present`() {
+    val media = MediaItemMapper.toMediaItem(
+      item(title = "Recently Played", subtitle = "Last 50 tracks")
+    )
+    assertEquals("Recently Played", media.mediaMetadata.title)
+    assertEquals("Last 50 tracks", media.mediaMetadata.subtitle)
+  }
+
+  @Test
+  fun `subtitle null leaves the metadata subtitle null`() {
+    val media = MediaItemMapper.toMediaItem(item(subtitle = null))
+    assertNull(media.mediaMetadata.subtitle)
+  }
+
+  @Test
+  fun `artwork URI is parsed when present and non-empty`() {
+    val media = MediaItemMapper.toMediaItem(
+      item(artworkUrl = "https://example.test/cover.jpg")
+    )
+    assertNotNull(media.mediaMetadata.artworkUri)
+    assertEquals(
+      "https://example.test/cover.jpg",
+      media.mediaMetadata.artworkUri.toString()
+    )
+  }
+
+  @Test
+  fun `artwork URI accepts file scheme for local artwork`() {
+    val media = MediaItemMapper.toMediaItem(
+      item(artworkUrl = "file:///var/data/cover.jpg")
+    )
+    assertEquals(
+      "file:///var/data/cover.jpg",
+      media.mediaMetadata.artworkUri.toString()
+    )
+  }
+
+  @Test
+  fun `empty artwork URL is treated as missing`() {
+    val media = MediaItemMapper.toMediaItem(item(artworkUrl = ""))
+    assertNull(media.mediaMetadata.artworkUri)
+  }
+
+  @Test
+  fun `null artwork URL leaves the metadata artworkUri null`() {
+    val media = MediaItemMapper.toMediaItem(item(artworkUrl = null))
+    assertNull(media.mediaMetadata.artworkUri)
+  }
+
+  @Test
+  fun `toMediaItems maps every input + preserves order`() {
+    val items = listOf(
+      item(id = "a", title = "Alpha", playable = true),
+      item(id = "b", title = "Beta", hasChildren = true),
+      item(id = "c", title = "Gamma", playable = true)
+    )
+    val mapped = MediaItemMapper.toMediaItems(items)
+    assertEquals(3, mapped.size)
+    assertEquals("a", mapped[0].mediaId)
+    assertEquals("b", mapped[1].mediaId)
+    assertEquals("c", mapped[2].mediaId)
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/MilestoneTrackerTest.kt

@@ -0,0 +1,81 @@
+package com.margelo.nitro.queueplayer
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Unit tests for [MilestoneTracker] — the pure 25/50/75/90% crossing
+ * logic behind `onPlaybackMilestone`. Native wiring (progress tick,
+ * seek, track-change reset) is covered by the `playback-milestones`
+ * demo suite.
+ */
+class MilestoneTrackerTest {
+
+  // 200s track => pct*2 seconds.
+  private fun MilestoneTracker.playTo(pct: Double, duration: Double = 200.0): List<Int> =
+    tick(duration, pct / 100.0 * duration)
+
+  @Test
+  fun `forward playthrough fires each once in order`() {
+    val t = MilestoneTracker()
+    val fired = mutableListOf<Int>()
+    var pct = 0.0
+    while (pct <= 100.0) {
+      fired += t.playTo(pct)
+      pct += 5.0
+    }
+    assertEquals(listOf(25, 50, 75, 90), fired)
+  }
+
+  @Test
+  fun `first tick establishes baseline and does not fire`() {
+    val t = MilestoneTracker()
+    assertEquals(emptyList<Int>(), t.tick(200.0, 120.0)) // 60% mid-track start
+    assertEquals(listOf(75), t.tick(200.0, 152.0))
+    assertEquals(listOf(90), t.tick(200.0, 184.0))
+  }
+
+  @Test
+  fun `seek past thresholds suppresses them`() {
+    val t = MilestoneTracker()
+    t.tick(200.0, 10.0) // baseline 5%
+    t.seek(200.0, 160.0) // jump to 80%
+    assertEquals(emptyList<Int>(), t.tick(200.0, 164.0))
+    assertEquals(listOf(90), t.tick(200.0, 182.0)) // only 90 fires
+  }
+
+  @Test
+  fun `each threshold fires only once per playthrough`() {
+    val t = MilestoneTracker()
+    t.tick(200.0, 0.0)
+    assertEquals(listOf(25, 50), t.tick(200.0, 120.0)) // 60%
+    t.seek(200.0, 20.0) // back to 10%
+    assertEquals(listOf(75), t.tick(200.0, 160.0)) // 80%, 25/50 stay fired
+  }
+
+  @Test
+  fun `reset re-arms for a new playthrough`() {
+    val t = MilestoneTracker()
+    t.tick(200.0, 0.0)
+    assertEquals(listOf(25, 50, 75, 90), t.tick(200.0, 200.0))
+    t.reset()
+    t.tick(200.0, 0.0)
+    assertEquals(listOf(25, 50, 75, 90), t.tick(200.0, 200.0))
+  }
+
+  @Test
+  fun `unknown duration fires nothing`() {
+    val t = MilestoneTracker()
+    assertEquals(emptyList<Int>(), t.tick(0.0, 30.0))
+    assertEquals(emptyList<Int>(), t.tick(0.0, 9999.0))
+    assertEquals(emptyList<Int>(), t.tick(200.0, 100.0)) // baseline 50%
+    assertEquals(listOf(75), t.tick(200.0, 152.0))
+  }
+
+  @Test
+  fun `threshold exactly on tick fires`() {
+    val t = MilestoneTracker()
+    t.tick(200.0, 0.0)
+    assertEquals(listOf(25, 50), t.tick(200.0, 100.0)) // exactly 50%
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/MultiplexingAudioBufferSinkTest.kt

@@ -0,0 +1,112 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.C
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.audio.TeeAudioProcessor
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.nio.ByteBuffer
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Unit coverage for [MultiplexingAudioBufferSink] — fan-out across
+ * the supplied sinks list + late-attach flush replay via
+ * [MultiplexingAudioBufferSink.primeNewSink].
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class MultiplexingAudioBufferSinkTest {
+
+  /**
+   * Records every `flush` + `handleBuffer` callback so tests can
+   * assert what landed.
+   */
+  private class RecordingSink : TeeAudioProcessor.AudioBufferSink {
+    data class Flush(val sampleRateHz: Int, val channelCount: Int, val encoding: Int)
+
+    val flushes = mutableListOf<Flush>()
+    var handleBufferCount: Int = 0
+
+    override fun flush(sampleRateHz: Int, channelCount: Int, encoding: Int) {
+      flushes.add(Flush(sampleRateHz, channelCount, encoding))
+    }
+
+    override fun handleBuffer(buffer: ByteBuffer) {
+      handleBufferCount++
+    }
+  }
+
+  @Test
+  fun `primeNewSink replays cached params onto sinks attached after first flush`() {
+    val sinks = CopyOnWriteArrayList<TeeAudioProcessor.AudioBufferSink>()
+    val mux = MultiplexingAudioBufferSink(sinks)
+    mux.flush(48000, 2, C.ENCODING_PCM_16BIT)
+
+    val late = RecordingSink()
+    sinks.add(late)
+    mux.primeNewSink(late)
+
+    assertEquals(1, late.flushes.size)
+    assertEquals(
+      RecordingSink.Flush(48000, 2, C.ENCODING_PCM_16BIT),
+      late.flushes[0],
+    )
+  }
+
+  @Test
+  fun `primeNewSink is a no-op before any flush`() {
+    val sinks = CopyOnWriteArrayList<TeeAudioProcessor.AudioBufferSink>()
+    val mux = MultiplexingAudioBufferSink(sinks)
+
+    val sink = RecordingSink()
+    sinks.add(sink)
+    mux.primeNewSink(sink)
+
+    assertEquals(0, sink.flushes.size)
+  }
+
+  @Test
+  fun `primeNewSink replays the most recent flush after multiple stream changes`() {
+    val sinks = CopyOnWriteArrayList<TeeAudioProcessor.AudioBufferSink>()
+    val mux = MultiplexingAudioBufferSink(sinks)
+    mux.flush(48000, 2, C.ENCODING_PCM_16BIT)
+    mux.flush(44100, 1, C.ENCODING_PCM_FLOAT)
+
+    val late = RecordingSink()
+    sinks.add(late)
+    mux.primeNewSink(late)
+
+    assertEquals(1, late.flushes.size)
+    assertEquals(
+      RecordingSink.Flush(44100, 1, C.ENCODING_PCM_FLOAT),
+      late.flushes[0],
+    )
+  }
+
+  @Test
+  fun `flush propagates to every sink already in the list`() {
+    val sinks = CopyOnWriteArrayList<TeeAudioProcessor.AudioBufferSink>()
+    val a = RecordingSink()
+    val b = RecordingSink()
+    sinks.add(a)
+    sinks.add(b)
+    val mux = MultiplexingAudioBufferSink(sinks)
+
+    mux.flush(44100, 1, C.ENCODING_PCM_16BIT)
+
+    assertEquals(1, a.flushes.size)
+    assertEquals(1, b.flushes.size)
+    assertEquals(
+      RecordingSink.Flush(44100, 1, C.ENCODING_PCM_16BIT),
+      a.flushes[0],
+    )
+    assertEquals(
+      RecordingSink.Flush(44100, 1, C.ENCODING_PCM_16BIT),
+      b.flushes[0],
+    )
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/NotificationProviderTest.kt

@@ -0,0 +1,86 @@
+package com.margelo.nitro.queueplayer
+
+import android.content.Context
+import android.content.Intent
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.DefaultMediaNotificationProvider
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * Robolectric coverage for [NotificationProvider]. Posting a real
+ * notification requires a live `MediaSession` + foreground service
+ * with the device's NotificationManager — that path lives in the
+ * demo cycle's lock-screen / notification suites.
+ *
+ * Unit-level scope: pin the constructor wiring (channel ID +
+ * notification ID resolved from [PlaybackService] companions, channel-
+ * name string-resource), confirm the provider subclasses Media3's
+ * [DefaultMediaNotificationProvider] (so the prev / play-pause / next
+ * compact view + scrub-progress expanded view ship for free), and
+ * confirm the provider attaches cleanly when the service stands up
+ * the BitmapLoader chain in `onCreate`.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class NotificationProviderTest {
+
+  @Test
+  fun `provider constructs against application context`() {
+    val context = ApplicationProvider.getApplicationContext<Context>()
+    val provider = NotificationProvider(context)
+    assertNotNull(provider)
+  }
+
+  @Test
+  fun `provider subclasses Media3's DefaultMediaNotificationProvider`() {
+    assertTrue(
+      "the lib's provider extends Media3's default provider so the standard compact + expanded layout, action mapping, and scrub progress are inherited",
+      DefaultMediaNotificationProvider::class.java.isAssignableFrom(NotificationProvider::class.java),
+    )
+  }
+
+  @Test
+  fun `PlaybackService channel and notification IDs are stable values the post-side surfaces consume`() {
+    // The provider posts under the channel ID + notification ID the
+    // `onCreate` `createNotificationChannel` call writes. Pinning them
+    // here prevents a silent rename from splitting the channel
+    // registration from the post.
+    assertEquals(
+      "com.margelo.nitro.queueplayer.playback",
+      PlaybackService.NOTIFICATION_CHANNEL_ID,
+    )
+    assertEquals(1001, PlaybackService.NOTIFICATION_ID)
+  }
+
+  @Test
+  fun `provider attaches to a fully-built PlaybackService without throwing`() {
+    val controller = Robolectric.buildService(PlaybackService::class.java).create()
+    try {
+      // Service.onCreate has already constructed the player + session
+      // + bitmap-loader chain + called setMediaNotificationProvider.
+      // Reaching this line proves the provider's constructor is
+      // compatible with the session BitmapLoader wiring (placeholder
+      // → cache → data-source). Any incompatibility (resource ID
+      // mismatch, missing context method, ICON_* enum drift) would
+      // surface as an exception during onCreate.
+      val service = controller.get()
+      val intent = Intent(
+        ApplicationProvider.getApplicationContext<Context>(),
+        PlaybackService::class.java,
+      ).setAction(PlaybackService.ACTION_LOCAL_BIND)
+      val binder = service.onBind(intent) as PlaybackService.LocalBinder
+      assertNotNull("session is wired up post-onCreate", binder.session)
+    } finally {
+      controller.destroy()
+    }
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/NowPlayingFormatExtractorTest.kt

@@ -0,0 +1,106 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.Format
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.util.UnstableApi
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Pure-mapping coverage for [NowPlayingFormatExtractor]. The full
+ * `extract(player:)` path is exercised through demo suites; these
+ * tests pin the codec / container tables so the JS-visible enum can't
+ * drift without a test failure.
+ */
+@UnstableApi
+class NowPlayingFormatExtractorTest {
+
+  @Test
+  fun mapCodecCoversAACAliases() {
+    assertEquals(AudioCodec.AAC, NowPlayingFormatExtractor.mapCodec(MimeTypes.AUDIO_AAC))
+    assertEquals(AudioCodec.AAC, NowPlayingFormatExtractor.mapCodec("audio/mp4a-latm"))
+    assertEquals(AudioCodec.AAC, NowPlayingFormatExtractor.mapCodec("audio/aac"))
+  }
+
+  @Test
+  fun mapCodecCoversMP3Layers() {
+    assertEquals(AudioCodec.MP3, NowPlayingFormatExtractor.mapCodec(MimeTypes.AUDIO_MPEG))
+    assertEquals(AudioCodec.MP3, NowPlayingFormatExtractor.mapCodec(MimeTypes.AUDIO_MPEG_L1))
+    assertEquals(AudioCodec.MP3, NowPlayingFormatExtractor.mapCodec(MimeTypes.AUDIO_MPEG_L2))
+  }
+
+  @Test
+  fun mapCodecCoversCommonFormats() {
+    assertEquals(AudioCodec.FLAC, NowPlayingFormatExtractor.mapCodec(MimeTypes.AUDIO_FLAC))
+    assertEquals(AudioCodec.FLAC, NowPlayingFormatExtractor.mapCodec("audio/x-flac"))
+    assertEquals(AudioCodec.ALAC, NowPlayingFormatExtractor.mapCodec(MimeTypes.AUDIO_ALAC))
+    assertEquals(AudioCodec.OPUS, NowPlayingFormatExtractor.mapCodec(MimeTypes.AUDIO_OPUS))
+    assertEquals(AudioCodec.PCM, NowPlayingFormatExtractor.mapCodec(MimeTypes.AUDIO_RAW))
+    assertEquals(AudioCodec.PCM, NowPlayingFormatExtractor.mapCodec("audio/wav"))
+  }
+
+  @Test
+  fun mapCodecIsCaseInsensitive() {
+    assertEquals(AudioCodec.AAC, NowPlayingFormatExtractor.mapCodec("AUDIO/AAC"))
+    assertEquals(AudioCodec.MP3, NowPlayingFormatExtractor.mapCodec("Audio/Mpeg"))
+  }
+
+  @Test
+  fun mapCodecUnknownForNullOrUnmapped() {
+    assertEquals(AudioCodec.UNKNOWN, NowPlayingFormatExtractor.mapCodec(null))
+    assertEquals(AudioCodec.UNKNOWN, NowPlayingFormatExtractor.mapCodec("video/mp4"))
+    assertEquals(AudioCodec.UNKNOWN, NowPlayingFormatExtractor.mapCodec("audio/made-up"))
+  }
+
+  @Test
+  fun mapContainerFromContainerMime() {
+    assertEquals(AudioContainer.HLS, mapWithContainer(MimeTypes.APPLICATION_M3U8))
+    assertEquals(AudioContainer.MP3, mapWithContainer(MimeTypes.AUDIO_MPEG))
+    assertEquals(AudioContainer.MP4, mapWithContainer("audio/mp4"))
+    assertEquals(AudioContainer.MP4, mapWithContainer("video/mp4"))
+    assertEquals(AudioContainer.FLAC, mapWithContainer(MimeTypes.AUDIO_FLAC))
+    assertEquals(AudioContainer.OGG, mapWithContainer("application/ogg"))
+    assertEquals(AudioContainer.WAV, mapWithContainer("audio/wav"))
+    // `MimeTypes.AUDIO_AAC` is `audio/mp4a-latm` (AAC inside MP4 LATM),
+    // not the ADTS container. Raw ADTS comes through as `audio/aac`.
+    assertEquals(AudioContainer.AAC_ADTS, mapWithContainer("audio/aac"))
+  }
+
+  @Test
+  fun mapContainerFallsBackOnUrlExtensionWhenContainerMissing() {
+    assertEquals(AudioContainer.AAC_ADTS, mapWithContainer(null, urlExtension = "aac"))
+    assertEquals(AudioContainer.MP4, mapWithContainer(null, urlExtension = "m4a"))
+    assertEquals(AudioContainer.MP4, mapWithContainer(null, urlExtension = "mp4"))
+    assertEquals(AudioContainer.FLAC, mapWithContainer(null, urlExtension = "flac"))
+    assertEquals(AudioContainer.OGG, mapWithContainer(null, urlExtension = "ogg"))
+    assertEquals(AudioContainer.WAV, mapWithContainer(null, urlExtension = "wav"))
+    assertEquals(AudioContainer.HLS, mapWithContainer(null, urlExtension = "m3u8"))
+  }
+
+  @Test
+  fun mapContainerFallsBackOnCodecWhenContainerAndUrlMissing() {
+    assertEquals(AudioContainer.MP4, mapWithContainer(null, sample = MimeTypes.AUDIO_AAC))
+    assertEquals(AudioContainer.MP3, mapWithContainer(null, sample = MimeTypes.AUDIO_MPEG))
+    assertEquals(AudioContainer.FLAC, mapWithContainer(null, sample = MimeTypes.AUDIO_FLAC))
+    assertEquals(AudioContainer.OGG, mapWithContainer(null, sample = MimeTypes.AUDIO_OPUS))
+    assertEquals(AudioContainer.WAV, mapWithContainer(null, sample = MimeTypes.AUDIO_RAW))
+  }
+
+  @Test
+  fun mapContainerUnknownWhenNoSignal() {
+    assertEquals(AudioContainer.UNKNOWN, mapWithContainer(null, sample = null))
+    assertEquals(AudioContainer.UNKNOWN, mapWithContainer(null, sample = "audio/made-up"))
+  }
+
+  private fun mapWithContainer(
+    container: String?,
+    sample: String? = MimeTypes.AUDIO_AAC,
+    urlExtension: String? = null
+  ): AudioContainer = NowPlayingFormatExtractor.mapContainer(
+    Format.Builder()
+      .setContainerMimeType(container)
+      .setSampleMimeType(sample)
+      .build(),
+    urlExtension
+  )
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/PendingBrowseRequestsTest.kt

@@ -0,0 +1,82 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.util.UnstableApi
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+@UnstableApi
+class PendingBrowseRequestsTest {
+
+  @Test
+  fun `drainAll on a fresh queue returns empty`() {
+    val queue = PendingBrowseRequests()
+    assertTrue(queue.drainAll().isEmpty())
+  }
+
+  @Test
+  fun `enqueue records the parentId`() {
+    val queue = PendingBrowseRequests()
+    queue.enqueue("root")
+    assertEquals(setOf("root"), queue.snapshotForTest())
+  }
+
+  @Test
+  fun `duplicate enqueues collapse to one entry`() {
+    val queue = PendingBrowseRequests()
+    queue.enqueue("root")
+    queue.enqueue("root")
+    queue.enqueue("section-a")
+    queue.enqueue("section-a")
+    assertEquals(setOf("root", "section-a"), queue.drainAll())
+  }
+
+  @Test
+  fun `drainAll empties the queue`() {
+    val queue = PendingBrowseRequests()
+    queue.enqueue("root")
+    queue.enqueue("section-a")
+    val drained = queue.drainAll()
+    assertEquals(setOf("root", "section-a"), drained)
+    assertTrue(queue.drainAll().isEmpty())
+    assertTrue(queue.snapshotForTest().isEmpty())
+  }
+
+  @Test
+  fun `clear empties without returning anything`() {
+    val queue = PendingBrowseRequests()
+    queue.enqueue("root")
+    queue.enqueue("section-a")
+    queue.clear()
+    assertTrue(queue.drainAll().isEmpty())
+  }
+
+  @Test
+  fun `concurrent enqueues preserve every unique parent`() {
+    val queue = PendingBrowseRequests()
+    val parents = (0 until 200).map { "parent-$it" }
+    val threads = parents.map { parent ->
+      Thread { queue.enqueue(parent) }
+    }
+    threads.forEach { it.start() }
+    threads.forEach { it.join() }
+    assertEquals(parents.toSet(), queue.drainAll())
+  }
+
+  @Test
+  fun `re-enqueue after drain accumulates fresh entries`() {
+    val queue = PendingBrowseRequests()
+    queue.enqueue("a")
+    queue.drainAll()
+    queue.enqueue("b")
+    queue.enqueue("c")
+    assertEquals(setOf("b", "c"), queue.drainAll())
+  }
+
+  @Test
+  fun `enqueue with an empty string is treated as a regular parent id`() {
+    val queue = PendingBrowseRequests()
+    queue.enqueue("")
+    assertEquals(setOf(""), queue.drainAll())
+  }
+}