Files
coder/scripts/develop/main_test.go
T
Thomas Kosiewski bf47fc68d9 feat: add a --bind-address flag to scripts/develop (#31815)
`scripts/develop.sh` always binds the API server, its metrics listener, the Vite dev server and the Prometheus UI container to `0.0.0.0`. On a shared or reachable host, anyone on the network can then reach a dev instance whose admin uses the published default password, or race the first-user setup on a new database.

This adds `--bind-address` (`CODER_DEV_BIND_ADDRESS`), which takes `0.0.0.0` (the default, unchanged behavior) or `127.0.0.1`. With `127.0.0.1`, all four listeners stay on loopback and the banner lists only `localhost`. Other addresses are refused, because develop's health check, the Vite proxy and the Prometheus scrape target reach the API on `127.0.0.1`. A running `coder-prometheus` container is reused only when it listens on the same address. Otherwise develop logs a warning and runs without the Prometheus UI, because that container usually belongs to another live run.

Workspaces in Docker containers, such as the `docker` starter template's, cannot reach a loopback-bound server, because their agents connect through `host.docker.internal`. The flag description and `.claude/docs/DEV_ISOLATION.md` say so.

The `verify-coder` skill in #31782 needs this. A review of that PR found the exposure, and this PR is its prerequisite.

Verification: `go test ./scripts/develop/` passes, with tests for the flag and env binding, validation, every listen address, the Vite `--host` argument (bare by default), the banner and the Prometheus reuse check. Reverting each of those turns a test red. A live `--bind-address 127.0.0.1` run listened on `127.0.0.1` only and refused connections on the host's network IPs. golangci-lint (full and new-code) is clean. I did not run the repo git hooks locally.

---
_Generated with [`xum`](https://github.com/coder/xum) • Model: `anthropic:claude-opus-5-5` • Thinking: `high`_
2026-11-06 04:26:44 +01:00

1020 lines
28 KiB
Go

//go:build !windows
package main
import (
"bytes"
"context"
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/xerrors"
"cdr.dev/slog/v3"
"cdr.dev/slog/v3/sloggers/sloghuman"
"github.com/coder/serpent"
)
func TestLogWriter(t *testing.T) {
t.Parallel()
t.Run("SingleLine", func(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
logger := slog.Make(sloghuman.Sink(&buf)).Named("test")
w := &logWriter{logger: logger}
_, err := w.Write([]byte("hello\n"))
require.NoError(t, err)
out := buf.String()
assert.Contains(t, out, "test:")
assert.Contains(t, out, "hello")
})
t.Run("MultiLine", func(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
logger := slog.Make(sloghuman.Sink(&buf)).Named("x")
w := &logWriter{logger: logger}
_, err := w.Write([]byte("a\nb\nc\n"))
require.NoError(t, err)
out := buf.String()
lines := strings.Split(strings.TrimSpace(out), "\n")
require.Len(t, lines, 3)
for _, line := range lines {
assert.Contains(t, line, "x:")
}
})
t.Run("PartialLine", func(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
logger := slog.Make(sloghuman.Sink(&buf)).Named("p")
w := &logWriter{logger: logger}
_, err := w.Write([]byte("no newline"))
require.NoError(t, err)
// Partial line should be buffered, not logged yet.
assert.Empty(t, buf.String())
})
t.Run("PartialThenNewline", func(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
logger := slog.Make(sloghuman.Sink(&buf)).Named("p")
w := &logWriter{logger: logger}
_, err := w.Write([]byte("hello"))
require.NoError(t, err)
assert.Empty(t, buf.String())
_, err = w.Write([]byte(" world\n"))
require.NoError(t, err)
assert.Contains(t, buf.String(), "hello world")
})
t.Run("EmptyLinesSkipped", func(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
logger := slog.Make(sloghuman.Sink(&buf)).Named("e")
w := &logWriter{logger: logger}
_, err := w.Write([]byte("\n\nfoo\n\n"))
require.NoError(t, err)
out := buf.String()
// Only "foo" should produce a log line.
lines := strings.Split(strings.TrimSpace(out), "\n")
assert.Len(t, lines, 1)
assert.Contains(t, lines[0], "foo")
})
t.Run("ConcurrentWrites", func(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
logger := slog.Make(sloghuman.Sink(&buf)).Named("c")
w := &logWriter{logger: logger}
var wg sync.WaitGroup
for range 10 {
wg.Go(func() {
for range 50 {
_, _ = w.Write([]byte("x\n"))
}
})
}
wg.Wait()
lines := strings.Split(strings.TrimSpace(buf.String()), "\n")
assert.Len(t, lines, 500)
for _, line := range lines {
assert.Contains(t, line, "c:")
assert.Contains(t, line, "x")
}
})
}
func TestFilterEnv(t *testing.T) {
t.Parallel()
env := []string{
"CODER_SESSION_TOKEN=secret",
"CODER_URL=https://example.com",
"KEEP_ME=yes",
"PATH=/usr/bin",
}
result := filterEnv(env, "CODER_SESSION_TOKEN", "CODER_URL")
for _, e := range result {
k, _, _ := strings.Cut(e, "=")
assert.NotEqual(t, "CODER_SESSION_TOKEN", k)
assert.NotEqual(t, "CODER_URL", k)
}
assert.Contains(t, result, "KEEP_ME=yes")
assert.Contains(t, result, "PATH=/usr/bin")
}
func TestShellBool(t *testing.T) {
t.Parallel()
assert.Equal(t, "1", shellBool(true))
assert.Equal(t, "0", shellBool(false))
}
func TestPortOffset(t *testing.T) {
t.Parallel()
root := "/tmp/coder/worktree-a"
offset := portOffset(root)
assert.Equal(t, offset, portOffset(root))
assert.GreaterOrEqual(t, offset, 0)
assert.Less(t, offset, 1000)
assert.Equal(t, 0, offset%10)
var foundDifferent bool
for _, otherRoot := range []string{
"/tmp/coder/worktree-b",
"/tmp/coder/worktree-c",
"/tmp/coder/worktree-d",
} {
if portOffset(otherRoot) != offset {
foundDifferent = true
break
}
}
assert.True(t, foundDifferent, "expected typical worktree paths to use different offsets")
}
func TestApplyPortOffsetSkipsExplicitPorts(t *testing.T) {
t.Parallel()
projectRoot := "/tmp/coder/worktree-offset"
for i := range 100 {
candidate := fmt.Sprintf("/tmp/coder/worktree-offset-%d", i)
if portOffset(candidate) != 0 {
projectRoot = candidate
break
}
}
offset := portOffset(projectRoot)
require.NotZero(t, offset)
cfg := &devConfig{
apiPort: 3000,
webPort: 8080,
proxyPort: 3010,
coderMetricsPort: 2114,
portOffsetEnabled: true,
projectRoot: projectRoot,
portExplicit: portExplicit{
web: true,
metrics: true,
},
}
cfg.applyPortOffset()
assert.Equal(t, int64(3000+offset), cfg.apiPort)
assert.Equal(t, int64(8080), cfg.webPort)
assert.Equal(t, int64(3010+offset), cfg.proxyPort)
assert.Equal(t, int64(2114), cfg.coderMetricsPort)
assert.Equal(t, portSourceOffset, cfg.apiPortSource)
assert.Equal(t, portSourceExplicit, cfg.webPortSource)
assert.Equal(t, portSourceOffset, cfg.proxyPortSource)
assert.Equal(t, portSourceExplicit, cfg.metricsPortSource)
}
func TestApplyPortOffsetDisabledUsesDefaultPorts(t *testing.T) {
t.Parallel()
projectRoot := "/tmp/coder/worktree-offset"
for i := range 100 {
candidate := fmt.Sprintf("/tmp/coder/worktree-offset-disabled-%d", i)
if portOffset(candidate) != 0 {
projectRoot = candidate
break
}
}
require.NotZero(t, portOffset(projectRoot))
cfg := &devConfig{
apiPort: 3000,
webPort: 8080,
proxyPort: 3010,
coderMetricsPort: 2114,
projectRoot: projectRoot,
}
cfg.applyPortOffset()
assert.Equal(t, int64(3000), cfg.apiPort)
assert.Equal(t, int64(8080), cfg.webPort)
assert.Equal(t, int64(3010), cfg.proxyPort)
assert.Equal(t, int64(2114), cfg.coderMetricsPort)
assert.Zero(t, cfg.portOffset)
assert.Empty(t, cfg.apiPortSource)
assert.Empty(t, cfg.webPortSource)
assert.Empty(t, cfg.proxyPortSource)
assert.Empty(t, cfg.metricsPortSource)
assert.Equal(t, "API: 3000", portBannerLine("API", cfg.apiPort, cfg.apiPortSource, cfg.portOffset))
}
func TestPortOffsetDefaultPortsDoNotOverlap(t *testing.T) {
t.Parallel()
ports := []struct {
name string
base int
}{
{name: "API", base: 3000},
{name: "Web UI", base: 8080},
{name: "Proxy", base: 3010},
{name: "Coder metrics", base: 2114},
}
seen := make(map[int]string)
for bucket := range portOffsetBuckets {
offset := bucket * portOffsetStep
for _, port := range ports {
effective := port.base + offset
if other, ok := seen[effective]; ok {
t.Fatalf("%s collides with %s on port %d", port.name, other, effective)
}
seen[effective] = fmt.Sprintf("%s with offset %d", port.name, offset)
}
}
}
func TestDevelopInCoder(t *testing.T) {
t.Run("DEVELOP_IN_CODER", func(t *testing.T) {
t.Setenv("DEVELOP_IN_CODER", "1")
t.Setenv("CODER_AGENT_URL", "")
assert.True(t, developInCoder())
})
t.Run("CODER_AGENT_URL", func(t *testing.T) {
t.Setenv("DEVELOP_IN_CODER", "")
t.Setenv("CODER_AGENT_URL", "http://something")
assert.True(t, developInCoder())
})
t.Run("Neither", func(t *testing.T) {
t.Setenv("DEVELOP_IN_CODER", "")
t.Setenv("CODER_AGENT_URL", "")
assert.False(t, developInCoder())
})
}
func TestDevConfigValidate(t *testing.T) {
t.Parallel()
base := func() *devConfig {
return &devConfig{
apiPort: 3000,
webPort: 8080,
proxyPort: 3010,
coderMetricsPort: 2114,
password: defaultPassword,
bindAddress: defaultBindAddress,
}
}
cases := []struct {
name string
mutate func(cfg *devConfig)
wantErrs []string
}{
{
name: "Valid",
},
{
name: "LoopbackBindAddress",
mutate: func(cfg *devConfig) { cfg.bindAddress = "127.0.0.1" },
},
{
name: "BindAddressHostname",
mutate: func(cfg *devConfig) { cfg.bindAddress = "localhost" },
wantErrs: []string{"--bind-address must be 0.0.0.0 or 127.0.0.1"},
},
{
name: "BindAddressOtherIP",
mutate: func(cfg *devConfig) { cfg.bindAddress = "::1" },
wantErrs: []string{"--bind-address must be 0.0.0.0 or 127.0.0.1"},
},
{
name: "AgplAndProxy",
mutate: func(cfg *devConfig) {
cfg.agpl = true
cfg.useProxy = true
},
wantErrs: []string{"--agpl and --use-proxy"},
},
{
name: "AgplAndMultiOrg",
mutate: func(cfg *devConfig) {
cfg.agpl = true
cfg.multiOrg = true
},
wantErrs: []string{"--agpl and --multi-organization"},
},
{
name: "PortTooLow",
mutate: func(cfg *devConfig) { cfg.apiPort = 0 },
wantErrs: []string{"--port must be between 1 and 65535"},
},
{
name: "PortTooHigh",
mutate: func(cfg *devConfig) { cfg.apiPort = 70000 },
wantErrs: []string{"--port must be between 1 and 65535"},
},
{
name: "PortConflictWithWeb",
mutate: func(cfg *devConfig) { cfg.apiPort = 8080 },
wantErrs: []string{"conflicts with frontend dev server"},
},
{
name: "PortConflictWithProxy",
mutate: func(cfg *devConfig) {
cfg.apiPort = 3010
cfg.useProxy = true
},
wantErrs: []string{"conflicts with workspace proxy"},
},
{
name: "ProxyPortOKWithoutFlag",
mutate: func(cfg *devConfig) { cfg.apiPort = 3010 },
},
{
name: "WebPortTooLow",
mutate: func(cfg *devConfig) { cfg.webPort = 0 },
wantErrs: []string{"--web-port must be between 1 and 65535"},
},
{
name: "ProxyPortTooHigh",
mutate: func(cfg *devConfig) { cfg.proxyPort = 70000 },
wantErrs: []string{"--proxy-port must be between 1 and 65535"},
},
{
name: "WebProxyPortConflict",
mutate: func(cfg *devConfig) {
cfg.webPort = 9000
cfg.proxyPort = 9000
cfg.useProxy = true
},
wantErrs: []string{"--web-port 9000 conflicts with --proxy-port"},
},
{
name: "WebProxyPortConflictOKWithoutProxy",
mutate: func(cfg *devConfig) {
cfg.webPort = 9000
cfg.proxyPort = 9000
},
},
{
name: "PrometheusPortConflictWithAPI",
mutate: func(cfg *devConfig) { cfg.coderMetricsPort = 3000 },
wantErrs: []string{"--prometheus-port 3000 conflicts with"},
},
{
name: "PrometheusPortConflictWithWeb",
mutate: func(cfg *devConfig) { cfg.coderMetricsPort = 8080 },
wantErrs: []string{"--prometheus-port 8080 conflicts with"},
},
{
name: "PrometheusPortConflictWithProxy",
mutate: func(cfg *devConfig) {
cfg.coderMetricsPort = 3010
cfg.useProxy = true
},
wantErrs: []string{"--prometheus-port 3010 conflicts with"},
},
{
name: "PrometheusPortZeroDisabled",
mutate: func(cfg *devConfig) { cfg.coderMetricsPort = 0 },
},
{
name: "PrometheusPortValid",
mutate: func(cfg *devConfig) { cfg.coderMetricsPort = 9090 },
},
{
name: "PrometheusPortTooHigh",
mutate: func(cfg *devConfig) { cfg.coderMetricsPort = 70000 },
wantErrs: []string{"--prometheus-port must be 0 (disabled) or between 1 and 65535"},
},
{
name: "PrometheusPortNegative",
mutate: func(cfg *devConfig) { cfg.coderMetricsPort = -1 },
wantErrs: []string{"--prometheus-port must be 0 (disabled) or between 1 and 65535"},
},
{
name: "PrometheusProxyProxyConflictIgnoredWithoutProxy",
mutate: func(cfg *devConfig) { cfg.coderMetricsPort = 3010 },
},
{
name: "PrometheusServerRequiresMetrics",
mutate: func(cfg *devConfig) {
cfg.prometheusServer = true
cfg.coderMetricsPort = 0
},
wantErrs: []string{"--prometheus-server requires prometheus to be enabled"},
},
{
name: "PrometheusServerValid",
mutate: func(cfg *devConfig) {
cfg.prometheusServer = true
cfg.coderMetricsPort = 2114
},
},
{
name: "PrometheusServerPortConflictWithAPI",
mutate: func(cfg *devConfig) {
cfg.prometheusServer = true
cfg.apiPort = prometheusServerPort
cfg.coderMetricsPort = 2114
},
wantErrs: []string{"--port", "conflicts with prometheus server"},
},
{
name: "PrometheusServerPortConflictWithWeb",
mutate: func(cfg *devConfig) {
cfg.prometheusServer = true
cfg.webPort = prometheusServerPort
cfg.coderMetricsPort = 2114
},
wantErrs: []string{"--web-port", "conflicts with prometheus server"},
},
{
name: "PrometheusServerPortConflictWithProxy",
mutate: func(cfg *devConfig) {
cfg.prometheusServer = true
cfg.useProxy = true
cfg.proxyPort = prometheusServerPort
},
wantErrs: []string{"--proxy-port", "conflicts with prometheus server"},
},
{
// useProxy is false, so no conflict.
name: "PrometheusServerPortNoProxyConflictWithoutFlag",
mutate: func(cfg *devConfig) {
cfg.prometheusServer = true
cfg.proxyPort = prometheusServerPort
},
},
{
name: "PrometheusServerPortConflictWithMetrics",
mutate: func(cfg *devConfig) {
cfg.prometheusServer = true
cfg.coderMetricsPort = prometheusServerPort
},
wantErrs: []string{"--prometheus-port", "conflicts with prometheus server"},
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
cfg := base()
if tc.mutate != nil {
tc.mutate(cfg)
}
err := cfg.validate()
if len(tc.wantErrs) == 0 {
assert.NoError(t, err)
return
}
require.Error(t, err)
for _, want := range tc.wantErrs {
assert.Contains(t, err.Error(), want)
}
})
}
}
func TestDevConfigResolveEnv(t *testing.T) {
t.Setenv("CODER_SESSION_TOKEN", "leaked")
t.Setenv("CODER_URL", "https://leaked.example.com")
wd, _ := os.Getwd()
cfg := &devConfig{apiPort: 3000, accessURL: defaultAccessURL}
require.NoError(t, cfg.resolveEnv())
assert.Equal(t, wd, cfg.projectRoot)
assert.Equal(t, filepath.Join(wd, "build",
fmt.Sprintf("coder_%s_%s", runtime.GOOS, runtime.GOARCH)), cfg.binaryPath)
assert.Equal(t, filepath.Join(wd, ".coderv2"), cfg.configDir)
assert.Equal(t, "http://127.0.0.1:3000", cfg.accessURL)
assert.Equal(t, int64(3000), cfg.apiPort)
assert.Zero(t, cfg.portOffset)
// Should have unset leaked env vars.
assert.Empty(t, os.Getenv("CODER_SESSION_TOKEN"))
assert.Empty(t, os.Getenv("CODER_URL"))
// childEnv should be populated and exclude leaked vars.
require.NotEmpty(t, cfg.childEnv)
for _, e := range cfg.childEnv {
k, _, _ := strings.Cut(e, "=")
assert.NotEqual(t, "CODER_SESSION_TOKEN", k)
assert.NotEqual(t, "CODER_URL", k)
}
}
func TestDevConfigResolveEnvUsesDefaultPortsWithoutPortOffset(t *testing.T) {
t.Setenv("CODER_SESSION_TOKEN", "")
t.Setenv("CODER_URL", "")
baseRoot := t.TempDir()
projectRoot := filepath.Join(baseRoot, "worktree")
for i := range 100 {
candidate := filepath.Join(baseRoot, fmt.Sprintf("worktree-default-%d", i))
if portOffset(candidate) != 0 {
projectRoot = candidate
break
}
}
require.NotZero(t, portOffset(projectRoot))
require.NoError(t, os.MkdirAll(projectRoot, 0o755))
t.Chdir(projectRoot)
cfg := &devConfig{
apiPort: 3000,
webPort: 8080,
proxyPort: 3010,
coderMetricsPort: 2114,
accessURL: defaultAccessURL,
}
require.NoError(t, cfg.resolveEnv())
assert.Equal(t, projectRoot, cfg.projectRoot)
assert.Equal(t, int64(3000), cfg.apiPort)
assert.Equal(t, int64(8080), cfg.webPort)
assert.Equal(t, int64(3010), cfg.proxyPort)
assert.Equal(t, int64(2114), cfg.coderMetricsPort)
assert.Zero(t, cfg.portOffset)
assert.Empty(t, cfg.apiPortSource)
assert.Empty(t, cfg.webPortSource)
assert.Empty(t, cfg.proxyPortSource)
assert.Empty(t, cfg.metricsPortSource)
assert.Equal(t, "http://127.0.0.1:3000", cfg.accessURL)
}
func TestDevConfigResolveEnvAppliesPortOffsetWhenEnabled(t *testing.T) {
t.Setenv("CODER_SESSION_TOKEN", "")
t.Setenv("CODER_URL", "")
baseRoot := t.TempDir()
projectRoot := filepath.Join(baseRoot, "worktree")
for i := range 100 {
candidate := filepath.Join(baseRoot, fmt.Sprintf("worktree-%d", i))
if portOffset(candidate) != 0 {
projectRoot = candidate
break
}
}
require.NotZero(t, portOffset(projectRoot))
require.NoError(t, os.MkdirAll(projectRoot, 0o755))
t.Chdir(projectRoot)
cfg := &devConfig{
apiPort: 3000,
webPort: 8080,
proxyPort: 3010,
coderMetricsPort: 2114,
portOffsetEnabled: true,
accessURL: defaultAccessURL,
}
require.NoError(t, cfg.resolveEnv())
offset := portOffset(projectRoot)
assert.Equal(t, projectRoot, cfg.projectRoot)
assert.Equal(t, int64(3000+offset), cfg.apiPort)
assert.Equal(t, int64(8080+offset), cfg.webPort)
assert.Equal(t, int64(3010+offset), cfg.proxyPort)
assert.Equal(t, int64(2114+offset), cfg.coderMetricsPort)
assert.Equal(t, offset, cfg.portOffset)
assert.Equal(t, portSourceOffset, cfg.apiPortSource)
assert.Equal(t, fmt.Sprintf("http://127.0.0.1:%d", 3000+offset), cfg.accessURL)
}
func TestDevConfigResolveEnvExplicitAccessURL(t *testing.T) {
t.Setenv("CODER_SESSION_TOKEN", "")
t.Setenv("CODER_URL", "")
cfg := &devConfig{
apiPort: 5000,
accessURL: "http://myhost:5000",
portExplicit: portExplicit{api: true},
}
require.NoError(t, cfg.resolveEnv())
assert.Equal(t, "http://myhost:5000", cfg.accessURL)
}
func TestBindAddressOption(t *testing.T) {
t.Parallel()
parse := func(t *testing.T, env []string, args ...string) *devConfig {
t.Helper()
cfg := &devConfig{}
cmd := &serpent.Command{
Use: "develop",
Options: cfg.options(),
Handler: func(*serpent.Invocation) error { return nil },
}
inv := cmd.Invoke(args...)
inv.Environ = serpent.ParseEnviron(env, "")
require.NoError(t, inv.Run())
return cfg
}
assert.Equal(t, defaultBindAddress, parse(t, nil).bindAddress)
assert.Equal(t, loopbackBindAddress, parse(t, nil, "--bind-address", "127.0.0.1").bindAddress)
assert.Equal(t, loopbackBindAddress, parse(t, []string{"CODER_DEV_BIND_ADDRESS=127.0.0.1"}).bindAddress)
}
func TestListenAddresses(t *testing.T) {
t.Parallel()
cfg := &devConfig{
bindAddress: loopbackBindAddress,
apiPort: 3000,
coderMetricsPort: 2114,
configDir: "/fake/.coderv2",
}
args := strings.Join(cfg.serverArgs(), " ")
assert.Contains(t, args, "--http-address 127.0.0.1:3000")
assert.Contains(t, args, "--prometheus-address 127.0.0.1:2114")
assert.Contains(t, cfg.prometheusRunArgs("/fake/prometheus.yml", "/fake/data"),
fmt.Sprintf("--web.listen-address=127.0.0.1:%d", prometheusServerPort))
cfg.bindAddress = defaultBindAddress
assert.Contains(t, strings.Join(cfg.serverArgs(), " "), "--http-address 0.0.0.0:3000")
}
func TestPrometheusReusable(t *testing.T) {
t.Parallel()
inspect := fmt.Sprintf(`true ["--config.file=/etc/prometheus/prometheus.yml","--web.listen-address=0.0.0.0:%d"]`, prometheusServerPort)
assert.True(t, (&devConfig{bindAddress: defaultBindAddress}).prometheusReusable(inspect))
assert.False(t, (&devConfig{bindAddress: loopbackBindAddress}).prometheusReusable(inspect))
}
func TestPnpmCmdHost(t *testing.T) {
t.Parallel()
// The default keeps a bare --host, which listens on IPv4 and IPv6.
cfg := &devConfig{bindAddress: defaultBindAddress, webPort: 8080, apiPort: 3000}
assert.Equal(t, []string{"pnpm", "--dir", "./site", "dev", "--host"}, pnpmCmd(context.Background(), cfg).Args)
cfg.bindAddress = loopbackBindAddress
assert.Equal(t, []string{"pnpm", "--dir", "./site", "dev", "--host", "127.0.0.1"}, pnpmCmd(context.Background(), cfg).Args)
}
func TestBannerHosts(t *testing.T) {
t.Parallel()
assert.Equal(t, []string{"localhost"}, bannerHosts(loopbackBindAddress))
all := bannerHosts(defaultBindAddress)
require.NotEmpty(t, all)
assert.Equal(t, "localhost", all[0])
}
func TestDevConfigCmd(t *testing.T) {
t.Parallel()
cfg := &devConfig{
projectRoot: "/fake/root",
childEnv: []string{"A=1", "B=2"},
}
cmd := cfg.cmd(context.Background(), "echo", "hello")
assert.Equal(t, "/fake/root", cmd.Dir)
assert.Equal(t, []string{"A=1", "B=2"}, cmd.Env)
// Verify childEnv is cloned, not shared.
cmd.Env = append(cmd.Env, "C=3")
assert.Len(t, cfg.childEnv, 2, "original childEnv must not be mutated")
}
func TestProcGroupProcessExit(t *testing.T) {
t.Parallel()
logger := slog.Make(sloghuman.Sink(&bytes.Buffer{}))
group := newProcGroup(t.Context(), logger)
cmd := exec.CommandContext(t.Context(), "false")
cmd.Env = os.Environ()
require.NoError(t, group.Start("dies-fast", cmd))
// Process exit should cancel the group context.
select {
case <-group.Ctx().Done():
case <-time.After(5 * time.Second):
t.Fatal("timed out waiting for context cancellation")
}
// Wait should return an error naming the exited process.
err := group.Wait()
require.Error(t, err)
assert.Contains(t, err.Error(), "dies-fast")
}
func TestProcGroupGracefulShutdown(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithCancel(t.Context())
logger := slog.Make(sloghuman.Sink(&bytes.Buffer{}))
group := newProcGroup(ctx, logger)
// Start a process that runs until signaled.
cmd := exec.CommandContext(ctx, "sleep", "60")
cmd.Env = os.Environ()
err := group.Start("sleeper", cmd)
require.NoError(t, err)
// Cancel the parent context. cmd.Cancel sends SIGINT, and
// cmd.WaitDelay escalates to SIGKILL if needed.
cancel()
done := make(chan error, 1)
go func() { done <- group.Wait() }()
select {
case err := <-done:
// The process was killed, so we expect an error.
require.Error(t, err)
case <-time.After(shutdownTimeout + 5*time.Second):
t.Fatal("timed out waiting for graceful shutdown")
}
}
func TestPoll(t *testing.T) {
t.Parallel()
t.Run("ImmediateSuccess", func(t *testing.T) {
t.Parallel()
val, err := poll(t.Context(), 10*time.Millisecond,
func(_ context.Context) (string, bool, error) {
return "done", true, nil
})
require.NoError(t, err)
assert.Equal(t, "done", val)
})
t.Run("EventualSuccess", func(t *testing.T) {
t.Parallel()
calls := 0
val, err := poll(t.Context(), 10*time.Millisecond,
func(_ context.Context) (int, bool, error) {
calls++
if calls >= 3 {
return calls, true, nil
}
return 0, false, nil
})
require.NoError(t, err)
assert.Equal(t, 3, val)
})
t.Run("ContextCanceled", func(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithCancel(t.Context())
cancel()
_, err := poll(ctx, 10*time.Millisecond,
func(_ context.Context) (struct{}, bool, error) {
t.Fatal("cond should not be called")
return struct{}{}, false, nil
})
require.ErrorIs(t, err, context.Canceled)
})
t.Run("ErrorStopsPolling", func(t *testing.T) {
t.Parallel()
calls := 0
_, err := poll(t.Context(), 10*time.Millisecond,
func(_ context.Context) (string, bool, error) {
calls++
if calls == 2 {
return "", false, xerrors.New("boom")
}
return "", false, nil
})
require.Error(t, err)
assert.Contains(t, err.Error(), "boom")
assert.Equal(t, 2, calls)
})
}
func TestStartPrometheusServerDockerMissing(t *testing.T) {
// Not t.Parallel(): mutates PATH via t.Setenv.
t.Setenv("PATH", "")
logger := slog.Make(sloghuman.Sink(&bytes.Buffer{}))
cfg := &devConfig{prometheusServer: true, coderMetricsPort: 2114}
started, err := startPrometheusServer(t.Context(), logger, cfg)
require.NoError(t, err)
assert.False(t, started)
}
func TestPrometheusBannerEntry(t *testing.T) {
t.Parallel()
cases := []struct {
name string
cfg *devConfig
started bool
wantLabel string
wantPort int64
}{
{
name: "MetricsDisabled",
cfg: &devConfig{coderMetricsPort: 0},
started: false,
wantLabel: "",
wantPort: 0,
},
{
name: "MetricsOnlyDefault",
cfg: &devConfig{coderMetricsPort: 2114},
started: false,
wantLabel: "Metrics:",
wantPort: 2114,
},
{
name: "PrometheusServerUp",
cfg: &devConfig{coderMetricsPort: 2114, prometheusServer: true},
started: true,
wantLabel: "Prometheus UI:",
wantPort: prometheusServerPort,
},
{
name: "ServerRequestedButDown",
cfg: &devConfig{coderMetricsPort: 2114, prometheusServer: true},
started: false,
wantLabel: "Metrics:",
wantPort: 2114,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
label, port := prometheusBannerEntry(tc.cfg, tc.started)
assert.Equal(t, tc.wantLabel, label)
assert.Equal(t, tc.wantPort, port)
})
}
}
//nolint:paralleltest // loadEnvFile mutates process-global environment.
func TestLoadEnvFile(t *testing.T) {
t.Run("LoadsVariablesFromFile", func(t *testing.T) {
tmpDir := t.TempDir()
envFile := filepath.Join(tmpDir, ".env")
err := os.WriteFile(envFile, []byte(strings.Join([]string{
"# Comment line",
"",
"FOO_TEST_VAR=bar",
"export BAZ_TEST_VAR=qux",
`QUOTED_TEST_VAR="hello world"`,
"SINGLE_QUOTED_TEST_VAR='single quoted'",
}, "\n")), 0o600)
require.NoError(t, err)
// Ensure none are set beforehand.
t.Setenv("FOO_TEST_VAR", "")
os.Unsetenv("FOO_TEST_VAR")
t.Setenv("BAZ_TEST_VAR", "")
os.Unsetenv("BAZ_TEST_VAR")
t.Setenv("QUOTED_TEST_VAR", "")
os.Unsetenv("QUOTED_TEST_VAR")
t.Setenv("SINGLE_QUOTED_TEST_VAR", "")
os.Unsetenv("SINGLE_QUOTED_TEST_VAR")
n, err := loadEnvFile(envFile)
require.NoError(t, err)
assert.Equal(t, 4, n)
assert.Equal(t, "bar", os.Getenv("FOO_TEST_VAR"))
assert.Equal(t, "qux", os.Getenv("BAZ_TEST_VAR"))
assert.Equal(t, "hello world", os.Getenv("QUOTED_TEST_VAR"))
assert.Equal(t, "single quoted", os.Getenv("SINGLE_QUOTED_TEST_VAR"))
})
t.Run("DoesNotOverrideExisting", func(t *testing.T) {
tmpDir := t.TempDir()
envFile := filepath.Join(tmpDir, ".env")
err := os.WriteFile(envFile, []byte("EXISTING_TEST_VAR=new\n"), 0o600)
require.NoError(t, err)
t.Setenv("EXISTING_TEST_VAR", "original")
n, err := loadEnvFile(envFile)
require.NoError(t, err)
assert.Equal(t, 0, n)
assert.Equal(t, "original", os.Getenv("EXISTING_TEST_VAR"))
})
t.Run("ErrorsOnMissingFile", func(t *testing.T) {
_, err := loadEnvFile("/nonexistent/path/.env")
require.Error(t, err)
})
t.Run("ErrorsOnEmptyPath", func(t *testing.T) {
// This tests the caller logic (main), but we verify loadEnvFile
// would error on empty path since godotenv.Read("") fails.
_, err := loadEnvFile("")
require.Error(t, err)
})
}
//nolint:paralleltest // parseEnvFileFlag mutates process-global os.Args.
func TestParseEnvFileFlag(t *testing.T) {
t.Run("FlagWithSpace", func(t *testing.T) {
orig := os.Args
t.Cleanup(func() { os.Args = orig })
os.Args = []string{"develop", "--env-file", "/tmp/test.env", "--port", "3000"}
result, err := parseEnvFileFlag()
require.NoError(t, err)
assert.Equal(t, "/tmp/test.env", result)
})
t.Run("FlagWithEquals", func(t *testing.T) {
orig := os.Args
t.Cleanup(func() { os.Args = orig })
os.Args = []string{"develop", "--env-file=/tmp/test.env", "--port", "3000"}
result, err := parseEnvFileFlag()
require.NoError(t, err)
assert.Equal(t, "/tmp/test.env", result)
})
t.Run("FallsBackToEnvVar", func(t *testing.T) {
orig := os.Args
t.Cleanup(func() { os.Args = orig })
os.Args = []string{"develop", "--port", "3000"}
t.Setenv("CODER_DEV_ENV_FILE", "/tmp/from-env.env")
result, err := parseEnvFileFlag()
require.NoError(t, err)
assert.Equal(t, "/tmp/from-env.env", result)
})
t.Run("FlagTakesPrecedenceOverEnvVar", func(t *testing.T) {
orig := os.Args
t.Cleanup(func() { os.Args = orig })
os.Args = []string{"develop", "--env-file", "/tmp/from-flag.env"}
t.Setenv("CODER_DEV_ENV_FILE", "/tmp/from-env.env")
result, err := parseEnvFileFlag()
require.NoError(t, err)
assert.Equal(t, "/tmp/from-flag.env", result)
})
t.Run("ReturnsEmptyWhenUnset", func(t *testing.T) {
orig := os.Args
t.Cleanup(func() { os.Args = orig })
os.Args = []string{"develop", "--port", "3000"}
t.Setenv("CODER_DEV_ENV_FILE", "")
os.Unsetenv("CODER_DEV_ENV_FILE")
result, err := parseEnvFileFlag()
require.NoError(t, err)
assert.Equal(t, "", result)
})
t.Run("ErrorsWhenValueMissing", func(t *testing.T) {
orig := os.Args
t.Cleanup(func() { os.Args = orig })
os.Args = []string{"develop", "--env-file"}
_, err := parseEnvFileFlag()
require.Error(t, err)
assert.Contains(t, err.Error(), "--env-file requires a value")
})
}