From 3b58d89b306770cc93d0e8c6bb7644084931cbcb Mon Sep 17 00:00:00 2001 From: Diego Beraldin Date: Mon, 25 Mar 2024 21:37:29 +0100 Subject: [PATCH] chore: domain identity tests (#633) --- domain/identity/build.gradle.kts | 7 +- .../DefaultApiConfigurationRepositoryTest.kt | 40 ++++ .../repository/DefaultAuthRepositoryTest.kt | 50 +++++ .../DefaultIdentityRepositoryTest.kt | 110 +++++++++++ .../DefaultDeleteAccountUseCaseTest.kt | 29 +++ .../usecase/DefaultLoginUseCaseTest.kt | 183 ++++++++++++++++++ .../usecase/DefaultLogoutUseCaseTest.kt | 63 ++++++ .../DefaultSwitchAccountUseCaseTest.kt | 85 ++++++++ settings.gradle.kts | 35 ++-- 9 files changed, 582 insertions(+), 20 deletions(-) create mode 100644 domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultApiConfigurationRepositoryTest.kt create mode 100644 domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultAuthRepositoryTest.kt create mode 100644 domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultIdentityRepositoryTest.kt create mode 100644 domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultDeleteAccountUseCaseTest.kt create mode 100644 domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultLoginUseCaseTest.kt create mode 100644 domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultLogoutUseCaseTest.kt create mode 100644 domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultSwitchAccountUseCaseTest.kt diff --git a/domain/identity/build.gradle.kts b/domain/identity/build.gradle.kts index 867239792..e06e91036 100644 --- a/domain/identity/build.gradle.kts +++ b/domain/identity/build.gradle.kts @@ -43,9 +43,12 @@ kotlin { implementation(projects.domain.lemmy.data) } } - val commonTest by getting { + val androidUnitTest by getting { dependencies { - implementation(kotlin("test")) + implementation(libs.kotlinx.coroutines.test) + implementation(kotlin("test-junit")) + implementation(libs.mockk) + implementation(projects.core.testutils) } } } diff --git a/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultApiConfigurationRepositoryTest.kt b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultApiConfigurationRepositoryTest.kt new file mode 100644 index 000000000..abc0e494c --- /dev/null +++ b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultApiConfigurationRepositoryTest.kt @@ -0,0 +1,40 @@ +package com.github.diegoberaldin.raccoonforlemmy.domain.identity.repository + +import com.github.diegoberaldin.raccoonforlemmy.core.api.provider.ServiceProvider +import com.github.diegoberaldin.raccoonforlemmy.core.preferences.TemporaryKeyStore +import com.github.diegoberaldin.raccoonforlemmy.core.testutils.DispatcherTestRule +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import org.junit.Rule +import org.junit.Test +import kotlin.test.assertEquals + +class DefaultApiConfigurationRepositoryTest { + @get:Rule + val dispatcherTestRule = DispatcherTestRule() + + private val serviceProvider = mockk(relaxUnitFun = true) { + every { currentInstance } returns "lemmy.world" + } + private val keyStore = mockk(relaxUnitFun = true) { + every { get(any(), any()) } returns "" + } + private val sut = DefaultApiConfigurationRepository( + serviceProvider = serviceProvider, + keyStore = keyStore, + ) + + @Test + fun whenChangeInstance_thenValueIsUpdated() { + val resBefore = sut.instance.value + assertEquals("", resBefore) + + sut.changeInstance("feddit.it") + + verify { + serviceProvider.changeInstance("feddit.it") + keyStore.save(any(), "feddit.it") + } + } +} \ No newline at end of file diff --git a/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultAuthRepositoryTest.kt b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultAuthRepositoryTest.kt new file mode 100644 index 000000000..1fe5d5587 --- /dev/null +++ b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultAuthRepositoryTest.kt @@ -0,0 +1,50 @@ +package com.github.diegoberaldin.raccoonforlemmy.domain.identity.repository + +import com.github.diegoberaldin.raccoonforlemmy.core.api.dto.LoginForm +import com.github.diegoberaldin.raccoonforlemmy.core.api.dto.LoginResponse +import com.github.diegoberaldin.raccoonforlemmy.core.api.provider.ServiceProvider +import com.github.diegoberaldin.raccoonforlemmy.core.api.service.AuthService +import com.github.diegoberaldin.raccoonforlemmy.core.testutils.DispatcherTestRule +import de.jensklingenberg.ktorfit.Response +import io.mockk.coEvery +import io.mockk.coVerify +import io.mockk.every +import io.mockk.mockk +import kotlinx.coroutines.test.runTest +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import kotlin.test.assertEquals + +class DefaultAuthRepositoryTest { + @get:Rule + val dispatcherTestRule = DispatcherTestRule() + + private val authService = mockk() + private val serviceProvider = mockk(relaxUnitFun = true) { + every { auth } returns authService + } + + private val sut = DefaultAuthRepository( + services = serviceProvider, + ) + + @Test + fun whenLogin_thenResultIsAsExpected() = runTest { + val loginData = LoginResponse(token = "", registrationCreated = false, verifyEmailSent = true) + val fakeResponse = mockk> { + every { isSuccessful } returns true + every { body() } returns loginData + } + coEvery { authService.login(any()) } returns fakeResponse + val res = sut.login("username", "password") + + assertTrue(res.isSuccess) + + val resultData = res.getOrThrow() + assertEquals(loginData, resultData) + coVerify { + authService.login(LoginForm("username", "password")) + } + } +} \ No newline at end of file diff --git a/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultIdentityRepositoryTest.kt b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultIdentityRepositoryTest.kt new file mode 100644 index 000000000..1e73722fa --- /dev/null +++ b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/repository/DefaultIdentityRepositoryTest.kt @@ -0,0 +1,110 @@ +package com.github.diegoberaldin.raccoonforlemmy.domain.identity.repository + +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.data.AccountModel +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.AccountRepository +import com.github.diegoberaldin.raccoonforlemmy.core.testutils.DispatcherTestRule +import com.github.diegoberaldin.raccoonforlemmy.core.utils.network.NetworkManager +import com.github.diegoberaldin.raccoonforlemmy.domain.lemmy.data.UserModel +import com.github.diegoberaldin.raccoonforlemmy.domain.lemmy.repository.SiteRepository +import com.github.diegoberaldin.raccoonforlemmy.domain.lemmy.repository.UserRepository +import io.mockk.Called +import io.mockk.coEvery +import io.mockk.coVerify +import io.mockk.every +import io.mockk.mockk +import kotlinx.coroutines.test.runTest +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull + +class DefaultIdentityRepositoryTest { + @get:Rule + val dispatcherTestRule = DispatcherTestRule() + + private val accountRepository = mockk() + private val userRepository = mockk { + coEvery { getModeratedCommunities(any(), any()) } returns emptyList() + } + private val siteRepository = mockk() + private val networkManager = mockk { + coEvery { isNetworkAvailable() } returns true + } + + private val sut = DefaultIdentityRepository( + accountRepository = accountRepository, + userRepository = userRepository, + siteRepository = siteRepository, + networkManager = networkManager, + ) + + @Test + fun givenNetworkAvailableAndUserLogged_whenStartup_thenResultIsAsExpected() = runTest { + val fakeToken = "fake-token" + val fakeAccount = mockk { + every { jwt } returns fakeToken + } + val fakeUser = UserModel(id = 1) + coEvery { accountRepository.getActive() } returns fakeAccount + coEvery { siteRepository.getCurrentUser(any()) } returns fakeUser + + sut.startup() + + val token = sut.authToken.value + assertEquals(fakeToken, token) + val isLogged = sut.isLogged.value + assertTrue(isLogged == true) + assertEquals(fakeUser, sut.cachedUser) + + coVerify { + accountRepository.getActive() + networkManager.isNetworkAvailable() + siteRepository.getCurrentUser("fake-token") + } + } + + @Test + fun givenNetworkUnavailable_whenStartup_thenResultIsAsExpected() = runTest { + coEvery { networkManager.isNetworkAvailable() } returns false + val fakeToken = "fake-token" + val fakeAccount = mockk { + every { jwt } returns fakeToken + } + val fakeUser = UserModel(id = 1) + coEvery { accountRepository.getActive() } returns fakeAccount + coEvery { siteRepository.getCurrentUser(any()) } returns fakeUser + + sut.startup() + + val token = sut.authToken.value + assertEquals(fakeToken, token) + val isLogged = sut.isLogged.value + assertNull(isLogged) + + coVerify { + accountRepository.getActive() + networkManager.isNetworkAvailable() + siteRepository wasNot Called + } + } + + @Test + fun givenNotUserLogged_whenStartup_thenResultIsAsExpected() = runTest { + coEvery { accountRepository.getActive() } returns null + + sut.startup() + + val token = sut.authToken.value + assertEquals("", token) + val isLogged = sut.isLogged.value + assertTrue(isLogged == false) + assertNull(sut.cachedUser) + + coVerify { + accountRepository.getActive() + networkManager wasNot Called + siteRepository wasNot Called + } + } +} \ No newline at end of file diff --git a/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultDeleteAccountUseCaseTest.kt b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultDeleteAccountUseCaseTest.kt new file mode 100644 index 000000000..efa1845a1 --- /dev/null +++ b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultDeleteAccountUseCaseTest.kt @@ -0,0 +1,29 @@ +package com.github.diegoberaldin.raccoonforlemmy.domain.identity.usecase + +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.data.AccountModel +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.AccountRepository +import com.github.diegoberaldin.raccoonforlemmy.core.testutils.DispatcherTestRule +import io.mockk.coVerify +import io.mockk.mockk +import kotlinx.coroutines.test.runTest +import org.junit.Rule +import org.junit.Test + +class DefaultDeleteAccountUseCaseTest { + @get:Rule + val dispatcherTestRule = DispatcherTestRule() + + + private val accountRepository = mockk(relaxUnitFun = true) + private val sut = DefaultDeleteAccountUseCase( + accountRepository = accountRepository, + ) + + @Test + fun whenExecute_thenInteractionsAreAsExpected() = runTest { + val account = AccountModel(id = 1, username = "test", jwt = "fake-token", instance = "test") + sut(account) + + coVerify { accountRepository.delete(1) } + } +} \ No newline at end of file diff --git a/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultLoginUseCaseTest.kt b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultLoginUseCaseTest.kt new file mode 100644 index 000000000..266db0b12 --- /dev/null +++ b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultLoginUseCaseTest.kt @@ -0,0 +1,183 @@ +package com.github.diegoberaldin.raccoonforlemmy.domain.identity.usecase + +import com.github.diegoberaldin.raccoonforlemmy.core.api.dto.LoginResponse +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.data.AccountModel +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.data.SettingsModel +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.AccountRepository +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.CommunitySortRepository +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.SettingsRepository +import com.github.diegoberaldin.raccoonforlemmy.core.testutils.DispatcherTestRule +import com.github.diegoberaldin.raccoonforlemmy.domain.identity.repository.ApiConfigurationRepository +import com.github.diegoberaldin.raccoonforlemmy.domain.identity.repository.AuthRepository +import com.github.diegoberaldin.raccoonforlemmy.domain.identity.repository.IdentityRepository +import com.github.diegoberaldin.raccoonforlemmy.domain.lemmy.repository.SiteRepository +import io.mockk.coEvery +import io.mockk.coVerify +import io.mockk.every +import io.mockk.mockk +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.test.runTest +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import kotlin.test.assertEquals + +class DefaultLoginUseCaseTest { + @get:Rule + val dispatcherTestRule = DispatcherTestRule() + + + private val authRepository = mockk() + private val apiConfigurationRepository = mockk(relaxUnitFun = true) { + every { instance } returns MutableStateFlow("") + } + private val identityRepository = mockk(relaxUnitFun = true) + private val accountRepository = mockk(relaxUnitFun = true) + private val settingsRepository = mockk(relaxUnitFun = true) + private val siteRepository = mockk(relaxUnitFun = true) + private val communitySortRepository = mockk(relaxUnitFun = true) + private val sut = DefaultLoginUseCase( + authRepository = authRepository, + apiConfigurationRepository = apiConfigurationRepository, + identityRepository = identityRepository, + accountRepository = accountRepository, + settingsRepository = settingsRepository, + siteRepository = siteRepository, + communitySortRepository = communitySortRepository, + ) + + @Test + fun givenNewAccount_whenExecute_thenInteractionsAreAsExpected() = runTest { + val accountId = 1L + val anonymousSettings = SettingsModel() + coEvery { + authRepository.login(any(), any()) + } returns Result.success(LoginResponse("fake-token", registrationCreated = false, verifyEmailSent = true)) + coEvery { + siteRepository.getAccountSettings(any()) + } returns null + coEvery { + accountRepository.getBy(any(), any()) + } returns null + coEvery { + accountRepository.getActive() + } returns null + coEvery { + accountRepository.createAccount(any()) + } returns accountId + coEvery { + settingsRepository.getSettings(any()) + } returns anonymousSettings + + val res = sut("fake-instance", "fake-username", "fake-password") + + assertTrue(res.isSuccess) + coVerify { + apiConfigurationRepository.changeInstance("fake-instance") + authRepository.login("fake-username", "fake-password") + siteRepository.getAccountSettings("fake-token") + accountRepository.getBy("fake-username", "fake-instance") + accountRepository.createAccount(withArg { + assertEquals("fake-username", it.username) + }) + accountRepository.setActive(accountId, true) + settingsRepository.createSettings(anonymousSettings, accountId) + settingsRepository.changeCurrentSettings(anonymousSettings) + communitySortRepository.clear() + } + } + + @Test + fun givenPreviousDifferentAccount_whenExecute_thenInteractionsAreAsExpected() = runTest { + val accountId = 2L + val oldAccountId = 1L + val anonymousSettings = SettingsModel() + coEvery { + authRepository.login(any(), any()) + } returns Result.success(LoginResponse("fake-token", registrationCreated = false, verifyEmailSent = true)) + coEvery { + siteRepository.getAccountSettings(any()) + } returns null + coEvery { + accountRepository.getBy(any(), any()) + } returns null + coEvery { + accountRepository.getActive() + } returns AccountModel( + id = oldAccountId, + username = "old-username", + instance = "old-instance", + jwt = "old-token" + ) + coEvery { + accountRepository.createAccount(any()) + } returns accountId + coEvery { + settingsRepository.getSettings(any()) + } returns anonymousSettings + + val res = sut("fake-instance", "fake-username", "fake-password") + + assertTrue(res.isSuccess) + coVerify { + apiConfigurationRepository.changeInstance("fake-instance") + authRepository.login("fake-username", "fake-password") + siteRepository.getAccountSettings("fake-token") + accountRepository.getBy("fake-username", "fake-instance") + accountRepository.createAccount(withArg { + assertEquals("fake-username", it.username) + }) + accountRepository.setActive(oldAccountId, false) + accountRepository.setActive(accountId, true) + settingsRepository.createSettings(anonymousSettings, accountId) + settingsRepository.changeCurrentSettings(anonymousSettings) + communitySortRepository.clear() + } + } + + @Test + fun givenPreviousExistingAccount_whenExecute_thenInteractionsAreAsExpected() = runTest { + val accountId = 2L + val oldSettings = SettingsModel(id = 1) + coEvery { + authRepository.login(any(), any()) + } returns Result.success(LoginResponse("fake-token", registrationCreated = false, verifyEmailSent = true)) + coEvery { + siteRepository.getAccountSettings(any()) + } returns null + coEvery { + accountRepository.getBy(any(), any()) + } returns AccountModel( + id = accountId, + username = "old-username", + instance = "old-instance", + jwt = "old-token" + ) + coEvery { + accountRepository.getActive() + } returns null + coEvery { + accountRepository.createAccount(any()) + } returns accountId + coEvery { + settingsRepository.getSettings(accountId) + } returns oldSettings + + val res = sut("fake-instance", "fake-username", "fake-password") + + assertTrue(res.isSuccess) + coVerify { + apiConfigurationRepository.changeInstance("fake-instance") + authRepository.login("fake-username", "fake-password") + siteRepository.getAccountSettings("fake-token") + accountRepository.getBy("fake-username", "fake-instance") + accountRepository.setActive(accountId, true) + settingsRepository.changeCurrentSettings(oldSettings) + communitySortRepository.clear() + } + coVerify(inverse = true) { + accountRepository.createAccount(any()) + settingsRepository.createSettings(any(), any()) + } + } +} \ No newline at end of file diff --git a/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultLogoutUseCaseTest.kt b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultLogoutUseCaseTest.kt new file mode 100644 index 000000000..3c471db61 --- /dev/null +++ b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultLogoutUseCaseTest.kt @@ -0,0 +1,63 @@ +package com.github.diegoberaldin.raccoonforlemmy.domain.identity.usecase + +import com.github.diegoberaldin.raccoonforlemmy.core.notifications.NotificationCenter +import com.github.diegoberaldin.raccoonforlemmy.core.notifications.NotificationCenterEvent +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.data.AccountModel +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.data.SettingsModel +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.AccountRepository +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.CommunitySortRepository +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.SettingsRepository +import com.github.diegoberaldin.raccoonforlemmy.core.testutils.DispatcherTestRule +import com.github.diegoberaldin.raccoonforlemmy.domain.identity.repository.IdentityRepository +import io.mockk.coEvery +import io.mockk.coVerify +import io.mockk.mockk +import kotlinx.coroutines.test.runTest +import org.junit.Rule +import org.junit.Test + +class DefaultLogoutUseCaseTest { + @get:Rule + val dispatcherTestRule = DispatcherTestRule() + + private val identityRepository = mockk(relaxUnitFun = true) + private val accountRepository = mockk(relaxUnitFun = true) + private val settingsRepository = mockk(relaxUnitFun = true) + private val notificationCenter = mockk(relaxUnitFun = true) + private val communitySortRepository = mockk(relaxUnitFun = true) + private val sut = DefaultLogoutUseCase( + identityRepository = identityRepository, + accountRepository = accountRepository, + settingsRepository = settingsRepository, + notificationCenter = notificationCenter, + communitySortRepository = communitySortRepository, + ) + + @Test + fun givenNewAccount_whenExecute_thenInteractionsAreAsExpected() = runTest { + val accountId = 1L + coEvery { + accountRepository.getActive() + } returns AccountModel( + id = accountId, + instance = "fake-instance", + username = "fake-username", + jwt = "fake-token", + ) + val anonymousSettings = SettingsModel() + coEvery { + settingsRepository.getSettings(any()) + } returns anonymousSettings + + sut() + + coVerify { + notificationCenter.send(ofType(NotificationCenterEvent.ResetHome::class)) + notificationCenter.send(ofType(NotificationCenterEvent.ResetExplore::class)) + notificationCenter.send(ofType(NotificationCenterEvent.Logout::class)) + identityRepository.clearToken() + accountRepository.setActive(accountId, false) + settingsRepository.changeCurrentSettings(anonymousSettings) + } + } +} diff --git a/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultSwitchAccountUseCaseTest.kt b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultSwitchAccountUseCaseTest.kt new file mode 100644 index 000000000..0588b1125 --- /dev/null +++ b/domain/identity/src/androidUnitTest/kotlin/com/github/diegoberaldin/raccoonforlemmy/domain/identity/usecase/DefaultSwitchAccountUseCaseTest.kt @@ -0,0 +1,85 @@ +package com.github.diegoberaldin.raccoonforlemmy.domain.identity.usecase + +import com.github.diegoberaldin.raccoonforlemmy.core.api.provider.ServiceProvider +import com.github.diegoberaldin.raccoonforlemmy.core.notifications.NotificationCenter +import com.github.diegoberaldin.raccoonforlemmy.core.notifications.NotificationCenterEvent +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.data.AccountModel +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.data.SettingsModel +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.AccountRepository +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.CommunitySortRepository +import com.github.diegoberaldin.raccoonforlemmy.core.persistence.repository.SettingsRepository +import com.github.diegoberaldin.raccoonforlemmy.core.testutils.DispatcherTestRule +import com.github.diegoberaldin.raccoonforlemmy.domain.identity.repository.IdentityRepository +import io.mockk.coEvery +import io.mockk.coVerify +import io.mockk.mockk +import kotlinx.coroutines.test.runTest +import org.junit.Rule +import org.junit.Test + +class DefaultSwitchAccountUseCaseTest { + @get:Rule + val dispatcherTestRule = DispatcherTestRule() + + + private val identityRepository = mockk(relaxUnitFun = true) + private val accountRepository = mockk(relaxUnitFun = true) + private val settingsRepository = mockk(relaxUnitFun = true) + private val serviceProvider = mockk(relaxUnitFun = true) + private val notificationCenter = mockk(relaxUnitFun = true) + private val communitySortRepository = mockk(relaxUnitFun = true) + private val sut = DefaultSwitchAccountUseCase( + identityRepository = identityRepository, + accountRepository = accountRepository, + settingsRepository = settingsRepository, + serviceProvider = serviceProvider, + notificationCenter = notificationCenter, + communitySortRepository = communitySortRepository, + ) + + @Test + fun whenExecute_thenInteractionsAreAsExpected() = runTest { + val accountId = 2L + val oldAccountId = 1L + val newAccount = AccountModel( + id = accountId, + username = "new-username", + instance = "new-instance", + jwt = "new-token" + ) + val oldAccount = AccountModel( + id = oldAccountId, + username = "old-username", + instance = "old-instance", + jwt = "old-token" + ) + val oldSettings = SettingsModel(id = 1) + val newSettings = SettingsModel(id = 2) + coEvery { + accountRepository.getBy(any(), any()) + } returns null + coEvery { + accountRepository.getActive() + } returns oldAccount + coEvery { + settingsRepository.getSettings(oldAccountId) + } returns oldSettings + coEvery { + settingsRepository.getSettings(accountId) + } returns newSettings + + sut(newAccount) + + coVerify { + accountRepository.setActive(oldAccountId, false) + accountRepository.setActive(accountId, true) + settingsRepository.getSettings(accountId) + settingsRepository.changeCurrentSettings(newSettings) + communitySortRepository.clear() + notificationCenter.send(ofType(NotificationCenterEvent.Logout::class)) + identityRepository.storeToken("new-token") + identityRepository.refreshLoggedState() + serviceProvider.changeInstance("new-instance") + } + } +} \ No newline at end of file diff --git a/settings.gradle.kts b/settings.gradle.kts index 86d9b5ada..4a3f3ee81 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -50,44 +50,43 @@ include(":feature:search") include(":feature:settings") include(":unit:about") +include(":unit:accountsettings") include(":unit:ban") include(":unit:chat") +include(":unit:choosecolor") +include(":unit:choosefont") include(":unit:communitydetail") include(":unit:communityinfo") +include(":unit:configurecontentview") +include(":unit:configureswipeactions") include(":unit:createcomment") include(":unit:createpost") include(":unit:createreport") +include(":unit:drafts") include(":unit:drawer") +include(":unit:editcommunity") +include(":unit:explore") +include(":unit:filteredcontents") include(":unit:instanceinfo") include(":unit:login") include(":unit:manageaccounts") +include(":unit:manageban") include(":unit:managesubscriptions") +include(":unit:mentions") +include(":unit:messages") +include(":unit:modlog") include(":unit:multicommunity") include(":unit:myaccount") include(":unit:postdetail") include(":unit:postlist") +include(":unit:rawcontent") include(":unit:remove") +include(":unit:replies") include(":unit:reportlist") include(":unit:saveditems") include(":unit:selectcommunity") +include(":unit:selectinstance") include(":unit:userdetail") +include(":unit:userinfo") include(":unit:web") include(":unit:zoomableimage") -include(":unit:replies") -include(":unit:mentions") -include(":unit:messages") -include(":unit:modlog") -include(":unit:userinfo") -include(":unit:rawcontent") -include(":unit:accountsettings") -include(":unit:manageban") -include(":unit:choosecolor") -include(":unit:selectinstance") -include(":unit:choosefont") -include(":unit:choosecolor") -include(":unit:configureswipeactions") -include(":unit:configurecontentview") -include(":unit:drafts") -include(":unit:filteredcontents") -include(":unit:explore") -include(":unit:editcommunity")