Ask mesh-delivery whether a merge's group still assembles (hq issue 525)

A merge from any head waited for the window because the controller could not see a group's members, so the window skip changed nothing in production and unrelated merges walked one after another. The controller now asks mesh-delivery's groups, within 3 s and before the plans are held: a merge waits only when its head's group has another member whose pull request is open and whose merge it does not keep yet (ADR 0306 §2). No answer means it waits, and its batch says why. A headed merge in no waiting group and related to no batch is cut at once, as one from no head is (ADR 0304 §1, ADR 0306 §3). The controller's grant names mesh-delivery.groups. The installer's first user list in mesh-host must carry it too before the genesis test can pass.
2026-10-12 12:14:46 +02:00
parent 6196a4815e
commit 4d203b5a5d
8 changed files with 312 additions and 45 deletions
@@ -1,6 +1,8 @@
 package main

 import (
+	"context"
+	"errors"
 	"strings"
 	"testing"
 	"time"
@@ -35,6 +37,7 @@ func TestARelatedMergeJoinsTheBatchAndWaitsForTheWindow(t *testing.T) {
 	for _, c := range []string{"same repository", "a module in common", "an edge of the graph", "the same group head"} {
 		t.Run(c, func(t *testing.T) {
 			open := windowed(t)
+			groupsWaiting(t, "pr/c1")
 			asksWithPaths(t)
 			inv := open.inventory
 			first := repoMerge("one", "c1", t0)
@@ -90,39 +93,103 @@ func TestARelatedMergeJoinsTheBatchAndWaitsForTheWindow(t *testing.T) {
 	}
 }

-// A merge from a head names its delivery group, which may have a member still to merge: it waits for the window
-// even with no batch assembling, and beside a batch it shares nothing with, in a batch of its own (ADR 0306
-// decision 2). A merge from another head that shares nothing does not join it.
+// A merge from a head whose delivery group has a member still to merge waits for the window, even with no batch
+// assembling, and says why; its sibling joins the same batch by their head (ADR 0306 decision 2). A merge from a
+// head that names no group shares nothing and is cut at once, as one from no head is.
 func TestAMergeOfAGroupWaitsEvenAlone(t *testing.T) {
 	open := windowed(t)
 	asksWithPaths(t)
+	groupsWaiting(t, "feat/x")
 	hear(t, open, fromHead(repoMerge("one", "c1", t0), "feat/x"), t0)
 	ws, bs := walks(t, open)
 	if len(ws) != 0 || len(bs) != 1 || bs[0].Delivery.Batch.CutAtOnce || windowClosed(bs[0], t0) {
 		t.Fatalf("a group's merge alone: %d walk(s), batches %+v", len(ws), bs)
 	}
-	if !strings.HasPrefix(batchWords(bs[0], t0), "assembling: 90 s left") {
-		t.Fatalf("it reads %q", batchWords(bs[0], t0))
+	if words := batchWords(bs[0], t0); !strings.HasPrefix(words, "assembling: 90 s left") ||
+		!strings.Contains(words, "group feat/x has a member still to merge: novox/elsewhere (ready)") {
+		t.Fatalf("it reads %q", words)
 	}
-	hear(t, open, fromHead(repoMerge("two", "c2", t0.Add(5*time.Second)), "feat/y"), t0.Add(5*time.Second))
-	if _, bs := walks(t, open); len(bs) != 2 {
-		t.Fatalf("a merge sharing nothing joined another's batch: %d batch(es)", len(bs))
+	hear(t, open, fromHead(repoMerge("two", "c2", t0.Add(5*time.Second)), "feat/x"), t0.Add(5*time.Second))
+	if _, bs := walks(t, open); len(bs) != 1 || len(bs[0].Delivery.Merges) != 2 {
+		t.Fatalf("the group's second member did not join the first: %+v", bs)
 	}
-	cutAt(t, open, t0.Add(89*time.Second))
+	cutAt(t, open, t0.Add(94*time.Second))
 	if ws, _ := walks(t, open); len(ws) != 0 {
 		t.Fatalf("cut before its window closed: %+v", ws)
 	}
-	cutAt(t, open, t0.Add(90*time.Second))
+	cutAt(t, open, t0.Add(95*time.Second))
 	ws, bs = walks(t, open)
-	if len(ws) != 1 || ws[0].Commit != "c1" || len(bs) != 1 {
+	if len(ws) != 1 || len(bs) != 0 || ws[0].CommitOf("novox/one") != "c1" || ws[0].CommitOf("novox/two") != "c2" {
 		t.Fatalf("at its window: %d walk(s) %+v, %d batch(es)", len(ws), ws, len(bs))
 	}
 }

+// A merge from a head that names no group, sharing nothing, with no walk open, is cut at once.
+func TestAHeadedMergeInNoGroupIsCutAtOnce(t *testing.T) {
+	open := windowed(t)
+	asksWithPaths(t)
+	hear(t, open, fromHead(repoMerge("one", "c1", t0), "fix/alone"), t0)
+	if ws, bs := walks(t, open); len(ws) != 1 || len(bs) != 0 || !ws[0].Open() {
+		t.Fatalf("a headed merge in no group: %d walk(s), %d batch(es)", len(ws), len(bs))
+	}
+}
+
+// When mesh-delivery cannot say a head's group, the merge waits for the window, the safe side, and its batch says
+// why.
+func TestAGroupNobodyCanSayWaits(t *testing.T) {
+	open := windowed(t)
+	asksWithPaths(t)
+	was := deliveryGroupOf
+	deliveryGroupOf = func(context.Context, bool, string) ([]groupMember, bool, error) {
+		return nil, false, errors.New("nothing serves mesh-delivery.groups")
+	}
+	t.Cleanup(func() { deliveryGroupOf = was })
+	hear(t, open, fromHead(repoMerge("one", "c1", t0), "feat/x"), t0)
+	ws, bs := walks(t, open)
+	if len(ws) != 0 || len(bs) != 1 || bs[0].Delivery.Batch.CutAtOnce {
+		t.Fatalf("a merge whose group nobody could say: %d walk(s), batches %+v", len(ws), bs)
+	}
+	if words := batchWords(bs[0], t0); !strings.Contains(words, "mesh-delivery did not say whether group feat/x has a "+
+		"member still to merge (nothing serves mesh-delivery.groups): it waits for the window, the safe side") {
+		t.Fatalf("it reads %q", words)
+	}
+}
+
+// A member counts as still to merge only while its pull request is open, and not once this controller keeps its
+// merge: a group whose other members are merged or closed makes nobody wait.
+func TestAGroupsMergedOrClosedMembersMakeNobodyWait(t *testing.T) {
+	open := windowed(t)
+	asksWithPaths(t)
+	ctx := t.Context()
+	members := []groupMember{{Repository: "novox/one", State: "ready"}, {Repository: "novox/two", State: "published"},
+		{Repository: "novox/three", State: "stopped"}}
+	was := deliveryGroupOf
+	deliveryGroupOf = func(context.Context, bool, string) ([]groupMember, bool, error) { return members, true, nil }
+	t.Cleanup(func() { deliveryGroupOf = was })
+	m := fromHead(repoMerge("one", "c1", t0), "feat/x")
+	if why, err := groupWait(ctx, open.inventory, m, true); err != nil || why != "" {
+		t.Fatalf("the group's other members are merged or closed, yet: %q %v", why, err)
+	}
+	members = append(members, groupMember{Repository: "novox/four", State: "checked"})
+	if why, _ := groupWait(ctx, open.inventory, m, true); !strings.Contains(why, "novox/four (checked)") {
+		t.Fatalf("an open member: %q", why)
+	}
+	// novox/four's merge is kept in a batch already: merged, whatever mesh-delivery says yet.
+	hear(t, open, fromHead(repoMerge("two", "c4", t0), "feat/x"), t0)
+	members[3].Repository = "novox/two"
+	if why, _ := groupWait(ctx, open.inventory, m, true); why != "" {
+		t.Fatalf("a member this controller keeps the merge of still waits: %q", why)
+	}
+	if got := memberOf("novox/mesh-sdk@d41d255f28ad (held)"); got != (groupMember{Repository: "novox/mesh-sdk", State: "held"}) {
+		t.Fatalf("a member reads %+v", got)
+	}
+}
+
 // A merge related to two batches assembling folds the newer into the older, which answers every merge of both
 // and names nothing twice; the folded one names the batch that took it over.
 func TestAMergeRelatedToTwoBatchesFoldsThem(t *testing.T) {
 	open := windowed(t)
+	groupsWaiting(t, "feat/a", "feat/b")
 	asksWithPaths(t)
 	ctx := t.Context()
 	hear(t, open, fromHead(repoMerge("one", "c1", t0), "feat/a"), t0)
@@ -164,6 +231,7 @@ func TestAMergeRelatedToTwoBatchesFoldsThem(t *testing.T) {
 // 0276 decision 4); it is cut once that walk ended, with no window to wait for.
 func TestACutAtOnceBatchQueuesBehindAnOpenWalk(t *testing.T) {
 	open := windowed(t)
+	groupsWaiting(t, "pr/c1")
 	asksWithPaths(t)
 	hear(t, open, repoMerge("one", "c1", t0), t0)
 	cutAt(t, open, t0.Add(90*time.Second))
@@ -201,6 +269,7 @@ func TestACutAtOnceBatchQueuesBehindAnOpenWalk(t *testing.T) {
 // change, whose window the stop would close.
 func TestAStopWalksTheOthersAgainInABatchOfTheirOwnWhenTheyShareNothing(t *testing.T) {
 	open := windowed(t)
+	groupsWaiting(t, "pr/cat1aaaaaaaa")
 	endsItsLine(t)
 	asksRecorded(t)
 	ctx := t.Context()
@@ -236,6 +305,7 @@ func TestAStopWalksTheOthersAgainInABatchOfTheirOwnWhenTheyShareNothing(t *testi
 // its window, rather than being cut at once as sharing nothing with what the batch's own merges move.
 func TestALoneMergeRelatedToAWalkTheCutFoldsJoinsTheBatch(t *testing.T) {
 	open := windowed(t)
+	groupsWaiting(t, "pr/c3")
 	asksWithPaths(t)
 	ctx := t.Context()
 	if err := open.inventory.RegisterModule(ctx, catalogue.Manifest{Module: "mesh-delivery", Version: "1",