First Commit

features/forward/api/build.gradle.kts

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 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.
+ */
+
+plugins {
+    id("io.element.android-library")
+}
+
+android {
+    namespace = "io.element.android.features.forward.api"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+}

features/forward/api/src/main/kotlin/io/element/android/features/forward/api/ForwardEntryPoint.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 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.features.forward.api
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import io.element.android.libraries.architecture.FeatureEntryPoint
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.timeline.TimelineProvider
+
+interface ForwardEntryPoint : FeatureEntryPoint {
+    interface Callback : Plugin {
+        fun onDone(roomIds: List<RoomId>)
+    }
+
+    data class Params(
+        val eventId: EventId,
+        val timelineProvider: TimelineProvider,
+    ) : NodeInputs
+
+    fun createNode(
+        parentNode: Node,
+        buildContext: BuildContext,
+        params: Params,
+        callback: Callback,
+    ): Node
+}

features/forward/impl/build.gradle.kts

@@ -0,0 +1,41 @@
+import extension.setupDependencyInjection
+import extension.testCommonDependencies
+
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 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.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+    id("kotlin-parcelize")
+}
+
+android {
+    namespace = "io.element.android.features.forward.impl"
+
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+        }
+    }
+}
+
+setupDependencyInjection()
+
+dependencies {
+    api(projects.features.forward.api)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.roomselect.api)
+    implementation(projects.libraries.uiStrings)
+
+    testCommonDependencies(libs, true)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.libraries.roomselect.test)
+    testImplementation(projects.libraries.testtags)
+}

features/forward/impl/src/main/kotlin/io/element/android/features/forward/impl/DefaultForwardEntryPoint.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 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.features.forward.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import dev.zacsweers.metro.ContributesBinding
+import io.element.android.features.forward.api.ForwardEntryPoint
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.SessionScope
+
+@ContributesBinding(SessionScope::class)
+class DefaultForwardEntryPoint : ForwardEntryPoint {
+    override fun createNode(
+        parentNode: Node,
+        buildContext: BuildContext,
+        params: ForwardEntryPoint.Params,
+        callback: ForwardEntryPoint.Callback,
+    ): Node {
+        return parentNode.createNode<ForwardMessagesNode>(
+            buildContext = buildContext,
+            plugins = listOf(
+                ForwardMessagesNode.Inputs(
+                    eventId = params.eventId,
+                    timelineProvider = params.timelineProvider,
+                ),
+                callback,
+            )
+        )
+    }
+}

features/forward/impl/src/main/kotlin/io/element/android/features/forward/impl/ForwardMessagesEvents.kt

@@ -0,0 +1,13 @@
+/*
+ * 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.features.forward.impl
+
+sealed interface ForwardMessagesEvents {
+    data object ClearError : ForwardMessagesEvents
+}

features/forward/impl/src/main/kotlin/io/element/android/features/forward/impl/ForwardMessagesNode.kt

@@ -0,0 +1,97 @@
+/*
+ * 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.features.forward.impl
+
+import android.os.Parcelable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.composable.Children
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.navigation.model.permanent.PermanentNavModel
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.node.ParentNode
+import com.bumble.appyx.core.plugin.Plugin
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.AssistedInject
+import io.element.android.annotations.ContributesNode
+import io.element.android.features.forward.api.ForwardEntryPoint
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.architecture.callback
+import io.element.android.libraries.architecture.inputs
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.timeline.TimelineProvider
+import io.element.android.libraries.roomselect.api.RoomSelectEntryPoint
+import io.element.android.libraries.roomselect.api.RoomSelectMode
+import kotlinx.parcelize.Parcelize
+
+@ContributesNode(SessionScope::class)
+@AssistedInject
+class ForwardMessagesNode(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    presenterFactory: ForwardMessagesPresenter.Factory,
+    private val roomSelectEntryPoint: RoomSelectEntryPoint,
+) : ParentNode<ForwardMessagesNode.NavTarget>(
+    navModel = PermanentNavModel(
+        navTargets = setOf(NavTarget),
+        savedStateMap = buildContext.savedStateMap,
+    ),
+    buildContext = buildContext,
+    plugins = plugins,
+) {
+    @Parcelize
+    object NavTarget : Parcelable
+
+    data class Inputs(
+        val eventId: EventId,
+        val timelineProvider: TimelineProvider,
+    ) : NodeInputs
+
+    private val inputs = inputs<Inputs>()
+    private val callback: ForwardEntryPoint.Callback = callback()
+    private val presenter = presenterFactory.create(inputs.eventId.value, inputs.timelineProvider)
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        val callback = object : RoomSelectEntryPoint.Callback {
+            override fun onRoomSelected(roomIds: List<RoomId>) {
+                presenter.onRoomSelected(roomIds)
+            }
+
+            override fun onCancel() {
+                callback.onDone(emptyList())
+            }
+        }
+
+        return roomSelectEntryPoint.createNode(
+            parentNode = this,
+            buildContext = buildContext,
+            params = RoomSelectEntryPoint.Params(mode = RoomSelectMode.Forward),
+            callback = callback,
+        )
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Box(modifier = modifier) {
+            // Will render to room select screen
+            Children(
+                navModel = navModel,
+            )
+
+            val state = presenter.present()
+            ForwardMessagesView(
+                state = state,
+                onForwardSuccess = callback::onDone,
+            )
+        }
+    }
+}

features/forward/impl/src/main/kotlin/io/element/android/features/forward/impl/ForwardMessagesPresenter.kt

@@ -0,0 +1,76 @@
+/*
+ * 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.features.forward.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.AssistedFactory
+import dev.zacsweers.metro.AssistedInject
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.architecture.runCatchingUpdatingState
+import io.element.android.libraries.di.annotations.SessionCoroutineScope
+import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.timeline.TimelineProvider
+import io.element.android.libraries.matrix.api.timeline.getActiveTimeline
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import timber.log.Timber
+
+@AssistedInject
+class ForwardMessagesPresenter(
+    @Assisted eventId: String,
+    @Assisted private val timelineProvider: TimelineProvider,
+    @SessionCoroutineScope
+    private val sessionCoroutineScope: CoroutineScope,
+) : Presenter<ForwardMessagesState> {
+    private val eventId: EventId = EventId(eventId)
+
+    @AssistedFactory
+    fun interface Factory {
+        fun create(eventId: String, timelineProvider: TimelineProvider): ForwardMessagesPresenter
+    }
+
+    private val forwardingActionState: MutableState<AsyncAction<List<RoomId>>> = mutableStateOf(AsyncAction.Uninitialized)
+
+    fun onRoomSelected(roomIds: List<RoomId>) {
+        sessionCoroutineScope.forwardEvent(eventId, roomIds)
+    }
+
+    @Composable
+    override fun present(): ForwardMessagesState {
+        fun handleEvent(event: ForwardMessagesEvents) {
+            when (event) {
+                ForwardMessagesEvents.ClearError -> forwardingActionState.value = AsyncAction.Uninitialized
+            }
+        }
+
+        return ForwardMessagesState(
+            forwardAction = forwardingActionState.value,
+            eventSink = ::handleEvent,
+        )
+    }
+
+    private fun CoroutineScope.forwardEvent(
+        eventId: EventId,
+        roomIds: List<RoomId>,
+    ) = launch {
+        suspend {
+            timelineProvider.getActiveTimeline().forwardEvent(eventId, roomIds)
+                .onFailure {
+                    Timber.e(it, "Error while forwarding event")
+                }
+                .getOrThrow()
+            roomIds
+        }.runCatchingUpdatingState(forwardingActionState)
+    }
+}

features/forward/impl/src/main/kotlin/io/element/android/features/forward/impl/ForwardMessagesState.kt

@@ -0,0 +1,17 @@
+/*
+ * 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.features.forward.impl
+
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+
+data class ForwardMessagesState(
+    val forwardAction: AsyncAction<List<RoomId>>,
+    val eventSink: (ForwardMessagesEvents) -> Unit
+)

features/forward/impl/src/main/kotlin/io/element/android/features/forward/impl/ForwardMessagesStateProvider.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.features.forward.impl
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+
+open class ForwardMessagesStateProvider : PreviewParameterProvider<ForwardMessagesState> {
+    override val values: Sequence<ForwardMessagesState>
+        get() = sequenceOf(
+            aForwardMessagesState(),
+            aForwardMessagesState(
+                forwardAction = AsyncAction.Loading,
+            ),
+            aForwardMessagesState(
+                forwardAction = AsyncAction.Success(
+                    listOf(RoomId("!room2:domain")),
+                )
+            ),
+            aForwardMessagesState(
+                forwardAction = AsyncAction.Failure(RuntimeException("error")),
+            ),
+        )
+}
+
+fun aForwardMessagesState(
+    forwardAction: AsyncAction<List<RoomId>> = AsyncAction.Uninitialized,
+    eventSink: (ForwardMessagesEvents) -> Unit = {}
+) = ForwardMessagesState(
+    forwardAction = forwardAction,
+    eventSink = eventSink
+)

features/forward/impl/src/main/kotlin/io/element/android/features/forward/impl/ForwardMessagesView.kt

@@ -0,0 +1,46 @@
+/*
+ * 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.features.forward.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import io.element.android.libraries.designsystem.components.async.AsyncActionView
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Composable
+fun ForwardMessagesView(
+    state: ForwardMessagesState,
+    onForwardSuccess: (List<RoomId>) -> Unit,
+) {
+    AsyncActionView(
+        async = state.forwardAction,
+        onSuccess = {
+            onForwardSuccess(it)
+        },
+        errorMessage = {
+            stringResource(id = CommonStrings.error_unknown)
+        },
+        onErrorDismiss = {
+            state.eventSink(ForwardMessagesEvents.ClearError)
+        },
+    )
+}
+
+@PreviewsDayNight
+@Composable
+internal fun ForwardMessagesViewPreview(@PreviewParameter(ForwardMessagesStateProvider::class) state: ForwardMessagesState) = ElementPreview {
+    ForwardMessagesView(
+        state = state,
+        onForwardSuccess = {}
+    )
+}

features/forward/impl/src/test/kotlin/io/element/android/features/forward/impl/DefaultForwardEntryPointTest.kt

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 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.features.forward.impl
+
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.testing.junit4.util.MainDispatcherRule
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.forward.api.ForwardEntryPoint
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.test.AN_EVENT_ID
+import io.element.android.libraries.matrix.test.timeline.FakeTimelineProvider
+import io.element.android.libraries.roomselect.test.FakeRoomSelectEntryPoint
+import io.element.android.tests.testutils.lambda.lambdaError
+import io.element.android.tests.testutils.node.TestParentNode
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class DefaultForwardEntryPointTest {
+    @get:Rule
+    val instantTaskExecutorRule = InstantTaskExecutorRule()
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `test node builder`() = runTest {
+        val entryPoint = DefaultForwardEntryPoint()
+        val parentNode = TestParentNode.create { buildContext, plugins ->
+            ForwardMessagesNode(
+                buildContext = buildContext,
+                plugins = plugins,
+                presenterFactory = { _, _ -> createForwardMessagesPresenter() },
+                roomSelectEntryPoint = FakeRoomSelectEntryPoint(),
+            )
+        }
+        val callback = object : ForwardEntryPoint.Callback {
+            override fun onDone(roomIds: List<RoomId>) = lambdaError()
+        }
+        val params = ForwardEntryPoint.Params(
+            eventId = AN_EVENT_ID,
+            timelineProvider = FakeTimelineProvider(),
+        )
+        val result = entryPoint.createNode(
+            parentNode = parentNode,
+            buildContext = BuildContext.root(null),
+            params = params,
+            callback = callback,
+        )
+        assertThat(result).isInstanceOf(ForwardMessagesNode::class.java)
+        assertThat(result.plugins).contains(
+            ForwardMessagesNode.Inputs(
+                eventId = params.eventId,
+                timelineProvider = params.timelineProvider,
+            )
+        )
+        assertThat(result.plugins).contains(callback)
+    }
+}

features/forward/impl/src/test/kotlin/io/element/android/features/forward/impl/ForwardMessagesPresenterTest.kt

@@ -0,0 +1,103 @@
+/*
+ * 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.features.forward.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.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.test.AN_EVENT_ID
+import io.element.android.libraries.matrix.test.room.FakeJoinedRoom
+import io.element.android.libraries.matrix.test.room.aRoomSummary
+import io.element.android.libraries.matrix.test.timeline.FakeTimeline
+import io.element.android.libraries.matrix.test.timeline.LiveTimelineProvider
+import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class ForwardMessagesPresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createForwardMessagesPresenter()
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.forwardAction.isUninitialized()).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - forward successful`() = runTest {
+        val forwardEventLambda = lambdaRecorder { _: EventId, _: List<RoomId> ->
+            Result.success(Unit)
+        }
+        val timeline = FakeTimeline().apply {
+            this.forwardEventLambda = forwardEventLambda
+        }
+        val room = FakeJoinedRoom(liveTimeline = timeline)
+        val presenter = createForwardMessagesPresenter(fakeRoom = room)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val summary = aRoomSummary()
+            presenter.onRoomSelected(listOf(summary.roomId))
+            val forwardingState = awaitItem()
+            assertThat(forwardingState.forwardAction.isLoading()).isTrue()
+            val successfulForwardState = awaitItem()
+            assertThat(successfulForwardState.forwardAction).isEqualTo(AsyncAction.Success(listOf(summary.roomId)))
+            forwardEventLambda.assertions().isCalledOnce()
+        }
+    }
+
+    @Test
+    fun `present - select a room and forward failed, then clear`() = runTest {
+        val forwardEventLambda = lambdaRecorder { _: EventId, _: List<RoomId> ->
+            Result.failure<Unit>(IllegalStateException("error"))
+        }
+        val timeline = FakeTimeline().apply {
+            this.forwardEventLambda = forwardEventLambda
+        }
+        val room = FakeJoinedRoom(liveTimeline = timeline)
+        val presenter = createForwardMessagesPresenter(fakeRoom = room)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val summary = aRoomSummary()
+            presenter.onRoomSelected(listOf(summary.roomId))
+            skipItems(1)
+            val failedForwardState = awaitItem()
+            assertThat(failedForwardState.forwardAction.isFailure()).isTrue()
+            // Then clear error
+            failedForwardState.eventSink(ForwardMessagesEvents.ClearError)
+            assertThat(awaitItem().forwardAction.isUninitialized()).isTrue()
+            forwardEventLambda.assertions().isCalledOnce()
+        }
+    }
+}
+
+fun TestScope.createForwardMessagesPresenter(
+    eventId: EventId = AN_EVENT_ID,
+    fakeRoom: FakeJoinedRoom = FakeJoinedRoom(),
+) = ForwardMessagesPresenter(
+    eventId = eventId.value,
+    timelineProvider = LiveTimelineProvider(fakeRoom),
+    sessionCoroutineScope = this,
+)

features/forward/impl/src/test/kotlin/io/element/android/features/forward/impl/ForwardMessagesViewTest.kt

@@ -0,0 +1,72 @@
+/*
+ * 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.features.forward.impl
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.junit4.AndroidComposeTestRule
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+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.matrix.test.AN_EXCEPTION
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.testtags.TestTags
+import io.element.android.tests.testutils.EnsureNeverCalledWithParam
+import io.element.android.tests.testutils.EventsRecorder
+import io.element.android.tests.testutils.ensureCalledOnceWithParam
+import io.element.android.tests.testutils.pressTag
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TestRule
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class ForwardMessagesViewTest {
+    @get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun `cancel error emits the expected event`() {
+        val eventsRecorder = EventsRecorder<ForwardMessagesEvents>()
+        rule.setForwardMessagesView(
+            aForwardMessagesState(
+                forwardAction = AsyncAction.Failure(AN_EXCEPTION),
+                eventSink = eventsRecorder
+            ),
+        )
+        rule.pressTag(TestTags.dialogPositive.value)
+        eventsRecorder.assertSingle(ForwardMessagesEvents.ClearError)
+    }
+
+    @Test
+    fun `success invokes onForwardSuccess`() {
+        val data = listOf(A_ROOM_ID)
+        val eventsRecorder = EventsRecorder<ForwardMessagesEvents>(expectEvents = false)
+        ensureCalledOnceWithParam<List<RoomId>?>(data) { callback ->
+            rule.setForwardMessagesView(
+                aForwardMessagesState(
+                    forwardAction = AsyncAction.Success(data),
+                    eventSink = eventsRecorder
+                ),
+                onForwardSuccess = callback,
+            )
+        }
+    }
+}
+
+private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setForwardMessagesView(
+    state: ForwardMessagesState,
+    onForwardSuccess: (List<RoomId>) -> Unit = EnsureNeverCalledWithParam(),
+) {
+    setContent {
+        ForwardMessagesView(
+            state = state,
+            onForwardSuccess = onForwardSuccess,
+        )
+    }
+}

features/forward/test/build.gradle.kts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 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.
+ */
+plugins {
+    id("io.element.android-library")
+}
+
+android {
+    namespace = "io.element.android.features.forward.test"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.features.forward.api)
+    implementation(projects.tests.testutils)
+}

features/forward/test/src/main/kotlin/io/element/android/features/forward/test/FakeForwardEntryPoint.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 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.features.forward.test
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import io.element.android.features.forward.api.ForwardEntryPoint
+import io.element.android.tests.testutils.lambda.lambdaError
+
+class FakeForwardEntryPoint : ForwardEntryPoint {
+    override fun createNode(
+        parentNode: Node,
+        buildContext: BuildContext,
+        params: ForwardEntryPoint.Params,
+        callback: ForwardEntryPoint.Callback,
+    ): Node = lambdaError()
+}