mesh-tools
9f0d9098b7
mesh/merge-gate head 9f0d9098b735 merged into trunk d163304e3ff1 — pass: builds build-agent, mesh-controller → ace, g14, novox, shanks; no bus step; every …
mesh/repo-check head 9f0d9098b735 merged into trunk d163304e3ff1 — pass: its merge-check.sh passed
mesh/delivery delivered
347 lines
17 KiB
Go
347 lines
17 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/asks"
|
|
sdkdelivery "git.novox.be/novox/mesh-sdk/go/delivery"
|
|
|
|
"github.com/novox/mesh-controller/internal/conditions"
|
|
"github.com/novox/mesh-controller/internal/link"
|
|
)
|
|
|
|
// The pieces of the catch-up that need no store (novox/hq ADR 0457, issue 1336).
|
|
|
|
func TestAMergeCommitsSubjectNamesItsPullRequest(t *testing.T) {
|
|
title, number, ok := pullOfSubject("Merge pull request 'Fix keycloak's sign-in (issue 1332)' (#378) from fix/1332-sign-in into main")
|
|
if !ok || number != 378 || title != "Fix keycloak's sign-in (issue 1332)" {
|
|
t.Fatalf("read %q %d %v", title, number, ok)
|
|
}
|
|
if b := headBranchOfSubject("Merge pull request 'x' (#378) from fix/1332-sign-in into main"); b != "fix/1332-sign-in" {
|
|
t.Fatalf("the head branch read as %q", b)
|
|
}
|
|
if _, _, ok := pullOfSubject("Merge branch 'main' of somewhere"); ok {
|
|
t.Fatal("a merge that names no pull request read as one")
|
|
}
|
|
}
|
|
|
|
func TestOnlyTheLastFiftyMergesOfATrunkAreRead(t *testing.T) {
|
|
pages := map[int][]trunkCommit{}
|
|
var all []trunkCommit // newest first: 51 merges, a plain commit between each pair
|
|
for i := 51; i >= 1; i-- {
|
|
all = append(all, trunkCommit{Commit: fmt.Sprintf("merge-%02d", i), SecondParent: fmt.Sprintf("head-%02d", i),
|
|
Subject: fmt.Sprintf("Merge pull request 'change %d' (#%d) from fix/x into main", i, i)},
|
|
trunkCommit{Commit: fmt.Sprintf("plain-%02d", i)})
|
|
}
|
|
for i := 0; i < len(all); i += 50 {
|
|
pages[i/50+1] = all[i:min(i+50, len(all))]
|
|
}
|
|
was := trunkCommitsPage
|
|
trunkCommitsPage = func(_ context.Context, _, _, _ string, page int) ([]trunkCommit, error) { return pages[page], nil }
|
|
t.Cleanup(func() { trunkCommitsPage = was })
|
|
got, err := readTrunkMerges(t.Context(), "novox", "mesh-catalog", "main")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != catchUpWindow || got[0].Commit != "merge-02" || got[len(got)-1].Commit != "merge-51" {
|
|
t.Fatalf("read %d merges from %s to %s: the oldest of 51 is outside the window", len(got), got[0].Commit, got[len(got)-1].Commit)
|
|
}
|
|
if got[0].Head != "head-02" {
|
|
t.Fatalf("a merge's head is its second parent, not %q", got[0].Head)
|
|
}
|
|
}
|
|
|
|
func TestAForgeThatDoesNotAnswerIsAnErrorNotAnEmptyTrunk(t *testing.T) {
|
|
was := trunkCommitsPage
|
|
trunkCommitsPage = func(context.Context, string, string, string, int) ([]trunkCommit, error) {
|
|
return nil, errors.New("the forge did not answer")
|
|
}
|
|
t.Cleanup(func() { trunkCommitsPage = was })
|
|
if got, err := readTrunkMerges(t.Context(), "novox", "mesh-catalog", "main"); err == nil {
|
|
t.Fatalf("a forge that did not answer read as %d merges: nothing to catch up", len(got))
|
|
}
|
|
}
|
|
|
|
func TestACaughtUpMergeIsAcceptedOnTheSameWarrantAsAnAnnouncedOne(t *testing.T) {
|
|
ok := approvedMerge(t)
|
|
for _, asker := range []string{sdkdelivery.TellerModule, theDelivery} {
|
|
w := ok.warrant
|
|
w.Asker = asker
|
|
if _, err := caughtUpWarrant(asker, &ok.ask, &w); err != nil {
|
|
t.Errorf("the operator's Approve under %s was refused: %v", asker, err)
|
|
}
|
|
}
|
|
if _, err := caughtUpWarrant("keycloak", &ok.ask, &ok.warrant); err == nil {
|
|
t.Error("a warrant of an asker the controller takes none from was accepted")
|
|
}
|
|
declined := ok.warrant
|
|
declined.Option, declined.Label = "decline", "Decline"
|
|
if _, err := caughtUpWarrant(theDelivery, &ok.ask, &declined); err == nil {
|
|
t.Error("a Decline was accepted as a warrant")
|
|
}
|
|
unproved := ok.warrant
|
|
by := *unproved.By
|
|
by.Verified = ""
|
|
unproved.By = &by
|
|
if _, err := caughtUpWarrant(theDelivery, &ok.ask, &unproved); err == nil {
|
|
t.Error("an answer whose channel proves nobody was accepted")
|
|
}
|
|
if _, err := caughtUpWarrant(theDelivery, nil, nil); err == nil {
|
|
t.Error("a router that holds nothing was accepted")
|
|
}
|
|
}
|
|
|
|
// aTellersAsk is the ask the delivery gate composes for a pull request, as the router holds it once the operator chose Approve
|
|
// (the gate's composeMergeAsk: its id from sdkdelivery.AskingID of the group and the heads, its Approve bound to mergeAct over the
|
|
// heads, the pull request and its head's first twelve digits in the details), with the warrant the router wrote.
|
|
func aTellersAsk(t *testing.T, group string, members ...sdkdelivery.Head) (asks.Ask, asks.Warrant) {
|
|
t.Helper()
|
|
key, err := sdkdelivery.MergeAskKey(group, members)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
id := sdkdelivery.AskingID(key, 1)
|
|
heads := map[string]string{}
|
|
var details []string
|
|
for _, m := range members {
|
|
owner, repo, _ := strings.Cut(m.Repository, "/")
|
|
heads[deliveryIDOf(owner, repo, m.Head)] = m.Head
|
|
details = append(details, fmt.Sprintf("%s#%d %q at %s: issues: none named; review: approved; reaches: no delivery plan yet", repo, m.Number, "title", m.Head[:12]))
|
|
}
|
|
bind := func(option string) string {
|
|
d, err := asks.ActDigest(mergeAct(id, option, heads))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return d
|
|
}
|
|
at := time.Date(2026, 10, 20, 12, 2, 1, 0, time.UTC)
|
|
ask := asks.Ask{ID: id, Headline: "Merge into main", Explanation: "passed its checks.", Who: asks.Operator, Expires: at.Add(24 * time.Hour),
|
|
OnExpiry: "nothing is merged; the ask is made again", Details: strings.Join(details, "\n"),
|
|
Options: []asks.Option{
|
|
{ID: optionApprove, Label: "Approve", Does: "merges", Level: asks.Approve, Binds: bind(optionApprove)},
|
|
{ID: "decline", Label: "Decline", Does: "nothing is merged", Level: asks.Approve, Binds: bind("decline")}}}
|
|
w := asks.Warrant{Ask: id, Asker: sdkdelivery.TellerModule, Outcome: asks.OutcomeChosen, Option: optionApprove, Label: "Approve",
|
|
Level: asks.Approve, By: &asks.Person{Who: asks.Operator, Kind: "telegram", Identity: "1", Verified: "user id"},
|
|
At: at.Add(time.Minute), AskDigest: ask.Digest()}
|
|
return ask, w
|
|
}
|
|
|
|
// withRouter hands findMergeWarrant these asks as the router's records, by asker.
|
|
func withRouter(t *testing.T, records map[string]map[string]struct {
|
|
ask asks.Ask
|
|
w asks.Warrant
|
|
}) {
|
|
t.Helper()
|
|
wasIDs, wasAsk := routerAskIDs, routerAskOf
|
|
closedRecords.Range(func(k, _ any) bool { closedRecords.Delete(k); return true })
|
|
routerAskIDs = func(_ context.Context, _ catalogueReader, asker string) ([]string, error) {
|
|
var ids []string
|
|
for id := range records[asker] {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids, nil
|
|
}
|
|
routerAskOf = func(_ context.Context, _ catalogueReader, asker, id string) (*asks.Ask, *asks.Warrant, error) {
|
|
r, ok := records[asker][id]
|
|
if !ok {
|
|
return nil, nil, nil
|
|
}
|
|
return &r.ask, &r.w, nil
|
|
}
|
|
t.Cleanup(func() {
|
|
routerAskIDs, routerAskOf = wasIDs, wasAsk
|
|
closedRecords.Range(func(k, _ any) bool { closedRecords.Delete(k); return true })
|
|
})
|
|
}
|
|
|
|
type aRouterRecord = struct {
|
|
ask asks.Ask
|
|
w asks.Warrant
|
|
}
|
|
|
|
// The teller's asks, as the router held them on 2026-10-20: the id is the router's own key, rebuilt here from the group and the
|
|
// head the gate composed it for (mesh-controller#405 at 8a330afd, mesh-catalog#381 at 1c702422, mesh-host#124 at 52600ec7). It names
|
|
// neither the pull request nor the head, so the warrant is found by the heads the Approve is bound to.
|
|
func TestATellersWarrantIsFoundByTheHeadItsApproveIsBoundTo(t *testing.T) {
|
|
real := []struct {
|
|
group, key, owner, repo string
|
|
number int
|
|
head string
|
|
}{
|
|
{"feat/r4b-sdk-users", "merge-feat_r4b_sdk_users-ba59b03220f8-989afe0a3bcf", "novox", "mesh-controller", 405, "8a330afd44ba852873339cf1210e90989dca46e1"},
|
|
{"fix/1351-remove-todays-delivery-module", "merge-fix_1351_remove_todays_delivery_module-64a353-d93b97b9697b", "novox", "mesh-catalog", 381, "1c7024224dd77c5b603299378883e0993b2e2fdd"},
|
|
{"feat/r4b-sdk-users", "merge-feat_r4b_sdk_users-6a59ba48da14-424e053ebc9c", "novox", "mesh-host", 124, "52600ec7bd61ee271a5cc7f4136bcf0a2a8f00fc"},
|
|
}
|
|
teller := map[string]aRouterRecord{}
|
|
for _, r := range real {
|
|
ask, w := aTellersAsk(t, r.group, sdkdelivery.Head{Repository: r.owner + "/" + r.repo, Number: r.number, Head: r.head})
|
|
if ask.ID != r.key {
|
|
t.Fatalf("the id of %s#%d is %q, and the router held it as %q: the fixture is not the router's", r.repo, r.number, ask.ID, r.key)
|
|
}
|
|
teller[ask.ID] = aRouterRecord{ask, w}
|
|
}
|
|
withRouter(t, map[string]map[string]aRouterRecord{sdkdelivery.TellerModule: teller})
|
|
for _, r := range real {
|
|
why, found, reason, err := findMergeWarrant(t.Context(), nil, r.owner, r.repo, r.number, r.head)
|
|
if err != nil || !found || !strings.Contains(why, r.key) || !strings.Contains(why, "bound to the head of this pull request") {
|
|
t.Errorf("%s#%d: the warrant was not found: %q %v %q %v", r.repo, r.number, why, found, reason, err)
|
|
}
|
|
// Another head of the same pull request is another merge: the Approve was not given for it.
|
|
if _, found, _, _ := findMergeWarrant(t.Context(), nil, r.owner, r.repo, r.number, "ffffffffffffffffffffffffffffffffffffffff"); found {
|
|
t.Errorf("%s#%d: another head found the warrant of this one", r.repo, r.number)
|
|
}
|
|
}
|
|
// One pull request's Approve is none for another repository's merge at the same head digits.
|
|
if _, found, _, _ := findMergeWarrant(t.Context(), nil, "novox", "mesh-tools", 405, real[0].head); found {
|
|
t.Error("a merge of another repository found mesh-controller#405's warrant")
|
|
}
|
|
}
|
|
|
|
// A group's ask binds several heads, and the router's record carries only twelve digits of the other members': the pull request is
|
|
// found in the ask as it was published, which the warrant's digest covers.
|
|
func TestAGroupsWarrantIsFoundByTheAsksWordsForThePullRequestAndItsHead(t *testing.T) {
|
|
a := sdkdelivery.Head{Repository: "novox/mesh-host", Number: 124, Head: "52600ec7bd61ee271a5cc7f4136bcf0a2a8f00fc"}
|
|
b := sdkdelivery.Head{Repository: "novox/mesh-controller", Number: 405, Head: "8a330afd44ba852873339cf1210e90989dca46e1"}
|
|
ask, w := aTellersAsk(t, "feat/r4b-sdk-users", a, b)
|
|
withRouter(t, map[string]map[string]aRouterRecord{sdkdelivery.TellerModule: {ask.ID: {ask, w}}})
|
|
for _, h := range []sdkdelivery.Head{a, b} {
|
|
owner, repo, _ := strings.Cut(h.Repository, "/")
|
|
why, found, reason, err := findMergeWarrant(t.Context(), nil, owner, repo, h.Number, h.Head)
|
|
if err != nil || !found || !strings.Contains(why, "a group's ask naming this pull request at this head") {
|
|
t.Errorf("%s#%d: not found in the group's ask: %q %v %q %v", repo, h.Number, why, found, reason, err)
|
|
}
|
|
}
|
|
if _, found, _, _ := findMergeWarrant(t.Context(), nil, "novox", "mesh-catalog", 381, a.Head); found {
|
|
t.Error("a pull request the group's ask does not name found its warrant")
|
|
}
|
|
// A Decline is no warrant.
|
|
declined := w
|
|
declined.Option, declined.Label = "decline", "Decline"
|
|
withRouter(t, map[string]map[string]aRouterRecord{sdkdelivery.TellerModule: {ask.ID: {ask, declined}}})
|
|
if _, found, _, _ := findMergeWarrant(t.Context(), nil, "novox", "mesh-host", 124, a.Head); found {
|
|
t.Error("a Decline found a warrant")
|
|
}
|
|
}
|
|
|
|
// Keycloak's merge was asked as mesh-delivery.merge-378-b9104454f9a5-1, before release 3e: the id names the pull request and
|
|
// the first twelve digits of its head, and the warrant is found by them under mesh-delivery.
|
|
func TestAWarrantAskedUnderMeshDeliveryIsFoundByThePullRequestAndItsHead(t *testing.T) {
|
|
ok := approvedMerge(t)
|
|
head := "b9104454f9a5e0c4d3b2a1f0e9d8c7b6a5948372"
|
|
askID := "merge-378-b9104454f9a5-1"
|
|
ask, w := ok.ask, ok.warrant
|
|
ask.ID, w.Ask, w.Asker = askID, askID, theDelivery
|
|
w.AskDigest = ask.Digest()
|
|
withRouter(t, map[string]map[string]aRouterRecord{theDelivery: {
|
|
"merge-377-aaaaaaaaaaaa-1": {},
|
|
askID: {ask, w},
|
|
}})
|
|
why, found, reason, err := findMergeWarrant(t.Context(), nil, "novox", "mesh-catalog", 378, head)
|
|
if err != nil || !found || !strings.Contains(why, askID) {
|
|
t.Fatalf("the warrant was not found: %q %v %q %v", why, found, reason, err)
|
|
}
|
|
// Another head names another ask, and none is found.
|
|
if _, found, _, _ := findMergeWarrant(t.Context(), nil, "novox", "mesh-catalog", 378, "ffffffffffff0000"); found {
|
|
t.Fatal("another head found a warrant")
|
|
}
|
|
// A router that cannot be read is an error, never "no warrant".
|
|
routerAskIDs = func(context.Context, catalogueReader, string) ([]string, error) { return nil, errors.New("no answer") }
|
|
if _, found, _, err := findMergeWarrant(t.Context(), nil, "novox", "mesh-catalog", 378, head); found || err == nil {
|
|
t.Fatalf("an unreadable router read as no warrant: %v %v", found, err)
|
|
}
|
|
}
|
|
|
|
// A trunk shorter than a page, or with none, is read without a fault: the pages end when the forge's do.
|
|
func TestAShortTrunkIsReadWholeAndAnEmptyOneIsNoMerges(t *testing.T) {
|
|
was := trunkCommitsPage
|
|
t.Cleanup(func() { trunkCommitsPage = was })
|
|
trunkCommitsPage = func(_ context.Context, _, _, _ string, page int) ([]trunkCommit, error) {
|
|
if page > 1 {
|
|
return nil, nil
|
|
}
|
|
return []trunkCommit{{Commit: "m2", SecondParent: "h2", Subject: "Merge pull request 'two' (#2) from fix/b into main"},
|
|
{Commit: "p"}, {Commit: "m1", SecondParent: "h1", Subject: "Merge pull request 'one' (#1) from fix/a into main"}}, nil
|
|
}
|
|
got, err := readTrunkMerges(t.Context(), "novox", "x", "main")
|
|
if err != nil || len(got) != 2 || got[0].Commit != "m1" || got[1].Commit != "m2" {
|
|
t.Fatalf("a short trunk read as %+v %v", got, err)
|
|
}
|
|
trunkCommitsPage = func(context.Context, string, string, string, int) ([]trunkCommit, error) { return nil, nil }
|
|
if got, err := readTrunkMerges(t.Context(), "novox", "x", "main"); err != nil || len(got) != 0 {
|
|
t.Fatalf("an empty trunk read as %+v %v", got, err)
|
|
}
|
|
}
|
|
|
|
// ADR 0253: what the operator reads of a merge not heard is plain: no hash, no identifier, nothing to do "by hand".
|
|
func TestTheConditionOfAMergeNotHeardIsInPlainWords(t *testing.T) {
|
|
keeper, _ := withConditionsInMemory(t)
|
|
tm := trunkMerge{Commit: "c0880c4d1f2e3a4b5c6d7e8f9a0b1c2d3e4f5a6b", Head: "b9104454f9a5e0c4d3b2a1f0e9d8c7b6a5948372"}
|
|
(following{}).raiseMergeNotHeard(t.Context(), "novox/mesh-catalog", "main", tm, link.SourceMoved{Number: 378},
|
|
"the router holds no chosen merge ask of mesh-delivery-teller or mesh-delivery that covers the head b9104454f9a5")
|
|
open, err := keeper.Open(t.Context())
|
|
if err != nil || len(open) != 1 {
|
|
t.Fatalf("opened %d conditions, %v", len(open), err)
|
|
}
|
|
c := open[0]
|
|
if why, ok := conditions.PlainWords(conditions.Words{Headline: c.Headline, Explanation: c.Explanation, Needs: c.Needs,
|
|
Resolved: c.Resolved}); !ok {
|
|
t.Fatalf("the condition's words are not plain: %s\n%q\n%q\n%q", why, c.Headline, c.Explanation, c.Needs)
|
|
}
|
|
}
|
|
|
|
// The trunk's history lists the merges made inside a pull request's branch too. On novox (2026-10-20) 15 of the 15 non-pull-request
|
|
// "gaps" of mesh-catalog and mesh-controller were such merges; only a pull request's merge into this trunk is a merge to catch up.
|
|
func TestAMergeMadeInsideABranchIsNoMergeOfTheTrunk(t *testing.T) {
|
|
was := trunkCommitsPage
|
|
t.Cleanup(func() { trunkCommitsPage = was })
|
|
trunkCommitsPage = func(_ context.Context, _, _, _ string, page int) ([]trunkCommit, error) {
|
|
if page > 1 {
|
|
return nil, nil
|
|
}
|
|
return []trunkCommit{
|
|
{Commit: "c0880c4d", SecondParent: "b9104454", Subject: "Merge pull request 'Read the grant file' (#378) from fix/1332 into main"},
|
|
{Commit: "6394a62a", SecondParent: "x1", Subject: "Merge remote-tracking branch 'origin/main' into fix/1081-withdraw"},
|
|
{Commit: "896f1d28", SecondParent: "x2", Subject: "Merge feat/agents-write-git-ssh into feat/agents-write-git-ssh-f (issue 955 F)"},
|
|
{Commit: "4d03755c", SecondParent: "x3", Subject: "Bring the branch up to main after #354 (issue 1047)"},
|
|
{Commit: "other", SecondParent: "x4", Subject: "Merge pull request 'Elsewhere' (#5) from fix/y into nox-mesh"},
|
|
}, nil
|
|
}
|
|
got, err := readTrunkMerges(t.Context(), "novox", "mesh-catalog", "main")
|
|
if err != nil || len(got) != 1 || got[0].Commit != "c0880c4d" {
|
|
t.Fatalf("read %+v %v: only keycloak's pull request merge into main is a merge to catch up", got, err)
|
|
}
|
|
}
|
|
|
|
// novox/hq ADR 0463 §2: the record of merges begins at the earliest merge the controller holds on any trunk. A merge before it is
|
|
// history on every trunk; a trunk with no merge kept of its own still has the merges made since as gaps (mesh-delivery #1 on novox).
|
|
func TestOnlyTheMergesSinceTheRecordBeganAreGapsOnEveryTrunk(t *testing.T) {
|
|
first := time.Date(2026, 10, 17, 12, 0, 0, 0, time.UTC) // the first merge it heard, on some trunk of the mesh
|
|
trunk := func(prefix string) []trunkMerge {
|
|
return []trunkMerge{
|
|
{Commit: prefix + "-old-1", At: first.Add(-30 * 24 * time.Hour)},
|
|
{Commit: prefix + "-old-2", At: first.Add(-2 * time.Hour)},
|
|
{Commit: prefix + "-within-grace", At: first.Add(-mergeGrace / 2)},
|
|
{Commit: prefix + "-since", At: first.Add(24 * time.Hour)},
|
|
}
|
|
}
|
|
// Two trunks, one of which the controller has kept no merge of: both read by the one starting point.
|
|
for _, prefix := range []string{"kept-trunk", "trunk-with-no-kept-merge"} {
|
|
var commits []string
|
|
for _, m := range sinceTheRecord(trunk(prefix), true, first) {
|
|
commits = append(commits, m.Commit)
|
|
}
|
|
if want := prefix + "-within-grace " + prefix + "-since"; strings.Join(commits, " ") != want {
|
|
t.Errorf("%s: the gaps are %v, want %q: earlier ones are history on every trunk, later ones are gaps", prefix, commits, want)
|
|
}
|
|
}
|
|
if none := sinceTheRecord(trunk("x"), false, time.Time{}); len(none) != 0 {
|
|
t.Errorf("with no merge kept anywhere there are %d gap(s), but no record to have one in", len(none))
|
|
}
|
|
}
|