Room directory : add tests and cleanup

2024-03-28 17:03:34 +01:00 · 2024-03-28 17:03:34 +01:00 · 35b12f265f
commit 35b12f265f
parent 33c3dc07aa
27 changed files with 573 additions and 77 deletions
--- a/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/DefaultRoomDirectoryEntryPoint.kt
+++ b/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/DefaultRoomDirectoryEntryPoint.kt
@ -28,12 +28,10 @@ import javax.inject.Inject

@ContributesBinding(AppScope::class)
 class DefaultRoomDirectoryEntryPoint @Inject constructor() : RoomDirectoryEntryPoint {
-
    override fun nodeBuilder(parentNode: Node, buildContext: BuildContext): RoomDirectoryEntryPoint.NodeBuilder {
        val plugins = ArrayList<Plugin>()

        return object : RoomDirectoryEntryPoint.NodeBuilder {
-
            override fun callback(callback: RoomDirectoryEntryPoint.Callback): RoomDirectoryEntryPoint.NodeBuilder {
                plugins += callback
                return this
--- a/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryNode.kt
+++ b/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryNode.kt
@ -35,7 +35,6 @@ class RoomDirectoryNode @AssistedInject constructor(
    @Assisted plugins: List<Plugin>,
    private val presenter: RoomDirectoryPresenter,
 ) : Node(buildContext, plugins = plugins) {
-
    private fun onRoomJoined(roomId: RoomId) {
        plugins<RoomDirectoryEntryPoint.Callback>().forEach {
            it.onOpenRoom(roomId)
--- a/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryPresenter.kt
+++ b/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryPresenter.kt
@ -26,13 +26,13 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
+import io.element.android.features.roomdirectory.impl.root.di.JoinRoom
 import io.element.android.features.roomdirectory.impl.root.model.RoomDirectoryListState
 import io.element.android.features.roomdirectory.impl.root.model.toFeatureModel
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.architecture.runUpdatingState
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
-import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryList
 import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryService
@ -46,10 +46,9 @@ import javax.inject.Inject

 class RoomDirectoryPresenter @Inject constructor(
    private val dispatchers: CoroutineDispatchers,
-    private val matrixClient: MatrixClient,
+    private val joinRoom: JoinRoom,
    private val roomDirectoryService: RoomDirectoryService,
 ) : Presenter<RoomDirectoryState> {
-
    @Composable
    override fun present(): RoomDirectoryState {
        var loadingMore by remember {
@ -68,9 +67,9 @@ class RoomDirectoryPresenter @Inject constructor(
        }
        LaunchedEffect(searchQuery) {
            if (searchQuery == null) return@LaunchedEffect
-            //debounce search query
+            // debounce search query
            delay(300)
-            //cancel load more right away
+            // cancel load more right away
            loadingMore = false
            roomDirectoryList.filter(searchQuery, 20)
        }
@ -108,7 +107,7 @@ class RoomDirectoryPresenter @Inject constructor(

    private fun CoroutineScope.joinRoom(state: MutableState<AsyncAction<RoomId>>, roomId: RoomId) = launch {
        state.runUpdatingState {
-            matrixClient.joinRoom(roomId)
+            joinRoom(roomId)
        }
    }

--- a/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryStateProvider.kt
+++ b/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryStateProvider.kt
@ -25,39 +25,14 @@ import io.element.android.libraries.matrix.api.core.RoomId
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf

-open class RoomDirectorySearchStateProvider : PreviewParameterProvider<RoomDirectoryState> {
+open class RoomDirectoryStateProvider : PreviewParameterProvider<RoomDirectoryState> {
    override val values: Sequence<RoomDirectoryState>
        get() = sequenceOf(
            aRoomDirectoryState(),
            aRoomDirectoryState(
                query = "Element",
-                roomDescriptions = persistentListOf(
-                    RoomDescription(
-                        roomId = RoomId("@exa:matrix.org"),
-                        name = "Element X Android",
-                        description = "Element X is a secure, private and decentralized messenger.",
-                        avatarData = AvatarData(
-                            id = "@exa:matrix.org",
-                            name = "Element X Android",
-                            url = null,
-                            size = AvatarSize.RoomDirectoryItem
-                        ),
-                        canBeJoined = true,
-                    ),
-                    RoomDescription(
-                        roomId = RoomId("@exi:matrix.org"),
-                        name = "Element X iOS",
-                        description = "Element X is a secure, private and decentralized messenger.",
-                        avatarData = AvatarData(
-                            id = "@exi:matrix.org",
-                            name = "Element X iOS",
-                            url = null,
-                            size = AvatarSize.RoomDirectoryItem
-                        ),
-                        canBeJoined = false,
-                    )
-                )
-            ),
+                roomDescriptions = aRoomDescriptionList(),
+            )
        )
 }

@ -66,10 +41,40 @@ fun aRoomDirectoryState(
    displayLoadMoreIndicator: Boolean = false,
    roomDescriptions: ImmutableList<RoomDescription> = persistentListOf(),
    joinRoomAction: AsyncAction<RoomId> = AsyncAction.Uninitialized,
+    eventSink: (RoomDirectoryEvents) -> Unit = {},
 ) = RoomDirectoryState(
    query = query,
    roomDescriptions = roomDescriptions,
    displayLoadMoreIndicator = displayLoadMoreIndicator,
    joinRoomAction = joinRoomAction,
-    eventSink = {},
+    eventSink = eventSink,
 )
+
+fun aRoomDescriptionList(): ImmutableList<RoomDescription> {
+    return persistentListOf(
+        RoomDescription(
+            roomId = RoomId("!exa:matrix.org"),
+            name = "Element X Android",
+            description = "Element X is a secure, private and decentralized messenger.",
+            avatarData = AvatarData(
+                id = "!exa:matrix.org",
+                name = "Element X Android",
+                url = null,
+                size = AvatarSize.RoomDirectoryItem
+            ),
+            canBeJoined = true,
+        ),
+        RoomDescription(
+            roomId = RoomId("!exi:matrix.org"),
+            name = "Element X iOS",
+            description = "Element X is a secure, private and decentralized messenger.",
+            avatarData = AvatarData(
+                id = "!exi:matrix.org",
+                name = "Element X iOS",
+                url = null,
+                size = AvatarSize.RoomDirectoryItem
+            ),
+            canBeJoined = false,
+        )
+    )
+}
--- a/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryView.kt
+++ b/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryView.kt
@ -40,6 +40,7 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.PreviewParameter
@ -61,6 +62,7 @@ import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.theme.components.TextField
 import io.element.android.libraries.designsystem.theme.components.TopAppBar
 import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.testtags.TestTags
 import io.element.android.libraries.ui.strings.CommonStrings
 import kotlinx.collections.immutable.ImmutableList

@ -71,7 +73,6 @@ fun RoomDirectoryView(
    onBackPressed: () -> Unit,
    modifier: Modifier = Modifier,
 ) {
-
    fun joinRoom(roomId: RoomId) {
        state.eventSink(RoomDirectoryEvents.JoinRoom(roomId))
    }
@ -86,8 +87,8 @@ fun RoomDirectoryView(
                state = state,
                onResultClicked = ::joinRoom,
                modifier = Modifier
-                    .padding(padding)
-                    .consumeWindowInsets(padding)
+                        .padding(padding)
+                        .consumeWindowInsets(padding)
            )
        }
    )
@ -96,7 +97,8 @@ fun RoomDirectoryView(
        onSuccess = onRoomJoined,
        onErrorDismiss = {
            state.eventSink(RoomDirectoryEvents.JoinRoomDismissError)
-        })
+        }
+    )
 }

@OptIn(ExperimentalMaterial3Api::class)
@ -171,7 +173,7 @@ private fun RoomDirectoryRoomList(
        if (displayLoadMoreIndicator) {
            item {
                LoadMoreIndicator(modifier = Modifier.fillMaxWidth())
-                LaunchedEffect(Unit) {
+                LaunchedEffect(onReachedLoadMore) {
                    onReachedLoadMore()
                }
            }
@ -182,10 +184,10 @@ private fun RoomDirectoryRoomList(
@Composable
 private fun LoadMoreIndicator(modifier: Modifier = Modifier) {
    Box(
-        modifier
-            .fillMaxWidth()
-            .wrapContentHeight()
-            .padding(24.dp),
+            modifier
+                    .fillMaxWidth()
+                    .wrapContentHeight()
+                    .padding(24.dp),
        contentAlignment = Alignment.Center,
    ) {
        CircularProgressIndicator(
@ -213,7 +215,7 @@ private fun SearchTextField(
 ) {
    val focusManager = LocalFocusManager.current
    TextField(
-        modifier = modifier,
+        modifier = modifier.testTag(TestTags.searchTextField.value),
        textStyle = ElementTheme.typography.fontBodyLgRegular,
        singleLine = true,
        value = query,
@ -255,14 +257,14 @@ private fun RoomDirectoryRoomRow(
 ) {
    Row(
        modifier = modifier
-            .fillMaxWidth()
-            .clickable { onClick(roomDescription.roomId) }
-            .padding(
-                top = 12.dp,
-                bottom = 12.dp,
-                start = 16.dp,
-            )
-            .height(IntrinsicSize.Min),
+                .fillMaxWidth()
+                .clickable { onClick(roomDescription.roomId) }
+                .padding(
+                        top = 12.dp,
+                        bottom = 12.dp,
+                        start = 16.dp,
+                )
+                .height(IntrinsicSize.Min),
    ) {
        Avatar(
            avatarData = roomDescription.avatarData,
@ -270,8 +272,8 @@ private fun RoomDirectoryRoomRow(
        )
        Column(
            modifier = Modifier
-                .weight(1f)
-                .padding(start = 16.dp)
+                    .weight(1f)
+                    .padding(start = 16.dp)
        ) {
            Text(
                text = roomDescription.name,
@ -293,8 +295,8 @@ private fun RoomDirectoryRoomRow(
                text = stringResource(id = CommonStrings.action_join),
                color = ElementTheme.colors.textSuccessPrimary,
                modifier = Modifier
-                    .align(Alignment.CenterVertically)
-                    .padding(start = 4.dp, end = 12.dp)
+                        .align(Alignment.CenterVertically)
+                        .padding(start = 4.dp, end = 12.dp)
            )
        } else {
            Spacer(modifier = Modifier.width(24.dp))
@ -304,7 +306,7 @@ private fun RoomDirectoryRoomRow(

@PreviewsDayNight
@Composable
-fun RoomDirectorySearchViewLightPreview(@PreviewParameter(RoomDirectorySearchStateProvider::class) state: RoomDirectoryState) = ElementPreview {
+internal fun RoomDirectoryViewPreview(@PreviewParameter(RoomDirectoryStateProvider::class) state: RoomDirectoryState) = ElementPreview {
    RoomDirectoryView(
        state = state,
        onRoomJoined = {},
--- a/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/di/JoinRoom.kt
+++ b/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/di/JoinRoom.kt
@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.roomdirectory.impl.root.di
+
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomId
+import javax.inject.Inject
+
+interface JoinRoom {
+    suspend operator fun invoke(roomId: RoomId): Result<RoomId>
+}
+
+@ContributesBinding(SessionScope::class)
+class DefaultJoinRoom @Inject constructor(private val client: MatrixClient) : JoinRoom {
+    override suspend fun invoke(roomId: RoomId) = client.joinRoom(roomId)
+}
--- a/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/model/RoomDirectoryListState.kt
+++ b/features/roomdirectory/impl/src/main/kotlin/io/element/android/features/roomdirectory/impl/root/model/RoomDirectoryListState.kt
@ -24,7 +24,6 @@ internal data class RoomDirectoryListState(
    val hasMoreToLoad: Boolean,
    val items: ImmutableList<RoomDescription>,
 ) {
-
    companion object {
        val Default = RoomDirectoryListState(
            hasMoreToLoad = true,
--- a/features/roomdirectory/impl/src/test/kotlin/io/element/android/features/roomdirectory/impl/root/FakeJoinRoom.kt
+++ b/features/roomdirectory/impl/src/test/kotlin/io/element/android/features/roomdirectory/impl/root/FakeJoinRoom.kt
@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.roomdirectory.impl.root
+
+import io.element.android.features.roomdirectory.impl.root.di.JoinRoom
+import io.element.android.libraries.matrix.api.core.RoomId
+
+class FakeJoinRoom(
+    var lambda: (RoomId) -> Result<RoomId> = { Result.success(it) }
+) : JoinRoom {
+    override suspend fun invoke(roomId: RoomId) = lambda(roomId)
+}
--- a/features/roomdirectory/impl/src/test/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryPresenterTest.kt
+++ b/features/roomdirectory/impl/src/test/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryPresenterTest.kt
@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.roomdirectory.impl.root
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.roomdirectory.impl.root.di.JoinRoom
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryList
+import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryService
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.roomdirectory.FakeRoomDirectoryList
+import io.element.android.libraries.matrix.test.roomdirectory.FakeRoomDirectoryService
+import io.element.android.libraries.matrix.test.roomdirectory.aRoomDescription
+import io.element.android.tests.testutils.lambda.any
+import io.element.android.tests.testutils.lambda.assert
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.lambda.value
+import io.element.android.tests.testutils.test
+import io.element.android.tests.testutils.testCoroutineDispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class) class RoomDirectoryPresenterTest {
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createRoomDirectoryPresenter()
+        presenter.test {
+            val initialState = awaitItem()
+            assertThat(initialState.query).isEmpty()
+            assertThat(initialState.displayEmptyState).isFalse()
+            assertThat(initialState.joinRoomAction).isEqualTo(AsyncAction.Uninitialized)
+            assertThat(initialState.roomDescriptions).isEmpty()
+            assertThat(initialState.displayLoadMoreIndicator).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - room directory list emits empty state`() = runTest {
+        val directoryListStateFlow = MutableSharedFlow<RoomDirectoryList.State>(replay = 1)
+        val roomDirectoryList = FakeRoomDirectoryList(directoryListStateFlow)
+        val roomDirectoryService = FakeRoomDirectoryService { roomDirectoryList }
+        val presenter = createRoomDirectoryPresenter(roomDirectoryService = roomDirectoryService)
+        presenter.test {
+            skipItems(1)
+            directoryListStateFlow.emit(
+                RoomDirectoryList.State(false, emptyList())
+            )
+            awaitItem().also { state ->
+                assertThat(state.displayEmptyState).isTrue()
+            }
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `present - room directory list emits non-empty state`() = runTest {
+        val directoryListStateFlow = MutableSharedFlow<RoomDirectoryList.State>(replay = 1)
+        val roomDirectoryList = FakeRoomDirectoryList(directoryListStateFlow)
+        val roomDirectoryService = FakeRoomDirectoryService { roomDirectoryList }
+        val presenter = createRoomDirectoryPresenter(roomDirectoryService = roomDirectoryService)
+        presenter.test {
+            skipItems(1)
+            directoryListStateFlow.emit(
+                RoomDirectoryList.State(
+                    hasMoreToLoad = true,
+                    items = listOf(aRoomDescription())
+                )
+            )
+            awaitItem().also { state ->
+                assertThat(state.displayEmptyState).isFalse()
+                assertThat(state.roomDescriptions).hasSize(1)
+            }
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `present - emit search event`() = runTest {
+        val filterLambda = lambdaRecorder { _: String?, _: Int ->
+            Result.success(Unit)
+        }
+        val roomDirectoryList = FakeRoomDirectoryList(filterLambda = filterLambda)
+        val roomDirectoryService = FakeRoomDirectoryService { roomDirectoryList }
+        val presenter = createRoomDirectoryPresenter(roomDirectoryService = roomDirectoryService)
+        presenter.test {
+            awaitItem().also { state ->
+                state.eventSink(RoomDirectoryEvents.Search("test"))
+            }
+            awaitItem().also { state ->
+                assertThat(state.query).isEqualTo("test")
+            }
+            advanceUntilIdle()
+            cancelAndIgnoreRemainingEvents()
+        }
+        assert(filterLambda)
+            .isCalledOnce()
+            .with(value("test"), any())
+    }
+
+    @Test
+    fun `present - emit load more event`() = runTest {
+        val loadMoreLambda = lambdaRecorder { ->
+            Result.success(Unit)
+        }
+        val roomDirectoryList = FakeRoomDirectoryList(loadMoreLambda = loadMoreLambda)
+        val roomDirectoryService = FakeRoomDirectoryService { roomDirectoryList }
+        val presenter = createRoomDirectoryPresenter(roomDirectoryService = roomDirectoryService)
+        presenter.test {
+            awaitItem().also { state ->
+                state.eventSink(RoomDirectoryEvents.LoadMore)
+            }
+            advanceUntilIdle()
+            cancelAndIgnoreRemainingEvents()
+        }
+        assert(loadMoreLambda)
+            .isCalledOnce()
+            .withNoParameter()
+    }
+
+    @Test
+    fun `present - emit join room event`() = runTest {
+        val joinRoomSuccess = lambdaRecorder { roomId: RoomId ->
+            Result.success(roomId)
+        }
+        val joinRoomFailure = lambdaRecorder { roomId: RoomId ->
+            Result.failure<RoomId>(RuntimeException("Failed to join room $roomId"))
+        }
+        val fakeJoinRoom = FakeJoinRoom(joinRoomSuccess)
+        val presenter = createRoomDirectoryPresenter(joinRoom = fakeJoinRoom)
+        presenter.test {
+            awaitItem().also { state ->
+                state.eventSink(RoomDirectoryEvents.JoinRoom(A_ROOM_ID))
+            }
+            awaitItem().also { state ->
+                assertThat(state.joinRoomAction).isEqualTo(AsyncAction.Success(A_ROOM_ID))
+                fakeJoinRoom.lambda = joinRoomFailure
+                state.eventSink(RoomDirectoryEvents.JoinRoom(A_ROOM_ID))
+            }
+            awaitItem().also { state ->
+                assertThat(state.joinRoomAction).isInstanceOf(AsyncAction.Failure::class.java)
+            }
+        }
+        assert(joinRoomSuccess)
+            .isCalledOnce()
+            .with(value(A_ROOM_ID))
+        assert(joinRoomFailure)
+            .isCalledOnce()
+            .with(value(A_ROOM_ID))
+    }
+
+    private fun TestScope.createRoomDirectoryPresenter(
+        roomDirectoryService: RoomDirectoryService = FakeRoomDirectoryService(
+            createRoomDirectoryListFactory = { FakeRoomDirectoryList() }
+        ),
+        joinRoom: JoinRoom = FakeJoinRoom { Result.success(it) },
+    ): RoomDirectoryPresenter {
+        return RoomDirectoryPresenter(
+            dispatchers = testCoroutineDispatchers(),
+            joinRoom = joinRoom,
+            roomDirectoryService = roomDirectoryService,
+        )
+    }
+}
--- a/features/roomdirectory/impl/src/test/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryViewTest.kt
+++ b/features/roomdirectory/impl/src/test/kotlin/io/element/android/features/roomdirectory/impl/root/RoomDirectoryViewTest.kt
@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.roomdirectory.impl.root
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.junit4.AndroidComposeTestRule
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.testtags.TestTags
+import io.element.android.tests.testutils.EnsureNeverCalled
+import io.element.android.tests.testutils.EnsureNeverCalledWithParam
+import io.element.android.tests.testutils.EventsRecorder
+import io.element.android.tests.testutils.ensureCalledOnceWithParam
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TestRule
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class RoomDirectoryViewTest {
+    @get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun `typing text in search field emits the expected Event`() {
+        val eventsRecorder = EventsRecorder<RoomDirectoryEvents>()
+        rule.setRoomDirectoryView(
+            state = aRoomDirectoryState(
+                eventSink = eventsRecorder,
+            )
+        )
+        rule.onNodeWithTag(TestTags.searchTextField.value).performTextInput(
+            text = "Test"
+        )
+        eventsRecorder.assertSingle(RoomDirectoryEvents.Search("Test"))
+    }
+
+    @Test
+    fun `clicking on room item emits the expected Event`() {
+        val eventsRecorder = EventsRecorder<RoomDirectoryEvents>()
+        val state = aRoomDirectoryState(
+            roomDescriptions = aRoomDescriptionList(),
+            eventSink = eventsRecorder,
+        )
+        rule.setRoomDirectoryView(state = state)
+        val clickedRoom = state.roomDescriptions.first()
+        rule.onNodeWithText(clickedRoom.name).performClick()
+        eventsRecorder.assertSingle(RoomDirectoryEvents.JoinRoom(clickedRoom.roomId))
+    }
+
+    @Test
+    fun `composing load more indicator emits expected Event`() {
+        val eventsRecorder = EventsRecorder<RoomDirectoryEvents>()
+        val state = aRoomDirectoryState(
+            displayLoadMoreIndicator = true,
+            eventSink = eventsRecorder,
+        )
+        rule.setRoomDirectoryView(state = state)
+        eventsRecorder.assertSingle(RoomDirectoryEvents.LoadMore)
+    }
+
+    @Test
+    fun `when joining room with success then onRoomJoined lambda is called once`() {
+        val eventsRecorder = EventsRecorder<RoomDirectoryEvents>(expectEvents = false)
+        val roomDescriptions = aRoomDescriptionList()
+        val joinedRoomId = roomDescriptions.first().roomId
+        val state = aRoomDirectoryState(
+            joinRoomAction = AsyncAction.Success(joinedRoomId),
+            roomDescriptions = roomDescriptions,
+            eventSink = eventsRecorder,
+        )
+        ensureCalledOnceWithParam(joinedRoomId) { callback ->
+            rule.setRoomDirectoryView(
+                state = state,
+                onRoomJoined = callback,
+            )
+        }
+    }
+}
+
+private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setRoomDirectoryView(
+    state: RoomDirectoryState,
+    onBackPressed: () -> Unit = EnsureNeverCalled(),
+    onRoomJoined: (RoomId) -> Unit = EnsureNeverCalledWithParam(),
+) {
+    setContent {
+        RoomDirectoryView(
+            state = state,
+            onRoomJoined = onRoomJoined,
+            onBackPressed = onBackPressed,
+        )
+    }
+}