fix: getting self team info will always wait for a remote sync first [WPB-21894] (#3842)

* fix: update GetUpdatedSelfTeamUseCase to retrieve cached team information

* refactor: rename GetUpdatedSelfTeamUseCase to SyncSelfTeamInfoUseCase and update related references

Author: MohamadJaara

…eature/team/GetUpdatedSelfTeamUseCase.kt …/feature/team/SyncSelfTeamInfoUseCase.ktlogic/src/commonMain/kotlin/com/wire/kalium/logic/feature/team/GetUpdatedSelfTeamUseCase.kt renamed to logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/team/SyncSelfTeamInfoUseCase.kt logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/team/GetUpdatedSelfTeamUseCase.kt renamed to logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/team/SyncSelfTeamInfoUseCase.kt

@@ -24,17 +24,16 @@ import com.wire.kalium.logic.data.team.Team
 import com.wire.kalium.logic.data.team.TeamRepository
 
 /**
- * This use case is responsible for getting the updated team information of the self user.
+ * This use case is responsible for syncing the self team information from the backend.
  */
-// todo(interface). extract interface for use case
-public class GetUpdatedSelfTeamUseCase internal constructor(
+public class SyncSelfTeamInfoUseCase internal constructor(
     private val selfTeamIdProvider: SelfTeamIdProvider,
     private val teamRepository: TeamRepository,
 ) {
 
     public suspend operator fun invoke(): Team? {
         return selfTeamIdProvider().nullableFold({
-            kaliumLogger.w("GetUpdatedSelfTeamUseCase - self team id not found")
+            kaliumLogger.w("SyncSelfTeamInfoUseCase - self team id not found")
             null
         }, { teamId ->
             teamId?.let { teamRepository.syncTeam(it) }

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/team/TeamScope.kt

@@ -29,8 +29,9 @@ public class TeamScope internal constructor(
     private val slowSyncRepository: SlowSyncRepository,
     private val selfTeamIdProvider: SelfTeamIdProvider
 ) {
-    public val getUpdatedSelfTeamUseCase: GetUpdatedSelfTeamUseCase
-        get() = GetUpdatedSelfTeamUseCase(
+
+    public val syncSelfTeamInfoUseCase: SyncSelfTeamInfoUseCase
+        get() = SyncSelfTeamInfoUseCase(
             selfTeamIdProvider = selfTeamIdProvider,
             teamRepository = teamRepository,
         )

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/user/ObserveSelfUserWithTeamUseCase.kt

@@ -25,16 +25,16 @@ import kotlinx.coroutines.flow.Flow
 /**
  * This use case is responsible for retrieving the current user and his/her team.
  */
-internal interface ObserveSelfUserWithTeamUseCase {
+public interface ObserveSelfUserWithTeamUseCase {
 
     /**
      * @return a [Flow] of Pair, where [Pair.first] is the current user [SelfUser] and [Pair.second] is the Team of the current User [Team]
      */
-    suspend operator fun invoke(): Flow<Pair<SelfUser, Team?>>
+    public suspend operator fun invoke(): Flow<Pair<SelfUser, Team?>>
 
 }
 
-internal class ObserveSelfUserWithTeamUseCaseImpl internal constructor(private val userRepository: UserRepository) :
+public class ObserveSelfUserWithTeamUseCaseImpl internal constructor(private val userRepository: UserRepository) :
     ObserveSelfUserWithTeamUseCase {
 
     override suspend operator fun invoke(): Flow<Pair<SelfUser, Team?>> {

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/user/ObserveValidAccountsUseCase.kt

@@ -61,7 +61,7 @@ internal class ObserveValidAccountsUseCaseImpl internal constructor(
                 } else {
                     val flowsOfSelfUsers = accountList.map { accountInfo ->
                         userSessionScopeProvider.getOrCreate(accountInfo.userId).let {
-                            it.users.getSelfUserWithTeam()
+                            it.users.observeSelfUserWithTeam()
                         }
                     }
                     combine(flowsOfSelfUsers) { it.asList() }

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/user/UserScope.kt

@@ -148,7 +148,8 @@ public class UserScope internal constructor(
     private val validateUserHandleUseCase: ValidateUserHandleUseCase get() = ValidateUserHandleUseCaseImpl()
     public val getSelfUser: GetSelfUserUseCase get() = GetSelfUserUseCaseImpl(userRepository)
     public val observeSelfUser: ObserveSelfUserUseCase get() = ObserveSelfUserUseCaseImpl(userRepository)
-    internal val getSelfUserWithTeam: ObserveSelfUserWithTeamUseCase get() = ObserveSelfUserWithTeamUseCaseImpl(userRepository)
+    public val observeSelfUserWithTeam: ObserveSelfUserWithTeamUseCase
+        get() = ObserveSelfUserWithTeamUseCaseImpl(userRepository)
     public val observeUserInfo: ObserveUserInfoUseCase get() = ObserveUserInfoUseCaseImpl(userRepository, teamRepository)
     public val uploadUserAvatar: UploadUserAvatarUseCase get() = UploadUserAvatarUseCaseImpl(userRepository, assetRepository)
     public val persistSelfUserEmail: PersistSelfUserEmailUseCase get() = PersistSelfUserEmailUseCaseImpl(userRepository)

…re/team/GetUpdatedSelfTeamUseCaseTest.kt …ture/team/SyncSelfTeamInfoUseCaseTest.ktlogic/src/commonTest/kotlin/com/wire/kalium/logic/feature/team/GetUpdatedSelfTeamUseCaseTest.kt renamed to logic/src/commonTest/kotlin/com/wire/kalium/logic/feature/team/SyncSelfTeamInfoUseCaseTest.kt logic/src/commonTest/kotlin/com/wire/kalium/logic/feature/team/GetUpdatedSelfTeamUseCaseTest.kt renamed to logic/src/commonTest/kotlin/com/wire/kalium/logic/feature/team/SyncSelfTeamInfoUseCaseTest.kt

@@ -24,89 +24,109 @@ import com.wire.kalium.logic.data.id.TeamId
 import com.wire.kalium.logic.data.team.Team
 import com.wire.kalium.logic.data.team.TeamRepository
 import com.wire.kalium.logic.framework.TestTeam
-import io.mockative.any
-import io.mockative.coEvery
-import io.mockative.coVerify
-import io.mockative.eq
-import io.mockative.mock
+import dev.mokkery.answering.returns
+import dev.mokkery.everySuspend
+import dev.mokkery.matcher.any
+import dev.mokkery.matcher.eq
+import dev.mokkery.mock
+import dev.mokkery.verify.VerifyMode
+import dev.mokkery.verifySuspend
 import kotlinx.coroutines.test.runTest
 import kotlin.test.Test
-import kotlin.test.assertNotNull
+import kotlin.test.assertEquals
 import kotlin.test.assertNull
 
-class GetUpdatedSelfTeamUseCaseTest {
+class SyncSelfTeamInfoUseCaseTest {
 
     @Test
-    fun givenSelfUserHasNotValidTeam_whenGettingSelfTeam_thenTeamInfoAndServicesAreNotRequested() = runTest {
+    fun givenSelfUserHasNotValidTeam_whenSyncingSelfTeam_thenTeamInfoIsNotRequested() = runTest {
         // given
         val (arrangement, sut) = Arrangement()
             .withSelfTeamIdProvider(Either.Right(null))
-            .withSyncingByIdReturning(Either.Right(TestTeam.TEAM))
+            .withSyncTeamReturning(Either.Right(TestTeam.TEAM))
             .arrange()
 
         // when
         val result = sut.invoke()
 
         // then
         assertNull(result)
-        coVerify {
-            arrangement.teamRepository.syncTeam(eq(TestTeam.TEAM_ID))
-        }.wasNotInvoked()
+        verifySuspend(VerifyMode.not) {
+            arrangement.teamRepository.syncTeam(any())
+        }
     }
 
     @Test
-    fun givenAnError_whenGettingSelfTeam_thenTeamInfoAndServicesAreNotRequested() = runTest {
+    fun givenAnError_whenSyncingSelfTeam_thenTeamInfoIsNotRequested() = runTest {
         // given
         val (arrangement, sut) = Arrangement()
             .withSelfTeamIdProvider(Either.Left(CoreFailure.Unknown(RuntimeException("some error"))))
-            .withSyncingByIdReturning(Either.Right(TestTeam.TEAM))
+            .withSyncTeamReturning(Either.Right(TestTeam.TEAM))
+            .arrange()
+
+        // when
+        val result = sut.invoke()
+
+        // then
+        assertNull(result)
+        verifySuspend(VerifyMode.not) {
+            arrangement.teamRepository.syncTeam(any())
+        }
+    }
+
+    @Test
+    fun givenSelfUserHasValidTeam_whenSyncingSelfTeamFails_thenNullIsReturned() = runTest {
+        // given
+        val (arrangement, sut) = Arrangement()
+            .withSelfTeamIdProvider(Either.Right(TestTeam.TEAM_ID))
+            .withSyncTeamReturning(Either.Left(CoreFailure.Unknown(RuntimeException("some error"))))
             .arrange()
 
         // when
         val result = sut.invoke()
 
         // then
         assertNull(result)
-        coVerify {
+        verifySuspend {
             arrangement.teamRepository.syncTeam(eq(TestTeam.TEAM_ID))
-        }.wasNotInvoked()
+        }
     }
 
     @Test
-    fun givenSelfUserHasValidTeam_whenGettingSelfTeam_thenTeamInfoAndServicesAreRequested() = runTest {
+    fun givenSelfUserHasValidTeam_whenSyncingSelfTeam_thenTeamInfoIsReturned() = runTest {
         // given
         val (arrangement, sut) = Arrangement()
             .withSelfTeamIdProvider(Either.Right(TestTeam.TEAM_ID))
-            .withSyncingByIdReturning(Either.Right(TestTeam.TEAM))
+            .withSyncTeamReturning(Either.Right(TestTeam.TEAM))
             .arrange()
 
         // when
         val result = sut.invoke()
 
         // then
-        assertNotNull(result)
-        coVerify {
+        assertEquals(TestTeam.TEAM, result)
+        verifySuspend {
             arrangement.teamRepository.syncTeam(eq(TestTeam.TEAM_ID))
-        }.wasInvoked()
+        }
     }
 
     private class Arrangement {
-        val selfTeamIdProvider: SelfTeamIdProvider = mock(SelfTeamIdProvider::class)
-        val teamRepository: TeamRepository = mock(TeamRepository::class)
+        val selfTeamIdProvider: SelfTeamIdProvider = mock<SelfTeamIdProvider>()
+        val teamRepository: TeamRepository = mock<TeamRepository>()
 
-        suspend fun withSelfTeamIdProvider(result: Either<CoreFailure, TeamId?>) = apply {
-            coEvery {
+        fun withSelfTeamIdProvider(result: Either<CoreFailure, TeamId?>) = apply {
+            everySuspend {
                 selfTeamIdProvider.invoke()
             }.returns(result)
         }
 
-        suspend fun withSyncingByIdReturning(result: Either<CoreFailure, Team>) = apply {
-            coEvery {
+        fun withSyncTeamReturning(result: Either<CoreFailure, Team>) = apply {
+            everySuspend {
                 teamRepository.syncTeam(any())
             }.returns(result)
         }
 
-        fun arrange() = this to GetUpdatedSelfTeamUseCase(
+        fun arrange() = this to SyncSelfTeamInfoUseCase(
             selfTeamIdProvider = selfTeamIdProvider,
             teamRepository = teamRepository
         )