feat: Improve wasmJs and iOS database handling and tests

- Refactor WebAssembly (wasmJs) database worker to support both SQLite3-WASM/OPFS and SQL.js as a fallback.
- Update `webpack.config.d/sqljs-config.js` to dynamically find the repo root, copy compose resources, and ensure SQLite WASM assets are available.
- Add `deleteDatabase` functionality for iOS to properly clean up database files, including WAL and SHM, improving test isolation.
- Configure wasmJs browser tests to run with Karma and Chrome, and only execute if Chrome is available.
- Stabilize UI tests by waiting for text fields to be displayed before interaction and wrapping navigation in the main dispatcher.
- Remove schema creation from `IosSafeRepo` as it's handled by the database driver.
- Set `duplicatesStrategy` to `EXCLUDE` for `wasmJsTestProcessResources` and `wasmJsBrowserDistribution` Gradle tasks to prevent build failures.

Author: softartdev

AGENTS.md

@@ -21,7 +21,9 @@
 - Desktop app: `./gradlew :app:desktop:run` (launches JVM desktop Compose app).
 - Desktop UI tests: `./gradlew :app:desktop:jvmTest` (uses `uiTestJUnit4`).
 - iOS: `cd iosApp && pod install` then open `iosApp/iosApp.xcworkspace` in Xcode and run. Regenerate podspec if needed: `./gradlew :app:ios-kit:podspec`.
+- iOS UI tests: `./gradlew :app:ios-kit:iosSimulatorArm64Test` (requires iOS simulator; uses multiplatform Compose UI tests).
 - Web app: `./gradlew :app:web:wasmJsBrowserDevelopmentRun --continuous` (launches the web app in a browser with hot reload).
+- Web UI tests: `./gradlew :app:web:wasmJsBrowserTest` (requires Chrome binary via `CHROME_BIN` environment variable; uses Karma/Chrome headless).
 - Build without iOS link tasks: `./gradle/build_quick.sh` (see [gradle/build_quick.sh](gradle/build_quick.sh))
 
 ## AI Agent Workflow for Verifying Changes
@@ -40,6 +42,8 @@ After making changes, AI agents must perform the following checks sequentially.
 - Unit tests: Kotlin Multiplatform `kotlin("test")`/JUnit. Run all with `./gradlew test` or per module (e.g., `:ui:shared:jvmTest`).
 - Android UI tests: Espresso/Compose in `app/android/src/androidTest`. Run with `connectedCheck`.
 - Desktop UI tests: in `app/desktop/src/jvmTest` using `uiTestJUnit4`.
+- iOS UI tests: Multiplatform Compose UI tests in `app/ios-kit/src/commonTest`. Run with `:app:ios-kit:iosSimulatorArm64Test`.
+- Web UI tests: Multiplatform Compose UI tests in `app/web/src/wasmJsTest`. Run with `:app:web:wasmJsBrowserTest` (requires `CHROME_BIN` environment variable).
 - Name tests `FooBarTest.kt`; prefer Given_When_Then method names.
 
 ## Commit & Pull Request Guidelines

app/ios-kit/README.md

@@ -358,6 +358,44 @@ dependencies {
 
 Kotlin code can be debugged from Xcode with proper symbol mapping.
 
+## Testing
+
+### UI Tests
+
+The iOS kit includes multiplatform Compose UI tests that extend `CommonUiTests` from the `ui/test` module:
+
+**Location**: `app/ios-kit/src/commonTest/kotlin/IosUiTests.kt`
+
+**Test Coverage**:
+- CRUD operations
+- Title editing after create/save
+- Database prepopulation
+- Encryption flow
+- Password settings
+- Locale switching
+
+**Running Tests**:
+
+```bash
+# Requires iOS Simulator to be running
+./gradlew :app:ios-kit:iosSimulatorArm64Test
+```
+
+**Test Configuration**:
+- Tests run on iOS Simulator (arm64)
+- Uses Compose Multiplatform testing API
+- Database is automatically cleaned up before each test
+- Handles iOS-specific database file cleanup (WAL, journal files)
+
+**Database Management**:
+Tests use improved database deletion that properly handles:
+- Main database file (`notes.db`)
+- Write-Ahead Logging files (`notes.db-wal`)
+- Shared memory files (`notes.db-shm`)
+- Journal files (`notes.db-journal`)
+
+This ensures clean test state and prevents test interference.
+
 ## Updating Framework
 
 After changing Kotlin code:

app/ios-kit/build.gradle.kts

@@ -1,4 +1,7 @@
+@file:OptIn(ExperimentalComposeLibrary::class)
+
 import org.gradle.internal.os.OperatingSystem
+import org.jetbrains.compose.ExperimentalComposeLibrary
 
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
@@ -39,5 +42,13 @@ kotlin {
             implementation(project.dependencies.platform(libs.koin.bom))
             api(libs.koin.core)
         }
+        commonTest.dependencies {
+            implementation(kotlin("test"))
+            implementation(projects.ui.test)
+            implementation(compose.uiTest)
+            implementation(compose.materialIconsExtended)
+            implementation(libs.androidx.lifecycle.runtime.compose)
+            implementation(libs.androidx.lifecycle.runtime.testing)
+        }
     }
 }

app/ios-kit/src/commonTest/kotlin/com/softartdev/notedelight/IosUiTests.kt

@@ -0,0 +1,36 @@
+package com.softartdev.notedelight
+
+import kotlinx.coroutines.test.TestResult
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+
+class IosUiTests : CommonUiTests() {
+
+    @BeforeTest
+    override fun setUp() = super.setUp()
+
+    @AfterTest
+    override fun tearDown() = super.tearDown()
+
+    @Test
+    override fun crudNoteTest(): TestResult = super.crudNoteTest()
+
+    @Test
+    override fun editTitleAfterCreateTest(): TestResult = super.editTitleAfterCreateTest()
+
+    @Test
+    override fun editTitleAfterSaveTest(): TestResult = super.editTitleAfterSaveTest()
+
+    @Test
+    override fun prepopulateDatabase(): TestResult = super.prepopulateDatabase()
+
+    @Test
+    override fun flowAfterCryptTest(): TestResult = super.flowAfterCryptTest()
+
+    @Test
+    override fun settingPasswordTest(): TestResult = super.settingPasswordTest()
+
+    @Test
+    override fun localeTest(): TestResult = super.localeTest()
+}

app/iosApp/iosApp.xcworkspace/xcuserdata/artur.xcuserdatad/UserInterfaceState.xcuserstate

@@ -399,9 +399,43 @@ self.addEventListener('install', (event) => {
 
 ## Testing
 
+### UI Tests
+
+The web app includes multiplatform Compose UI tests that extend `CommonUiTests` from the `ui/test` module:
+
+**Location**: `app/web/src/wasmJsTest/kotlin/WebUiTests.kt`
+
+**Test Coverage**:
+- CRUD operations
+- Title editing after create/save
+- Database prepopulation
+- Encryption flow
+- Password settings
+- Locale switching
+
+**Running Tests**:
+
+```bash
+# Requires CHROME_BIN environment variable
+export CHROME_BIN=/path/to/chrome
+./gradlew :app:web:wasmJsBrowserTest
+```
+
+**Test Configuration**:
+- Uses Karma with Chrome headless for test execution
+- Automatically disabled if `CHROME_BIN` is not set
+- Tests use SQL.js fallback when SQLite3 WASM is not available (common in headless browsers)
+- Database is automatically cleaned up before each test
+
+**Database Fallback for Tests**:
+The test worker (`sqlite.worker.js`) implements a fallback mechanism:
+1. First attempts to use official SQLite3 WASM with OPFS support
+2. Falls back to SQL.js (in-memory) if SQLite3 is unavailable
+3. This ensures tests can run in headless browser environments that may not support OPFS
+
 ### Unit Tests
 
-Web-specific tests:
+Web-specific unit tests:
 
 ```kotlin
 // In wasmJsTest/
@@ -411,10 +445,15 @@ fun testWebInitialization() {
 }
 ```
 
-### Running Tests
+### Running All Tests
 
 ```bash
+# Unit tests
 ./gradlew :app:web:wasmJsTest
+
+# UI tests (requires CHROME_BIN)
+export CHROME_BIN=/path/to/chrome
+./gradlew :app:web:wasmJsBrowserTest
 ```
 
 ### Browser Testing

app/web/README.md

@@ -1,8 +1,12 @@
-@file:OptIn(ExperimentalWasmDsl::class)
+@file:OptIn(ExperimentalWasmDsl::class, ExperimentalComposeLibrary::class)
 
 import de.undercouch.gradle.tasks.download.Download
+import org.jetbrains.compose.ExperimentalComposeLibrary
 import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpackConfig
+import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
+import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.tasks.Copy
 
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
@@ -17,6 +21,12 @@ kotlin {
         browser {
             val rootDirPath = project.rootDir.path
             val projectDirPath = project.projectDir.path
+            testTask {
+                useKarma {
+                    useChrome()
+                    useChromeHeadless()
+                }
+            }
             commonWebpackConfig {
                 outputFileName = "composeApp.js"
                 devServer = (devServer ?: KotlinWebpackConfig.DevServer()).apply {
@@ -34,6 +44,7 @@ kotlin {
     sourceSets {
         val wasmJsMain by getting {
             dependencies {
+                implementation(projects.core.domain)
                 implementation(projects.core.presentation)
                 implementation(projects.ui.shared)
                 implementation(compose.ui)
@@ -44,10 +55,27 @@ kotlin {
             }
             resources.srcDir(layout.buildDirectory.dir("sqlite"))
         }
-        val wasmJsTest by getting
+        val wasmJsTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+                implementation(projects.ui.test)
+                implementation(compose.uiTest)
+                implementation(compose.materialIconsExtended)
+                implementation(libs.androidx.lifecycle.runtime.compose)
+                implementation(libs.androidx.lifecycle.runtime.testing)
+            }
+            resources.srcDir(layout.buildDirectory.dir("sqlite"))
+        }
     }
 }
 
+val chromeBinaryFromEnv = providers.environmentVariable("CHROME_BIN").orNull
+val hasChromeForTests = chromeBinaryFromEnv?.let { file(it).exists() } == true
+
+tasks.named<KotlinJsTest>("wasmJsBrowserTest").configure {
+    enabled = hasChromeForTests
+}
+
 val sqliteVersion = 3500400 // See https://sqlite.org/download.html for the latest wasm build version
 val sqliteDownload = tasks.register("sqliteDownload", Download::class.java) {
     src("https://sqlite.org/2025/sqlite-wasm-$sqliteVersion.zip")
@@ -70,3 +98,11 @@ val sqliteUnzip = tasks.register("sqliteUnzip", Copy::class.java) {
 tasks.named("wasmJsProcessResources").configure {
     dependsOn(sqliteUnzip)
 }
+tasks.named<Copy>("wasmJsTestProcessResources").configure {
+    dependsOn(sqliteUnzip)
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+tasks.named<Sync>("wasmJsBrowserDistribution").configure {
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}

app/web/build.gradle.kts

@@ -1,13 +1,57 @@
-importScripts("sqlite3.js");
+let sqlite3Available = false;
+let useSqlJs = false;
+
+try {
+  importScripts("sqlite3.js");
+  sqlite3Available = typeof sqlite3InitModule === "function";
+} catch (error) {
+  sqlite3Available = false;
+}
 
 let db = null;
 
 async function createDatabase() {
-  const sqlite3 = await sqlite3InitModule();
+  if (sqlite3Available) {
+    const sqlite3 = await sqlite3InitModule();
+
+    // This is the key part for OPFS support
+    // It instructs SQLite to use the OPFS VFS.
+    try {
+      db = new sqlite3.oo1.DB("file:database.db?vfs=opfs", "c");
+      return;
+    } catch (error) {
+      try {
+        // Fallback for environments without OPFS support (e.g., headless browsers).
+        db = new sqlite3.oo1.DB(":memory:", "c");
+        return;
+      } catch (fallbackError) {
+        sqlite3Available = false;
+      }
+    }
+  }
+
+  if (typeof initSqlJs !== "function") {
+    importScripts("sql-wasm.js");
+  }
+
+  const SQL = await initSqlJs({
+    locateFile: (file) => file,
+  });
+  db = new SQL.Database();
+  useSqlJs = true;
+}
 
-  // This is the key part for OPFS support
-  // It instructs SQLite to use the OPFS VFS.
-  db = new sqlite3.oo1.DB("file:database.db?vfs=opfs", "c");
+function execSqlJs(sql, params) {
+  const stmt = db.prepare(sql);
+  if (params && params.length) {
+    stmt.bind(params);
+  }
+  const rows = [];
+  while (stmt.step()) {
+    rows.push(stmt.get());
+  }
+  stmt.free();
+  return rows;
 }
 
 function handleMessage() {
@@ -19,25 +63,35 @@ function handleMessage() {
         throw new Error("exec: Missing query string");
       }
 
+      if (useSqlJs) {
+        return postMessage({
+          id: data.id,
+          results: { values: execSqlJs(data.sql, data.params) },
+        });
+      }
+
       return postMessage({
         id: data.id,
         results: { values: db.exec({ sql: data.sql, bind: data.params, returnValue: "resultRows" }) },
-      })
+      });
     case "begin_transaction":
-      return postMessage({
-        id: data.id,
-        results: db.exec("BEGIN TRANSACTION;"),
-      })
+      if (useSqlJs) {
+        db.exec("BEGIN TRANSACTION;");
+        return postMessage({ id: data.id, results: [] });
+      }
+      return postMessage({ id: data.id, results: db.exec("BEGIN TRANSACTION;") });
     case "end_transaction":
-      return postMessage({
-        id: data.id,
-        results: db.exec("END TRANSACTION;"),
-      })
+      if (useSqlJs) {
+        db.exec("END TRANSACTION;");
+        return postMessage({ id: data.id, results: [] });
+      }
+      return postMessage({ id: data.id, results: db.exec("END TRANSACTION;") });
     case "rollback_transaction":
-      return postMessage({
-        id: data.id,
-        results: db.exec("ROLLBACK TRANSACTION;"),
-      })
+      if (useSqlJs) {
+        db.exec("ROLLBACK TRANSACTION;");
+        return postMessage({ id: data.id, results: [] });
+      }
+      return postMessage({ id: data.id, results: db.exec("ROLLBACK TRANSACTION;") });
     default:
       throw new Error(`Unsupported action: ${data && data.action}`);
   }