mesh-controller/cmd/mesh-controller/placement_words_moved_test.go

package main

import (
	"encoding/json"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"testing"

	"github.com/novox/mesh-controller/internal/link"
)

// wordedMesh is every live layer that says `endpoints`, `expose`, `reach` or `ports` (issue 736) — 36, read with
// the settings verb on 2026-10-14, ace's as anchor's and novox's as laptop's, one stand-in for an address — split as
// the store holds them once migration 0097 has run: the four words still among the settings, `places` and
// `accesses` already beside them. With each module shaped as its definition in the catalogue (mesh-catalog's, and
// the media catalogue's) is where the four words reach: its listens, what its containers publish and on which
// network, its route, its directories and accesses, and its mergeable files — every key of the layer, or the keys
// they name. The shapes are the modules'; the files' text and the images are the test's.
type wordedMesh struct {
	Modules []json.RawMessage `json:"modules"`
	Layers  []struct {
		Node      string         `json:"node"`
		Module    string         `json:"module"`
		Settings  map[string]any `json:"settings"`
		Placement map[string]any `json:"placement"`
	} `json:"layers"`
}

func theWordedMesh(t *testing.T) wordedMesh {
	t.Helper()
	raw, err := os.ReadFile(filepath.Join("testdata", "placement-words-moved", "mesh.json"))
	if err != nil {
		t.Fatal(err)
	}
	var w wordedMesh
	if err := json.Unmarshal(raw, &w); err != nil {
		t.Fatal(err)
	}
	return w
}

// aMeshWithTheWordsInItsLayers is aMesh with every module of the worded mesh registered, a route provider on both
// machines, and its layers held as the store holds them before the four words move.

// toldOfTheWords is what a machine is told of the modules whose layers say the four words, and of the route
// provider that serves their names: those modules' resources and the filter's rules, as JSON a person can diff.
func toldOfTheWords(t *testing.T, open *stores, node string) string {
	t.Helper()
	ctx := t.Context()
	plan, _, err := resolveNode(ctx, open, node)
	if err != nil {
		t.Fatal(err)
	}
	with, err := madeAndRendered(ctx, open, node)
	if err != nil {
		t.Fatal(err)
	}
	composed, err := plan.Compose(with)
	if err != nil {
		t.Fatal(err)
	}
	if len(composed.LeftOut) > 0 {
		t.Fatalf("%s leaves out %v", node, composed.LeftOut)
	}
	rules, err := plan.Rules(with)
	if err != nil {
		t.Fatal(err)
	}
	ours := map[string]bool{"proxy": true}
	for _, l := range theWordedMesh(t).Layers {
		ours[l.Module] = true
	}
	var told []map[string]any
	for _, r := range composed.Resources {
		if ours[composed.Owner[r["id"].(string)]] {
			told = append(told, r)
		}
	}
	sort.Slice(told, func(i, j int) bool { return told[i]["id"].(string) < told[j]["id"].(string) })
	got, err := json.MarshalIndent(map[string]any{"resources": told, "rules": rules}, "", "  ")
	if err != nil {
		t.Fatal(err)
	}
	return string(got) + "\n"
}

// sameAsTheGolden holds what a machine is told to the golden file the controller before issue 736 wrote from the
// same seed (MESH_WRITE_GOLDEN=1 writes it instead).
func sameAsTheGolden(t *testing.T, open *stores, when string) {
	t.Helper()
	for _, node := range []string{"anchor", "laptop"} {
		got := toldOfTheWords(t, open, node)
		golden := filepath.Join("testdata", "placement-words-moved", node+".json")
		if os.Getenv("MESH_WRITE_GOLDEN") != "" {
			if err := os.MkdirAll(filepath.Dir(golden), 0o755); err != nil {
				t.Fatal(err)
			}
			if err := os.WriteFile(golden, []byte(got), 0o644); err != nil {
				t.Fatal(err)
			}
			continue
		}
		want, err := os.ReadFile(golden)
		if err != nil {
			t.Fatal(err)
		}
		if string(want) != got {
			t.Errorf("%s: %s is told something else:\n%s\nwas:\n%s", when, node, got, want)
		}
	}
}

// **The four words leave the settings layers and no machine is told anything new** (novox/hq ADR 0348 clause 11,
// issue 736). Every live layer that says `endpoints`, `expose`, `reach` or `ports` is seeded as the store holds it
// after delivery, on a module shaped as its definition is, and every machine's declaration is composed. What each
// is told is byte for byte what the controller before this change composed from the same seed.

// **And after the move, still nothing new** (issue 736). The move of placement, asked without confirming, says
// every layer that holds one of the four words and moves nothing; confirmed, it moves them all, no settings layer
// holds a placement key after, and each machine is told byte for byte what it was told before the move — and what
// the controller before this change told it. Asked again, it moves nothing.

// The verb's command line: a dry run unless confirmed, and a confirmed move says why, recorded as a person's step
// of the release, never a repair (issue 736).
func TestTheMoveOfPlacementIsADryRunUnlessConfirmed(t *testing.T) {
	for _, c := range []struct {
		args map[string]any
		want string
	}{
		{map[string]any{}, "move-placement --json"},
		{map[string]any{"confirm": "false"}, "move-placement --json"},
		{map[string]any{"confirm": "true", "why": "release 57 is delivered"}, "move-placement --json --confirm --why release 57 is delivered"},
	} {
		argv, err := argvFor("move-placement", c.args)
		if err != nil || strings.Join(argv, " ") != c.want {
			t.Errorf("%v: %q %v, want %q", c.args, argv, err, c.want)
		}
	}
	for _, args := range []map[string]any{
		{"confirm": "true"},            // a move without a why
		{"why": "tidy"},                // a why for a dry run, recorded nowhere
		{"confirm": "yes", "why": "x"}, // a switch is true or false
		{"node": "anchor"},
	} {
		if argv, err := argvFor("move-placement", args); err == nil {
			t.Errorf("%v was composed as %q", args, argv)
		}
	}
	if repairingCommand([]string{"move-placement", "--json", "--confirm", "--why", "x"}) != "move-placement" {
		t.Error("a confirmed move through the generic verb would go unrecorded")
	}
	if repairingCommand([]string{"move-placement", "--json"}) != "" {
		t.Error("a dry run was taken for an act by hand")
	}
	if !personsDecision(link.HandAct{Verb: "move-placement"}) {
		t.Error("a move of the release would count toward a healer the mesh lacks")
	}
}