mesh-sdk/go/catalogue/no_subjects_test.go

package catalogue

import (
	"encoding/json"
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"testing"

	"git.novox.be/novox/mesh-sdk/go/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
}