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
126 lines
7.1 KiB
Go
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])
|
|
}
|
|
}
|
|
}
|