From 7ffcb39dd373ad5aa442f487b993a8a64b139626 Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Tue, 24 Oct 2023 15:45:29 +0200 Subject: [PATCH] Test coverage: Add test on DefaultNavigationStateService --- .../android/libraries/matrix/test/TestData.kt | 2 + .../impl/DefaultNavigationStateServiceTest.kt | 308 +++++++++++++++++- 2 files changed, 293 insertions(+), 17 deletions(-) diff --git a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/TestData.kt b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/TestData.kt index cae5df4dc4..8e71447716 100644 --- a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/TestData.kt +++ b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/TestData.kt @@ -43,9 +43,11 @@ val A_USER_ID_10 = UserId("@walter:server.org") val A_SESSION_ID: SessionId = A_USER_ID val A_SESSION_ID_2: SessionId = A_USER_ID_2 val A_SPACE_ID = SpaceId("!aSpaceId:domain") +val A_SPACE_ID_2 = SpaceId("!aSpaceId2:domain") val A_ROOM_ID = RoomId("!aRoomId:domain") val A_ROOM_ID_2 = RoomId("!aRoomId2:domain") val A_THREAD_ID = ThreadId("\$aThreadId") +val A_THREAD_ID_2 = ThreadId("\$aThreadId2") val AN_EVENT_ID = EventId("\$anEventId") val AN_EVENT_ID_2 = EventId("\$anEventId2") val A_TRANSACTION_ID = TransactionId("aTransactionId") diff --git a/services/appnavstate/impl/src/test/kotlin/io/element/android/services/appnavstate/impl/DefaultNavigationStateServiceTest.kt b/services/appnavstate/impl/src/test/kotlin/io/element/android/services/appnavstate/impl/DefaultNavigationStateServiceTest.kt index ab272478cc..713839ee86 100644 --- a/services/appnavstate/impl/src/test/kotlin/io/element/android/services/appnavstate/impl/DefaultNavigationStateServiceTest.kt +++ b/services/appnavstate/impl/src/test/kotlin/io/element/android/services/appnavstate/impl/DefaultNavigationStateServiceTest.kt @@ -18,9 +18,14 @@ package io.element.android.services.appnavstate.impl import com.google.common.truth.Truth.assertThat import io.element.android.libraries.matrix.test.A_ROOM_ID +import io.element.android.libraries.matrix.test.A_ROOM_ID_2 import io.element.android.libraries.matrix.test.A_SESSION_ID +import io.element.android.libraries.matrix.test.A_SESSION_ID_2 import io.element.android.libraries.matrix.test.A_SPACE_ID +import io.element.android.libraries.matrix.test.A_SPACE_ID_2 import io.element.android.libraries.matrix.test.A_THREAD_ID +import io.element.android.libraries.matrix.test.A_THREAD_ID_2 +import io.element.android.services.appnavstate.api.AppNavigationStateService import io.element.android.services.appnavstate.api.NavigationState import io.element.android.services.appnavstate.test.A_ROOM_OWNER import io.element.android.services.appnavstate.test.A_SESSION_OWNER @@ -32,31 +37,48 @@ import kotlinx.coroutines.flow.first import org.junit.Test class DefaultNavigationStateServiceTest { + private val navigationStateRoot = NavigationState.Root + private val navigationStateSession = NavigationState.Session( + owner = A_SESSION_OWNER, + sessionId = A_SESSION_ID + ) + private val navigationStateSpace = NavigationState.Space( + owner = A_SPACE_OWNER, + spaceId = A_SPACE_ID, + parentSession = navigationStateSession + ) + private val navigationStateRoom = NavigationState.Room( + owner = A_ROOM_OWNER, + roomId = A_ROOM_ID, + parentSpace = navigationStateSpace + ) + private val navigationStateThread = NavigationState.Thread( + owner = A_THREAD_OWNER, + threadId = A_THREAD_ID, + parentRoom = navigationStateRoom + ) @Test fun testNavigation() = runCancellableScopeTest { scope -> val service = createStateService(scope) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom) service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID) - assertThat(service.appNavigationState.first().navigationState).isEqualTo( - NavigationState.Thread( - A_THREAD_OWNER, A_THREAD_ID, - NavigationState.Room( - A_ROOM_OWNER, - A_ROOM_ID, - NavigationState.Space( - A_SPACE_OWNER, - A_SPACE_ID, - NavigationState.Session( - A_SESSION_OWNER, - A_SESSION_ID - ) - ) - ) - ) - ) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread) + // Leaving the states + service.onLeavingThread(A_THREAD_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom) + service.onLeavingRoom(A_ROOM_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) + service.onLeavingSpace(A_SPACE_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + service.onLeavingSession(A_SESSION_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) } @Test @@ -66,6 +88,258 @@ class DefaultNavigationStateServiceTest { assertThat(service.appNavigationState.value.navigationState).isEqualTo(NavigationState.Root) } + @Test + fun testOnNavigateToThread() = runCancellableScopeTest { scope -> + val service = createStateService(scope) + // From root (no effect) + service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) + // From session (no effect) + service.reset() + service.navigateToSession() + service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + // From space (no effect) + service.reset() + service.navigateToSpace() + service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) + // From room + service.reset() + service.navigateToRoom() + service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread) + // From thread + service.reset() + service.navigateToThread() + // Navigate to another thread + service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID_2) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread.copy(threadId = A_THREAD_ID_2)) + } + + @Test + fun testOnNavigateToRoom() = runCancellableScopeTest { scope -> + val service = createStateService(scope) + // From root (no effect) + service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) + // From session (no effect) + service.reset() + service.navigateToSession() + service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + // From space + service.reset() + service.navigateToSpace() + service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom) + // From room + service.reset() + service.navigateToRoom() + // Navigate to another room + service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID_2) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom.copy(roomId = A_ROOM_ID_2)) + // From thread + service.reset() + service.navigateToThread() + service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom) + } + + @Test + fun testOnNavigateToSpace() = runCancellableScopeTest { scope -> + val service = createStateService(scope) + // From root (no effect) + service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) + // From session + service.reset() + service.navigateToSession() + service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) + // From space + service.reset() + service.navigateToSpace() + // Navigate to another space + service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID_2) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace.copy(spaceId = A_SPACE_ID_2)) + // From room (no effect) + service.reset() + service.navigateToRoom() + service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) + // From thread (no effect) + service.reset() + service.navigateToThread() + service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) + } + + @Test + fun testOnNavigateToSession() = runCancellableScopeTest { scope -> + val service = createStateService(scope) + // From root + service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + // From session + service.reset() + service.navigateToSession() + // Navigate to another session + service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID_2) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession.copy(sessionId = A_SESSION_ID_2)) + // From space + service.reset() + service.navigateToSpace() + service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + // From room + service.reset() + service.navigateToRoom() + service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + // From thread + service.reset() + service.navigateToThread() + service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + } + + @Test + fun testOnLeavingThread() = runCancellableScopeTest { scope -> + val service = createStateService(scope) + // From root (no effect) + service.onLeavingThread(A_THREAD_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) + // From session (no effect) + service.reset() + service.navigateToSession() + service.onLeavingThread(A_THREAD_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + // From space (no effect) + service.reset() + service.navigateToSpace() + service.onLeavingThread(A_THREAD_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) + // From room (no effect) + service.reset() + service.navigateToRoom() + service.onLeavingThread(A_THREAD_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom) + // From thread + service.reset() + service.navigateToThread() + service.onLeavingThread(A_THREAD_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom) + } + + @Test + fun testOnLeavingRoom() = runCancellableScopeTest { scope -> + val service = createStateService(scope) + // From root (no effect) + service.onLeavingRoom(A_ROOM_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) + // From session (no effect) + service.reset() + service.navigateToSession() + service.onLeavingRoom(A_ROOM_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + // From space (no effect) + service.reset() + service.navigateToSpace() + service.onLeavingRoom(A_ROOM_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) + // From room + service.reset() + service.navigateToRoom() + service.onLeavingRoom(A_ROOM_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) + // From thread (no effect) + service.reset() + service.navigateToThread() + service.onLeavingRoom(A_ROOM_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread) + } + + @Test + fun testOnLeavingSpace() = runCancellableScopeTest { scope -> + val service = createStateService(scope) + // From root (no effect) + service.onLeavingSpace(A_SPACE_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) + // From session (no effect) + service.reset() + service.navigateToSession() + service.onLeavingSpace(A_SPACE_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + // From space + service.reset() + service.navigateToSpace() + service.onLeavingSpace(A_SPACE_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession) + // From room (no effect) + service.reset() + service.navigateToRoom() + service.onLeavingSpace(A_SPACE_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom) + // From thread (no effect) + service.reset() + service.navigateToThread() + service.onLeavingSpace(A_SPACE_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread) + } + + @Test + fun testOnLeavingSession() = runCancellableScopeTest { scope -> + val service = createStateService(scope) + // From root + service.onLeavingSession(A_SESSION_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) + // From session + service.reset() + service.navigateToSession() + service.onLeavingSession(A_SESSION_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot) + // From space (no effect) + service.reset() + service.navigateToSpace() + service.onLeavingSession(A_SESSION_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace) + // From room (no effect) + service.reset() + service.navigateToRoom() + service.onLeavingSession(A_SESSION_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom) + // From thread (no effect) + service.reset() + service.navigateToThread() + service.onLeavingSession(A_SESSION_OWNER) + assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread) + } + + private fun AppNavigationStateService.reset() { + navigateToSession() + onLeavingSession(A_SESSION_OWNER) + } + + private fun AppNavigationStateService.navigateToSession() { + onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID) + } + + private fun AppNavigationStateService.navigateToSpace() { + navigateToSession() + onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID) + } + + private fun AppNavigationStateService.navigateToRoom() { + navigateToSpace() + onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID) + } + + private fun AppNavigationStateService.navigateToThread() { + navigateToRoom() + onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID) + } + private fun createStateService( coroutineScope: CoroutineScope ) = DefaultAppNavigationStateService(FakeAppForegroundStateService(), coroutineScope)