fix: repair broken test compilation and runtime failures

- UsdcDepositSweepTest: add missing dispatchers param, use TestDispatchers
- ChatCoordinatorEagerBalanceTest: replace advanceUntilIdle with bounded
  advanceTimeBy to avoid infinite heartbeat loop causing OOM

Author: bmc08gt

apps/flipcash/shared/chat/src/test/kotlin/com/flipcash/shared/chat/ChatCoordinatorEagerBalanceTest.kt

@@ -28,7 +28,8 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.test.TestCoroutineScheduler
-import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.runCurrent
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
@@ -124,7 +125,8 @@ class ChatCoordinatorEagerBalanceTest {
         triggerCollection()
         val amount = Fiat(fiat = 5.0, currencyCode = CurrencyCode.CAD)
         chatUpdatesChannel.send(chatUpdate(cashMessage(senderId = otherId, amount = amount)))
-        advanceUntilIdle()
+        advanceTimeBy(1_000)
+        runCurrent()
 
         coVerify(exactly = 1) { tokenCoordinator.add(mint, amount) }
         coordinator.reset()
@@ -134,7 +136,8 @@ class ChatCoordinatorEagerBalanceTest {
     fun `self-sent cash message does not trigger tokenCoordinator add`() = runTest(testDispatchers.dispatcher) {
         triggerCollection()
         chatUpdatesChannel.send(chatUpdate(cashMessage(senderId = selfId)))
-        advanceUntilIdle()
+        advanceTimeBy(1_000)
+        runCurrent()
 
         coVerify(exactly = 0) { tokenCoordinator.add(any<Mint>(), any()) }
         coordinator.reset()
@@ -144,7 +147,8 @@ class ChatCoordinatorEagerBalanceTest {
     fun `text message does not trigger tokenCoordinator add`() = runTest(testDispatchers.dispatcher) {
         triggerCollection()
         chatUpdatesChannel.send(chatUpdate(textMessage(senderId = otherId)))
-        advanceUntilIdle()
+        advanceTimeBy(1_000)
+        runCurrent()
 
         coVerify(exactly = 0) { tokenCoordinator.add(any<Mint>(), any()) }
         coordinator.reset()
@@ -160,7 +164,8 @@ class ChatCoordinatorEagerBalanceTest {
         val msg2 = cashMessage(senderId = otherId, amount = amount2, mint = mintB).copy(messageId = 3L)
 
         chatUpdatesChannel.send(chatUpdate(msg1, msg2))
-        advanceUntilIdle()
+        advanceTimeBy(1_000)
+        runCurrent()
 
         coVerify(exactly = 1) { tokenCoordinator.add(mint, amount1) }
         coVerify(exactly = 1) { tokenCoordinator.add(mintB, amount2) }
@@ -174,7 +179,8 @@ class ChatCoordinatorEagerBalanceTest {
         val outgoing = cashMessage(senderId = selfId).copy(messageId = 3L)
 
         chatUpdatesChannel.send(chatUpdate(incoming, outgoing))
-        advanceUntilIdle()
+        advanceTimeBy(1_000)
+        runCurrent()
 
         coVerify(exactly = 1) { tokenCoordinator.add(any<Mint>(), any()) }
         coordinator.reset()

apps/flipcash/shared/tokens/src/test/kotlin/com/flipcash/app/tokens/UsdcDepositSweepTest.kt

@@ -8,11 +8,13 @@ import com.getcode.opencode.model.accounts.AccountType
 import com.getcode.opencode.model.financial.Fiat
 import com.getcode.solana.keys.Mint
 import com.getcode.solana.keys.PublicKey
+import com.flipcash.app.core.dispatchers.TestDispatchers
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.TestCoroutineScheduler
 import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.runTest
 import org.junit.After
@@ -30,6 +32,8 @@ class UsdcDepositSweepTest {
 
     private val owner: AccountCluster = mockk(relaxed = true)
 
+    private val testDispatchers = TestDispatchers(TestCoroutineScheduler())
+
     private lateinit var sweep: UsdcDepositSweep
 
     @Before
@@ -43,6 +47,7 @@ class UsdcDepositSweepTest {
             accountController = accountController,
             tokenCoordinator = tokenCoordinator,
             balancePoller = balancePoller,
+            dispatchers = testDispatchers,
             maxRetries = 3,
             initialDelay = 10.milliseconds,
             backoffFactor = 1.0,
@@ -74,46 +79,43 @@ class UsdcDepositSweepTest {
     }
 
     @Test
-    fun `gives up after max retries when USDC account is not found`() = runTest {
+    fun `gives up after max retries when USDC account is not found`() = runTest(testDispatchers.dispatcher) {
         stubNoUsdcAccount()
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(200)
 
         coVerify(exactly = 0) {
             transactionOperations.swapUsdc(any(), any())
         }
     }
 
     @Test
-    fun `gives up after max retries when account type is not AssociatedToken`() = runTest {
+    fun `gives up after max retries when account type is not AssociatedToken`() = runTest(testDispatchers.dispatcher) {
         stubUsdcAccount(balance = 1_000_000L, type = AccountType.Primary)
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(200)
 
         coVerify(exactly = 0) {
             transactionOperations.swapUsdc(any(), any())
         }
     }
 
     @Test
-    fun `gives up after max retries when USDC balance stays zero`() = runTest {
+    fun `gives up after max retries when USDC balance stays zero`() = runTest(testDispatchers.dispatcher) {
         stubUsdcAccount(balance = 0L)
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(200)
 
         coVerify(exactly = 0) {
             transactionOperations.swapUsdc(any(), any())
         }
     }
 
     @Test
-    fun `retries until balance appears then sweeps`() = runTest {
+    fun `retries until balance appears then sweeps`() = runTest(testDispatchers.dispatcher) {
         var callCount = 0
         coEvery {
             accountController.getAccount(any(), any(), any())
@@ -131,36 +133,33 @@ class UsdcDepositSweepTest {
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(300)
 
         coVerify {
             transactionOperations.swapUsdc(owner, 2_000_000L)
         }
     }
 
     @Test
-    fun `calls swapUsdc with correct amount when balance is positive`() = runTest {
+    fun `calls swapUsdc with correct amount when balance is positive`() = runTest(testDispatchers.dispatcher) {
         val amount = 5_000_000L
         stubUsdcAccount(balance = amount)
         coEvery { transactionOperations.swapUsdc(any(), any()) } returns Result.success(Unit)
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(200)
 
         coVerify {
             transactionOperations.swapUsdc(owner, amount)
         }
     }
 
     @Test
-    fun `polls for USDF balance on successful swap`() = runTest {
+    fun `polls for USDF balance on successful swap`() = runTest(testDispatchers.dispatcher) {
         stubUsdcAccount(balance = 1_000_000L)
         coEvery { transactionOperations.swapUsdc(any(), any()) } returns Result.success(Unit)
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(200)
 
         coVerify {
             balancePoller.awaitBalanceChange(
@@ -174,23 +173,22 @@ class UsdcDepositSweepTest {
     }
 
     @Test
-    fun `does not poll for USDF balance when swap fails`() = runTest {
+    fun `does not poll for USDF balance when swap fails`() = runTest(testDispatchers.dispatcher) {
         stubUsdcAccount(balance = 1_000_000L)
         coEvery {
             transactionOperations.swapUsdc(any(), any())
         } returns Result.failure(RuntimeException("swap failed"))
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(200)
 
         coVerify(exactly = 0) {
             balancePoller.awaitBalanceChange(any(), any(), any(), any(), any())
         }
     }
 
     @Test
-    fun `completes gracefully when USDF balance poll times out`() = runTest {
+    fun `completes gracefully when USDF balance poll times out`() = runTest(testDispatchers.dispatcher) {
         stubUsdcAccount(balance = 1_000_000L)
         coEvery { transactionOperations.swapUsdc(any(), any()) } returns Result.success(Unit)
         coEvery {
@@ -199,15 +197,14 @@ class UsdcDepositSweepTest {
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(200)
 
         coVerify {
             balancePoller.awaitBalanceChange(any(), any(), any(), any(), any())
         }
     }
 
     @Test
-    fun `does not execute concurrently when job is active`() = runTest {
+    fun `does not execute concurrently when job is active`() = runTest(testDispatchers.dispatcher) {
         stubUsdcAccount(balance = 1_000_000L)
         coEvery { transactionOperations.swapUsdc(any(), any()) } coAnswers {
             kotlinx.coroutines.delay(500)
@@ -216,16 +213,15 @@ class UsdcDepositSweepTest {
 
         sweep.execute(owner)
         sweep.execute(owner)
-
-        Thread.sleep(700)
+        advanceUntilIdle()
 
         coVerify(exactly = 1) {
             transactionOperations.swapUsdc(any(), any())
         }
     }
 
     @Test
-    fun `cancel stops active job`() = runTest {
+    fun `cancel stops active job`() = runTest(testDispatchers.dispatcher) {
         coEvery {
             accountController.getAccount(any(), any(), any())
         } coAnswers {
@@ -240,9 +236,8 @@ class UsdcDepositSweepTest {
         coEvery { transactionOperations.swapUsdc(any(), any()) } returns Result.success(Unit)
 
         sweep.execute(owner)
-        Thread.sleep(50)
         sweep.cancel()
-        Thread.sleep(100)
+        advanceUntilIdle()
 
         coVerify(exactly = 0) {
             transactionOperations.swapUsdc(any(), any())