rework the library lists: inline filter, playlist updated, starred sort, clearer controls

2026-11-10 15:11:58 +01:00 · 2026-10-04 00:29:55 +00:00
parent 9a99977342
commit a2d42f7957
25 changed files with 1460 additions and 408 deletions
@@ -48,10 +48,19 @@ class LibraryDaoTest {
                ),
            )

-            assertEquals(listOf("Alpha", "Beta", "Gamma"), dao.albumsByName(sourceId, starredOnly = false).page().map { it.name })
-            assertEquals(listOf("Gamma", "Beta", "Alpha"), dao.albumsByNameReversed(sourceId, starredOnly = false).page().map { it.name })
-            assertEquals(listOf("Alpha", "Beta", "Gamma"), dao.albumsByYear(sourceId, starredOnly = false).page().map { it.name })
-            assertEquals(listOf("Alpha"), dao.albumsByName(sourceId, starredOnly = true).page().map { it.name })
+            assertEquals(
+                listOf("Alpha", "Beta", "Gamma"),
+                dao.albumsByName(sourceId, starredOnly = false, search = "").page().map { it.name },
+            )
+            assertEquals(
+                listOf("Gamma", "Beta", "Alpha"),
+                dao.albumsByNameReversed(sourceId, starredOnly = false, search = "").page().map { it.name },
+            )
+            assertEquals(
+                listOf("Alpha", "Beta", "Gamma"),
+                dao.albumsByYear(sourceId, starredOnly = false, search = "").page().map { it.name },
+            )
+            assertEquals(listOf("Alpha"), dao.albumsByName(sourceId, starredOnly = true, search = "").page().map { it.name })
        }

    @Test
@@ -66,9 +75,39 @@ class LibraryDaoTest {
                ),
            )

-            assertEquals(listOf("Apple", "Zebra"), dao.songsByTitle(sourceId, starredOnly = false).page().map { it.song.title })
-            assertEquals(listOf("Zebra", "Apple"), dao.songsByTitleReversed(sourceId, starredOnly = false).page().map { it.song.title })
-            assertEquals(listOf("Apple"), dao.songsByTitle(sourceId, starredOnly = true).page().map { it.song.title })
+            assertEquals(
+                listOf("Apple", "Zebra"),
+                dao.songsByTitle(sourceId, starredOnly = false, search = "").page().map { it.song.title },
+            )
+            assertEquals(
+                listOf("Zebra", "Apple"),
+                dao.songsByTitleReversed(sourceId, starredOnly = false, search = "").page().map { it.song.title },
+            )
+            assertEquals(listOf("Apple"), dao.songsByTitle(sourceId, starredOnly = true, search = "").page().map { it.song.title })
+        }
+
+    @Test
+    fun albumAddedAndStarredSortsAndSearch() =
+        runTest {
+            val sourceId = source()
+            val dao = db.libraryDao()
+            dao.upsertAlbums(
+                listOf(
+                    album(sourceId, "a", "Beta", year = 2000, starred = null, created = 300),
+                    album(sourceId, "b", "Alpha", year = 2010, starred = 200, created = 100),
+                    album(sourceId, "c", "Gamma", year = 1990, starred = 100, created = 200),
+                ),
+            )
+
+            assertEquals(
+                listOf("Beta", "Gamma", "Alpha"),
+                dao.albumsByRecentlyAdded(sourceId, starredOnly = false, search = "").page().map { it.name },
+            )
+            assertEquals(
+                listOf("Alpha", "Gamma", "Beta"),
+                dao.albumsByStarred(sourceId, starredOnly = false, search = "").page().map { it.name },
+            )
+            assertEquals(listOf("Gamma"), dao.albumsByName(sourceId, starredOnly = false, search = "gam").page().map { it.name })
        }

    private suspend fun source(): Long =
@@ -87,13 +126,14 @@ class LibraryDaoTest {
        name: String,
        year: Long?,
        starred: Long?,
+        created: Long = 0,
    ) = Album(
        sourceId = sourceId,
        id = id,
        artistId = "ar-1",
        name = name,
        albumArtist = "Artist",
-        created = 0,
+        created = created,
        coverArt = null,
        genre = null,
        year = year,
@@ -0,0 +1,33 @@
+package com.subtracks.data.prefs
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.File
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+class UserPreferencesTest {
+    @Test
+    fun listQueryRoundTripsPerTab() =
+        runTest {
+            val file = File.createTempFile("user-prefs", ".preferences_pb").apply { delete() }
+            val store = PreferenceDataStoreFactory.create(scope = backgroundScope) { file }
+            val prefs = UserPreferences(store)
+
+            assertEquals(ListQuery("Name"), prefs.listQuery(LibraryListTab.Albums).first())
+            assertEquals(ListQuery("Album"), prefs.listQuery(LibraryListTab.Songs).first())
+
+            prefs.setListQuery(LibraryListTab.Albums, ListQuery("Added", descending = true, starredOnly = true))
+
+            assertEquals(ListQuery("Added", descending = true, starredOnly = true), prefs.listQuery(LibraryListTab.Albums).first())
+            assertEquals(ListQuery("Album"), prefs.listQuery(LibraryListTab.Songs).first())
+
+            file.delete()
+        }
+}
@@ -60,7 +60,7 @@ class SyncServiceTest {
                2,
                db
                    .libraryDao()
-                    .artistsByName(1, false)
+                    .artistsByName(1, false, "")
                    .allRows()
                    .size,
            )
@@ -68,7 +68,7 @@ class SyncServiceTest {
                2,
                db
                    .libraryDao()
-                    .songs(1, false)
+                    .songs(1, false, "")
                    .allRows()
                    .size,
            )
@@ -90,7 +90,7 @@ class SyncServiceTest {
                listOf("a1"),
                db
                    .libraryDao()
-                    .artistsByName(1, false)
+                    .artistsByName(1, false, "")
                    .allRows()
                    .map { it.id },
            )
@@ -98,7 +98,7 @@ class SyncServiceTest {
                listOf("s1"),
                db
                    .libraryDao()
-                    .songs(1, false)
+                    .songs(1, false, "")
                    .allRows()
                    .map { it.song.id },
            )
@@ -200,7 +200,7 @@ class SyncServiceTest {
                "Old",
                db
                    .libraryDao()
-                    .artistsByName(1, false)
+                    .artistsByName(1, false, "")
                    .allRows()
                    .single()
                    .name,
@@ -213,7 +213,7 @@ class SyncServiceTest {
                "New",
                db
                    .libraryDao()
-                    .artistsByName(1, false)
+                    .artistsByName(1, false, "")
                    .allRows()
                    .single()
                    .name,
@@ -5,7 +5,6 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
 import androidx.compose.ui.test.onAllNodesWithTag
-import androidx.compose.ui.test.onAllNodesWithText
 import androidx.compose.ui.test.onNodeWithContentDescription
 import androidx.compose.ui.test.onRoot
 import androidx.compose.ui.test.performClick
@@ -19,11 +18,9 @@ import com.subtracks.data.model.Artist
 import com.subtracks.data.model.Playlist
 import com.subtracks.data.model.SongListItem
 import com.subtracks.data.prefs.ListQuery
-import com.subtracks.data.repo.SearchHit
 import com.subtracks.ui.library.ALBUM_COVER_TAG
 import com.subtracks.ui.library.LibraryScreen
 import com.subtracks.ui.library.LibraryTab
-import com.subtracks.ui.library.SearchScreen
 import com.subtracks.ui.library.sortOptionsFor
 import com.subtracks.ui.theme.SubtracksTheme
 import kotlinx.coroutines.flow.flowOf
@@ -36,7 +33,7 @@ import org.robolectric.annotation.GraphicsMode
@RunWith(AndroidJUnit4::class)
@GraphicsMode(GraphicsMode.Mode.NATIVE)
@Config(qualifiers = RobolectricDeviceQualifiers.PixelXL)
-class LibraryListsScreenshotTest {
+class LibraryOptionsScreenshotTest {
    @get:Rule
    val composeRule = createAndroidComposeRule<ComponentActivity>()

@@ -73,34 +70,6 @@ class LibraryListsScreenshotTest {
        composeRule.onRoot().captureRoboImage("src/test/screenshots/library_options.png")
    }

-    @Test
-    fun search() {
-        composeRule.setContent {
-            SubtracksTheme {
-                SearchScreen(
-                    query = "radio",
-                    results =
-                        listOf(
-                            SearchHit("song", "s-eiirp", "Everything In Its Right Place"),
-                            SearchHit("album", "al-kid-a", "Kid A"),
-                            SearchHit("artist", "ar-radiohead", "Radiohead"),
-                            SearchHit("playlist", "pl-late-night", "Late Night"),
-                        ),
-                    onQueryChange = {},
-                    onBack = {},
-                    onAlbumClick = {},
-                    onArtistClick = {},
-                    onPlaylistClick = {},
-                    onSongClick = {},
-                )
-            }
-        }
-        composeRule.waitUntil(timeoutMillis = 5_000) {
-            composeRule.onAllNodesWithText("Radiohead").fetchSemanticsNodes().isNotEmpty()
-        }
-        composeRule.onRoot().captureRoboImage("src/test/screenshots/search.png")
-    }
-
    private fun albums() =
        (1..7).map { index ->
            Album(
@@ -0,0 +1,94 @@
+package com.subtracks.ui
+
+import androidx.activity.ComponentActivity
+import androidx.compose.runtime.remember
+import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
+import androidx.compose.ui.test.onAllNodesWithTag
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onRoot
+import androidx.compose.ui.test.performClick
+import androidx.paging.PagingData
+import androidx.paging.compose.collectAsLazyPagingItems
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.github.takahirom.roborazzi.RobolectricDeviceQualifiers
+import com.github.takahirom.roborazzi.captureRoboImage
+import com.subtracks.data.model.Album
+import com.subtracks.data.model.Artist
+import com.subtracks.data.model.Playlist
+import com.subtracks.data.model.SongListItem
+import com.subtracks.data.prefs.ListQuery
+import com.subtracks.ui.library.ALBUM_COVER_TAG
+import com.subtracks.ui.library.LibraryScreen
+import com.subtracks.ui.library.LibraryTab
+import com.subtracks.ui.library.sortOptionsFor
+import com.subtracks.ui.theme.SubtracksTheme
+import kotlinx.coroutines.flow.flowOf
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+
+@RunWith(AndroidJUnit4::class)
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+@Config(qualifiers = RobolectricDeviceQualifiers.PixelXL)
+class LibrarySearchScreenshotTest {
+    @get:Rule
+    val composeRule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun librarySearch() {
+        composeRule.setContent {
+            SubtracksTheme {
+                LibraryScreen(
+                    selectedTab = LibraryTab.Albums,
+                    onTabSelected = {},
+                    albums = remember { flowOf(PagingData.from(albums())) }.collectAsLazyPagingItems(),
+                    artists = remember { flowOf(PagingData.empty<Artist>()) }.collectAsLazyPagingItems(),
+                    songs = remember { flowOf(PagingData.empty<SongListItem>()) }.collectAsLazyPagingItems(),
+                    playlists = remember { flowOf(PagingData.empty<Playlist>()) }.collectAsLazyPagingItems(),
+                    coverArt = { _, _ -> null },
+                    onAlbumClick = {},
+                    onArtistClick = {},
+                    onPlaylistClick = {},
+                    onSongClick = {},
+                    onSync = {},
+                    onOpenSettings = {},
+                    listQuery = ListQuery("Name"),
+                    sortOptions = sortOptionsFor(LibraryTab.Albums),
+                    starredSupported = true,
+                )
+            }
+        }
+        composeRule.waitUntil(timeoutMillis = 5_000) {
+            composeRule.onAllNodesWithTag(ALBUM_COVER_TAG).fetchSemanticsNodes().isNotEmpty()
+        }
+        composeRule.onNodeWithContentDescription("List options").performClick()
+        composeRule.mainClock.advanceTimeBy(1_000)
+        composeRule.waitForIdle()
+        composeRule.onAllNodesWithText("Search this list")[0].performClick()
+        composeRule.mainClock.advanceTimeBy(1_000)
+        composeRule.waitForIdle()
+        composeRule.onRoot().captureRoboImage("src/test/screenshots/library_search.png")
+    }
+
+    private fun albums() =
+        (1..7).map { index ->
+            Album(
+                sourceId = 1,
+                id = "al-$index",
+                artistId = "ar-1",
+                name = "Album $index",
+                albumArtist = "Artist",
+                created = 0,
+                coverArt = null,
+                genre = null,
+                year = null,
+                starred = null,
+                songCount = 1,
+                frequentRank = null,
+                recentRank = null,
+            )
+        }
+}