Files
mesh-delivery/modules/mesh-grants/internal/grants/namedpurge_test.go
T

149 lines
6.5 KiB
Go

package grants
import (
"errors"
"slices"
"strings"
"testing"
"git.novox.be/novox/mesh-sdk/go/catalogue"
"git.novox.be/novox/mesh-sdk/go/membership"
"mesh-grants/internal/buscompose"
)
type purged struct{ acts []string }
func (p *purged) PurgeSubject(stream, subject string) error {
p.acts = append(p.acts, "purge "+stream+" "+subject)
return nil
}
func (p *purged) DeleteConsumer(stream, name string) error {
p.acts = append(p.acts, "delete "+stream+"."+name)
return nil
}
type memStore map[string][]byte
func (m memStore) Get(state, key string) ([]byte, uint64, bool, error) {
v, ok := m[state+"/"+key]
return v, uint64(len(m)), ok, nil
}
func (m memStore) Put(state, key string, value []byte) (uint64, error) {
m[state+"/"+key] = value
return uint64(len(m)), nil
}
func (m memStore) Keys(state string) ([]string, error) {
var out []string
for k := range m {
if rest, ok := strings.CutPrefix(k, state+"/"); ok {
out = append(out, rest)
}
}
return out, nil
}
func (m memStore) Delete(state, key string) error { delete(m, state+"/"+key); return nil }
// Design 47 G §544, A-231: at the first revision in which no entry invokes a queue of a build seat the part purges each
// queue's named asks and deletes its named worker, once, and again only after they were used and left again; a failed read
// of the catalog half purges nothing; grants_named_purge records its hand act first and then has the process purge.
func TestTheNamedAsksArePurgedAtTheFirstRevisionThatLeavesThem(t *testing.T) {
recs := buscompose.Records{Nodes: []string{"one"}, Assigned: map[string][]buscompose.Declared{"one": {{Module: "go-module",
Holds: []buscompose.Seat{{Name: "node-build-go", Scope: "node", Accepts: []string{"check"}, PulledByKind: true}}}}}}
unused := Inputs{Manifests: map[string]catalogue.Manifest{"runner": {Module: "runner", Invokes: []string{"seat:node-build-go.run"}}}}
used := Inputs{Manifests: map[string]catalogue.Manifest{"runner": {Module: "runner", Invokes: []string{"seat:node-build-go.accept.check"}}}}
// A-414: a build taken from its want's newest build that invokes a queue keeps the named workers too.
runs := unused
runs.Running = map[string]catalogue.Manifest{"shanks.builder": {Module: "builder", Invokes: []string{"seat:node-build-go.accept.check"}}}
if NamedAsksUnused(runs) {
t.Error("named asks unused though a wanted build invokes a queue")
}
unread := unused
unread.CatalogUnread = "the catalog half of the branch main"
bus := &purged{}
p := &Part{NamedPurge: bus, Store: memStore{}}
want := []string{"purge SEAT_NODE_BUILD_GO mesh.seat.node-build-go.accept.check.*",
"delete SEAT_NODE_BUILD_GO.SEAT_NODE_BUILD_GO_CHECK_named_worker"}
for i, c := range []struct {
in Inputs
byHand string
acts int
}{{unread, "", 0}, {used, "", 0}, {unused, "", 2}, {unused, "", 2}, {used, "", 2}, {unused, "", 4}, {used, "jochen@shanks", 6}} {
var res Result
p.purgeNamed(&res, c.in, recs, c.byHand)
if len(bus.acts) != c.acts {
t.Fatalf("pass %d: %d acts, want %d: %v", i, len(bus.acts), c.acts, bus.acts)
}
}
if !slices.Equal(bus.acts[:2], want) {
t.Errorf("purged %v, want %v", bus.acts[:2], want)
}
// The named workers are composed while an entry invokes a queue, and not while none does.
for _, c := range []struct {
in Inputs
named bool
}{{used, true}, {unused, false}, {unread, true}} {
d := buscompose.Declared{Holds: slices.Clone(recs.Assigned["one"][0].Holds)}
withNoNamedAsks(NamedAsksUnused(c.in), &d)
tr := buscompose.SeatTrafficOf("go-module", d.Holds, nil, nil)
has := slices.ContainsFunc(tr.Workers, func(w buscompose.Worker) bool { return w.Consumer == "SEAT_NODE_BUILD_GO_CHECK_named_worker" })
if has != c.named {
t.Errorf("a named worker composed %v, want %v (%v)", has, c.named, c.in.Manifests["runner"].Invokes)
}
}
// A-413: an account granted a named ask (it uses the seat's queue and holds a seat its AcceptCallers name) keeps the named
// workers though no entry invokes the queue; with neither, they go out and the purge runs.
asker := buscompose.Declared{Module: "asker",
Holds: []buscompose.Seat{{Name: "node-delivery", Scope: "node"}},
Uses: []buscompose.Seat{{Name: "node-build-go", Scope: "node", Accepts: []string{"check"}, PulledByKind: true, AcceptCallers: map[string][]string{"check": {"node-delivery"}}}}}
granted := buscompose.Records{Nodes: []string{"one"}, Assigned: map[string][]buscompose.Declared{"one": {recs.Assigned["one"][0], asker}}}
for _, c := range []struct {
r buscompose.Records
granted bool
}{{granted, true}, {recs, false}} {
if got := buscompose.NamedAsksGranted(c.r); got != c.granted {
t.Errorf("NamedAsksGranted = %v, want %v", got, c.granted)
}
before := len(bus.acts)
var res Result
pp := &Part{NamedPurge: bus, Store: memStore{}}
pp.purgeNamed(&res, unused, c.r, "")
if purgedNow := len(bus.acts) > before; purgedNow == c.granted {
t.Errorf("granted %v: purged %v", c.granted, purgedNow)
}
}
// A-413: a membership held in the part's state (carried over for a module it cannot compose) that publishes a named ask keeps
// the named workers; main's own `accept.<queue>` does not.
for _, c := range []struct {
publish string
kept bool
}{{"mesh.seat.node-build-go.accept.delivery.mesh-builds", true}, {"mesh.seat.node-build-go.accept.delivery", false}} {
st := memStore{}
st.Put(StateMemberships, "shanks.mesh-delivery-builder", membership.EncodeGrantsMembership(membership.Membership{Node: "shanks", Module: "mesh-delivery-builder",
SeatTraffic: &membership.SeatTraffic{Publish: []string{c.publish}}}))
cin := unused
(&Part{Store: st}).withCarriedNamedAsks(&cin)
if NamedAsksUnused(cin) == c.kept {
t.Errorf("carried publish %s: unused = %v", c.publish, NamedAsksUnused(cin))
}
}
// The hand tool: nothing is asked when the hand act is not recorded; once it is, the process purges at its ask.
if _, err := p.AskNamedPurge("jochen@shanks", "the part stopped first", func(string, string) error { return errors.New("down") }); err == nil {
t.Error("asked though the hand act was not recorded")
}
if a := p.asked(); a.NamedPurge {
t.Error("an ask was written though the hand act was not recorded")
}
var acts []string
if _, err := p.AskNamedPurge("jochen@shanks", "the part stopped first", func(what, why string) error {
acts = append(acts, what+": "+why)
return nil
}); err != nil || len(acts) != 1 {
t.Fatalf("the hand act: %v %v", err, acts)
}
if a := p.asked(); !a.NamedPurge || a.By != "jochen@shanks" {
t.Errorf("the ask read back: %+v", a)
}
}