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

package/android/src/test/java/com/doublesymmetry/trackplayer/models/BrowseNavigationTest.kt

@@ -0,0 +1,215 @@
+package com.doublesymmetry.trackplayer.models
+
+import org.junit.Test
+import org.junit.Assert.*
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class BrowseNavigationTest {
+
+    // Helper to build a tree with two categories, each having different item types
+    private fun buildTree(): BrowseTree {
+        return BrowseTree(listOf(
+            BrowseCategory(
+                mediaId = "cat-music",
+                title = "Music",
+                items = listOf(
+                    BrowseMediaItem(
+                        mediaId = "track-1",
+                        url = "https://example.com/track1.mp3",
+                        title = "Track 1",
+                        artist = "Artist A",
+                        artworkUrl = "https://example.com/art.jpg",
+                    ),
+                    BrowseMediaItem(
+                        mediaId = "album-1",
+                        title = "Album",
+                        children = listOf(
+                            BrowseMediaItem(
+                                mediaId = "track-2",
+                                url = "https://example.com/track2.mp3",
+                                title = "Track 2",
+                                artist = "Artist B",
+                            )
+                        ),
+                    ),
+                ),
+            ),
+            BrowseCategory(
+                mediaId = "cat-podcasts",
+                title = "Podcasts",
+                items = listOf(
+                    BrowseMediaItem(
+                        mediaId = "episode-1",
+                        url = "https://example.com/ep1.mp3",
+                        title = "Episode 1",
+                    )
+                ),
+            ),
+        ))
+    }
+
+    // --- Simulating onGetChildren root logic ---
+    // Root: return categories mapped to browsable MediaItems
+
+    @Test
+    fun `root returns all categories as browsable items`() {
+        val tree = buildTree()
+
+        // Simulate what onGetChildren("root") does: map categories to MediaItems
+        val items = tree.categories.map { cat ->
+            BrowseMediaItem(
+                mediaId = cat.mediaId,
+                title = cat.title,
+                children = cat.items, // presence of children makes it browsable
+            ).toMediaItem()
+        }
+
+        assertEquals(2, items.size)
+        items.forEach { item ->
+            assertEquals(true, item.mediaMetadata.isBrowsable)
+            assertEquals(false, item.mediaMetadata.isPlayable)
+        }
+        assertEquals("cat-music", items[0].mediaId)
+        assertEquals("cat-podcasts", items[1].mediaId)
+        assertEquals("Music", items[0].mediaMetadata.title.toString())
+    }
+
+    // --- Simulating onGetChildren for a category parentId ---
+
+    @Test
+    fun `category returns its direct children`() {
+        val tree = buildTree()
+
+        val category = tree.findCategory("cat-music")
+        assertNotNull(category)
+
+        val items = category!!.items.map { it.toMediaItem() }
+        assertEquals(2, items.size)
+
+        // First child is a playable track
+        val track = items[0]
+        assertEquals("track-1", track.mediaId)
+        assertEquals(true, track.mediaMetadata.isPlayable)
+        assertEquals(false, track.mediaMetadata.isBrowsable)
+
+        // Second child is a browsable album
+        val album = items[1]
+        assertEquals("album-1", album.mediaId)
+        assertEquals(false, album.mediaMetadata.isPlayable)
+        assertEquals(true, album.mediaMetadata.isBrowsable)
+    }
+
+    // --- Simulating onGetChildren for a browsable item parentId ---
+
+    @Test
+    fun `browsable item returns its children`() {
+        val tree = buildTree()
+
+        val item = tree.findItem("album-1")
+        assertNotNull(item)
+        assertNotNull(item!!.children)
+
+        val children = item.children!!.map { it.toMediaItem() }
+        assertEquals(1, children.size)
+        assertEquals("track-2", children[0].mediaId)
+        assertEquals(true, children[0].mediaMetadata.isPlayable)
+    }
+
+    @Test
+    fun `unknown parentId returns null for both lookups`() {
+        val tree = buildTree()
+
+        val category = tree.findCategory("nonexistent")
+        val item = tree.findItem("nonexistent")
+
+        assertNull(category)
+        assertNull(item)
+    }
+
+    @Test
+    fun `playable items in category have correct metadata`() {
+        val tree = buildTree()
+
+        val category = tree.findCategory("cat-music")!!
+        val playableItem = category.items.first { it.isPlayable }
+        val mediaItem = playableItem.toMediaItem()
+
+        assertEquals("track-1", mediaItem.mediaId)
+        assertEquals("Track 1", mediaItem.mediaMetadata.title.toString())
+        assertEquals("Artist A", mediaItem.mediaMetadata.artist.toString())
+        assertNotNull(mediaItem.localConfiguration?.uri)
+        assertEquals("https://example.com/track1.mp3", mediaItem.localConfiguration!!.uri.toString())
+        assertEquals(true, mediaItem.mediaMetadata.isPlayable)
+        assertEquals(false, mediaItem.mediaMetadata.isBrowsable)
+    }
+
+    @Test
+    fun `browsable items have no URI and isBrowsable is true`() {
+        val tree = buildTree()
+
+        val category = tree.findCategory("cat-music")!!
+        val browsableItem = category.items.first { it.isBrowsable }
+        val mediaItem = browsableItem.toMediaItem()
+
+        assertEquals("album-1", mediaItem.mediaId)
+        assertEquals(true, mediaItem.mediaMetadata.isBrowsable)
+        assertEquals(false, mediaItem.mediaMetadata.isPlayable)
+        // Browsable items have no local configuration (no URI set)
+        assertNull(mediaItem.localConfiguration)
+    }
+
+    @Test
+    fun `category lookup works across multiple categories`() {
+        val tree = buildTree()
+
+        val podcasts = tree.findCategory("cat-podcasts")
+        assertNotNull(podcasts)
+        assertEquals("Podcasts", podcasts!!.title)
+        assertEquals(1, podcasts.items.size)
+        assertEquals("episode-1", podcasts.items[0].mediaId)
+    }
+
+    @Test
+    fun `toMediaItem sets correct artwork URI for playable items`() {
+        val item = BrowseMediaItem(
+            mediaId = "t1",
+            url = "https://example.com/t.mp3",
+            artworkUrl = "https://example.com/art.jpg",
+        )
+        val mediaItem = item.toMediaItem()
+
+        assertNotNull(mediaItem.mediaMetadata.artworkUri)
+        assertEquals("https://example.com/art.jpg", mediaItem.mediaMetadata.artworkUri.toString())
+    }
+
+    @Test
+    fun `toMediaItem stores duration and isLive in extras`() {
+        val item = BrowseMediaItem(
+            mediaId = "live-1",
+            url = "https://example.com/live.mp3",
+            duration = 3600.0,
+            isLive = true,
+        )
+        val mediaItem = item.toMediaItem()
+
+        val extras = mediaItem.mediaMetadata.extras
+        assertNotNull(extras)
+        assertEquals(3600.0, extras!!.getDouble("duration"), 0.001)
+        assertTrue(extras.getBoolean("isLive"))
+        // Live items get a LiveConfiguration
+        assertNotNull(mediaItem.liveConfiguration)
+    }
+
+    @Test
+    fun `empty category returns empty children list`() {
+        val tree = BrowseTree(listOf(
+            BrowseCategory(mediaId = "empty-cat", title = "Empty", items = emptyList())
+        ))
+
+        val category = tree.findCategory("empty-cat")
+        assertNotNull(category)
+        assertTrue(category!!.items.isEmpty())
+    }
+}

package/android/src/test/java/com/doublesymmetry/trackplayer/models/BrowseTreeTest.kt

@@ -0,0 +1,166 @@
+package com.doublesymmetry.trackplayer.models
+
+import org.junit.Test
+import org.junit.Assert.*
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class BrowseTreeTest {
+
+    @Test
+    fun `store and load round-trip preserves data`() {
+        val tree = BrowseTree(listOf(
+            BrowseCategory("cat-1", "Music", listOf(
+                BrowseMediaItem(mediaId = "t1", url = "https://example.com/t1.mp3", title = "Track 1")
+            ))
+        ))
+        val context = RuntimeEnvironment.getApplication()
+        tree.store(context)
+        val loaded = BrowseTree.load(context)
+
+        assertEquals(1, loaded.categories.size)
+        assertEquals("Music", loaded.categories[0].title)
+        assertEquals("t1", loaded.categories[0].items[0].mediaId)
+    }
+
+    @Test
+    fun `load with corrupt JSON returns empty tree`() {
+        val context = RuntimeEnvironment.getApplication()
+        val prefs = context.getSharedPreferences("TrackPlayerPrefs", 0)
+        prefs.edit().putString("browse_tree", "not valid json{{{").apply()
+
+        val tree = BrowseTree.load(context)
+        assertTrue(tree.categories.isEmpty())
+    }
+
+    @Test
+    fun `load with no saved data returns empty tree`() {
+        val context = RuntimeEnvironment.getApplication()
+        val tree = BrowseTree.load(context)
+        assertTrue(tree.categories.isEmpty())
+    }
+
+    @Test
+    fun `findCategory returns matching category`() {
+        val tree = BrowseTree(listOf(
+            BrowseCategory("cat-1", "Music", emptyList()),
+            BrowseCategory("cat-2", "Podcasts", emptyList()),
+        ))
+        assertEquals("Podcasts", tree.findCategory("cat-2")?.title)
+    }
+
+    @Test
+    fun `findCategory returns null for unknown id`() {
+        val tree = BrowseTree(listOf(BrowseCategory("cat-1", "Music", emptyList())))
+        assertNull(tree.findCategory("unknown"))
+    }
+
+    @Test
+    fun `findItem finds top-level item`() {
+        val tree = BrowseTree(listOf(
+            BrowseCategory("cat-1", "Music", listOf(
+                BrowseMediaItem(mediaId = "t1", url = "a.mp3", title = "Track 1"),
+                BrowseMediaItem(mediaId = "t2", url = "b.mp3", title = "Track 2"),
+            ))
+        ))
+        assertEquals("Track 2", tree.findItem("t2")?.title)
+    }
+
+    @Test
+    fun `findItem finds deeply nested item`() {
+        val tree = BrowseTree(listOf(
+            BrowseCategory("cat-1", "Music", listOf(
+                BrowseMediaItem(mediaId = "album-1", title = "Album", children = listOf(
+                    BrowseMediaItem(mediaId = "disc-1", title = "Disc 1", children = listOf(
+                        BrowseMediaItem(mediaId = "deep-track", url = "deep.mp3", title = "Deep Track")
+                    ))
+                ))
+            ))
+        ))
+        val found = tree.findItem("deep-track")
+        assertEquals("Deep Track", found?.title)
+        assertEquals("deep.mp3", found?.url)
+    }
+
+    @Test
+    fun `findItem returns null for unknown id`() {
+        val tree = BrowseTree(listOf(
+            BrowseCategory("cat-1", "Music", listOf(
+                BrowseMediaItem(mediaId = "t1", url = "a.mp3")
+            ))
+        ))
+        assertNull(tree.findItem("nonexistent"))
+    }
+
+    @Test
+    fun `isPlayable is true when url is present`() {
+        val item = BrowseMediaItem(mediaId = "t1", url = "a.mp3")
+        assertTrue(item.isPlayable)
+        assertFalse(item.isBrowsable)
+    }
+
+    @Test
+    fun `isBrowsable is true when children present and no url`() {
+        val item = BrowseMediaItem(mediaId = "folder", children = listOf(
+            BrowseMediaItem(mediaId = "t1", url = "a.mp3")
+        ))
+        assertTrue(item.isBrowsable)
+        assertFalse(item.isPlayable)
+    }
+
+    @Test
+    fun `url takes precedence over children for playability`() {
+        val item = BrowseMediaItem(mediaId = "t1", url = "a.mp3", children = listOf(
+            BrowseMediaItem(mediaId = "t2", url = "b.mp3")
+        ))
+        assertTrue(item.isPlayable)
+        assertFalse(item.isBrowsable)
+    }
+
+    @Test
+    fun `toMediaItem sets playable metadata for track`() {
+        val item = BrowseMediaItem(
+            mediaId = "t1", url = "https://example.com/t1.mp3",
+            title = "Song", artist = "Artist",
+        )
+        val mediaItem = item.toMediaItem()
+        assertEquals("t1", mediaItem.mediaId)
+        assertEquals("Song", mediaItem.mediaMetadata.title.toString())
+        assertEquals(true, mediaItem.mediaMetadata.isPlayable)
+        assertEquals(false, mediaItem.mediaMetadata.isBrowsable)
+    }
+
+    @Test
+    fun `toMediaItem sets browsable metadata for folder`() {
+        val item = BrowseMediaItem(
+            mediaId = "album-1", title = "Album",
+            children = listOf(BrowseMediaItem(mediaId = "t1", url = "a.mp3")),
+        )
+        val mediaItem = item.toMediaItem()
+        assertEquals(false, mediaItem.mediaMetadata.isPlayable)
+        assertEquals(true, mediaItem.mediaMetadata.isBrowsable)
+    }
+
+    @Test
+    fun `store and load preserves nested children`() {
+        val tree = BrowseTree(listOf(
+            BrowseCategory("cat-1", "Music", listOf(
+                BrowseMediaItem(mediaId = "album", title = "Album", children = listOf(
+                    BrowseMediaItem(mediaId = "t1", url = "a.mp3", title = "Track 1"),
+                    BrowseMediaItem(mediaId = "t2", url = "b.mp3", title = "Track 2"),
+                ))
+            ))
+        ))
+        val context = RuntimeEnvironment.getApplication()
+        tree.store(context)
+        val loaded = BrowseTree.load(context)
+
+        val album = loaded.categories[0].items[0]
+        assertEquals("album", album.mediaId)
+        assertNotNull(album.children)
+        assertEquals(2, album.children!!.size)
+        assertEquals("t1", album.children!![0].mediaId)
+    }
+}

package/android/src/test/java/com/doublesymmetry/trackplayer/models/EmitEventTest.kt

@@ -0,0 +1,68 @@
+package com.doublesymmetry.trackplayer.models
+
+import org.junit.Test
+import org.junit.Assert.*
+
+class EmitEventTest {
+
+    @Test
+    fun `PlaybackStateChangedEvent produces correct pairs`() {
+        val event = PlaybackStateChangedEvent("ready")
+        assertEquals(EmitEventType.PLAYBACK_STATE_CHANGED, event.type)
+        assertEquals(1, event.pairs().size)
+        assertEquals("state" to "ready", event.pairs()[0])
+    }
+
+    @Test
+    fun `IsPlayingChangedEvent produces correct pairs`() {
+        val event = IsPlayingChangedEvent(true)
+        assertEquals("playing" to true, event.pairs()[0])
+    }
+
+    @Test
+    fun `MediaItemTransitionEvent with null item omits item`() {
+        val event = MediaItemTransitionEvent(null, 3)
+        assertEquals(1, event.pairs().size)
+        assertEquals("index" to 3, event.pairs()[0])
+    }
+
+    @Test
+    fun `MediaItemTransitionEvent with item includes both`() {
+        val event = MediaItemTransitionEvent("item-data", 0)
+        assertEquals(2, event.pairs().size)
+        assertTrue(event.pairs().any { it.first == "index" && it.second == 0 })
+        assertTrue(event.pairs().any { it.first == "item" && it.second == "item-data" })
+    }
+
+    @Test
+    fun `SleepTimerTriggeredEvent produces correct pairs`() {
+        val event = SleepTimerTriggeredEvent("time")
+        assertEquals(EmitEventType.SLEEP_TIMER_TRIGGERED, event.type)
+        assertEquals("type" to "time", event.pairs()[0])
+    }
+
+    @Test
+    fun `PlaybackErrorEvent produces code and message`() {
+        val event = PlaybackErrorEvent("network", "Connection failed")
+        assertTrue(event.pairs().any { it.first == "code" && it.second == "network" })
+        assertTrue(event.pairs().any { it.first == "message" && it.second == "Connection failed" })
+    }
+
+    @Test
+    fun `MetadataReceivedEvent with partial fields only includes non-null`() {
+        val event = MetadataReceivedEvent(title = "Song", artist = null)
+        assertEquals(1, event.pairs().size)
+        assertEquals("title" to "Song", event.pairs()[0])
+    }
+
+    @Test
+    fun `QueueChangedEvent has empty pairs`() {
+        assertEquals(0, QueueChangedEvent().pairs().size)
+    }
+
+    @Test
+    fun `all EmitEventType values have unique string values`() {
+        val values = EmitEventType.entries.map { it.value }
+        assertEquals(values.size, values.toSet().size)
+    }
+}