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.
101 lines
2.5 KiB
Go
101 lines
2.5 KiB
Go
package scanner
|
|
|
|
import (
|
|
"context"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"gitea.oblak.solutions/dimitar/gitFlow/pkg/status"
|
|
)
|
|
|
|
func newGitRepo(t *testing.T, dir string) string {
|
|
t.Helper()
|
|
if _, err := exec.LookPath("git"); err != nil {
|
|
t.Skip("git not available")
|
|
}
|
|
cmd := exec.Command("git", "init", "-q", "-b", "main", filepath.Base(dir))
|
|
cmd.Dir = filepath.Dir(dir)
|
|
if out, err := cmd.CombinedOutput(); err != nil {
|
|
t.Fatalf("git init: %v\n%s", err, out)
|
|
}
|
|
cmd = exec.Command("git", "config", "user.email", "t@t")
|
|
cmd.Dir = dir
|
|
_ = cmd.Run()
|
|
cmd = exec.Command("git", "config", "user.name", "t")
|
|
cmd.Dir = dir
|
|
_ = cmd.Run()
|
|
return dir
|
|
}
|
|
|
|
func TestScannerScanMixed(t *testing.T) {
|
|
root := t.TempDir()
|
|
repo1 := newGitRepo(t, filepath.Join(root, "one"))
|
|
repo2 := newGitRepo(t, filepath.Join(root, "two"))
|
|
bogus := filepath.Join(root, "not-a-repo")
|
|
|
|
s := NewScanner()
|
|
infos, err := s.Scan(context.Background(), []string{repo1, repo2, bogus})
|
|
if err != nil {
|
|
t.Fatalf("Scan: %v", err)
|
|
}
|
|
if len(infos) != 3 {
|
|
t.Fatalf("Scan returned %d infos, want 3", len(infos))
|
|
}
|
|
|
|
for _, info := range infos {
|
|
switch info.Path {
|
|
case repo1, repo2:
|
|
if info.Status != status.StatusClean {
|
|
t.Errorf("%s: Status = %v, want clean", info.Path, info.Status)
|
|
}
|
|
case bogus:
|
|
if info.Status != status.StatusError {
|
|
t.Errorf("bogus: Status = %v, want error", info.Status)
|
|
}
|
|
if info.Error == "" {
|
|
t.Errorf("bogus: Error is empty")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestScannerConcurrentErrors(t *testing.T) {
|
|
// Many failing paths at low worker count: everything must come back as
|
|
// StatusError and no goroutine may leak or race.
|
|
root := t.TempDir()
|
|
paths := make([]string, 20)
|
|
for i := range paths {
|
|
paths[i] = filepath.Join(root, "nope", "repo", string(rune('a'+i)))
|
|
}
|
|
|
|
s := NewScanner(WithWorkers(4))
|
|
infos, err := s.Scan(context.Background(), paths)
|
|
if err != nil {
|
|
t.Fatalf("Scan: %v", err)
|
|
}
|
|
if len(infos) != len(paths) {
|
|
t.Fatalf("Scan returned %d infos, want %d", len(infos), len(paths))
|
|
}
|
|
for i, info := range infos {
|
|
if info.Status != status.StatusError {
|
|
t.Errorf("path %d: Status = %v, want error", i, info.Status)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestScannerCancellation(t *testing.T) {
|
|
root := t.TempDir()
|
|
repo := newGitRepo(t, filepath.Join(root, "one"))
|
|
paths := make([]string, 0, 10)
|
|
for i := 0; i < 10; i++ {
|
|
paths = append(paths, repo)
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
if _, err := NewScanner().Scan(ctx, paths); err == nil {
|
|
t.Error("Scan(cancelled ctx) succeeded, want error")
|
|
}
|
|
}
|