mesh-host/internal/compose/resolution/setting_into_test.go

package resolution

import (
	"errors"
	"strings"
	"testing"

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

// A config value reaches a resource from the assignment's layers, the node's over the mesh's (novox/hq ADR 0112,
// ADR 0155), and a value nothing set is refused by name; and a resource under `if-config` is declared only while a
// config value holds (design 42 zfs-owns-zfs §2, ADR 0679 §16 (b)). One table of the two, each row its layers, what it
// does to a resource and what comes of it.
func TestAConfigValueReachesAResourceAndDecidesWhetherItIsDeclared(t *testing.T) {
	filled := func(content string) func([]mcat.Layer) (string, error) {
		return func(layers []mcat.Layer) (string, error) {
			file := map[string]any{"id": "env", "type": "file", "path": "/x/mail.env", "content": content}
			err := settingInto(file, layers, "mail")
			return file["content"].(string), err
		}
	}
	// declared is the ids of what is left of a resource under each condition, and whether the key is gone from it.
	declared := func(conditions ...any) func([]mcat.Layer) (string, error) {
		return func(layers []mcat.Layer) (string, error) {
			kept := withoutUnconfigured([]map[string]any{
				{"id": "plain", "type": "file"}, {"id": "cond", "type": "file", mcat.IfConfigField: conditions}}, layers)
			var ids []string
			for _, r := range kept {
				if _, has := r[mcat.IfConfigField]; has {
					return "", errKeyKept
				}
				ids = append(ids, r["id"].(string))
			}
			return strings.Join(ids, ","), nil
		}
	}
	values := func(kv map[string]any) []mcat.Layer { return []mcat.Layer{{From: "the mesh", Values: kv}} }
	for _, row := range []struct {
		name   string
		layers []mcat.Layer
		do     func([]mcat.Layer) (string, error)
		want   string   // what comes of it
		errs   []string // or what the refusal says
	}{
		{"the node's layer over the mesh's", []mcat.Layer{
			{From: "the mesh", Values: map[string]any{"domain": "example.tld", "sitename": "Mesh", "workers": float64(4)}},
			{From: "this node", Values: map[string]any{"sitename": "This one"}}},
			filled("DOMAIN=${setting:domain}\nSITENAME=${setting:sitename}\nWORKERS=${setting:workers}\n"),
			"DOMAIN=example.tld\nSITENAME=This one\nWORKERS=4\n", nil},
		{"a value nothing set is refused, the file left as it was", values(map[string]any{"other": "x"}),
			filled("DOMAIN=${setting:domain}\n"), "DOMAIN=${setting:domain}\n",
			[]string{"${setting:domain}", "settings set mail", "set today: other"}},
		{"if-config: a key never set leaves it out", nil, declared("k"), "plain", nil},
		{"if-config: a key set to text declares it", values(map[string]any{"k": "x"}), declared("k"), "plain,cond", nil},
		{"if-config: a key set to false, off, none, empty or an empty list leaves it out", values(map[string]any{"k": false}),
			declared("k"), "plain", nil},
		{"if-config: off", values(map[string]any{"k": "off"}), declared("k"), "plain", nil},
		{"if-config: none", values(map[string]any{"k": "none"}), declared("k"), "plain", nil},
		{"if-config: empty text", values(map[string]any{"k": ""}), declared("k"), "plain", nil},
		{"if-config: an empty list", values(map[string]any{"k": []any{}}), declared("k"), "plain", nil},
		{"if-config: a list of entries", values(map[string]any{"k": []any{"a"}}), declared("k"), "plain,cond", nil},
		{"if-config: a value equal to the condition", values(map[string]any{"k": "on"}), declared("k=on"), "plain,cond", nil},
		{"if-config: a value other than the condition", values(map[string]any{"k": "off"}), declared("k=on"), "plain", nil},
		{"if-config: a list holding the entry", values(map[string]any{"k": []any{"a", "b"}}), declared("k=b"), "plain,cond", nil},
		{"if-config: a list without the entry", values(map[string]any{"k": []any{"a"}}), declared("k=b"), "plain", nil},
		{"if-config: any of the conditions", values(map[string]any{"j": "x"}), declared("k", "j"), "plain,cond", nil},
		{"if-config: a value from a default layer", []mcat.Layer{{Default: true, Values: map[string]any{"k": "on"}}},
			declared("k=on"), "plain,cond", nil},
		{"if-config: a number equal to the condition", values(map[string]any{"k": float64(64)}), declared("k=64"), "plain,cond", nil},
	} {
		t.Run(row.name, func(t *testing.T) {
			got, err := row.do(row.layers)
			if len(row.errs) == 0 && err != nil {
				t.Fatal(err)
			}
			if len(row.errs) > 0 && err == nil {
				t.Fatalf("a refusal was expected, got %q", got)
			}
			for _, want := range row.errs {
				if !strings.Contains(err.Error(), want) {
					t.Fatalf("the refusal lacks %q: %v", want, err)
				}
			}
			if got != row.want {
				t.Fatalf("got %q, want %q", got, row.want)
			}
		})
	}
}

// errKeyKept is what a row of the table above says when `if-config` reached the node-engine, which parses strictly.
var errKeyKept = errors.New("the if-config key was kept in a declared resource")

// The composition takes a resource out while its condition does not hold, and a value going from set to unset takes it
// out of the next composition, which the node-engine removes as it removes any resource that left (design 42 §2).
func TestAConfigConditionedResourceIsComposedWhileItsValueHolds(t *testing.T) {
	m := mustParse(t, `{"module":"zfs","version":"1","config":{"zed":{"type":"string","default":"off"}},"resources":[
		{"id":"conf","type":"file","path":"/etc/zfs/mesh.conf","content":"x\n"},
		{"id":"zed","type":"file","path":"/etc/zfs/zed.rc","content":"y\n","if-config":["zed=on"]}]}`)
	for _, row := range []struct {
		layers []mcat.Layer
		zed    bool
	}{{nil, false}, {[]mcat.Layer{{From: "this node", Values: map[string]any{"zed": "on"}}}, true}} {
		out, err := Declaration(mcat.Resolution{Node: "workstation", Modules: []mcat.Manifest{m}},
			mcat.Rendering{Settings: mcat.SettingsBy{"zfs": row.layers}})
		if err != nil {
			t.Fatal(err)
		}
		if fileNamed(out, "zfs.conf") == nil {
			t.Error("the unconditioned file was left out")
		}
		zed := fileNamed(out, "zfs.zed")
		if (zed != nil) != row.zed {
			t.Errorf("with %v the conditioned file is declared: %v, want %v", row.layers, zed != nil, row.zed)
		}
		if _, has := zed[mcat.IfConfigField]; has {
			t.Errorf("%s reached the node-engine, which parses strictly", mcat.IfConfigField)
		}
	}
}