The eight Go test functions H2 added become subtests of existing tests (catalogue's state test, the bundle's state test, the views test, the process state test, the testbus bus test, the seal byte-for-byte test), and four more are folded beside them (two seal, two process watch); the two TypeScript seal tests become one, and two more TypeScript tests are folded into their neighbours. No assertion is lost. Builds: design 47 H2 §819
149 lines
7.1 KiB
Go
149 lines
7.1 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"encoding/json"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/seatdef"
|
|
)
|
|
|
|
// A module declares the state it keeps and the state it reads (novox/hq ADR 0201), a bucket by its
|
|
// bare name or with the owner's options.
|
|
func TestAManifestMaySayWhatStateItKeepsAndReads(t *testing.T) {
|
|
m, err := decodeForTest([]byte(`{"module":"claude-code","version":"1",` +
|
|
`"state":["servers",{"name":"seen","history":5,"ttl-seconds":3600}],` +
|
|
`"reads":["licence-manager.bindings"]}`))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(m.State) != 2 || m.State[0].Name != "servers" || m.State[1].History != 5 || m.State[1].TTLSeconds != 3600 {
|
|
t.Fatalf("state not read: %+v", m.State)
|
|
}
|
|
if len(m.Reads) != 1 || m.Reads[0] != "licence-manager.bindings" {
|
|
t.Fatalf("reads not read: %v", m.Reads)
|
|
}
|
|
// Written back as it came in: the short form where nothing else is said.
|
|
out, _ := json.Marshal(m.State)
|
|
if string(out) != `["servers",{"name":"seen","history":5,"ttl-seconds":3600}]` {
|
|
t.Fatalf("written back as %s", out)
|
|
}
|
|
// Design 47 H2 §812, §814: the validator reads every state, log and objects entry of a manifest that names no cap, in
|
|
// the old sections and in requires alike; a capped entry, and an entry of another template, is none of them.
|
|
t.Run("each kept store that names no cap", func(t *testing.T) {
|
|
m, err := decodeForTest([]byte(`{"module":"x","version":"1",
|
|
"state":["seen",{"name":"held","max-mib":8}],
|
|
"logs":[{"name":"acts"},{"name":"kept","max-mib":64}],
|
|
"objects":[{"name":"outputs","max-mib":256}],
|
|
"requires":[{"name":"performed","storage":"key-value","template":"state","options":{"history":1}},
|
|
{"name":"taken","storage":"key-value","template":"state","options":{"max-mib":8,"key-ttl":true}},
|
|
{"name":"archives","storage":"object-store","template":"objects"},
|
|
{"name":"finding-events","storage":"stream","template":"events"}]}`))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := []Uncapped{{Name: "seen", Kind: "state", OldSection: true}, {Name: "acts", Kind: "log", OldSection: true},
|
|
{Name: "performed", Kind: "state"}, {Name: "archives", Kind: "objects"}}
|
|
if got := m.UncappedStores(); !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("the uncapped stores are %+v, want %+v", got, want)
|
|
}
|
|
})
|
|
// Design 47 H2 §810 (H-A-394): a manifest says its class, core or leaf; one that names none is a leaf.
|
|
t.Run("its class, none a leaf", func(t *testing.T) {
|
|
for raw, leaf := range map[string]bool{`"class":"core",`: false, `"class":"leaf",`: true, ``: true} {
|
|
m, err := decodeForTest([]byte(`{` + raw + `"module":"x","version":"1"}`))
|
|
if err != nil || m.Leaf() != leaf || m.UnknownField() != "" {
|
|
t.Errorf("%s read as class %q, leaf %v (%v, unknown %q), want leaf %v", raw, m.Class, m.Leaf(), err, m.UnknownField(), leaf)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// 1154/AC1: a state entry may say key-ttl; it is read, written back, and a bare name or an entry without it reads as before.
|
|
// G-sdk-contracts 4: read-only likewise, and given twice it is refused.
|
|
func TestAStateMayHaveKeysThatExpireOneByOne(t *testing.T) {
|
|
m, err := decodeForTest([]byte(`{"module":"mesh-delivery-watchman","version":"1",` +
|
|
`"state":[{"name":"pulse","key-ttl":true},"stuck",{"name":"seen","history":5},{"name":"spent","read-only":true}]}`))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !m.State[0].KeyTTL || m.State[1].KeyTTL || m.State[2].KeyTTL {
|
|
t.Fatalf("key-ttl not read as said: %+v", m.State)
|
|
}
|
|
if !m.State[3].ReadOnly || m.State[0].ReadOnly || m.State[1].ReadOnly {
|
|
t.Fatalf("read-only not read as said: %+v", m.State)
|
|
}
|
|
out, _ := json.Marshal(m.State)
|
|
if string(out) != `[{"name":"pulse","key-ttl":true},"stuck",{"name":"seen","history":5},{"name":"spent","read-only":true}]` {
|
|
t.Fatalf("written back as %s", out)
|
|
}
|
|
// G §469, §695: an old state entry takes max-mib, written back, bounded as an objects section's.
|
|
capped, err := decodeForTest([]byte(`{"module":"x","version":"1","state":[{"name":"a","max-mib":256},"b"]}`))
|
|
if err != nil || capped.State[0].MaxMiB != 256 || capped.State[1].MaxMiB != 0 {
|
|
t.Fatalf("max-mib read as %+v, %v", capped.State, err)
|
|
}
|
|
if out, _ := json.Marshal(capped.State); string(out) != `[{"name":"a","max-mib":256},"b"]` {
|
|
t.Fatalf("max-mib written back as %s", out)
|
|
}
|
|
for _, bad := range []string{"0", "-1", "8193"} {
|
|
if _, err := decodeForTest([]byte(`{"module":"x","version":"1","state":[{"name":"a","max-mib":` + bad + `}]}`)); err == nil {
|
|
t.Errorf("max-mib %s was read", bad)
|
|
}
|
|
}
|
|
if _, err := decodeForTest([]byte(`{"module":"x","version":"1","state":[{"name":"a","max-mib":8192}]}`)); err != nil {
|
|
t.Errorf("max-mib 8192 refused: %v", err)
|
|
}
|
|
if _, err := decodeForTest([]byte(`{"module":"nats","version":"1","state":[{"name":"spent","read-only":true,"read-only":false}]}`)); err == nil ||
|
|
!strings.Contains(err.Error(), "the field state[0].read-only is given twice") {
|
|
t.Fatalf("read-only given twice: %v", err)
|
|
}
|
|
}
|
|
|
|
// A read of a seat holder's state is its own kind, `seat:<seat>.<state>` (design 47 G A-128), and a seat's compiled form
|
|
// carries the names of the states its definition declares.
|
|
func TestSeatRead(t *testing.T) {
|
|
for _, row := range []struct {
|
|
read, seat, local string
|
|
ok, bad bool
|
|
}{
|
|
{"seat:mesh-provisioner.plans", "mesh-provisioner", "plans", true, false},
|
|
{"mesh-provisioner.plans", "", "", false, false},
|
|
{"seat:mesh-provisioner", "", "", true, true},
|
|
{"seat:.plans", "", "", true, true},
|
|
{"seat:Mesh.plans", "", "", true, true},
|
|
} {
|
|
seat, local, ok, err := SeatRead(row.read)
|
|
if seat != row.seat || local != row.local || ok != row.ok || (err != nil) != row.bad {
|
|
t.Errorf("SeatRead(%q) = %q, %q, %v, %v", row.read, seat, local, ok, err)
|
|
}
|
|
}
|
|
for _, row := range []struct {
|
|
consume, seat, state string
|
|
ok, bad bool
|
|
}{
|
|
{"seat:mesh-provisioner.views.plans", "mesh-provisioner", "plans", true, false},
|
|
{"mesh-provisioner.views.plans", "", "", false, false},
|
|
{"seat:mesh-provisioner.plans", "", "", true, true},
|
|
{"seat:.views.plans", "", "", true, true},
|
|
} {
|
|
seat, state, ok, err := SeatViewConsume(row.consume)
|
|
if seat != row.seat || state != row.state || ok != row.ok || (err != nil) != row.bad {
|
|
t.Errorf("SeatViewConsume(%q) = %q, %q, %v, %v", row.consume, seat, state, ok, err)
|
|
}
|
|
}
|
|
s := SeatFromDefinition(seatdef.Definition{Seat: "mesh-provisioner", Scope: "mesh",
|
|
States: []seatdef.State{{Name: "plans", View: true}, {Name: "provisions"}},
|
|
Accepts: []seatdef.Message{{Name: "step", Stream: "check"}, {Name: "step"}}})
|
|
if len(s.States) != 2 || s.States[0] != "plans" || s.States[1] != "provisions" || len(s.Views) != 1 || s.Views[0] != "plans" ||
|
|
len(s.AcceptedOn) != 1 || s.AcceptedOn[0] != "check.step" {
|
|
t.Errorf("the seat's states = %v, views = %v, accepted on = %v", s.States, s.Views, s.AcceptedOn)
|
|
}
|
|
// A-177 (design 46 approval mark §2, §4): a compiled verb carries its definition's approval mark.
|
|
marked := SeatFromDefinition(seatdef.Definition{Seat: "node-login-shell",
|
|
Verbs: []seatdef.Verb{{Name: "execute", NeedsApproval: true}, {Name: "read"}}})
|
|
if len(marked.Serves) != 2 || !marked.Serves[0].NeedsApproval || marked.Serves[1].NeedsApproval {
|
|
t.Errorf("the compiled verbs' marks = %+v", marked.Serves)
|
|
}
|
|
}
|