package service
import (
"context"
"strings"
"testing"
"time"
"sourcecraft.dev/bigbes/sr-ht-spec/core"
"sourcecraft.dev/bigbes/sr-ht-spec/gitx"
)
// facts builds a SpaceFacts with the clock and grace fixed, so a case only has
// to say what it is about.
func facts(head, indexRev string, proposals ...ProposalFact) SpaceFacts {
return SpaceFacts{
Space: fxSpace,
SpaceID: 1,
ApprovedHead: head,
IndexRev: indexRev,
Proposals: proposals,
Now: fxTime(60),
Grace: DefaultReconcileGrace,
}
}
const (
headRev = "1f0c1d1a1e2b3c4d5e6f708192a3b4c5d6e7f809"
branchRev = "2a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d"
baseRev = "3b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e"
)
// The four rows of the design's repair table, plus every state that must be
// left alone. Nothing here touches git or Postgres.
func TestPlanRepairs(t *testing.T) {
old := fxTime(0) // an hour before Now: well past the grace window
fresh := fxTime(59) // one minute before Now: still in flight
tests := []struct {
name string
facts SpaceFacts
want []RepairKind
}{
{
name: "nothing to do",
facts: facts(headRev, headRev),
},
{
// Crash between the row insert and the branch write. The row holds
// no content and the agent still has the document it wanted.
name: "open row with no branch",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true,
State: core.StateOpen, Created: old,
}),
want: []RepairKind{RepairDeleteRow},
},
{
// The same state a live propose passes through. Deleting it would
// destroy an agent's work at random and never in a test.
name: "open row with no branch, still inside the grace window",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true,
State: core.StateOpen, Created: fresh,
}),
},
{
// The id is a Postgres serial and title, rationale, base_rev and
// provenance live nowhere in a ref, so the row cannot be rebuilt.
name: "orphan ref with no row",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasBranch: true, BranchHead: branchRev,
}),
want: []RepairKind{RepairDeleteRef},
},
{
name: "orphan ref whose name carries no id",
facts: facts(headRev, headRev, ProposalFact{
Branch: "proposals/scratch", HasBranch: true, BranchHead: branchRev,
}),
want: []RepairKind{RepairDeleteRef},
},
{
// Crash between the merge commit and the row update. The ref is
// truth for merged-ness.
name: "open row whose branch merged into the approved head",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true, HasBranch: true,
State: core.StateOpen, Created: old, MergedIntoApproved: true,
BranchHead: branchRev, BaseRev: baseRev,
}),
want: []RepairKind{RepairMarkMerged},
},
{
// A branch still sitting on its base has no content and cannot have
// merged, even though its tip is trivially an ancestor of the head.
// This is the state every propose passes through between cutting
// the branch and the agent's first commit.
name: "open row whose branch was cut but never committed to",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true, HasBranch: true,
State: core.StateOpen, Created: old, MergedIntoApproved: true,
BranchHead: baseRev, BaseRev: baseRev,
}),
},
{
// Repairing on facts we could not establish is worse than leaving
// the row open where a human can see it.
name: "open row whose base could not be resolved",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true, HasBranch: true,
State: core.StateOpen, Created: old, MergedIntoApproved: true,
BranchHead: branchRev,
}),
},
{
name: "ordinary open proposal",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true, HasBranch: true,
State: core.StateOpen, Created: old,
}),
},
{
// A merged or rejected proposal keeps its branch and its row.
// Neither is a half-finished write.
name: "merged proposal that still has its branch",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true, HasBranch: true,
State: core.StateMerged, Created: old, MergedIntoApproved: true,
BranchHead: branchRev, BaseRev: baseRev,
}),
},
{
name: "rejected proposal that still has its branch",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true, HasBranch: true,
State: core.StateRejected, Created: old,
}),
},
{
name: "rejected proposal whose branch is gone",
facts: facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true,
State: core.StateRejected, Created: old,
}),
},
{
name: "index stamp behind the approved head",
facts: facts(headRev, branchRev),
want: []RepairKind{RepairReindex},
},
{
// A missing stamp is stale, never "up to date".
name: "space that has never been indexed",
facts: facts(headRev, ""),
want: []RepairKind{RepairReindex},
},
{
name: "several repairs in one space",
facts: facts(headRev, branchRev,
ProposalFact{ID: 1, Branch: "proposals/1", HasRow: true,
State: core.StateOpen, Created: old},
ProposalFact{ID: 2, Branch: "proposals/2", HasBranch: true, BranchHead: branchRev},
ProposalFact{ID: 3, Branch: "proposals/3", HasRow: true, HasBranch: true,
State: core.StateOpen, Created: old, MergedIntoApproved: true,
BranchHead: branchRev, BaseRev: baseRev},
),
want: []RepairKind{RepairDeleteRow, RepairDeleteRef, RepairMarkMerged, RepairReindex},
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got := PlanRepairs(tc.facts)
if len(got) != len(tc.want) {
t.Fatalf("repairs = %v, want %v", kinds(got), tc.want)
}
for i, want := range tc.want {
if got[i].Kind != want {
t.Fatalf("repairs = %v, want %v", kinds(got), tc.want)
}
if got[i].Space != fxSpace || got[i].SpaceID != 1 {
t.Errorf("repair %d lost its space: %+v", i, got[i])
}
if got[i].Reason == "" {
t.Errorf("repair %d has no reason for the log", i)
}
}
})
}
}
// The approval kind existed only in the memory of the process that died. Of the
// two available lies, "policy" is the safe one: "human" would launder
// unreviewed content as blessed, while "policy" puts the proposal in the digest
// where a human sees it again.
func TestPlanRepairsRecordsAPolicyApprovalOnARepairedMerge(t *testing.T) {
got := PlanRepairs(facts(headRev, headRev, ProposalFact{
ID: 42, Branch: "proposals/42", HasRow: true, HasBranch: true,
State: core.StateOpen, Created: fxTime(0), MergedIntoApproved: true,
BranchHead: branchRev, BaseRev: baseRev,
}))
if len(got) != 1 {
t.Fatalf("repairs = %v", kinds(got))
}
if got[0].Approval != core.ApprovalPolicy {
t.Errorf("approval = %q, want %q", got[0].Approval, core.ApprovalPolicy)
}
if got[0].Rev != headRev {
t.Errorf("merged rev = %q, want the approved head", got[0].Rev)
}
}
func TestPlanRepairsIgnoresAnUnknownApprovedHead(t *testing.T) {
if got := PlanRepairs(facts("", "")); len(got) != 0 {
t.Fatalf("repairs = %v, want none when the approved head is unknown", kinds(got))
}
}
func kinds(rs []Repair) []RepairKind {
out := make([]RepairKind, 0, len(rs))
for _, r := range rs {
out = append(out, r.Kind)
}
return out
}
func TestDeleteProposalRefRemovesOnlyProposalBranches(t *testing.T) {
svc, root := newService(t)
sp := newSpace(t, root, 1)
ctx := context.Background()
commitFiles(t, sp, sp.ApprovedBranch(), 1, map[string][]byte{
"specs/0007.md": mdDoc("SPEC-0007", "Storage", "one"),
})
cutBranch(t, sp, "proposals/1", sp.ApprovedBranch())
if err := svc.deleteProposalRef(ctx, sp, "proposals/1"); err != nil {
t.Fatalf("deleteProposalRef: %v", err)
}
branches, err := sp.Repo.ListProposalBranches(ctx)
if err != nil {
t.Fatalf("ListProposalBranches: %v", err)
}
if len(branches) != 0 {
t.Fatalf("branches = %+v, want none", branches)
}
// The namespace check is the only thing between a caller bug and a deleted
// approved branch.
err = svc.deleteProposalRef(ctx, sp, sp.ApprovedBranch())
if err == nil {
t.Fatal("deleted the approved branch")
}
if !strings.Contains(err.Error(), gitx.ProposalPrefix) {
t.Errorf("err = %v, want it to name the only deletable namespace", err)
}
if _, err := sp.Repo.ApprovedHead(ctx); err != nil {
t.Fatalf("approved branch is gone: %v", err)
}
}
func TestApplyRepairRefusesAnUnimplementedKind(t *testing.T) {
svc, root := newService(t)
sp := newSpace(t, root, 1)
err := svc.applyRepair(context.Background(), sp, Repair{Kind: "invented"})
if err == nil {
t.Fatal("an unknown repair kind was silently ignored")
}
}
func TestRunReconcilerStopsWithItsContext(t *testing.T) {
svc, _ := newService(t)
ctx, cancel := context.WithCancel(context.Background())
done := make(chan struct{})
var passes int
go func() {
defer close(done)
svc.RunReconciler(ctx, time.Hour, func(*ReconcileReport, error) {
passes++
cancel()
})
}()
select {
case <-done:
case <-time.After(10 * time.Second):
t.Fatal("RunReconciler did not return after its context was cancelled")
}
// The startup pass is the half that matters: a daemon killed mid-merge
// repairs itself on the next boot with no manual intervention.
if passes != 1 {
t.Errorf("passes = %d, want the one startup pass", passes)
}
}