refactor: Introduce Idling Resource for UI tests

- Introduce a `CountingIdlingRes` object to track asynchronous operations and ensure UI tests wait for them to complete. This is similar to Espresso's `CountingIdlingResource`.
- Create a `ComposeCountingIdlingResource` wrapper to integrate `CountingIdlingRes` with Compose UI tests.
- Register and unregister the idling resource in `AbstractJvmUiTests` during `setUp` and `tearDown`.
- Update `SettingsViewModel` to increment/decrement the `CountingIdlingRes` counter during long-running asynchronous operations like encryption changes and database path retrieval.
- Override `setUp` and `tearDown` methods in `AndroidUiTests.kt` and `DesktopUiTests.kt` to call the superclass implementations, ensuring proper registration of the idling resource.

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,93 @@
+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 very similar to the way a {@link java.util.concurrent.Semaphore} behaves.
+ *
+ * <p>The counter may be incremented or decremented from any thread. If it reaches an illogical
+ * state (like counter less than zero) it will throw an IllegalStateException.
+ *
+ * <p>This class can then be used to wrap up operations that while in progress should block tests
+ * from accessing the UI.
+ *
+ * <pre>{@code
+ * public interface FooServer {
+ *   public Foo newFoo();
+ *   public void updateFoo(Foo foo);
+ * }
+ *
+ * public DecoratedFooServer implements FooServer {
+ *   private final FooServer realFooServer;
+ *   private final CountingIdlingRes fooServerIdlingResource;
+ *
+ *   public DecoratedFooServer(FooServer realFooServer,
+ *       CountingIdlingRes fooServerIdlingResource) {
+ *     this.realFooServer = checkNotNull(realFooServer);
+ *     this.fooServerIdlingResource = checkNotNull(fooServerIdlingResource);
+ *   }
+ *
+ *   public Foo newFoo() {
+ *     fooServerIdlingResource.increment();
+ *     try {
+ *       return realFooServer.newFoo();
+ *     } finally {
+ *       fooServerIdlingResource.decrement();
+ *     }
+ *   }
+ *
+ *   public void updateFoo(Foo foo) {
+ *     fooServerIdlingResource.increment();
+ *     try {
+ *       realFooServer.updateFoo(foo);
+ *     } finally {
+ *       fooServerIdlingResource.decrement();
+ *     }
+ *   }
+ * }
+ * }</pre>
+ *
+ * Then in your test setup:
+ *
+ * <pre>{@code
+ * public void setUp() throws Exception {
+ *   super.setUp();
+ *   FooServer realServer = FooApplication.getFooServer();
+ *   CountingIdlingRes countingResource = new CountingIdlingRes("FooServerCalls");
+ *   FooApplication.setFooServer(new DecoratedFooServer(realServer, countingResource));
+ *   Espresso.registerIdlingResource(countingResource);
+ * }
+ * }</pre>
+ */
+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()
         }
     }
 

ui/test-jvm/src/main/kotlin/com/softartdev/notedelight/ui/AbstractJvmUiTests.kt

@@ -7,8 +7,19 @@ import androidx.compose.ui.test.ExperimentalTestApi
 import androidx.compose.ui.test.junit4.ComposeContentTestRule
 import com.softartdev.notedelight.AbstractUITests
 import com.softartdev.notedelight.reflect
+import com.softartdev.notedelight.util.ComposeCountingIdlingResource
 
 abstract class AbstractJvmUiTests : AbstractUITests() {
     abstract val composeTestRule: ComposeContentTestRule
     override val composeUiTest: ComposeUiTest by lazy { reflect(composeTestRule) }
+
+    override fun setUp() {
+        super.setUp()
+        composeTestRule.registerIdlingResource(ComposeCountingIdlingResource)
+    }
+
+    override fun tearDown() {
+        super.tearDown()
+        composeTestRule.unregisterIdlingResource(ComposeCountingIdlingResource)
+    }
 }

ui/test-jvm/src/main/kotlin/com/softartdev/notedelight/util/ComposeCountingIdlingResource.kt

@@ -0,0 +1,12 @@
+package com.softartdev.notedelight.util
+
+import androidx.compose.ui.test.IdlingResource
+
+object ComposeCountingIdlingResource : IdlingResource {
+
+    override val isIdleNow: Boolean
+        get() = CountingIdlingRes.isIdleNow
+
+    override fun getDiagnosticMessageIfBusy(): String =
+        "Idling resource with counter = ${CountingIdlingRes.counter}"
+}