diff --git a/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/MockTokensRepository.kt b/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/MockTokensRepository.kt index 8c9ec119a7..59e58db799 100644 --- a/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/MockTokensRepository.kt +++ b/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/MockTokensRepository.kt @@ -9,10 +9,10 @@ import kotlinx.coroutines.flow.flowOf internal class MockTokensRepository : TokensRepository { - override suspend fun sortTokens( + override suspend fun saveTokens( userWalletId: UserWalletId, - sortedTokens: Set, - isGrouped: Boolean, + tokens: Set, + isGroupedByNetwork: Boolean, isSortedByBalance: Boolean, ) = Unit diff --git a/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCase.kt b/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCase.kt index 2f51531dc2..53a38d6642 100644 --- a/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCase.kt +++ b/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCase.kt @@ -42,7 +42,7 @@ class ApplyTokenListSortingUseCase( isSortedByBalance: Boolean, ) = withContext(dispatchers.io) { catch( - block = { tokensRepository.sortTokens(userWalletId, tokens, isGrouped, isSortedByBalance) }, + block = { tokensRepository.saveTokens(userWalletId, tokens, isGrouped, isSortedByBalance) }, catch = { raise(TokenListSortingError.DataError(it)) }, ) } diff --git a/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/repository/TokensRepository.kt b/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/repository/TokensRepository.kt index 1f978018a3..06e0b286b3 100644 --- a/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/repository/TokensRepository.kt +++ b/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/repository/TokensRepository.kt @@ -9,10 +9,10 @@ import kotlinx.coroutines.flow.Flow * */ interface TokensRepository { - suspend fun sortTokens( + suspend fun saveTokens( userWalletId: UserWalletId, - sortedTokens: Set, - isGrouped: Boolean, + tokens: Set, + isGroupedByNetwork: Boolean, isSortedByBalance: Boolean, ) diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCaseTest.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCaseTest.kt new file mode 100644 index 0000000000..0af91c7c22 --- /dev/null +++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCaseTest.kt @@ -0,0 +1,166 @@ +package com.tangem.domain.tokens + +import arrow.core.Either +import arrow.core.left +import arrow.core.right +import com.tangem.domain.core.error.DataError +import com.tangem.domain.tokens.error.TokenListSortingError +import com.tangem.domain.tokens.mock.MockTokens +import com.tangem.domain.tokens.repository.MockTokensRepository +import com.tangem.domain.wallets.models.UserWalletId +import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider +import junit.framework.TestCase.assertEquals +import kotlinx.coroutines.flow.emptyFlow +import kotlinx.coroutines.test.runTest +import org.junit.Test + +internal class ApplyTokenListSortingUseCaseTest { + + private val userWalletId = UserWalletId(value = null) + + @Test + fun `when tokens are empty then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsEmpty.left() + + val useCase = getUseCase() + + // When + val result = useCase( + userWalletId = userWalletId, + sortedTokens = emptySet(), + isGrouped = false, + isSortedByBalance = false, + ) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when tokens saving failed then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.DataError(DataError.NetworkError.NoInternetConnection).left() + + val repository = getTokensRepository( + sortTokensResult = DataError.NetworkError.NoInternetConnection.left(), + ) + val useCase = getUseCase(repository) + + // When + val result = useCase( + userWalletId = userWalletId, + sortedTokens = MockTokens.tokens, + isGrouped = false, + isSortedByBalance = false, + ) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when apply sorting for sorted and grouped list then correct args should be used`() = runTest { + // Given + val expectedTokens = MockTokens.tokens + val expectedIsGrouped = true + val expectedIsSorted = true + + val repository = getTokensRepository() + val useCase = getUseCase(repository) + + // When + useCase( + userWalletId = userWalletId, + sortedTokens = expectedTokens, + isGrouped = expectedIsGrouped, + isSortedByBalance = expectedIsSorted, + ) + + // Then + assertEquals(expectedTokens, repository.tokensIdsAfterSortingApply) + assertEquals(expectedIsGrouped, repository.isTokensGroupedAfterSortingApply) + assertEquals(expectedIsSorted, repository.isTokensSortedByBalanceAfterSortingApply) + } + + @Test + fun `when apply sorting for unsorted and grouped list then correct args should be used`() = runTest { + // Given + val expectedTokens = MockTokens.tokens + val expectedIsGrouped = true + val expectedIsSorted = false + + val repository = getTokensRepository() + val useCase = getUseCase(repository) + + // When + useCase( + userWalletId = userWalletId, + sortedTokens = expectedTokens, + isGrouped = expectedIsGrouped, + isSortedByBalance = expectedIsSorted, + ) + + // Then + assertEquals(expectedTokens, repository.tokensIdsAfterSortingApply) + assertEquals(expectedIsGrouped, repository.isTokensGroupedAfterSortingApply) + assertEquals(expectedIsSorted, repository.isTokensSortedByBalanceAfterSortingApply) + } + + @Test + fun `when apply sorting for sorted and ungrouped list then correct args should be used`() = runTest { + // Given + val expectedTokens = MockTokens.tokens + val expectedIsGrouped = false + val expectedIsSorted = true + + val repository = getTokensRepository() + val useCase = getUseCase(repository) + + // When + useCase( + userWalletId = userWalletId, + sortedTokens = expectedTokens, + isGrouped = expectedIsGrouped, + isSortedByBalance = expectedIsSorted, + ) + + // Then + assertEquals(expectedTokens, repository.tokensIdsAfterSortingApply) + assertEquals(expectedIsGrouped, repository.isTokensGroupedAfterSortingApply) + assertEquals(expectedIsSorted, repository.isTokensSortedByBalanceAfterSortingApply) + } + + @Test + fun `when apply sorting for unsorted and ungrouped list then correct args should be used`() = runTest { + // Given + val expectedTokens = MockTokens.tokens + val expectedIsGrouped = false + val expectedIsSorted = false + + val repository = getTokensRepository() + val useCase = getUseCase(repository) + + // When + useCase( + userWalletId = userWalletId, + sortedTokens = expectedTokens, + isGrouped = expectedIsGrouped, + isSortedByBalance = expectedIsSorted, + ) + + // Then + assertEquals(expectedTokens, repository.tokensIdsAfterSortingApply) + assertEquals(expectedIsGrouped, repository.isTokensGroupedAfterSortingApply) + assertEquals(expectedIsSorted, repository.isTokensSortedByBalanceAfterSortingApply) + } + + private fun getUseCase(tokensRepository: MockTokensRepository = getTokensRepository()) = + ApplyTokenListSortingUseCase( + tokensRepository = tokensRepository, + dispatchers = TestingCoroutineDispatcherProvider(), + ) + + private fun getTokensRepository(sortTokensResult: Either = Unit.right()) = + MockTokensRepository(sortTokensResult, emptyFlow(), emptyFlow(), emptyFlow()) +} \ No newline at end of file diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetTokenListUseCaseTest.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetTokenListUseCaseTest.kt index fb26a27895..8cb8237f21 100644 --- a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetTokenListUseCaseTest.kt +++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetTokenListUseCaseTest.kt @@ -31,7 +31,7 @@ internal class GetTokenListUseCaseTest { @Test fun `when list ungrouped and unsorted then correct token list should be returned`() = runTest { // Given - val expectedResult = MockTokenLists.ungroupedTokenList.right() + val expectedResult = MockTokenLists.failedUngroupedTokenList.right() val useCase = getUseCase( isGrouped = flowOf(false.right()), @@ -137,7 +137,7 @@ internal class GetTokenListUseCaseTest { // Given val error = DataError.NetworkError.NoInternetConnection.left() val expectedResult = listOf( - MockTokenLists.ungroupedTokenList.right(), + MockTokenLists.failedUngroupedTokenList.right(), TokenListError.DataError(DataError.NetworkError.NoInternetConnection).left(), ) @@ -159,7 +159,7 @@ internal class GetTokenListUseCaseTest { @Test fun `when list grouped then correct token list should be received`() = runTest { - val expectedResult = MockTokenLists.groupedTokenList.right() + val expectedResult = MockTokenLists.failedGroupedTokenList.right() val useCase = getUseCase(isGrouped = flowOf(true.right())) @@ -235,7 +235,7 @@ internal class GetTokenListUseCaseTest { @Test fun `when networks is empty and list is grouped then ungrouped list should be received`() = runTest { - val expectedResult = TokenListError.UnableToSortTokenList(MockTokenLists.ungroupedTokenList).left() + val expectedResult = TokenListError.UnableToSortTokenList(MockTokenLists.failedUngroupedTokenList).left() val useCase = getUseCase( networks = emptySet().right(), @@ -326,7 +326,7 @@ internal class GetTokenListUseCaseTest { isSortedByBalance: Flow> = flowOf(MockTokenLists.isSortedByBalance.right()), ) = GetTokenListUseCase( dispatchers = dispatchers, - tokensRepository = MockTokensRepository(tokens, isGrouped, isSortedByBalance), + tokensRepository = MockTokensRepository(Unit.right(), tokens, isGrouped, isSortedByBalance), quotesRepository = MockQuotesRepository(quotes), networksRepository = MockNetworksRepository(networks, statuses), ) diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ToggleTokenListGroupingTest.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ToggleTokenListGroupingTest.kt new file mode 100644 index 0000000000..0faaff77ea --- /dev/null +++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ToggleTokenListGroupingTest.kt @@ -0,0 +1,180 @@ +package com.tangem.domain.tokens + +import arrow.core.Either +import arrow.core.left +import arrow.core.right +import com.tangem.domain.core.error.DataError +import com.tangem.domain.tokens.error.TokenListSortingError +import com.tangem.domain.tokens.mock.MockNetworks +import com.tangem.domain.tokens.mock.MockTokenLists +import com.tangem.domain.tokens.model.Network +import com.tangem.domain.tokens.repository.MockNetworksRepository +import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider +import junit.framework.TestCase.assertEquals +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.test.runTest +import org.junit.Test + +internal class ToggleTokenListGroupingTest { + + @Test + fun `when grouped list is empty then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsEmpty.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.emptyGroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when ungrouped list is empty then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsEmpty.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.emptyUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is grouped and loading then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsLoading.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.loadingGroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is ungrouped and loading then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsLoading.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.loadingUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is not initialized then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsLoading.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.notInitializedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is ungrouped and sorted then sorted grouped list should be received`() = runTest { + // Given + val expectedResult = MockTokenLists.sortedGroupedTokenList.right() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.sortedUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is ungrouped and unsorted then unsorted grouped list should be received`() = runTest { + // Given + val expectedResult = MockTokenLists.unsortedGroupedTokenList.right() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.unsortedUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is grouped and sorted then sorted ungrouped list should be received`() = runTest { + // Given + val expectedResult = MockTokenLists.sortedUngroupedTokenList.right() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.sortedGroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is grouped and unsorted then unsorted ungrouped list should be received`() = runTest { + // Given + val expectedResult = MockTokenLists.unsortedUngroupedTokenList.right() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.unsortedGroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is ungrouped but networks is empty then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.UnableToSortTokenList.left() + + val useCase = getUseCase(networks = emptySet().right()) + + // When + val result = useCase(MockTokenLists.unsortedUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is ungrouped but networks getting failed then error should be received`() = runTest { + // Given + val error = DataError.NetworkError.NoInternetConnection + val expectedResult = TokenListSortingError.DataError(error).left() + + val useCase = getUseCase(networks = error.left()) + + // When + val result = useCase(MockTokenLists.unsortedUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + private fun getUseCase(networks: Either> = MockNetworks.networks.right()) = + ToggleTokenListGroupingUseCase( + networksRepository = MockNetworksRepository(networks, statuses = flowOf()), + dispatchers = TestingCoroutineDispatcherProvider(), + ) +} \ No newline at end of file diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ToggleTokenListSortingUseCaseTest.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ToggleTokenListSortingUseCaseTest.kt new file mode 100644 index 0000000000..f8070694f7 --- /dev/null +++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ToggleTokenListSortingUseCaseTest.kt @@ -0,0 +1,143 @@ +package com.tangem.domain.tokens + +import arrow.core.left +import arrow.core.right +import com.tangem.domain.tokens.error.TokenListSortingError +import com.tangem.domain.tokens.mock.MockTokenLists +import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider +import junit.framework.TestCase.assertEquals +import kotlinx.coroutines.test.runTest +import org.junit.Test + +internal class ToggleTokenListSortingUseCaseTest { + + @Test + fun `when grouped list is not initialized then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsLoading.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.notInitializedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when grouped list is empty then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsEmpty.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.emptyGroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when ungrouped list is empty then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsEmpty.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.emptyUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is grouped and loading then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsLoading.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.loadingGroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is ungrouped and loading then error should be received`() = runTest { + // Given + val expectedResult = TokenListSortingError.TokenListIsLoading.left() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.loadingUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is grouped and unsorted then grouped and sorted list should be received`() = runTest { + // Given + val expectedResult = MockTokenLists.sortedGroupedTokenList.right() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.unsortedGroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is ungrouped and unsorted then ungrouped and sorted list should be received`() = runTest { + // Given + val expectedResult = MockTokenLists.sortedUngroupedTokenList.right() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.unsortedUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is grouped and sorted then grouped and unsorted list should be received`() = runTest { + // Given + val expectedResult = MockTokenLists.sortedGroupedTokenList.right() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.unsortedGroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + @Test + fun `when list is ungrouped and sorted then ungrouped and unsorted list should be received`() = runTest { + // Given + val expectedResult = MockTokenLists.sortedUngroupedTokenList.right() + + val useCase = getUseCase() + + // When + val result = useCase(MockTokenLists.unsortedUngroupedTokenList) + + // Then + assertEquals(expectedResult, result) + } + + private fun getUseCase() = ToggleTokenListSortingUseCase( + dispatchers = TestingCoroutineDispatcherProvider(), + ) +} \ No newline at end of file diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockNetworksGroups.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockNetworksGroups.kt new file mode 100644 index 0000000000..2e0aab633f --- /dev/null +++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockNetworksGroups.kt @@ -0,0 +1,52 @@ +package com.tangem.domain.tokens.mock + +import arrow.core.nonEmptySetOf +import arrow.core.toNonEmptySetOrNull +import com.tangem.domain.tokens.model.NetworkGroup + +@Suppress("MemberVisibilityCanBePrivate") +internal object MockNetworksGroups { + + val networkGroup1 = NetworkGroup( + network = MockNetworks.network1, + tokens = MockTokensStates.failedTokenStates + .filter { it.networkId == MockNetworks.network1.id } + .toNonEmptySetOrNull()!!, + ) + + val networkGroup2 = NetworkGroup( + network = MockNetworks.network2, + tokens = MockTokensStates.failedTokenStates + .filter { it.networkId == MockNetworks.network2.id } + .toNonEmptySetOrNull()!!, + ) + + val networkGroup3 = NetworkGroup( + network = MockNetworks.network3, + tokens = MockTokensStates.failedTokenStates + .filter { it.networkId == MockNetworks.network3.id } + .toNonEmptySetOrNull()!!, + ) + + val failedNetworksGroups = nonEmptySetOf(networkGroup1, networkGroup2, networkGroup3) + + val loadedNetworksGroups = failedNetworksGroups.map { group -> + group.copy( + tokens = MockTokensStates.loadedTokensStates + .filter { it.networkId == group.network.id } + .toNonEmptySetOrNull()!!, + ) + }.toNonEmptySet() + + val sortedNetworksGroups = loadedNetworksGroups.map { group -> + group.copy( + tokens = group.tokens + .sortedByDescending { it.value.fiatAmount } + .toNonEmptySetOrNull()!!, + ) + } + .sortedByDescending { group -> + group.tokens.sumOf { it.value.fiatAmount!! } + } + .toNonEmptySetOrNull()!! +} \ No newline at end of file diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokenLists.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokenLists.kt index b2befbeeb1..604a2cbffc 100644 --- a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokenLists.kt +++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokenLists.kt @@ -1,8 +1,10 @@ package com.tangem.domain.tokens.mock -import arrow.core.nonEmptySetOf +import arrow.core.NonEmptySet import arrow.core.toNonEmptySetOrNull -import com.tangem.domain.tokens.model.NetworkGroup +import com.tangem.domain.tokens.mock.MockNetworksGroups.failedNetworksGroups +import com.tangem.domain.tokens.mock.MockNetworksGroups.loadedNetworksGroups +import com.tangem.domain.tokens.mock.MockNetworksGroups.sortedNetworksGroups import com.tangem.domain.tokens.model.TokenList import com.tangem.domain.tokens.model.TokenStatus import java.math.BigDecimal @@ -13,72 +15,59 @@ internal object MockTokenLists { const val isGrouped = false const val isSortedByBalance = false - val networkGroup1 = NetworkGroup( - network = MockNetworks.network1, - tokens = MockTokensStates.tokenStates - .filter { it.networkId == MockNetworks.network1.id } - .toNonEmptySetOrNull()!!, - ) - - val networkGroup2 = NetworkGroup( - network = MockNetworks.network2, - tokens = MockTokensStates.tokenStates - .filter { it.networkId == MockNetworks.network2.id } - .toNonEmptySetOrNull()!!, - ) - - val networkGroup3 = NetworkGroup( - network = MockNetworks.network3, - tokens = MockTokensStates.tokenStates - .filter { it.networkId == MockNetworks.network3.id } - .toNonEmptySetOrNull()!!, - ) - - val networksGroups = nonEmptySetOf(networkGroup1, networkGroup2, networkGroup3) - - val sortedNetworksGroups = networksGroups.map { group -> - group.copy( - tokens = MockTokensStates.loadedTokensStates - .filter { it.networkId == group.network.id } - .sortedByDescending { it.value.fiatAmount } - .toNonEmptySetOrNull()!!, - ) - } - .sortedByDescending { group -> - group.tokens.sumOf { it.value.fiatAmount!! } - } - .toNonEmptySetOrNull()!! - val notInitializedTokenList = TokenList.NotInitialized - val groupedTokenList = TokenList.GroupedByNetwork( - groups = networksGroups, + val emptyGroupedTokenList = TokenList.GroupedByNetwork( + groups = emptySet(), totalFiatBalance = TokenList.FiatBalance.Failed, sortedBy = TokenList.SortType.NONE, ) - val ungroupedTokenList = TokenList.Ungrouped( - tokens = MockTokensStates.tokenStates, + val emptyUngroupedTokenList = TokenList.Ungrouped( + tokens = emptySet(), totalFiatBalance = TokenList.FiatBalance.Failed, sortedBy = TokenList.SortType.NONE, ) - val loadingUngroupedTokenList = with(ungroupedTokenList) { + val failedGroupedTokenList = TokenList.GroupedByNetwork( + groups = failedNetworksGroups, + totalFiatBalance = TokenList.FiatBalance.Failed, + sortedBy = TokenList.SortType.NONE, + ) + + val failedUngroupedTokenList = TokenList.Ungrouped( + tokens = MockTokensStates.failedTokenStates, + totalFiatBalance = TokenList.FiatBalance.Failed, + sortedBy = TokenList.SortType.NONE, + ) + + val loadingUngroupedTokenList = with(failedUngroupedTokenList) { copy( - tokens = tokens.map { it.copy(value = TokenStatus.Loading) }.toSet(), + tokens = tokens.map { it.copy(value = TokenStatus.Loading) }.toNonEmptySetOrNull()!!, totalFiatBalance = TokenList.FiatBalance.Loading, ) } - val sortedUngroupedTokenList: TokenList.Ungrouped + val loadingGroupedTokenList = with(failedGroupedTokenList) { + copy( + totalFiatBalance = TokenList.FiatBalance.Loading, + groups = groups.map { group -> + group.copy( + tokens = group.tokens + .map { it.copy(value = TokenStatus.Loading) } + .toNonEmptySetOrNull()!!, + ) + }.toNonEmptySetOrNull()!!, + ) + } + + val unsortedUngroupedTokenList: TokenList.Ungrouped get() { val tokens = MockTokensStates.loadedTokensStates - .sortedByDescending { it.value.fiatAmount } - .toNonEmptySetOrNull()!! - return ungroupedTokenList.copy( + return failedUngroupedTokenList.copy( tokens = tokens, - sortedBy = TokenList.SortType.BALANCE, + sortedBy = TokenList.SortType.NONE, totalFiatBalance = TokenList.FiatBalance.Loaded( amount = tokens.sumOf { it.value.fiatAmount ?: BigDecimal.ZERO }, isAllAmountsSummarized = true, @@ -86,19 +75,41 @@ internal object MockTokenLists { ) } - val sortedGroupedTokenList: TokenList.GroupedByNetwork + val unsortedGroupedTokenList: TokenList.GroupedByNetwork get() { - val groups = sortedNetworksGroups.toSet() + val groups = loadedNetworksGroups - return groupedTokenList.copy( + return failedGroupedTokenList.copy( groups = groups, - sortedBy = TokenList.SortType.BALANCE, + sortedBy = TokenList.SortType.NONE, totalFiatBalance = TokenList.FiatBalance.Loaded( amount = groups - .flatMap { it.tokens } + .flatMap { it.tokens as NonEmptySet } .sumOf { it.value.fiatAmount ?: BigDecimal.ZERO }, isAllAmountsSummarized = true, ), ) } + + val sortedUngroupedTokenList: TokenList.Ungrouped + get() { + val tokens = MockTokensStates.loadedTokensStates + .sortedByDescending { it.value.fiatAmount } + .toNonEmptySetOrNull()!! + + return unsortedUngroupedTokenList.copy( + tokens = tokens, + sortedBy = TokenList.SortType.BALANCE, + ) + } + + val sortedGroupedTokenList: TokenList.GroupedByNetwork + get() { + val groups = sortedNetworksGroups + + return unsortedGroupedTokenList.copy( + groups = groups, + sortedBy = TokenList.SortType.BALANCE, + ) + } } \ No newline at end of file diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokens.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokens.kt index ec1d422785..53703985ec 100644 --- a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokens.kt +++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokens.kt @@ -1,6 +1,5 @@ package com.tangem.domain.tokens.mock -import arrow.core.nonEmptySetOf import com.tangem.domain.tokens.model.Token internal object MockTokens { @@ -116,5 +115,5 @@ internal object MockTokens { derivationPath = null, ) - val tokens = nonEmptySetOf(token1, token2, token3, token4, token5, token6, token7, token8, token9, token10) + val tokens = setOf(token1, token2, token3, token4, token5, token6, token7, token8, token9, token10) } \ No newline at end of file diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokensStates.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokensStates.kt index 9b5677d97e..b712bc465d 100644 --- a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokensStates.kt +++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokensStates.kt @@ -117,7 +117,7 @@ internal object MockTokensStates { value = TokenStatus.NoAccount, ) - val tokenStates = nonEmptySetOf( + val failedTokenStates = nonEmptySetOf( tokenState1, tokenState2, tokenState3, @@ -130,7 +130,7 @@ internal object MockTokensStates { tokenState10, ) - val loadedTokensStates = tokenStates.map { state -> + val loadedTokensStates = failedTokenStates.map { state -> val networkStatus = MockNetworks.verifiedNetworksStatuses.first { it.networkId == state.networkId } val amount = (networkStatus.value as NetworkStatus.Verified).amounts[state.id]!! val quote = MockQuotes.quotes.first { it.tokenId == state.id } @@ -144,5 +144,5 @@ internal object MockTokensStates { hasTransactionsInProgress = false, ), ) - } + }.toNonEmptySet() } \ No newline at end of file diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockTokensRepository.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockTokensRepository.kt index c5db701f0b..02b76b06d5 100644 --- a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockTokensRepository.kt +++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockTokensRepository.kt @@ -9,17 +9,33 @@ import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.map internal class MockTokensRepository( + private val sortTokensResult: Either, private val tokens: Flow>>, private val isGrouped: Flow>, private val isSortedByBalance: Flow>, ) : TokensRepository { - override suspend fun sortTokens( + var tokensIdsAfterSortingApply: Set? = null + private set + + var isTokensGroupedAfterSortingApply: Boolean? = null + private set + + var isTokensSortedByBalanceAfterSortingApply: Boolean? = null + private set + + override suspend fun saveTokens( userWalletId: UserWalletId, - sortedTokens: Set, - isGrouped: Boolean, + tokens: Set, + isGroupedByNetwork: Boolean, isSortedByBalance: Boolean, - ) = Unit + ) { + sortTokensResult.onLeft { throw it } + + tokensIdsAfterSortingApply = tokens + isTokensGroupedAfterSortingApply = isGroupedByNetwork + isTokensSortedByBalanceAfterSortingApply = isSortedByBalance + } override fun getTokens(userWalletId: UserWalletId, refresh: Boolean): Flow> { return tokens.map { it.getOrElse { e -> throw e } }