mesh-controller/cmd/mesh-controller/compose_sdk_test.go

package main

import (
	"context"
	"reflect"
	"strings"
	"testing"

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

// A declaration as the SDK composes it is the one the controller sends, byte for byte, whatever it carries: the body is the
// envelope's only marshaller on either side (design 47 R4b, issue 1386).
func TestASendableIsTheComposedDeclarationByteForByte(t *testing.T) {
	d := compose.Declared{
		Resources: []map[string]any{{"id": "files.config", "type": "file"}, {"id": "mesh.hosts", "type": "file"}},
		Sequence:  7, Epoch: 3, Generation: 9, ReadsModules: true,
		ModuleOf: map[string]string{"files.config": "files"}, BuildIDs: map[string]string{"files": "b-1"},
		Adoption: &compose.Adoption{Taken: []string{"files"}, Untaken: map[string][]string{"nats": {"nats.server"}}},
		Filled:   []string{"/etc/files/filled.json"}, Provisioner: "mesh-provisioner",
		LeftOut: []string{"cache"}, LeftOutWhy: map[string]string{"cache": "a setting cannot compose"},
	}
	want, err := d.Body()
	if err != nil {
		t.Fatal(err)
	}
	got, err := sendableOf(d).Body()
	if err != nil {
		t.Fatal(err)
	}
	if string(got) != string(want) {
		t.Fatalf("the controller would send\n%s\nand the composition made\n%s", got, want)
	}
	if empty, err := sendableOf(compose.Declared{}).Body(); err != nil || !strings.Contains(string(empty), `"owns_nothing":true`) {
		t.Fatalf("an empty declaration is not deliberate: %s %v", empty, err)
	}
}

// 1386: what a send records as carried: the current build of each module it carries, the build a module left out of it was last
// sent (when that is known), and a module kept at the build the machine runs at that one. (The controller's carriedOn recorded
// the same; mesh-sdk's node_test TestAModuleLeftOutKeepsTheBuildItWasLastSent holds the left-out case.)
func TestWhatASendRecordsAsCarriedIsWhatTheControllerRecorded(t *testing.T) {
	plan := catalogue.Resolution{Modules: []catalogue.Manifest{{Module: "postgres"}, {Module: "files"}, {Module: "cache"}}}
	leftOut := map[string]string{"cache": "a setting cannot compose"}
	for name, c := range map[string]struct {
		sent  map[string]string
		known bool
		kept  map[string]string
		want  map[string]string
	}{
		"nothing sent": {want: map[string]string{"postgres": "p2", "files": "f2"}},
		"sent and kept": {sent: map[string]string{"postgres": "p1", "cache": "c1", "files": "f1"}, known: true,
			kept: map[string]string{"postgres": "p1"}, want: map[string]string{"postgres": "p1", "files": "f2", "cache": "c1"}},
		"sent but not known":   {sent: map[string]string{"cache": "c1"}, want: map[string]string{"postgres": "p2", "files": "f2"}},
		"kept a module not in": {known: true, kept: map[string]string{"mail": "m1"}, want: map[string]string{"postgres": "p2", "files": "f2"}},
	} {
		in := compose.Input{CurrentBuilds: map[string]string{"postgres": "p2", "files": "f2", "cache": "c2"}}
		node := compose.Node{SentBuilds: c.sent, SentKnown: c.known, KeptBuilds: c.kept}
		if got := buildsOf(in, node, plan, leftOut); !reflect.DeepEqual(got, c.want) {
			t.Errorf("%s: a send records %v, want %v", name, got, c.want)
		}
	}
}

// 1385: a declaration that stands in for a value anywhere is still foreseen, in a list the composition names or in the body
// alone (a pair credential's stand-in is in no list); one that stands in for nothing is not. It failed first, before the body
// was scanned.
func TestADeclarationThatStandsInForAValueIsStillForeseen(t *testing.T) {
	clean := compose.Declared{Resources: []map[string]any{{"id": "files.config", "type": "file", "content": "ok"}}}
	if left := stillForeseen(clean); len(left) != 0 {
		t.Fatalf("a declaration that stands in for nothing is foreseen: %v", left)
	}
	for name, d := range map[string]compose.Declared{
		"an own secret":     {StoodIn: []string{"files/admin"}},
		"a port":            {ForeseenPorts: []string{"files:80"}},
		"a core box":        {CoreBoxesWanted: []compose.CoreBoxWanted{{Node: "anchor", Module: "mesh-vault", Name: "root"}}},
		"a pass of a seat":  {Passes: compose.Passes{Passes: []catalogue.SeatPass{{Seat: catalogue.Seat{Name: "mesh-store"}}}}},
		"a pair credential": {Resources: []map[string]any{{"id": "files.needs-db", "sealed": catalogue.ForeseenSealed}}},
		"the certificate":   {Resources: []map[string]any{{"id": "proxy.cert", "content": compose.ForeseenCertificate}}},
		"the bus's list":    {Resources: []map[string]any{{"id": "nats.users", "content": compose.ForeseenBusUsers}}},
		"the vault's box":   {Resources: []map[string]any{{"id": "x", "box": catalogue.ForeseenVaultBox}}},
	} {
		if left := stillForeseen(d); len(left) == 0 {
			t.Errorf("%s: a declaration that stands in for it is not foreseen", name)
		}
	}
}

// 1386: an Input read for a person's push is never the one read for a send that keeps recorded builds, and the cache is
// emptied by what a send made.
func TestAnInputIsCachedPerWhatItKeepsAndForgottenAfterASend(t *testing.T) {
	ctx := withInputCache(context.Background())
	plain := keptSignature(ctx)
	kept := keptSignature(keepingRecorded(ctx))
	bus := keptSignature(keepingRecorded(ctx, "nats"))
	every := keptSignature(keepingEveryBuild(ctx, "anchor"))
	for name, sig := range map[string]string{"a push": plain, "a kept send": kept, "the bus step": bus, "the grants step": every} {
		for other, o := range map[string]string{"a push": plain, "a kept send": kept, "the bus step": bus, "the grants step": every} {
			if name != other && sig == o {
				t.Errorf("%s and %s read the same Input", name, other)
			}
		}
	}
	cache := ctx.Value(inputCacheKey{}).(*inputCache)
	cache.by[plain] = &meshInput{}
	forgetInput(ctx)
	if len(cache.by) != 0 {
		t.Fatal("what a send made left the Input it read in the cache")
	}
}