Files
mesh-delivery/modules/mesh-delivery-pipeline/manifest_test.go
T
jschoubben 4194e93a67 Area 2 (join 11): every seat verb and build-seat queue a delivery module calls is in its invokes
The grants part grants a seat verb only to a module that names it in invokes (GR8), so a call missing from a
manifest is refused live. Listed every module's seat-verb calls in code (constant clients, seatlist.HolderOf,
operatorask, buildrun's drops and puts) against its invokes: the teller asks who holds operator-channel
(operatorask.Bucket) and the checker drops asks of the image build seat. Every asker of a build seat names the
queues it asks as seat:<seat>.accept.<queue> (A-231): the runner check and delivery, the assigner check, the
builder delivery, the checker check and recheck; the indexer had its entry. The validator judges that form
through mesh-sdk's catalogue.QueueInvoke against the kinds the seat accepts.

mesh-grants: a consumed seat view whose seat has no holder on record grants nothing instead of refusing the whole
module (TestGrants); TestCallersAndWhyRefused and TestSentStoresRead take §610's class defaults.

Builds: design 47 G §544, §601, §610, §616, A-231, A-179

Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
2026-11-12 12:17:50 +01:00

175 lines
7.9 KiB
Go

package pipeline_test
import (
"encoding/json"
"os"
"slices"
"testing"
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner"
"git.novox.be/novox/mesh-sdk/go/catalogue"
)
// TestManifest holds the runner's manifest to its design lines, row by row.
func TestManifest(t *testing.T) {
raw, err := os.ReadFile("module.json")
if err != nil {
t.Fatal(err)
}
m, err := catalogue.Decode(raw)
if err != nil {
t.Fatalf("the manifest does not read: %v", err)
}
var states, streams, objects []string
keyTTL := map[string]bool{}
stateMiB := map[string]int{}
for _, s := range m.State {
states = append(states, s.Name)
keyTTL[s.Name] = s.KeyTTL
stateMiB[s.Name] = s.MaxMiB
}
objectMiB := map[string]int{}
for _, s := range m.Streams {
streams = append(streams, s.Name)
}
for _, o := range m.Objects {
objects = append(objects, o.Name)
objectMiB[o.Name] = o.MaxMiB
}
var program catalogue.Artifact
if m.Build == nil {
t.Fatal("the manifest builds nothing")
}
for _, a := range m.Build.Artifacts {
if a.Name == "program" {
program = a
}
}
rows := []struct {
name string
ok bool
}{
// RN1/AC1 (§21): a foundation part asks no template; its kept data are in old sections.
{"no requires", len(m.Requires) == 0},
{"claims the seat serving every verb of its definition", len(m.Claims) == 1 && m.Claims[0].Name == seat.Seat &&
equalSets(m.Claims[0].Serves, seat.Verbs())},
// §27, §85, §330, §355, §77: the old state sections.
{"old state sections", equalSets(states, []string{seat.StatePipelines, seat.StateKept, "aged", "recoveries", "bounds", "toolchains", "findings", "first-views", "consumers"})},
// §535, §647, A-77, A-104: an ask no holder takes is bound by a key with its own time to live.
{"bounds is key-ttl", keyTTL["bounds"]},
// RN25 (§469, §85): an old state section declares its cap, pipelines 256 MiB and kept 128 MiB.
{"pipelines 256 MiB", stateMiB[seat.StatePipelines] == 256},
{"kept 128 MiB", stateMiB[seat.StateKept] == 128},
// §470 (amending §27, §85): the step log is an old logs section kept 100 days, 128 MiB; RN24 (§383, §387): the finding
// stream its findings are said on is the one old stream.
{"old streams section", equalSets(streams, []string{"mesh-delivery-pipeline-findings"})},
{"step-log an old logs section of 100 days and 128 MiB", len(m.Logs) == 1 && m.Logs[0].Name == seat.StateStepLog &&
m.Logs[0].MaxAgeDays == 100 && m.Logs[0].MaxMiB == 128},
{"finding stream 7 days 16 MiB", len(m.Streams) == 1 && m.Streams[0].MaxAgeDays == 7 && m.Streams[0].MaxMiB == 16 &&
equalSets(m.Streams[0].Events, []string{"finding-written.*", "finding-cleared.*", "findings-stated.*"})},
// RN24 (§368): the version as MAJOR.MINOR, 0.1 with none published.
{"version 0.1", m.Version == "0.1"},
// RN25 (§477, §533, §59): a foundation part whose seat has verbs and events declares its sent store, 256 MiB.
{"old objects section", equalSets(objects, []string{seat.StateStepOutputs, catalogue.SentObjectsLocal})},
{"step-outputs 1 GiB", objectMiB[seat.StateStepOutputs] == 1024},
{"sent-objects 256 MiB", objectMiB[catalogue.SentObjectsLocal] == 256},
// §333, §54, §44, §53, §376, §24, §37, §4, §77: what the runner hears.
{"consumes", equalSets(m.Consumes, []string{
"mesh-delivery-indexer.take-in.taken", "mesh-builds.package-published", "mesh-builds.toolchain-agreed", "mesh-builds.step-ended", "mesh-delivery-builder.build.ended.**",
"operator-channel.decided", "node-build-go.step-ended", "node-build-node.step-ended",
"node-build-image.step-ended", "node-build-go.ask-taken", "node-build-node.ask-taken", "node-build-image.ask-taken", "node-engine.running", "mesh-wants.step-ended", "mesh-catalog.registration-changed",
"mesh-catalog.catalog-revision", "mesh-conditions.findings-asked", "mesh-delivery.recovery-merged",
// A-186: the seat list its write verbs' callers are checked against, heard as it changes.
"mesh-catalog.seat-definition-changed", "mesh-catalog.seat-definition-removed"})},
// RN2 (§21, §195, §200, §77): the registrations and the catalog half asked by their verbs, the first views read and
// asked again by hand (a hand act).
{"invokes", equalSets(m.Invokes, []string{"seat:mesh-catalog.registrations",
// A-186: the seat list, read by its verb.
"seat:mesh-catalog.seat-definitions", "seat:mesh-catalog.revision", "seat:mesh-hand-acts.hand-act",
// RN3 (§53, §334): a publication's dependents behind.
"seat:mesh-catalog.outdated",
// RN10 (§71, §441, A-207): the permissions a change widens, asked of the grants part.
"seat:mesh-grants.grants-for",
// RN11 (§33, A-191): the author of a failed head, read as the forge records it.
"seat:git.pull",
// RN8 (§31, §350; A-182): a superseded step's ask dropped of the build seat that holds it.
"seat:node-build-go.drop", "seat:node-build-node.drop", "seat:node-build-image.drop",
// A-74, A-89: who holds the seat operator-channel, whose state asks holds the router's record of the approval ask.
"seat:mesh-module-assigner.assignments",
// A-102 (§22, §24): the accepted kinds the runner puts its steps on.
"seat:mesh-builds.step", "seat:mesh-wants.step", "seat:node-build-go.check.step", "seat:node-build-node.check.step",
"seat:node-build-image.check.step",
// RN22 (§86, §415, A-207): a recovery's steps on the build seats' stream delivery.
"seat:node-build-go.delivery.step", "seat:node-build-node.delivery.step", "seat:node-build-image.delivery.step",
// A-231: the queues of the build seats it asks, check for the steps and delivery for a recovery's.
"seat:node-build-go.accept.check", "seat:node-build-go.accept.delivery", "seat:node-build-node.accept.check",
"seat:node-build-node.accept.delivery", "seat:node-build-image.accept.check", "seat:node-build-image.accept.delivery"})},
{"uses operator-channel", equalSets(m.Uses, []string{"operator-channel"})},
// RN25 (§539): the runner's tools carry the prefix runner_.
{"first-view tools", equalSets(m.Tools, []string{"runner_first_views", "runner_first_view_again", "runner_health", "runner_waits", "runner_release", "runner_unlogged", "runner_unlogged_append"})},
// RN25 (§468, §76): the health check, run outside the process, is the tool runner_health.
{"health is runner_health", healthTool(raw) == "tool runner_health"},
// RN1/AC5 (§95, §130): the new assigner is delivered before the runner.
{"program needs the assigner's program", slices.Equal(program.Needs, []string{"mesh-delivery-assigner:program"})},
}
for _, r := range rows {
if !r.ok {
t.Errorf("%s: not as the design says", r.name)
}
}
}
// §610, A-75: no verb of the runner's definition names its callers, so the class's default holds for each.
func TestNoVerbNamesItsCallers(t *testing.T) {
raw, err := os.ReadFile("../mesh-delivery-contracts/seats/mesh-pipeline-runner/seat.json")
if err != nil {
t.Fatal(err)
}
var def struct {
Verbs []struct {
Name string `json:"name"`
Callers []string `json:"callers"`
} `json:"verbs"`
}
if err := json.Unmarshal(raw, &def); err != nil {
t.Fatal(err)
}
if len(def.Verbs) == 0 {
t.Fatal("the definition holds no verb")
}
for _, v := range def.Verbs {
if len(v.Callers) != 0 {
t.Errorf("the verb %s names callers %v; from G no verb does (§610)", v.Name, v.Callers)
}
}
}
// healthTool is the process resource's health kind and tool.
func healthTool(raw []byte) string {
var m struct {
Resources []struct {
Type string `json:"type"`
Health struct {
Kind string `json:"kind"`
Tool string `json:"tool"`
} `json:"health"`
} `json:"resources"`
}
if err := json.Unmarshal(raw, &m); err != nil {
return err.Error()
}
for _, r := range m.Resources {
if r.Type == "process" {
return r.Health.Kind + " " + r.Health.Tool
}
}
return ""
}
func equalSets(a, b []string) bool {
x, y := slices.Clone(a), slices.Clone(b)
slices.Sort(x)
slices.Sort(y)
return slices.Equal(x, y)
}