jschoubben
2d3b61ec45
A group has no order: mesh-delivery asks the controller for none, reads no after: line (it says once that the line is not read), merges every member in one pass once the composed check passed and the Approve covers the heads, and gives the plan its word once every member is merged. A failed member stops no other. The composed verdict sets each member's mesh/merge-gate (pending, saying why, until one stands), the groups answer says composed_gate, and a trunk move asks the out-of-date members' checks at once and merges on the same Approve (issue 1047).
413 lines
17 KiB
Go
413 lines
17 KiB
Go
package main
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// **A verdict holds for the trunk commit it judged** (novox/hq ADR 0323, issue 341). The check judges the head
|
|
// merged into a named trunk commit; when another merge moves that trunk, a ready delivery goes back to proposed,
|
|
// a rejected one stays rejected, and nothing is asked. A verdict for an old trunk is kept and shown and does not
|
|
// count, so the table reaches a fixed point. A group's composed check goes out of date on a merge that is not one of
|
|
// its members, and runs again for new heads instead of holding the group.
|
|
|
|
const (
|
|
trunk0 = "a2c2c35000000000000000000000000000000000"
|
|
merge1 = "d28ca95000000000000000000000000000000000"
|
|
)
|
|
|
|
// judged is a verdict of a head merged into a trunk commit.
|
|
func judged(repo string, number int, sha, gate, trunk string) CheckedEvent {
|
|
c := verdict(repo, number, sha, gate)
|
|
c.Trunk = shortOf(trunk, 12)
|
|
c.ID = "check-of-" + sha + "-at-" + shortOf(trunk, 8)
|
|
c.Took = "4m12s"
|
|
c.Beside = map[string]string{"mesh-catalog": "0123456789ab"}
|
|
plan := *c.Plan
|
|
plan.Head, plan.Trunk = sha, c.Trunk
|
|
c.Plan = &plan
|
|
return c
|
|
}
|
|
|
|
func TestATrunkMoveSendsAReadyDeliveryBackToProposed(t *testing.T) {
|
|
const host = "novox/mesh-host"
|
|
const h64, h66, h67 = "6464646464646464", "dfb1415dfb1415df", "6767676767676767"
|
|
w := newWorld(t)
|
|
for _, p := range []PullEvent{pr(host, 64, h64, "a"), pr(host, 66, h66, "b"), pr(host, 67, h67, "c")} {
|
|
w.h.PullUpdated(p)
|
|
}
|
|
w.h.Checked(judged(host, 64, h64, "pass", trunk0))
|
|
w.h.Checked(judged(host, 66, h66, "pass", trunk0))
|
|
w.h.Checked(judged(host, 67, h67, "fail", trunk0))
|
|
id66, id67 := IDOf(host, h66), IDOf(host, h67)
|
|
if s := w.state(id66); s != Ready {
|
|
t.Fatalf("#66 checked green against the trunk is %s", s)
|
|
}
|
|
asked := len(w.ctl.checks)
|
|
|
|
// #64 merges: the trunk moves to its merge commit.
|
|
w.h.PullMerged(merged(host, 64, h64, merge1))
|
|
w.settleAll()
|
|
d := w.delivery(id66)
|
|
if d.State != Proposed {
|
|
t.Fatalf("#66's verdict names trunk %s, the trunk is now %s, and it is %s", trunk0[:12], merge1[:12], d.State)
|
|
}
|
|
last := d.Transitions[len(d.Transitions)-1]
|
|
if last.Event != EvTrunkMoved || !strings.Contains(last.Why, trunk0[:12]) || !strings.Contains(last.Why, merge1[:12]) {
|
|
t.Fatalf("its transition was %s, %q: not trunk moved with both commits", last.Event, last.Why)
|
|
}
|
|
if d.Check == nil || d.Check.Trunk != trunk0[:12] {
|
|
t.Fatalf("its out-of-date verdict was not kept to be shown: %+v", d.Check)
|
|
}
|
|
if s := w.state(id67); s != Rejected {
|
|
t.Fatalf("a rejected delivery went to %s on the trunk's move", s)
|
|
}
|
|
if len(w.ctl.checks) != asked {
|
|
t.Fatalf("the trunk's move asked a check: %v", w.ctl.checks[asked:])
|
|
}
|
|
|
|
// Out of date and not asked: no bound, so stalled does not list it, however long it waits.
|
|
w.later(5 * time.Hour)
|
|
w.settleAll()
|
|
for _, l := range w.h.Stalled() {
|
|
if l.ID == id66 {
|
|
t.Fatalf("stalled lists a proposed delivery whose check is out of date and not asked: %+v", l)
|
|
}
|
|
}
|
|
if len(w.ctl.checks) != asked {
|
|
t.Fatalf("an out-of-date check was asked by this owner: %v", w.ctl.checks[asked:])
|
|
}
|
|
|
|
// A late verdict for the old trunk is kept, does not count, and moves nothing: the table's fixed point.
|
|
before := len(w.delivery(id66).Transitions)
|
|
late := judged(host, 66, h66, "pass", trunk0)
|
|
late.ID = "check-late"
|
|
w.h.Checked(late)
|
|
w.settleAll()
|
|
d = w.delivery(id66)
|
|
if d.State != Proposed || len(d.Transitions) != before || d.Check == nil || d.Check.ID != "check-late" {
|
|
t.Fatalf("a late verdict for an old trunk left it %s after %d transition(s), verdict %+v", d.State,
|
|
len(d.Transitions)-before, d.Check)
|
|
}
|
|
if ts := settle(d, Facts{Now: w.now}); len(ts) != 0 {
|
|
t.Fatalf("the table took %d more transition(s) on a verdict that does not count", len(ts))
|
|
}
|
|
|
|
// The check asked again judges the head merged into the trunk's head: it counts.
|
|
w.h.Checked(judged(host, 66, h66, "pass", merge1))
|
|
w.settleAll()
|
|
if s := w.state(id66); s != Ready {
|
|
t.Fatalf("a verdict judged against the trunk's head left it %s", s)
|
|
}
|
|
}
|
|
|
|
// A rejected delivery judged again against another trunk — the merge tool's ask — is taken as its recheck.
|
|
func TestARejectedDeliveryJudgedAgainstANewTrunkIsRecheckedByTheVerdict(t *testing.T) {
|
|
const repo = "novox/mesh-lab"
|
|
const head = "1a2b3c4d5e6f7a8b"
|
|
w := newWorld(t)
|
|
w.h.PullUpdated(pr(repo, 9, head, "x"))
|
|
w.h.Checked(judged(repo, 9, head, "fail", trunk0))
|
|
id := IDOf(repo, head)
|
|
if s := w.state(id); s != Rejected {
|
|
t.Fatalf("it is %s", s)
|
|
}
|
|
w.h.PullMerged(merged(repo, 8, "8888888888888888", merge1))
|
|
w.h.Checked(judged(repo, 9, head, "pass", merge1))
|
|
w.settleAll()
|
|
d := w.delivery(id)
|
|
if d.State != Ready || d.Check.Trunk != merge1[:12] {
|
|
t.Fatalf("judged green against the trunk's head it is %s with %+v", d.State, d.Check)
|
|
}
|
|
}
|
|
|
|
// **A verdict names the trunk commit it judged** in `checks` and `show`, and the kept plan records it (ADR 0323 §3).
|
|
func TestChecksAndShowNameTheHeadAndTheTrunkCommit(t *testing.T) {
|
|
const repo = "novox/mesh-lab"
|
|
const head = "1a2b3c4d5e6f7a8b"
|
|
w := newWorld(t)
|
|
w.h.PullUpdated(pr(repo, 9, head, "x"))
|
|
w.h.Checked(judged(repo, 9, head, "pass", trunk0))
|
|
id := IDOf(repo, head)
|
|
|
|
a, err := w.h.Checks(repo, 0, head)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := "head " + head[:12] + " merged into trunk " + trunk0[:12]
|
|
if a.Judged != want || a.Verdict == nil || a.Verdict.Head != head[:12] || a.Verdict.Trunk != trunk0[:12] {
|
|
t.Fatalf("checks says %q, verdict %+v; want %q", a.Judged, a.Verdict, want)
|
|
}
|
|
if !strings.Contains(a.Says, want) {
|
|
t.Fatalf("checks' words do not say what was judged: %s", a.Says)
|
|
}
|
|
if a.Verdict.Beside["mesh-catalog"] != "0123456789ab" || a.Verdict.Took != "4m12s" {
|
|
t.Fatalf("checks does not name the other repositories' commits or how long it took: %+v", a.Verdict)
|
|
}
|
|
shown, err := w.h.Show(id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
d := shown.(map[string]any)["delivery"].(*Delivery)
|
|
if d.Check.Head != head[:12] || d.Check.Trunk != trunk0[:12] {
|
|
t.Fatalf("show gives the verdict %+v", d.Check)
|
|
}
|
|
if d.Plan == nil || d.Plan.Trunk != trunk0[:12] || d.Plan.Head != head {
|
|
t.Fatalf("the kept delivery plan records %+v", d.Plan)
|
|
}
|
|
|
|
w.h.PullMerged(merged(repo, 8, "8888888888888888", merge1))
|
|
if a, _ = w.h.Checks(repo, 0, head); !strings.Contains(a.OutOfDate, merge1[:12]) {
|
|
t.Fatalf("checks does not say the verdict is out of date: %+v", a)
|
|
}
|
|
}
|
|
|
|
// **A delivery group's composed check follows the same rule** (ADR 0323 §6, §7): a merge that is not one of its
|
|
// members into a member's trunk puts it out of date and the group reads checking; its own members merging in its
|
|
// order do not; and it runs again once a member is judged again.
|
|
func TestAGroupsComposedCheckGoesOutOfDateOnAMergeThatIsNotItsMember(t *testing.T) {
|
|
const ctl, cat = "novox/mesh-controller", "novox/mesh-catalog"
|
|
const hc, hk = "c1c1c1c1c1c1c1c1", "k1k1k1k1k1k1k1k1"
|
|
idc, idk := IDOf(ctl, hc), IDOf(cat, hk)
|
|
start := func(t *testing.T) *world {
|
|
w := newWorld(t)
|
|
w.h.PullUpdated(pr(ctl, 1, hc, "feat/g"))
|
|
w.h.PullUpdated(pr(cat, 2, hk, "feat/g"))
|
|
w.h.Checked(judged(ctl, 1, hc, "pass", trunk0))
|
|
w.h.Checked(judged(cat, 2, hk, "pass", trunk0))
|
|
w.settleAll()
|
|
g := w.h.groups["feat/g"]
|
|
if g == nil || g.Check == nil {
|
|
t.Fatalf("no composed check was asked: %+v", g)
|
|
}
|
|
w.h.Checked(CheckedEvent{Group: "feat/g", ID: g.Check.Asked, Verdict: "pass", Summary: "composed",
|
|
Members: []struct {
|
|
Owner string `json:"owner"`
|
|
Repo string `json:"repo"`
|
|
Commit string `json:"commit"`
|
|
Trunk string `json:"trunk,omitempty"`
|
|
}{{Owner: "novox", Repo: "mesh-controller", Commit: hc, Trunk: trunk0[:12]},
|
|
{Owner: "novox", Repo: "mesh-catalog", Commit: hk, Trunk: trunk0[:12]}}})
|
|
w.settleAll()
|
|
if state, _ := GroupState(g, w.h.membersOf(g)); state != "ready" {
|
|
t.Fatalf("the group composed green is %s", state)
|
|
}
|
|
if g.Check.Trunks[idc] != trunk0[:12] {
|
|
t.Fatalf("the composed check names its members' trunks %v", g.Check.Trunks)
|
|
}
|
|
return w
|
|
}
|
|
|
|
t.Run("a merge that is not a member", func(t *testing.T) {
|
|
w := start(t)
|
|
asked := len(w.ctl.checks)
|
|
w.h.PullMerged(merged(ctl, 5, "5555555555555555", merge1))
|
|
w.settleAll()
|
|
g := w.h.groups["feat/g"]
|
|
state, why := GroupState(g, w.h.membersOf(g))
|
|
if state != "checking" || g.Check.OutOfDate == "" {
|
|
t.Fatalf("the group is %s (%s) after a merge that is not its member moved a member's trunk", state, why)
|
|
}
|
|
for _, head := range []string{ctl + "@" + hc, cat + "@" + hk} {
|
|
s := w.forge.statuses[head+" "+ctxGroup]
|
|
if !strings.HasPrefix(s, "pending ") || !strings.Contains(s, "out of date") {
|
|
t.Fatalf("mesh/delivery-group on %s says %q, not pending with the reason", head, s)
|
|
}
|
|
}
|
|
// The group's Approve stays; each member whose verdict went out of date has its check asked at once, against the
|
|
// trunk's head (ADR 0421 §3, issue 1047): only the member whose trunk moved, and the composed check is asked
|
|
// after it.
|
|
if got := w.ctl.checks[asked:]; len(got) != 1 || got[0] != ":"+idc {
|
|
t.Fatalf("the trunk's move asked %v; wanted the moved member's own check once", got)
|
|
}
|
|
asked++
|
|
// The controller's member judged again against the trunk's head: the composed check runs again.
|
|
w.later(time.Minute)
|
|
w.h.Checked(judged(ctl, 1, hc, "pass", merge1))
|
|
w.settleAll()
|
|
if len(w.ctl.checks) == asked || !strings.HasPrefix(w.ctl.checks[len(w.ctl.checks)-1], "feat/g:") {
|
|
t.Fatalf("the composed check was not asked again once a member was judged again: %v", w.ctl.checks)
|
|
}
|
|
})
|
|
|
|
t.Run("its own member merging", func(t *testing.T) {
|
|
w := start(t)
|
|
mc := merged(ctl, 1, hc, merge1)
|
|
mc.Head = "feat/g"
|
|
w.h.PullMerged(mc)
|
|
w.settleAll()
|
|
g := w.h.groups["feat/g"]
|
|
if g.Check.OutOfDate != "" {
|
|
t.Fatalf("the group's own member merging put its composed check out of date: %s", g.Check.OutOfDate)
|
|
}
|
|
if s := w.state(idk); s != Ready {
|
|
t.Fatalf("the catalogue's member, in another repository, is %s", s)
|
|
}
|
|
})
|
|
}
|
|
|
|
// **After a member is rebased or pushed, the composed check runs again for the new heads** and the group reads
|
|
// checking, not held (ADR 0323 §6, issue 406's second symptom): its first member merged, closing the group, and then
|
|
// its second was rebased just before its own merge.
|
|
func TestARebasedMemberIsComposedAgainNotHeld(t *testing.T) {
|
|
const ctl, cat = "novox/mesh-controller", "novox/mesh-catalog"
|
|
const hc, hk, hc2 = "c1c1c1c1c1c1c1c1", "k1k1k1k1k1k1k1k1", "c2c2c2c2c2c2c2c2"
|
|
idc, idk, idc2 := IDOf(ctl, hc), IDOf(cat, hk), IDOf(ctl, hc2)
|
|
w := newWorld(t)
|
|
w.op.auto = false // the merges are heard as events below, as when the forge refused one
|
|
w.h.PullUpdated(pr(ctl, 1, hc, "feat/g"))
|
|
w.h.PullUpdated(pr(cat, 2, hk, "feat/g"))
|
|
w.h.Checked(judged(ctl, 1, hc, "pass", trunk0))
|
|
w.h.Checked(judged(cat, 2, hk, "pass", trunk0))
|
|
w.settleAll()
|
|
g := w.h.groups["feat/g"]
|
|
w.h.Checked(CheckedEvent{Group: "feat/g", ID: g.Check.Asked, Verdict: "pass", Summary: "composed"})
|
|
w.settleAll()
|
|
|
|
// The catalogue's member merges first: the group is closed.
|
|
mk := merged(cat, 2, hk, merge1)
|
|
mk.Head = "feat/g"
|
|
w.h.PullMerged(mk)
|
|
w.h.WalkMoved(w.ctl.put(aWalk("plan-cat", cat, merge1, true)))
|
|
w.settleAll()
|
|
if !g.Closed {
|
|
t.Fatal("the group is not closed once a member merged")
|
|
}
|
|
|
|
// The controller's member is rebased just before its merge: a new head, with its own check.
|
|
w.h.PullUpdated(pr(ctl, 1, hc2, "feat/g"))
|
|
w.settleAll()
|
|
if d := w.delivery(idc2); d.Group != "feat/g" {
|
|
t.Fatalf("the rebased head did not take its place in its closed group: %q", d.Group)
|
|
}
|
|
if containsString(g.Members, idc) || !containsString(g.Members, idc2) || len(g.Members) != 2 {
|
|
t.Fatalf("the group's members are %v", g.Members)
|
|
}
|
|
if state, why := GroupState(g, w.h.membersOf(g)); state != "checking" {
|
|
t.Fatalf("the group reads %s (%s), not checking", state, why)
|
|
}
|
|
w.h.Checked(judged(ctl, 1, hc2, "pass", trunk0))
|
|
w.settleAll()
|
|
asked := w.ctl.checks[len(w.ctl.checks)-1]
|
|
if !strings.HasPrefix(asked, "feat/g:") || !strings.Contains(asked, idc2) || !strings.Contains(asked, idk) {
|
|
t.Fatalf("the composed check was not asked again for the new heads: %v", w.ctl.checks)
|
|
}
|
|
if state, why := GroupState(g, w.h.membersOf(g)); state != "checking" {
|
|
t.Fatalf("the group reads %s (%s), not checking", state, why)
|
|
}
|
|
for _, id := range []string{idk, idc2} {
|
|
if d := w.delivery(id); d.State == Held {
|
|
t.Fatalf("%s is held for a person: %s", id, d.HeldWhy)
|
|
}
|
|
}
|
|
// Its verdict for the new heads: the rebased member merges and takes its turn.
|
|
w.h.Checked(CheckedEvent{Group: "feat/g", ID: g.Check.Asked, Verdict: "pass", Summary: "composed again"})
|
|
mc := merged(ctl, 1, hc2, "e0e0e0e0e0e0e0e0")
|
|
mc.Head = "feat/g"
|
|
w.h.PullMerged(mc)
|
|
w.h.WalkMoved(w.ctl.put(aWalk("plan-ctl", ctl, "e0e0e0e0e0e0e0e0", true)))
|
|
w.settleAll()
|
|
if d := w.delivery(idc2); d.State == Held {
|
|
t.Fatalf("the rebased member, composed green for the new heads, is held: %s", d.HeldWhy)
|
|
}
|
|
}
|
|
|
|
// A head whose merge check the forge's holder put out of date is not a check asked and not answered: `stalled` does
|
|
// not list it, however long it waits — rejected, or with no delivery here — until its check is asked (ADR 0323 §7).
|
|
func TestAnOutOfDateCheckOnTheForgeIsNotSaidUnanswered(t *testing.T) {
|
|
const repo = "novox/mesh-lab"
|
|
const head = "1a2b3c4d5e6f7a8b9c0d"
|
|
w := newWorld(t)
|
|
w.h.PullUpdated(pr(repo, 9, head, "x"))
|
|
w.h.Checked(judged(repo, 9, head, "fail", trunk0))
|
|
words := outOfDateWords(trunk0, merge1)
|
|
pending := func(description, at string) map[string]HeadCheck {
|
|
return map[string]HeadCheck{ctxGate: {State: "pending", Description: description, UpdatedAt: at},
|
|
ctxRepo: {State: "pending", Description: description, UpdatedAt: at}}
|
|
}
|
|
w.forge.open = []OpenPull{{Owner: "novox", Repo: "mesh-lab", Number: 9, Base: "main", HeadSHA: head,
|
|
Required: []string{ctxGate, ctxRepo}, Statuses: []string{ctxGate, ctxRepo}, Checks: pending(words, "2026-10-06T12:01:00Z")}}
|
|
w.h.SeeOpenPulls()
|
|
w.later(3 * time.Hour)
|
|
w.h.SeeOpenPulls()
|
|
for _, l := range w.h.Stalled() {
|
|
if strings.HasPrefix(l.ID, repo) {
|
|
t.Fatalf("an out-of-date check nobody asked is said stalled: %+v", l)
|
|
}
|
|
}
|
|
// Asked by the merge tool: pending anew, and its bound runs from then.
|
|
w.forge.open[0].Checks = pending("waiting in the build queue since 15:01: asked by the merge tool", "2026-10-06T15:01:00Z")
|
|
w.h.SeeOpenPulls()
|
|
w.later(2 * time.Hour)
|
|
w.h.SeeOpenPulls()
|
|
said := false
|
|
for _, l := range w.h.Stalled() {
|
|
said = said || l.State == Unanswered
|
|
}
|
|
if !said {
|
|
t.Fatal("a check the merge tool asked and that never answered is not said")
|
|
}
|
|
}
|
|
|
|
// The merge tool's ask announces an out-of-date head again: its one-hour bound runs from then, and a check that never
|
|
// answers is said stalled (ADR 0323 §7).
|
|
func TestAnOutOfDateDeliveryAskedAgainIsBoundFromTheAsk(t *testing.T) {
|
|
const repo = "novox/mesh-lab"
|
|
const head = "1a2b3c4d5e6f7a8b"
|
|
w := newWorld(t)
|
|
w.h.PullUpdated(pr(repo, 9, head, "x"))
|
|
w.h.Checked(judged(repo, 9, head, "pass", trunk0))
|
|
w.h.PullMerged(merged(repo, 8, "8888888888888888", merge1))
|
|
id := IDOf(repo, head)
|
|
w.later(3 * time.Hour)
|
|
w.h.PullUpdated(pr(repo, 9, head, "x")) // the merge tool asked its check
|
|
w.later(30 * time.Minute)
|
|
for _, l := range w.h.Stalled() {
|
|
if l.ID == id {
|
|
t.Fatalf("listed half an hour after its check was asked again: %+v", l)
|
|
}
|
|
}
|
|
w.later(time.Hour)
|
|
said := false
|
|
for _, l := range w.h.Stalled() {
|
|
if l.ID == id {
|
|
said = true
|
|
if !strings.Contains(l.Says, "asked again") || !strings.Contains(l.H2, "operator") {
|
|
t.Fatalf("its stalled line says %+v", l)
|
|
}
|
|
}
|
|
}
|
|
if !said {
|
|
t.Fatal("a check asked again that never answered is not said")
|
|
}
|
|
// Its verdict judged against the trunk's head: ready, and nothing bounds it as proposed.
|
|
w.h.Checked(judged(repo, 9, head, "pass", merge1))
|
|
if d := w.delivery(id); d.State != Ready || d.AskedAgain != nil {
|
|
t.Fatalf("judged again it is %s, asked again %v", d.State, d.AskedAgain)
|
|
}
|
|
}
|
|
|
|
// A check this owner asks — a recheck — sends the base head the forge last announced the head with, so the
|
|
// controller's verdict for a head no build judges names its trunk commit (ADR 0323 §3, review of mesh-controller#271).
|
|
func TestARecheckSendsTheAnnouncedBaseHead(t *testing.T) {
|
|
const repo = "novox/mesh-tools-go"
|
|
const head = "1a2b3c4d5e6f7a8b"
|
|
w := newWorld(t)
|
|
p := pr(repo, 3, head, "x")
|
|
p.BaseSHA = trunk0
|
|
w.h.PullUpdated(p)
|
|
id := IDOf(repo, head)
|
|
if m := MemberOf(w.delivery(id)); m.BaseSHA != trunk0 {
|
|
t.Fatalf("the member sends base head %q", m.BaseSHA)
|
|
}
|
|
p.BaseSHA = merge1 // announced again, by the merge tool
|
|
w.h.PullUpdated(p)
|
|
if m := MemberOf(w.delivery(id)); m.BaseSHA != merge1 {
|
|
t.Fatalf("announced again, the member sends base head %q", m.BaseSHA)
|
|
}
|
|
if raw := string(mustJSON(MemberOf(w.delivery(id)))); !strings.Contains(raw, `"base_sha":"`+merge1+`"`) {
|
|
t.Fatalf("the member as the controller reads it: %s", raw)
|
|
}
|
|
}
|