"Main's workers are held already" held only while the controller made them: the Node build module's install queue, added since, never had its plain worker, so the module pulled nothing. The account consumers now name each queue's plain worker beside its named one; a held one is left as it is. Builds: design 47 H H-A-468 (third addendum)
168 lines
7.8 KiB
Go
168 lines
7.8 KiB
Go
package buscompose
|
|
|
|
import (
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// Design 47 G §543, §544, §600: a build seat's ask names its asker and each queue has a named worker beside main's; any module may
|
|
// put any ask (principle 6, the operator 2026-11-15).
|
|
func TestNamedAsks(t *testing.T) {
|
|
build := Seat{Name: "node-build-go", Scope: "node", Accepts: []string{"delivery", "check", "recheck"}, PulledByKind: true}
|
|
asker := func(module string, held ...string) Principal {
|
|
p := Principal{Kind: KindModule, Node: "one", Module: module, Uses: []Seat{build}}
|
|
for _, h := range held {
|
|
p.Holds = append(p.Holds, Seat{Name: h})
|
|
}
|
|
return p
|
|
}
|
|
const base = "mesh.seat.node-build-go.accept."
|
|
// Principle 6 (the operator, 2026-11-15): every module's account may put an ask on any queue of any seat, under any asker's
|
|
// name or none (AnySeatSubject); the callers lists withhold nothing.
|
|
for _, who := range []Principal{asker("runner-module", "mesh-pipeline-runner"), asker("an-indexer", "mesh-catalog"),
|
|
asker("the-builder", "mesh-builds"), asker("a-stranger")} {
|
|
perms, err := PermissionsFor(who)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, subject := range []string{base + "check", base + "delivery", base + "check.mesh-catalog", base + "recheck.mesh-builds",
|
|
base + "check." + who.Module} {
|
|
if !MayPublish(perms, subject) {
|
|
t.Errorf("%s may not publish %s", who.Module, subject)
|
|
}
|
|
}
|
|
}
|
|
// Each queue's workers: main's and the named one, filtered to subjects that overlap nothing.
|
|
held := Seat{Name: "node-build-go", Scope: "node", Accepts: []string{"delivery", "check"}, PulledByKind: true}
|
|
// Main's subject, which names no asker, is the builder's alone: the checker is gone (design 47 H §764).
|
|
for holder, main := range map[string]bool{"mesh-builds": true, "mesh-delivery-checker": false} {
|
|
tr := SeatTrafficOf("m", []Seat{{Name: holder, Scope: "mesh"}}, []Seat{held}, nil)
|
|
if got := slices.Contains(tr.Publish, base+"check"); got != main {
|
|
t.Errorf("a holder of %s is granted main's %scheck: %v, want %v", holder, base, got, main)
|
|
}
|
|
}
|
|
tr := SeatTrafficOf("go-module", []Seat{held}, nil, nil)
|
|
filters := map[string]string{}
|
|
for _, w := range tr.Workers {
|
|
filters[w.Consumer] = w.Filter
|
|
}
|
|
for consumer, filter := range map[string]string{
|
|
"SEAT_NODE_BUILD_GO_CHECK_worker": base + "check",
|
|
"SEAT_NODE_BUILD_GO_CHECK_named_worker": base + "check.*",
|
|
"SEAT_NODE_BUILD_GO_DELIVERY_worker": base + "delivery",
|
|
"SEAT_NODE_BUILD_GO_DELIVERY_named_worker": base + "delivery.*",
|
|
} {
|
|
if filters[consumer] != filter {
|
|
t.Errorf("worker %s filters %q, want %q", consumer, filters[consumer], filter)
|
|
}
|
|
}
|
|
_, consumers := SeatTrafficObjects([]Principal{{Kind: KindModule, Node: "one", Module: "go-module", Holds: []Seat{held}}})
|
|
if len(consumers) != 4 {
|
|
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.
|
|
// 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}}}) {
|
|
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 || plain != 2 {
|
|
t.Errorf("account consumers hold %d named and %d plain workers, want 2 and 2", named, plain)
|
|
}
|
|
}
|
|
|
|
// Design 47 H §752, H-A-113 (2): every module's account may call every verb of every seat, invoked or not, in its own name,
|
|
// so no definition's callers withhold one; another account's name it may not take.
|
|
func TestEveryModuleMayCallEveryVerb(t *testing.T) {
|
|
build := Seat{Name: "node-build-go", Scope: "node", Serves: []string{"kept-artifact", "freed", "run"}}
|
|
invoker := Principal{Kind: KindModule, Node: "one", Module: "an-invoker", Uses: []Seat{build}, Invokes: []string{"seat:node-build-go.kept-artifact"}}
|
|
stranger := Principal{Kind: KindModule, Node: "one", Module: "a-stranger"}
|
|
for _, who := range []Principal{invoker, stranger} {
|
|
perms, err := PermissionsFor(who)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, subject := range []string{"mesh.seat.node-build-go.tool.freed.ace", "mesh.seat.node-build-go.tool.run",
|
|
"mesh.seat.mesh-wants.tool.upgrade", "mesh.seat.mesh-wants.call.upgrade." + CallerToken(who.Username())} {
|
|
if !MayPublish(perms, subject) {
|
|
t.Errorf("%s may not publish %s", who.Module, subject)
|
|
}
|
|
}
|
|
if MayPublish(perms, "mesh.seat.mesh-wants.call.upgrade.someone~else") {
|
|
t.Errorf("%s may call in another's name", who.Module)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Design 47 G §544: the grants part's account alone is granted the purge of a build seat's stream and the delete of its
|
|
// named workers, for every queue of a build seat a composed user holds.
|
|
func TestTheGrantsPartAlonePurgesTheNamedAsks(t *testing.T) {
|
|
held := Seat{Name: "node-build-go", Scope: "node", Accepts: []string{"check"}, PulledByKind: true}
|
|
users, err := Users(Records{Nodes: []string{"one"}, Assigned: map[string][]Declared{"one": {
|
|
{Module: GrantsModule}, {Module: "go-module", Holds: []Seat{held}}}}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, u := range users {
|
|
perms, err := PermissionsFor(u)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, subject := range []string{"$JS.API.STREAM.PURGE.SEAT_NODE_BUILD_GO",
|
|
"$JS.API.CONSUMER.DELETE.SEAT_NODE_BUILD_GO.SEAT_NODE_BUILD_GO_CHECK_named_worker"} {
|
|
if got, want := MayPublish(perms, subject), u.Module == GrantsModule && u.Kind == KindModule; got != want {
|
|
t.Errorf("%s may publish %s: %v, want %v", u.Username(), subject, got, want)
|
|
}
|
|
}
|
|
if u.Module == GrantsModule && MayPublish(perms, "$JS.API.CONSUMER.DELETE.SEAT_NODE_BUILD_GO.SEAT_NODE_BUILD_GO_CHECK_worker") {
|
|
t.Errorf("the grants part may delete main's worker")
|
|
}
|
|
}
|
|
}
|
|
|
|
// Design 47 G, lead answer A-393: a verb of a node-scoped seat asked with no machine is answered by any one holder, so each
|
|
// holder is granted the verb's subject without the machine (tool and call forms) beside its machine's, and a caller of the
|
|
// verb may publish on it; a verb of a seat held once for the mesh gains nothing, and a stranger is granted nothing.
|
|
func TestANodeSeatVerbIsAlsoGrantedWithoutTheMachine(t *testing.T) {
|
|
build := Seat{Name: "node-build-go", Scope: "node", Serves: []string{"steps"}}
|
|
holder := Principal{Kind: KindModule, Node: "shanks", Module: "mesh-build-go", Holds: []Seat{build}}
|
|
caller := Principal{Kind: KindModule, Node: "shanks", Module: "an-indexer", Uses: []Seat{build},
|
|
Invokes: []string{"seat:node-build-go.steps"}}
|
|
stranger := Principal{Kind: KindModule, Node: "shanks", Module: "a-stranger", Uses: []Seat{build}}
|
|
const tool = "mesh.seat.node-build-go.tool.steps"
|
|
call := "mesh.seat.node-build-go.call.steps."
|
|
for _, c := range []struct {
|
|
name string
|
|
who Principal
|
|
subject string
|
|
sub bool
|
|
want bool
|
|
}{
|
|
{"holder hears its machine's", holder, tool + ".shanks", true, true},
|
|
{"holder hears the node-less tool", holder, tool, true, true},
|
|
{"holder hears the node-less call", holder, call + "someone", true, true},
|
|
{"caller asks the node-less tool", caller, tool, false, true},
|
|
{"caller asks a machine's", caller, tool + ".shanks", false, true},
|
|
{"caller asks the node-less call in its name", caller, call + CallerToken(caller.Username()), false, true},
|
|
{"stranger asks the node-less tool: every account may call every verb (design 47 H §752)", stranger, tool, false, true},
|
|
} {
|
|
perms, err := PermissionsFor(c.who)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := MayPublish(perms, c.subject)
|
|
if c.sub {
|
|
got = MaySubscribe(perms, c.subject)
|
|
}
|
|
if got != c.want {
|
|
t.Errorf("%s: %v, want %v", c.name, got, c.want)
|
|
}
|
|
}
|
|
}
|