dimitar
ae23019277
Implement the core data layer that everything else builds on: walking a parent directory for Git repositories and snapshotting each repository's state via porcelain commands. Domain model (pkg/status): - RepoStatus enum with zero value = StatusUnknown (invalid/unset), covering clean / modified / ahead / behind / diverged / detached / bare / error - RepoInfo snapshot: path, name, remote URL, branch, detached flag, staged / modified / untracked file lists, ahead/behind counts, stash count, error - ScanResult with computed Summary counters and NeedsAttention filter Git wrapper (internal/git): - Executor built with functional options (binary, timeout, env), defaults to "git" with a 10s per-command timeout so a hung repository can never stall a scan; context cancellation honoured via exec.CommandContext - Status() validates with rev-parse --is-bare-repository (bare repos are reported as StatusBare and skipped), then parses `git status --porcelain=v2 --branch -z` - Parsing uses the NUL-separated v2 format so paths with spaces, quotes, and tabs survive verbatim (no C-quoting to decode); rename records (type 2) and ahead/behind lines (# branch.ab) are handled, unknown tokens are ignored for forward compatibility - Best-effort remote URL (git config --get-regexp) and stash count Discovery (internal/scanner/discover.go): - WalkDir-based traversal that never descends into .git internals - Detects working trees via .git directory or .git pointer file (linked worktrees, submodule checkouts) and bare repos via a *.git directory carrying its own HEAD/objects/refs - WithExclude glob patterns (matched against full path and base name) and WithMaxDepth depth limiting as functional options - Walk errors (e.g. permission denied) are aggregated and returned alongside partial results via errors.Join; cancellation is propagated Scanner (internal/scanner/scanner.go): - Concurrent status scanning with a bounded worker pool (errgroup + SetLimit, default 8 workers) - Per-repo failures become StatusError entries instead of aborting the pass; a cancelled context aborts the whole scan Testing: - Table-driven parser tests with canned NUL-separated porcelain output - Integration tests against a real git binary (clean / modified / staged / stashed / detached / bare / non-repo) - Discovery tests over a fixture tree with nested repos, a bare repo, a linked worktree, and an exclusion target - Scanner tests for mixed success/failure, bounded concurrency, and cancellation; everything runs under -race Note: LastFetch from the original plan was dropped — the only reliable source is a reflog of the remote-tracking ref, which does not exist on fresh clones, so it would always be misleading. The model remains extensible if a fetch-history feature is wanted later.
100 lines
2.3 KiB
Go
100 lines
2.3 KiB
Go
package status
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestRepoStatusString(t *testing.T) {
|
|
cases := []struct {
|
|
s RepoStatus
|
|
want string
|
|
}{
|
|
{StatusUnknown, "unknown"},
|
|
{StatusClean, "clean"},
|
|
{StatusModified, "modified"},
|
|
{StatusAhead, "ahead"},
|
|
{StatusBehind, "behind"},
|
|
{StatusDiverged, "diverged"},
|
|
{StatusDetached, "detached"},
|
|
{StatusBare, "bare"},
|
|
{StatusError, "error"},
|
|
}
|
|
for _, tc := range cases {
|
|
if got := tc.s.String(); got != tc.want {
|
|
t.Errorf("RepoStatus(%d).String() = %q, want %q", tc.s, got, tc.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRepoStatusNeedsAttention(t *testing.T) {
|
|
cases := []struct {
|
|
s RepoStatus
|
|
want bool
|
|
}{
|
|
{StatusUnknown, false},
|
|
{StatusClean, false},
|
|
{StatusModified, true},
|
|
{StatusAhead, true},
|
|
{StatusBehind, true},
|
|
{StatusDiverged, true},
|
|
{StatusDetached, true},
|
|
{StatusBare, true},
|
|
{StatusError, true},
|
|
}
|
|
for _, tc := range cases {
|
|
if got := tc.s.NeedsAttention(); got != tc.want {
|
|
t.Errorf("RepoStatus(%d).NeedsAttention() = %v, want %v", tc.s, got, tc.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRepoInfoFileCount(t *testing.T) {
|
|
info := RepoInfo{
|
|
StagedFiles: []string{"a", "b"},
|
|
ModifiedFiles: []string{"c"},
|
|
UntrackedFiles: []string{"d", "e", "f"},
|
|
}
|
|
if got := info.FileCount(); got != 6 {
|
|
t.Errorf("FileCount() = %d, want 6", got)
|
|
}
|
|
}
|
|
|
|
func TestScanResultSummary(t *testing.T) {
|
|
result := ScanResult{
|
|
ScannedAt: time.Now(),
|
|
ParentDir: "/tmp",
|
|
Repos: []RepoInfo{
|
|
{Status: StatusClean},
|
|
{Status: StatusModified, StagedFiles: []string{"a"}, ModifiedFiles: []string{"b"}},
|
|
{Status: StatusDiverged, UntrackedFiles: []string{"c"}},
|
|
{Status: StatusError, Error: "boom"},
|
|
{Status: StatusUnknown},
|
|
},
|
|
}
|
|
got := result.Summary()
|
|
want := Summary{Total: 5, Clean: 1, Attention: 2, Errored: 1, Staged: 1, Modified: 1, Untracked: 1}
|
|
if got != want {
|
|
t.Errorf("Summary() = %+v, want %+v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestScanResultNeedsAttention(t *testing.T) {
|
|
result := ScanResult{
|
|
Repos: []RepoInfo{
|
|
{Path: "/a", Status: StatusClean},
|
|
{Path: "/b", Status: StatusBehind},
|
|
{Path: "/c", Status: StatusError},
|
|
},
|
|
}
|
|
got := result.NeedsAttention()
|
|
if len(got) != 2 {
|
|
t.Fatalf("NeedsAttention() returned %d repos, want 2", len(got))
|
|
}
|
|
for _, r := range got {
|
|
if r.Path == "/a" {
|
|
t.Errorf("clean repo /a listed as needing attention")
|
|
}
|
|
}
|
|
}
|