Test the remaining CLI cases (closes #16)

Most of the command-line contract was already tested through run. This
adds what was missing: report and trees with no database exit 1 with
the message telling the user to run scan; a scan that skips an
unreadable file prints its warning and counts the skip in its summary;
the report and trees summary lines are checked exactly. The fatal-path
test now takes its subcommands from the command tree, so a new
subcommand wired without runE fails it. The nonexistent-operand test
gets an accurate name.

Model: opus-5-5

TODO.md

@@ -29,9 +29,9 @@
 
 # Completed Steps
 
-- tests cover a missing database, `scan` keeping stdout empty, its skip
+- tests cover a missing database, the `scan` skip warning, the `report`
-  warning, the `report` and `trees` summary lines, and every subcommand
+  and `trees` summary lines, and every subcommand going through `runE`
-  going through `runE` (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/16)
+  (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/16)
 
 - `.golangci.yml` replaced with the current canonical copy, which uses
   `gomodguard_v2`, so lint no longer prints a deprecation warning

cancel_test.go

@@ -344,14 +344,13 @@ func storedPaths(t *testing.T, path string) []string {
 
 // TestRunScanInterrupted calls the scan entrypoint with a context that
 // is already cancelled, as when a signal arrives at once. It must return
-// errInterrupted promptly with its one line on stderr and nothing on
+// errInterrupted promptly with its one line on stderr, leave the
-// stdout, leave the database valid and as it was, and leave nothing in
+// database valid and as it was, and leave nothing in the way of the
-// the way of the next scan, which must bring the database up to date.
+// next scan, which must bring the database up to date.
 func TestRunScanInterrupted(t *testing.T) {
 	path := testDBPath(t)
 	t.Setenv(databaseEnv, path)
 
-	stdout := captureStdout(t)
 	stderr := captureStderr(t)
 	dir := buildSmokeTree(t)
 
@@ -394,10 +393,6 @@ func TestRunScanInterrupted(t *testing.T) {
 		t.Errorf("stderr = %q, want %q", got, want)
 	}
 
-	if got := stdout(); got != "" {
-		t.Errorf("stdout = %q, want nothing (data only)", got)
-	}
-
 	assertNoSidecars(t, path)
 
 	if got := storedPaths(t, path); !slices.Equal(got, before) {
@@ -420,13 +415,12 @@ func TestRunScanInterrupted(t *testing.T) {
 // TestRunScanInterruptedMidHash interrupts the scan entrypoint part-way
 // through its hash phase, after the database is open. It must return
 // errInterrupted, release the lock, end stderr with its line counting
-// every file the walk reached, write nothing to stdout, close the
+// every file the walk reached, close the database out of WAL mode, and
-// database out of WAL mode, and keep the records it hashed.
+// keep the records it hashed.
 func TestRunScanInterruptedMidHash(t *testing.T) {
 	path := testDBPath(t)
 	t.Setenv(databaseEnv, path)
 
-	stdout := captureStdout(t)
 	stderr := captureStderr(t)
 	dir := buildWalkCancelTree(t)
 
@@ -444,10 +438,6 @@ func TestRunScanInterruptedMidHash(t *testing.T) {
 		t.Errorf("stderr = %q, want it to end with %q", got, want)
 	}
 
-	if got := stdout(); got != "" {
-		t.Errorf("stdout = %q, want nothing (data only)", got)
-	}
-
 	assertNoSidecars(t, path)
 
 	db, err := openReportDatabase(t.Context(), path)

main_test.go

@@ -91,35 +91,16 @@ func makeReadOnly(t *testing.T, path string) {
 func captureStderr(t *testing.T) func() string {
 	t.Helper()
 
-	return capture(t, &os.Stderr)
+	f, err := os.Create(filepath.Join(t.TempDir(), "stderr"))
-}
-
-// captureStdout does for os.Stdout what captureStderr does for
-// os.Stderr. scan is never given run's stdout writer, so anything it
-// printed would go straight to os.Stdout. The scan tests pass os.Stdout
-// as run's stdout too, so the one capture sees both.
-func captureStdout(t *testing.T) func() string {
-	t.Helper()
-
-	return capture(t, &os.Stdout)
-}
-
-// capture redirects *std, which is os.Stdout or os.Stderr, to a file
-// for the rest of the test and returns a function reading back
-// everything written to it.
-func capture(t *testing.T, std **os.File) func() string {
-	t.Helper()
-
-	f, err := os.Create(filepath.Join(t.TempDir(), "output"))
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	saved := *std
+	saved := os.Stderr
-	*std = f
+	os.Stderr = f
 
 	t.Cleanup(func() {
-		*std = saved
+		os.Stderr = saved
 
 		_ = f.Close()
 	})
@@ -220,17 +201,15 @@ func TestRunFatalAfterOpenClosesDatabase(t *testing.T) {
 				args = append(args, t.TempDir())
 			}
 
-			stdout := captureStdout(t)
+			var stdout, stderr bytes.Buffer
 
-			var stderr bytes.Buffer
+			code := run(args, &stdout, &stderr)
-
-			code := run(args, os.Stdout, &stderr)
 			if code != exitFatal {
 				t.Errorf("run(%v) = %d, want %d", args, code, exitFatal)
 			}
 
 			assertNoSidecars(t, path)
-			assertFatalOutput(t, stderr.String(), stdout())
+			assertFatalOutput(t, stderr.String(), stdout.String())
 
 			// Proof that the failure happened after the open: only a
 			// query against the opened database can report this.
@@ -248,18 +227,16 @@ func TestRunNonexistentPathIsFatalNotUsage(t *testing.T) {
 	// must not dump the usage text.
 	t.Setenv(databaseEnv, testDBPath(t))
 
-	stdout := captureStdout(t)
+	var stdout, stderr bytes.Buffer
-
-	var stderr bytes.Buffer
 
 	missing := filepath.Join(t.TempDir(), "nope")
 
-	code := run([]string{cmdScan, missing}, os.Stdout, &stderr)
+	code := run([]string{cmdScan, missing}, &stdout, &stderr)
 	if code != exitFatal {
 		t.Errorf("run(scan %s) = %d, want %d", missing, code, exitFatal)
 	}
 
-	assertFatalOutput(t, stderr.String(), stdout())
+	assertFatalOutput(t, stderr.String(), stdout.String())
 }
 
 // assertFatalOutput checks that a fatal error was reported the way
@@ -488,16 +465,17 @@ func scanFixture(t *testing.T) []string {
 func scanOK(t *testing.T, operands ...string) string {
 	t.Helper()
 
-	stdout := captureStdout(t)
+	var stdout bytes.Buffer
+
 	stderr := captureStderr(t)
 
-	code := run(append([]string{cmdScan}, operands...), os.Stdout, os.Stderr)
+	code := run(append([]string{cmdScan}, operands...), &stdout, os.Stderr)
 	if code != exitOK {
 		t.Fatalf("run(scan %q) = %d, want %d; stderr: %s",
 			operands, code, exitOK, stderr())
 	}
 
-	if got := stdout(); got != "" {
+	if got := stdout.String(); got != "" {
 		t.Errorf("scan stdout = %q, want nothing (data only)", got)
 	}
 
@@ -829,11 +807,9 @@ func TestRunSecondScanFails(t *testing.T) {
 
 	holdScanLock(t, path)
 
-	stdout := captureStdout(t)
+	var stdout, stderr bytes.Buffer
 
-	var stderr bytes.Buffer
+	code := run([]string{cmdScan, t.TempDir()}, &stdout, &stderr)
-
-	code := run([]string{cmdScan, t.TempDir()}, os.Stdout, &stderr)
 	if code != exitFatal {
 		t.Errorf("run(scan) = %d, want %d", code, exitFatal)
 	}
@@ -844,7 +820,7 @@ func TestRunSecondScanFails(t *testing.T) {
 		t.Errorf("stderr = %q, want %q", got, want)
 	}
 
-	if got := stdout(); got != "" {
+	if got := stdout.String(); got != "" {
 		t.Errorf("stdout = %q, want nothing (data only)", got)
 	}