jschoubben
eb72075104
Tests that read ../../../mesh-catalog or ../../../mesh-host gave a verdict that depended on what sat beside the checkout: a stale or dirty sibling failed them on a desktop, and a missing one skipped them unseen. They now read the clone the build seat puts in MESH_CHECK_BESIDE, failing when it is absent there, and elsewhere a copy captured at a named commit. The skip had hidden that the builder test read a module retired by ADR 0190. The systemd reading test no longer counts the machine's own environment.d.
125 lines
3.5 KiB
Go
125 lines
3.5 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/novox/mesh-controller/internal/beside"
|
|
)
|
|
|
|
// **A manifest holds no subject** (novox/hq design 29 §1).
|
|
//
|
|
// A module names its events, tools and seats locally, and the mesh derives where they land. The
|
|
// property that buys: reorganise the subject space and every manifest in the catalogue is still
|
|
// correct. It holds today by construction — nothing reads a subject from a manifest — and a rule
|
|
// held by construction is one a later field breaks quietly, with the symptom appearing as a
|
|
// permission that does not match a subject rather than as a manifest that was wrong.
|
|
func TestNoManifestContainsASubject(t *testing.T) {
|
|
root := beside.Catalogue(t)
|
|
entries, err := os.ReadDir(root)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Anything in the mesh's own subject space, and anything shaped like a wire address.
|
|
subject := regexp.MustCompile(`^(mesh|\$JS)\.[a-zA-Z0-9_*>.-]+$`)
|
|
|
|
var found []string
|
|
var walk func(module string, path string, v any)
|
|
walk = func(module, path string, v any) {
|
|
switch t := v.(type) {
|
|
case string:
|
|
if subject.MatchString(t) {
|
|
found = append(found, module+" "+path+" = "+t)
|
|
}
|
|
case map[string]any:
|
|
for k, inner := range t {
|
|
walk(module, path+"."+k, inner)
|
|
}
|
|
case []any:
|
|
for _, inner := range t {
|
|
walk(module, path+"[]", inner)
|
|
}
|
|
}
|
|
}
|
|
|
|
checked := 0
|
|
for _, e := range entries {
|
|
if !e.IsDir() {
|
|
continue
|
|
}
|
|
raw, err := os.ReadFile(filepath.Join(root, e.Name(), "module.json"))
|
|
if err != nil {
|
|
continue
|
|
}
|
|
var m any
|
|
if err := json.Unmarshal(raw, &m); err != nil {
|
|
t.Errorf("%s: %v", e.Name(), err)
|
|
continue
|
|
}
|
|
checked++
|
|
walk(e.Name(), "", m)
|
|
}
|
|
if checked == 0 {
|
|
t.Fatal("no manifests read, so this proved nothing")
|
|
}
|
|
if len(found) > 0 {
|
|
t.Errorf("a manifest names a subject, so reorganising the subject space would mean "+
|
|
"editing the catalogue:\n %s", strings.Join(found, "\n "))
|
|
}
|
|
t.Logf("%d manifests hold no subject", checked)
|
|
}
|
|
|
|
// **Every module's event names are what design 29 says, across the whole catalogue.**
|
|
//
|
|
// The rule above holds by construction and turned out to be weaker than it reads: a manifest holds
|
|
// no subject, and every manifest in the catalogue still held the old bus's routing key, which
|
|
// derives into a namespace nobody owns (novox/hq 04-ISSUES/127). Nothing failed — the services
|
|
// started and none of them reacted. This is the check that was missing.
|
|
func TestEveryManifestsEventNamesAreLocal(t *testing.T) {
|
|
manifests := theCatalogue(t)
|
|
|
|
var problems []string
|
|
for _, m := range manifests {
|
|
problems = append(problems, EventProblems(m)...)
|
|
}
|
|
if len(problems) > 0 {
|
|
t.Fatalf("the catalogue holds %d event name(s) the mesh would derive wrongly:\n %s",
|
|
len(problems), strings.Join(problems, "\n "))
|
|
}
|
|
}
|
|
|
|
// theCatalogue is every manifest of the catalogue internal/beside finds, parsed the way registration
|
|
// parses one.
|
|
func theCatalogue(t *testing.T) []Manifest {
|
|
t.Helper()
|
|
root := beside.Catalogue(t)
|
|
entries, err := os.ReadDir(root)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var out []Manifest
|
|
for _, e := range entries {
|
|
if !e.IsDir() {
|
|
continue
|
|
}
|
|
raw, err := os.ReadFile(filepath.Join(root, e.Name(), "module.json"))
|
|
if err != nil {
|
|
continue
|
|
}
|
|
var m Manifest
|
|
if err := json.Unmarshal(raw, &m); err != nil {
|
|
t.Fatalf("%s: %v", e.Name(), err)
|
|
}
|
|
out = append(out, m)
|
|
}
|
|
if len(out) == 0 {
|
|
t.Fatalf("no manifests under %s, so this proved nothing", root)
|
|
}
|
|
return out
|
|
}
|