@rntp/player 5.0.0-beta.3 → 5.0.0-beta.5

package/android/src/test/java/com/doublesymmetry/trackplayer/ExoPlayerIntegrationTest.kt

@@ -0,0 +1,319 @@
+package com.doublesymmetry.trackplayer
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Player
+import androidx.media3.exoplayer.ExoPlayer
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.Assert.*
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class ExoPlayerIntegrationTest {
+
+    private lateinit var player: ExoPlayer
+
+    @Before
+    fun setUp() {
+        val context = RuntimeEnvironment.getApplication()
+        player = ExoPlayer.Builder(context).build()
+    }
+
+    @After
+    fun tearDown() {
+        player.release()
+    }
+
+    // ---- Helpers ----
+
+    private fun buildMediaItem(id: String, title: String, url: String = "https://example.com/$id.mp3"): MediaItem {
+        return MediaItem.Builder()
+            .setMediaId(id)
+            .setUri(url)
+            .setMediaMetadata(MediaMetadata.Builder().setTitle(title).build())
+            .build()
+    }
+
+    private fun buildQueue(count: Int): List<MediaItem> =
+        (1..count).map { buildMediaItem("track-$it", "Track $it") }
+
+    // ---- setMediaItems ----
+
+    @Test
+    fun `setMediaItems loads queue`() {
+        val items = buildQueue(3)
+        player.setMediaItems(items)
+
+        assertEquals(3, player.mediaItemCount)
+    }
+
+    @Test
+    fun `setMediaItems replaces existing queue`() {
+        player.setMediaItems(buildQueue(5))
+        assertEquals(5, player.mediaItemCount)
+
+        player.setMediaItems(buildQueue(2))
+        assertEquals(2, player.mediaItemCount)
+    }
+
+    @Test
+    fun `setMediaItems preserves mediaId`() {
+        val item = buildMediaItem("my-id", "My Track")
+        player.setMediaItems(listOf(item))
+
+        assertEquals("my-id", player.getMediaItemAt(0).mediaId)
+    }
+
+    // ---- seekToNextMediaItem / seekToPreviousMediaItem ----
+
+    @Test
+    fun `seekToNextMediaItem advances index`() {
+        player.setMediaItems(buildQueue(3))
+        assertEquals(0, player.currentMediaItemIndex)
+
+        player.seekToNextMediaItem()
+        assertEquals(1, player.currentMediaItemIndex)
+
+        player.seekToNextMediaItem()
+        assertEquals(2, player.currentMediaItemIndex)
+    }
+
+    @Test
+    fun `seekToPreviousMediaItem goes back`() {
+        player.setMediaItems(buildQueue(3))
+        player.seekTo(2, 0L)
+        assertEquals(2, player.currentMediaItemIndex)
+
+        player.seekToPreviousMediaItem()
+        assertEquals(1, player.currentMediaItemIndex)
+    }
+
+    @Test
+    fun `seekToNextMediaItem does not advance past last item without repeat`() {
+        player.setMediaItems(buildQueue(2))
+        player.repeatMode = Player.REPEAT_MODE_OFF
+        player.seekTo(1, 0L)
+
+        // Already at last item; seekToNext should have no effect
+        player.seekToNextMediaItem()
+        assertEquals(1, player.currentMediaItemIndex)
+    }
+
+    // ---- repeat modes ----
+
+    @Test
+    fun `repeat mode one can be set`() {
+        player.repeatMode = Player.REPEAT_MODE_ONE
+        assertEquals(Player.REPEAT_MODE_ONE, player.repeatMode)
+    }
+
+    @Test
+    fun `repeat mode all wraps around`() {
+        player.setMediaItems(buildQueue(3))
+        player.repeatMode = Player.REPEAT_MODE_ALL
+        assertEquals(Player.REPEAT_MODE_ALL, player.repeatMode)
+
+        // At last item, next should wrap to index 0
+        player.seekTo(2, 0L)
+        player.seekToNextMediaItem()
+        assertEquals(0, player.currentMediaItemIndex)
+    }
+
+    @Test
+    fun `repeat mode off is the default`() {
+        assertEquals(Player.REPEAT_MODE_OFF, player.repeatMode)
+    }
+
+    // ---- shuffle mode ----
+
+    @Test
+    fun `shuffle mode can be enabled`() {
+        player.shuffleModeEnabled = true
+        assertTrue(player.shuffleModeEnabled)
+    }
+
+    @Test
+    fun `shuffle mode can be disabled`() {
+        player.shuffleModeEnabled = true
+        player.shuffleModeEnabled = false
+        assertFalse(player.shuffleModeEnabled)
+    }
+
+    @Test
+    fun `shuffle mode does not change item count`() {
+        player.setMediaItems(buildQueue(5))
+        player.shuffleModeEnabled = true
+        assertEquals(5, player.mediaItemCount)
+    }
+
+    // ---- removeMediaItem ----
+
+    @Test
+    fun `removeMediaItem removes from queue`() {
+        player.setMediaItems(buildQueue(3))
+        player.removeMediaItem(1)
+
+        assertEquals(2, player.mediaItemCount)
+        assertEquals("track-1", player.getMediaItemAt(0).mediaId)
+        assertEquals("track-3", player.getMediaItemAt(1).mediaId)
+    }
+
+    @Test
+    fun `removeMediaItem at index 0`() {
+        player.setMediaItems(buildQueue(3))
+        player.removeMediaItem(0)
+
+        assertEquals(2, player.mediaItemCount)
+        assertEquals("track-2", player.getMediaItemAt(0).mediaId)
+    }
+
+    @Test
+    fun `removeMediaItem at last index`() {
+        player.setMediaItems(buildQueue(3))
+        player.removeMediaItem(2)
+
+        assertEquals(2, player.mediaItemCount)
+        assertEquals("track-1", player.getMediaItemAt(0).mediaId)
+        assertEquals("track-2", player.getMediaItemAt(1).mediaId)
+    }
+
+    // ---- replaceMediaItem ----
+
+    @Test
+    fun `replaceMediaItem swaps item at index`() {
+        player.setMediaItems(buildQueue(3))
+
+        val replacement = buildMediaItem("replacement", "Replacement Track")
+        player.replaceMediaItem(1, replacement)
+
+        assertEquals(3, player.mediaItemCount)
+        assertEquals("replacement", player.getMediaItemAt(1).mediaId)
+        assertEquals("track-1", player.getMediaItemAt(0).mediaId)
+        assertEquals("track-3", player.getMediaItemAt(2).mediaId)
+    }
+
+    @Test
+    fun `replaceMediaItem at index 0`() {
+        player.setMediaItems(buildQueue(2))
+        val newItem = buildMediaItem("new-first", "New First")
+        player.replaceMediaItem(0, newItem)
+
+        assertEquals("new-first", player.getMediaItemAt(0).mediaId)
+        assertEquals("track-2", player.getMediaItemAt(1).mediaId)
+    }
+
+    // ---- clearMediaItems ----
+
+    @Test
+    fun `clearMediaItems empties queue`() {
+        player.setMediaItems(buildQueue(5))
+        assertEquals(5, player.mediaItemCount)
+
+        player.clearMediaItems()
+        assertEquals(0, player.mediaItemCount)
+    }
+
+    @Test
+    fun `clearMediaItems on empty queue is safe`() {
+        player.clearMediaItems()
+        assertEquals(0, player.mediaItemCount)
+    }
+
+    // ---- addMediaItem / addMediaItems ----
+
+    @Test
+    fun `addMediaItem appends to queue`() {
+        player.setMediaItems(buildQueue(2))
+        player.addMediaItem(buildMediaItem("track-3", "Track 3"))
+
+        assertEquals(3, player.mediaItemCount)
+        assertEquals("track-3", player.getMediaItemAt(2).mediaId)
+    }
+
+    @Test
+    fun `addMediaItem at index inserts at correct position`() {
+        player.setMediaItems(buildQueue(3))
+        val inserted = buildMediaItem("inserted", "Inserted")
+        player.addMediaItem(1, inserted)
+
+        assertEquals(4, player.mediaItemCount)
+        assertEquals("track-1", player.getMediaItemAt(0).mediaId)
+        assertEquals("inserted", player.getMediaItemAt(1).mediaId)
+        assertEquals("track-2", player.getMediaItemAt(2).mediaId)
+    }
+
+    // ---- volume ----
+
+    @Test
+    fun `volume defaults to 1`() {
+        assertEquals(1.0f, player.volume, 0.001f)
+    }
+
+    @Test
+    fun `volume can be set to 0`() {
+        player.volume = 0.0f
+        assertEquals(0.0f, player.volume, 0.001f)
+    }
+
+    @Test
+    fun `volume can be set to half`() {
+        player.volume = 0.5f
+        assertEquals(0.5f, player.volume, 0.001f)
+    }
+
+    @Test
+    fun `volume is clamped between 0 and 1`() {
+        // ExoPlayer clamps values; setting beyond range should be bounded
+        player.volume = 1.0f
+        assertEquals(1.0f, player.volume, 0.001f)
+
+        player.volume = 0.0f
+        assertEquals(0.0f, player.volume, 0.001f)
+    }
+
+    // ---- seekTo ----
+
+    @Test
+    fun `seekTo sets position in queue`() {
+        player.setMediaItems(buildQueue(3))
+        player.seekTo(2, 5000L)
+
+        assertEquals(2, player.currentMediaItemIndex)
+    }
+
+    // ---- moveMediaItem ----
+
+    @Test
+    fun `moveMediaItem reorders queue`() {
+        player.setMediaItems(buildQueue(3))
+        player.moveMediaItem(0, 2)
+
+        // track-1 should now be at index 2
+        assertEquals("track-2", player.getMediaItemAt(0).mediaId)
+        assertEquals("track-3", player.getMediaItemAt(1).mediaId)
+        assertEquals("track-1", player.getMediaItemAt(2).mediaId)
+    }
+
+    // ---- metadata retrieval ----
+
+    @Test
+    fun `getMediaItemAt returns correct metadata`() {
+        val item = buildMediaItem("meta-test", "Metadata Test Track")
+        player.setMediaItems(listOf(item))
+
+        val retrieved = player.getMediaItemAt(0)
+        assertEquals("meta-test", retrieved.mediaId)
+        assertEquals("Metadata Test Track", retrieved.mediaMetadata.title.toString())
+    }
+
+    @Test
+    fun `player initial state is idle`() {
+        assertEquals(Player.STATE_IDLE, player.playbackState)
+    }
+}