Coverage round 2 batch C: AppState-constructible tests, dialog states, project load/export

build.gradle.kts

@@ -151,9 +151,9 @@ registerTestSubset(
 koverReport {
     defaults {
         verify {
-            // Guards against coverage regressions; raise the bound as coverage grows (baseline: 59% on 2026-07-09).
+            // Guards against coverage regressions; raise the bound as coverage grows (baseline: 61% on 2026-07-10).
             rule("Minimal line coverage") {
-                minBound(56)
+                minBound(59)
             }
         }
     }

docs/testing.md

@@ -108,6 +108,8 @@ Notes:
 - Screen-level dialogs wrapped in an AWT `DialogWindow` (e.g. `PluginDialog`, `ColorPickerDialog`) do not mount in
   `runComposeUiTest`; test their inner content composable or drive the flow through the public state holder instead.
 
+A real `AppState` can be built in tests via `testutil.TestAppState.create(scope)`, which injects a `testutil.FakeIpcState` (the `AppState` constructor takes an IPC-state factory so no local port is bound) and collaborators that avoid network/audio. Prefer this over reflection for app-level glue and dialog-state tests; see `ui/AppStateConstructionTest.kt`.
+
 State-holder classes (`ui/ProjectStore.kt`, `AppErrorState`, dialog states, ...) are plain classes over Compose
 `mutableStateOf` and are tested without rendering — see `ui/ProjectStoreTest.kt`, which drives the real
 implementations against fixture projects. For classes that require an `AppState` (which cannot be constructed in

src/jvmMain/kotlin/com/sdercolin/vlabeler/ipc/IpcState.kt

@@ -12,9 +12,16 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 
 /**
- * State for Inter-Process Communication.
+ * State for Inter-Process Communication. Tests provide a fake implementation so that no local port is bound.
  */
-class IpcState(private val appState: AppState) {
+interface IpcState {
+    fun close()
+}
+
+/**
+ * The real [IpcState], backed by a ZeroMQ server bound to a fixed local port (see [IpcServer]).
+ */
+class IpcStateImpl(private val appState: AppState) : IpcState {
 
     private val server = IpcServer(appState.mainScope)
 
@@ -41,7 +48,7 @@ class IpcState(private val appState: AppState) {
         response(response)
     }
 
-    fun close() {
+    override fun close() {
         server.close()
     }
 }

src/jvmMain/kotlin/com/sdercolin/vlabeler/ui/AppState.kt

@@ -21,6 +21,7 @@ import com.sdercolin.vlabeler.io.loadProject
 import com.sdercolin.vlabeler.io.openCreatedProject
 import com.sdercolin.vlabeler.io.saveProjectFile
 import com.sdercolin.vlabeler.ipc.IpcState
+import com.sdercolin.vlabeler.ipc.IpcStateImpl
 import com.sdercolin.vlabeler.ipc.request.OpenOrCreateRequest
 import com.sdercolin.vlabeler.model.AppConf
 import com.sdercolin.vlabeler.model.AppRecord
@@ -103,6 +104,10 @@ class AppState(
     snackbarState: AppSnackbarState = AppSnackbarStateImpl(snackbarHostState),
     dialogState: AppDialogState = AppDialogStateImpl(unsavedChangesState, projectStore, snackbarState),
     updaterState: AppUpdaterState = AppUpdaterStateImpl(appConf, snackbarState, dialogState, appRecordStore, mainScope),
+    // Factory for the IPC state. It needs the fully-constructed AppState, so it is passed as a factory rather than a
+    // value. The default builds the real IPC server (which binds a fixed local port); tests pass a factory that
+    // returns a fake [IpcState] so no port is bound.
+    ipcStateFactory: (AppState) -> IpcState = { IpcStateImpl(it) },
 ) : AppErrorState by errorState,
     AppViewState by viewState,
     AppScreenState by screenState,
@@ -135,7 +140,7 @@ class AppState(
         errorState,
     ) { toggleVideoPopup(false) }
 
-    private val ipcState: IpcState = IpcState(this)
+    private val ipcState: IpcState = ipcStateFactory(this)
     val trackingState = TrackingState(appRecordStore, mainScope)
 
     fun validate() {

src/jvmTest/kotlin/io/ExportProjectTest.kt

@@ -0,0 +1,99 @@
+package io
+
+import com.sdercolin.vlabeler.env.Log
+import com.sdercolin.vlabeler.io.exportProject
+import com.sdercolin.vlabeler.io.exportProjectModule
+import com.sdercolin.vlabeler.io.singleModuleToRawLabels
+import com.sdercolin.vlabeler.model.Project
+import com.sdercolin.vlabeler.ui.AppState
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.runBlocking
+import testutil.TestEnv
+import testutil.TestFixtures
+import testutil.TestLabelers
+import testutil.createTestProject
+import java.io.File
+import kotlin.io.path.createTempDirectory
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * Tests for [ProjectStore.exportProject] and [ProjectStore.exportProjectModule]: the raw label file written by the
+ * labeler writer, and the creation of missing output directories.
+ */
+class ExportProjectTest {
+
+    private lateinit var tempDir: File
+    private lateinit var sampleDir: File
+    private lateinit var scope: CoroutineScope
+    private lateinit var appState: AppState
+
+    @BeforeTest
+    fun setup() {
+        Log.muted = true
+        TestEnv.ensureLogDirectory()
+        scope = CoroutineScope(SupervisorJob())
+        tempDir = createTempDirectory("vlabeler-test").toFile()
+        sampleDir = TestFixtures.deploy(
+            "oto",
+            tempDir.resolve("oto"),
+            wavFiles = listOf("_a_ka.wav"),
+        )
+        appState = testutil.TestAppState.create(scope = scope)
+    }
+
+    @AfterTest
+    fun teardown() {
+        scope.cancel()
+        Log.muted = false
+        tempDir.deleteRecursively()
+    }
+
+    private fun createProject(): Project = createTestProject(
+        labeler = TestLabelers.utauOto,
+        sampleDirectory = sampleDir,
+        inputFilePath = sampleDir.resolve("oto.ini").absolutePath,
+    )
+
+    @Test
+    fun testExportProjectModuleWritesRawLabels() {
+        val project = createProject()
+        val output = tempDir.resolve("out/exported.ini")
+
+        runBlocking { appState.exportProjectModule(project, moduleIndex = 0, outputFile = output) }
+
+        // parent directory is created on demand
+        assertTrue(output.parentFile.isDirectory)
+        val expected = project.singleModuleToRawLabels(0)
+        assertEquals(expected, output.readText())
+        assertTrue(output.readText().isNotBlank())
+    }
+
+    @Test
+    fun testExportProjectWritesToModuleRawFile() {
+        val project = createProject()
+        val rawFile = requireNotNull(project.modules[0].getRawFile(project))
+
+        runBlocking { appState.exportProject(project) }
+
+        val expected = project.singleModuleToRawLabels(0)
+        assertEquals(expected, rawFile.readText())
+    }
+
+    @Test
+    fun testExportProjectSkipsModulesWithoutRawFile() {
+        // a module whose rawFilePath is null must be skipped without error
+        val project = createProject()
+        val withoutRaw = project.copy(
+            modules = project.modules.map { it.copy(rawFilePath = null) },
+        )
+
+        // no exception thrown and nothing written
+        runBlocking { appState.exportProject(withoutRaw) }
+    }
+}