Files
mesh-catalog/modules/claude-licence-manager/cmd/manager/manifest_test.go
T
jschoubben b1da6344a8 Join 11: merge origin/main (the licence manager in parts, issue 1409)
The conflict in the old cmd/claude-licence-manager/tools_test.go resolves to both sides: main
moved it to cmd/manager, and the join's count of binding.changed.<consumer> under its family
goes into the moved TestResyncSaysEachOnce. The whole-module test's runtime refused
binding.changed.<consumer> because the manifest names the family binding.changed: it now
accepts a key that extends a named family by further parts, as A-134 says the event.

Builds: design 47 G A-134

Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
2026-11-12 14:05:51 +01:00

394 lines
13 KiB
Go

package main
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"regexp"
"slices"
"sort"
"strings"
"testing"
. "claude-licence-manager/internal/licences"
)
// design 39 bus-and-switch §1: the module moves to the new form whole — no `reads`, no old `state`, no `prepare`
// step — and asks for each state it keeps by template; its two logs are in the `logs` section with their bounds, the
// form the runtime on main issues (C3).
func TestTheManifestKeepsNoOldForm(t *testing.T) {
raw, err := os.ReadFile(filepath.Join(moduleDir, "module.json"))
if err != nil {
t.Fatal(err)
}
var m map[string]json.RawMessage
if err := json.Unmarshal(raw, &m); err != nil {
t.Fatal(err)
}
for _, old := range []string{"reads", "state"} {
if _, ok := m[old]; ok {
t.Errorf("the manifest keeps the old section %q", old)
}
}
var resources []struct {
ID string `json:"id"`
}
_ = json.Unmarshal(m["resources"], &resources)
for _, r := range resources {
if r.ID == "prepare" {
t.Error("the manifest keeps the run-once step prepare")
}
}
var requires []json.RawMessage
_ = json.Unmarshal(m["requires"], &requires)
kept := map[string]string{}
for _, r := range requires {
var e struct{ Name, Template string }
if json.Unmarshal(r, &e) == nil {
kept[e.Name] = e.Template
}
}
for name, template := range map[string]string{"licences": "state", "bindings": "state", "leases": "state",
"offered": "state", "usage": "", "audit": "", "carried": "state", "conditions": "state"} {
if kept[name] != template {
t.Errorf("bus-state entry %s is %q in requires, want %q", name, kept[name], template)
}
}
var logs []json.RawMessage
_ = json.Unmarshal(m["logs"], &logs)
declared := logsSection(logs)
for name, bounds := range map[string]map[string]float64{"usage": {"max-age-days": 35, "max-mib": 256},
"audit": {"max-mib": 64}} {
l, ok := declared[name]
if !ok {
t.Errorf("the log %s is not in the logs section", name)
continue
}
for k, v := range bounds {
if l[k] != v {
t.Errorf("the log %s has %s %v, want %v", name, k, l[k], v)
}
}
}
}
// issued is what the manager's own runtime is issued from its manifest (design 39 bus-and-switch C1): its account, the
// states it keeps (`requires` by template), the logs it keeps (the `logs` section, the form the runtime on main issues,
// C3; a log asked for by template in `requires` is issued nothing), what it may ask (`invokes`) and say (`emits`).
type issued struct {
RunsAs, SecretsOwner string
OwnSecrets map[string]string
Resources []map[string]any
States, Logs map[string]bool
Invokes, Emits map[string]bool
}
func manifestIssued(t testing.TB) issued {
t.Helper()
raw, err := os.ReadFile(filepath.Join(moduleDir, "module.json"))
if err != nil {
t.Fatal(err)
}
var m struct {
RunsAs string `json:"runs-as"`
SecretsOwner string `json:"secrets-owner"`
OwnSecrets map[string]string `json:"own-secrets"`
Requires []json.RawMessage `json:"requires"`
Logs []json.RawMessage `json:"logs"`
Resources []map[string]any `json:"resources"`
Invokes []string `json:"invokes"`
Emits []string `json:"emits"`
}
if err := json.Unmarshal(raw, &m); err != nil {
t.Fatal(err)
}
out := issued{RunsAs: m.RunsAs, SecretsOwner: m.SecretsOwner, OwnSecrets: m.OwnSecrets, Resources: m.Resources,
States: map[string]bool{}, Logs: map[string]bool{}, Invokes: map[string]bool{}, Emits: map[string]bool{}}
for _, r := range m.Requires {
var e struct{ Name, Storage string }
if json.Unmarshal(r, &e) != nil {
continue
}
if e.Storage == "key-value" {
out.States[e.Name] = true
}
}
for name := range logsSection(m.Logs) {
out.Logs[name] = true
}
for _, k := range m.Invokes {
out.Invokes[k] = true
}
for _, e := range m.Emits {
out.Emits[e] = true
}
return out
}
// logsSection is the manifest's `logs` section by name: each a name alone or {name, max-age-days, max-mib}.
func logsSection(logs []json.RawMessage) map[string]map[string]any {
out := map[string]map[string]any{}
for _, l := range logs {
var name string
if json.Unmarshal(l, &name) == nil {
out[name] = map[string]any{}
continue
}
var e map[string]any
if json.Unmarshal(l, &e) == nil {
if n, _ := e["name"].(string); n != "" {
out[n] = e
}
}
}
return out
}
// mayAsk is whether the manager's own account may ask key: a module tool asked on one node (`<module>.<tool>@<node>`)
// is invoked as `<module>.<tool>`.
// emits is whether the manifest names the event key's family: the key itself, or a family it extends by further parts,
// as binding.changed.<consumer> extends binding.changed (design 47 G A-134).
func (i issued) emits(key string) bool {
for k := key; k != ""; {
if i.Emits[k] {
return true
}
dot := strings.LastIndex(k, ".")
if dot < 0 {
break
}
k = k[:dot]
}
return false
}
func (i issued) mayAsk(key string) bool {
k, _, _ := strings.Cut(key, "@")
return i.Invokes[k]
}
// design 39 bus-and-switch C1: the manager runs as an account of its own, which it makes and which owns what it places
// on its machine and its secrets, reaching the bus as itself; and that account is issued every ask its code makes,
// since its runtime is not the machine's tool runner.
func TestTheManagerRunsAsItsOwnAccount(t *testing.T) {
m := manifestIssued(t)
if m.RunsAs != Publisher {
t.Fatalf("the manager runs as %q, not as its own account %s", m.RunsAs, Publisher)
}
if m.SecretsOwner != Publisher || m.OwnSecrets["broker"] == "" {
t.Errorf("its secrets belong to %q and its own broker secret is %q: both are its account's", m.SecretsOwner,
m.OwnSecrets["broker"])
}
made := false
for _, r := range m.Resources {
switch r["type"] {
case "user":
made = made || r["name"] == Publisher
case "directory", "file":
if r["owner"] != Publisher {
t.Errorf("resource %v is owned by %v, not by the manager's account", r["id"], r["owner"])
}
}
}
if !made {
t.Errorf("the manager does not make its account: no user resource named %s", Publisher)
}
files, _ := filepath.Glob("../*/*.go")
shared, _ := filepath.Glob("../../internal/*/*.go")
files = append(files, shared...)
asked := regexp.MustCompile(`stdio\.Ask\("([^"]+)"`)
for _, f := range files {
if strings.HasSuffix(f, "_test.go") {
continue
}
src, err := os.ReadFile(f)
if err != nil {
t.Fatal(err)
}
for _, k := range asked.FindAllStringSubmatch(string(src), -1) {
if !m.mayAsk(k[1]) {
t.Errorf("%s asks %s, which the manifest's invokes do not name", f, k[1])
}
}
}
}
// design 39 parts §9, §10: the carry-over has left the module whole. Its manifest requires neither the store database
// nor the secret grant-key, contributes and binds nothing and has no secrets section; no word of its code names the
// database's address or grant.key; its go.mod requires no postgres driver; the tool licences_carried is gone, and the
// state carried stays as the carry-over's record.
func TestTheCarryOverHasLeft(t *testing.T) {
raw, err := os.ReadFile(filepath.Join(moduleDir, "module.json"))
if err != nil {
t.Fatal(err)
}
var m map[string]json.RawMessage
if err := json.Unmarshal(raw, &m); err != nil {
t.Fatal(err)
}
for _, gone := range []string{"contributes", "binds", "secrets"} {
if _, ok := m[gone]; ok {
t.Errorf("the manifest keeps %q", gone)
}
}
var requires []json.RawMessage
_ = json.Unmarshal(m["requires"], &requires)
carried := false
for _, r := range requires {
var bare string
if json.Unmarshal(r, &bare) == nil {
t.Errorf("the manifest requires %q", bare)
}
var e struct{ Name string }
if json.Unmarshal(r, &e) == nil && e.Name == "carried" {
carried = true
}
}
if !carried {
t.Error("the state carried, the carry-over's record, is gone")
}
var tools []string
_ = json.Unmarshal(m["tools"], &tools)
if slices.Contains(tools, "licences_carried") {
t.Error("the manifest keeps the tool licences_carried")
}
var resources []struct{ ID string }
_ = json.Unmarshal(m["resources"], &resources)
for _, r := range resources {
if r.ID == "database-url" {
t.Error("the manifest keeps the resource database-url")
}
}
words := []string{"DATABASE_URL" + "_FILE", "MESH_LICENCE_KEY" + "_FILE"}
err = filepath.WalkDir(moduleDir, func(path string, d os.DirEntry, err error) error {
if err != nil || d.IsDir() {
return err
}
switch filepath.Ext(path) {
case ".go", ".json", ".mod", ".sum":
default:
if filepath.Base(filepath.Dir(path)) != "files" {
return nil // a built binary is no code of the module
}
}
src, err := os.ReadFile(path)
if err != nil {
return err
}
for _, w := range words {
if strings.Contains(string(src), w) {
t.Errorf("%s names %s", path, w)
}
}
if filepath.Base(path) == "go.mod" && strings.Contains(string(src), "github.com/jackc/pgx") {
t.Errorf("%s requires the postgres driver", path)
}
return nil
})
if err != nil {
t.Fatal(err)
}
}
// design 39 parts §1 to §4, §6 to §8: the module is four parts in one manifest. Its artifacts are exactly the manager
// bundle, the tools bundle and the templates archive, with their words; its resources exactly the account, its
// directory and the settings file, in that order; no process or container resource, no run-once step, no bus account
// of its own and no runtime-health; its tools are the four reading ones and the three acting ones; files/ holds only
// the settings template.
func TestTheModuleIsFourParts(t *testing.T) {
raw, err := os.ReadFile(filepath.Join(moduleDir, "module.json"))
if err != nil {
t.Fatal(err)
}
var m map[string]any
if err := json.Unmarshal(raw, &m); err != nil {
t.Fatal(err)
}
same := func(what string, got, want any) {
t.Helper()
g, _ := json.Marshal(got)
w, _ := json.Marshal(want)
if string(g) != string(w) {
t.Errorf("%s is %s, want %s", what, g, w)
}
}
build, _ := m["build"].(map[string]any)
same("build.artifacts", build["artifacts"], []map[string]any{
{"name": "manager", "kind": "bundle", "language": "go", "system": "arch", "from": "cmd/manager",
"binary": "claude-licence-manager", "loads": []string{"claude-licence-manager"},
"env": map[string]string{"MESH_LICENCE_STATE": "${dir:state}", "MESH_LICENCE_SETTINGS": "${dir:state}/settings.json"}},
{"name": "tools", "kind": "bundle", "language": "go", "system": "arch", "from": "cmd/tools",
"binary": "claude-licence-manager-tools", "loads": []string{"claude-licence-manager-tools"}},
{"name": "files", "kind": "archive", "from": "files"},
})
same("resources", m["resources"], []map[string]any{
{"id": "account", "type": "user", "name": Publisher, "shell": "/usr/bin/nologin", "home": "/var/lib/" + Publisher},
{"id": "state", "type": "directory", "mode": "0700", "owner": Publisher, "place": ".", "unknown": "program"},
{"id": "settings", "type": "file", "path": "${dir:state}/settings.json", "mode": "0600", "owner": Publisher,
"takes-config": []string{"cadence_minutes", "floor_minutes", "failures_to_notify", "cooldown_hours",
"refresh_warn_days", "switch_auto", "switch_at_pct", "room_below_pct", "warn_at_pct", "usage_minutes",
"usage_stale_minutes"}, "merge": "json", "template": "files/settings.json"},
})
tools, _ := m["tools"].([]any)
var names []string
for _, n := range tools {
names = append(names, fmt.Sprint(n))
}
sort.Strings(names)
same("tools", names, []string{"licences_conditions", "licences_kept", "licences_read_usage", "licences_resync",
"licences_settings", "licences_switch_now", "licences_switches"})
same("runs-as", m["runs-as"], Publisher)
same("secrets-owner", m["secrets-owner"], Publisher)
same("own-secrets", m["own-secrets"], map[string]string{"broker": "${dir:state}/broker"})
if _, ok := m["runtime-health"]; ok {
t.Error("the manifest adds runtime-health: the node-engine's judgement that the runtime is alive is its health")
}
var walk func(path string, v any)
walk = func(path string, v any) {
switch v := v.(type) {
case map[string]any:
for k, e := range v {
if k == "bus" || k == "run-once" {
t.Errorf("the manifest says %s at %s", k, path)
}
if k == "type" && (e == "process" || e == "container") {
t.Errorf("the manifest has a %v resource at %s", e, path)
}
walk(path+"."+k, e)
}
case []any:
for i, e := range v {
walk(fmt.Sprintf("%s[%d]", path, i), e)
}
}
}
walk("", m)
files, _ := os.ReadDir(filepath.Join(moduleDir, "files"))
var templates []string
for _, f := range files {
templates = append(templates, f.Name())
}
same("files/", templates, []string{"settings.json"})
}
// design 39 parts §2, §4: the manager bundle registers the seat's ten verbs under the seat and the three acting tools
// under the module, and nothing more.
func TestTheManagerRegistersTheVerbsAndTheActs(t *testing.T) {
var names []string
for _, tool := range tools() {
names = append(names, tool.Name)
}
sort.Strings(names)
var want []string
for _, v := range []string{"licences", "bindings", "bind", "switch", "release", "refresh", "usage", "adopt",
"current", "public-key"} {
want = append(want, Seat+"."+v)
}
want = append(want, "licences_read_usage", "licences_resync", "licences_switch_now")
sort.Strings(want)
if !slices.Equal(names, want) {
t.Fatalf("the manager bundle registers %v, not %v", names, want)
}
}