mesh-controller/cmd/mesh-controller/placement_moved_test.go

//go:build integration

package main

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

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

// **Placement leaves the settings layers and no machine is told anything new** (novox/hq ADR 0348 clause
// 11, issue 651). A mesh is seeded as the store holds it before migration 0097 — `places`, `accesses` and a
// kept network among the settings, at the mesh's level and a machine's, one layer of placement only — then
// migrated, and every machine's declaration is composed. What each machine is told of the seeded modules is
// byte for byte what the controller before this change composed from the same seed: the golden files were
// written by the integration branch's controller at bfc79c6 running this same test (MESH_WRITE_GOLDEN=1),
// where there was no migration 0097 to run.
func TestADeclarationIsTheSameAfterPlacementMoves(t *testing.T) {
	open, migrate := aMeshBefore(t, 97)
	ctx := t.Context()
	inv := open.inventory
	image := "registry.invalid:5000/library@sha256:" + strings.Repeat("a", 64)
	register(t, open, catalogue.Manifest{Module: "library", Version: "1",
		Accesses: []catalogue.Access{{ID: "series"}, {ID: "downloads", Mode: catalogue.AccessRead}},
		Resources: []map[string]any{
			{"id": "config", "type": "directory", "mode": "0750"},
			{"id": "server", "type": "container", "image": image,
				"volumes": []any{"${dir:config}:/config", "${access:series}:/series", "${access:downloads}:/downloads:ro"}},
			// Today's form: a mergeable file naming no keys takes every key of the layer (ADR 0326 §3).
			{"id": "runtime-config", "type": "file", "path": "${dir:config}/runtime.json", "mode": "0640",
				"content": `{"log":"info"}`, "merge": "json"},
		}})
	register(t, open, catalogue.Manifest{Module: "found", Version: "1",
		Resources: []map[string]any{{"id": "server", "type": "container", "image": image}}})
	if err := inv.SetAdopted(ctx, "anchor", true); err != nil {
		t.Fatal(err)
	}
	for _, l := range []struct{ node, module, values string }{
		{"", "library", `{"accesses": {"downloads": "/storage/downloads"}, "log": "warn"}`},
		{"anchor", "library", `{"places": {"config": {"path": "/var/lib/library/config", "owner": "1001:2000"}},
			"accesses": {"series": "/storage/media/series"}, "workers": 4}`},
		{"laptop", "library", `{"accesses": {"series": "/home/media/series"}}`},
		{"anchor", "found", `{"networks": {"server": ["predecessor_default"]}}`},
	} {
		if l.node == "" {
			inv.ExecForTest(t, `insert into settings (node, module, values) values (null, $1, $2)`, l.module, l.values)
			continue
		}
		inv.ExecForTest(t, `insert into settings (node, module, values) select id, $2, $3 from node where name = $1`,
			l.node, l.module, l.values)
	}

	migrate()
	// Assigned once the store is migrated: an assignment reads the layers, as this controller holds them.
	for _, a := range [][]string{{"anchor", "library", "found"}, {"laptop", "library"}} {
		if _, err := assign(ctx, open, a[0], a[1:]...); err != nil {
			t.Fatalf("assign %v: %v", a, err)
		}
	}

	for _, node := range []string{"anchor", "laptop"} {
		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)
		}
		var told []map[string]any
		for _, r := range composed.Resources {
			if owner := composed.Owner[r["id"].(string)]; owner == "library" || owner == "found" {
				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(told, "", "  ")
		if err != nil {
			t.Fatal(err)
		}
		golden := filepath.Join("testdata", "placement-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, append(got, '\n'), 0o644); err != nil {
				t.Fatal(err)
			}
			continue
		}
		want, err := os.ReadFile(golden)
		if err != nil {
			t.Fatal(err)
		}
		if string(want) != string(got)+"\n" {
			t.Errorf("%s is told something else after placement moved:\n%s\nwas:\n%s", node, got, want)
		}
	}
}