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)) } }