Every module built against the SDK reads its catalog half through mesh-catalog's registrations, revision and entry and mesh-delivery's source; naming them in the Go package's calls lets the indexer order such a module after the running versions that serve its start. Builds: design 47 G lead answer A-357 (the SDK half), §47 kind 6 Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
169 lines
10 KiB
Go
169 lines
10 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"maps"
|
|
"os"
|
|
"slices"
|
|
"testing"
|
|
)
|
|
|
|
// mesh-sdk's own manifest declares its two packages (design 32, SDK-10): the TypeScript `lib` and the Go `go`, built
|
|
// from the directory go, each without a series (design 47 G §411), so the Go build module publishes mesh-sdk's Go package through the Go seat
|
|
// (design 51). Its words are judged by the group's own indexer, delivered with them (ADR 0621 §4).
|
|
func TestOwnManifestUsesNoWordTheRunningControllerRefuses(t *testing.T) {
|
|
raw, err := os.ReadFile("../../module.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m, err := decodeForTest(raw)
|
|
if err != nil {
|
|
t.Fatalf("mesh-sdk's module.json does not parse: %v", err)
|
|
}
|
|
if m.Version != "0.1" || m.UnknownField() != "" {
|
|
t.Errorf("mesh-sdk's version is %q (unknown word %q), want 0.1 (design 47 G §368, §372)", m.Version, m.UnknownField())
|
|
}
|
|
if m.Build == nil || len(m.Build.Artifacts) == 0 {
|
|
t.Fatal("mesh-sdk's module.json declares no artifact")
|
|
}
|
|
packages := map[string]Artifact{}
|
|
for _, a := range m.Build.Artifacts {
|
|
packages[a.Language] = a
|
|
if a.Kind != ArtifactPackage || a.Series != "" {
|
|
t.Errorf("artifact %q is a %s in series %q, want a package in none (design 47 G §411)", a.Name, a.Kind, a.Series)
|
|
}
|
|
}
|
|
if g := packages["go"]; g.Name != "go" || !slices.Equal(g.Paths, []string{"go"}) {
|
|
t.Errorf("mesh-sdk's Go package is %+v, want go built from go", g)
|
|
}
|
|
// The seat verbs its code calls on a module's behalf, in the invokes form, so the indexer orders every module built
|
|
// against it after the running versions that serve its start (design 47 G lead answer A-357).
|
|
for _, verb := range []string{"seat:mesh-catalog.registrations", "seat:mesh-catalog.revision", "seat:mesh-catalog.entry", "seat:mesh-delivery.source"} {
|
|
if !slices.Contains(packages["go"].Calls, verb) {
|
|
t.Errorf("mesh-sdk's Go package calls %v, want %s among them", packages["go"].Calls, verb)
|
|
}
|
|
}
|
|
// Its named paths, so the indexer holds them and a change to them is a changed package (design 47 G A-285).
|
|
if l := packages["typescript"]; l.Name != "lib" || !slices.Equal(l.Paths, []string{"package.json", "package-lock.json", "tsconfig.json", "src"}) {
|
|
t.Errorf("mesh-sdk's TypeScript package is %+v, want lib built from package.json, package-lock.json, tsconfig.json and src", l)
|
|
}
|
|
|
|
// What a reader reads (novox/hq ADR 0614 §4): the baseline is the contract of mesh-sdk f02f142, which every running
|
|
// node-engine was built with, and this contract reads all of it; the words added since are the only ones it lacks.
|
|
reads, baseline := ManifestReads(), BaselineManifestReads()
|
|
var added []string
|
|
for _, r := range reads {
|
|
if !slices.Contains(baseline, r) {
|
|
added = append(added, r)
|
|
}
|
|
}
|
|
// The two seats the milestone renamed (ADR 0634 §9) are read by their new names; a node-engine built with the baseline
|
|
// reads the old ones, and a manifest of the new names is the milestone's to deliver after the engines. The word
|
|
// `waits` is no longer read: novox/hq ADR 0670 §2 retired it.
|
|
renamed := []string{"seat:mesh-enrolment", "seat:mesh-placement", "word:waits"}
|
|
for _, b := range baseline {
|
|
if !slices.Contains(reads, b) && !slices.Contains(renamed, b) {
|
|
t.Errorf("the baseline's %s is no reader capability of this contract", b)
|
|
}
|
|
}
|
|
for _, want := range []string{"word:tool-runner", "word:core-credentials", "word:bus-state", "word:bus-state.storage",
|
|
// The reference form a registry seat answers (ADR 0605 §9), and the seats the registry milestone adds.
|
|
ReadForm + ReferenceFormSeat, ReadForm + ReferenceFormSeatReach, "seat:go-package-registry", "seat:container-image-registry", "seat:oci-artifact-registry"} {
|
|
if !slices.Contains(added, want) {
|
|
t.Errorf("%s is in the baseline, or not read: added since it are %v", want, added)
|
|
}
|
|
}
|
|
for _, want := range []string{"word:claims.serves", "word:settings.default", "form:config", "form:setting", "seat:mesh-catalog"} {
|
|
if !slices.Contains(baseline, want) {
|
|
t.Errorf("the baseline lacks %s", want)
|
|
}
|
|
}
|
|
if blocks := untaggedBlocks(); len(blocks) != 0 {
|
|
t.Errorf("blocks whose words are their Go names, no decoder's keys: %v (name their keys in wireKeys)", blocks)
|
|
}
|
|
// What a manifest's own words, forms and seat names need, beyond the baseline.
|
|
for _, row := range []struct {
|
|
why, raw string
|
|
needs []string // among its needs
|
|
missing []string // what the baseline lacks of them
|
|
}{
|
|
{"a tool runner", `{"module":"r","version":"1","tool-runner":true}`, []string{"word:tool-runner"}, []string{"word:tool-runner"}},
|
|
{"a manifest of the baseline's words", `{"module":"a","version":"1","claims":[{"name":"mesh-catalog","scope":"mesh",` +
|
|
`"serves":["modules"]}],"invokes":["seat:mesh-delivery.show"],"config":{"x":{"type":"string","default":""}},` +
|
|
`"resources":[{"id":"f","type":"file","content":"${config:x} ${count:-0}"}],"provides":["plain",{"name":"p",` +
|
|
`"identity":{"max":20,"in":"x"}}]}`,
|
|
[]string{"word:claims.serves", "word:settings.type", "form:config", "seat:mesh-catalog", "seat:mesh-delivery",
|
|
"word:provides.identity.max", "word:resources"}, nil},
|
|
{"a bus-state entry of requires", `{"module":"b","version":"1","requires":["mesh-bus",{"name":"jobs","storage":"kv"}]}`,
|
|
[]string{"word:requires", "word:bus-state.storage"}, []string{"word:bus-state", "word:bus-state.name", "word:bus-state.storage"}},
|
|
// A seat's reach, filled from the seat holder's listen (ADR 0632 §1): an engine before it lacks the reading.
|
|
{"a seat's reach", `{"module":"s","version":"1","resources":[{"id":"f","type":"file","content":"${seat:container-image-registry:reach}"}]}`,
|
|
[]string{"form:seat", "form:seat-reach"}, []string{"form:seat-reach"}},
|
|
// The store holder's manifest, distribution's as ADR 0632 leaves it: no reach written, no provision served; an engine
|
|
// stating only the baseline lacks the reading that finds the store by it (ADR 0632 §2).
|
|
{"the store's holder", `{"module":"distribution","version":"1","claims":[{"name":"container-image-registry",` +
|
|
`"scope":"mesh","serves":["list"]}],"listens":[{"name":"registry","port":5000,"from":"mesh"}]}`,
|
|
[]string{"form:seat-reach", "seat:container-image-registry"}, []string{"form:seat-reach", "seat:container-image-registry"}},
|
|
// docker's daemon file as ADR 0632 leaves it: the manifest unchanged, its template naming the image seat's reach;
|
|
// TemplatePaths names the template a reader of the files reads.
|
|
{"a template naming a seat's reach", `{"module":"d","version":"1","resources":[{"id":"daemon","type":"file",` +
|
|
`"path":"/etc/d.json","template":"files/daemon.json"}]}`, []string{"form:seat", "form:seat-reach"},
|
|
[]string{"form:seat-reach"}},
|
|
// A resource under a config condition (design 42 zfs-owns-zfs §4, A-13).
|
|
{"a resource under if-config", `{"module":"z","version":"1","config":{"k":{"type":"string"}},"resources":[{"id":"f","type":"file",` +
|
|
`"if-config":["k"]}]}`, []string{"word:resources.if-config"}, []string{"word:resources.if-config"}},
|
|
{"a resource without if-config", `{"module":"z","version":"1","resources":[{"id":"f","type":"file"}]}`,
|
|
[]string{"word:resources"}, nil},
|
|
// The template forms of the config file and the option lines (design 42 zfs-owns-zfs §3, §9; A-13, A-15, A-25).
|
|
{"a template writing config lines", `{"module":"z","version":"1","resources":[{"id":"f","type":"file","template":"files/o.conf"}]}`,
|
|
[]string{"form:config-lines"}, []string{"form:config-lines"}},
|
|
{"a template writing the config as json", `{"module":"z","version":"1","resources":[{"id":"f","type":"file","template":"files/c.json"}]}`,
|
|
[]string{"form:config-json"}, []string{"form:config-json"}},
|
|
{"a template of the config form alone", `{"module":"z","version":"1","resources":[{"id":"f","type":"file","template":"files/k"}]}`,
|
|
[]string{"form:config"}, nil},
|
|
{"a word this contract does not know", `{"module":"u","version":"1","newer-word":{"inside":1}}`, []string{"word:module"}, nil},
|
|
} {
|
|
templates := map[string]map[string]string{ // the templates' text a row's module names
|
|
"a template naming a seat's reach": {"files/daemon.json": `{"x":"${seat:container-image-registry:reach}"}`},
|
|
"a template writing config lines": {"files/o.conf": "${config-lines:arc-max:options zfs zfs_arc_max=:mib-bytes}"},
|
|
"a template writing the config as json": {"files/c.json": "${config-json}"},
|
|
"a template of the config form alone": {"files/k": "${config:k}"},
|
|
}[row.why]
|
|
needs, err := ModuleNeeds([]byte(row.raw), templates)
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", row.why, err)
|
|
}
|
|
if templates != nil {
|
|
m, err := Decode([]byte(row.raw))
|
|
if paths := TemplatePaths(m); err != nil || !slices.Equal(paths, slices.Sorted(maps.Keys(templates))) {
|
|
t.Errorf("%s: TemplatePaths = %v (%v), want %v", row.why, paths, err, slices.Sorted(maps.Keys(templates)))
|
|
}
|
|
}
|
|
for _, n := range row.needs {
|
|
if !slices.Contains(needs, n) {
|
|
t.Errorf("%s: needs %v, not %s", row.why, needs, n)
|
|
}
|
|
}
|
|
if slices.ContainsFunc(needs, func(n string) bool { return n == "word:newer-word" || n == "form:count" }) {
|
|
t.Errorf("%s: needs %v, naming what the contract does not read", row.why, needs)
|
|
}
|
|
for _, f := range []string{"form:config-lines", "form:config-json"} {
|
|
if slices.Contains(needs, f) != (row.why == map[string]string{"form:config-lines": "a template writing config lines",
|
|
"form:config-json": "a template writing the config as json"}[f]) {
|
|
t.Errorf("%s: needs %v, %s read wrongly", row.why, needs, f)
|
|
}
|
|
}
|
|
if slices.Contains(needs, "word:resources.if-config") != (row.why == "a resource under if-config") {
|
|
t.Errorf("%s: needs %v, if-config read wrongly", row.why, needs)
|
|
}
|
|
if got := MissingManifestReads(needs, nil); !slices.Equal(got, row.missing) {
|
|
t.Errorf("%s: an engine stating nothing lacks %v, want %v", row.why, got, row.missing)
|
|
}
|
|
if got := MissingManifestReads(needs, reads); len(got) != 0 {
|
|
t.Errorf("%s: this contract lacks %v", row.why, got)
|
|
}
|
|
}
|
|
if got := MissingManifestReads([]string{"seat:mesh-catalog", "word:module"}, []string{"word:module"}); !slices.Equal(got, []string{"seat:mesh-catalog"}) {
|
|
t.Errorf("an engine stating its own reads is read by them alone: lacks %v", got)
|
|
}
|
|
}
|