Files
mesh-catalog/modules/mesh-issues/cmd/mesh-issues/learn_test.go
T
jschoubben c854373840 ISSUES: mesh-issues reads git.pull, git.contains and the runner's list and show, not mesh-delivery.checks and the forge's tools
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
2026-11-11 23:05:28 +01:00

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 := &notified{}
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))
}
}