Files
mesh-delivery/modules/mesh-delivery-forge-bridge/cmd/mesh-delivery-forge-bridge/groups_test.go
T
jschoubben a600090fcd G-715: the forge bridge says a group's end once per base
ForgeGroupEnd gains base; the bridge reads each member's base from the seat's
verb groups (Member.base is already in the contract and seatgen's output),
keeps groups.<group>.<base>, says one end per base from that base's members,
and bridge_group_end_again takes the base.

Builds: design 47 G §715, A-236
Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
2026-11-12 09:19:46 +01:00

126 lines
7.1 KiB
Go

package main
import (
"bytes"
"context"
"errors"
"log"
"strings"
"testing"
"time"
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery"
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg"
groupkeys "mesh-delivery-forge-bridge/internal/groups"
)
// idPub records the subjects, bodies and message ids it is handed.
type idPub struct {
subjects, ids []string
data [][]byte
}
func (p *idPub) send(_ context.Context, subject string, data []byte, id string) error {
p.subjects, p.data, p.ids = append(p.subjects, subject), append(p.data, data), append(p.ids, id)
return nil
}
// 1585/T16, T17, T19 (ADR 0633 §4), acceptance 49: a member's merged message names its group from the seat
// mesh-delivery's verb groups, the group's end is said once after the last member's merged message, and said again by hand.
func TestAGroupsMembersNameItAndItsEndIsSaidOnce(t *testing.T) {
ctx := context.Background()
h1, h2 := strings.Repeat("1", 40), strings.Repeat("2", 40)
c1, c2 := strings.Repeat("c", 40), strings.Repeat("d", 40)
group := seat.Group{ID: "feat/take-in", State: "merging", Members: []seat.Member{
{Repository: "novox/mesh-sdk", Number: 37, Head: h1, State: "merged", Base: "beta"}, {Repository: "novox/mesh-delivery", Number: 9, Head: h2, State: "merging", Base: "beta"},
{Repository: "novox/mesh-tools", Number: 5, Head: h2, State: "merging", Base: "main"}}}
var of []seat.Group
var read error
var logs bytes.Buffer
pub, done := &idPub{}, memStrs{}
g := &grouper{send: pub.send, done: done, logger: log.New(&logs, "", 0),
groups: func(context.Context) ([]seat.Group, error) { return of, read }}
mergedOf := func(repo string, number int, head, commit string) []byte {
data, err := forgemsg.EncodeForge(forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: repo, Branch: "feat/take-in", Base: "beta", Number: number, Head: head, Merge: commit, Root: "r"})
if err != nil {
t.Fatal(err)
}
return data
}
// A lone pull request's merged message carries no group, and neither does one whose groups cannot be read.
of = []seat.Group{group, {ID: "solo", Members: []seat.Member{{Repository: "novox/hq", Number: 4, Head: h1}}}}
lone, _ := forgemsg.EncodeForge(forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/hq", Branch: "solo", Number: 4, Head: h1, Merge: c1, Root: "r"})
if _, f, ok := g.member(ctx, lone); ok || f.Group != "" {
t.Errorf("a lone pull request names the group %q", f.Group)
}
read = errors.New("the seat did not answer")
if _, f, ok := g.member(ctx, mergedOf("novox/mesh-sdk", 37, h1, c1)); ok || f.Group != "" || !strings.Contains(logs.String(), "the seat did not answer") {
t.Errorf("a group read that failed names the group %q: %s", f.Group, logs.String())
}
read = nil
// The first member: its message names the group and both members in the group's order; the group is not ended.
data, f, ok := g.member(ctx, mergedOf("novox/mesh-sdk", 37, h1, c1))
if back, err := forgemsg.DecodeForge(data); !ok || err != nil || back.Group != "feat/take-in" || len(back.Members) != 3 || back.Members[0].Number != 37 {
t.Fatalf("a member's message: %+v %v", back, err)
}
g.published(ctx, f)
if len(pub.subjects) != 0 || done[groupkeys.PublishedKey("novox/mesh-sdk", 37)] != c1 {
t.Fatalf("after the first member: ends %v, performed %v", pub.subjects, done)
}
// The last member's merged message ends the group; a second merged message of it says no second end.
_, f, _ = g.member(ctx, mergedOf("novox/mesh-delivery", 9, h2, c2))
g.published(ctx, f)
g.published(ctx, f)
if len(pub.subjects) != 1 || pub.subjects[0] != "mesh.stream.mesh-delivery-forge-bridge.event.forge.group.merged" || pub.ids[0] != "group-end.feat/take-in.beta."+c2 {
t.Fatalf("ends %v ids %v, want one forge.group.merged with id group-end.feat/take-in.beta.%s", pub.subjects, pub.ids, c2)
}
end, err := forgemsg.DecodeForgeGroupEnd(pub.data[0])
if err != nil || end.Base != "beta" || len(end.Members) != 2 || end.Members[0].Merge != c1 || end.Members[1].Merge != c2 {
t.Errorf("the end = %+v %v, want the two members on beta in the group's order", end, err)
}
if key, _ := groupkeys.Key("feat/take-in", "beta"); done[key] != c2 {
t.Errorf("performed %v: want groups.feat~take-in kept with the last merge", done)
}
// §715: the member on main is on another base, and its merged message ends the group on main alone, once.
done[groupkeys.PublishedKey("novox/mesh-tools", 5)] = c1
g.published(ctx, forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-tools", Branch: "feat/take-in", Base: "main", Number: 5, Merge: c1})
g.published(ctx, forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-tools", Branch: "feat/take-in", Base: "main", Number: 5, Merge: c1})
if mainEnd, err := forgemsg.DecodeForgeGroupEnd(pub.data[len(pub.data)-1]); len(pub.subjects) != 2 || err != nil || mainEnd.Base != "main" || len(mainEnd.Members) != 1 || mainEnd.Members[0].Number != 5 {
t.Errorf("ends %d, the last %+v %v: want one more end, on main, of the member on main alone", len(pub.subjects), mainEnd, err)
}
// 1585/T19: an ask to say a group's end again is answered from the seat's groups, with the ask's time on the message id;
// not written while a member's merged message is not written, with the reason; not for a group the seat does not hold,
// nor when the groups cannot be read.
ask := groupkeys.EndAsk{V: 1, Group: "feat/take-in", Base: "beta", By: "operator@shanks", Why: "the indexer never took it in", At: time.Date(2026, 11, 4, 23, 0, 0, 123, time.UTC)}
for _, tc := range []struct {
name string
of []seat.Group
read error
published bool
written bool
answer string
}{
{"every message written: written again", []seat.Group{group}, nil, true, true, "written again"},
{"a base no member is on", []seat.Group{{ID: group.ID, Members: []seat.Member{group.Members[2], {Repository: "novox/mesh-sdk", Number: 37, Base: "main"}}}}, nil, true, false, "not written"},
{"a member's message not written", []seat.Group{group}, nil, false, false, "not written"},
{"no such group at the seat", []seat.Group{{ID: "other", Members: group.Members}}, nil, true, false, "holds no group"},
{"the groups cannot be read", nil, errors.New("no answer"), true, false, "cannot be read"},
} {
pub, done := &idPub{}, memStrs{}
if tc.published {
done[groupkeys.PublishedKey("novox/mesh-sdk", 37)], done[groupkeys.PublishedKey("novox/mesh-delivery", 9)] = c1, c2
done[groupkeys.PublishedKey("novox/mesh-tools", 5)] = c1
}
g := &grouper{send: pub.send, done: done, logger: log.New(&bytes.Buffer{}, "", 0),
groups: func(context.Context) ([]seat.Group, error) { return tc.of, tc.read }}
got := g.answerEnd(ctx, ask, ask.At.Add(time.Second))
if got.Written != tc.written || !strings.Contains(got.Answer, tc.answer) || !got.Done() || len(pub.ids) != map[bool]int{true: 1}[tc.written] {
t.Errorf("%s: %+v, ids %v", tc.name, got, pub.ids)
}
if tc.written && pub.ids[0] != groupkeys.EndID("feat/take-in", "beta", c2, groupkeys.AgainStamp(ask.At)) {
t.Errorf("%s: the id %s does not carry the ask's time", tc.name, pub.ids[0])
}
}
}