Feature 57 (config and provisioning): release mesh-tools (the provider's StateBus, the SDK pin, templates), reviewed

node-tools/internal/runtime/provision_test.go

@@ -0,0 +1,203 @@
+package runtime
+
+import (
+	"encoding/json"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/nats-io/nats.go"
+
+	mt "github.com/novox/mesh-tools/node-tools/internal/meshtest"
+)
+
+// A module's code reads its values at runtime through moduleBus.Provision and ProvisionWatch (novox/hq ADR 0349
+// §14, ADR 0370, issue 685), against a real bus with a stand-in for the machine's provisioner client: the runtime
+// asks as the module whose bundle asks, whatever the bundle names; a watch hands the current value, then each change
+// the client says moved, and a refusal once; a secret is refused without asking.
+
+// standInClient answers prov.ask.<node> from its values, keyed `<module>.<kind>.<key>`, and keeps every ask.
+type standInClient struct {
+	mu     sync.Mutex
+	values map[string]string
+	asks   []string
+	nc     *nats.Conn
+}
+
+func aStandInClient(t *testing.T, node string, values map[string]string) *standInClient {
+	t.Helper()
+	nc, err := nats.Connect(mt.URL(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(nc.Close)
+	c := &standInClient{values: values, nc: nc}
+	if _, err := nc.Subscribe("prov.ask."+node, func(m *nats.Msg) {
+		var a struct{ Module, Kind, Key string }
+		_ = json.Unmarshal(m.Data, &a)
+		c.mu.Lock()
+		c.asks = append(c.asks, string(m.Data))
+		v, ok := c.values[a.Module+"."+a.Kind+"."+a.Key]
+		c.mu.Unlock()
+		if !ok {
+			_ = m.Respond([]byte(`{"error":"` + a.Module + ` declares no config value ` + a.Key + `"}`))
+			return
+		}
+		_ = m.Respond([]byte(`{"value":` + v + `}`))
+	}); err != nil {
+		t.Fatal(err)
+	}
+	_ = nc.Flush()
+	return c
+}
+
+func (c *standInClient) set(key, value string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if value == "" {
+		delete(c.values, key)
+		return
+	}
+	c.values[key] = value
+}
+
+func (c *standInClient) asked() []string {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return append([]string(nil), c.asks...)
+}
+
+func (c *standInClient) say(t *testing.T, node, module, body string) {
+	t.Helper()
+	if err := c.nc.Publish("prov.changed."+node+"."+module, []byte(body)); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestABundleAsksForItsValuesAsItsOwnModule(t *testing.T) {
+	client := aStandInClient(t, "anchor", map[string]string{
+		"claude-code.config.managed_settings": `{"spinnerTipsEnabled":false}`,
+		"dunst.config.managed_settings":       `"dunst's"`,
+	})
+	conn := connect(t, "node-tools", "anchor")
+	all := &consumers{conn: conn, logf: t.Logf, of: map[string]*moduleEvents{}}
+	b := all.forModule("claude-code").(*moduleBus)
+
+	// Its own value, though the bundle names another module: the runtime names the module from the bundle.
+	got, err := b.Provision("get", json.RawMessage(`{"kind":"config","key":"managed_settings","module":"dunst"}`))
+	if err != nil || string(got) != `{"spinnerTipsEnabled":false}` {
+		t.Fatalf("answered %s, %v", got, err)
+	}
+	if asks := client.asked(); len(asks) != 1 || asks[0] != `{"key":"managed_settings","kind":"config","module":"claude-code"}` {
+		t.Fatalf("the client was asked %v", asks)
+	}
+	// The client's refusal, in its words.
+	if _, err := b.Provision("get", json.RawMessage(`{"kind":"config","key":"nothing"}`)); err == nil ||
+		!strings.Contains(err.Error(), "declares no config value nothing") {
+		t.Errorf("an undeclared key: %v", err)
+	}
+	// A secret, refused here and never asked; and what is not an ask.
+	before := len(client.asked())
+	for params, want := range map[string]string{
+		`{"kind":"secret","key":"gitea-read"}`: "the vault hands a secret only to a caller the bus proves",
+		`{"kind":"setting","key":"role"}`:      "not a kind of value",
+		`{"key":"role"}`:                       "names no value",
+	} {
+		if _, err := b.Provision("get", json.RawMessage(params)); err == nil || !strings.Contains(err.Error(), want) {
+			t.Errorf("%s: %v, want %q", params, err, want)
+		}
+	}
+	if _, err := b.ProvisionWatch(json.RawMessage(`{"kind":"secret","key":"gitea-read"}`), func(json.RawMessage) error {
+		return nil
+	}); err == nil {
+		t.Error("a secret was watched")
+	}
+	if n := len(client.asked()); n != before {
+		t.Errorf("the client was asked for what the runtime refuses: %v", client.asked()[before:])
+	}
+}
+
+func TestABundlesWatchIsHandedTheValueAndEachChange(t *testing.T) {
+	client := aStandInClient(t, "anchor", map[string]string{"claude-code.config.managed_settings": `{"a":1}`})
+	conn := connect(t, "node-tools", "anchor")
+	all := &consumers{conn: conn, logf: t.Logf, of: map[string]*moduleEvents{}}
+	t.Cleanup(all.stopAll)
+	b := all.forModule("claude-code").(*moduleBus)
+
+	handed := make(chan ProvisionChange, 16)
+	stop, err := b.ProvisionWatch(json.RawMessage(`{"kind":"config","key":"managed_settings","module":"dunst"}`),
+		func(raw json.RawMessage) error {
+			var c ProvisionChange
+			if err := json.Unmarshal(raw, &c); err != nil {
+				t.Errorf("handed %s", raw)
+			}
+			handed <- c
+			return nil
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	next := func(what string) ProvisionChange {
+		t.Helper()
+		select {
+		case c := <-handed:
+			return c
+		case <-time.After(5 * time.Second):
+			t.Fatalf("nothing handed: %s", what)
+		}
+		return ProvisionChange{}
+	}
+	nothing := func(what string) {
+		t.Helper()
+		select {
+		case c := <-handed:
+			t.Errorf("%s: handed %+v", what, c)
+		case <-time.After(300 * time.Millisecond):
+		}
+	}
+	if c := next("the current value"); string(c.Value) != `{"a":1}` || c.Kind != "config" || c.Key != "managed_settings" {
+		t.Fatalf("first handed %+v", c)
+	}
+
+	// A change, said by the client: asked again, handed.
+	client.set("claude-code.config.managed_settings", `{"a":2}`)
+	client.say(t, "anchor", "claude-code", `{"kind":"config","key":"managed_settings"}`)
+	if c := next("the change"); string(c.Value) != `{"a":2}` {
+		t.Fatalf("after the change, handed %+v", c)
+	}
+	// Every key of the kind said to have moved, the value the same: nothing handed. Another module's or another
+	// key's word: not even asked.
+	client.say(t, "anchor", "claude-code", `{"kind":"config"}`)
+	nothing("the same value again")
+	before := len(client.asked())
+	client.say(t, "anchor", "dunst", `{"kind":"config","key":"managed_settings"}`)
+	client.say(t, "anchor", "claude-code", `{"kind":"config","key":"role"}`)
+	nothing("another's word")
+	if n := len(client.asked()); n != before {
+		t.Errorf("asked again for another's word: %v", client.asked()[before:])
+	}
+	// No longer answered: handed the refusal, once.
+	client.set("claude-code.config.managed_settings", "")
+	client.say(t, "anchor", "claude-code", `{"kind":"config"}`)
+	if c := next("the refusal"); c.Refused == "" || len(c.Value) != 0 {
+		t.Fatalf("handed %+v, want the refusal", c)
+	}
+	client.say(t, "anchor", "claude-code", `{"kind":"config"}`)
+	nothing("the same refusal again")
+	// Answered again, and then stopped: nothing after.
+	client.set("claude-code.config.managed_settings", `{"a":3}`)
+	client.say(t, "anchor", "claude-code", `{"kind":"config"}`)
+	if c := next("answered again"); string(c.Value) != `{"a":3}` {
+		t.Fatalf("handed %+v", c)
+	}
+	stop()
+	client.set("claude-code.config.managed_settings", `{"a":4}`)
+	client.say(t, "anchor", "claude-code", `{"kind":"config"}`)
+	nothing("a stopped watch")
+	for _, a := range client.asked() {
+		if !strings.Contains(a, `"module":"claude-code"`) {
+			t.Errorf("asked as another module: %s", a)
+		}
+	}
+}