253 lines
10 KiB
Go
253 lines
10 KiB
Go
package manifest
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
|
|
"mesh-delivery-watchman/internal/watch"
|
|
)
|
|
|
|
// The controller's manifest reader is mesh-controller internal/catalogue (ParseManifest), an internal package of another
|
|
// repository, which this module cannot import. These tests therefore decode the manifest strictly into the fields its
|
|
// Manifest type names (DisallowUnknownFields, as its parseManifest does) and check the rules the issue names.
|
|
// **The merge gate's module check is what proves the controller takes this manifest (1135/AC6); these tests hold the
|
|
// rules so a unit run catches a refusal early.**
|
|
|
|
type state struct {
|
|
Name string `json:"name"`
|
|
History int `json:"history,omitempty"`
|
|
KeyTTL bool `json:"key-ttl,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"`
|
|
Context *struct {
|
|
Repository string `json:"repository"`
|
|
} `json:"context"`
|
|
}
|
|
|
|
type claim struct {
|
|
Name string `json:"name"`
|
|
Scope string `json:"scope"`
|
|
Serves []string `json:"serves"`
|
|
}
|
|
|
|
type manifest struct {
|
|
Module string `json:"module"`
|
|
Claims []claim `json:"claims"`
|
|
Tools []string `json:"tools"`
|
|
Moved bool `json:"moved"`
|
|
Version string `json:"version"`
|
|
Slug string `json:"slug"`
|
|
Reads []string `json:"reads"`
|
|
Consumes []string `json:"consumes"`
|
|
Invokes []string `json:"invokes"`
|
|
State []state `json:"state"`
|
|
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 TestManifestStateAndReads(t *testing.T) { // 1135/AC6
|
|
m, top := load(t)
|
|
if m.Module != "mesh-delivery-watchman" || m.Moved || m.Slug != "watchman" {
|
|
t.Errorf("module %q moved %v (it has no template, so it is not moved) slug %q", m.Module, m.Moved, m.Slug)
|
|
}
|
|
want := []state{{Name: "presence", History: 20}, {Name: "pulse", KeyTTL: true}, {Name: "stuck", History: 20}, {Name: "findings", History: 5}, {Name: "first-views", History: 1}}
|
|
if !reflect.DeepEqual(m.State, want) {
|
|
t.Errorf("state = %+v, want %+v", m.State, want)
|
|
}
|
|
reads := slices.Clone(m.Reads)
|
|
slices.Sort(reads)
|
|
if !reflect.DeepEqual(reads, []string{"mesh-build-go.steps", "mesh-build-image.steps", "mesh-build-node.steps",
|
|
"mesh-delivery-builder.builds", "mesh-host.health", "mesh-provisioner.provisions", "node-engine.have"}) {
|
|
t.Errorf("reads = %v", reads)
|
|
}
|
|
// DLV-M5 (ADR 0615 §1): the assigner's wants and the indexer's modules are their owners' states, 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)
|
|
}
|
|
}
|
|
// The join: its first view asked again by hand is a hand act, recorded through the seat (views.StatusTools). The waits the
|
|
// indexer holds at the watchman's start are asked of its tool (ADR 0633 §5), a verb edge as the view's.
|
|
if want := []string{"mesh-delivery-assigner.assigner_read_wants", "mesh-delivery-indexer.indexer_pending", "mesh-delivery-indexer.indexer_read_modules", "seat:mesh-hand-acts.hand-act"}; !reflect.DeepEqual(m.Invokes, want) {
|
|
t.Errorf("invokes = %v, want %v", m.Invokes, want)
|
|
}
|
|
// DLV-M5 its first views, 1585/T20 the indexer's take-in events, and DLV-W1 (ADR 0595 §4): the accepted verdicts and the bus module's created and refused, durably.
|
|
if want := []string{"mesh-delivery-assigner.views.wants", "mesh-delivery-indexer.take-in.pending", "mesh-delivery-indexer.take-in.taken", "mesh-delivery-indexer.views.modules", "mesh-catalog.manifest-accepted", "mesh-broker.created", "mesh-broker.refused"}; !reflect.DeepEqual(m.Consumes, want) {
|
|
t.Errorf("consumes = %v, want %v", m.Consumes, want)
|
|
}
|
|
// 1952/WM1: the watchman holds the seat mesh-watchdogs at mesh scope, its first seat (novox/hq ADR 0564 §1, §4).
|
|
if !reflect.DeepEqual(m.Claims, []claim{{Name: "mesh-watchdogs", Scope: "mesh", Serves: []string{"signals", "stuck", "presence", "dead-letters", "resync"}}}) {
|
|
t.Errorf("claims = %+v", m.Claims)
|
|
}
|
|
if !reflect.DeepEqual(m.Tools, []string{"watchman_findings", "watchman_first_views", "watchman_first_view_again"}) {
|
|
t.Errorf("tools = %v", m.Tools)
|
|
}
|
|
for _, k := range []string{"emits", "context", "items", "provides"} {
|
|
if _, ok := top[k]; ok {
|
|
t.Errorf("the manifest declares %q: the watchman has none", k)
|
|
}
|
|
}
|
|
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-watchman" {
|
|
t.Errorf("secrets-owner = %q", m.SecretsOwner)
|
|
}
|
|
// D-11 (ADR 0634 §1): the holders and buckets the watchman names are its manifest's: a state of the seat it holds, a
|
|
// `reads` entry, a `consumes` views family or an `invokes` tool, each as "<module>_<state>".
|
|
// bucket is "<module>_<state>" of a manifest entry "<module>.<state>" or "<module>.views.<state>".
|
|
bucket := func(list []string, entry string) string {
|
|
if !slices.Contains(list, entry) {
|
|
return "(not in the manifest: " + entry + ")"
|
|
}
|
|
parts := strings.Split(entry, ".")
|
|
return parts[0] + "_" + parts[len(parts)-1]
|
|
}
|
|
entry := func(list []string, e string) string {
|
|
if !slices.Contains(list, e) {
|
|
return "(not in the manifest: " + e + ")"
|
|
}
|
|
return e
|
|
}
|
|
for name, row := range map[string]struct{ got, want string }{
|
|
"module": {watch.WatchmanModule, m.Module},
|
|
"presence": {watch.PresenceBucket, m.Module + "_" + m.State[0].Name},
|
|
"pulse": {watch.PulseBucket, m.Module + "_" + m.State[1].Name},
|
|
"stuck": {watch.StuckBucket, m.Module + "_" + m.State[2].Name},
|
|
"have": {watch.HaveBucket, bucket(m.Reads, "node-engine.have")},
|
|
"health": {watch.NodeHealthBucket, bucket(m.Reads, "mesh-host.health")},
|
|
"builds": {watch.BuilderBuildsBucket, bucket(m.Reads, "mesh-delivery-builder.builds")},
|
|
"steps": {watch.StepsBucket("mesh-build-go"), bucket(m.Reads, "mesh-build-go.steps")},
|
|
"wants": {watch.AssignerWantsBucket, bucket(m.Consumes, "mesh-delivery-assigner.views.wants")},
|
|
"provisions": {watch.ProvisionsBucket, bucket(m.Reads, "mesh-provisioner.provisions")},
|
|
"modules": {watch.ModulesBucket, bucket(m.Consumes, "mesh-delivery-indexer.views.modules")},
|
|
"assigner": {watch.AssignerModule + ".assigner_read_wants", entry(m.Invokes, "mesh-delivery-assigner.assigner_read_wants")},
|
|
"indexer": {watch.IndexerModule + ".indexer_pending", entry(m.Invokes, "mesh-delivery-indexer.indexer_pending")},
|
|
} {
|
|
if row.got != row.want {
|
|
t.Errorf("the name for %s is %q, its manifest's is %q", name, row.got, row.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// The manifest is whole in its repository: the program, and the tools bundle the runtime loads (1952/WM1).
|
|
func manifestIsWholeInItsRepository(t *testing.T, m manifest) { // 1135/AC6
|
|
if len(m.Build.Artifacts) != 2 {
|
|
t.Fatalf("artifacts = %+v, want the program and the tools bundle", m.Build.Artifacts)
|
|
}
|
|
for i, name := range []string{"program", "tools"} {
|
|
a := m.Build.Artifacts[i]
|
|
if a.Name != name || a.Kind != "bundle" || a.Language != "go" || a.System != "arch" || a.Context != nil {
|
|
t.Errorf("artifact = %+v", a)
|
|
}
|
|
if st, err := os.Stat(a.From); err != nil || !st.IsDir() {
|
|
t.Errorf("the artifact builds from %q, which is not a directory of this module", a.From)
|
|
}
|
|
if !strings.HasSuffix(a.From, a.Binary) || (name == "tools") != reflect.DeepEqual(a.Loads, []string{a.Binary}) {
|
|
t.Errorf("binary %q from %q loads %v", a.Binary, a.From, a.Loads)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestManifestResources(t *testing.T) { // 1135/AC6
|
|
m, _ := load(t)
|
|
manifestIsWholeInItsRepository(t, m)
|
|
byType := map[string][]map[string]any{}
|
|
for _, r := range m.Resources {
|
|
ty, _ := r["type"].(string)
|
|
byType[ty] = append(byType[ty], r)
|
|
}
|
|
for _, ty := range []string{"user", "directory", "process"} {
|
|
if len(byType[ty]) == 0 {
|
|
t.Fatalf("no %s resource", ty)
|
|
}
|
|
}
|
|
user := byType["user"][0]["name"]
|
|
if user != "mesh-delivery-watchman" {
|
|
t.Errorf("user = %v", user)
|
|
}
|
|
p := byType["process"][0]
|
|
if p["user"] != user || p["artifact"] != "program" {
|
|
t.Errorf("process = %v", p)
|
|
}
|
|
env, _ := p["env"].(map[string]any)
|
|
if env["MESH_BROKER_FILE"] != "${dir:state}/broker" {
|
|
t.Errorf("the process reads %v", env["MESH_BROKER_FILE"])
|
|
}
|
|
if h, _ := p["health"].(map[string]any); h["kind"] != "unit" {
|
|
t.Errorf("health = %v", p["health"])
|
|
}
|
|
d := byType["directory"][0]
|
|
if d["id"] != "state" || d["mode"] != "0700" || d["owner"] != user {
|
|
t.Errorf("state directory = %v", d)
|
|
}
|
|
}
|
|
|
|
func TestNoTickerTimerOrSleep(t *testing.T) { // 1135/AC7
|
|
forbidden := []string{"time.Tick", "time.NewTicker", "time.Sleep", "time.After", "time.NewTimer", "time.AfterFunc"}
|
|
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 program holds no timer", path, f)
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if files < 3 {
|
|
t.Fatalf("read %d source files, want the program's", files)
|
|
}
|
|
}
|