Merge pull request #3554 from element-hq/feature/bma/testEmptyTimeline

Add unit tests on TimelineItemsSubscriber
2024-10-02 14:04:48 +02:00 · 2024-10-02 14:04:48 +02:00 · 4d554de838
commit 4d554de838
parent e789d677f4 015d59af13
14 changed files with 349 additions and 130 deletions
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/factories/EventTimelineItemDebugInfo.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/factories/EventTimelineItemDebugInfo.kt
@ -0,0 +1,20 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.fixtures.factories
+
+import org.matrix.rustcomponents.sdk.EventTimelineItemDebugInfo
+
+fun anEventTimelineItemDebugInfo(
+    model: String = "model",
+    originalJson: String? = null,
+    latestEditJson: String? = null,
+) = EventTimelineItemDebugInfo(
+    model = model,
+    originalJson = originalJson,
+    latestEditJson = latestEditJson
+)
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustEventTimelineItem.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustEventTimelineItem.kt
@ -0,0 +1,44 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.fixtures.fakes
+
+import io.element.android.libraries.matrix.impl.fixtures.factories.anEventTimelineItemDebugInfo
+import io.element.android.libraries.matrix.test.AN_EVENT_ID
+import io.element.android.libraries.matrix.test.A_USER_ID
+import org.matrix.rustcomponents.sdk.EventSendState
+import org.matrix.rustcomponents.sdk.EventTimelineItem
+import org.matrix.rustcomponents.sdk.EventTimelineItemDebugInfo
+import org.matrix.rustcomponents.sdk.NoPointer
+import org.matrix.rustcomponents.sdk.ProfileDetails
+import org.matrix.rustcomponents.sdk.Reaction
+import org.matrix.rustcomponents.sdk.Receipt
+import org.matrix.rustcomponents.sdk.ShieldState
+import org.matrix.rustcomponents.sdk.TimelineItemContent
+import uniffi.matrix_sdk_ui.EventItemOrigin
+
+class FakeRustEventTimelineItem(
+    private val origin: EventItemOrigin? = null,
+) : EventTimelineItem(NoPointer) {
+    override fun origin(): EventItemOrigin? = origin
+    override fun eventId(): String = AN_EVENT_ID.value
+    override fun transactionId(): String? = null
+    override fun isEditable(): Boolean = false
+    override fun canBeRepliedTo(): Boolean = false
+    override fun isLocal(): Boolean = false
+    override fun isOwn(): Boolean = false
+    override fun isRemote(): Boolean = false
+    override fun localSendState(): EventSendState? = null
+    override fun reactions(): List<Reaction> = emptyList()
+    override fun readReceipts(): Map<String, Receipt> = emptyMap()
+    override fun sender(): String = A_USER_ID.value
+    override fun senderProfile(): ProfileDetails = ProfileDetails.Unavailable
+    override fun timestamp(): ULong = 0u
+    override fun content(): TimelineItemContent = FakeRustTimelineItemContent()
+    override fun debugInfo(): EventTimelineItemDebugInfo = anEventTimelineItemDebugInfo()
+    override fun getShield(strict: Boolean): ShieldState? = null
+}
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustTimeline.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustTimeline.kt
@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.fixtures.fakes
+
+import org.matrix.rustcomponents.sdk.NoPointer
+import org.matrix.rustcomponents.sdk.TaskHandle
+import org.matrix.rustcomponents.sdk.Timeline
+import org.matrix.rustcomponents.sdk.TimelineDiff
+import org.matrix.rustcomponents.sdk.TimelineListener
+
+class FakeRustTimeline : Timeline(NoPointer) {
+    private var listener: TimelineListener? = null
+    override suspend fun addListener(listener: TimelineListener): TaskHandle {
+        this.listener = listener
+        return FakeRustTaskHandle()
+    }
+
+    fun emitDiff(diff: List<TimelineDiff>) {
+        listener!!.onUpdate(diff)
+    }
+}
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustTimelineItem.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustTimelineItem.kt
@ -12,8 +12,10 @@ import org.matrix.rustcomponents.sdk.NoPointer
 import org.matrix.rustcomponents.sdk.TimelineItem
 import org.matrix.rustcomponents.sdk.VirtualTimelineItem

-class FakeRustTimelineItem : TimelineItem(NoPointer) {
-    override fun asEvent(): EventTimelineItem? = null
+class FakeRustTimelineItem(
+    private val asEventResult: EventTimelineItem? = null,
+) : TimelineItem(NoPointer) {
+    override fun asEvent(): EventTimelineItem? = asEventResult
    override fun asVirtual(): VirtualTimelineItem? = null
    override fun fmtDebug(): String = "fmtDebug"
    override fun uniqueId(): String = "uniqueId"
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustTimelineItemContent.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustTimelineItemContent.kt
@ -0,0 +1,18 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.fixtures.fakes
+
+import org.matrix.rustcomponents.sdk.Message
+import org.matrix.rustcomponents.sdk.NoPointer
+import org.matrix.rustcomponents.sdk.TimelineItemContent
+import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+
+class FakeRustTimelineItemContent : TimelineItemContent(NoPointer) {
+    override fun asMessage(): Message? = null
+    override fun kind(): TimelineItemContentKind = TimelineItemContentKind.Message
+}
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomdirectory/RustRoomDirectoryListTest.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomdirectory/RustRoomDirectoryListTest.kt
@ -13,12 +13,12 @@ import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryList
 import io.element.android.libraries.matrix.impl.fixtures.factories.aRustRoomDescription
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRoomDirectorySearch
 import io.element.android.libraries.matrix.test.A_ROOM_ID_2
-import io.element.android.tests.testutils.runCancellableScopeTestWithTestScope
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import org.matrix.rustcomponents.sdk.RoomDirectorySearch
 import org.matrix.rustcomponents.sdk.RoomDirectorySearchEntryUpdate
@ -26,15 +26,15 @@ import org.matrix.rustcomponents.sdk.RoomDirectorySearchEntryUpdate
@OptIn(ExperimentalCoroutinesApi::class)
 class RustRoomDirectoryListTest {
    @Test
-    fun `check that the state emits the expected values`() = runCancellableScopeTestWithTestScope { testScope, cancellableScope ->
+    fun `check that the state emits the expected values`() = runTest {
        val fakeRoomDirectorySearch = FakeRoomDirectorySearch()
        val mapper = RoomDescriptionMapper()
-        val sut = testScope.createRustRoomDirectoryList(
+        val sut = createRustRoomDirectoryList(
            roomDirectorySearch = fakeRoomDirectorySearch,
-            scope = cancellableScope,
+            scope = backgroundScope,
        )
        // Let the mxCallback be ready
-        testScope.runCurrent()
+        runCurrent()
        sut.state.test {
            sut.filter("", 20)
            fakeRoomDirectorySearch.emitResult(
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomdirectory/RustRoomDirectoryServiceTest.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomdirectory/RustRoomDirectoryServiceTest.kt
@ -8,18 +8,18 @@
 package io.element.android.libraries.matrix.impl.roomdirectory

 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustClient
-import io.element.android.tests.testutils.runCancellableScopeTestWithTestScope
 import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.runTest
 import org.junit.Test

 class RustRoomDirectoryServiceTest {
    @Test
-    fun test() = runCancellableScopeTestWithTestScope { testScope, cancellableScope ->
+    fun test() = runTest {
        val client = FakeRustClient()
        val sut = RustRoomDirectoryService(
            client = client,
-            sessionDispatcher = StandardTestDispatcher(testScope.testScheduler),
+            sessionDispatcher = StandardTestDispatcher(testScheduler),
        )
-        sut.createRoomDirectoryList(cancellableScope)
+        sut.createRoomDirectoryList(backgroundScope)
    }
 }
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomlist/RoomListFactoryTest.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomlist/RoomListFactoryTest.kt
@ -9,16 +9,16 @@ package io.element.android.libraries.matrix.impl.roomlist

 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustRoomList
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustRoomListService
-import io.element.android.tests.testutils.runCancellableScopeTest
+import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import kotlin.coroutines.EmptyCoroutineContext

 class RoomListFactoryTest {
    @Test
-    fun `createRoomList should work`() = runCancellableScopeTest {
+    fun `createRoomList should work`() = runTest {
        val sut = RoomListFactory(
            innerRoomListService = FakeRustRoomListService(),
-            sessionCoroutineScope = it,
+            sessionCoroutineScope = backgroundScope,
        )
        sut.createRoomList(
            pageSize = 10,
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomlist/RustRoomListServiceTest.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomlist/RustRoomListServiceTest.kt
@ -11,13 +11,13 @@ import com.google.common.truth.Truth.assertThat
 import io.element.android.libraries.matrix.api.roomlist.RoomListService
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustRoomListService
 import io.element.android.libraries.matrix.impl.room.RoomSyncSubscriber
-import io.element.android.tests.testutils.runCancellableScopeTestWithTestScope
 import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import org.matrix.rustcomponents.sdk.RoomListServiceSyncIndicator
 import org.matrix.rustcomponents.sdk.RoomListService as RustRoomListService
@ -25,14 +25,14 @@ import org.matrix.rustcomponents.sdk.RoomListService as RustRoomListService
@OptIn(ExperimentalCoroutinesApi::class)
 class RustRoomListServiceTest {
    @Test
-    fun `syncIndicator should emit the expected values`() = runCancellableScopeTestWithTestScope { testScope, cancellableScope ->
+    fun `syncIndicator should emit the expected values`() = runTest {
        val roomListService = FakeRustRoomListService()
-        val sut = testScope.createRustRoomListService(
-            sessionCoroutineScope = cancellableScope,
+        val sut = createRustRoomListService(
+            sessionCoroutineScope = backgroundScope,
            roomListService = roomListService,
        )
        // Give time for mxCallback to setup
-        testScope.runCurrent()
+        runCurrent()
        sut.syncIndicator.test {
            assertThat(awaitItem()).isEqualTo(RoomListService.SyncIndicator.Hide)
            roomListService.emitRoomListServiceSyncIndicator(RoomListServiceSyncIndicator.SHOW)
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/timeline/MatrixTimelineDiffProcessorTest.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/timeline/MatrixTimelineDiffProcessorTest.kt
@ -16,6 +16,7 @@ import io.element.android.libraries.matrix.impl.timeline.item.virtual.VirtualTim
 import io.element.android.libraries.matrix.test.A_UNIQUE_ID
 import io.element.android.libraries.matrix.test.A_UNIQUE_ID_2
 import io.element.android.libraries.matrix.test.timeline.anEventTimelineItem
+import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runTest
@ -31,7 +32,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `Append adds new entries at the end of the list`() = runTest {
        timelineItems.value = listOf(anEvent)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.APPEND)))
        assertThat(timelineItems.value.count()).isEqualTo(2)
        assertThat(timelineItems.value).containsExactly(
@ -43,7 +44,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `PushBack adds a new entry at the end of the list`() = runTest {
        timelineItems.value = listOf(anEvent)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.PUSH_BACK)))
        assertThat(timelineItems.value.count()).isEqualTo(2)
        assertThat(timelineItems.value).containsExactly(
@ -55,7 +56,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `PushFront inserts a new entry at the start of the list`() = runTest {
        timelineItems.value = listOf(anEvent)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.PUSH_FRONT)))
        assertThat(timelineItems.value.count()).isEqualTo(2)
        assertThat(timelineItems.value).containsExactly(
@ -67,7 +68,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `Set replaces an entry at some index`() = runTest {
        timelineItems.value = listOf(anEvent, anEvent2)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.SET)))
        assertThat(timelineItems.value.count()).isEqualTo(2)
        assertThat(timelineItems.value).containsExactly(
@ -79,7 +80,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `Insert inserts a new entry at the provided index`() = runTest {
        timelineItems.value = listOf(anEvent, anEvent2)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.INSERT)))
        assertThat(timelineItems.value.count()).isEqualTo(3)
        assertThat(timelineItems.value).containsExactly(
@ -92,7 +93,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `Remove removes an entry at some index`() = runTest {
        timelineItems.value = listOf(anEvent, MatrixTimelineItem.Other, anEvent2)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.REMOVE)))
        assertThat(timelineItems.value.count()).isEqualTo(2)
        assertThat(timelineItems.value).containsExactly(
@ -104,7 +105,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `PopBack removes an entry at the end of the list`() = runTest {
        timelineItems.value = listOf(anEvent, anEvent2)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.POP_BACK)))
        assertThat(timelineItems.value.count()).isEqualTo(1)
        assertThat(timelineItems.value).containsExactly(
@ -115,7 +116,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `PopFront removes an entry at the start of the list`() = runTest {
        timelineItems.value = listOf(anEvent, anEvent2)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.POP_FRONT)))
        assertThat(timelineItems.value.count()).isEqualTo(1)
        assertThat(timelineItems.value).containsExactly(
@ -126,7 +127,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `Clear removes all the entries`() = runTest {
        timelineItems.value = listOf(anEvent, anEvent2)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.CLEAR)))
        assertThat(timelineItems.value).isEmpty()
    }
@ -134,7 +135,7 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `Truncate removes all entries after the provided length`() = runTest {
        timelineItems.value = listOf(anEvent, MatrixTimelineItem.Other, anEvent2)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.TRUNCATE)))
        assertThat(timelineItems.value.count()).isEqualTo(1)
        assertThat(timelineItems.value).containsExactly(
@ -145,27 +146,29 @@ class MatrixTimelineDiffProcessorTest {
    @Test
    fun `Reset removes all entries and add the provided ones`() = runTest {
        timelineItems.value = listOf(anEvent, MatrixTimelineItem.Other, anEvent2)
-        val processor = createProcessor()
+        val processor = createMatrixTimelineDiffProcessor(timelineItems)
        processor.postDiffs(listOf(FakeRustTimelineDiff(change = TimelineChange.RESET)))
        assertThat(timelineItems.value.count()).isEqualTo(1)
        assertThat(timelineItems.value).containsExactly(
            MatrixTimelineItem.Other,
        )
    }
-
-    private fun TestScope.createProcessor(): MatrixTimelineDiffProcessor {
-        val timelineEventContentMapper = TimelineEventContentMapper()
-        val timelineItemMapper = MatrixTimelineItemMapper(
-            fetchDetailsForEvent = { _ -> Result.success(Unit) },
-            coroutineScope = this,
-            virtualTimelineItemMapper = VirtualTimelineItemMapper(),
-            eventTimelineItemMapper = EventTimelineItemMapper(
-                contentMapper = timelineEventContentMapper
-            )
-        )
-        return MatrixTimelineDiffProcessor(
-            timelineItems,
-            timelineItemFactory = timelineItemMapper,
-        )
-    }
+}
+
+internal fun TestScope.createMatrixTimelineDiffProcessor(
+    timelineItems: MutableSharedFlow<List<MatrixTimelineItem>>,
+): MatrixTimelineDiffProcessor {
+    val timelineEventContentMapper = TimelineEventContentMapper()
+    val timelineItemMapper = MatrixTimelineItemMapper(
+        fetchDetailsForEvent = { _ -> Result.success(Unit) },
+        coroutineScope = this,
+        virtualTimelineItemMapper = VirtualTimelineItemMapper(),
+        eventTimelineItemMapper = EventTimelineItemMapper(
+            contentMapper = timelineEventContentMapper
+        )
+    )
+    return MatrixTimelineDiffProcessor(
+        timelineItems = timelineItems,
+        timelineItemFactory = timelineItemMapper,
+    )
 }
--- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/timeline/TimelineItemsSubscriberTest.kt
+++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/timeline/TimelineItemsSubscriberTest.kt
@ -0,0 +1,139 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.timeline
+
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
+import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustEventTimelineItem
+import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustTimeline
+import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustTimelineDiff
+import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustTimelineItem
+import io.element.android.tests.testutils.lambda.lambdaError
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import org.matrix.rustcomponents.sdk.Timeline
+import org.matrix.rustcomponents.sdk.TimelineChange
+import uniffi.matrix_sdk_ui.EventItemOrigin
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class TimelineItemsSubscriberTest {
+    @Test
+    fun `when timeline emits an empty list of items, the flow must emits an empty list`() = runTest {
+        val timelineItems: MutableSharedFlow<List<MatrixTimelineItem>> =
+            MutableSharedFlow(replay = 1, extraBufferCapacity = Int.MAX_VALUE)
+        val timeline = FakeRustTimeline()
+        val timelineItemsSubscriber = createTimelineItemsSubscriber(
+            coroutineScope = backgroundScope,
+            timeline = timeline,
+            timelineItems = timelineItems,
+        )
+        timelineItems.test {
+            timelineItemsSubscriber.subscribeIfNeeded()
+            // Wait for the listener to be set.
+            runCurrent()
+            timeline.emitDiff(listOf(FakeRustTimelineDiff(item = null, change = TimelineChange.RESET)))
+            val final = awaitItem()
+            assertThat(final).isEmpty()
+            timelineItemsSubscriber.unsubscribeIfNeeded()
+        }
+    }
+
+    @Test
+    fun `when timeline emits a non empty list of items, the flow must emits a non empty list`() = runTest {
+        val timelineItems: MutableSharedFlow<List<MatrixTimelineItem>> =
+            MutableSharedFlow(replay = 1, extraBufferCapacity = Int.MAX_VALUE)
+        val timeline = FakeRustTimeline()
+        val timelineItemsSubscriber = createTimelineItemsSubscriber(
+            coroutineScope = backgroundScope,
+            timeline = timeline,
+            timelineItems = timelineItems,
+        )
+        timelineItems.test {
+            timelineItemsSubscriber.subscribeIfNeeded()
+            // Wait for the listener to be set.
+            runCurrent()
+            timeline.emitDiff(listOf(FakeRustTimelineDiff(item = FakeRustTimelineItem(), change = TimelineChange.RESET)))
+            val final = awaitItem()
+            assertThat(final).isNotEmpty()
+            timelineItemsSubscriber.unsubscribeIfNeeded()
+        }
+    }
+
+    @Test
+    fun `when timeline emits an item with SYNC origin, the callback onNewSyncedEvent is invoked`() = runTest {
+        val timelineItems: MutableSharedFlow<List<MatrixTimelineItem>> =
+            MutableSharedFlow(replay = 1, extraBufferCapacity = Int.MAX_VALUE)
+        val timeline = FakeRustTimeline()
+        val onNewSyncedEventRecorder = lambdaRecorder<Unit> { }
+        val timelineItemsSubscriber = createTimelineItemsSubscriber(
+            coroutineScope = backgroundScope,
+            timeline = timeline,
+            timelineItems = timelineItems,
+            onNewSyncedEvent = onNewSyncedEventRecorder,
+        )
+        timelineItems.test {
+            timelineItemsSubscriber.subscribeIfNeeded()
+            // Wait for the listener to be set.
+            runCurrent()
+            timeline.emitDiff(
+                listOf(
+                    FakeRustTimelineDiff(
+                        item = FakeRustTimelineItem(
+                            asEventResult = FakeRustEventTimelineItem(origin = EventItemOrigin.SYNC)
+                        ),
+                        change = TimelineChange.RESET,
+                    )
+                )
+            )
+            val final = awaitItem()
+            assertThat(final).isNotEmpty()
+            timelineItemsSubscriber.unsubscribeIfNeeded()
+        }
+        onNewSyncedEventRecorder.assertions().isCalledOnce()
+    }
+
+    @Test
+    fun `multiple subscriptions does not have side effect`() = runTest {
+        val timelineItemsSubscriber = createTimelineItemsSubscriber(
+            coroutineScope = backgroundScope,
+        )
+        timelineItemsSubscriber.subscribeIfNeeded()
+        timelineItemsSubscriber.subscribeIfNeeded()
+        timelineItemsSubscriber.unsubscribeIfNeeded()
+        timelineItemsSubscriber.unsubscribeIfNeeded()
+    }
+}
+
+private fun TestScope.createTimelineItemsSubscriber(
+    coroutineScope: CoroutineScope,
+    timeline: Timeline = FakeRustTimeline(),
+    timelineItems: MutableSharedFlow<List<MatrixTimelineItem>> = MutableSharedFlow(replay = 1, extraBufferCapacity = Int.MAX_VALUE),
+    initLatch: CompletableDeferred<Unit> = CompletableDeferred(),
+    isTimelineInitialized: MutableStateFlow<Boolean> = MutableStateFlow(false),
+    onNewSyncedEvent: () -> Unit = { lambdaError() },
+): TimelineItemsSubscriber {
+    return TimelineItemsSubscriber(
+        timelineCoroutineScope = coroutineScope,
+        dispatcher = StandardTestDispatcher(testScheduler),
+        timeline = timeline,
+        timelineDiffProcessor = createMatrixTimelineDiffProcessor(timelineItems),
+        initLatch = initLatch,
+        isTimelineInitialized = isTimelineInitialized,
+        onNewSyncedEvent = onNewSyncedEvent,
+    )
+}