jschoubben
2aab86c5cb
catalogue.ControllerMirrors and StateReadsNothingDeclares go, and the catalogue pass no longer judges a read against the owner's manifest: an owner's announcement and its own announcement test hold what it keeps.
96 lines
4.0 KiB
Go
96 lines
4.0 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// 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 := ParseManifest([]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)
|
|
}
|
|
}
|
|
|
|
// A name the bus could not hold, or that would let two modules derive one bucket, is refused at
|
|
// registration in the manifest's words.
|
|
func TestAStateNameIsLocalAndOneToken(t *testing.T) {
|
|
for _, c := range []struct{ manifest, says string }{
|
|
{`{"module":"a","version":"1","state":["mesh.servers"]}`, `keeps state "mesh.servers": a state is named locally`},
|
|
{`{"module":"a","version":"1","state":["my_servers"]}`, `keeps state "my_servers"`},
|
|
{`{"module":"a","version":"1","state":["s","s"]}`, `keeps state "s" twice`},
|
|
{`{"module":"a","version":"1","state":[{"name":"s","history":65}]}`, `a key keeps between 1 and 64`},
|
|
{`{"module":"a.b","version":"1","state":["s"]}`, `no dot`},
|
|
{`{"module":"a","version":"1","reads":["bindings"]}`, `a read is <module>.<name>`},
|
|
{`{"module":"a","version":"1","reads":["a.s"]}`, `which is its own state`},
|
|
{`{"module":"a","version":"1","state":[{"name":"s","shared":true}]}`, `{name, history, ttl-seconds, per-machine, key-ttl}`},
|
|
} {
|
|
_, err := ParseManifest([]byte(c.manifest))
|
|
if err == nil {
|
|
t.Errorf("%s was accepted", c.manifest)
|
|
continue
|
|
}
|
|
if !strings.Contains(err.Error(), c.says) {
|
|
t.Errorf("%s refused for the wrong reason: %v", c.manifest, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// **Across the whole catalogue**: every state name is local and every read names a module's state.
|
|
func TestEveryManifestsStateIsLocalAndEveryReadIsKept(t *testing.T) {
|
|
manifests := theCatalogue(t)
|
|
var problems []string
|
|
for _, m := range manifests {
|
|
problems = append(problems, StateProblems(m)...)
|
|
}
|
|
if len(problems) > 0 {
|
|
t.Fatalf("the catalogue's state is not what ADR 0201 says:\n %s", strings.Join(problems, "\n "))
|
|
}
|
|
}
|
|
|
|
// The catalogue pass no longer judges one module's reads against another's manifest (novox/hq ADR 0495 clauses 1 and 5,
|
|
// issue 1790): what an owner keeps is what it announces on the bus, and each module's own announcement test holds that.
|
|
func TestTheCataloguePassJudgesNoReadAgainstTheOwnersManifest(t *testing.T) {
|
|
shelf := Shelf{
|
|
"licence-manager": {Module: "licence-manager", State: []StateDeclaration{{Name: "bindings"}}},
|
|
"claude-code": {Module: "claude-code", Reads: []string{"licence-manager.tokens"}},
|
|
}
|
|
for _, p := range CatalogueProblems(shelf) {
|
|
if strings.Contains(p, "keeps no state") {
|
|
t.Fatalf("the catalogue pass judged a read against the owner's manifest: %s", p)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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.
|
|
func TestAStateMayHaveKeysThatExpireOneByOne(t *testing.T) {
|
|
m, err := ParseManifest([]byte(`{"module":"mesh-delivery-watchman","version":"1",` +
|
|
`"state":[{"name":"pulse","key-ttl":true},"stuck",{"name":"seen","history":5}]}`))
|
|
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)
|
|
}
|
|
out, _ := json.Marshal(m.State)
|
|
if string(out) != `[{"name":"pulse","key-ttl":true},"stuck",{"name":"seen","history":5}]` {
|
|
t.Fatalf("written back as %s", out)
|
|
}
|
|
}
|