test(cli): cover ViewCommand, TuiCommand, IoWorker

ViewCommand/TuiCommand: pin the pre-terminal control paths — wrong arity
(USAGE_ERROR), missing local file and malformed URL (both FILE_NOT_FOUND).
The TUI happy path needs a real terminal and stays covered by the TUI tests.

IoWorker: cover the executor contract with no I/O — tasks run on the worker
thread, runAndAwait flushes prior submits in FIFO order, a throwing task does
not kill the loop, submit after close is dropped, and close is idempotent.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dfa1

cli/src/test/java/io/github/dfa1/vortex/cli/TuiCommandTest.java

@@ -0,0 +1,53 @@
+package io.github.dfa1.vortex.cli;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Path;
+
+import static io.github.dfa1.vortex.cli.CliTestSupport.capture;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/// Covers the non-TUI control paths of `tui` — the happy path needs a real terminal
+/// and is exercised by the TUI tests; here we pin the argument/open failures that return
+/// before any terminal is touched.
+class TuiCommandTest {
+
+    @Test
+    void wrongArity_returnsUsageError() {
+        // Given / When — only the subcommand name, no target
+        CliTestSupport.Captured result = capture(() -> TuiCommand.run(new String[]{"tui"}));
+
+        // Then
+        assertThat(result.status()).isEqualTo(ExitStatus.USAGE_ERROR);
+        assertThat(result.stderr()).contains("usage:");
+    }
+
+    @Test
+    void missingFile_returnsFileNotFound(@TempDir Path tmp) {
+        // Given — a path that does not exist
+        Path missing = tmp.resolve("nope.vortex");
+
+        // When
+        CliTestSupport.Captured result = capture(() ->
+                TuiCommand.run(new String[]{"tui", missing.toString()}));
+
+        // Then — open() returns null on a missing local file, run() maps that to FILE_NOT_FOUND
+        assertThat(result.status()).isEqualTo(ExitStatus.FILE_NOT_FOUND);
+        assertThat(result.stderr()).contains("file not found");
+    }
+
+    @Test
+    void malformedUrl_returnsFileNotFound() {
+        // Given — http(s) prefix forces URI parsing; the space makes it syntactically invalid
+        String badUrl = "http://a b";
+
+        // When
+        CliTestSupport.Captured result = capture(() ->
+                TuiCommand.run(new String[]{"tui", badUrl}));
+
+        // Then — URISyntaxException is caught and reported as a null handle
+        assertThat(result.status()).isEqualTo(ExitStatus.FILE_NOT_FOUND);
+        assertThat(result.stderr()).contains("invalid URL");
+    }
+}

cli/src/test/java/io/github/dfa1/vortex/cli/ViewCommandTest.java

@@ -0,0 +1,53 @@
+package io.github.dfa1.vortex.cli;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Path;
+
+import static io.github.dfa1.vortex.cli.CliTestSupport.capture;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/// Covers the non-TUI control paths of `view` — the happy path needs a real terminal
+/// and is exercised by the TUI tests; here we pin the argument/open failures that return
+/// before any terminal is touched.
+class ViewCommandTest {
+
+    @Test
+    void wrongArity_returnsUsageError() {
+        // Given / When — only the subcommand name, no target
+        CliTestSupport.Captured result = capture(() -> ViewCommand.run(new String[]{"view"}));
+
+        // Then
+        assertThat(result.status()).isEqualTo(ExitStatus.USAGE_ERROR);
+        assertThat(result.stderr()).contains("usage:");
+    }
+
+    @Test
+    void missingFile_returnsFileNotFound(@TempDir Path tmp) {
+        // Given — a path that does not exist
+        Path missing = tmp.resolve("nope.vortex");
+
+        // When
+        CliTestSupport.Captured result = capture(() ->
+                ViewCommand.run(new String[]{"view", missing.toString()}));
+
+        // Then — open() returns null on a missing local file, run() maps that to FILE_NOT_FOUND
+        assertThat(result.status()).isEqualTo(ExitStatus.FILE_NOT_FOUND);
+        assertThat(result.stderr()).contains("file not found");
+    }
+
+    @Test
+    void malformedUrl_returnsFileNotFound() {
+        // Given — http(s) prefix forces URI parsing; the space makes it syntactically invalid
+        String badUrl = "http://a b";
+
+        // When
+        CliTestSupport.Captured result = capture(() ->
+                ViewCommand.run(new String[]{"view", badUrl}));
+
+        // Then — URISyntaxException is caught and reported as a null handle
+        assertThat(result.status()).isEqualTo(ExitStatus.FILE_NOT_FOUND);
+        assertThat(result.stderr()).contains("invalid URL");
+    }
+}

cli/src/test/java/io/github/dfa1/vortex/cli/tui/IoWorkerTest.java

@@ -0,0 +1,103 @@
+package io.github.dfa1.vortex.cli.tui;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+
+/// Exercises the single-thread executor contract without any file I/O: tasks run on the
+/// worker thread, `runAndAwait` flushes prior `submit`s in order, a throwing task does not
+/// kill the loop, and `close()` stops accepting work.
+class IoWorkerTest {
+
+    @Test
+    void runAndAwait_runsTaskOnTheWorkerThread() throws InterruptedException {
+        // Given
+        try (IoWorker sut = new IoWorker("test-io")) {
+            AtomicReference<Thread> ranOn = new AtomicReference<>();
+
+            // When
+            sut.runAndAwait(() -> ranOn.set(Thread.currentThread()));
+
+            // Then — the task executed off the caller thread, on the named worker
+            assertThat(ranOn.get()).isNotNull().isNotSameAs(Thread.currentThread());
+            assertThat(ranOn.get().getName()).isEqualTo("test-io");
+        }
+    }
+
+    @Test
+    void pending_isZeroAfterTaskCompletes() throws InterruptedException {
+        // Given
+        try (IoWorker sut = new IoWorker("test-io")) {
+            // When
+            sut.runAndAwait(() -> { });
+
+            // Then — the finally block decremented the in-flight counter
+            assertThat(sut.pending()).isZero();
+        }
+    }
+
+    @Test
+    void submit_runsTasksInFifoOrder() throws InterruptedException {
+        // Given — a blocking runAndAwait at the end flushes the two prior submits
+        try (IoWorker sut = new IoWorker("test-io")) {
+            List<Integer> order = new CopyOnWriteArrayList<>();
+
+            // When
+            sut.submit(() -> order.add(1));
+            sut.submit(() -> order.add(2));
+            sut.runAndAwait(() -> order.add(3));
+
+            // Then
+            assertThat(order).containsExactly(1, 2, 3);
+            assertThat(sut.pending()).isZero();
+        }
+    }
+
+    @Test
+    void submit_throwingTask_doesNotKillTheWorker() throws InterruptedException {
+        // Given — the loop must swallow a task's RuntimeException and keep draining
+        try (IoWorker sut = new IoWorker("test-io")) {
+            sut.submit(() -> {
+                throw new IllegalStateException("boom");
+            });
+            AtomicBoolean laterRan = new AtomicBoolean(false);
+
+            // When
+            sut.runAndAwait(() -> laterRan.set(true));
+
+            // Then — the subsequent task still executed
+            assertThat(laterRan).isTrue();
+        }
+    }
+
+    @Test
+    void submitAfterClose_isDroppedAndDoesNotCount() {
+        // Given
+        IoWorker sut = new IoWorker("test-io");
+        sut.close();
+        AtomicBoolean ran = new AtomicBoolean(false);
+
+        // When — submit observes the volatile closed flag and returns early
+        sut.submit(() -> ran.set(true));
+
+        // Then — nothing enqueued, nothing counted
+        assertThat(sut.pending()).isZero();
+        assertThat(ran).isFalse();
+    }
+
+    @Test
+    void close_isIdempotent() {
+        // Given
+        IoWorker sut = new IoWorker("test-io");
+
+        // When / Then
+        sut.close();
+        assertThatCode(sut::close).doesNotThrowAnyException();
+    }
+}