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>
53 lines
2 KiB
Go
53 lines
2 KiB
Go
package cli
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
)
|
|
|
|
// runWorkspaceDryRun inspects the local repo at resolvedPath and
|
|
// prints the file list that `vm run` / `workspace prepare` would ship
|
|
// into the guest. Runs on the CLI side (no daemon RPC needed) since
|
|
// the daemon is always local and the workspace inspection is a pure
|
|
// git read. Git calls go through d.repoInspector so tests inject a
|
|
// stub Runner via the deps struct instead of touching package globals.
|
|
func (d *deps) runWorkspaceDryRun(ctx context.Context, out io.Writer, resolvedPath, branchName, fromRef string, includeUntracked bool) error {
|
|
spec, err := d.repoInspector.InspectRepo(ctx, resolvedPath, branchName, fromRef, includeUntracked)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Fprintf(out, "dry-run: %d file(s) would be copied to guest\n", len(spec.OverlayPaths))
|
|
fmt.Fprintf(out, "repo: %s\n", spec.RepoRoot)
|
|
if includeUntracked {
|
|
fmt.Fprintln(out, "mode: tracked + untracked non-ignored (--include-untracked)")
|
|
} else {
|
|
fmt.Fprintln(out, "mode: tracked only (re-run with --include-untracked to also copy untracked non-ignored files)")
|
|
}
|
|
fmt.Fprintln(out, "---")
|
|
for _, path := range spec.OverlayPaths {
|
|
fmt.Fprintln(out, path)
|
|
}
|
|
if !includeUntracked {
|
|
if err := d.noteUntrackedSkipped(ctx, out, spec.RepoRoot); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// noteUntrackedSkipped prints a one-line notice to stderr-analog when
|
|
// the repo has untracked non-ignored files that will NOT be copied
|
|
// because --include-untracked was not passed. Silent when there are
|
|
// no such files, or when the count can't be determined.
|
|
func (d *deps) noteUntrackedSkipped(ctx context.Context, out io.Writer, repoRoot string) error {
|
|
count, err := d.repoInspector.CountUntrackedPaths(ctx, repoRoot)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count == 0 {
|
|
return nil
|
|
}
|
|
fmt.Fprintf(out, "---\nnote: %d untracked non-ignored file(s) were NOT copied (git-tracked files only by default — pass --include-untracked to include them)\n", count)
|
|
return nil
|
|
}
|