Multi accounts - Fix test on HomePresenter - WIP

Author: bmarty

features/home/impl/build.gradle.kts

@@ -76,6 +76,8 @@ dependencies {
     testImplementation(projects.libraries.permissions.noop)
     testImplementation(projects.libraries.permissions.test)
     testImplementation(projects.libraries.preferences.test)
+    testImplementation(projects.libraries.sessionStorage.implMemory)
+    testImplementation(projects.libraries.sessionStorage.test)
     testImplementation(projects.libraries.push.test)
     testImplementation(projects.services.analytics.test)
     testImplementation(projects.services.toolbox.test)

features/home/impl/src/test/kotlin/io/element/android/features/home/impl/HomePresenterTest.kt

@@ -29,10 +29,14 @@ import io.element.android.libraries.matrix.test.A_USER_ID
 import io.element.android.libraries.matrix.test.A_USER_NAME
 import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.matrix.test.sync.FakeSyncService
+import io.element.android.libraries.sessionstorage.api.SessionStore
+import io.element.android.libraries.sessionstorage.impl.memory.InMemorySessionStore
+import io.element.android.libraries.sessionstorage.test.aSessionData
 import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.lambda.value
 import io.element.android.tests.testutils.test
 import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runTest
 import org.junit.Rule
 import org.junit.Test
@@ -48,29 +52,46 @@ class HomePresenterTest {
             userAvatarUrl = null,
         )
         matrixClient.givenGetProfileResult(matrixClient.sessionId, Result.success(MatrixUser(matrixClient.sessionId, A_USER_NAME, AN_AVATAR_URL)))
+        val updateUserProfileResult = lambdaRecorder<String, String?, String?, Unit> { _, _, _ -> }
         val presenter = createHomePresenter(
             client = matrixClient,
             rageshakeFeatureAvailability = { flowOf(false) },
+            sessionStore = InMemorySessionStore(
+                initialSessionData = aSessionData(
+                    sessionId = matrixClient.sessionId.value,
+                ),
+                updateUserProfileResult = updateUserProfileResult,
+            ),
         )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.matrixUser).isEqualTo(MatrixUser(A_USER_ID))
+            assertThat(initialState.matrixUserAndNeighbors.first()).isEqualTo(
+                MatrixUser(A_USER_ID, null, null)
+            )
             assertThat(initialState.canReportBug).isFalse()
             val withUserState = awaitItem()
-            assertThat(withUserState.matrixUser.userId).isEqualTo(A_USER_ID)
-            assertThat(withUserState.matrixUser.displayName).isEqualTo(A_USER_NAME)
-            assertThat(withUserState.matrixUser.avatarUrl).isEqualTo(AN_AVATAR_URL)
+            assertThat(withUserState.matrixUserAndNeighbors.first()).isEqualTo(
+                MatrixUser(A_USER_ID, A_USER_NAME, AN_AVATAR_URL)
+            )
             assertThat(withUserState.showAvatarIndicator).isFalse()
             assertThat(withUserState.isSpaceFeatureEnabled).isFalse()
+            updateUserProfileResult.assertions().isCalledOnce().with(
+                value(matrixClient.sessionId),
+                value(A_USER_NAME),
+                value(AN_AVATAR_URL),
+            )
         }
     }
 
     @Test
     fun `present - can report bug`() = runTest {
         val presenter = createHomePresenter(
             rageshakeFeatureAvailability = { flowOf(true) },
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
         )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
@@ -88,6 +109,9 @@ class HomePresenterTest {
             featureFlagService = FakeFeatureFlagService(
                 initialState = mapOf(FeatureFlags.Space.key to true),
             ),
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
         )
         presenter.test {
             skipItems(1)
@@ -101,6 +125,9 @@ class HomePresenterTest {
         val indicatorService = FakeIndicatorService()
         val presenter = createHomePresenter(
             indicatorService = indicatorService,
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
         )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
@@ -120,19 +147,28 @@ class HomePresenterTest {
             userAvatarUrl = null,
         )
         matrixClient.givenGetProfileResult(matrixClient.sessionId, Result.failure(AN_EXCEPTION))
-        val presenter = createHomePresenter(client = matrixClient)
+        val presenter = createHomePresenter(
+            client = matrixClient,
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
+        )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.matrixUser).isEqualTo(MatrixUser(matrixClient.sessionId))
+            assertThat(initialState.matrixUserAndNeighbors.first()).isEqualTo(MatrixUser(matrixClient.sessionId))
             // No new state is coming
         }
     }
 
     @Test
     fun `present - NavigationBar change`() = runTest {
-        val presenter = createHomePresenter()
+        val presenter = createHomePresenter(
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
+        )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -144,13 +180,14 @@ class HomePresenterTest {
         }
     }
 
-    private fun TestScope.createHomePresenter(
+    private fun createHomePresenter(
         client: MatrixClient = FakeMatrixClient(),
         syncService: SyncService = FakeSyncService(),
         snackbarDispatcher: SnackbarDispatcher = SnackbarDispatcher(),
         rageshakeFeatureAvailability: RageshakeFeatureAvailability = RageshakeFeatureAvailability { flowOf(false) },
         indicatorService: IndicatorService = FakeIndicatorService(),
-        featureFlagService: FeatureFlagService = FakeFeatureFlagService()
+        featureFlagService: FeatureFlagService = FakeFeatureFlagService(),
+        sessionStore: SessionStore = InMemorySessionStore(),
     ) = HomePresenter(
         client = client,
         syncService = syncService,
@@ -160,5 +197,6 @@ class HomePresenterTest {
         roomListPresenter = { aRoomListState() },
         rageshakeFeatureAvailability = rageshakeFeatureAvailability,
         featureFlagService = featureFlagService,
+        sessionStore = sessionStore,
     )
 }

libraries/session-storage/test/src/main/kotlin/io/element/android/libraries/sessionstorage/test/InMemorySessionStore.kt

@@ -15,10 +15,11 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.map
 
 class InMemorySessionStore(
+    initialSessionData: SessionData? = null,
     private val updateUserProfileResult: (String, String?, String?) -> Unit = { _, _, _ -> error("Not implemented") },
     private val setLatestSessionResult: (String) -> Unit = { error("Not implemented") },
 ) : SessionStore {
-    private var sessionDataFlow = MutableStateFlow<SessionData?>(null)
+    private var sessionDataFlow = MutableStateFlow(initialSessionData)
 
     override fun isLoggedIn(): Flow<LoggedInState> {
         return sessionDataFlow.map {
@@ -46,6 +47,10 @@ class InMemorySessionStore(
     }
 
     override suspend fun updateUserProfile(sessionId: String, displayName: String?, avatarUrl: String?) {
+        sessionDataFlow.value = sessionDataFlow.value?.copy(
+            userDisplayName = displayName,
+            userAvatarUrl = avatarUrl
+        )
         updateUserProfileResult(sessionId, displayName, avatarUrl)
     }