Updated on 2026-08-14
This commit is contained in:
Tangem
parent
121160ed8e
commit
d9b3679274
10 changed files with 900 additions and 0 deletions
|
|
@ -7,4 +7,7 @@ dependencies {
|
|||
implementation(projects.domain.core)
|
||||
implementation(projects.domain.wallets.models)
|
||||
implementation(projects.core.utils)
|
||||
|
||||
testImplementation(deps.test.junit)
|
||||
testImplementation(deps.test.coroutine)
|
||||
}
|
||||
|
|
@ -0,0 +1,334 @@
|
|||
package com.tangem.domain.tokens
|
||||
|
||||
import arrow.core.Either
|
||||
import arrow.core.left
|
||||
import arrow.core.right
|
||||
import com.tangem.domain.tokens.error.TokensError
|
||||
import com.tangem.domain.tokens.mock.MockNetworks
|
||||
import com.tangem.domain.tokens.mock.MockQuotes
|
||||
import com.tangem.domain.tokens.mock.MockTokenLists
|
||||
import com.tangem.domain.tokens.mock.MockTokens
|
||||
import com.tangem.domain.tokens.model.Network
|
||||
import com.tangem.domain.tokens.model.NetworkStatus
|
||||
import com.tangem.domain.tokens.model.Quote
|
||||
import com.tangem.domain.tokens.model.Token
|
||||
import com.tangem.domain.tokens.repository.MockNetworksRepository
|
||||
import com.tangem.domain.tokens.repository.MockQuotesRepository
|
||||
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.ExperimentalCoroutinesApi
|
||||
import kotlinx.coroutines.flow.*
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import org.junit.Test
|
||||
|
||||
@OptIn(ExperimentalCoroutinesApi::class)
|
||||
internal class GetTokenListUseCaseTest {
|
||||
|
||||
private val dispatchers = TestingCoroutineDispatcherProvider()
|
||||
private val userWalletId = UserWalletId(value = null)
|
||||
|
||||
@Test
|
||||
fun `when list ungrouped and unsorted then correct token list should be returned`() = runTest {
|
||||
// Given
|
||||
val expectedResult = MockTokenLists.ungroupedTokenList.right()
|
||||
|
||||
val useCase = getUseCase(
|
||||
isGrouped = flowOf(false.right()),
|
||||
isSortedByBalance = flowOf(false.right()),
|
||||
)
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when tokens getting failed then error should be received`() = runTest {
|
||||
// Given
|
||||
val expectedResult = TokensError.EmptyTokens.left()
|
||||
|
||||
val useCase = getUseCase(tokens = flowOf(expectedResult))
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when quotes getting failed then error should be received`() = runTest {
|
||||
// Given
|
||||
val expectedResult = TokensError.EmptyQuotes.left()
|
||||
|
||||
val useCase = getUseCase(quotes = flowOf(expectedResult))
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when networks getting failed and list is groped then error should be received`() = runTest {
|
||||
// Given
|
||||
val expectedResult = TokensError.EmptyNetworkStatues.left()
|
||||
|
||||
val useCase = getUseCase(
|
||||
networks = expectedResult,
|
||||
isGrouped = flowOf(true.right()),
|
||||
)
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when networks statuses getting failed then error should be received`() = runTest {
|
||||
// Given
|
||||
val expectedResult = TokensError.EmptyNetworkStatues.left()
|
||||
|
||||
val useCase = getUseCase(statuses = flowOf(expectedResult))
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when grouping type getting failed then error should be received`() = runTest {
|
||||
// Given
|
||||
val expectedResult = TokensError.EmptyTokens.left()
|
||||
|
||||
val useCase = getUseCase(isGrouped = flowOf(expectedResult))
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when sorting type getting failed then error should be received`() = runTest {
|
||||
// Given
|
||||
val expectedResult = TokensError.EmptyTokens.left()
|
||||
|
||||
val useCase = getUseCase(isSortedByBalance = flowOf(expectedResult))
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when tokens getting failed on second emit then error should be received`() = runTest {
|
||||
// Given
|
||||
val error = TokensError.EmptyTokens.left()
|
||||
val expectedResult = listOf(
|
||||
MockTokenLists.ungroupedTokenList.right(),
|
||||
error,
|
||||
)
|
||||
|
||||
val useCase = getUseCase(
|
||||
tokens = flowOf(
|
||||
MockTokens.tokens.right(),
|
||||
error,
|
||||
),
|
||||
)
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId)
|
||||
.take(count = 2)
|
||||
.toList()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when list grouped then correct token list should be received`() = runTest {
|
||||
val expectedResult = MockTokenLists.groupedTokenList.right()
|
||||
|
||||
val useCase = getUseCase(isGrouped = flowOf(true.right()))
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when list is grouped and networks getting failed then error should be received`() = runTest {
|
||||
val expectedResult = TokensError.EmptyNetworks.left()
|
||||
|
||||
val useCase = getUseCase(
|
||||
networks = expectedResult,
|
||||
isGrouped = flowOf(true.right()),
|
||||
)
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when list is sorted and ungrouped then correct token list should be received`() = runTest {
|
||||
val expectedResult = MockTokenLists.sortedUngroupedTokenList.right()
|
||||
|
||||
val useCase = getUseCase(
|
||||
statuses = flowOf(MockNetworks.verifiedNetworksStatuses.right()),
|
||||
isGrouped = flowOf(false.right()),
|
||||
isSortedByBalance = flowOf(true.right()),
|
||||
)
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when list is sorted and grouped then correct token list should be received`() = runTest {
|
||||
val expectedResult = MockTokenLists.sortedGroupedTokenList.right()
|
||||
|
||||
val useCase = getUseCase(
|
||||
statuses = flowOf(MockNetworks.verifiedNetworksStatuses.right()),
|
||||
isGrouped = flowOf(true.right()),
|
||||
isSortedByBalance = flowOf(true.right()),
|
||||
)
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when tokens is empty then not initialized token list should be received`() = runTest {
|
||||
val expectedResult = MockTokenLists.notInitializedTokenList.right()
|
||||
|
||||
val useCase = getUseCase(tokens = flowOf(emptySet<Token>().right()))
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when networks is empty and list is grouped then error should be received`() = runTest {
|
||||
val expectedResult = TokensError.EmptyNetworks.left()
|
||||
|
||||
val useCase = getUseCase(
|
||||
networks = emptySet<Network>().right(),
|
||||
isGrouped = flowOf(true.right()),
|
||||
)
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when tokens flow is empty then error should be received`() = runTest {
|
||||
val expectedResult = TokensError.EmptyTokens.left()
|
||||
|
||||
val useCase = getUseCase(tokens = flowOf())
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when networks statuses flow is empty then error should be received`() = runTest {
|
||||
val expectedResult = TokensError.EmptyNetworkStatues.left()
|
||||
|
||||
val useCase = getUseCase(statuses = flowOf())
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when networks statuses is empty then loading token list should be received`() = runTest {
|
||||
val expectedResult = MockTokenLists.loadingUngroupedTokenList.right()
|
||||
|
||||
val useCase = getUseCase(statuses = flowOf(emptySet<NetworkStatus>().right()))
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when quotes flow is empty then error should be received`() = runTest {
|
||||
val expectedResult = TokensError.EmptyQuotes.left()
|
||||
|
||||
val useCase = getUseCase(quotes = flowOf())
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `when quotes is empty and statuses verified then loading token list should be received`() = runTest {
|
||||
val expectedResult = MockTokenLists.loadingUngroupedTokenList.right()
|
||||
|
||||
val useCase = getUseCase(
|
||||
statuses = flowOf(MockNetworks.verifiedNetworksStatuses.right()),
|
||||
quotes = flowOf(emptySet<Quote>().right()),
|
||||
)
|
||||
|
||||
// When
|
||||
val result = useCase(userWalletId).first()
|
||||
|
||||
// Then
|
||||
assertEquals(expectedResult, result)
|
||||
}
|
||||
|
||||
private fun getUseCase(
|
||||
tokens: Flow<Either<TokensError, Set<Token>>> = flowOf(MockTokens.tokens.right()),
|
||||
quotes: Flow<Either<TokensError, Set<Quote>>> = flowOf(MockQuotes.quotes.right()),
|
||||
networks: Either<TokensError, Set<Network>> = MockNetworks.networks.right(),
|
||||
statuses: Flow<Either<TokensError, Set<NetworkStatus>>> = flowOf(MockNetworks.errorNetworksStatuses.right()),
|
||||
isGrouped: Flow<Either<TokensError, Boolean>> = flowOf(MockTokenLists.isGrouped.right()),
|
||||
isSortedByBalance: Flow<Either<TokensError, Boolean>> = flowOf(MockTokenLists.isSortedByBalance.right()),
|
||||
) = GetTokenListUseCase(
|
||||
dispatchers = dispatchers,
|
||||
tokensRepository = MockTokensRepository(tokens, isGrouped, isSortedByBalance),
|
||||
quotesRepository = MockQuotesRepository(quotes),
|
||||
networksRepository = MockNetworksRepository(networks, statuses),
|
||||
)
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
package com.tangem.domain.tokens.mock
|
||||
|
||||
import arrow.core.NonEmptySet
|
||||
import arrow.core.nonEmptySetOf
|
||||
import com.tangem.domain.tokens.model.Network
|
||||
import com.tangem.domain.tokens.model.NetworkStatus
|
||||
import java.math.BigDecimal
|
||||
|
||||
@Suppress("MemberVisibilityCanBePrivate")
|
||||
internal object MockNetworks {
|
||||
|
||||
val amountToCreateAccount: BigDecimal = BigDecimal.TEN
|
||||
|
||||
val network1 = Network(
|
||||
id = Network.ID("network1"),
|
||||
name = "Network One",
|
||||
)
|
||||
|
||||
val network2 = Network(
|
||||
id = Network.ID("network2"),
|
||||
name = "Network Two",
|
||||
)
|
||||
|
||||
val network3 = Network(
|
||||
id = Network.ID("network3"),
|
||||
name = "Network Three",
|
||||
)
|
||||
|
||||
val networks = nonEmptySetOf(network1, network2, network3)
|
||||
|
||||
val networkStatus1 = NetworkStatus(
|
||||
networkId = network1.id,
|
||||
value = NetworkStatus.Unreachable,
|
||||
)
|
||||
|
||||
val networkStatus2 = NetworkStatus(
|
||||
networkId = network2.id,
|
||||
value = NetworkStatus.MissedDerivation,
|
||||
)
|
||||
|
||||
val networkStatus3 = NetworkStatus(
|
||||
networkId = network3.id,
|
||||
value = NetworkStatus.NoAccount(
|
||||
amountToCreateAccount = amountToCreateAccount,
|
||||
),
|
||||
)
|
||||
|
||||
val errorNetworksStatuses = nonEmptySetOf(networkStatus1, networkStatus2, networkStatus3)
|
||||
|
||||
val verifiedNetworkStatus1: NetworkStatus
|
||||
get() = networkStatus1.copy(
|
||||
value = NetworkStatus.Verified(
|
||||
amounts = mapOf(
|
||||
MockTokens.token1.id to BigDecimal.TEN,
|
||||
MockTokens.token2.id to BigDecimal.TEN,
|
||||
MockTokens.token3.id to BigDecimal.TEN,
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
val verifiedNetworkStatus2: NetworkStatus
|
||||
get() = networkStatus2.copy(
|
||||
value = NetworkStatus.Verified(
|
||||
amounts = mapOf(
|
||||
MockTokens.token4.id to BigDecimal.TEN,
|
||||
MockTokens.token5.id to BigDecimal.TEN,
|
||||
MockTokens.token6.id to BigDecimal.TEN,
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
val verifiedNetworkStatus3: NetworkStatus
|
||||
get() = networkStatus3.copy(
|
||||
value = NetworkStatus.Verified(
|
||||
amounts = mapOf(
|
||||
MockTokens.token7.id to BigDecimal.TEN,
|
||||
MockTokens.token8.id to BigDecimal.TEN,
|
||||
MockTokens.token9.id to BigDecimal.TEN,
|
||||
MockTokens.token10.id to BigDecimal.TEN,
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
val verifiedNetworksStatuses: NonEmptySet<NetworkStatus>
|
||||
get() = nonEmptySetOf(
|
||||
verifiedNetworkStatus1,
|
||||
verifiedNetworkStatus2,
|
||||
verifiedNetworkStatus3,
|
||||
)
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
package com.tangem.domain.tokens.mock
|
||||
|
||||
import arrow.core.nonEmptySetOf
|
||||
import com.tangem.domain.tokens.model.Quote
|
||||
import java.math.BigDecimal
|
||||
|
||||
@Suppress("MemberVisibilityCanBePrivate")
|
||||
internal object MockQuotes {
|
||||
|
||||
val quote1 = Quote(
|
||||
tokenId = MockTokens.token1.id,
|
||||
fiatRate = BigDecimal("1.23"),
|
||||
priceChange = BigDecimal("0.01"),
|
||||
)
|
||||
|
||||
val quote2 = Quote(
|
||||
tokenId = MockTokens.token2.id,
|
||||
fiatRate = BigDecimal("2.34"),
|
||||
priceChange = BigDecimal("-0.02"),
|
||||
)
|
||||
|
||||
val quote3 = Quote(
|
||||
tokenId = MockTokens.token3.id,
|
||||
fiatRate = BigDecimal("3.45"),
|
||||
priceChange = BigDecimal("0.03"),
|
||||
)
|
||||
|
||||
val quote4 = Quote(
|
||||
tokenId = MockTokens.token4.id,
|
||||
fiatRate = BigDecimal("4.56"),
|
||||
priceChange = BigDecimal("-0.04"),
|
||||
)
|
||||
|
||||
val quote5 = Quote(
|
||||
tokenId = MockTokens.token5.id,
|
||||
fiatRate = BigDecimal("5.67"),
|
||||
priceChange = BigDecimal("0.05"),
|
||||
)
|
||||
|
||||
val quote6 = Quote(
|
||||
tokenId = MockTokens.token6.id,
|
||||
fiatRate = BigDecimal("6.78"),
|
||||
priceChange = BigDecimal("-0.06"),
|
||||
)
|
||||
|
||||
val quote7 = Quote(
|
||||
tokenId = MockTokens.token7.id,
|
||||
fiatRate = BigDecimal("7.89"),
|
||||
priceChange = BigDecimal("0.07"),
|
||||
)
|
||||
|
||||
val quote8 = Quote(
|
||||
tokenId = MockTokens.token8.id,
|
||||
fiatRate = BigDecimal("8.90"),
|
||||
priceChange = BigDecimal("-0.08"),
|
||||
)
|
||||
|
||||
val quote9 = Quote(
|
||||
tokenId = MockTokens.token9.id,
|
||||
fiatRate = BigDecimal("9.01"),
|
||||
priceChange = BigDecimal("0.09"),
|
||||
)
|
||||
|
||||
val quote10 = Quote(
|
||||
tokenId = MockTokens.token10.id,
|
||||
fiatRate = BigDecimal("10.12"),
|
||||
priceChange = BigDecimal("-0.10"),
|
||||
)
|
||||
|
||||
val quotes = nonEmptySetOf(quote1, quote2, quote3, quote4, quote5, quote6, quote7, quote8, quote9, quote10)
|
||||
}
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
package com.tangem.domain.tokens.mock
|
||||
|
||||
import arrow.core.nonEmptySetOf
|
||||
import arrow.core.toNonEmptySetOrNull
|
||||
import com.tangem.domain.tokens.model.NetworkGroup
|
||||
import com.tangem.domain.tokens.model.TokenList
|
||||
import com.tangem.domain.tokens.model.TokenStatus
|
||||
import java.math.BigDecimal
|
||||
|
||||
@Suppress("MemberVisibilityCanBePrivate")
|
||||
internal object MockTokenLists {
|
||||
|
||||
const val isGrouped = false
|
||||
const val isSortedByBalance = false
|
||||
|
||||
val networkGroup1 = NetworkGroup(
|
||||
networkId = MockNetworks.network1.id,
|
||||
name = MockNetworks.network1.name,
|
||||
tokens = MockTokensStates.tokenStates
|
||||
.filter { it.networkId == MockNetworks.network1.id }
|
||||
.toNonEmptySetOrNull()!!,
|
||||
)
|
||||
|
||||
val networkGroup2 = NetworkGroup(
|
||||
networkId = MockNetworks.network2.id,
|
||||
name = MockNetworks.network2.name,
|
||||
tokens = MockTokensStates.tokenStates
|
||||
.filter { it.networkId == MockNetworks.network2.id }
|
||||
.toNonEmptySetOrNull()!!,
|
||||
)
|
||||
|
||||
val networkGroup3 = NetworkGroup(
|
||||
networkId = MockNetworks.network3.id,
|
||||
name = MockNetworks.network3.name,
|
||||
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.networkId }
|
||||
.sortedByDescending { it.value.fiatAmount }
|
||||
.toNonEmptySetOrNull()!!,
|
||||
)
|
||||
}
|
||||
.sortedByDescending { group ->
|
||||
group.tokens.sumOf { it.value.fiatAmount!! }
|
||||
}
|
||||
.toNonEmptySetOrNull()!!
|
||||
|
||||
val notInitializedTokenList = TokenList.NotInitialized
|
||||
|
||||
val groupedTokenList = TokenList.GroupedByNetwork(
|
||||
groups = networksGroups,
|
||||
totalFiatBalance = TokenList.FiatBalance.Failed,
|
||||
sortedBy = TokenList.SortType.NONE,
|
||||
)
|
||||
|
||||
val ungroupedTokenList = TokenList.Ungrouped(
|
||||
tokens = MockTokensStates.tokenStates,
|
||||
totalFiatBalance = TokenList.FiatBalance.Failed,
|
||||
sortedBy = TokenList.SortType.NONE,
|
||||
)
|
||||
|
||||
val loadingUngroupedTokenList = with(ungroupedTokenList) {
|
||||
copy(
|
||||
tokens = tokens.map { it.copy(value = TokenStatus.Loading) },
|
||||
totalFiatBalance = TokenList.FiatBalance.Loading,
|
||||
)
|
||||
}
|
||||
|
||||
val sortedUngroupedTokenList: TokenList.Ungrouped
|
||||
get() {
|
||||
val tokens = MockTokensStates.loadedTokensStates
|
||||
.sortedByDescending { it.value.fiatAmount }
|
||||
.toNonEmptySetOrNull()!!
|
||||
|
||||
return ungroupedTokenList.copy(
|
||||
tokens = tokens,
|
||||
sortedBy = TokenList.SortType.BALANCE,
|
||||
totalFiatBalance = TokenList.FiatBalance.Loaded(
|
||||
amount = tokens.sumOf { it.value.fiatAmount ?: BigDecimal.ZERO },
|
||||
isAllAmountsSummarized = true,
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
val sortedGroupedTokenList: TokenList.GroupedByNetwork
|
||||
get() {
|
||||
val groups = sortedNetworksGroups
|
||||
|
||||
return groupedTokenList.copy(
|
||||
groups = groups,
|
||||
sortedBy = TokenList.SortType.BALANCE,
|
||||
totalFiatBalance = TokenList.FiatBalance.Loaded(
|
||||
amount = groups
|
||||
.flatMap { it.tokens }
|
||||
.sumOf { it.value.fiatAmount ?: BigDecimal.ZERO },
|
||||
isAllAmountsSummarized = true,
|
||||
),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
package com.tangem.domain.tokens.mock
|
||||
|
||||
import arrow.core.nonEmptySetOf
|
||||
import com.tangem.domain.tokens.model.Token
|
||||
|
||||
internal object MockTokens {
|
||||
|
||||
val token1 = Token(
|
||||
id = Token.ID("token1"),
|
||||
networkId = MockNetworks.network1.id,
|
||||
name = "Token 1",
|
||||
symbol = "T1",
|
||||
isCustom = false,
|
||||
isCoin = true,
|
||||
)
|
||||
val token2 = Token(
|
||||
id = Token.ID("token2"),
|
||||
networkId = MockNetworks.network1.id,
|
||||
name = "Token 2",
|
||||
symbol = "T2",
|
||||
isCustom = false,
|
||||
isCoin = false,
|
||||
)
|
||||
val token3 = Token(
|
||||
id = Token.ID("token3"),
|
||||
networkId = MockNetworks.network1.id,
|
||||
name = "Token 3",
|
||||
symbol = "T3",
|
||||
isCustom = false,
|
||||
isCoin = false,
|
||||
)
|
||||
val token4 = Token(
|
||||
id = Token.ID("token4"),
|
||||
networkId = MockNetworks.network2.id,
|
||||
name = "Token 4",
|
||||
symbol = "T4",
|
||||
isCustom = false,
|
||||
isCoin = true,
|
||||
)
|
||||
val token5 = Token(
|
||||
id = Token.ID("token5"),
|
||||
networkId = MockNetworks.network2.id,
|
||||
name = "Token 5",
|
||||
symbol = "T5",
|
||||
isCustom = false,
|
||||
isCoin = true,
|
||||
)
|
||||
val token6 = Token(
|
||||
id = Token.ID("token6"),
|
||||
networkId = MockNetworks.network2.id,
|
||||
name = "Token 6",
|
||||
symbol = "T6",
|
||||
isCustom = false,
|
||||
isCoin = false,
|
||||
)
|
||||
val token7 = Token(
|
||||
id = Token.ID("token7"),
|
||||
networkId = MockNetworks.network3.id,
|
||||
name = "Token 7",
|
||||
symbol = "T7",
|
||||
isCustom = false,
|
||||
isCoin = false,
|
||||
)
|
||||
val token8 = Token(
|
||||
id = Token.ID("token8"),
|
||||
networkId = MockNetworks.network3.id,
|
||||
name = "Token 8",
|
||||
symbol = "T8",
|
||||
isCustom = false,
|
||||
isCoin = true,
|
||||
)
|
||||
val token9 = Token(
|
||||
id = Token.ID("token9"),
|
||||
networkId = MockNetworks.network3.id,
|
||||
name = "Token 9",
|
||||
symbol = "T9",
|
||||
isCustom = false,
|
||||
isCoin = true,
|
||||
)
|
||||
val token10 = Token(
|
||||
id = Token.ID("token10"),
|
||||
networkId = MockNetworks.network3.id,
|
||||
name = "Token 10",
|
||||
symbol = "T10",
|
||||
isCustom = false,
|
||||
isCoin = false,
|
||||
)
|
||||
|
||||
val tokens = nonEmptySetOf(token1, token2, token3, token4, token5, token6, token7, token8, token9, token10)
|
||||
}
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
package com.tangem.domain.tokens.mock
|
||||
|
||||
import arrow.core.nonEmptySetOf
|
||||
import com.tangem.domain.tokens.model.NetworkStatus
|
||||
import com.tangem.domain.tokens.model.TokenStatus
|
||||
|
||||
@Suppress("MemberVisibilityCanBePrivate")
|
||||
internal object MockTokensStates {
|
||||
|
||||
val tokenState1 = TokenStatus(
|
||||
id = MockTokens.token1.id,
|
||||
networkId = MockTokens.token1.networkId,
|
||||
name = MockTokens.token1.name,
|
||||
symbol = MockTokens.token1.symbol,
|
||||
isCoin = MockTokens.token1.isCoin,
|
||||
value = TokenStatus.Unreachable,
|
||||
)
|
||||
|
||||
val tokenState2 = TokenStatus(
|
||||
id = MockTokens.token2.id,
|
||||
networkId = MockTokens.token2.networkId,
|
||||
name = MockTokens.token2.name,
|
||||
symbol = MockTokens.token2.symbol,
|
||||
isCoin = MockTokens.token2.isCoin,
|
||||
value = TokenStatus.Unreachable,
|
||||
)
|
||||
|
||||
val tokenState3 = TokenStatus(
|
||||
id = MockTokens.token3.id,
|
||||
networkId = MockTokens.token3.networkId,
|
||||
name = MockTokens.token3.name,
|
||||
symbol = MockTokens.token3.symbol,
|
||||
isCoin = MockTokens.token3.isCoin,
|
||||
value = TokenStatus.Unreachable,
|
||||
)
|
||||
|
||||
val tokenState4 = TokenStatus(
|
||||
id = MockTokens.token4.id,
|
||||
networkId = MockTokens.token4.networkId,
|
||||
name = MockTokens.token4.name,
|
||||
symbol = MockTokens.token4.symbol,
|
||||
isCoin = MockTokens.token4.isCoin,
|
||||
value = TokenStatus.MissedDerivation,
|
||||
)
|
||||
|
||||
val tokenState5 = TokenStatus(
|
||||
id = MockTokens.token5.id,
|
||||
networkId = MockTokens.token5.networkId,
|
||||
name = MockTokens.token5.name,
|
||||
symbol = MockTokens.token5.symbol,
|
||||
isCoin = MockTokens.token5.isCoin,
|
||||
value = TokenStatus.MissedDerivation,
|
||||
)
|
||||
|
||||
val tokenState6 = TokenStatus(
|
||||
id = MockTokens.token6.id,
|
||||
networkId = MockTokens.token6.networkId,
|
||||
name = MockTokens.token6.name,
|
||||
symbol = MockTokens.token6.symbol,
|
||||
isCoin = MockTokens.token6.isCoin,
|
||||
value = TokenStatus.MissedDerivation,
|
||||
)
|
||||
|
||||
val tokenState7 = TokenStatus(
|
||||
id = MockTokens.token7.id,
|
||||
networkId = MockTokens.token7.networkId,
|
||||
name = MockTokens.token7.name,
|
||||
symbol = MockTokens.token7.symbol,
|
||||
isCoin = MockTokens.token7.isCoin,
|
||||
value = TokenStatus.NoAccount,
|
||||
)
|
||||
|
||||
val tokenState8 = TokenStatus(
|
||||
id = MockTokens.token8.id,
|
||||
networkId = MockTokens.token8.networkId,
|
||||
name = MockTokens.token8.name,
|
||||
symbol = MockTokens.token8.symbol,
|
||||
isCoin = MockTokens.token8.isCoin,
|
||||
value = TokenStatus.NoAccount,
|
||||
)
|
||||
|
||||
val tokenState9 = TokenStatus(
|
||||
id = MockTokens.token9.id,
|
||||
networkId = MockTokens.token9.networkId,
|
||||
name = MockTokens.token9.name,
|
||||
symbol = MockTokens.token9.symbol,
|
||||
isCoin = MockTokens.token9.isCoin,
|
||||
value = TokenStatus.NoAccount,
|
||||
)
|
||||
|
||||
val tokenState10 = TokenStatus(
|
||||
id = MockTokens.token10.id,
|
||||
networkId = MockTokens.token10.networkId,
|
||||
name = MockTokens.token10.name,
|
||||
symbol = MockTokens.token10.symbol,
|
||||
isCoin = MockTokens.token10.isCoin,
|
||||
value = TokenStatus.NoAccount,
|
||||
)
|
||||
|
||||
val tokenStates = nonEmptySetOf(
|
||||
tokenState1,
|
||||
tokenState2,
|
||||
tokenState3,
|
||||
tokenState4,
|
||||
tokenState5,
|
||||
tokenState6,
|
||||
tokenState7,
|
||||
tokenState8,
|
||||
tokenState9,
|
||||
tokenState10,
|
||||
)
|
||||
|
||||
val loadedTokensStates = tokenStates.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 }
|
||||
val fiatAmount = amount * quote.fiatRate
|
||||
|
||||
state.copy(
|
||||
value = TokenStatus.Loaded(
|
||||
amount = amount,
|
||||
fiatAmount = fiatAmount,
|
||||
priceChange = quote.priceChange,
|
||||
hasTransactionsInProgress = false,
|
||||
),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
package com.tangem.domain.tokens.repository
|
||||
|
||||
import arrow.core.Either
|
||||
import com.tangem.domain.tokens.error.TokensError
|
||||
import com.tangem.domain.tokens.model.Network
|
||||
import com.tangem.domain.tokens.model.NetworkStatus
|
||||
import com.tangem.domain.tokens.model.Token
|
||||
import com.tangem.domain.wallets.models.UserWalletId
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
|
||||
internal class MockNetworksRepository(
|
||||
private val networks: Either<TokensError, Set<Network>>,
|
||||
private val statuses: Flow<Either<TokensError, Set<NetworkStatus>>>,
|
||||
) : NetworksRepository {
|
||||
|
||||
override fun getNetworks(networksIds: Set<Network.ID>): Either<TokensError, Set<Network>> {
|
||||
return networks
|
||||
}
|
||||
|
||||
override fun getNetworkStatuses(
|
||||
userWalletId: UserWalletId,
|
||||
networks: Map<Network.ID, Set<Token.ID>>,
|
||||
refresh: Boolean,
|
||||
): Flow<Either<TokensError, Set<NetworkStatus>>> {
|
||||
return statuses
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
package com.tangem.domain.tokens.repository
|
||||
|
||||
import arrow.core.Either
|
||||
import com.tangem.domain.tokens.error.TokensError
|
||||
import com.tangem.domain.tokens.model.Quote
|
||||
import com.tangem.domain.tokens.model.Token
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
|
||||
internal class MockQuotesRepository(
|
||||
private val quotes: Flow<Either<TokensError, Set<Quote>>>,
|
||||
) : QuotesRepository {
|
||||
|
||||
override fun getQuotes(tokensIds: Set<Token.ID>, refresh: Boolean): Flow<Either<TokensError, Set<Quote>>> {
|
||||
return quotes
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
package com.tangem.domain.tokens.repository
|
||||
|
||||
import arrow.core.Either
|
||||
import arrow.core.right
|
||||
import com.tangem.domain.tokens.error.TokensError
|
||||
import com.tangem.domain.tokens.model.Token
|
||||
import com.tangem.domain.wallets.models.UserWalletId
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
|
||||
internal class MockTokensRepository(
|
||||
private val tokens: Flow<Either<TokensError, Set<Token>>>,
|
||||
private val isGrouped: Flow<Either<TokensError, Boolean>>,
|
||||
private val isSortedByBalance: Flow<Either<TokensError, Boolean>>,
|
||||
) : TokensRepository {
|
||||
|
||||
override suspend fun sortTokens(
|
||||
userWalletId: UserWalletId,
|
||||
sortedTokensIds: Set<Token.ID>,
|
||||
isGrouped: Boolean,
|
||||
isSortedByBalance: Boolean,
|
||||
): Either<TokensError, Unit> = Unit.right()
|
||||
|
||||
override fun getTokens(userWalletId: UserWalletId, refresh: Boolean): Flow<Either<TokensError, Set<Token>>> {
|
||||
return tokens
|
||||
}
|
||||
|
||||
override fun isTokensGrouped(userWalletId: UserWalletId): Flow<Either<TokensError, Boolean>> {
|
||||
return isGrouped
|
||||
}
|
||||
|
||||
override fun isTokensSortedByBalance(userWalletId: UserWalletId): Flow<Either<TokensError, Boolean>> {
|
||||
return isSortedByBalance
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue