Indexer and grants: a source-only registration's history subject; every composed worker is created (H-A-470, H-A-468) #325
@@ -145,6 +145,9 @@ func newRegistry(js jetstream.JetStream, conn *nats.Conn, cred process.Account,
|
||||
}
|
||||
ix.SeedWaits(context.Background(), ask, waiting)
|
||||
},
|
||||
Unwritten: func(name, ask, reason string, unwritten bool) {
|
||||
ix.RegistrationUnwritten(context.Background(), name, ask, reason, unwritten)
|
||||
},
|
||||
Logf: logf}
|
||||
}
|
||||
|
||||
@@ -160,7 +163,8 @@ func routerRecordOf(module string, call toolCaller, record func(bucket, id strin
|
||||
}
|
||||
|
||||
// heardDecided is the handler of the decided events for this module: a warrant is applied by the registry; one it could not
|
||||
// apply is left unacknowledged, so the bus gives it again, and said.
|
||||
// apply is left for the bus to give again, and said. On the last delivery its consumer allows the warrant is given up: its ask
|
||||
// is answered as not applied and the registration said unwritten (design 47 H2 H-A-470 (2)).
|
||||
func heardDecided(ctx context.Context, reg *index.Registry, m jetstream.Msg, logf func(string, ...any)) {
|
||||
var w oc.Warrant
|
||||
if err := json.Unmarshal(m.Data(), &w); err != nil {
|
||||
@@ -169,7 +173,14 @@ func heardDecided(ctx context.Context, reg *index.Registry, m jetstream.Msg, log
|
||||
return
|
||||
}
|
||||
if err := reg.Heard(ctx, w); err != nil {
|
||||
logf("the warrant of the ask %s is left unapplied and given again: %s", w.Ask, strings.TrimSpace(err.Error()))
|
||||
reason := strings.TrimSpace(err.Error())
|
||||
logf("the warrant of the ask %s is left unapplied and given again: %s", w.Ask, reason)
|
||||
leftForBus(m, "the warrant of the ask "+w.Ask, err, logf)
|
||||
if md, merr := m.Metadata(); merr == nil && md != nil && md.NumDelivered >= EventDeliveries {
|
||||
if gerr := reg.GiveUp(ctx, w, reason); gerr != nil {
|
||||
logf("the warrant of the ask %s is given up, but its ask is not answered: %v", w.Ask, gerr)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
_ = m.Ack()
|
||||
|
||||
@@ -0,0 +1,153 @@
|
||||
//go:build integration
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/nats-io/nats-server/v2/server"
|
||||
"github.com/nats-io/nats.go"
|
||||
"github.com/nats-io/nats.go/jetstream"
|
||||
|
||||
occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient"
|
||||
oc "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel"
|
||||
gitseat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git"
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
|
||||
"git.novox.be/novox/mesh-sdk/go/buscompose"
|
||||
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
||||
|
||||
"mesh-delivery-indexer/internal/index"
|
||||
)
|
||||
|
||||
// TestARegistrationIsKeptOnTheHistoryStreamItsManifestDeclares (design 47 H2 H-A-470 (3); the kind of fix-a-bug-met-twice: a
|
||||
// test that does not use the real stream's subject): the program's registry, as newRegistry wires it, writes a warranted
|
||||
// registration of a module (one token after registration.) and of a source-only repository (source.<owner>.<name>, H-A-408's
|
||||
// key) through the stream registration-history on an embedded bus, made from the indexer's manifest's streams section as the
|
||||
// grants part makes it (buscompose); each version lands on its subject, the name whole.
|
||||
func TestARegistrationIsKeptOnTheHistoryStreamItsManifestDeclares(t *testing.T) {
|
||||
srv, err := server.NewServer(&server.Options{Host: "127.0.0.1", Port: -1, JetStream: true, StoreDir: t.TempDir(), NoLog: true, NoSigs: true})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
go srv.Start()
|
||||
if !srv.ReadyForConnections(10 * time.Second) {
|
||||
t.Fatal("the bus did not come up")
|
||||
}
|
||||
t.Cleanup(srv.Shutdown)
|
||||
conn, err := nats.Connect(srv.ClientURL())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(conn.Close)
|
||||
js, err := jetstream.New(conn)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
t.Cleanup(cancel)
|
||||
|
||||
// The stream as the grants part makes it from the manifest: its events spelled as the bus spells them, on the module's subjects.
|
||||
raw, err := os.ReadFile("../../module.json")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var m struct {
|
||||
Streams []struct {
|
||||
Name string `json:"name"`
|
||||
Events []string `json:"events"`
|
||||
} `json:"streams"`
|
||||
}
|
||||
if err := json.Unmarshal(raw, &m); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var wire []string
|
||||
for _, s := range m.Streams {
|
||||
if s.Name == index.RegistrationHistoryStream {
|
||||
for _, e := range s.Events {
|
||||
wire = append(wire, buscompose.WirePattern(e))
|
||||
}
|
||||
}
|
||||
}
|
||||
subjects := (buscompose.ModuleStream{Module: testIndexer, Events: wire}).Subjects()
|
||||
stream, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: catalogue.StreamBusName(index.RegistrationHistoryStream), Subjects: subjects})
|
||||
if err != nil {
|
||||
t.Fatalf("the stream of %v: %v", subjects, err)
|
||||
}
|
||||
|
||||
// The seat git answers the default branch's head and a tree holding no module.json; the router's record holds the warrant
|
||||
// of each ask the indexer publishes.
|
||||
const head = "0123456789abcdef0123456789abcdef01234567"
|
||||
call := func(key string, body any) (json.RawMessage, error) {
|
||||
var out any
|
||||
switch key {
|
||||
case "seat:" + gitseat.Seat + "." + gitseat.VerbBranch:
|
||||
in := body.(gitseat.BranchInput)
|
||||
out = gitseat.BranchAnswer{Branch: "main", Repository: in.Repository, Head: head}
|
||||
case gitVerb(gitseat.VerbTrees):
|
||||
out = gitseat.TreesAnswer{Commit: head, Trees: map[string]string{"tools": "t1"}}
|
||||
default:
|
||||
t.Errorf("asked %s", key)
|
||||
}
|
||||
return json.Marshal(out)
|
||||
}
|
||||
asks := make(chan oc.Ask, 4)
|
||||
sub, err := conn.Subscribe(oc.AcceptSubjectAsk(testIndexer), func(msg *nats.Msg) {
|
||||
var a oc.Ask
|
||||
if err := json.Unmarshal(msg.Data, &a); err == nil {
|
||||
asks <- a
|
||||
}
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = sub.Unsubscribe() })
|
||||
warrants := map[string]oc.Warrant{}
|
||||
where := func(id string) (string, *oc.Warrant, error) {
|
||||
if w, ok := warrants[id]; ok {
|
||||
return "chosen", &w, nil
|
||||
}
|
||||
return "open", nil, nil
|
||||
}
|
||||
reg := newRegistry(js, conn, testAccount, call, index.MemoryStore(), index.MemoryStore(), where, &index.Indexer{Module: testIndexer}, t.Logf)
|
||||
|
||||
check := &meshcatalog.SourceCheck{Seat: meshcatalog.SourceCheckSeatNodeBuildGo, Step: meshcatalog.SourceCheckStepUnit}
|
||||
for name, r := range map[string]meshcatalog.Registration{
|
||||
"avahi": {Module: "avahi", Origin: "novox/mesh-catalog", Path: "modules/avahi/module.json", Branches: []string{"main"}},
|
||||
"source.novox.hq": {Origin: "novox/hq", Check: check, Policy: meshcatalog.Policy{Steps: meshcatalog.StepStatuses{Unit: "required"}}},
|
||||
} {
|
||||
change, _ := json.Marshal(meshcatalog.RegisterInput{Registration: r})
|
||||
got, err := reg.Propose(ctx, "register", "s@n", change)
|
||||
if err != nil || got.Ask == "" || got.Module != name {
|
||||
t.Fatalf("register %s: %+v, %v; want an ask", name, got, err)
|
||||
}
|
||||
var a oc.Ask
|
||||
select {
|
||||
case a = <-asks:
|
||||
case <-ctx.Done():
|
||||
t.Fatalf("the ask of %s was not published", name)
|
||||
}
|
||||
o, _ := occ.OptionOf(a, "approve")
|
||||
w := oc.Warrant{Ask: a.ID, Asker: testIndexer, Outcome: occ.OutcomeChosen, Option: "approve", Level: o.Level, Label: o.Label,
|
||||
AskDigest: occ.Digest(a), At: occ.FormatTime(time.Now()), By: &oc.Person{Who: occ.Operator, Kind: "telegram", Verified: "user id verified"}}
|
||||
warrants[a.ID] = w
|
||||
if err := reg.Heard(ctx, w); err != nil {
|
||||
t.Fatalf("the warrant of %s was not applied: %v", name, err)
|
||||
}
|
||||
msg, err := stream.GetLastMsgForSubject(ctx, historySubject(testIndexer, name))
|
||||
var kept meshcatalog.Registration
|
||||
if err == nil {
|
||||
err = json.Unmarshal(msg.Data, &kept)
|
||||
}
|
||||
if err != nil || kept.Version != 1 || index.RegistrationName(kept) != name {
|
||||
t.Fatalf("registration-history of %s holds %+v (%v); want its version 1 kept on %v", name, kept, err, subjects)
|
||||
}
|
||||
if one, _, _ := reg.Registration(ctx, name); one.Version != 1 || !strings.Contains(one.Origin, "novox/") {
|
||||
t.Errorf("the registration of %s is %+v, want version 1 written", name, one)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +1,17 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
oc "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel"
|
||||
stdio "git.novox.be/novox/mesh-sdk/go"
|
||||
|
||||
"mesh-delivery-indexer/internal/index"
|
||||
)
|
||||
|
||||
// Design 47 G §700, A-74: the router's record of an ask is read under the indexer's module's name from the state asks of the
|
||||
@@ -35,3 +41,43 @@ func TestTheRoutersRecordIsReadFromTheBucketOfTheSeatsHolder(t *testing.T) {
|
||||
t.Errorf("with no holder Where answered %v; want the reason", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Design 47 H2 H-A-470 (2), addendum (d): a warrant the registry cannot apply is left for the bus (naked) while the bus gives it
|
||||
// again; on the delivery that reaches EventDeliveries it is given up: its key ends refused, not applied, and registration-unwritten
|
||||
// is said naming the ask and the reason.
|
||||
func TestAWarrantIsGivenUpOnItsLastDelivery(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
var said []string
|
||||
proposals := index.MemoryStore()
|
||||
open, _ := json.Marshal(index.Proposal{V: 1, Verb: "register", Module: "source.novox.hq", Ask: "a1", State: index.ProposalOpen})
|
||||
if err := proposals.Create(ctx, "register.source.novox.hq", open); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
reg := &index.Registry{Module: testIndexer, Registrations: index.MemoryStore(), Proposals: proposals,
|
||||
Where: func(string) (string, *oc.Warrant, error) { return "", nil, errors.New("nats: no response from stream") },
|
||||
Unwritten: func(name, ask, reason string, unwritten bool) {
|
||||
said = append(said, fmt.Sprintf("%s %s %t %s", name, ask, unwritten, reason))
|
||||
}}
|
||||
body, _ := json.Marshal(oc.Warrant{Ask: "a1", Outcome: "chosen", Option: "approve"})
|
||||
state := func() index.Proposal {
|
||||
v, _, _, _ := proposals.Get(ctx, "register.source.novox.hq")
|
||||
var p index.Proposal
|
||||
_ = json.Unmarshal(v, &p)
|
||||
return p
|
||||
}
|
||||
for n := uint64(1); n < EventDeliveries; n++ {
|
||||
m := &deliveredMsg{subject: "decided", data: body, n: n}
|
||||
heardDecided(ctx, reg, m, func(string, ...any) {})
|
||||
if !m.naked || state().State != index.ProposalOpen || len(said) != 0 {
|
||||
t.Fatalf("delivery %d: naked %t, key %+v, said %v; want it left for the bus, the key open, nothing said", n, m.naked, state(), said)
|
||||
}
|
||||
}
|
||||
m := &deliveredMsg{subject: "decided", data: body, n: EventDeliveries}
|
||||
heardDecided(ctx, reg, m, func(string, ...any) {})
|
||||
if p := state(); !m.naked || p.State != index.ProposalRefused || !strings.HasPrefix(p.Outcome, "not applied: ") || !strings.Contains(p.Outcome, "no response from stream") {
|
||||
t.Fatalf("the last delivery: naked %t, key %+v; want it ended refused, not applied, naming the reason", m.naked, p)
|
||||
}
|
||||
if len(said) != 1 || !strings.HasPrefix(said[0], "source.novox.hq a1 true ") || !strings.Contains(said[0], "no response from stream") {
|
||||
t.Fatalf("said %v; want registration-unwritten of source.novox.hq naming the ask and the reason", said)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@ const CallUnansweredKind = "indexer-call-unanswered"
|
||||
// (H-A-247 (1)); a views reader's and the emitter's (views.ViewKinds) are always the writer's besides. The tool runner's
|
||||
// writer over the same state `findings` owns its own. TestFindingKindsHoldEveryKindTheCodeRaises holds the code to this list.
|
||||
var FindingKinds = []string{TakeInWaitingKind, PinMissingKind, OutOfStepKind, PackagesNotPublishedKind, HistoryFillingKind, SeedWaitsKind,
|
||||
SeedLeftOutKind, SeatDefinitionUnparsedKind, SeatDefinedTwiceKind, SeatOutsideItsDomainKind, CallUnansweredKind,
|
||||
SeedLeftOutKind, RegistrationUnwrittenKind, SeatDefinitionUnparsedKind, SeatDefinedTwiceKind, SeatOutsideItsDomainKind, CallUnansweredKind,
|
||||
views.EventUnhandledKind, heard.Kind}
|
||||
|
||||
// RetiredFindingKinds are kinds no code of the indexer raises any more, which its writer clears once at its start (H-A-247
|
||||
|
||||
@@ -23,6 +23,10 @@ const (
|
||||
// module, id the module's name), naming the artifact and its language or kind; cleared only when a later seed finds a
|
||||
// build seat for every artifact of it, or the module leaves the catalogue (A-324, A-329).
|
||||
SeedLeftOutKind = "seed-left-out"
|
||||
// RegistrationUnwrittenKind is the finding of a warranted registration change the indexer gave up writing (scope module, id
|
||||
// the registration's name), naming the ask and the reason; cleared when a later version of that registration is written
|
||||
// (design 47 H2 H-A-470 (2) and its addendum).
|
||||
RegistrationUnwrittenKind = "registration-unwritten"
|
||||
)
|
||||
|
||||
// HistoryFill writes the finding registration-history-filling when the stream holds used bytes of its max, 80 % or more,
|
||||
@@ -68,3 +72,25 @@ func (ix *Indexer) SeedWaits(ctx context.Context, ask string, waiting bool) {
|
||||
ix.logf("registrations: the finding %s is not cleared: %v", SeedWaitsKind, err)
|
||||
}
|
||||
}
|
||||
|
||||
// RegistrationUnwritten writes the finding registration-unwritten of the registration name, naming the ask whose warrant was given
|
||||
// up and the reason, and clears it when a later version of the registration is written (design 47 H2 H-A-470 (2)).
|
||||
func (ix *Indexer) RegistrationUnwritten(ctx context.Context, name, ask, reason string, unwritten bool) {
|
||||
if ix.Findings == nil {
|
||||
return
|
||||
}
|
||||
if unwritten {
|
||||
f := ix.observed(mcc.ScopeModule, name, RegistrationUnwrittenKind,
|
||||
fmt.Sprintf("the registration of %s is not written (ask %s): %s", name, ask, reason),
|
||||
"A registration change approved was not written",
|
||||
fmt.Sprintf("The operator's warrant of the ask %s was given up after the bus gave it its last time, so the registration of %s is not written and the ask is answered as not applied: %s. Asking the change again raises a new ask.", ask, name, reason),
|
||||
"indexer."+RegistrationUnwrittenKind)
|
||||
if err := ix.Findings.Write(ctx, f); err != nil {
|
||||
ix.logf("registrations: the finding %s of %s is not written: %v", RegistrationUnwrittenKind, name, err)
|
||||
}
|
||||
return
|
||||
}
|
||||
if err := ix.clearFinding(ctx, mcc.ScopeModule, name, RegistrationUnwrittenKind, "a later version of "+name+" is written (ask "+ask+")"); err != nil {
|
||||
ix.logf("registrations: the finding %s of %s is not cleared: %v", RegistrationUnwrittenKind, name, err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,6 +2,7 @@ package index
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
mcc "git.novox.be/novox/mesh-contracts/health-and-repair/go/clients/meshconditionsclient"
|
||||
@@ -45,4 +46,15 @@ func TestRegistrationFindings(t *testing.T) {
|
||||
if held(SeedWaitsKind) {
|
||||
t.Fatal("the warrant did not clear seed-waits")
|
||||
}
|
||||
// Design 47 H2 H-A-470 (2): registration-unwritten is of the module, its id the registration's name, naming the ask and
|
||||
// the reason; cleared when a later version is written.
|
||||
ix.RegistrationUnwritten(ctx, "source.novox.hq", "ask-2", "nats: no response from stream", true)
|
||||
if h := w.Held(); len(h) != 1 || h[0].Scope != mcc.ScopeModule || h[0].Kind != RegistrationUnwrittenKind || h[0].ID != keyID("source.novox.hq") ||
|
||||
!strings.Contains(h[0].Summary, "ask-2") || !strings.Contains(h[0].Summary, "no response from stream") {
|
||||
t.Fatalf("registration-unwritten: %+v", h)
|
||||
}
|
||||
ix.RegistrationUnwritten(ctx, "source.novox.hq", "ask-3", "", false)
|
||||
if len(w.Held()) != 0 {
|
||||
t.Fatal("a later version written did not clear registration-unwritten")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -202,6 +202,9 @@ type Registry struct {
|
||||
Where func(id string) (state string, w *oc.Warrant, err error)
|
||||
// SeedWaits says the finding seed-waits naming the ask, and clears it (§8); nil says nothing.
|
||||
SeedWaits func(ask string, waiting bool)
|
||||
// Unwritten says the finding registration-unwritten of a registration whose warrant was given up, naming the ask and the
|
||||
// reason, and clears it when a later version of it is written (design 47 H2 H-A-470 (2)); nil says nothing.
|
||||
Unwritten func(name, ask, reason string, unwritten bool)
|
||||
// Seed composes the first registrations (§8); nil proposes none.
|
||||
Seed func(ctx context.Context) (SeedProposal, error)
|
||||
Now func() time.Time
|
||||
@@ -899,6 +902,30 @@ func (r *Registry) Heard(ctx context.Context, w oc.Warrant) error {
|
||||
return r.apply(ctx, key, *p, *rec)
|
||||
}
|
||||
|
||||
// GiveUp answers the ask of a warrant the indexer gives up on, its message given the last time the bus gives it, as not applied:
|
||||
// its key ends refused "not applied: <reason>", and the registration it would have written is said as the finding
|
||||
// registration-unwritten naming the ask and the reason; never left silent. The seed's key raises no such finding: its end
|
||||
// already says seed-waits (design 47 H2 H-A-470 (2) and its two addenda).
|
||||
func (r *Registry) GiveUp(ctx context.Context, w oc.Warrant, reason string) error {
|
||||
r.mu.Lock()
|
||||
defer r.mu.Unlock()
|
||||
key, p, err := r.findAsk(ctx, w.Ask)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if p == nil || p.State != ProposalOpen {
|
||||
r.logf("the warrant of the ask %s is given up and matches no open proposal, so nothing is answered", w.Ask)
|
||||
return nil
|
||||
}
|
||||
if err := r.endKey(ctx, key, *p, ProposalRefused, "not applied: "+reason); err != nil {
|
||||
return err
|
||||
}
|
||||
if key != SeedKey && r.Unwritten != nil {
|
||||
r.Unwritten(p.Module, w.Ask, reason, true)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Registry) endKey(ctx context.Context, key string, p Proposal, state, outcome string) error {
|
||||
if key == SeedKey && state != ProposalApplied && r.SeedWaits != nil {
|
||||
state = ProposalSeedWaits
|
||||
@@ -977,6 +1004,9 @@ func (r *Registry) write(ctx context.Context, key string, p Proposal, next meshc
|
||||
return err
|
||||
}
|
||||
step("written")
|
||||
if r.Unwritten != nil {
|
||||
r.Unwritten(name, w.Ask, "", false)
|
||||
}
|
||||
if r.Say != nil {
|
||||
defer step("registration-changed said")
|
||||
if err := r.Say(ctx, meshcatalog.RegistrationChangedEvent{V: 1, Module: name, Version: next.Version, Moved: p.Lines, By: p.Caller, Warrant: w.Ask, At: &at}); err != nil {
|
||||
|
||||
@@ -256,6 +256,66 @@ func TestRegistrationsAreWrittenOnTheirWarrantOnly(t *testing.T) {
|
||||
})
|
||||
}
|
||||
|
||||
// Design 47 H2 H-A-470 (2) and its addenda: a warrant the indexer gives up on (its history write refused, given the last time)
|
||||
// ends its key refused "not applied: <reason>" and says registration-unwritten of the registration, naming the ask and the
|
||||
// reason; a later version written clears it; the seed's key ends so too, with no such finding (seed-waits says it).
|
||||
func TestAWarrantGivenUpIsAnsweredNotAppliedAndSaid(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
g := newRegRig()
|
||||
type said struct {
|
||||
name, ask, reason string
|
||||
unwritten bool
|
||||
}
|
||||
var findings []said
|
||||
g.r.Unwritten = func(name, ask, reason string, unwritten bool) {
|
||||
findings = append(findings, said{name, ask, reason, unwritten})
|
||||
}
|
||||
refused := errors.New("nats: no response from stream")
|
||||
g.r.History = func(context.Context, meshcatalog.Registration) error { return refused }
|
||||
got, _ := g.r.Propose(ctx, "register", "s@n", reg("a", meshcatalog.StepStatuses{}, "main"))
|
||||
g.chosen[got.Ask] = "approve"
|
||||
err := g.r.Heard(ctx, g.warrant(got.Ask, "approve"))
|
||||
if err == nil {
|
||||
t.Fatal("a history write refused was applied")
|
||||
}
|
||||
if err := g.r.GiveUp(ctx, g.warrant(got.Ask, "approve"), err.Error()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rows, _ := ListProposals(ctx, g.r.Proposals)
|
||||
if len(rows) != 1 || rows[0].State != ProposalRefused || !strings.HasPrefix(rows[0].Outcome, "not applied: ") || !strings.Contains(rows[0].Outcome, refused.Error()) {
|
||||
t.Fatalf("the key given up: %+v; want refused, not applied, naming the reason", rows)
|
||||
}
|
||||
if len(findings) != 1 || findings[0].name != "a" || findings[0].ask != got.Ask || !strings.Contains(findings[0].reason, refused.Error()) || !findings[0].unwritten {
|
||||
t.Fatalf("findings said %+v; want registration-unwritten of a naming the ask and the reason", findings)
|
||||
}
|
||||
// Given up again (a late redelivery), an ended key says nothing more.
|
||||
_ = g.r.GiveUp(ctx, g.warrant(got.Ask, "approve"), "again")
|
||||
if len(findings) != 1 {
|
||||
t.Fatalf("an ended key said %+v", findings)
|
||||
}
|
||||
// Asked again and written, the finding clears.
|
||||
g.r.History = func(context.Context, meshcatalog.Registration) error { return nil }
|
||||
again, _ := g.r.Propose(ctx, "register", "s@n", reg("a", meshcatalog.StepStatuses{}, "main"))
|
||||
g.decide(t, again.Ask, "approve")
|
||||
if len(findings) != 2 || findings[1].name != "a" || findings[1].unwritten {
|
||||
t.Fatalf("findings said %+v; want registration-unwritten of a cleared by the version written", findings)
|
||||
}
|
||||
// The seed's warrant given up ends its key refused, says seed-waits and no registration-unwritten.
|
||||
var waits []bool
|
||||
g.r.SeedWaits = func(_ string, waiting bool) { waits = append(waits, waiting) }
|
||||
seed, _ := json.Marshal(Proposal{V: 1, Verb: verbSeed, Ask: "ask-seed", State: ProposalOpen})
|
||||
if err := g.r.Proposals.Create(ctx, SeedKey, seed); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := g.r.GiveUp(ctx, oc.Warrant{Ask: "ask-seed"}, "the store refused"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
p, _, _, _ := g.r.load(ctx, SeedKey)
|
||||
if p.State != ProposalSeedWaits || p.Outcome != "not applied: the store refused" || len(waits) != 1 || !waits[0] || len(findings) != 2 {
|
||||
t.Fatalf("the seed given up: %+v, seed-waits %v, findings %+v; want it ended not applied, seed-waits said, no registration-unwritten", p, waits, findings)
|
||||
}
|
||||
}
|
||||
|
||||
func mustJSON(v any) json.RawMessage { b, _ := json.Marshal(v); return b }
|
||||
|
||||
func TestProposalsSurviveARestartAndAreDropped(t *testing.T) {
|
||||
|
||||
@@ -14,10 +14,12 @@ import (
|
||||
"testing"
|
||||
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-indexer/takein"
|
||||
"git.novox.be/novox/mesh-sdk/go/buscompose"
|
||||
"git.novox.be/novox/mesh-sdk/go/busretry"
|
||||
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
||||
|
||||
"git.novox.be/novox/mesh-sdk/go/views"
|
||||
"github.com/nats-io/nats-server/v2/server"
|
||||
|
||||
"mesh-delivery-indexer/internal/index"
|
||||
)
|
||||
@@ -228,6 +230,16 @@ func TestManifestDeclarations(t *testing.T) { // 1238/AC1, 1444 (reads the build
|
||||
m.Streams[1].Name != m.Module+"-findings" || m.Streams[1].MaxAgeDays != 7 || m.Streams[1].MaxMiB != 8 {
|
||||
t.Errorf("streams = %+v, want registration-history keeping its history, 64 MiB, and the findings stream at 8 MiB (§387, H2 §783)", m.Streams)
|
||||
}
|
||||
// Design 47 H2 H-A-470 (1): the stream takes every registration's name whole, a module's one token and a source-only
|
||||
// registration's source.<owner>.<name> (H-A-408's key), so its write lands and is never dropped for want of a subject; the manifest spells the bus's `>` as `**`.
|
||||
if len(m.Streams) > 0 {
|
||||
for _, name := range []string{"mesh-delivery-indexer", "source.novox.hq"} {
|
||||
subject := index.RegistrationHistoryEvent + "." + name
|
||||
if !slices.ContainsFunc(m.Streams[0].Events, func(e string) bool { return server.SubjectMatchesFilter(subject, buscompose.WirePattern(e)) }) {
|
||||
t.Errorf("registration-history takes %v, so the history of %s (%s) has no subject on it (H-A-470)", m.Streams[0].Events, name, subject)
|
||||
}
|
||||
}
|
||||
}
|
||||
// Design 47 H2 §810, §814 (H-A-394 (1)): it claims a seat, so its class is core. §775: it makes kept calls, so it declares
|
||||
// the kept-call pace, 1 s to 30 s, read while it runs. §803 (H-A-461 (2)): a take-in's waiting line and bound, 1m and 5m.
|
||||
if m.Class != "core" {
|
||||
|
||||
@@ -173,7 +173,7 @@
|
||||
{ "name": "dry-runs", "history": 1, "ttl-seconds": 3600, "max-mib": 16 }
|
||||
],
|
||||
"streams": [
|
||||
{ "name": "registration-history", "events": ["registration.*"], "retention": "history", "max-mib": 64 },
|
||||
{ "name": "registration-history", "events": ["registration.**"], "retention": "history", "max-mib": 64 },
|
||||
{ "name": "mesh-delivery-indexer-findings", "events": ["finding-written.*", "finding-cleared.*", "findings-stated.*"], "max-age-days": 7, "max-mib": 8 }
|
||||
],
|
||||
"objects": [
|
||||
|
||||
@@ -70,7 +70,8 @@ func (c creating) CreateDeclared(cfg jetstream.StreamConfig) error {
|
||||
}
|
||||
|
||||
// AddSubjects adds subjects to a held stream and changes nothing else: it reads the stream's configuration, sets its
|
||||
// subjects to the union and updates with the rest as it was.
|
||||
// subjects to grants.WidenSubjects of what it holds and add (a held subject an added one covers replaced by it, since the
|
||||
// bus refuses an overlap: design 47 H H-A-470, third addendum) and updates with the rest as it was.
|
||||
func (c creating) AddSubjects(stream string, add []string) error {
|
||||
ctx, cancel := context.WithTimeout(c.ctx, requestWithin)
|
||||
defer cancel()
|
||||
@@ -79,11 +80,7 @@ func (c creating) AddSubjects(stream string, add []string) error {
|
||||
return err
|
||||
}
|
||||
cfg := s.CachedInfo().Config
|
||||
for _, a := range add {
|
||||
if !slices.Contains(cfg.Subjects, a) {
|
||||
cfg.Subjects = append(cfg.Subjects, a)
|
||||
}
|
||||
}
|
||||
cfg.Subjects, _ = grants.WidenSubjects(cfg.Subjects, add)
|
||||
_, err = c.js.UpdateStream(ctx, cfg)
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -614,6 +614,27 @@ func TestTheGrantsPartWhole(t *testing.T) {
|
||||
if again, _ := stream.Info(ctx); !slices.Equal(again.Config.Subjects, []string{"a.>", "b.>"}) {
|
||||
t.Errorf("subjects after adding a held one: %v", again.Config.Subjects)
|
||||
}
|
||||
// A held subject the added one covers is replaced by it, the messages kept: the bus refuses `registration.>` beside
|
||||
// `registration.*` (JetStream 10052, overlapping subjects), the live registration history's case (design 47 H
|
||||
// H-A-470, third addendum).
|
||||
reg, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "REGHIST", Subjects: []string{"m.registration.*"}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, subj := range []string{"m.registration.one", "m.registration.two"} {
|
||||
if _, err := js.Publish(ctx, subj, []byte("x")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if err := c.AddSubjects("REGHIST", []string{"m.registration.>"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := js.Publish(ctx, "m.registration.source.novox.hq", []byte("x")); err != nil {
|
||||
t.Errorf("a source-only registration's write: %v", err)
|
||||
}
|
||||
if now, _ := reg.Info(ctx); !slices.Equal(now.Config.Subjects, []string{"m.registration.>"}) || now.State.Msgs != 3 {
|
||||
t.Errorf("the registration history after the widening: subjects %v, %d messages, want m.registration.> and 3", now.Config.Subjects, now.State.Msgs)
|
||||
}
|
||||
// A kept stream's source filter is brought to its definition's in place: the stream is not made again, its settings
|
||||
// stay, and an equal filter or a source of another stream changes nothing (design 47 H H-A-145, §746).
|
||||
if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "KEPTSRC", Subjects: []string{"ev.>"}}); err != nil {
|
||||
|
||||
@@ -181,7 +181,7 @@ func (b *fakeBus) CreateConsumer(stream string, cfg jetstream.ConsumerConfig) er
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddSubjects is the bus's addition of subjects to a held stream: the union, every other setting kept.
|
||||
// AddSubjects is the bus's addition of subjects to a held stream: a covered subject replaced, every other setting kept.
|
||||
func (b *fakeBus) AddSubjects(stream string, add []string) error {
|
||||
b.mu.Lock()
|
||||
defer b.mu.Unlock()
|
||||
@@ -192,12 +192,7 @@ func (b *fakeBus) AddSubjects(stream string, add []string) error {
|
||||
for _, s := range b.streams {
|
||||
if s["name"] == stream {
|
||||
have, _ := s["subjects"].([]string)
|
||||
for _, a := range add {
|
||||
if !slices.Contains(have, a) {
|
||||
have = append(have, a)
|
||||
}
|
||||
}
|
||||
s["subjects"] = have
|
||||
s["subjects"], _ = grants.WidenSubjects(have, add)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
@@ -2270,7 +2265,8 @@ func TestGrants(t *testing.T) {
|
||||
|
||||
// H-A-468 (design 47 H2): a seat with an accept that is not pulled by kind gets its one shared worker, SeatQueue's, made by
|
||||
// the grants part where the bus lacks it (its holders bind it, never make it); a seat pulled by kind gets none (its
|
||||
// per-queue workers are its holders' seat traffic's); a worker the bus holds is left as it is, and no pass deletes it.
|
||||
// per-queue workers are its holders' seat traffic's, made too where the bus lacks them: H-A-468, third addendum); a
|
||||
// worker the bus holds is left as it is, and no pass deletes it.
|
||||
t.Run("a seat's shared worker is made where the bus lacks it", func(t *testing.T) {
|
||||
raw, err := os.ReadFile("module.json")
|
||||
if err != nil {
|
||||
@@ -2279,6 +2275,10 @@ func TestGrants(t *testing.T) {
|
||||
b := fixture()
|
||||
b.manifestOf("mesh-grants", string(raw))
|
||||
b.assign("a", "mesh-grants")
|
||||
// H-A-468 (third addendum): a holder of a seat pulled by kind, on a bus that holds one queue's plain worker and lacks
|
||||
// the other's (live, the Node build module's install queue had none and pulled nothing).
|
||||
b.manifestOf("go-builder", `{"module":"go-builder","version":"1","own-secrets":{"broker":"/var/lib/gb/broker"},"claims":[{"name":"node-build-go"}]}`)
|
||||
b.assign("a", "go-builder")
|
||||
b.loaded = shadowOf(t, b)
|
||||
p := partOn(b)
|
||||
p.Create, p.Consumers = b, b
|
||||
@@ -2287,8 +2287,19 @@ func TestGrants(t *testing.T) {
|
||||
"node-build-go": {Seat: "node-build-go", PulledByKind: true, Accepts: []seatdef.Message{{Name: "check"}}},
|
||||
"mesh-wants": {Seat: "mesh-wants", Accepts: []seatdef.Message{{Name: "step"}}},
|
||||
}
|
||||
b.consumers = map[string][]map[string]any{"SEAT_MESH_WANTS": {{"name": "SEAT_MESH_WANTS_worker", "filters": []string{"mesh.seat.mesh-wants.accept.>"}, "max_deliver": 9}}}
|
||||
b.consumers = map[string][]map[string]any{"SEAT_MESH_WANTS": {{"name": "SEAT_MESH_WANTS_worker", "filters": []string{"mesh.seat.mesh-wants.accept.>"}, "max_deliver": 9}},
|
||||
"SEAT_NODE_BUILD_GO": {{"name": "SEAT_NODE_BUILD_GO_CHECK_worker", "filters": []string{"mesh.seat.node-build-go.accept.check"}, "max_deliver": 9}}}
|
||||
res := p.Compose()
|
||||
if !slices.Contains(res.Consumers.Created, "SEAT_NODE_BUILD_GO.SEAT_NODE_BUILD_GO_DELIVERY_worker") ||
|
||||
!slices.Contains(res.Consumers.Created, "SEAT_NODE_BUILD_GO.SEAT_NODE_BUILD_GO_RECHECK_worker") ||
|
||||
slices.Contains(res.Consumers.Created, "SEAT_NODE_BUILD_GO.SEAT_NODE_BUILD_GO_CHECK_worker") {
|
||||
t.Errorf("a pulled-by-kind seat's per-queue workers: created %v, want each queue's the bus lacks, the held check worker not", res.Consumers.Created)
|
||||
}
|
||||
for _, c := range b.consumers["SEAT_NODE_BUILD_GO"] {
|
||||
if c["name"] == "SEAT_NODE_BUILD_GO_CHECK_worker" && c["max_deliver"] != 9 {
|
||||
t.Errorf("the held check worker was changed: %v", c)
|
||||
}
|
||||
}
|
||||
var made map[string]any
|
||||
for _, c := range b.consumers["SEAT_MESH_BUILDS"] {
|
||||
if c["name"] == "SEAT_MESH_BUILDS_worker" {
|
||||
@@ -2306,7 +2317,7 @@ func TestGrants(t *testing.T) {
|
||||
t.Errorf("the wants seat's held worker was changed: %v", b.consumers["SEAT_MESH_WANTS"])
|
||||
}
|
||||
p.Compose()
|
||||
if len(b.consumers["SEAT_MESH_BUILDS"]) != 1 || len(b.consumers["SEAT_MESH_WANTS"]) != 1 {
|
||||
if len(b.consumers["SEAT_MESH_BUILDS"]) != 1 || len(b.consumers["SEAT_MESH_WANTS"]) != 1 || len(b.consumers["SEAT_NODE_BUILD_GO"]) != 3 {
|
||||
t.Errorf("a pass changed the seats' workers: %v", b.consumers)
|
||||
}
|
||||
})
|
||||
|
||||
@@ -286,13 +286,21 @@ func AccountConsumers(users []Principal) []ModuleConsumer {
|
||||
out = append(out, mc)
|
||||
}
|
||||
}
|
||||
// A build seat's named workers (design 47 G §544, A-413): the seat traffic of each composed holder names them, and the part makes
|
||||
// them, never only names them in a membership. Main's workers are held already; only the named ones are made here.
|
||||
// A build seat's workers (design 47 G §544, A-413; H2 H-A-468, third addendum): the seat traffic of each composed holder
|
||||
// names them, each queue's plain worker (SEAT_<SEAT>_<QUEUE>_worker) and its named one, and the part makes them where the
|
||||
// bus lacks them, never only names them in a membership. "Main's workers are held already" held only while the
|
||||
// controller made them: a queue added since had none.
|
||||
made := map[string]bool{}
|
||||
for _, p := range users {
|
||||
byKind := map[string]bool{}
|
||||
for _, s := range p.Holds {
|
||||
if s.PulledByKind {
|
||||
byKind[seatStreamName(s.Name)] = true
|
||||
}
|
||||
}
|
||||
_, cs := SeatTrafficObjects([]Principal{p})
|
||||
for _, c := range cs {
|
||||
if !strings.HasSuffix(c.Name, "_named_worker") || made[c.Stream+"."+c.Name] {
|
||||
if !(byKind[c.Stream] || strings.HasSuffix(c.Name, "_named_worker")) || made[c.Stream+"."+c.Name] {
|
||||
continue
|
||||
}
|
||||
made[c.Stream+"."+c.Name] = true
|
||||
|
||||
@@ -62,14 +62,18 @@ func TestNamedAsks(t *testing.T) {
|
||||
t.Errorf("the work queue's consumers: %d, want 4 (a main and a named worker for each of two queues)", len(consumers))
|
||||
}
|
||||
// A-413: the part makes the named workers (AccountConsumers), never only names them in a membership.
|
||||
named := 0
|
||||
// H-A-468 (third addendum): and each queue's plain worker, which a queue added since the controller ended had none of.
|
||||
named, plain := 0, 0
|
||||
for _, mc := range AccountConsumers([]Principal{{Kind: KindModule, Node: "one", Module: "go-module", Holds: []Seat{held}}}) {
|
||||
if strings.HasSuffix(mc.Consumer.Name, "_named_worker") {
|
||||
switch {
|
||||
case strings.HasSuffix(mc.Consumer.Name, "_named_worker"):
|
||||
named++
|
||||
case mc.Consumer.Name == "SEAT_NODE_BUILD_GO_CHECK_worker" || mc.Consumer.Name == "SEAT_NODE_BUILD_GO_DELIVERY_worker":
|
||||
plain++
|
||||
}
|
||||
}
|
||||
if named != 2 {
|
||||
t.Errorf("account consumers hold %d named workers, want 2", named)
|
||||
if named != 2 || plain != 2 {
|
||||
t.Errorf("account consumers hold %d named and %d plain workers, want 2 and 2", named, plain)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -62,8 +62,9 @@ const CreatesMissing = "a bucket, log or stream the manifest declares and the bu
|
||||
// 08:54). A stream the bus holds already answers ErrHeld.
|
||||
type Creator interface {
|
||||
CreateDeclared(cfg jetstream.StreamConfig) error
|
||||
// AddSubjects adds subjects to a stream the bus holds and nothing else: the stream's subjects become the union of what
|
||||
// it holds and add; no subject is removed, no limit, retention or other setting changed, the stream not recreated.
|
||||
// AddSubjects adds subjects to a stream the bus holds and nothing else: the stream's subjects become WidenSubjects of
|
||||
// what it holds and add, a held subject an added one covers replaced by it (design 47 H H-A-470, third addendum) and
|
||||
// no other removed; no limit, retention or other setting changed, the stream not recreated.
|
||||
AddSubjects(stream string, add []string) error
|
||||
// RaiseMaxBytes raises the size cap of a stream the bus holds to `to` when `to` is larger than the cap it holds, and
|
||||
// changes nothing else (the operator, 2026-11-09 09:07: "raise only"). It answers the cap it held and whether it
|
||||
@@ -208,7 +209,8 @@ func createMissing(c Creator, done *creations, a *Assertion, m catalogue.Manifes
|
||||
}
|
||||
}
|
||||
// A stream the bus holds whose manifest names events it has no subject for gains those subjects, and only ever those: a
|
||||
// subject the manifest dropped stays, limits and retention are left as they are (the operator, 2026-11-05).
|
||||
// subject the manifest dropped stays, limits and retention are left as they are (the operator, 2026-11-05). A held
|
||||
// subject a gained one covers is replaced by it, nothing dropped (design 47 H H-A-470, third addendum).
|
||||
for i := range a.Items {
|
||||
it := &a.Items[i]
|
||||
if it.Held == nil || it.Kind != "stream" {
|
||||
@@ -234,7 +236,14 @@ func createMissing(c Creator, done *creations, a *Assertion, m catalogue.Manifes
|
||||
}
|
||||
done.cleared(it.Stream)
|
||||
it.Created = "subjects added: " + strings.Join(add, ", ")
|
||||
made = append(made, "stream "+it.Stream+" gained "+strings.Join(add, ", "))
|
||||
gained := "stream " + it.Stream + " gained " + strings.Join(add, ", ")
|
||||
// A held subject an added one covers is replaced by it, and said (design 47 H H-A-470, third addendum).
|
||||
if _, replaced := WidenSubjects(it.Held.Subjects, add); len(replaced) > 0 {
|
||||
why := " (replacing " + strings.Join(replaced, ", ") + ", which it covers: every message kept)"
|
||||
it.Created += why
|
||||
gained += why
|
||||
}
|
||||
made = append(made, gained)
|
||||
}
|
||||
// A held stream, of any kind, whose manifest declares a larger size cap gets that cap, and no other limit changes: a
|
||||
// cap the bus holds that is larger or equal stays (the operator, 2026-11-09 09:07). Compared once per manifest.
|
||||
|
||||
@@ -93,16 +93,37 @@ func GrantWaits(accounts []string, composed, loaded map[string]User, unknown str
|
||||
func notAllowed(a, b []string) []string {
|
||||
var out []string
|
||||
for _, x := range a {
|
||||
if !slices.ContainsFunc(b, func(y string) bool { return subjectCovers(y, x) }) {
|
||||
if !slices.ContainsFunc(b, func(y string) bool { return SubjectCovers(y, x) }) {
|
||||
out = append(out, x)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// subjectCovers says whether the permission pattern p allows every subject the permission s allows, by the bus's wildcards:
|
||||
// `*` one token, `>` one or more tokens at the end.
|
||||
func subjectCovers(p, s string) bool {
|
||||
// WidenSubjects is a held stream's subjects once add is given them: each subject of add the stream lacks is added, and a
|
||||
// held subject an added one covers is replaced by it, since the bus refuses a subject overlapping one the stream holds
|
||||
// (JetStream 10052) and the held subject's every message still matches the added one (design 47 H H-A-470, third
|
||||
// addendum). No other held subject is removed. It answers the held subjects it replaced.
|
||||
func WidenSubjects(held, add []string) (subjects, replaced []string) {
|
||||
for _, h := range held {
|
||||
if slices.ContainsFunc(add, func(a string) bool { return a != h && SubjectCovers(a, h) }) {
|
||||
replaced = append(replaced, h)
|
||||
continue
|
||||
}
|
||||
subjects = append(subjects, h)
|
||||
}
|
||||
for _, a := range add {
|
||||
if !slices.Contains(subjects, a) {
|
||||
subjects = append(subjects, a)
|
||||
}
|
||||
}
|
||||
return subjects, replaced
|
||||
}
|
||||
|
||||
// SubjectCovers says whether the permission pattern p allows every subject the permission s allows, by the bus's wildcards:
|
||||
// `*` one token, `>` one or more tokens at the end. It also
|
||||
// says whether a stream subject p takes every message a held subject s takes (design 47 H H-A-470, third addendum).
|
||||
func SubjectCovers(p, s string) bool {
|
||||
pt, st := strings.Split(p, "."), strings.Split(s, ".")
|
||||
for i, t := range pt {
|
||||
if t == ">" {
|
||||
|
||||
@@ -25,8 +25,8 @@ func TestAGrantWaitsOnlyForWhatTheLoadedListDoesNotAllow(t *testing.T) {
|
||||
p, s string
|
||||
want bool
|
||||
}{{">", "a", true}, {">", "a.>", true}, {"a.>", "a", false}, {"a.*", "a.>", false}, {"a.*", "a.*", true}, {"a.b", "a.b", true}, {"a.b", "a.b.c", false}} {
|
||||
if got := subjectCovers(c.p, c.s); got != c.want {
|
||||
t.Errorf("subjectCovers(%q, %q) = %v, want %v", c.p, c.s, got, c.want)
|
||||
if got := SubjectCovers(c.p, c.s); got != c.want {
|
||||
t.Errorf("SubjectCovers(%q, %q) = %v, want %v", c.p, c.s, got, c.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
package grants
|
||||
|
||||
import (
|
||||
"slices"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
||||
@@ -38,3 +40,31 @@ func TestAStatesDeclaredCapReachesItsBucket(t *testing.T) {
|
||||
t.Errorf("the held bucket was raised to %d (%v), want 256 MiB", r.to, raises)
|
||||
}
|
||||
}
|
||||
|
||||
// adder is a Creator that records the subjects it is asked to add to a held stream.
|
||||
type adder struct {
|
||||
Creator
|
||||
add []string
|
||||
}
|
||||
|
||||
func (a *adder) AddSubjects(_ string, add []string) error { a.add = add; return nil }
|
||||
|
||||
// A held subject the composed one covers is replaced by it, and the assertion says so (design 47 H H-A-470, third
|
||||
// addendum: the bus refuses `registration.>` beside `registration.*`, JetStream 10052); no other subject is dropped.
|
||||
func TestAHeldSubjectTheComposedOneCoversIsReplaced(t *testing.T) {
|
||||
held, replaced := WidenSubjects([]string{"m.registration.*", "kept.subject"}, []string{"m.registration.>"})
|
||||
if !slices.Equal(held, []string{"kept.subject", "m.registration.>"}) || !slices.Equal(replaced, []string{"m.registration.*"}) {
|
||||
t.Errorf("widened to %v replacing %v", held, replaced)
|
||||
}
|
||||
if held, replaced := WidenSubjects([]string{"a.>"}, []string{"a.>", "b.*"}); !slices.Equal(held, []string{"a.>", "b.*"}) || replaced != nil {
|
||||
t.Errorf("an equal or uncovered subject: %v replacing %v", held, replaced)
|
||||
}
|
||||
a := Assertion{Manifest: "d", Items: []Item{{Kind: "stream", Stream: "LOG_m_registration-history",
|
||||
Composed: Limits{Subjects: []string{"m.registration.>"}}, Held: &Limits{Subjects: []string{"m.registration.*"}}}}}
|
||||
c := &adder{}
|
||||
made, _ := createMissing(c, &creations{}, &a, catalogue.Manifest{Module: "m"}, nil, false)
|
||||
const said = "replacing m.registration.*, which it covers"
|
||||
if !slices.Equal(c.add, []string{"m.registration.>"}) || len(made) != 1 || !strings.Contains(made[0], said) || !strings.Contains(a.Items[0].Created, said) {
|
||||
t.Errorf("added %v, said %v and %q: want the replacement said", c.add, made, a.Items[0].Created)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user