mesh-delivery/modules/mesh-delivery-assigner/manifest_test.go

package manifest

import (
	"git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner"
	"git.novox.be/novox/mesh-delivery/contracts/go/seats/meshwants"
	"os"
	"reflect"
	"slices"
	"strings"
	"testing"

	"git.novox.be/novox/mesh-sdk/go/catalogue"

	"git.novox.be/novox/mesh-sdk/go/views"

	"mesh-delivery-assigner/internal/buckets"
)

func load(t *testing.T) catalogue.Manifest {
	t.Helper()
	raw, err := os.ReadFile("module.json")
	if err != nil {
		t.Fatal(err)
	}
	m, err := catalogue.Decode(raw)
	if err != nil {
		t.Fatalf("mesh-sdk cannot decode the manifest: %v", err)
	}
	return m
}

// 1297/B2a: the controller's reader (mesh-sdk catalogue, which the controller reads manifests with) takes the
// manifest; it reads exactly the buckets the assigner opens (the program's list, held equal in its own test), keeps
// the states it declares (the differences kept read-only, 1906/D5), and holds a credential of its own.
func TestManifest(t *testing.T) {
	m := load(t)
	if m.Module != "mesh-delivery-assigner" {
		t.Errorf("module = %q", m.Module)
	}
	reads := slices.Clone(m.Reads)
	slices.Sort(reads)
	// ADR 0593 §8: it composes nothing, so it reads no candidate, held or resolved value, compose step or build log; it reads
	// every node's published compositions to compare them, and the gate's source and merges, for the release that carries a build (ADR 0601 §1).
	// DLV-F2r (ADR 0615 §1, ADR 0631 §1): the indexer's manifests, modules and module graph (whose verb edges a want waits
	// on, ADR 0614 §2, §3) are read through its first views and views family, none of the indexer's states by reads.
	want := []string{"mesh-delivery-builder.builds", "mesh-delivery-gate.merges", "mesh-delivery-gate.source",
		"mesh-delivery-teller.answers", "mesh-delivery-watchman.presence", "mesh-grants.grants", "mesh-host.composed",
		"mesh-provisioner.provisions", "node-engine.have"}
	if !reflect.DeepEqual(reads, want) {
		t.Errorf("reads = %v, want exactly %v", reads, want)
	}
	// the buckets the program names are the manifest's reads, `<module>.<state>` as `<module>_<state>`
	named := []string{buckets.Builds, buckets.Merges, buckets.Source, buckets.Answers, buckets.Presence, buckets.Grants,
		buckets.ComposedRead, "mesh-provisioner_provisions", buckets.Have}
	slices.Sort(named)
	for i, r := range want {
		if got := strings.Replace(named[i], "_", ".", 1); got != r {
			t.Errorf("the buckets package names %q, the manifest reads %q", got, r)
		}
	}
	states := map[string]int{}
	for _, s := range m.State {
		states[s.Name] = s.History
	}
	if want := map[string]int{"asks": 5, "differences": 64, "puts": 20, "wants": 20,
		"assignments": 64, "placement": 64, "proposals": 5, "candidates": 5, "pulses": 0, "findings": 5, "policies": 20, "seat-holders": 5, views.MarksState: 1, views.StatusState: 1,
		"engine-reads": 1}; !reflect.DeepEqual(states, want) {
		t.Errorf("state = %v, want %v", states, want)
	}
	if _, ok := m.OwnSecrets["broker"]; !ok || len(m.OwnSecrets) != 1 {
		t.Errorf("own-secrets = %v, want exactly broker (or no credential is issued)", m.OwnSecrets)
	}
	if m.SecretsOwner != "mesh-delivery-assigner" {
		t.Errorf("secrets-owner = %q", m.SecretsOwner)
	}
	// 1906/D3: it says its conditions on the operator channel; it asks the Go build seat nothing since the composition is
	// the node-engine's (ADR 0593 §7).
	if !slices.Equal(m.Uses, []string{"operator-channel"}) {
		t.Errorf("uses = %v, want exactly operator-channel", m.Uses)
	}
	// ADR 0546: it serves its own tools (put, release, puts) from its bundle through the tool runner (the artifact loads the
	// module), says each put's step as the event put, and calls the hand-act seat and the bus node's backup holder.
	// ADR 0567 §1, §6-§10: it holds the seat mesh-module-assigner, serving its five verbs (adopt and hand-back went with the
	// controller, ADR 0590); keeps the seat's events on its stream assignments for 30 days; calls the hand-act log; and reads
	// mesh-config's resolved values to compose every node a proposal touches.
	// ADR 0565 §7, §9 (issue 1953 D4): and the seat mesh-wants, serving upgrade and bus.
	if len(m.Claims) != 2 || m.Claims[0].Name != meshmoduleassigner.Seat || m.Claims[0].At() != catalogue.ScopeMesh ||
		!slices.Equal(m.Claims[0].Serves, []string{"assignments", "proposals", "propose", "withdraw", "again"}) ||
		m.Claims[1].Name != meshwants.Seat || m.Claims[1].At() != catalogue.ScopeMesh || !slices.Equal(m.Claims[1].Serves, []string{"upgrade", "bus"}) {
		t.Errorf("the assigner claims %+v, want mesh-module-assigner with its five verbs and mesh-wants with its two", m.Claims)
	}
	// Whether the seats' definitions let it hold them is the manifest validator's (the judge, at the seat list).
	// ADR 0621 §1: the first-view tools assignments, seat-holders and wants and design 25 § 12.2's six read tools, of the
	// program's bundle, which runs in a runtime of its own on the assigner's account; ADR 0618 §3: and assigner_engine_reads,
	// which lists and asks again what each node's engine reads.
	if !slices.Equal(m.Tools, []string{"assigner_put", "assigner_release", "assigner_puts", "assignments", "seat-holders", "wants",
		"assigner_read_assignments", "assigner_read_seat_holders", "assigner_read_wants", "assigner_read_findings", "assigner_read_asks", "assigner_read_differences",
		"assigner_first_views", "assigner_first_view_again", "assigner_engine_reads"}) {
		t.Errorf("the assigner serves tools %v, want its three put tools, three first views, six read tools and assigner_engine_reads", m.Tools)
	}
	if m.RunsAs != m.Module || m.SecretsOwner != m.RunsAs {
		t.Errorf("runs-as = %q: the bundle runs on the assigner's own account (ADR 0621 §1)", m.RunsAs)
	}
	// ADR 0621 §2: each first-view tool answers exactly its readers, never the assigner.
	callers := map[string]string{"assignments": "mesh-grants,node-tools,mesh-delivery-indexer", "seat-holders": "node-tools", "wants": "mesh-grants"}
	env := m.Build.Artifacts[0].Env
	for tool, list := range callers {
		if env[views.CallersEnv(tool)] != list || views.ParseCallers(env[views.CallersEnv(tool)]).Allows("n1."+m.Module) {
			t.Errorf("%s callers = %q, want %q", tool, env[views.CallersEnv(tool)], list)
		}
	}
	// ADR 0635 §5: its views family is its ordinary events, `views.<state>` among its emits, on no stream of its own.
	// The seat's four events are said on the seat's own subject (the seat's family), so the module keeps no stream for them
	// and lists none among its emits.
	if len(m.Streams) != 0 {
		t.Errorf("streams = %+v, want none: the seat's events ride the shared events stream", m.Streams)
	}
	for _, e := range meshmoduleassigner.Events() {
		if slices.Contains(m.Emits, e) {
			t.Errorf("emits lists %s, an event the seat says", e)
		}
	}
	// ADR 0618 §4: and it hears each node's engine say its reads changed.
	if !slices.Equal(m.Consumes, []string{"mesh-delivery-indexer.views.graph", "mesh-delivery-indexer.views.manifests", "mesh-delivery-indexer.views.modules", "node-engine.manifest-reads-changed"}) {
		t.Errorf("consumes = %v, want the indexer's views of graph, manifests and modules and the engines' reads changed", m.Consumes)
	}
	if want := []string{"mesh-delivery-indexer.graph", "mesh-delivery-indexer.manifests", "mesh-delivery-indexer.modules",
		"seat:mesh-hand-acts.hand-act", "seat:mesh-hand-acts.hand-acts", "seat:mesh-hand-acts.warranted", // ADR 0565 §9, §11: the seat alone
		"seat:node-backup.backed-up", "seat:node-backup.now",
		"seat:node-engine.manifest-reads"}; !slices.Equal(slices.Sorted(slices.Values(m.Invokes)), want) { // ADR 0618 §3
		t.Errorf("invokes = %v, want %v", m.Invokes, want)
	}
	if want := []string{"assignments-copied", "put", "views.asks", "views.differences", "views.findings", "views.assignments", "views.seat-holders", "views.wants"}; !slices.Equal(m.Emits, want) {
		t.Errorf("emits = %v, want the copy, put and its six views", m.Emits)
	}
}