Files
archie/internal/worktree/worktree_repair_test.go
T
2026-08-29 00:20:05 +10:00

463 lines
13 KiB
Go

package worktree
import (
"context"
"errors"
"log/slog"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/go-git/go-git/v6"
"github.com/go-git/go-git/v6/plumbing"
)
// slogCaptureHandler records all log records for asserting log output.
type slogCaptureHandler struct {
records []slog.Record
}
func (h *slogCaptureHandler) Enabled(context.Context, slog.Level) bool { return true }
func (h *slogCaptureHandler) Handle(_ context.Context, r slog.Record) error {
h.records = append(h.records, r)
return nil
}
func (h *slogCaptureHandler) WithAttrs([]slog.Attr) slog.Handler { return h }
func (h *slogCaptureHandler) WithGroup(string) slog.Handler { return h }
func setSlogCapture(t *testing.T) *slogCaptureHandler {
t.Helper()
prev := slog.Default()
h := &slogCaptureHandler{}
slog.SetDefault(slog.New(h))
t.Cleanup(func() { slog.SetDefault(prev) })
return h
}
// TestPushSucceedsWhenPostPublicationMetadataFails covers BUG 1 (archie-core-1ysw.6).
// A post-publication upstream metadata failure (e.g. read-only config or corrupted config)
// must NOT cause Push to report an error when the remote ref was successfully published.
// The failure must be logged as a warning instead of failing the task.
func TestPushSucceedsWhenPostPublicationMetadataFails(t *testing.T) {
tests := []struct {
name string
issue int
title string
labels string
file string
content string
commitMsg string
configPerm os.FileMode
useLogger bool
}{
{
name: "read-only config causes warning with default logger but push succeeds",
issue: 101,
title: "feat: push robustness",
labels: "feature",
file: "feature.txt",
content: "data\n",
commitMsg: "feat: push robustness",
configPerm: 0o400,
useLogger: false,
},
{
name: "read-only config causes warning with manager logger but push succeeds",
issue: 102,
title: "feat: custom logger push",
labels: "feature",
file: "custom.txt",
content: "custom data\n",
commitMsg: "feat: custom logger push",
configPerm: 0o400,
useLogger: true,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
logs := setSlogCapture(t)
ctx := context.Background()
host := newLocalRemote(t, "acme", "push-test")
m := newManager(t, host)
if tc.useLogger {
m.Log = slog.New(logs)
}
dir, branch, err := m.Prepare(ctx, "acme", "push-test", testBase, tc.issue, tc.title, "", tc.labels)
if err != nil {
t.Fatalf("Prepare() error = %v", err)
}
if err := os.WriteFile(filepath.Join(dir, tc.file), []byte(tc.content), 0o600); err != nil {
t.Fatalf("WriteFile() error = %v", err)
}
committed, err := m.CommitAll(ctx, dir, tc.commitMsg)
if err != nil {
t.Fatalf("CommitAll() error = %v", err)
}
if !committed {
t.Fatal("CommitAll() = false, want true")
}
// Make .git/config read-only so SetConfig will fail when recording upstream.
cfgPath := filepath.Join(dir, ".git", "config")
if err := os.Chmod(cfgPath, tc.configPerm); err != nil {
t.Fatalf("Chmod() error = %v", err)
}
t.Cleanup(func() { _ = os.Chmod(cfgPath, 0o644) })
// Push should succeed despite the local metadata failure.
err = m.Push(ctx, dir, branch)
if err != nil {
t.Fatalf("Push() error = %v, want nil (post-publication metadata failure should not fail push)", err)
}
// Remote repository MUST have the branch published.
bare := filepath.Join(host, "acme", "push-test.git")
remote, err := git.PlainOpen(bare)
if err != nil {
t.Fatalf("open bare remote: %v", err)
}
if _, err := remote.Reference(plumbing.NewBranchReferenceName(branch), true); err != nil {
t.Fatalf("branch %q not published on remote after Push: %v", branch, err)
}
// A warning log must have been recorded for the upstream metadata failure.
var warningFound bool
for _, r := range logs.records {
if r.Level >= slog.LevelWarn && strings.Contains(r.Message, "upstream") {
warningFound = true
break
}
}
if !warningFound {
t.Errorf("expected warning log about upstream metadata failure, got records: %v", logs.records)
}
})
}
}
// TestRecordUpstreamErrorPaths explicitly tests the error paths of recordUpstream.
func TestRecordUpstreamErrorPaths(t *testing.T) {
tests := []struct {
name string
setup func(t *testing.T, dir string)
wantSubstr string
}{
{
name: "write repo config fails when config is read only",
setup: func(t *testing.T, dir string) {
cfgPath := filepath.Join(dir, ".git", "config")
if err := os.Chmod(cfgPath, 0o400); err != nil {
t.Fatalf("Chmod config read-only error = %v", err)
}
t.Cleanup(func() { _ = os.Chmod(cfgPath, 0o644) })
},
wantSubstr: "write repo config",
},
{
name: "read repo config fails when config is corrupted",
setup: func(t *testing.T, dir string) {
cfgPath := filepath.Join(dir, ".git", "config")
if err := os.WriteFile(cfgPath, []byte("[unclosed section\nkey ="), 0o644); err != nil {
t.Fatalf("corrupt config error = %v", err)
}
},
wantSubstr: "read repo config",
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
ctx := context.Background()
host := newLocalRemote(t, "acme", "record-upstream")
m := newManager(t, host)
dir, branch, err := m.Prepare(ctx, "acme", "record-upstream", testBase, 105, "feat: record upstream", "", "feature")
if err != nil {
t.Fatalf("Prepare() error = %v", err)
}
r, err := git.PlainOpen(dir)
if err != nil {
t.Fatalf("PlainOpen() error = %v", err)
}
tc.setup(t, dir)
ref := plumbing.NewBranchReferenceName(branch)
err = m.recordUpstream(r, branch, ref)
if err == nil {
t.Fatalf("recordUpstream() error = nil, want error containing %q", tc.wantSubstr)
}
if !strings.Contains(err.Error(), tc.wantSubstr) {
t.Errorf("recordUpstream() error = %q, want substring %q", err.Error(), tc.wantSubstr)
}
})
}
}
// TestCommitAllHonoursCancellation covers BUG 2 (archie-core-1ysw.8).
// A cancelled context must abort CommitAll before mutating index or HEAD.
func TestCommitAllHonoursCancellation(t *testing.T) {
tests := []struct {
name string
cancelPre bool
timeout bool
wantError error
}{
{
name: "pre-cancelled context returns context.Canceled without mutating index or HEAD",
cancelPre: true,
wantError: context.Canceled,
},
{
name: "expired deadline returns context.DeadlineExceeded without mutating index or HEAD",
timeout: true,
wantError: context.DeadlineExceeded,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
ctx := context.Background()
host := newLocalRemote(t, "acme", "cancel-test")
m := newManager(t, host)
dir, _, err := m.Prepare(ctx, "acme", "cancel-test", testBase, 201, "feat: cancel test", "", "feature")
if err != nil {
t.Fatalf("Prepare() error = %v", err)
}
// Capture HEAD commit before attempting any commit.
r, err := git.PlainOpen(dir)
if err != nil {
t.Fatalf("PlainOpen() error = %v", err)
}
headBefore, err := r.Head()
if err != nil {
t.Fatalf("Head() before error = %v", err)
}
// Write a new file to the worktree.
newFile := filepath.Join(dir, "work.txt")
if err := os.WriteFile(newFile, []byte("uncommitted work\n"), 0o600); err != nil {
t.Fatalf("WriteFile() error = %v", err)
}
var testCtx context.Context
var cancel context.CancelFunc
if tc.cancelPre {
testCtx, cancel = context.WithCancel(context.Background())
cancel() // Pre-cancel
} else if tc.timeout {
var timeoutCancel context.CancelFunc
testCtx, timeoutCancel = context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
cancel = timeoutCancel
}
if cancel != nil {
defer cancel()
}
committed, commitErr := m.CommitAll(testCtx, dir, "feat: should be aborted")
if commitErr == nil {
t.Fatalf("CommitAll() error = nil, want %v", tc.wantError)
}
if !errors.Is(commitErr, tc.wantError) {
t.Fatalf("CommitAll() error = %v, want errors.Is(..., %v)", commitErr, tc.wantError)
}
if committed {
t.Errorf("CommitAll() returned committed=true on cancelled context, want false")
}
// Verify HEAD commit has NOT moved.
headAfter, err := r.Head()
if err != nil {
t.Fatalf("Head() after error = %v", err)
}
if headBefore.Hash() != headAfter.Hash() {
t.Errorf("HEAD mutated: before=%s, after=%s", headBefore.Hash(), headAfter.Hash())
}
// Verify index has NOT staged the new file (worktree status should show it untracked).
wt, err := r.Worktree()
if err != nil {
t.Fatalf("Worktree() error = %v", err)
}
status, err := wt.Status()
if err != nil {
t.Fatalf("Status() error = %v", err)
}
fileStatus := status.File("work.txt")
if fileStatus.Staging != git.Untracked {
t.Errorf("work.txt Staging status = %v, want Untracked (no index mutation)", fileStatus.Staging)
}
})
}
}
// TestBranchNamingPrecedence covers BUG 3 (archie-core-1ysw.9).
// Tests title-vs-label precedence, dead parameter removal, no-op removal,
// and 60-char slug boundary agreement.
func TestBranchNamingPrecedence(t *testing.T) {
tests := []struct {
name string
issue int
title string
labels string
want string
}{
{
name: "unlabeled issue with conventional prefix in title derives prefix from title",
issue: 12,
title: "fix: crash on empty payload",
labels: "",
want: "fix/12-crash-on-empty-payload",
},
{
name: "unlabeled issue with scoped conventional prefix in title",
issue: 13,
title: "chore(deps): update go to 1.26",
labels: "",
want: "chore/13-update-go-to-126",
},
{
name: "title conventional prefix takes precedence when title and labels disagree",
issue: 14,
title: "fix: wrong calculation",
labels: "feature,enhancement",
want: "fix/14-wrong-calculation",
},
{
name: "title feat takes precedence when label says bug",
issue: 15,
title: "feat: new export option",
labels: "bug",
want: "feat/15-new-export-option",
},
{
name: "unlabeled issue without conventional prefix falls back to default feat",
issue: 16,
title: "plain title without prefix",
labels: "",
want: "feat/16-plain-title-without-prefix",
},
{
name: "title without prefix falls back to label",
issue: 17,
title: "unexpected crash on startup",
labels: "bug",
want: "fix/17-unexpected-crash-on-startup",
},
{
name: "title without prefix with docs label",
issue: 18,
title: "update installation instructions",
labels: "docs",
want: "docs/18-update-installation-instructions",
},
{
name: "title without prefix with refactor label",
issue: 19,
title: "clean up worker loops",
labels: "refactor",
want: "refactor/19-clean-up-worker-loops",
},
{
name: "title without prefix with test label",
issue: 20,
title: "add integration tests",
labels: "test",
want: "test/20-add-integration-tests",
},
{
name: "title with uppercase prefix normalizes correctly",
issue: 21,
title: "FIX: critical issue",
labels: "",
want: "fix/21-critical-issue",
},
{
name: "colon in title that is not a commit type falls back to labels",
issue: 22,
title: "step 1: initial setup",
labels: "chore",
want: "chore/22-step-1-initial-setup",
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got := archieBranch(tc.issue, tc.title, tc.labels)
if got != tc.want {
t.Errorf("archieBranch(%d, %q, %q) = %q, want %q", tc.issue, tc.title, tc.labels, got, tc.want)
}
gotPrefix := branchPrefix(tc.title, tc.labels)
wantPrefix, _, _ := strings.Cut(tc.want, "/")
if gotPrefix != wantPrefix {
t.Errorf("branchPrefix(%q, %q) = %q, want %q", tc.title, tc.labels, gotPrefix, wantPrefix)
}
})
}
}
// TestBranchSlugBoundaryAgreesWithLimit tests the 60-char slug boundary.
func TestBranchSlugBoundaryAgreesWithLimit(t *testing.T) {
tests := []struct {
name string
title string
wantLen int
wantSlug string
maxCapLen int
}{
{
name: "short slug under 60 chars",
title: "short title",
wantLen: 11,
wantSlug: "short-title",
maxCapLen: 60,
},
{
name: "exact 60 char slug",
title: strings.Repeat("a", 60),
wantLen: 60,
wantSlug: strings.Repeat("a", 60),
maxCapLen: 60,
},
{
name: "slug is capped at exactly 60 chars for long title",
title: strings.Repeat("a", 80),
wantLen: 60,
wantSlug: strings.Repeat("a", 60),
maxCapLen: 60,
},
{
name: "long title with hyphens capped at 60",
title: "this is a very long title that exceeds sixty characters easily and goes on and on",
wantLen: 60,
wantSlug: "this-is-a-very-long-title-that-exceeds-sixty-characters-easi",
maxCapLen: 60,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
slug := branchSlug(tc.title)
if len(slug) > tc.maxCapLen {
t.Errorf("branchSlug(%q) length = %d, exceeds max cap %d", tc.title, len(slug), tc.maxCapLen)
}
if len(slug) != tc.wantLen {
t.Errorf("branchSlug(%q) length = %d, want %d", tc.title, len(slug), tc.wantLen)
}
if slug != tc.wantSlug {
t.Errorf("branchSlug(%q) = %q, want %q", tc.title, slug, tc.wantSlug)
}
})
}
}