Pull request facts come from seat git's pull, ancestry from contains, the review time from the runner's review step, and get shows one pipeline row per module (no run where the runner's list answers none). Builds: design 47 G §654, A-75 Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
242 lines
10 KiB
Go
242 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// The seat git's answer for novox/mesh-delivery#5 (shortened): merged, its merge commit and moment.
|
|
const forgePullMerged = `{"pull":{"repository":"novox/mesh-delivery","number":5,"base":"main","branch":"feat/delivery-parts",` +
|
|
`"head":"4444444444444444444444444444444444444444","state":"merged","merged-at":"2026-10-19T18:05:16Z",` +
|
|
`"merge-commit":"1325c8b452c8fa65c478af6815887870a1f42e7b"}}`
|
|
|
|
func TestAPullRequestWithNoFixRecordLearnsItsMerge(t *testing.T) {
|
|
mergedAt := time.Date(2026, 10, 19, 18, 5, 16, 0, time.UTC)
|
|
merged := Delivery{Pulled: true, Merged: true, MergedAs: "1325c8b452c8fa65c478af6815887870a1f42e7b", MergedAt: &mergedAt, Repository: "novox/mesh-catalog"}
|
|
closed := Delivery{Pulled: true, Closed: true}
|
|
open := Delivery{Pulled: true}
|
|
for _, c := range []struct {
|
|
name string
|
|
delivery Delivery
|
|
deliveryEr error
|
|
forge *Delivery
|
|
forgeEr error
|
|
want string // the delivery line after learning
|
|
wantErr bool
|
|
}{
|
|
{name: "mesh-delivery's pull says merged", delivery: merged, want: "fix merged, not delivered: mesh-catalog#50"},
|
|
{name: "mesh-delivery cannot, the forge says merged", deliveryEr: errors.New("down"), forge: &merged,
|
|
want: "fix merged, not delivered: mesh-catalog#50"},
|
|
{name: "mesh-delivery says nothing of the pull, the forge says merged", forge: &merged, want: "fix merged, not delivered: mesh-catalog#50"},
|
|
{name: "closed without merging is withdrawn", delivery: closed, want: "fix withdrawn: mesh-catalog#50 closed without merging"},
|
|
{name: "still open stays unheard", delivery: open, want: "nothing heard from the delivery of mesh-catalog#50"},
|
|
{name: "a forge that cannot say leaves it", forgeEr: errors.New("forge down"), want: "nothing heard from the delivery of mesh-catalog#50"},
|
|
{name: "neither can say", deliveryEr: errors.New("down"), forgeEr: errors.New("forge down"), want: "nothing heard from the delivery of mesh-catalog#50", wantErr: true},
|
|
} {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
h := newHarness(t)
|
|
n := fixIssue(t, h, "mesh-catalog#50")
|
|
h.Deliveries = func(string, string) (Delivery, error) { return c.delivery, c.deliveryEr }
|
|
h.Pull = func(string, string) (Delivery, error) {
|
|
if c.forge != nil {
|
|
return *c.forge, nil
|
|
}
|
|
return Delivery{}, errOr(c.forgeEr)
|
|
}
|
|
_, err := h.LearnFixes(n)
|
|
if (err != nil) != c.wantErr {
|
|
t.Fatalf("error %v, wanted error %v", err, c.wantErr)
|
|
}
|
|
if v, _ := h.View(n); v.Delivery != c.want {
|
|
t.Fatalf("%q, wanted %q", v.Delivery, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func errOr(e error) error {
|
|
if e == nil {
|
|
return errors.New("the forge has no such pull request")
|
|
}
|
|
return e
|
|
}
|
|
|
|
// A fix merged before the tracker heard deliveries: the delivered event itself learns its merge and covers it, a resolved issue's
|
|
// included; and the sweep learns it with no event.
|
|
func TestAFixMergedBeforeTheTrackerHeardDeliveriesIsDeliveredByTheNextEventOfItsRepository(t *testing.T) {
|
|
mergedAs := "1325c8b452c8fa65c478af6815887870a1f42e7b"
|
|
forge := func(string, string) (Delivery, error) {
|
|
return Delivery{Pulled: true, Merged: true, MergedAs: mergedAs, Repository: "novox/mesh-catalog"}, nil
|
|
}
|
|
contains := func(_, _, commit, in string) (bool, error) {
|
|
return commit == mergedAs && in == "ffffffffffff0000", nil
|
|
}
|
|
heads := map[string]string{"novox/mesh-catalog": "ffffffffffff0000"}
|
|
delivered := "delivered to every machine it should reach"
|
|
|
|
h := newHarness(t)
|
|
n := fixIssue(t, h, "mesh-catalog#51")
|
|
h.Pull, h.Contains = forge, contains
|
|
viewSays(t, h, 30, "", heads)
|
|
if v, _ := h.View(n); v.Delivery != delivered {
|
|
t.Fatalf("the event did not cover the old fix: %q", v.Delivery)
|
|
}
|
|
if f := fixOf(get(t, h, n), "mesh-catalog#51"); f == nil || f.MergedAs != mergedAs || f.Repository != "novox/mesh-catalog" || f.MergedAt != nil && f.MergedAt.IsZero() {
|
|
t.Fatalf("fix %+v", f)
|
|
}
|
|
|
|
// A resolved issue is learned by the sweep, which then waits for the next event, not for ever.
|
|
h2 := newHarness(t)
|
|
m := fixIssue(t, h2, "mesh-catalog#52")
|
|
if _, err := h2.Move(MoveAsk{Number: m, Status: StatusResolved, FixedBy: []string{"mesh-catalog#52"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if v, _ := h2.View(m); !strings.HasPrefix(v.Delivery, "nothing heard") {
|
|
t.Fatalf("before: %q", v.Delivery)
|
|
}
|
|
h2.Pull, h2.Contains = forge, contains
|
|
if _, err := h2.Sweep(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if v, _ := h2.View(m); v.Delivery != "fix merged, not delivered: mesh-catalog#52" {
|
|
t.Fatalf("after the sweep: %q", v.Delivery)
|
|
}
|
|
viewSays(t, h2, 31, "", heads)
|
|
if v, _ := h2.View(m); v.Delivery != delivered {
|
|
t.Fatalf("after the event: %q", v.Delivery)
|
|
}
|
|
}
|
|
|
|
func TestTheSeatGitsPullAnswerIsReadAsMerged(t *testing.T) {
|
|
d, head, err := parsePull(json.RawMessage(forgePullMerged), "novox/mesh-delivery")
|
|
if err != nil || head != "4444444444444444444444444444444444444444" {
|
|
t.Fatalf("%v %s", err, head)
|
|
}
|
|
if !d.Pulled || !d.Merged || d.Closed || d.MergedAs != "1325c8b452c8fa65c478af6815887870a1f42e7b" ||
|
|
d.MergedAt == nil || d.MergedAt.Format(time.RFC3339) != "2026-10-19T18:05:16Z" || d.Repository != "novox/mesh-delivery" {
|
|
t.Fatalf("%+v", d)
|
|
}
|
|
if d, _, _ := parsePull(json.RawMessage(`{"pull":{"state":"closed","head":"x"}}`), "novox/r"); !d.Closed || d.Merged {
|
|
t.Fatalf("closed: %+v", d)
|
|
}
|
|
if d, _, _ := parsePull(json.RawMessage(`{"pull":{"state":"open","head":"x"}}`), "novox/r"); d.Closed || d.Merged {
|
|
t.Fatalf("open: %+v", d)
|
|
}
|
|
for _, bad := range []string{`{"error":"no such pull request","error-kind":"not-found"}`, `{"pull":{}}`, `nothing`} {
|
|
if _, _, err := parsePull(json.RawMessage(bad), "novox/r"); err == nil {
|
|
t.Fatalf("%s read as a pull request", bad)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTheSeatGitsContainsAnswerIsReadAndAFailureIsNeverNo(t *testing.T) {
|
|
for raw, want := range map[string]bool{`{"commit":"a","in":"b","contains":true}`: true, `{"contains":false,"ahead":2}`: false} {
|
|
if got, err := parseContains(json.RawMessage(raw)); err != nil || got != want {
|
|
t.Fatalf("%s: %v %v", raw, got, err)
|
|
}
|
|
}
|
|
for _, bad := range []string{`{"error":"forge down","error-kind":"failed"}`, `{}`} {
|
|
if _, err := parseContains(json.RawMessage(bad)); err == nil {
|
|
t.Fatalf("%s read as an answer", bad)
|
|
}
|
|
}
|
|
}
|
|
|
|
// design 47 G §654: a repository of two modules shows two rows with their steps; a commit the runner's list answers none for
|
|
// shows "no run"; an unreadable runner is said, never read as none.
|
|
func TestAPullRequestShowsOnePipelineRowPerModuleAndNoRunWhereThereIsNone(t *testing.T) {
|
|
keys, err := parsePipelineKeys(json.RawMessage(`{"pipelines":[{"pipeline":"b.1.a","module":"a"},{"pipeline":"b.1.b","module":"b"}]}`))
|
|
if err != nil || len(keys) != 2 {
|
|
t.Fatalf("%v %v", keys, err)
|
|
}
|
|
if keys, err := parsePipelineKeys(json.RawMessage(`{"pipelines":[]}`)); err != nil || len(keys) != 0 {
|
|
t.Fatalf("%v %v", keys, err)
|
|
}
|
|
h := newHarness(t)
|
|
n := fixIssue(t, h, "mesh-catalog#50")
|
|
h.Pipelines = func(repo, number string) ([]PipelineRow, error) {
|
|
return []PipelineRow{
|
|
{PullRequest: repo + "#" + number, Module: "a", Outcome: "passed", Steps: []StepRow{{"unit", "passed"}, {"review", "passed"}}},
|
|
{PullRequest: repo + "#" + number, Module: "b", Outcome: "failed", Steps: []StepRow{{"unit", "failed"}}}}, nil
|
|
}
|
|
v, err := h.View(n)
|
|
if err != nil || len(v.Pipelines) != 2 || v.Pipelines[1].Module != "b" || len(v.Pipelines[0].Steps) != 2 {
|
|
t.Fatalf("%+v %v", v, err)
|
|
}
|
|
h.Pipelines = func(repo, number string) ([]PipelineRow, error) {
|
|
return []PipelineRow{{PullRequest: repo + "#" + number, Outcome: NoRun}}, nil
|
|
}
|
|
if v, _ := h.View(n); len(v.Pipelines) != 1 || v.Pipelines[0].Outcome != "no run" {
|
|
t.Fatalf("%+v", v.Pipelines)
|
|
}
|
|
h.Pipelines = func(string, string) ([]PipelineRow, error) { return nil, errors.New("runner down") }
|
|
if v, _ := h.View(n); len(v.Pipelines) != 1 || !strings.HasPrefix(v.Pipelines[0].Outcome, "not readable") {
|
|
t.Fatalf("%+v", v.Pipelines)
|
|
}
|
|
}
|
|
|
|
// A merge learned late is kept as of the moment it was learned: the stuck bound runs from then, so an old merge raises no
|
|
// false warning in the sweep that learned it; and an issue closed before its fix was timed keeps no fix time when a late
|
|
// delivery covers it.
|
|
func TestALearnedOldMergeRaisesNoStuckWarningAndTimesNoClosedIssue(t *testing.T) {
|
|
h := newHarness(t)
|
|
now := clocked(h)
|
|
note := ¬ified{}
|
|
h.Notify = note.notify
|
|
old := now.Add(-10 * 24 * time.Hour)
|
|
mergedAs := "1325c8b452c8fa65c478af6815887870a1f42e7b"
|
|
h.Pull = func(string, string) (Delivery, error) {
|
|
return Delivery{Pulled: true, Merged: true, MergedAs: mergedAs, MergedAt: &old, Repository: "novox/mesh-catalog"}, nil
|
|
}
|
|
h.Contains = func(_, _, commit, _ string) (bool, error) { return commit == mergedAs, nil }
|
|
open := fixIssue(t, h, "mesh-catalog#60")
|
|
closed := fixIssue(t, h, "mesh-catalog#61")
|
|
if _, err := h.Move(MoveAsk{Number: closed, Status: StatusResolved, FixedBy: []string{"mesh-catalog#61"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := h.Sweep(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(note.said) != 0 || noted(get(t, h, open), "Stuck: the fix") {
|
|
t.Fatalf("a learned old merge was said stuck in the sweep that learned it: %q", note.said)
|
|
}
|
|
if f := fixOf(get(t, h, open), "mesh-catalog#60"); f == nil || f.MergedAt == nil || !f.MergedAt.Equal(old) {
|
|
t.Fatalf("the forge's merge moment is kept: %+v", f)
|
|
}
|
|
*now = now.Add(3 * time.Hour)
|
|
if _, err := h.Sweep(); err != nil || len(note.said) != 1 {
|
|
t.Fatalf("not delivered 3 hours after it was learned: %q %v", note.said, err)
|
|
}
|
|
viewSays(t, h, 40, "", map[string]string{"novox/mesh-catalog": "ffffffffffff0000"})
|
|
if v, _ := h.View(closed); v.Delivery != "delivered to every machine it should reach" || get(t, h, closed).FixTime != nil {
|
|
t.Fatalf("closed issue: %q, fix time %+v", v.Delivery, get(t, h, closed).FixTime)
|
|
}
|
|
}
|
|
|
|
// Pull requests that cannot be learned (still open) do not starve the others: the one asked longest ago goes first.
|
|
func TestTheSweepAsksTheLeastRecentlyAskedPullRequestFirst(t *testing.T) {
|
|
h := newHarness(t)
|
|
var stuck []uint64
|
|
for i := 0; i < MostSweepAsks+2; i++ {
|
|
stuck = append(stuck, fixIssue(t, h, "mesh-catalog#"+itoa(70+i)))
|
|
}
|
|
last := fixIssue(t, h, "mesh-catalog#99")
|
|
h.Pull = func(_, number string) (Delivery, error) {
|
|
if number == "99" {
|
|
return Delivery{Pulled: true, Merged: true, MergedAs: "1325c8b452c8fa65c478af6815887870a1f42e7b"}, nil
|
|
}
|
|
return Delivery{Pulled: true}, nil // still open
|
|
}
|
|
for i := 0; i < 4; i++ {
|
|
if _, err := h.Sweep(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if v, _ := h.View(last); !strings.HasPrefix(v.Delivery, "fix merged") {
|
|
t.Fatalf("starved by pull requests that cannot be learned: %q (%d of them)", v.Delivery, len(stuck))
|
|
}
|
|
}
|