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
175 lines
7.9 KiB
Go
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)
|
|
}
|