Thales Maciel
ecb18ce6ca
Three test seams were still package-level mutable vars, which tests
had to swap before use. That's the classic path to flaky parallel
tests — two goroutines fighting over the same global fake. Push each
down to the struct that owns the behaviour.
internal/daemon/dns_routing.go
lookupExecutableFunc + vmDNSAddrFunc → fields on *HostNetwork,
defaulted at newHostNetwork time. dns_routing_test builds
HostNetwork{..., lookupExecutable: stub, vmDNSAddr: stub} inline,
no more t.Cleanup dance around package-level vars.
internal/daemon/preflight.go + doctor.go
vsockHostDevicePath (mutable string) → vsockHostDevice field on
*VMService, defaulted via defaultVsockHostDevice constant in
newVMService. Preflight reads s.vsockHostDevice; doctor reads
d.vm.vsockHostDevice. Logger test sets d.vm.vsockHostDevice = tmp
after wireServices.
internal/daemon/workspace/workspace.go
HostCommandOutputFunc → *Inspector struct with a Runner field.
Every git-using helper (GitOutput, GitTrimmedOutput,
GitResolvedConfigValue, RunHostCommand, ListSubmodules,
ListOverlayPaths, CountUntrackedPaths, InspectRepo,
ImportRepoToGuest, PrepareRepoCopy) is now a method on *Inspector.
NewInspector() wraps the real host runner for production;
WorkspaceService holds one via repoInspector, CLI deps holds one
too. cli_test.go's submodule-rejection test builds its own
Inspector with a scripted Runner instead of patching a global.
Pure helpers (FinalizeScript, ResolveSourcePath, ParsePrepareMode,
ShellQuote, FormatStepError, GitFileURL, ParseNullSeparatedOutput)
stay free functions since they don't touch the host.
Sentinel: grep for HostCommandOutputFunc, lookupExecutableFunc,
vmDNSAddrFunc, vsockHostDevicePath is now empty across internal/.
make lint test green.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
102 lines
3.1 KiB
Go
102 lines
3.1 KiB
Go
package workspace
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"slices"
|
|
"testing"
|
|
)
|
|
|
|
// seedRepo creates a tiny git repo with one tracked file, one
|
|
// gitignored file, and one untracked-non-ignored file. Returns the
|
|
// repo root path. Skips the test if git isn't on PATH (unusual for
|
|
// a dev machine, but polite).
|
|
func seedRepo(t *testing.T) string {
|
|
t.Helper()
|
|
if _, err := exec.LookPath("git"); err != nil {
|
|
t.Skipf("git not on PATH: %v", err)
|
|
}
|
|
dir := t.TempDir()
|
|
run := func(args ...string) {
|
|
t.Helper()
|
|
cmd := exec.Command(args[0], args[1:]...)
|
|
cmd.Dir = dir
|
|
// Isolate from the ambient user config so commits don't need
|
|
// a global user.name/user.email. Also disable GPG signing.
|
|
cmd.Env = append(os.Environ(),
|
|
"GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@t",
|
|
"GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@t",
|
|
"GIT_CONFIG_GLOBAL=/dev/null",
|
|
)
|
|
if out, err := cmd.CombinedOutput(); err != nil {
|
|
t.Fatalf("%v: %v\n%s", args, err, out)
|
|
}
|
|
}
|
|
writeFile := func(relPath, content string) {
|
|
t.Helper()
|
|
if err := os.WriteFile(filepath.Join(dir, relPath), []byte(content), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
run("git", "init", "-q", "-b", "main")
|
|
run("git", "config", "commit.gpgsign", "false")
|
|
writeFile(".gitignore", "ignored.log\n")
|
|
writeFile("README.md", "hello\n")
|
|
run("git", "add", ".gitignore", "README.md")
|
|
run("git", "commit", "-q", "-m", "init")
|
|
// A tracked file AFTER the first commit so ls-files picks it up.
|
|
// A gitignored file so --exclude-standard filters it.
|
|
// An untracked non-ignored file so the flag matters.
|
|
writeFile("src.go", "package main\n")
|
|
run("git", "add", "src.go")
|
|
run("git", "commit", "-q", "-m", "src")
|
|
writeFile("ignored.log", "noisy\n")
|
|
writeFile("SECRETS.env", "TOKEN=abc\n")
|
|
return dir
|
|
}
|
|
|
|
func TestListOverlayPaths_TrackedOnlyByDefault(t *testing.T) {
|
|
repo := seedRepo(t)
|
|
i := NewInspector()
|
|
got, err := i.ListOverlayPaths(context.Background(), repo, false)
|
|
if err != nil {
|
|
t.Fatalf("ListOverlayPaths: %v", err)
|
|
}
|
|
want := []string{".gitignore", "README.md", "src.go"}
|
|
if !slices.Equal(got, want) {
|
|
t.Fatalf("got %v, want %v (untracked SECRETS.env must be excluded; gitignored ignored.log must always be excluded)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestListOverlayPaths_IncludeUntracked(t *testing.T) {
|
|
repo := seedRepo(t)
|
|
i := NewInspector()
|
|
got, err := i.ListOverlayPaths(context.Background(), repo, true)
|
|
if err != nil {
|
|
t.Fatalf("ListOverlayPaths: %v", err)
|
|
}
|
|
want := []string{".gitignore", "README.md", "SECRETS.env", "src.go"}
|
|
if !slices.Equal(got, want) {
|
|
t.Fatalf("got %v, want %v", got, want)
|
|
}
|
|
// gitignored files must stay out even when untracked is included.
|
|
for _, p := range got {
|
|
if p == "ignored.log" {
|
|
t.Fatalf("gitignored file leaked into overlay: %v", got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCountUntrackedPaths(t *testing.T) {
|
|
repo := seedRepo(t)
|
|
i := NewInspector()
|
|
count, err := i.CountUntrackedPaths(context.Background(), repo)
|
|
if err != nil {
|
|
t.Fatalf("CountUntrackedPaths: %v", err)
|
|
}
|
|
if count != 1 {
|
|
t.Fatalf("count = %d, want 1 (only SECRETS.env; ignored.log is gitignored)", count)
|
|
}
|
|
}
|