Updated on 2026-08-14

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCaseTest.kt

@@ -193,6 +193,6 @@ internal class ApplyTokenListSortingUseCaseTest {
         sortTokensResult: Either<DataError, Unit> = Unit.right(),
         tokens: Flow<Either<DataError, Set<CryptoCurrency>>> = flowOf(MockTokens.tokens.right()),
     ): MockTokensRepository {
-        return MockTokensRepository(sortTokensResult, tokens, emptyFlow(), emptyFlow())
+        return MockTokensRepository(sortTokensResult, MockTokens.token1.right(), tokens, emptyFlow(), emptyFlow())
     }
 }

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetPrimaryCurrencyUseCaseTest.kt

@@ -0,0 +1,167 @@
+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.TokenError
+import com.tangem.domain.tokens.mock.MockNetworks
+import com.tangem.domain.tokens.mock.MockQuotes
+import com.tangem.domain.tokens.mock.MockTokens
+import com.tangem.domain.tokens.mock.MockTokensStates
+import com.tangem.domain.tokens.model.CryptoCurrency
+import com.tangem.domain.tokens.model.CryptoCurrencyStatus
+import com.tangem.domain.tokens.model.NetworkStatus
+import com.tangem.domain.tokens.model.Quote
+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.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+internal class GetPrimaryCurrencyUseCaseTest {
+
+    private val dispatchers = TestingCoroutineDispatcherProvider()
+    private val userWalletId = UserWalletId(value = null)
+
+    @Test
+    fun `when all data received then token should be received`() = runTest {
+        // Given
+        val expectedResult = MockTokensStates.loadedTokensStates.first().right()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(userWalletId).first()
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when token getting failed then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenError.DataError(DataError.NetworkError.NoInternetConnection).left()
+
+        val useCase = getUseCase(token = DataError.NetworkError.NoInternetConnection.left())
+
+        // 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 = TokenError.DataError(DataError.NetworkError.NoInternetConnection).left()
+
+        val useCase = getUseCase(quotes = flowOf(DataError.NetworkError.NoInternetConnection.left()))
+
+        // 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 = TokenError.DataError(DataError.NetworkError.NoInternetConnection).left()
+
+        val useCase = getUseCase(statuses = flowOf(DataError.NetworkError.NoInternetConnection.left()))
+
+        // 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 = TokenError.UnableToCreateToken.left()
+
+        val useCase = getUseCase(statuses = flowOf())
+
+        // 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 = TokenError.UnableToCreateToken.left()
+
+        val useCase = getUseCase(quotes = flowOf())
+
+        // When
+        val result = useCase(userWalletId).first()
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when quotes are empty and statuses are verified then loading token should be received`() = runTest {
+        val expectedResult = MockTokensStates.tokenState1
+            .copy(value = CryptoCurrencyStatus.Loading)
+            .right()
+
+        val useCase = getUseCase(
+            statuses = flowOf(MockNetworks.verifiedNetworksStatuses.right()),
+            quotes = flowOf(emptySet<Quote>().right()),
+        )
+
+        // When
+        val result = useCase(userWalletId).first()
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when quotes are loaded and statuses are empty then loading token should be received`() = runTest {
+        val expectedResult = MockTokensStates.tokenState1
+            .copy(value = CryptoCurrencyStatus.Loading)
+            .right()
+
+        val useCase = getUseCase(
+            statuses = flowOf(emptySet<NetworkStatus>().right()),
+            quotes = flowOf(MockQuotes.quotes.right()),
+        )
+
+        // When
+        val result = useCase(userWalletId).first()
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    private fun getUseCase(
+        token: Either<DataError, CryptoCurrency> = MockTokens.token1.right(),
+        quotes: Flow<Either<DataError, Set<Quote>>> = flowOf(MockQuotes.quotes.right()),
+        statuses: Flow<Either<DataError, Set<NetworkStatus>>> = flowOf(MockNetworks.verifiedNetworksStatuses.right()),
+    ) = GetPrimaryCurrencyUseCase(
+        dispatchers = dispatchers,
+        tokensRepository = MockTokensRepository(
+            sortTokensResult = Unit.right(),
+            token = token,
+            tokens = flowOf(),
+            isGrouped = flowOf(),
+            isSortedByBalance = flowOf(),
+        ),
+        quotesRepository = MockQuotesRepository(quotes),
+        networksRepository = MockNetworksRepository(MockNetworks.networks.right(), statuses),
+    )
+}

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetTokenListUseCaseTest.kt

@@ -326,7 +326,13 @@ internal class GetTokenListUseCaseTest {
         isSortedByBalance: Flow<Either<DataError, Boolean>> = flowOf(MockTokenLists.isSortedByBalance.right()),
     ) = GetTokenListUseCase(
         dispatchers = dispatchers,
-        tokensRepository = MockTokensRepository(Unit.right(), tokens, isGrouped, isSortedByBalance),
+        tokensRepository = MockTokensRepository(
+            sortTokensResult = Unit.right(),
+            token = MockTokens.token1.right(),
+            tokens = tokens,
+            isGrouped = isGrouped,
+            isSortedByBalance = isSortedByBalance,
+        ),
         quotesRepository = MockQuotesRepository(quotes),
         networksRepository = MockNetworksRepository(networks, statuses),
     )

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockTokensRepository.kt

@@ -3,7 +3,6 @@ package com.tangem.domain.tokens.repository
 import arrow.core.Either
 import arrow.core.getOrElse
 import com.tangem.domain.core.error.DataError
-import com.tangem.domain.tokens.mock.MockTokens
 import com.tangem.domain.tokens.model.CryptoCurrency
 import com.tangem.domain.wallets.models.UserWalletId
 import kotlinx.coroutines.flow.Flow
@@ -11,6 +10,7 @@ import kotlinx.coroutines.flow.map
 
 internal class MockTokensRepository(
     private val sortTokensResult: Either<DataError, Unit>,
+    private val token: Either<DataError, CryptoCurrency>,
     private val tokens: Flow<Either<DataError, Set<CryptoCurrency>>>,
     private val isGrouped: Flow<Either<DataError, Boolean>>,
     private val isSortedByBalance: Flow<Either<DataError, Boolean>>,
@@ -39,7 +39,7 @@ internal class MockTokensRepository(
     }
 
     override suspend fun getPrimaryCurrency(userWalletId: UserWalletId): CryptoCurrency {
-        return MockTokens.token1
+        return token.getOrElse { e -> throw e }
     }
 
     override fun getMultiCurrencyWalletCurrencies(