package manifest import ( "bytes" "encoding/json" checker "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdeliverychecker" "io/fs" "os" "path/filepath" "reflect" "slices" "strings" "testing" "mesh-delivery-checker/internal/check" ) // The controller's manifest reader is mesh-controller internal/catalogue (Manifest, manifest.go: Consumes :521, // Invokes :590, Streams :613, Reads :659; StreamDeclaration, streams.go), an internal package of another repository. // These tests decode the manifest strictly into the fields those types name (DisallowUnknownFields) and hold the // rules of issues 1678 and 1683 (ADR 0453 §4, ADR 0484). The merge gate's module check proves the controller takes the manifest. type state struct { Name string `json:"name"` History int `json:"history,omitempty"` TTL int `json:"ttl-seconds,omitempty"` MaxMiB int `json:"max-mib,omitempty"` } type artifact struct { Name string `json:"name"` Kind string `json:"kind"` Language string `json:"language"` System string `json:"system"` From string `json:"from"` Binary string `json:"binary"` Loads []string `json:"loads"` Paths []string `json:"paths"` Series string `json:"series"` } type stream struct { Name string `json:"name"` Events []string `json:"events"` MaxAgeDays int `json:"max-age-days,omitempty"` MaxMiB int `json:"max-mib,omitempty"` Retention string `json:"retention,omitempty"` } type manifest struct { Claims []struct { Name string `json:"name"` Scope string `json:"scope"` Serves []string `json:"serves"` } `json:"claims"` Streams []stream `json:"streams"` Tools []string `json:"tools"` Module string `json:"module"` Version string `json:"version"` Slug string `json:"slug"` Consumes []string `json:"consumes"` State []state `json:"state"` Reads []string `json:"reads"` Uses []string `json:"uses"` Invokes []string `json:"invokes"` Config map[string]struct { Type string `json:"type"` Description string `json:"description"` Pattern string `json:"pattern"` Default any `json:"default"` Minimum *float64 `json:"minimum"` Maximum *float64 `json:"maximum"` Trusted bool `json:"trusted"` } `json:"config"` OwnSecrets map[string]string `json:"own-secrets"` SecretsOwner string `json:"secrets-owner"` Resources []map[string]any `json:"resources"` Build struct { Artifacts []artifact `json:"artifacts"` } `json:"build"` } func load(t *testing.T) (manifest, map[string]json.RawMessage) { t.Helper() raw, err := os.ReadFile("module.json") if err != nil { t.Fatal(err) } var m manifest dec := json.NewDecoder(bytes.NewReader(raw)) dec.DisallowUnknownFields() if err := dec.Decode(&m); err != nil { t.Fatalf("the controller's reader refuses a key this manifest has: %v", err) } var top map[string]json.RawMessage if err := json.Unmarshal(raw, &top); err != nil { t.Fatal(err) } return m, top } func sorted(s []string) []string { s = slices.Clone(s) slices.Sort(s) return s } func TestManifestDeclarations(t *testing.T) { // 1678/AC1 m, top := load(t) // 1373: checker_ask_again asks the delivery view's build_usage for the build seats' backlog; the list below is the rest. if !slices.Contains(m.Invokes, "mesh-delivery-view.build_usage") { t.Error("invokes lack mesh-delivery-view.build_usage, which checker_ask_again asks for the build seats' streams") } m.Invokes = slices.DeleteFunc(slices.Clone(m.Invokes), func(s string) bool { return s == "mesh-delivery-view.build_usage" }) if m.Module != "mesh-delivery-checker" { t.Errorf("module = %q", m.Module) } // The histories of the checker's four seat states (checked against internal/check names below); the names follow the seat mesh-delivery-checker. if want := []state{{Name: "asks", History: 1}, {Name: "hearing", History: 1}, {Name: "inputs", TTL: 86400}, {Name: "compositions", TTL: 259200, MaxMiB: 256}, {Name: "kept", History: 1}, {Name: "owed", History: 5}, {Name: "previews", History: 5}, {Name: "tries", History: 1}, {Name: "verdicts", History: 5}, {Name: "first-views", History: 1}, {Name: "findings", History: 1}, {Name: "could-not-run", History: 1}}; !reflect.DeepEqual(m.State, want) { t.Errorf("state = %+v, want %+v", m.State, want) } // The build modules are no names (design 47 G A-82): the steps and toolchains of the build seats are read as the seat's holder's states. if want := []string{"mesh-delivery-builder.builds", "mesh-delivery-watchman.presence", "node-engine.have", "seat:mesh-module-assigner.assignments", "seat:node-build-go.steps", "seat:node-build-go.toolchains", "seat:node-build-node.steps", "seat:node-build-node.toolchains"}; !reflect.DeepEqual(sorted(m.Reads), want) { t.Errorf("reads = %v, want %v", m.Reads, want) } // DLV-M2 (ADR 0615 §1, ADR 0596): the indexer's candidates, modules, manifests, packages and predefined keys and the // assigner's assignments are asked by their read tools and followed by their views families, never read. for _, r := range m.Reads { if strings.HasPrefix(r, "mesh-delivery-indexer.") || strings.HasPrefix(r, "mesh-delivery-assigner.") { t.Errorf("reads %s: the indexer's and the assigner's state is read by their tools and views families alone", r) } } // 1887/A5b: the checker reads nothing of the controller's plans-building (ADR 0483 superseded by ADR 0525 §7), calls no // build module's tool and holds no capacity: it puts check asks on the Go and Node build seats (ADR 0525 §1, §4). // The forge's file read through the seat git, never a module's tool (milestone 47/G W6.14), the build seats' drop, and of // the node seat node-engine its one verb compose-candidate, asked of every placed node (ADR 0593 §7), never its other verbs. if want := []string{"mesh-delivery-indexer.indexer_read_candidates", "mesh-delivery-indexer.indexer_read_manifests", "mesh-delivery-indexer.indexer_read_modules", "mesh-delivery-indexer.indexer_read_packages", "mesh-delivery-indexer.indexer_read_predefined", "mesh-delivery-indexer.indexer_read_seat_definitions", "seat:git.file", "seat:mesh-catalog.registrations", "seat:mesh-catalog.revision", "seat:mesh-catalog.seat-definitions", "seat:mesh-delivery.source", "seat:mesh-config.renames", "seat:mesh-hand-acts.hand-act", "seat:mesh-module-assigner.assignments", "seat:node-build-go.drop", "seat:node-build-node.drop", "seat:node-engine.compose-candidate", // The image build seat's drop too: a check of a module built by it is asked of it, and dropped of it (buildrun.SeatDrops). "seat:node-build-image.drop", // A-290, A-291: a step's answer its key keeps as an object, read through each build seat's verb output. "seat:node-build-go.output", "seat:node-build-node.output", "seat:node-build-image.output", // A-231: the check asks on each build seat's queues check and recheck. "seat:node-build-go.accept.check", "seat:node-build-go.accept.recheck", "seat:node-build-node.accept.check", "seat:node-build-node.accept.recheck", "seat:node-build-image.accept.check", "seat:node-build-image.accept.recheck"}; !reflect.DeepEqual(sorted(m.Invokes), sorted(want)) { t.Errorf("invokes = %v, want the seat git's file, the seats' drop and compose-candidate", m.Invokes) } if want := []string{"node-build-go", "node-build-node"}; !reflect.DeepEqual(sorted(m.Uses), want) { t.Errorf("uses = %v, want the Go and Node build seats", m.Uses) } // The checker is woken by a build seat's report of a toolchain, as the builder is: the bucket may not exist when it starts. // Design 47 G §717, §614: the catalog half, whose claimant's seat-holders view names the holder of the assignments. if want := []string{"mesh-catalog.catalog-revision", "mesh-catalog.registration-changed", "mesh-catalog.seat-definition-changed", "mesh-catalog.seat-definition-removed", "mesh-conditions.findings-asked", "mesh-delivery-indexer.views.candidates", "mesh-delivery-indexer.views.manifests", "mesh-delivery-indexer.views.modules", "mesh-delivery-indexer.views.packages", "mesh-delivery-indexer.views.predefined", "mesh-delivery-indexer.views.seat-definitions", "mesh-delivery.source-moved", "node-build-go.toolchain-reported", "node-build-node.toolchain-reported", "node-engine.running", "seat:mesh-module-assigner.views.assignments", "seat:mesh-module-assigner.views.seat-holders"}; !reflect.DeepEqual(sorted(m.Consumes), want) { t.Errorf("consumes = %v, want %v", m.Consumes, want) } if b, ok := m.OwnSecrets["broker"]; !ok || len(m.OwnSecrets) != 1 || b != "${dir:state}/broker" { t.Errorf("own-secrets = %v, want exactly broker", m.OwnSecrets) } if m.SecretsOwner != "mesh-delivery-checker" { t.Errorf("secrets-owner = %q", m.SecretsOwner) } // The checker says each time it wrote a preview or a status, so the indexer's and the forge bridge's watches find the buckets (ADR 0484 clauses 2 and 3). // Its family asks (design 26): verdict, apart from checks so a waiter on a verdict does not wake on a check; a stream that keeps its history, the predefined form of an event family // (ADR 0592 §6, the manifest validator). if want := []stream{{Name: "checks", Events: []string{"preview.**", "owed.**", "try.**"}}, {Name: "asks", Events: []string{"verdict"}, Retention: "history"}, {Name: "mesh-delivery-checker-findings", Events: []string{"finding-written.*", "finding-cleared.*", "findings-stated.*"}, MaxAgeDays: 7, MaxMiB: 16}}; !reflect.DeepEqual(m.Streams, want) { t.Errorf("streams = %+v, want %+v", m.Streams, want) } // Only the checker's account publishes try.* on its stream checks: the stream is declared by its owner alone, and no other // module of the repository declares a stream carrying a try event (the indexer and the others only consume them). siblings, err := filepath.Glob("../*/module.json") if err != nil || len(siblings) < 2 { t.Fatalf("the sibling manifests = %v, %v", siblings, err) } for _, f := range siblings { raw, err := os.ReadFile(f) if err != nil { t.Fatal(err) } var other struct { Module string `json:"module"` Streams []stream `json:"streams"` } if err := json.Unmarshal(raw, &other); err != nil { t.Fatalf("%s: %v", f, err) } for _, st := range other.Streams { for _, e := range st.Events { if strings.HasPrefix(e, "try.") && other.Module != m.Module { t.Errorf("%s declares the stream %s with %s: only the checker's account publishes try events", other.Module, st.Name, e) } } } } // The read tools (issue 1686) are served by the tools bundle, not by the checker's process. // The try's tools (ADR 0501 §5; the end by hand, issue 734) beside them: mesh-controller's try calls them. A lost check // is asked again by hand (checker_ask_again). if want := []string{"checker_ask_again", "checker_composition_requests", "checker_composition_requests_drop", "checker_first_view_again", "checker_first_views", "checker_inputs", "checker_kept", "checker_previews", "checker_pull", "checker_status", "checker_tries", "checker_try", "checker_try_end", "checker_try_read", "checker_verdicts"}; !reflect.DeepEqual(sorted(m.Tools), want) { t.Errorf("tools = %v, want %v", m.Tools, want) } // The try is the checker's own seat's verbs (ADR 0547 §10, issue 774), served beside the tools by the same code; so is // input, a checking program's input the Go build module asks (issue 1921, ADR 0596 §2). if len(m.Claims) != 1 || m.Claims[0].Name != "mesh-delivery-checker" || m.Claims[0].Scope != "mesh" || !reflect.DeepEqual(m.Claims[0].Serves, []string{"try", "try-read", "try-end", "input"}) { t.Errorf("claims = %+v, want the mesh seat mesh-delivery-checker serving try, try-read, try-end and input", m.Claims) } for _, k := range []string{"logs", "emits", "provides", "requires", "defines-seats", "seat", "seats", "bus"} { // config: compose-answer-bound (ADR 0593 §7) if _, ok := top[k]; ok { t.Errorf("the manifest declares %q: the checker has none", k) } } // D-11 (ADR 0634 §1): the holders and buckets internal/check names, no contract naming a holder, are the manifest's: a state // the checker reads is a `reads` (.) and a state of the indexer it follows a `consumes` of its views family. for bucket, read := range map[string]string{ check.PresenceBucket: "mesh-delivery-watchman.presence", check.HaveBucket: "node-engine.have"} { if strings.Replace(bucket, "_", ".", 1) != read || !slices.Contains(m.Reads, read) { t.Errorf("the bucket %s is not the declared read %s", bucket, read) } } for bucket, view := range map[string]string{check.CandidatesBucket: "candidates", check.ModulesBucket: "modules", check.ManifestsBucket: "manifests"} { if bucket != check.IndexerModule+"_"+view || !slices.Contains(m.Consumes, check.IndexerModule+".views."+view) { t.Errorf("the bucket %s is not a followed view of the indexer's %s", bucket, view) } } if !slices.Contains(m.Consumes, check.IndexerModule+".views."+check.IndexerPredefinedState) { t.Errorf("the indexer's state %s is followed, and not declared", check.IndexerPredefinedState) } for own, history := range map[string]int{checker.StateVerdicts: 5, checker.StateKept: 1, checker.StateOwed: 5, checker.StatePreviews: 5} { if !slices.ContainsFunc(m.State, func(st state) bool { return st.Name == own && st.History == history }) { t.Errorf("the state %s is not a state of the manifest at history %d", own, history) } } } func TestManifestProcess(t *testing.T) { // 1678/AC1 m, _ := load(t) var procs []map[string]any for _, r := range m.Resources { if r["type"] == "process" { procs = append(procs, r) } if r["type"] == "tool" || r["type"] == "seat" { t.Errorf("resource %v: the checker serves no tool and holds no seat", r) } } if len(procs) != 1 { t.Fatalf("%d process resources, want one", len(procs)) } p := procs[0] if p["artifact"] != "program" || !reflect.DeepEqual(p["run"], []any{"./mesh-delivery-checker"}) { t.Errorf("process = %v", p) } env, _ := p["env"].(map[string]any) if len(env) != 2 || env["MESH_BROKER_FILE"] != "${dir:state}/broker" || env["MESH_CHECKER_SETTINGS"] != "${dir:state}/settings.json" { t.Errorf("env = %v, want the broker file and the settings file", p["env"]) } // Its settings hold its answer bound (ADR 0593 §7: compose-answer-bound, 60 s, the checker's) and its wait for the // candidate's builds (ADR 0603 §10: build-wait-bound, 1800 s), never a capacity of its own (ADR 0525 §4). for _, r := range m.Resources { if r["id"] == "settings" && !reflect.DeepEqual(r["takes-config"], []any{"compose-answer-bound", "build-wait-bound"}) { t.Errorf("the settings resource %v takes other than compose-answer-bound and build-wait-bound", r) } } if c, ok := m.Config["build-wait-bound"]; !ok || c.Default != float64(1800) || c.Trusted { t.Errorf("build-wait-bound = %+v, want 1800 by default, not trusted", c) } if c, ok := m.Config["compose-answer-bound"]; !ok || c.Default != float64(60) || c.Trusted { t.Errorf("compose-answer-bound = %+v, want 60 by default, not trusted", c) } if _, bus := p["bus"]; bus { t.Errorf("the process declares a bus: it runs on its own broker credential") } // The settings template is packed as the files archive (novox/hq ADR 0349 §2), or the indexer's judge refuses it. // Issue 1966's bootstrap: the package artifact checkermsg is out of the manifest until the new builder runs; the // follow-up puts it back with its assertion (ADR 0634 section 2: four artifacts, the fourth the package checkermsg). if len(m.Build.Artifacts) != 3 { t.Fatalf("artifacts = %+v, want the program, the tools and the files archive", m.Build.Artifacts) } if a := m.Build.Artifacts[2]; a.Name != "files" || a.Kind != "archive" || a.From != "files" { t.Errorf("files artifact = %+v, want an archive from files/", a) } if a := m.Build.Artifacts[1]; a.Name != "tools" || a.Kind != "bundle" || a.Language != "go" || a.Binary != "mesh-delivery-checker-tools" || !reflect.DeepEqual(a.Loads, []string{"mesh-delivery-checker-tools"}) { t.Errorf("tools artifact = %+v", a) } if st, err := os.Stat(m.Build.Artifacts[1].From); err != nil || !st.IsDir() { t.Errorf("the tools' source %s: %v", m.Build.Artifacts[1].From, err) } a := m.Build.Artifacts[0] if st, err := os.Stat(a.From); err != nil || !st.IsDir() || a.Binary != "mesh-delivery-checker" || !strings.HasSuffix(a.From, a.Binary) || a.Kind != "bundle" || a.Language != "go" { t.Errorf("artifact = %+v", a) } } func TestServesNoRequestSubjectAndHoldsNoTicker(t *testing.T) { // 1678/AC6 (ADR 0437 §8: no timer, a wait is a context's bound) forbidden := []string{"Subscribe(", "QueueSubscribe", "ChanSubscribe", "time.NewTicker", "time.Tick", "time.NewTimer", "time.AfterFunc", "time.After(", "time.Sleep"} var files int for _, root := range []string{"cmd", "internal"} { err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { if err != nil || d.IsDir() || !strings.HasSuffix(path, ".go") || strings.HasSuffix(path, "_test.go") { return err } files++ src, err := os.ReadFile(path) if err != nil { return err } for _, f := range forbidden { if strings.Contains(string(src), f) { t.Errorf("%s holds %s: the checker serves no request subject and holds no timer", path, f) } } return nil }) if err != nil { t.Fatal(err) } } if files < 1 { t.Fatalf("read %d source files, want the program's", files) } }