Read each module's own manifest through mesh-sdk's catalogue reader (H-A-498)

The fifteen desktop modules' tools tests failed on every manifest with
"json: unknown field class": a test helper copied into each module decoded
module.json into its own struct, refusing unknown fields. Manifest
strictness is the catalog check's alone, and the manifest's form is a
contract read through mesh-sdk's catalogue package, so the copied
`manifest` struct and its reader go from the fifteen desktop modules and
pacman; each test reads module.json with catalogue.Decode and asserts only
the module's own promises (claims, files, tools) on catalogue.Manifest.

Builds: design 47 H2 H-A-498, H-A-498 addendum
This commit is contained in:
2026-11-22 21:32:03 +01:00
parent bf972d1d34
commit a3db292b8d
31 changed files with 1205 additions and 1207 deletions
@@ -9,6 +9,8 @@ import (
"strings"
"testing"
"time"
"git.novox.be/novox/mesh-sdk/go/catalogue"
)
const nobody = 4194400
@@ -185,8 +187,16 @@ func TestAnInhibitionTurnsIdleOffAndRestoresWhatWasThereWhenItEndsOrIsStopped(t
}
func TestTheDeclaredTimeoutsAreTheSessionStartsOwn(t *testing.T) {
m := readManifest(t)
code := m.shell(t)[0].Code
manifestJSON, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
if err != nil {
t.Fatal(err)
}
// manifest strictness is the catalog check's (H-A-498): the SDK's reader sets an unknown field aside.
m, err := catalogue.Decode(manifestJSON)
if err != nil {
t.Fatalf("module.json: %v", err)
}
code := shell(t, m)[0].Code
if !strings.Contains(code, "xset s "+strconv.Itoa(declaredLock)+" "+strconv.Itoa(declaredLock)+"\n") ||
!strings.Contains(code, "xset dpms "+strconv.Itoa(declaredStandby)+" "+strconv.Itoa(declaredSuspend)+" "+strconv.Itoa(declaredOff)+"\n") {
t.Fatalf("the tools' declared values and the session start's disagree:\n%s", code)
@@ -1,64 +1,19 @@
package main
import (
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
"git.novox.be/novox/mesh-sdk/go/catalogue"
)
// The module's manifest, read the way the catalogue reads it, for the manifest tests. The same in
// every desktop module that carries it.
type manifest struct {
Module string `json:"module"`
Version string `json:"version"`
Moved bool `json:"moved"`
Items []item `json:"items"`
Capabilities []string `json:"capabilities"`
Requires []string `json:"requires"`
Claims []claim `json:"claims"`
Seats []any `json:"seats"`
Tools []string `json:"tools"`
Environment *environment `json:"environment"`
Shell []shellCode `json:"shell"`
Resources []map[string]any `json:"resources"`
Build struct {
Artifacts []map[string]any `json:"artifacts"`
} `json:"build"`
}
type claim struct {
Name string `json:"name"`
Scope string `json:"scope"`
Serves []string `json:"serves"`
}
type environment struct {
Variables map[string]string `json:"variables"`
Path []map[string]any `json:"path"`
}
type shellCode struct {
For string `json:"for"`
Slot string `json:"slot"`
Code string `json:"code"`
}
// An item of a collection (novox/hq ADR 0349 clause 13): its text is the template file beside the manifest.
type item struct {
Collection string `json:"collection"`
Name string `json:"name"`
Attributes map[string]string `json:"attributes"`
Template string `json:"template"`
}
// shell is the code the module adds to a shell's or the session's start, read from the templates of its items of
// the collections shell:<file>:<slot>, in the order they are declared.
func (m manifest) shell(t *testing.T) []shellCode {
func shell(t *testing.T, m catalogue.Manifest) []catalogue.ShellCode {
t.Helper()
var out []shellCode
var out []catalogue.ShellCode
for _, it := range m.Items {
parts := strings.Split(it.Collection, ":")
if len(parts) != 3 || parts[0] != "shell" {
@@ -68,15 +23,15 @@ func (m manifest) shell(t *testing.T) []shellCode {
if err != nil {
t.Fatal(err)
}
out = append(out, shellCode{For: parts[1], Slot: parts[2], Code: string(text)})
out = append(out, catalogue.ShellCode{For: parts[1], Slot: parts[2], Code: string(text)})
}
return out
}
// environmentOf is the variables the module sets, read from the templates of its items of the environment.
func (m manifest) environmentOf(t *testing.T) *environment {
func environmentOf(t *testing.T, m catalogue.Manifest) *catalogue.Environment {
t.Helper()
var env *environment
var env *catalogue.Environment
for _, it := range m.Items {
if it.Collection != "environment" || it.Attributes["kind"] != "variable" {
continue
@@ -86,30 +41,14 @@ func (m manifest) environmentOf(t *testing.T) *environment {
t.Fatal(err)
}
if env == nil {
env = &environment{Variables: map[string]string{}}
env = &catalogue.Environment{Variables: map[string]string{}}
}
env.Variables[it.Attributes["name"]] = strings.TrimSuffix(string(text), "\n")
}
return env
}
func readManifest(t *testing.T) manifest {
t.Helper()
raw, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
if err != nil {
t.Fatal(err)
}
dec := json.NewDecoder(strings.NewReader(string(raw)))
dec.DisallowUnknownFields()
var m manifest
if err := dec.Decode(&m); err != nil {
t.Fatalf("module.json: %v", err)
}
m.Environment = m.environmentOf(t)
return m
}
func (m manifest) resource(t *testing.T, id string) map[string]any {
func resource(t *testing.T, m catalogue.Manifest, id string) map[string]any {
t.Helper()
for _, r := range m.Resources {
if r["id"] == id {
@@ -120,7 +59,7 @@ func (m manifest) resource(t *testing.T, id string) map[string]any {
return nil
}
func (m manifest) packages() (present, absent []string) {
func packages(m catalogue.Manifest) (present, absent []string) {
for _, r := range m.Resources {
if r["type"] == "package" {
if r["absent"] == true {
@@ -136,9 +75,9 @@ func (m manifest) packages() (present, absent []string) {
// fromTemplate checks that a file resource takes its text from its template file in the module's
// repository (novox/hq ADR 0349 §2): it names the template, carries no text of its own beside it, and the
// template is there. The readable file in the repository is the one place the machine's text is written.
func (m manifest) fromTemplate(t *testing.T, id, template string) {
func fromTemplate(t *testing.T, m catalogue.Manifest, id, template string) {
t.Helper()
r := m.resource(t, id)
r := resource(t, m, id)
if r["type"] != "file" {
t.Fatalf("%s is a %v, not a file", id, r["type"])
}
@@ -158,7 +97,7 @@ func (m manifest) fromTemplate(t *testing.T, id, template string) {
// everyFileIsATemplate checks that no file resource carries its text inline, and that the build packs
// files/ into the one archive the controller reads the templates back from (novox/hq ADR 0349 §2).
func (m manifest) everyFileIsATemplate(t *testing.T) {
func everyFileIsATemplate(t *testing.T, m catalogue.Manifest) {
t.Helper()
for _, r := range m.Resources {
if _, inline := r["content"]; inline {
@@ -167,10 +106,10 @@ func (m manifest) everyFileIsATemplate(t *testing.T) {
}
packs := 0
for _, a := range m.Build.Artifacts {
if a["kind"] == "archive" && a["from"] == "files" {
if a.Kind == "archive" && a.From == "files" {
packs++
if a["name"] != "files" {
t.Errorf("the templates archive is named %v, not files", a["name"])
if a.Name != "files" {
t.Errorf("the templates archive is named %v, not files", a.Name)
}
}
}
@@ -180,9 +119,9 @@ func (m manifest) everyFileIsATemplate(t *testing.T) {
}
// text is the text a file resource places on the machine: its template file's.
func (m manifest) text(t *testing.T, id string) string {
func templateText(t *testing.T, m catalogue.Manifest, id string) string {
t.Helper()
name, _ := m.resource(t, id)["template"].(string)
name, _ := resource(t, m, id)["template"].(string)
if name == "" {
t.Fatalf("resource %s names no template", id)
}
@@ -195,7 +134,7 @@ func (m manifest) text(t *testing.T, id string) string {
// checkTheToolsAgree checks that the manifest lists the module's own tools exactly, that the bundle
// serves each seat verb the claims promise as <seat>.<verb>, and that the Go bundle is declared.
func checkTheToolsAgree(t *testing.T, m manifest) {
func checkTheToolsAgree(t *testing.T, m catalogue.Manifest) {
t.Helper()
own, seat := map[string]bool{}, map[string]bool{}
for _, tool := range tools() {
@@ -237,14 +176,14 @@ func checkTheToolsAgree(t *testing.T, m manifest) {
t.Errorf("the bundle serves %s, which no claim promises", name)
}
}
var bundle map[string]any
var bundle *catalogue.Artifact
for _, a := range m.Build.Artifacts {
if a["kind"] == "bundle" {
bundle = a
if a.Kind == "bundle" {
bundle = &a
}
}
if bundle == nil || bundle["language"] != "go" || bundle["system"] != "arch" ||
bundle["from"] != "cmd/"+m.Module+"-tools" || bundle["binary"] != m.Module+"-tools" {
if bundle == nil || bundle.Language != "go" || bundle.System != "arch" ||
bundle.From != "cmd/"+m.Module+"-tools" || bundle.Binary != m.Module+"-tools" {
t.Errorf("the Go tools bundle: %v", bundle)
}
}
@@ -1,9 +1,13 @@
package main
import (
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"git.novox.be/novox/mesh-sdk/go/catalogue"
)
// screen-lock's shape (novox/hq ADR 0208, research 026/04): it claims node-lock-screen serving lock,
@@ -12,11 +16,19 @@ import (
// the timeouts once, from the session's start. The lock key is the window manager's.
func TestItClaimsTheLockScreenSeatServingLockAndRequiresTheXDisplay(t *testing.T) {
m := readManifest(t)
if m.Module != "screen-lock" || m.Seats != nil {
t.Fatalf("module %q declares seats %v", m.Module, m.Seats)
manifestJSON, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(m.Claims, []claim{{Name: "node-lock-screen", Scope: "node", Serves: []string{"lock"}}}) {
// manifest strictness is the catalog check's (H-A-498): the SDK's reader sets an unknown field aside.
m, err := catalogue.Decode(manifestJSON)
if err != nil {
t.Fatalf("module.json: %v", err)
}
if m.Module != "screen-lock" || m.DefinesSeats != nil {
t.Fatalf("module %q declares seats %v", m.Module, m.DefinesSeats)
}
if !reflect.DeepEqual(m.Claims, []catalogue.Claim{{Name: "node-lock-screen", Scope: "node", Serves: []string{"lock"}}}) {
t.Fatalf("claims: %+v", m.Claims)
}
if !reflect.DeepEqual(m.Requires, []string{"x11-display"}) {
@@ -25,17 +37,25 @@ func TestItClaimsTheLockScreenSeatServingLockAndRequiresTheXDisplay(t *testing.T
}
func TestTheColourBuildIsKeptWithAFallbackAndXscreensaverGoes(t *testing.T) {
m := readManifest(t)
present, absent := m.packages()
manifestJSON, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
if err != nil {
t.Fatal(err)
}
// manifest strictness is the catalog check's (H-A-498): the SDK's reader sets an unknown field aside.
m, err := catalogue.Decode(manifestJSON)
if err != nil {
t.Fatalf("module.json: %v", err)
}
present, absent := packages(m)
if !reflect.DeepEqual(present, []string{"xss-lock", "i3lock"}) || !reflect.DeepEqual(absent, []string{"xscreensaver"}) {
t.Fatalf("packages: %v, absent %v", present, absent)
}
m.fromTemplate(t, "wrapper", "files/bin/screen-lock")
wrapper := m.resource(t, "wrapper")
fromTemplate(t, m, "wrapper", "files/bin/screen-lock")
wrapper := resource(t, m, "wrapper")
if wrapper["mode"] != "0755" || wrapper["path"] != "${machine:account-home}/.local/bin/screen-lock" {
t.Fatalf("the locker: %v", wrapper)
}
c := m.text(t, "wrapper")
c := templateText(t, m, "wrapper")
// The colour build's options only once it has said it is the colour build: the distribution's
// i3lock refuses an option it does not know, and the screen would not lock at all.
check := strings.Index(c, `i3lock --version 2>&1 | grep -qE '[0-9]\.c\.[0-9]'`)
@@ -52,11 +72,19 @@ func TestTheColourBuildIsKeptWithAFallbackAndXscreensaverGoes(t *testing.T) {
}
func TestTheSessionStartSetsTheTimeoutsAndKeepsOneWatcherForTheSession(t *testing.T) {
m := readManifest(t)
if len(m.shell(t)) != 1 || m.shell(t)[0].For != "xinitrc" || m.shell(t)[0].Slot != "normal" {
t.Fatalf("one xinitrc contribution in normal: %+v", m.shell(t))
manifestJSON, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
if err != nil {
t.Fatal(err)
}
code := m.shell(t)[0].Code
// manifest strictness is the catalog check's (H-A-498): the SDK's reader sets an unknown field aside.
m, err := catalogue.Decode(manifestJSON)
if err != nil {
t.Fatalf("module.json: %v", err)
}
if len(shell(t, m)) != 1 || shell(t, m)[0].For != "xinitrc" || shell(t, m)[0].Slot != "normal" {
t.Fatalf("one xinitrc contribution in normal: %+v", shell(t, m))
}
code := shell(t, m)[0].Code
if strings.Count(code, "xss-lock --") != 1 || !strings.Contains(code, "--transfer-sleep-lock") ||
!strings.Contains(code, "while kill -0 $$") || !strings.HasSuffix(strings.TrimSpace(code), "&") {
t.Fatalf("the watcher: %q", code)
@@ -72,7 +100,15 @@ func TestTheSessionStartSetsTheTimeoutsAndKeepsOneWatcherForTheSession(t *testin
}
func TestTheLockKeyIsTheWindowManagersNotThisModules(t *testing.T) {
m := readManifest(t)
manifestJSON, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
if err != nil {
t.Fatal(err)
}
// manifest strictness is the catalog check's (H-A-498): the SDK's reader sets an unknown field aside.
m, err := catalogue.Decode(manifestJSON)
if err != nil {
t.Fatalf("module.json: %v", err)
}
// The i3 module binds $mod+Delete to logind's lock, which names no locker; a binding here as well
// would be i3's duplicate.
for _, r := range m.Resources {
@@ -83,12 +119,29 @@ func TestTheLockKeyIsTheWindowManagersNotThisModules(t *testing.T) {
}
func TestTheToolsAgreeWithTheManifest(t *testing.T) {
m := readManifest(t)
manifestJSON, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
if err != nil {
t.Fatal(err)
}
// manifest strictness is the catalog check's (H-A-498): the SDK's reader sets an unknown field aside.
m, err := catalogue.Decode(manifestJSON)
if err != nil {
t.Fatalf("module.json: %v", err)
}
checkTheToolsAgree(t, m)
checkNoSecretsOrInstallationNames(t)
}
// No file resource carries its text inline (novox/hq ADR 0349 §2).
func TestEveryFileTakesItsTextFromATemplate(t *testing.T) {
readManifest(t).everyFileIsATemplate(t)
manifestJSON, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
if err != nil {
t.Fatal(err)
}
// manifest strictness is the catalog check's (H-A-498): the SDK's reader sets an unknown field aside.
m, err := catalogue.Decode(manifestJSON)
if err != nil {
t.Fatalf("module.json: %v", err)
}
everyFileIsATemplate(t, m)
}