test: cover proxy handlers, entrypoint parsing, logger and checksum paths (#929)

* test: cover proxy handlers, entrypoint parsing, logger and checksum paths

Raises runner package coverage from 82.5% to 85.7% by testing paths that
had none:

- proxy: worker script handler, Reload/BuildFailed delegation, Stop, the
  non-flusher and bad-request branches of the proxy/reload handlers, and
  streamCopy write/short-write errors
- entrypoint.UnmarshalTOML: nil, string, array, and both error cases
- logger: raw logger fallback, color fallback, silent/empty/add-time
- engine: cacheFileChecksums exclusion rules and primeChecksum on an
  unreadable file, isExcludeFile patterns
- config: buildDelay and rerunDelay
- flag: appendableValue String/Set semantics

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

* test: use string pattern for assert.Regexp

golangci-lint (testifylint) rejects regexp.MustCompile inside
assert.Regexp, which accepts the pattern directly.

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

* test: make exclude_file pattern separator-aware on Windows

isExcludeFile matches with filepath.Match against a path cleaned with the
platform separator, so a "docs/*.md" pattern never matches on Windows.

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

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: xiantang

runner/config_test.go

@@ -313,6 +313,22 @@ func TestReadConfigWithWrongPath(t *testing.T) {
 	}
 }
 
+func TestBuildAndRerunDelay(t *testing.T) {
+	t.Parallel()
+	config := Config{
+		Build: cfgBuild{
+			Delay:      300,
+			RerunDelay: 700,
+		},
+	}
+	if got, want := config.buildDelay(), 300*time.Millisecond; got != want {
+		t.Fatalf("buildDelay() = %v, want %v", got, want)
+	}
+	if got, want := config.rerunDelay(), 700*time.Millisecond; got != want {
+		t.Fatalf("rerunDelay() = %v, want %v", got, want)
+	}
+}
+
 func TestKillDelay(t *testing.T) {
 	t.Parallel()
 	config := Config{

runner/engine_checksum_test.go

@@ -0,0 +1,117 @@
+package runner
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// writeFile creates path (including parents) with the given contents.
+func writeFile(t *testing.T, path, contents string) {
+	t.Helper()
+	require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
+	require.NoError(t, os.WriteFile(path, []byte(contents), 0o644))
+}
+
+func TestEngineCacheFileChecksums(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	writeFile(t, filepath.Join(tmpDir, "main.go"), "package main\n")
+	writeFile(t, filepath.Join(tmpDir, "internal", "app.go"), "package internal\n")
+	writeFile(t, filepath.Join(tmpDir, "README.md"), "docs\n")           // extension not watched
+	writeFile(t, filepath.Join(tmpDir, "skip.go"), "package skip\n")     // exclude_file
+	writeFile(t, filepath.Join(tmpDir, "app_test.go"), "package main\n") // exclude_regex
+	writeFile(t, filepath.Join(tmpDir, "tmp", "main.go"), "package tmp\n")
+	writeFile(t, filepath.Join(tmpDir, "vendor", "dep.go"), "package dep\n")
+	writeFile(t, filepath.Join(tmpDir, ".hidden", "hidden.go"), "package hidden\n")
+
+	cfg := defaultConfig()
+	cfg.Root = tmpDir
+	cfg.TmpDir = "tmp"
+	cfg.Build.IncludeExt = []string{"go"}
+	cfg.Build.ExcludeDir = []string{"vendor"}
+	cfg.Build.ExcludeFile = []string{"skip.go"}
+	cfg.Build.ExcludeRegex = []string{"_test.go"}
+	require.NoError(t, cfg.preprocess(nil))
+
+	engine, err := NewEngineWithConfig(&cfg, false)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = engine.watcher.Close() })
+
+	require.NoError(t, engine.cacheFileChecksums(cfg.Root))
+
+	cached := func(rel string) bool {
+		path := filepath.Join(cfg.Root, rel)
+		checksum, err := fileChecksum(path)
+		require.NoError(t, err)
+		// updateFileChecksum reports false when the checksum is already stored.
+		return !engine.fileChecksums.updateFileChecksum(path, checksum)
+	}
+
+	assert.True(t, cached("main.go"), "watched file should be cached")
+	assert.True(t, cached(filepath.Join("internal", "app.go")), "watched file in subdir should be cached")
+
+	assert.False(t, cached("README.md"), "unwatched extension should not be cached")
+	assert.False(t, cached("skip.go"), "exclude_file match should not be cached")
+	assert.False(t, cached("app_test.go"), "exclude_regex match should not be cached")
+	assert.False(t, cached(filepath.Join("vendor", "dep.go")), "exclude_dir content should not be cached")
+	assert.False(t, cached(filepath.Join(".hidden", "hidden.go")), "hidden dir content should not be cached")
+}
+
+func TestEngineCacheFileChecksumsMissingRoot(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	cfg := defaultConfig()
+	cfg.Root = tmpDir
+	require.NoError(t, cfg.preprocess(nil))
+
+	engine, err := NewEngineWithConfig(&cfg, false)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = engine.watcher.Close() })
+
+	assert.Error(t, engine.cacheFileChecksums(filepath.Join(tmpDir, "does-not-exist")))
+}
+
+func TestEnginePrimeChecksumIgnoresUnreadableFile(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	cfg := defaultConfig()
+	cfg.Root = tmpDir
+	require.NoError(t, cfg.preprocess(nil))
+
+	engine, err := NewEngineWithConfig(&cfg, false)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = engine.watcher.Close() })
+
+	missing := filepath.Join(tmpDir, "gone.go")
+	engine.primeChecksum(missing)
+
+	// Nothing was stored, so the first real update reports a change.
+	writeFile(t, missing, "package main\n")
+	checksum, err := fileChecksum(missing)
+	require.NoError(t, err)
+	assert.True(t, engine.fileChecksums.updateFileChecksum(missing, checksum))
+}
+
+func TestEngineIsExcludeFile(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	cfg := defaultConfig()
+	cfg.Root = tmpDir
+	// isExcludeFile matches with filepath.Match, so the directory pattern has
+	// to use the platform separator to match on Windows too.
+	cfg.Build.ExcludeFile = []string{"skip.go", filepath.Join("docs", "*.md")}
+	require.NoError(t, cfg.preprocess(nil))
+
+	engine, err := NewEngineWithConfig(&cfg, false)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = engine.watcher.Close() })
+
+	assert.True(t, engine.isExcludeFile(filepath.Join(cfg.Root, "skip.go")))
+	assert.True(t, engine.isExcludeFile(filepath.Join(cfg.Root, "docs", "readme.md")))
+	assert.False(t, engine.isExcludeFile(filepath.Join(cfg.Root, "main.go")))
+	assert.False(t, engine.isExcludeFile(filepath.Join(cfg.Root, "docs", "nested", "readme.md")))
+}

runner/entrypoint_test.go

@@ -0,0 +1,85 @@
+package runner
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEntrypointUnmarshalTOML(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		value   interface{}
+		want    entrypoint
+		wantErr string
+	}{
+		{
+			name:  "nil clears the entrypoint",
+			value: nil,
+			want:  nil,
+		},
+		{
+			name:  "string becomes a single element",
+			value: "./tmp/main",
+			want:  entrypoint{"./tmp/main"},
+		},
+		{
+			name:  "array keeps binary and args",
+			value: []interface{}{"./tmp/main", "server", ":8080"},
+			want:  entrypoint{"./tmp/main", "server", ":8080"},
+		},
+		{
+			name:  "empty array yields an empty entrypoint",
+			value: []interface{}{},
+			want:  entrypoint{},
+		},
+		{
+			name:    "non-string array element is rejected",
+			value:   []interface{}{"./tmp/main", 42},
+			wantErr: "entrypoint values must be strings, got int",
+		},
+		{
+			name:    "unsupported type is rejected",
+			value:   42,
+			wantErr: "entrypoint must be a string or array of strings, got int",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			// Start from a non-empty value so nil is seen to clear it.
+			e := entrypoint{"stale"}
+			err := e.UnmarshalTOML(tt.value)
+
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, e)
+		})
+	}
+}
+
+func TestEntrypointBinaryAndArgs(t *testing.T) {
+	t.Parallel()
+
+	var empty entrypoint
+	assert.Empty(t, empty.binary())
+	assert.Nil(t, empty.args())
+
+	single := entrypoint{"./tmp/main"}
+	assert.Equal(t, "./tmp/main", single.binary())
+	assert.Nil(t, single.args())
+
+	withArgs := entrypoint{"./tmp/main", "server", ":8080"}
+	assert.Equal(t, "./tmp/main", withArgs.binary())
+	assert.Equal(t, []string{"server", ":8080"}, withArgs.args())
+}

runner/flag_value_test.go

@@ -0,0 +1,70 @@
+package runner
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAppendableValueString(t *testing.T) {
+	t.Parallel()
+
+	var nilValue *appendableValue
+	assert.Empty(t, nilValue.String(), "nil receiver should stringify to empty")
+
+	assert.Empty(t, (&appendableValue{}).String(), "nil target should stringify to empty")
+
+	s := "a,b"
+	assert.Equal(t, "a,b", (&appendableValue{p: &s}).String())
+}
+
+func TestAppendableValueSet(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		initial string
+		sets    []string
+		want    string
+	}{
+		{
+			name:    "first set replaces the default",
+			initial: "default",
+			sets:    []string{"a"},
+			want:    "a",
+		},
+		{
+			name:    "later sets append",
+			initial: "default",
+			sets:    []string{"a", "b,c"},
+			want:    "a" + sliceCmdArgSeparator + "b,c",
+		},
+		{
+			name:    "empty append is ignored",
+			initial: "default",
+			sets:    []string{"a", ""},
+			want:    "a",
+		},
+		{
+			name:    "append onto an emptied value does not add a separator",
+			initial: "default",
+			sets:    []string{"", "b"},
+			want:    "b",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			target := tt.initial
+			v := &appendableValue{p: &target}
+			for _, s := range tt.sets {
+				require.NoError(t, v.Set(s))
+			}
+			assert.Equal(t, tt.want, target)
+			assert.Equal(t, tt.want, v.String())
+		})
+	}
+}

runner/logger_extra_test.go

@@ -0,0 +1,89 @@
+package runner
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/fatih/color"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// captureColorOutput redirects the writer fatih/color logs to, so colored log
+// lines can be asserted on instead of leaking into the test output.
+func captureColorOutput(t *testing.T) *bytes.Buffer {
+	t.Helper()
+	var buf bytes.Buffer
+	orig := color.Error
+	origNoColor := color.NoColor
+	color.Error = &buf
+	color.NoColor = true
+	t.Cleanup(func() {
+		color.Error = orig
+		color.NoColor = origNoColor
+	})
+	return &buf
+}
+
+func TestGetColorFallsBackToWhite(t *testing.T) {
+	t.Parallel()
+
+	assert.Equal(t, color.FgRed, getColor("red"))
+	assert.Equal(t, color.FgWhite, getColor("white"))
+	assert.Equal(t, color.FgWhite, getColor("not-a-color"))
+}
+
+func TestGetLoggerFallsBackToRawLogger(t *testing.T) {
+	// Not parallel: captureColorOutput swaps package-level color state.
+	buf := captureColorOutput(t)
+
+	cfg := defaultConfig()
+	l := newLogger(&cfg)
+	require.NotNil(t, l)
+
+	// Known names come from the configured loggers.
+	assert.NotNil(t, l.main())
+	assert.NotNil(t, l.build())
+	assert.NotNil(t, l.runner())
+	assert.NotNil(t, l.watcher())
+
+	// An unknown name falls back to the raw logger, which still logs.
+	l.getLogger("no-such-logger")("fallback message")
+	assert.NotNil(t, rawLogger())
+	assert.Empty(t, buf.String(), "raw logger should not write through color.Error")
+}
+
+func TestNewLogFuncSilentSkipsOutput(t *testing.T) {
+	buf := captureColorOutput(t)
+
+	logFn := newLogFunc("white", cfgLog{Silent: true})
+	logFn("should not be printed")
+
+	assert.Empty(t, buf.String())
+}
+
+func TestNewLogFuncSkipsEmptyMessage(t *testing.T) {
+	buf := captureColorOutput(t)
+
+	logFn := newLogFunc("white", cfgLog{})
+	logFn("   \n  ")
+
+	assert.Empty(t, buf.String())
+}
+
+func TestNewLogFuncAddsTime(t *testing.T) {
+	buf := captureColorOutput(t)
+
+	logFn := newLogFunc("white", cfgLog{AddTime: true})
+	logFn("hello %s", "air")
+
+	out := buf.String()
+	assert.Contains(t, out, "hello air")
+	assert.Regexp(t, `^\[\d{2}:\d{2}:\d{2}\] `, out)
+}
+
+func TestNewLoggerReturnsNilWithoutConfig(t *testing.T) {
+	t.Parallel()
+
+	assert.Nil(t, newLogger(nil))
+}