Move RoomAliasResolver classes to their own module.

features/roomaliasresolver/impl/src/main/kotlin/io/element/android/features/roomaliasresolver/impl/DefaultRoomAliasResolverEntryPoint.kt

@@ -0,0 +1,49 @@
+/*
+ * 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.roomaliasresolver.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.roomaliasesolver.api.RoomAliasResolverEntryPoint
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.AppScope
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultRoomAliasResolverEntryPoint @Inject constructor() : RoomAliasResolverEntryPoint {
+    override fun nodeBuilder(parentNode: Node, buildContext: BuildContext): RoomAliasResolverEntryPoint.NodeBuilder {
+        val plugins = ArrayList<Plugin>()
+
+        return object : RoomAliasResolverEntryPoint.NodeBuilder {
+            override fun callback(callback: RoomAliasResolverEntryPoint.Callback): RoomAliasResolverEntryPoint.NodeBuilder {
+                plugins += callback
+                return this
+            }
+
+            override fun params(params: RoomAliasResolverEntryPoint.Params): RoomAliasResolverEntryPoint.NodeBuilder {
+                plugins += params
+                return this
+            }
+
+            override fun build(): Node {
+                return parentNode.createNode<RoomAliasResolverNode>(buildContext, plugins)
+            }
+        }
+    }
+}

features/roomaliasresolver/impl/src/main/kotlin/io/element/android/features/roomaliasresolver/impl/RoomAliasResolverEvents.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.roomaliasresolver.impl
+
+sealed interface RoomAliasResolverEvents {
+    data object Retry : RoomAliasResolverEvents
+}

features/roomaliasresolver/impl/src/main/kotlin/io/element/android/features/roomaliasresolver/impl/RoomAliasResolverNode.kt

@@ -0,0 +1,59 @@
+/*
+ * 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.roomaliasresolver.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.roomaliasesolver.api.RoomAliasResolverEntryPoint
+import io.element.android.libraries.architecture.inputs
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.core.RoomId
+
+@ContributesNode(SessionScope::class)
+class RoomAliasResolverNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    presenterFactory: RoomAliasResolverPresenter.Factory,
+) : Node(buildContext, plugins = plugins) {
+    private val inputs = inputs<RoomAliasResolverEntryPoint.Params>()
+
+    private val presenter = presenterFactory.create(
+        inputs.roomAlias
+    )
+
+    private fun onAliasResolved(roomId: RoomId) {
+        plugins<RoomAliasResolverEntryPoint.Callback>().forEach { it.onAliasResolved(roomId) }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        RoomAliasResolverView(
+            state = state,
+            onAliasResolved = ::onAliasResolved,
+            onBackPressed = ::navigateUp,
+            modifier = modifier
+        )
+    }
+}

features/roomaliasresolver/impl/src/main/kotlin/io/element/android/features/roomaliasresolver/impl/RoomAliasResolverPresenter.kt

@@ -0,0 +1,72 @@
+/*
+ * 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.roomaliasresolver.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.architecture.runCatchingUpdatingState
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomAlias
+import io.element.android.libraries.matrix.api.core.RoomId
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+
+class RoomAliasResolverPresenter @AssistedInject constructor(
+    @Assisted private val roomAlias: RoomAlias,
+    private val matrixClient: MatrixClient,
+) : Presenter<RoomAliasResolverState> {
+    interface Factory {
+        fun create(
+            roomAlias: RoomAlias,
+        ): RoomAliasResolverPresenter
+    }
+
+    @Composable
+    override fun present(): RoomAliasResolverState {
+        val coroutineScope = rememberCoroutineScope()
+        val resolveState: MutableState<AsyncData<RoomId>> = remember { mutableStateOf(AsyncData.Uninitialized) }
+        LaunchedEffect(Unit) {
+            resolveAlias(resolveState)
+        }
+
+        fun handleEvents(event: RoomAliasResolverEvents) {
+            when (event) {
+                RoomAliasResolverEvents.Retry -> coroutineScope.resolveAlias(resolveState)
+            }
+        }
+
+        return RoomAliasResolverState(
+            roomAlias = roomAlias,
+            resolveState = resolveState.value,
+            eventSink = ::handleEvents
+        )
+    }
+
+    private fun CoroutineScope.resolveAlias(resolveState: MutableState<AsyncData<RoomId>>) = launch {
+        suspend {
+            matrixClient.resolveRoomAlias(roomAlias).getOrThrow()
+        }.runCatchingUpdatingState(resolveState)
+    }
+}

features/roomaliasresolver/impl/src/main/kotlin/io/element/android/features/roomaliasresolver/impl/RoomAliasResolverState.kt

@@ -0,0 +1,29 @@
+/*
+ * 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.roomaliasresolver.impl
+
+import androidx.compose.runtime.Immutable
+import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.core.RoomAlias
+import io.element.android.libraries.matrix.api.core.RoomId
+
+@Immutable
+data class RoomAliasResolverState(
+    val roomAlias: RoomAlias,
+    val resolveState: AsyncData<RoomId>,
+    val eventSink: (RoomAliasResolverEvents) -> Unit
+)

features/roomaliasresolver/impl/src/main/kotlin/io/element/android/features/roomaliasresolver/impl/RoomAliasResolverStateProvider.kt

@@ -0,0 +1,47 @@
+/*
+ * 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.roomaliasresolver.impl
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.core.RoomAlias
+import io.element.android.libraries.matrix.api.core.RoomId
+
+open class RoomAliasResolverStateProvider : PreviewParameterProvider<RoomAliasResolverState> {
+    override val values: Sequence<RoomAliasResolverState>
+        get() = sequenceOf(
+            aRoomAliasResolverState(),
+            aRoomAliasResolverState(
+                resolveState = AsyncData.Loading(),
+            ),
+            aRoomAliasResolverState(
+                resolveState = AsyncData.Failure(Exception("Error")),
+            ),
+        )
+}
+
+fun aRoomAliasResolverState(
+    roomAlias: RoomAlias = A_ROOM_ALIAS,
+    resolveState: AsyncData<RoomId> = AsyncData.Uninitialized,
+    eventSink: (RoomAliasResolverEvents) -> Unit = {}
+) = RoomAliasResolverState(
+    roomAlias = roomAlias,
+    resolveState = resolveState,
+    eventSink = eventSink,
+)
+
+private val A_ROOM_ALIAS = RoomAlias("#exa:matrix.org")

features/roomaliasresolver/impl/src/main/kotlin/io/element/android/features/roomaliasresolver/impl/RoomAliasResolverView.kt

@@ -0,0 +1,205 @@
+/*
+ * 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.roomaliasresolver.impl
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.PreviewLightDark
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.compound.theme.ElementTheme
+import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.designsystem.atomic.atoms.PlaceholderAtom
+import io.element.android.libraries.designsystem.atomic.pages.HeaderFooterPage
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.theme.components.Button
+import io.element.android.libraries.designsystem.theme.components.ButtonSize
+import io.element.android.libraries.designsystem.theme.components.CircularProgressIndicator
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.designsystem.theme.components.TopAppBar
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Composable
+fun RoomAliasResolverView(
+    state: RoomAliasResolverState,
+    onBackPressed: () -> Unit,
+    onAliasResolved: (RoomId) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val latestOnAliasResolved by rememberUpdatedState(onAliasResolved)
+    LaunchedEffect(state.resolveState) {
+        if (state.resolveState is AsyncData.Success) {
+            latestOnAliasResolved(state.resolveState.data)
+        }
+    }
+
+    HeaderFooterPage(
+        modifier = modifier,
+        paddingValues = PaddingValues(16.dp),
+        topBar = {
+            RoomAliasResolverTopBar(onBackClicked = onBackPressed)
+        },
+        content = {
+            RoomAliasResolverContent(state = state)
+        },
+        footer = {
+            RoomAliasResolverFooter(
+                state = state,
+            )
+        }
+    )
+}
+
+@Composable
+private fun RoomAliasResolverFooter(
+    state: RoomAliasResolverState,
+    modifier: Modifier = Modifier,
+) {
+    when (state.resolveState) {
+        is AsyncData.Failure -> {
+            Button(
+                text = stringResource(CommonStrings.action_retry),
+                onClick = {
+                    state.eventSink(RoomAliasResolverEvents.Retry)
+                },
+                modifier = modifier.fillMaxWidth(),
+                size = ButtonSize.Medium,
+            )
+        }
+        is AsyncData.Loading -> {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.Center,
+            ) {
+                CircularProgressIndicator()
+            }
+        }
+        AsyncData.Uninitialized,
+        is AsyncData.Success -> Unit
+    }
+}
+
+@Composable
+private fun RoomAliasResolverContent(
+    state: RoomAliasResolverState,
+    modifier: Modifier = Modifier,
+) {
+    ContentScaffold(
+        modifier = modifier,
+        avatar = {
+            PlaceholderAtom(width = AvatarSize.RoomHeader.dp, height = AvatarSize.RoomHeader.dp)
+        },
+        title = {
+        },
+        subtitle = {
+            Title(state.roomAlias.value)
+        },
+        description = {
+            if (state.resolveState.isFailure()) {
+                Text(
+                    text = "Failed to resolve room alias",
+                    textAlign = TextAlign.Center,
+                    color = MaterialTheme.colorScheme.error,
+                )
+            }
+        },
+        memberCount = {
+        }
+    )
+}
+
+@Composable
+private fun ContentScaffold(
+    avatar: @Composable () -> Unit,
+    title: @Composable () -> Unit,
+    subtitle: @Composable () -> Unit,
+    modifier: Modifier = Modifier,
+    description: @Composable (() -> Unit)? = null,
+    memberCount: @Composable (() -> Unit)? = null,
+) {
+    Column(
+        modifier = modifier.fillMaxWidth(),
+        horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+        avatar()
+        Spacer(modifier = Modifier.height(16.dp))
+        title()
+        Spacer(modifier = Modifier.height(8.dp))
+        subtitle()
+        Spacer(modifier = Modifier.height(8.dp))
+        if (memberCount != null) {
+            memberCount()
+        }
+        Spacer(modifier = Modifier.height(8.dp))
+        if (description != null) {
+            description()
+        }
+        Spacer(modifier = Modifier.height(24.dp))
+    }
+}
+
+@Composable
+private fun Title(title: String, modifier: Modifier = Modifier) {
+    Text(
+        modifier = modifier,
+        text = title,
+        style = ElementTheme.typography.fontHeadingMdBold,
+        textAlign = TextAlign.Center,
+        color = ElementTheme.colors.textPrimary,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun RoomAliasResolverTopBar(
+    onBackClicked: () -> Unit,
+) {
+    TopAppBar(
+        navigationIcon = {
+            BackButton(onClick = onBackClicked)
+        },
+        title = {},
+    )
+}
+
+@PreviewLightDark
+@Composable
+internal fun RoomAliasResolverViewPreview(@PreviewParameter(RoomAliasResolverStateProvider::class) state: RoomAliasResolverState) = ElementPreview {
+    RoomAliasResolverView(
+        state = state,
+        onAliasResolved = { },
+        onBackPressed = { }
+    )
+}

features/roomaliasresolver/impl/src/main/kotlin/io/element/android/features/roomaliasresolver/impl/di/RoomAliasResolverModule.kt

@@ -0,0 +1,43 @@
+/*
+ * 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.roomaliasresolver.impl.di
+
+import com.squareup.anvil.annotations.ContributesTo
+import dagger.Module
+import dagger.Provides
+import io.element.android.features.roomaliasresolver.impl.RoomAliasResolverPresenter
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomAlias
+
+@Module
+@ContributesTo(SessionScope::class)
+object RoomAliasResolverModule {
+    @Provides
+    fun providesJoinRoomPresenterFactory(
+        client: MatrixClient,
+    ): RoomAliasResolverPresenter.Factory {
+        return object : RoomAliasResolverPresenter.Factory {
+            override fun create(roomAlias: RoomAlias): RoomAliasResolverPresenter {
+                return RoomAliasResolverPresenter(
+                    roomAlias = roomAlias,
+                    matrixClient = client,
+                )
+            }
+        }
+    }
+}

features/roomaliasresolver/impl/src/test/kotlin/io/element/android/features/roomaliasresolver/impl/RoomAliasResolverPresenterTest.kt

@@ -0,0 +1,94 @@
+/*
+ * 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.roomaliasresolver.impl
+
+import app.cash.molecule.RecompositionMode
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomAlias
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
+import io.element.android.libraries.matrix.test.A_ROOM_ALIAS
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.tests.testutils.WarmUpRule
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class RoomAliasResolverPresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createPresenter()
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            assertThat(awaitItem().resolveState.isUninitialized()).isTrue()
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `present - resolve alias to roomId`() = runTest {
+        val client = FakeMatrixClient(
+            resolveRoomAliasResult = { Result.success(A_ROOM_ID) }
+        )
+        val presenter = createPresenter(matrixClient = client)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            assertThat(awaitItem().resolveState.isUninitialized()).isTrue()
+            assertThat(awaitItem().resolveState.isLoading()).isTrue()
+            val resultState = awaitItem()
+            assertThat(resultState.roomAlias).isEqualTo(A_ROOM_ALIAS)
+            assertThat(resultState.resolveState.dataOrNull()).isEqualTo(A_ROOM_ID)
+        }
+    }
+
+    @Test
+    fun `present - resolve alias error and retry`() = runTest {
+        val client = FakeMatrixClient(
+            resolveRoomAliasResult = { Result.failure(AN_EXCEPTION) }
+        )
+        val presenter = createPresenter(matrixClient = client)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            assertThat(awaitItem().resolveState.isUninitialized()).isTrue()
+            assertThat(awaitItem().resolveState.isLoading()).isTrue()
+            val resultState = awaitItem()
+            assertThat(resultState.resolveState.errorOrNull()).isEqualTo(AN_EXCEPTION)
+            resultState.eventSink(RoomAliasResolverEvents.Retry)
+            val retryLoadingState = awaitItem()
+            assertThat(retryLoadingState.resolveState.isLoading()).isTrue()
+            val retryState = awaitItem()
+            assertThat(retryState.resolveState.errorOrNull()).isEqualTo(AN_EXCEPTION)
+        }
+    }
+
+    private fun createPresenter(
+        roomAlias: RoomAlias = A_ROOM_ALIAS,
+        matrixClient: MatrixClient = FakeMatrixClient(),
+    ) = RoomAliasResolverPresenter(
+        roomAlias = roomAlias,
+        matrixClient = matrixClient,
+    )
+}