mesh-tools/node-tools/internal/console/address_test.go

package console

import (
	"encoding/json"
	"fmt"
	"strings"
	"testing"
	"time"

	mt "github.com/novox/mesh-tools/node-tools/internal/meshtest"
	"github.com/novox/mesh-tools/node-tools/internal/runtime"
)

// text is a tool result's first text, and whether it was an error.
func text(t *testing.T, reply map[string]any) (string, bool) {
	t.Helper()
	result, ok := reply["result"].(map[string]any)
	if !ok {
		t.Fatalf("no result: %v", reply)
	}
	content := result["content"].([]any)
	isErr, _ := result["isError"].(bool)
	var parts []string
	for _, c := range content {
		parts = append(parts, c.(map[string]any)["text"].(string))
	}
	return strings.Join(parts, "\n"), isErr
}

func call(t *testing.T, endpoint, tool string, args map[string]any) (string, bool) {
	t.Helper()
	body, _ := json.Marshal(map[string]any{"jsonrpc": "2.0", "id": 9, "method": "tools/call",
		"params": map[string]any{"name": tool, "arguments": args}})
	return text(t, post(t, endpoint, string(body)))
}

// novox/hq ADR 0195: the console announces five tools, and everything the mesh answers is reached
// through them by one address per layer.
func TestTheMeshsToolsAreFoundByAddress(t *testing.T) {
	was := IndexKept
	IndexKept = 0 // every discovery asks the mesh, so a module arriving mid-test is found
	t.Cleanup(func() { IndexKept = was })

	mesh := mt.New(t)
	// alpha: interchangeable (the mesh issued it a plain subject); beta: state on its machine, holds
	// the node-shelf seat there.
	mesh.Issue(t, mt.MembershipOf("alpha", "desk", true, nil))
	mesh.Issue(t, mt.MembershipOf("beta", "desk", false, map[string][]string{"node-shelf": {"list", "clear"}}))
	nodeTools := connect(t, "node-tools", "desk")
	stop, err := runtime.Run(nodeTools, []runtime.Served{
		{Module: "alpha", Entrypoints: []string{mt.Fixture("many-alpha.serve.mjs")}},
		{Module: "beta", Entrypoints: []string{mt.Fixture("many-beta.serve.mjs")}},
	}, nil, (&mt.Logs{}).Logf)
	if err != nil {
		t.Fatal(err)
	}
	defer stop()

	catalogue := connect(t, "mesh-catalog", "")
	stopCat, _ := catalogue.Handle("catalog_modules", func(json.RawMessage) (any, error) {
		return map[string]any{"modules": []map[string]string{{"module": "alpha"}, {"module": "beta"}, {"module": "gamma"}}}, nil
	})
	defer stopCat()

	// The controller, answering as its seat verbs do: the command's printed output.
	controller := connect(t, "mesh-controller", "")
	out := func(s string) map[string]any { return map[string]any{"output": s, "ok": true} }
	serve := func(verb string, answer func() any) {
		stop, err := controller.HandleSubject("mesh.seat.mesh-controller.tool."+verb, func(json.RawMessage) (any, error) {
			return answer(), nil
		})
		if err != nil {
			t.Fatal(err)
		}
		t.Cleanup(stop)
	}
	serve("tools", func() any {
		return map[string]any{"seats": []map[string]any{
			{"seat": "mesh-controller", "scope": "mesh", "tools": []map[string]any{
				{"name": "nodes", "description": "Every machine the mesh knows.", "input": map[string]any{}}}},
			{"seat": "node-shelf", "scope": "node", "tools": []map[string]any{
				{"name": "list", "description": "what is on the shelf", "input": map[string]any{}},
				{"name": "clear", "description": "take it all off", "input": map[string]any{}}}},
		}}
	})
	serve("nodes", func() any {
		return out("bench                3m ago         converged 1f2e\ndesk                 here           converged 9a8b\n")
	})
	serve("seats", func() any {
		return out("a warning the command printed first\n" + `{
  "seats": [
    {"seat": "mesh-controller", "scope": "mesh", "decision": "x", "holders": [{"module": "mesh-controller", "node": "bench"}]},
    {"seat": "node-shelf", "scope": "node", "decision": "y", "holders": [{"module": "beta", "node": "desk"}]}
  ]
}`)
	})
	gammaOn := "nothing"
	serve("modules", func() any {
		return out(fmt.Sprintf("alpha              1        built 1a2b3c4d          on desk\n    needs container-runtime\n"+
			"beta               1        built 1a2b3c4d          on desk\n"+
			"gamma              1        built 1a2b3c4d          on %s\n", gammaOn))
	})
	catalogue.Flush()
	controller.Flush()

	up, err := Serve(NewSurface(nodeTools, "desk.node-tools"), "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	defer up.Close()
	endpoint := "http://" + up.Address + "/mcp"

	// Five tools, nothing else.
	listed := post(t, endpoint, `{"jsonrpc":"2.0","id":2,"method":"tools/list"}`)["result"].(map[string]any)
	var names []string
	for _, x := range listed["tools"].([]any) {
		name := x.(map[string]any)["name"].(string)
		names = append(names, name)
		for _, r := range name {
			if !(r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '_' || r == '-') || len(name) > 64 {
				t.Errorf("%q is not a name the API takes", name)
			}
		}
	}
	if got := strings.Join(names, ","); got != "mesh_overview,mesh_machine,mesh_search,mesh_describe,mesh_call" {
		t.Errorf("announced %s", got)
	}

	// The overview names the mesh's seats, the machines' seats and the machines.
	overview, isErr := call(t, endpoint, "mesh_overview", nil)
	if isErr || !strings.Contains(overview, "mesh-controller.nodes") || !strings.Contains(overview, "<node>/node-shelf.list") ||
		!strings.Contains(overview, `"bench"`) || !strings.Contains(overview, `"desk"`) {
		t.Errorf("overview: %s", overview)
	}
	machine, isErr := call(t, endpoint, "mesh_machine", map[string]any{"node": "desk"})
	if isErr || !strings.Contains(machine, "desk/node-shelf.list") || !strings.Contains(machine, "desk/beta.three") ||
		!strings.Contains(machine, "desk/alpha.one") {
		t.Errorf("machine: %s", machine)
	}

	// A mesh seat, a node seat, an assignment and an interchangeable module, each by address.
	if got, isErr := call(t, endpoint, "mesh_call", map[string]any{"address": "mesh-controller.nodes"}); isErr || !strings.Contains(got, "converged") {
		t.Errorf("mesh seat: %s", got)
	}
	if got, isErr := call(t, endpoint, "mesh_call", map[string]any{"address": "desk/node-shelf.list"}); isErr || !strings.Contains(got, `"a"`) {
		t.Errorf("node seat: %s", got)
	}
	if got, isErr := call(t, endpoint, "mesh_call", map[string]any{"address": "desk/beta.three"}); isErr ||
		!strings.Contains(got, `"beta": 3`) || !strings.Contains(got, "answered by desk") {
		t.Errorf("assignment: %s", got)
	}
	if got, isErr := call(t, endpoint, "mesh_call", map[string]any{"address": "alpha.one"}); isErr || !strings.Contains(got, `"alpha": 1`) {
		t.Errorf("interchangeable module: %s", got)
	}

	// Refused, by name, where the address does not say enough or says the wrong thing.
	for address, want := range map[string]string{
		"beta.three":                 "keeps state on each machine it runs on, so a call names the machine: write <node>/beta.three — it runs on desk",
		"node-shelf.list":            "held once per machine: write <node>/node-shelf.list — it is held on desk",
		"desk/mesh-controller.nodes": "held once for the whole mesh",
		"bench/beta.three":           "beta does not run on bench; it runs on desk",
		"nonsense":                   "is not an address",
	} {
		got, isErr := call(t, endpoint, "mesh_call", map[string]any{"address": address})
		if !isErr || !strings.Contains(got, want) {
			t.Errorf("%s: %s (want %q)", address, got, want)
		}
	}

	// Described without `node`: the address carries the machine.
	described, isErr := call(t, endpoint, "mesh_describe", map[string]any{"address": "desk/beta.three"})
	if isErr || strings.Contains(described, `"node"`) || !strings.Contains(described, `"address": "desk/beta.three"`) {
		t.Errorf("describe: %s", described)
	}

	// Search finds across the layers; a module that starts serving after the first answer is found.
	if got, _ := call(t, endpoint, "mesh_search", map[string]any{"query": "shelf"}); !strings.Contains(got, "desk/node-shelf.list") {
		t.Errorf("search a node seat: %s", got)
	}
	if got, _ := call(t, endpoint, "mesh_search", map[string]any{"query": "gamma"}); strings.Contains(got, "gamma.given") {
		t.Fatalf("gamma was found before it served: %s", got)
	}
	mesh.Issue(t, mt.MembershipOf("gamma", "desk", false, nil))
	gammaOn = "desk"
	late := connect(t, "node-tools", "desk")
	stopLate, err := runtime.Run(late, []runtime.Served{{Module: "gamma", Entrypoints: []string{mt.Fixture("env-gamma.serve.mjs")}}},
		nil, (&mt.Logs{}).Logf)
	if err != nil {
		t.Fatal(err)
	}
	defer stopLate()
	var found string
	for i := 0; i < 30; i++ {
		found, _ = call(t, endpoint, "mesh_search", map[string]any{"query": "gamma given"})
		if strings.Contains(found, "desk/gamma.given") {
			break
		}
		time.Sleep(100 * time.Millisecond)
	}
	if !strings.Contains(found, "desk/gamma.given") {
		t.Errorf("a module that arrived later was not found: %s", found)
	}

	// The old names still answer, unannounced.
	if got, isErr := call(t, endpoint, "alpha.one", nil); isErr || !strings.Contains(got, `"alpha": 1`) {
		t.Errorf("an old name: %s", got)
	}
}

func TestTheControllersPrintedListsAreRead(t *testing.T) {
	machines := machinesIn("the bus's user list leaves out 2 user(s)\nace                  2m ago         converged 0c1d\n" +
		"g14                  here           converged 77aa\nnovox                5s ago         adopted   3e4f\n")
	if got := strings.Join(machines, ","); got != "ace,g14,novox" {
		t.Errorf("machines: %s", got)
	}
	on := assignmentsIn("baserow            1        built 7c800705          on ace\n    requires postgres-database\n" +
		"confluence         1        built 7c800705          on nothing\n" +
		"mesh-wireguard     1        with the control plane  on ace, g14, novox, shanks\n")
	if strings.Join(on["baserow"], ",") != "ace" || len(on["confluence"]) != 0 || strings.Join(on["mesh-wireguard"], ",") != "ace,g14,novox,shanks" {
		t.Errorf("assignments: %v", on)
	}
}