Merge pull request #6117 from element-hq/feature/fga/room_list_filter_rust

Refactor room list filtering to use Rust SDK

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/roomlist/RoomListDynamicEvents.kt

@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2025 Element Creations Ltd.
- * Copyright 2023-2025 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.libraries.matrix.impl.roomlist
-
-import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind
-
-internal sealed interface RoomListDynamicEvents {
-    data object Reset : RoomListDynamicEvents
-    data object LoadMore : RoomListDynamicEvents
-    data class SetFilter(val filter: RoomListEntriesDynamicFilterKind) : RoomListDynamicEvents
-}

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/roomlist/RoomListExtensions.kt

@@ -18,9 +18,8 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.buffer
 import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
 import org.matrix.rustcomponents.sdk.Room
+import org.matrix.rustcomponents.sdk.RoomListDynamicEntriesController
 import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind
 import org.matrix.rustcomponents.sdk.RoomListEntriesListener
 import org.matrix.rustcomponents.sdk.RoomListEntriesUpdate
@@ -57,8 +56,8 @@ fun RoomListInterface.loadingStateFlow(): Flow<RoomListLoadingState> =
 
 internal fun RoomListInterface.entriesFlow(
     pageSize: Int,
-    roomListDynamicEvents: Flow<RoomListDynamicEvents>,
-    initialFilterKind: RoomListEntriesDynamicFilterKind
+    initialFilterKind: RoomListEntriesDynamicFilterKind,
+    onControllerCreated: (RoomListDynamicEntriesController) -> Unit,
 ): Flow<List<RoomListEntriesUpdate>> =
     callbackFlow {
         val listener = object : RoomListEntriesListener {
@@ -73,19 +72,7 @@ internal fun RoomListInterface.entriesFlow(
         )
         val controller = result.controller()
         controller.setFilter(initialFilterKind)
-        roomListDynamicEvents.onEach { controllerEvents ->
-            when (controllerEvents) {
-                is RoomListDynamicEvents.SetFilter -> {
-                    controller.setFilter(controllerEvents.filter)
-                }
-                is RoomListDynamicEvents.LoadMore -> {
-                    controller.addOnePage()
-                }
-                is RoomListDynamicEvents.Reset -> {
-                    controller.resetToOnePage()
-                }
-            }
-        }.launchIn(this)
+        onControllerCreated(controller)
         awaitClose {
             result.entriesStream().cancelAndDestroy()
             controller.destroy()

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/roomlist/RoomListFactory.kt

@@ -11,6 +11,7 @@ package io.element.android.libraries.matrix.impl.roomlist
 import io.element.android.libraries.matrix.api.roomlist.DynamicRoomList
 import io.element.android.libraries.matrix.api.roomlist.RoomList
 import io.element.android.libraries.matrix.api.roomlist.RoomListFilter
+import io.element.android.libraries.matrix.api.roomlist.RoomListFilter.Companion.all
 import io.element.android.libraries.matrix.api.roomlist.RoomSummary
 import io.element.android.services.analytics.api.AnalyticsLongRunningTransaction
 import io.element.android.services.analytics.api.AnalyticsService
@@ -18,24 +19,16 @@ import io.element.android.services.analytics.api.finishLongRunningTransaction
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.getAndUpdate
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
-import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind
+import org.matrix.rustcomponents.sdk.RoomListDynamicEntriesController
 import org.matrix.rustcomponents.sdk.RoomListLoadingState
 import org.matrix.rustcomponents.sdk.RoomListService
 import kotlin.coroutines.CoroutineContext
 import org.matrix.rustcomponents.sdk.RoomList as InnerRoomList
 
-private val ROOM_LIST_RUST_FILTERS = listOf(
-    RoomListEntriesDynamicFilterKind.NonLeft,
-    RoomListEntriesDynamicFilterKind.DeduplicateVersions
-)
-
 internal class RoomListFactory(
     private val innerRoomListService: RoomListService,
     private val analyticsService: AnalyticsService,
@@ -49,18 +42,14 @@ internal class RoomListFactory(
         pageSize: Int,
         coroutineContext: CoroutineContext,
         coroutineScope: CoroutineScope,
-        initialFilter: RoomListFilter = RoomListFilter.all(),
+        initialFilter: RoomListFilter = all(),
         innerProvider: suspend () -> InnerRoomList
     ): DynamicRoomList {
         val loadingStateFlow: MutableStateFlow<RoomList.LoadingState> = MutableStateFlow(RoomList.LoadingState.NotLoaded)
-        val filteredSummariesFlow = MutableSharedFlow<List<RoomSummary>>(replay = 1, extraBufferCapacity = 1)
         val summariesFlow = MutableSharedFlow<List<RoomSummary>>(replay = 1, extraBufferCapacity = 1)
         val processor = RoomSummaryListProcessor(summariesFlow, innerRoomListService, coroutineContext, roomSummaryFactory, analyticsService)
-        // Makes sure we don't miss any events
-        val dynamicEvents = MutableSharedFlow<RoomListDynamicEvents>(replay = 100)
-        val currentFilter = MutableStateFlow(initialFilter)
-        val loadedPages = MutableStateFlow(1)
         var innerRoomList: InnerRoomList? = null
+        var dynamicController: RoomListDynamicEntriesController? = null
 
         val firstRoomsTransaction = analyticsService.startTransaction("Load first set of rooms", "innerRoomList.entriesFlow")
 
@@ -69,8 +58,10 @@ internal class RoomListFactory(
             innerRoomList.let { innerRoomList ->
                 innerRoomList.entriesFlow(
                     pageSize = pageSize,
-                    roomListDynamicEvents = dynamicEvents,
-                    initialFilterKind = RoomListEntriesDynamicFilterKind.All(ROOM_LIST_RUST_FILTERS),
+                    initialFilterKind = RoomListFilterMapper.toRustFilter(initialFilter),
+                    onControllerCreated = { controller ->
+                        dynamicController = controller
+                    }
                 ).onEach { update ->
                     if (!firstRoomsTransaction.isFinished()) {
                         analyticsService.finishLongRunningTransaction(AnalyticsLongRunningTransaction.FirstRoomsDisplayed)
@@ -85,61 +76,20 @@ internal class RoomListFactory(
                         loadingStateFlow.value = it
                     }
                     .launchIn(this)
-
-                combine(
-                    currentFilter,
-                    summariesFlow
-                ) { filter, summaries ->
-                    summaries.filter(filter)
-                }.onEach {
-                    filteredSummariesFlow.emit(it)
-                }.launchIn(this)
             }
         }.invokeOnCompletion {
             innerRoomList?.destroy()
         }
         return RustDynamicRoomList(
             summaries = summariesFlow,
-            filteredSummaries = filteredSummariesFlow,
             loadingState = loadingStateFlow,
-            currentFilter = currentFilter,
-            loadedPages = loadedPages,
-            dynamicEvents = dynamicEvents,
             processor = processor,
             pageSize = pageSize,
+            dynamicController = { dynamicController }
         )
     }
 }
 
-private class RustDynamicRoomList(
-    override val summaries: MutableSharedFlow<List<RoomSummary>>,
-    override val filteredSummaries: SharedFlow<List<RoomSummary>>,
-    override val loadingState: MutableStateFlow<RoomList.LoadingState>,
-    override val currentFilter: MutableStateFlow<RoomListFilter>,
-    override val loadedPages: MutableStateFlow<Int>,
-    private val dynamicEvents: MutableSharedFlow<RoomListDynamicEvents>,
-    private val processor: RoomSummaryListProcessor,
-    override val pageSize: Int,
-) : DynamicRoomList {
-    override suspend fun rebuildSummaries() {
-        processor.rebuildRoomSummaries()
-    }
-
-    override suspend fun updateFilter(filter: RoomListFilter) {
-        currentFilter.emit(filter)
-    }
-
-    override suspend fun loadMore() {
-        dynamicEvents.emit(RoomListDynamicEvents.LoadMore)
-        loadedPages.getAndUpdate { it + 1 }
-    }
-
-    override suspend fun reset() {
-        dynamicEvents.emit(RoomListDynamicEvents.Reset)
-        loadedPages.emit(1)
-    }
-}
-
 private fun RoomListLoadingState.toLoadingState(): RoomList.LoadingState {
     return when (this) {
         is RoomListLoadingState.Loaded -> RoomList.LoadingState.Loaded(maximumNumberOfRooms?.toInt() ?: 0)

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/roomlist/RoomListFilter.kt

@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2025 Element Creations Ltd.
- * Copyright 2024, 2025 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.libraries.matrix.impl.roomlist
-
-import io.element.android.libraries.core.extensions.withoutAccents
-import io.element.android.libraries.matrix.api.room.CurrentUserMembership
-import io.element.android.libraries.matrix.api.room.isDm
-import io.element.android.libraries.matrix.api.roomlist.RoomListFilter
-import io.element.android.libraries.matrix.api.roomlist.RoomSummary
-
-val RoomListFilter.predicate
-    get() = when (this) {
-        is RoomListFilter.All -> { roomSummary -> NonSpacePredicate(roomSummary) || IsInvitedPredicate(roomSummary) }
-        is RoomListFilter.Any -> { roomSummary -> NonSpacePredicate(roomSummary) || IsInvitedPredicate(roomSummary) }
-        RoomListFilter.None -> { _ -> false }
-        RoomListFilter.Category.Group -> { roomSummary: RoomSummary ->
-            !roomSummary.info.isDm && NonInvitedPredicate(roomSummary) && NonSpacePredicate(roomSummary)
-        }
-        RoomListFilter.Category.People -> { roomSummary: RoomSummary ->
-            roomSummary.info.isDm && NonInvitedPredicate(roomSummary) && NonSpacePredicate(roomSummary)
-        }
-        RoomListFilter.Category.Space -> IsSpacePredicate
-        RoomListFilter.Favorite -> { roomSummary: RoomSummary ->
-            roomSummary.info.isFavorite && NonInvitedPredicate(roomSummary) && NonSpacePredicate(roomSummary)
-        }
-        RoomListFilter.Unread -> { roomSummary: RoomSummary ->
-            NonInvitedPredicate(roomSummary) &&
-                NonSpacePredicate(roomSummary) &&
-                (roomSummary.info.numUnreadNotifications > 0 || roomSummary.info.isMarkedUnread)
-        }
-        is RoomListFilter.NormalizedMatchRoomName -> { roomSummary: RoomSummary ->
-            roomSummary.info.name?.withoutAccents().orEmpty().contains(normalizedPattern, ignoreCase = true) &&
-                (NonSpacePredicate(roomSummary) || IsInvitedPredicate(roomSummary))
-        }
-        RoomListFilter.Invite -> IsInvitedPredicate
-    }
-
-fun List<RoomSummary>.filter(filter: RoomListFilter): List<RoomSummary> {
-    return when (filter) {
-        is RoomListFilter.All -> {
-            val predicates = if (filter.filters.isNotEmpty()) {
-                filter.filters.map { it.predicate }
-            } else {
-                listOf(filter.predicate)
-            }
-            filter { roomSummary -> predicates.all { it(roomSummary) } }
-        }
-        is RoomListFilter.Any -> {
-            val predicates = if (filter.filters.isNotEmpty()) {
-                filter.filters.map { it.predicate }
-            } else {
-                listOf(filter.predicate)
-            }
-            filter { roomSummary -> predicates.any { it(roomSummary) } }
-        }
-        else -> filter(filter.predicate)
-    }
-}
-
-private val IsSpacePredicate = { roomSummary: RoomSummary -> roomSummary.info.isSpace }
-
-private val NonSpacePredicate = { roomSummary: RoomSummary -> !IsSpacePredicate(roomSummary) }
-
-private val IsInvitedPredicate = { roomSummary: RoomSummary -> roomSummary.info.currentUserMembership == CurrentUserMembership.INVITED }
-
-private val NonInvitedPredicate = { roomSummary: RoomSummary -> !IsInvitedPredicate(roomSummary) }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/roomlist/RoomListFilterMapper.kt

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.roomlist
+
+import io.element.android.libraries.matrix.api.roomlist.RoomListFilter
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.All
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.Any
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.Category
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.DeduplicateVersions
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.Favourite
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.Invite
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.NonLeft
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.NonSpace
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.None
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.NormalizedMatchRoomName
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.Space
+import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind.Unread
+import org.matrix.rustcomponents.sdk.RoomListFilterCategory
+
+/**
+ * Mapper for converting RoomListFilter to Rust SDK filter kinds.
+ */
+internal object RoomListFilterMapper {
+    /**
+     * Base rust filters to always apply across all room lists.
+     * These filters ensure we show:
+     * - Non-space, non-left rooms (regular rooms user is part of)
+     * - OR space invites (pending space invitations)
+     * - With version deduplication enabled
+     */
+    private val RUST_BASE_FILTERS = listOf(
+        Any(
+            listOf(
+                All(listOf(NonSpace, NonLeft)),
+                All(listOf(Space, Invite)),
+            )
+        ),
+        DeduplicateVersions
+    )
+
+    /**
+     * Converts a RoomListFilter to a Rust SDK RoomListEntriesDynamicFilterKind.
+     * Applies base filters along with the provided filter.
+     */
+    fun toRustFilter(filter: RoomListFilter): RoomListEntriesDynamicFilterKind {
+        return All(RUST_BASE_FILTERS + mapFilter(filter))
+    }
+
+    /**
+     * Maps a RoomListFilter to its Rust SDK equivalent.
+     * This replaces the previous RoomListFilter.into() extension function.
+     */
+    private fun mapFilter(filter: RoomListFilter): RoomListEntriesDynamicFilterKind {
+        return when (filter) {
+            is RoomListFilter.All -> All(filters = filter.filters.map { mapFilter(it) })
+            is RoomListFilter.Any -> Any(filters = filter.filters.map { mapFilter(it) })
+            RoomListFilter.None -> None
+            RoomListFilter.Category.Group -> Category(RoomListFilterCategory.GROUP)
+            RoomListFilter.Category.People -> Category(RoomListFilterCategory.PEOPLE)
+            RoomListFilter.Category.Space -> Space
+            RoomListFilter.Favorite -> Favourite
+            RoomListFilter.Unread -> Unread
+            is RoomListFilter.NormalizedMatchRoomName -> NormalizedMatchRoomName(
+                pattern = filter.pattern
+            )
+            RoomListFilter.Invite -> Invite
+        }
+    }
+}

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/roomlist/RustDynamicRoomList.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.roomlist
+
+import io.element.android.libraries.matrix.api.roomlist.DynamicRoomList
+import io.element.android.libraries.matrix.api.roomlist.RoomList
+import io.element.android.libraries.matrix.api.roomlist.RoomListFilter
+import io.element.android.libraries.matrix.api.roomlist.RoomSummary
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.matrix.rustcomponents.sdk.RoomListDynamicEntriesController
+
+private const val DEFAULT_ADD_PAGES_COUNT = 3
+
+internal class RustDynamicRoomList(
+    override val summaries: MutableSharedFlow<List<RoomSummary>>,
+    override val loadingState: MutableStateFlow<RoomList.LoadingState>,
+    private val processor: RoomSummaryListProcessor,
+    override val pageSize: Int,
+    private val dynamicController: () -> RoomListDynamicEntriesController?,
+    private val addPagesCount: Int = DEFAULT_ADD_PAGES_COUNT
+) : DynamicRoomList {
+    private val mutex = Mutex()
+
+    override suspend fun rebuildSummaries() {
+        processor.rebuildRoomSummaries()
+    }
+
+    override suspend fun updateFilter(filter: RoomListFilter) {
+        mutex.withLock {
+            dynamicController()?.let { controller ->
+                // Reset pagination when filter changes
+                controller.resetToOnePage()
+                val rustFilter = RoomListFilterMapper.toRustFilter(filter)
+                controller.setFilter(rustFilter)
+                // Then preload some pages
+                controller.addPages(addPagesCount)
+            }
+        }
+    }
+
+    override suspend fun loadMore() {
+        mutex.withLock {
+            dynamicController()?.addPages(addPagesCount)
+        }
+    }
+
+    override suspend fun reset() {
+        mutex.withLock {
+            dynamicController()?.resetToOnePage()
+        }
+    }
+
+    private fun RoomListDynamicEntriesController.addPages(pageCount: Int) = repeat(pageCount) { addOnePage() }
+}

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/roomlist/RustRoomListService.kt

@@ -11,9 +11,7 @@ package io.element.android.libraries.matrix.impl.roomlist
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.roomlist.DynamicRoomList
 import io.element.android.libraries.matrix.api.roomlist.RoomList
-import io.element.android.libraries.matrix.api.roomlist.RoomListFilter
 import io.element.android.libraries.matrix.api.roomlist.RoomListService
-import io.element.android.libraries.matrix.api.roomlist.loadAllIncrementally
 import io.element.android.libraries.matrix.impl.room.RoomSyncSubscriber
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
@@ -28,8 +26,6 @@ import org.matrix.rustcomponents.sdk.RoomListServiceSyncIndicator
 import timber.log.Timber
 import org.matrix.rustcomponents.sdk.RoomListService as InnerRustRoomListService
 
-private const val DEFAULT_PAGE_SIZE = 20
-
 internal class RustRoomListService(
     private val innerRoomListService: InnerRustRoomListService,
     private val sessionDispatcher: CoroutineDispatcher,
@@ -39,13 +35,11 @@ internal class RustRoomListService(
 ) : RoomListService {
     override fun createRoomList(
         pageSize: Int,
-        initialFilter: RoomListFilter,
         source: RoomList.Source,
         coroutineScope: CoroutineScope,
     ): DynamicRoomList {
         return roomListFactory.createRoomList(
             pageSize = pageSize,
-            initialFilter = initialFilter,
             coroutineContext = sessionDispatcher,
             coroutineScope = coroutineScope,
         ) {
@@ -59,18 +53,14 @@ internal class RustRoomListService(
         roomSyncSubscriber.batchSubscribe(roomIds)
     }
 
-    override val allRooms: DynamicRoomList = roomListFactory.createRoomList(
-        pageSize = DEFAULT_PAGE_SIZE,
+    override val allRooms: RoomList = roomListFactory.createRoomList(
+        pageSize = Int.MAX_VALUE,
         coroutineContext = sessionDispatcher,
         coroutineScope = sessionCoroutineScope,
     ) {
         innerRoomListService.allRooms()
     }
 
-    init {
-        allRooms.loadAllIncrementally(sessionCoroutineScope)
-    }
-
     override val syncIndicator: StateFlow<RoomListService.SyncIndicator> =
         innerRoomListService.syncIndicator()
             .map { it.toSyncIndicator() }

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomlist/RoomListFilterTest.kt

@@ -1,156 +0,0 @@
-/*
- * Copyright (c) 2025 Element Creations Ltd.
- * Copyright 2024, 2025 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.libraries.matrix.impl.roomlist
-
-import com.google.common.truth.Truth.assertThat
-import io.element.android.libraries.matrix.api.room.CurrentUserMembership
-import io.element.android.libraries.matrix.api.roomlist.RoomListFilter
-import io.element.android.libraries.matrix.test.room.aRoomSummary
-import kotlinx.coroutines.test.runTest
-import org.junit.Test
-
-class RoomListFilterTest {
-    private val regularRoom = aRoomSummary(
-        isDirect = false,
-    )
-    private val dmRoom = aRoomSummary(
-        isDirect = true,
-        activeMembersCount = 2
-    )
-    private val favoriteRoom = aRoomSummary(
-        isFavorite = true
-    )
-    private val markedAsUnreadRoom = aRoomSummary(
-        isMarkedUnread = true
-    )
-    private val unreadNotificationRoom = aRoomSummary(
-        numUnreadNotifications = 1
-    )
-    private val roomToSearch = aRoomSummary(
-        name = "Room to search"
-    )
-    private val roomWithAccent = aRoomSummary(
-        name = "Frédéric"
-    )
-    private val invitedRoom = aRoomSummary(
-        currentUserMembership = CurrentUserMembership.INVITED
-    )
-
-    private val space = aRoomSummary(
-        isSpace = true
-    )
-    private val invitedSpace = aRoomSummary(
-        isSpace = true,
-        currentUserMembership = CurrentUserMembership.INVITED
-    )
-
-    private val roomSummaries = listOf(
-        regularRoom,
-        dmRoom,
-        favoriteRoom,
-        markedAsUnreadRoom,
-        unreadNotificationRoom,
-        roomToSearch,
-        roomWithAccent,
-        invitedRoom,
-        space,
-        invitedSpace,
-    )
-
-    @Test
-    fun `Room list filter all empty`() = runTest {
-        val filter = RoomListFilter.all()
-        assertThat(roomSummaries.filter(filter)).isEqualTo(roomSummaries - space)
-    }
-
-    @Test
-    fun `Room list filter none`() = runTest {
-        val filter = RoomListFilter.None
-        assertThat(roomSummaries.filter(filter)).isEmpty()
-    }
-
-    @Test
-    fun `Room list filter people`() = runTest {
-        val filter = RoomListFilter.Category.People
-        assertThat(roomSummaries.filter(filter)).containsExactly(dmRoom)
-    }
-
-    @Test
-    fun `Room list filter group`() = runTest {
-        val filter = RoomListFilter.Category.Group
-        assertThat(roomSummaries.filter(filter)).containsExactly(
-            regularRoom,
-            favoriteRoom,
-            markedAsUnreadRoom,
-            unreadNotificationRoom,
-            roomToSearch,
-            roomWithAccent,
-        )
-    }
-
-    @Test
-    fun `Room list filter space`() = runTest {
-        val filter = RoomListFilter.Category.Space
-        assertThat(roomSummaries.filter(filter)).containsExactly(space, invitedSpace)
-    }
-
-    @Test
-    fun `Room list filter favorite`() = runTest {
-        val filter = RoomListFilter.Favorite
-        assertThat(roomSummaries.filter(filter)).containsExactly(favoriteRoom)
-    }
-
-    @Test
-    fun `Room list filter unread`() = runTest {
-        val filter = RoomListFilter.Unread
-        assertThat(roomSummaries.filter(filter)).containsExactly(markedAsUnreadRoom, unreadNotificationRoom)
-    }
-
-    @Test
-    fun `Room list filter invites`() = runTest {
-        val filter = RoomListFilter.Invite
-        assertThat(roomSummaries.filter(filter)).containsExactly(invitedRoom, invitedSpace)
-    }
-
-    @Test
-    fun `Room list filter normalized match room name`() = runTest {
-        val filter = RoomListFilter.NormalizedMatchRoomName("search")
-        assertThat(roomSummaries.filter(filter)).containsExactly(roomToSearch)
-    }
-
-    @Test
-    fun `Room list filter normalized match room name with accent`() = runTest {
-        val filter = RoomListFilter.NormalizedMatchRoomName("Fred")
-        assertThat(roomSummaries.filter(filter)).containsExactly(roomWithAccent)
-    }
-
-    @Test
-    fun `Room list filter normalized match room name with accent when searching with accent`() = runTest {
-        val filter = RoomListFilter.NormalizedMatchRoomName("Fréd")
-        assertThat(roomSummaries.filter(filter)).containsExactly(roomWithAccent)
-    }
-
-    @Test
-    fun `Room list filter all with one match`() = runTest {
-        val filter = RoomListFilter.all(
-            RoomListFilter.Category.Group,
-            RoomListFilter.Favorite
-        )
-        assertThat(roomSummaries.filter(filter)).containsExactly(favoriteRoom)
-    }
-
-    @Test
-    fun `Room list filter all with no match`() = runTest {
-        val filter = RoomListFilter.all(
-            RoomListFilter.Category.People,
-            RoomListFilter.Favorite
-        )
-        assertThat(roomSummaries.filter(filter)).isEmpty()
-    }
-}