fix: Stabilize UI tests with Idling Resources

- Introduce `CountingIdlingRes`, a new idling resource to track ongoing asynchronous operations in ViewModels, preventing flaky tests.
- Wrap async calls in `SignInViewModel`, `SplashViewModel`, `SettingsViewModel`, and security-related ViewModels (`Enter`, `Confirm`, `Change`) with `increment()` and `decrement()` from `CountingIdlingRes`.
- Create `ComposeCountingIdlingResource` to integrate `CountingIdlingRes` with the Compose UI test framework.
- Register and unregister the `ComposeCountingIdlingResource` in the `setUp()` and `tearDown()` methods of `AbstractJvmUiTests` to automatically wait for async operations to complete.
- Add `composeUiTest.awaitIdle()` in `EditTitleAfterCreateTestCase` to ensure UI is stable before interaction.
- Add a new `TESTING_GUIDE.md` section explaining the usage and purpose of the new idling resource implementation.

Author: softartdev

app/android/src/androidTest/java/com/softartdev/notedelight/ui/AndroidUiTests.kt

@@ -8,6 +8,8 @@ import androidx.test.filters.LargeTest
 import com.softartdev.notedelight.MainActivity
 import leakcanary.DetectLeaksAfterTestSuccess
 import leakcanary.TestDescriptionHolder
+import org.junit.After
+import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.RuleChain
@@ -25,6 +27,12 @@ class AndroidUiTests : AbstractJvmUiTests() {
         .around(DetectLeaksAfterTestSuccess())
         .around(composeTestRule)
 
+    @Before
+    override fun setUp() = super.setUp()
+
+    @After
+    override fun tearDown() = super.tearDown()
+
     @Test
     override fun crudNoteTest() = super.crudNoteTest()
 

app/desktop/src/jvmTest/kotlin/com/softartdev/notedelight/ui/DesktopUiTests.kt

@@ -43,6 +43,7 @@ class DesktopUiTests : AbstractJvmUiTests() {
 
     @Before
     override fun setUp() = runTest {
+        super.setUp()
         Logger.setLogWriters(platformLogWriter())
         when (GlobalContext.getKoinApplicationOrNull()) {
             null -> startKoin {
@@ -57,7 +58,6 @@ class DesktopUiTests : AbstractJvmUiTests() {
         safeRepo.buildDbIfNeed()
         val noteDAO: NoteDAO = get(NoteDAO::class.java)
         noteDAO.deleteAll()
-        super.setUp()
         val lifecycleOwner = TestLifecycleOwner(
             initialState = Lifecycle.State.RESUMED,
             coroutineDispatcher = Dispatchers.Swing

core/domain/src/commonMain/kotlin/com/softartdev/notedelight/util/CountingIdlingRes.kt

@@ -0,0 +1,81 @@
+package com.softartdev.notedelight.util
+
+import co.touchlab.kermit.Logger
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * An object that determines idleness by maintaining an internal counter.
+ * When the counter is 0 - it is considered to be idle, when it is non-zero it is not idle.
+ * This is similar to the way a [kotlinx.coroutines.sync.Semaphore] behaves.
+ *
+ * The counter may be incremented or decremented from any coroutine. Thread-safe operations
+ * are ensured using a [Mutex]. If the counter reaches an illogical state (like counter less than zero),
+ * an error is logged but no exception is thrown to prevent test failures.
+ *
+ * This object is used to wrap up operations that while in progress should block UI tests
+ * from accessing the UI. It integrates with [com.softartdev.notedelight.util.ComposeCountingIdlingResource]
+ * for Compose UI testing.
+ *
+ * ## Usage in ViewModels
+ *
+ * Wrap async operations in ViewModels with increment/decrement calls:
+ *
+ * ```kotlin
+ * private fun loadData() = viewModelScope.launch {
+ *     CountingIdlingRes.increment()
+ *     try {
+ *         mutableStateFlow.update(Result::showLoading)
+ *         val data = withContext(Dispatchers.IO) {
+ *             repository.loadData()
+ *         }
+ *         mutableStateFlow.update { Result.Success(data) }
+ *     } catch (e: Throwable) {
+ *         handleError(e)
+ *     } finally {
+ *         mutableStateFlow.update(Result::hideLoading)
+ *         CountingIdlingRes.decrement()
+ *     }
+ * }
+ * ```
+ *
+ * ## Integration with UI Tests
+ *
+ * The [ComposeCountingIdlingResource] wraps this object and implements [androidx.compose.ui.test.IdlingResource]
+ * for Compose UI tests. Tests automatically wait for the counter to reach zero before proceeding.
+ *
+ * ```kotlin
+ * // In test setup
+ * composeTestRule.registerIdlingResource(ComposeCountingIdlingResource)
+ * ```
+ *
+ * @see [ComposeCountingIdlingResource] for Compose UI test integration
+ */
+object CountingIdlingRes {
+    private val logger = Logger.withTag("CountingIdlingRes")
+    private val mutex = Mutex()
+
+    var counter: Int = 0
+        private set
+
+    val isIdleNow: Boolean
+        get() = counter == 0
+    
+    suspend fun increment() = mutex.withLock(action = ::unsafeIncrement)
+    
+    suspend fun decrement() = mutex.withLock(action = ::unsafeDecrement)
+
+    private fun unsafeIncrement() {
+        counter++
+        logger.d { "IdlingResource incremented, counter = $counter" }
+    }
+    
+    private fun unsafeDecrement() {
+        if (counter <= 0) {
+            logger.e { "IdlingResource counter has been corrupted! Counter = $counter" }
+            return
+        }
+        counter--
+        logger.d { "IdlingResource decremented, counter = $counter" }
+    }
+}

core/presentation/src/commonMain/kotlin/com/softartdev/notedelight/presentation/settings/SettingsViewModel.kt

@@ -12,6 +12,7 @@ import com.softartdev.notedelight.navigation.Router
 import com.softartdev.notedelight.repository.SafeRepo
 import com.softartdev.notedelight.usecase.crypt.CheckSqlCipherVersionUseCase
 import com.softartdev.notedelight.usecase.settings.RevealFileListUseCase
+import com.softartdev.notedelight.util.CountingIdlingRes
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
@@ -58,6 +59,7 @@ class SettingsViewModel(
     private fun changeLanguage() = router.navigate(route = AppNavGraph.LanguageDialog)
 
     private fun checkEncryption() = viewModelScope.launch {
+        CountingIdlingRes.increment()
         mutableStateFlow.update(SecurityResult::showLoading)
         try {
             mutableStateFlow.update { result ->
@@ -70,10 +72,12 @@ class SettingsViewModel(
             handleError(e) { "error checking encryption" }
         } finally {
             mutableStateFlow.update(SecurityResult::hideLoading)
+            CountingIdlingRes.decrement()
         }
     }
 
     private fun changeEncryption(checked: Boolean) = viewModelScope.launch {
+        CountingIdlingRes.increment()
         mutableStateFlow.update(SecurityResult::showLoading)
         try {
             when {
@@ -87,10 +91,12 @@ class SettingsViewModel(
             handleError(e) { "error changing encryption" }
         } finally {
             mutableStateFlow.update(SecurityResult::hideLoading)
+            CountingIdlingRes.decrement()
         }
     }
 
     private fun changePassword() = viewModelScope.launch {
+        CountingIdlingRes.increment()
         mutableStateFlow.update(SecurityResult::showLoading)
         try {
             when {
@@ -101,10 +107,12 @@ class SettingsViewModel(
             handleError(e) { "error changing password" }
         } finally {
             mutableStateFlow.update(SecurityResult::hideLoading)
+            CountingIdlingRes.decrement()
         }
     }
 
     private fun showCipherVersion() = viewModelScope.launch {
+        CountingIdlingRes.increment()
         mutableStateFlow.update(SecurityResult::showLoading)
         try {
             val cipherVersion: String? = checkSqlCipherVersionUseCase.invoke()
@@ -113,10 +121,12 @@ class SettingsViewModel(
             handleError(e) { "error checking sqlcipher version" }
         } finally {
             mutableStateFlow.update(SecurityResult::hideLoading)
+            CountingIdlingRes.decrement()
         }
     }
 
     private fun showDatabasePath() = viewModelScope.launch {
+        CountingIdlingRes.increment()
         mutableStateFlow.update(SecurityResult::showLoading)
         try {
             val dbPath: String = safeRepo.dbPath
@@ -125,6 +135,7 @@ class SettingsViewModel(
             handleError(e) { "error getting database path" }
         } finally {
             mutableStateFlow.update(SecurityResult::hideLoading)
+            CountingIdlingRes.decrement()
         }
     }
 

core/presentation/src/commonMain/kotlin/com/softartdev/notedelight/presentation/settings/security/change/ChangeViewModel.kt

@@ -11,6 +11,7 @@ import com.softartdev.notedelight.presentation.settings.security.FieldLabel
 import com.softartdev.notedelight.usecase.crypt.ChangePasswordUseCase
 import com.softartdev.notedelight.usecase.crypt.CheckPasswordUseCase
 import com.softartdev.notedelight.util.CoroutineDispatchers
+import com.softartdev.notedelight.util.CountingIdlingRes
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
@@ -53,6 +54,7 @@ class ChangeViewModel(
     }
 
     private fun change() = viewModelScope.launch(context = coroutineDispatchers.io) {
+        CountingIdlingRes.increment()
         mutableStateFlow.update(ChangeResult::showLoading)
         try {
             val oldPassword = mutableStateFlow.value.oldPassword
@@ -89,6 +91,7 @@ class ChangeViewModel(
             e.message?.let { snackbarInteractor.showMessage(SnackbarMessage.Simple(it)) }
         } finally {
             mutableStateFlow.update(ChangeResult::hideLoading)
+            CountingIdlingRes.decrement()
         }
     }
 

core/presentation/src/commonMain/kotlin/com/softartdev/notedelight/presentation/settings/security/confirm/ConfirmViewModel.kt

@@ -10,6 +10,7 @@ import com.softartdev.notedelight.navigation.Router
 import com.softartdev.notedelight.presentation.settings.security.FieldLabel
 import com.softartdev.notedelight.usecase.crypt.ChangePasswordUseCase
 import com.softartdev.notedelight.util.CoroutineDispatchers
+import com.softartdev.notedelight.util.CountingIdlingRes
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
@@ -47,6 +48,7 @@ class ConfirmViewModel(
     }
 
     private fun confirm() = viewModelScope.launch(context = coroutineDispatchers.io) {
+        CountingIdlingRes.increment()
         mutableStateFlow.update(ConfirmResult::showLoading)
         try {
             val password = mutableStateFlow.value.password
@@ -78,6 +80,7 @@ class ConfirmViewModel(
             e.message?.let { snackbarInteractor.showMessage(SnackbarMessage.Simple(it)) }
         } finally {
             mutableStateFlow.update(ConfirmResult::hideLoading)
+            CountingIdlingRes.decrement()
         }
     }
 

core/presentation/src/commonMain/kotlin/com/softartdev/notedelight/presentation/settings/security/enter/EnterViewModel.kt

@@ -11,6 +11,7 @@ import com.softartdev.notedelight.presentation.settings.security.FieldLabel
 import com.softartdev.notedelight.usecase.crypt.ChangePasswordUseCase
 import com.softartdev.notedelight.usecase.crypt.CheckPasswordUseCase
 import com.softartdev.notedelight.util.CoroutineDispatchers
+import com.softartdev.notedelight.util.CountingIdlingRes
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
@@ -46,6 +47,7 @@ class EnterViewModel(
     }
 
     private fun enterCheck() = viewModelScope.launch(context = coroutineDispatchers.io) {
+        CountingIdlingRes.increment()
         mutableStateFlow.update(EnterResult::showLoading)
         try {
             val password = mutableStateFlow.value.password
@@ -70,6 +72,7 @@ class EnterViewModel(
             e.message?.let { snackbarInteractor.showMessage(SnackbarMessage.Simple(it)) }
         } finally {
             mutableStateFlow.update(EnterResult::hideLoading)
+            CountingIdlingRes.decrement()
         }
     }
 

core/presentation/src/commonMain/kotlin/com/softartdev/notedelight/presentation/signin/SignInViewModel.kt

@@ -7,6 +7,7 @@ import co.touchlab.kermit.Logger
 import com.softartdev.notedelight.navigation.AppNavGraph
 import com.softartdev.notedelight.navigation.Router
 import com.softartdev.notedelight.usecase.crypt.CheckPasswordUseCase
+import com.softartdev.notedelight.util.CountingIdlingRes
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
@@ -28,6 +29,7 @@ class SignInViewModel(
     }
 
     private fun signIn(pass: CharSequence) = viewModelScope.launch {
+        CountingIdlingRes.increment()
         mutableStateFlow.value = SignInResult.ShowProgress
         try {
             mutableStateFlow.value = when {
@@ -44,6 +46,8 @@ class SignInViewModel(
             autofillManager?.cancel()
             router.navigate(route = AppNavGraph.ErrorDialog(message = error.message))
             mutableStateFlow.value = SignInResult.ShowSignInForm
+        } finally {
+            CountingIdlingRes.decrement()
         }
     }
 }

core/presentation/src/commonMain/kotlin/com/softartdev/notedelight/presentation/splash/SplashViewModel.kt

@@ -7,6 +7,7 @@ import com.softartdev.notedelight.model.PlatformSQLiteState
 import com.softartdev.notedelight.navigation.AppNavGraph
 import com.softartdev.notedelight.navigation.Router
 import com.softartdev.notedelight.repository.SafeRepo
+import com.softartdev.notedelight.util.CountingIdlingRes
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
@@ -20,6 +21,7 @@ class SplashViewModel(
     val stateFlow: StateFlow<Boolean> = mutableStateFlow
 
     fun checkEncryption() = viewModelScope.launch {
+        CountingIdlingRes.increment()
         try {
             logger.d { "Building database if need..." }
             safeRepo.buildDbIfNeed()
@@ -39,6 +41,7 @@ class SplashViewModel(
             router.navigate(route = AppNavGraph.ErrorDialog(message = error.message))
         } finally {
             mutableStateFlow.value = false
+            CountingIdlingRes.decrement()
         }
     }
 }

docs/TESTING_GUIDE.md

@@ -196,6 +196,65 @@ The `ui/test` module provides multiplatform UI tests that can run on all platfor
 **Platform-Specific Test Utilities**:
 The `ui/test-jvm` module provides JVM-specific utilities and abstractions for Android and Desktop tests, including platform-specific implementations of `runOnUiThread` and test setup.
 
+### Idling Resources for UI Tests
+
+UI tests need to wait for async operations to complete before making assertions. The project uses `CountingIdlingRes` to track ongoing async operations in ViewModels.
+
+**Purpose**:
+- Prevents flaky tests by ensuring async operations complete before assertions
+- Allows tests to wait for ViewModel operations (database queries, network calls, etc.)
+- Integrates with Compose UI test framework via `ComposeCountingIdlingResource`
+
+**Usage in ViewModels**:
+
+All async operations in ViewModels should be wrapped with `CountingIdlingRes`:
+
+```kotlin
+private fun loadData() = viewModelScope.launch {
+    CountingIdlingRes.increment()
+    mutableStateFlow.update(Result::showLoading)
+    try {
+        val data = withContext(Dispatchers.IO) {
+            repository.loadData()
+        }
+        mutableStateFlow.update { Result.Success(data) }
+    } catch (e: Throwable) {
+        handleError(e)
+    } finally {
+        mutableStateFlow.update(Result::hideLoading)
+        CountingIdlingRes.decrement()
+    }
+}
+```
+
+**Pattern**:
+1. Call `CountingIdlingRes.increment()` at the start of the coroutine
+2. Perform the async operation
+3. Call `CountingIdlingRes.decrement()` in the `finally` block
+
+**Integration with Tests**:
+
+The `ComposeCountingIdlingResource` wraps `CountingIdlingRes` and implements `IdlingResource` for Compose UI tests:
+
+```kotlin
+// In AbstractJvmUiTests (ui/test-jvm)
+override fun setUp() {
+    super.setUp()
+    composeTestRule.registerIdlingResource(ComposeCountingIdlingResource)
+}
+
+override fun tearDown() {
+    super.tearDown()
+    composeTestRule.unregisterIdlingResource(ComposeCountingIdlingResource)
+}
+```
+
+Tests automatically wait for `CountingIdlingRes.counter` to reach zero before proceeding, ensuring all ViewModel operations complete.
+
+**See also**:
+- [CountingIdlingRes](../core/domain/src/commonMain/kotlin/com/softartdev/notedelight/util/CountingIdlingRes.kt) - Core idling resource implementation
+- [ComposeCountingIdlingResource](../ui/test-jvm/src/main/kotlin/com/softartdev/notedelight/util/ComposeCountingIdlingResource.kt) - Compose UI test integration
+
 ## Testing by Layer
 
 ### Domain Layer Testing