jschoubben
54680238a0
Pins mesh-sdk bb993dd. The assignments stream stays the membership's fallback until the lease write; a log another module keeps is read as <module>.<log>.
235 lines
10 KiB
Go
235 lines
10 KiB
Go
package console
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-tools/node-tools/internal/announce"
|
|
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 and ADR 0367: the console announces seven tools, and everything the mesh answers is reached
|
|
// through them by one address per layer.
|
|
func TestTheMeshsToolsAreFoundByAddress(t *testing.T) {
|
|
mt.NeedBundles(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()
|
|
|
|
// Nothing may be asked for a roster or a module's `tools` any more (ADR 0197): counted.
|
|
var asked atomic.Int32
|
|
watcher := connect(t, "watcher", "")
|
|
for _, subject := range []string{"mesh.mod.*.tool.tools", "mesh.mod.*.tool.tools.*", "mesh.mod.mesh-catalog.>"} {
|
|
stop, err := watcher.Raw(subject, func(string, []byte) []byte { asked.Add(1); return nil })
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(stop)
|
|
}
|
|
|
|
// The controller: its own seat's verbs announced on the bus like every runtime's; its records are asked by no one.
|
|
controller := connect(t, "mesh-controller", "bench")
|
|
// Its verb nodes, called through the console as any seat's verb is.
|
|
stopNodes, err := controller.HandleSubject("mesh.seat.mesh-controller.tool.nodes", func(json.RawMessage) (any, error) {
|
|
return map[string]any{"ok": true, "output": `[{"name":"bench","mode":"converged"},{"name":"desk","mode":"converged"}]`}, nil
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(stopNodes)
|
|
// What the mesh holds, as the indexer and placement write it (ADR 0571 clauses 4, 5): never the controller's records.
|
|
tools := map[string][]string{"alpha": {"one", "two"}, "beta": {"three"}, "gamma": {"given"}, "delta": nil,
|
|
"epsilon": {"seven"}, "mesh-controller": {"nodes"}}
|
|
mesh.Placed(t, tools, map[string][]string{"desk": {"alpha", "beta", "delta"}, "bench": {"epsilon", "mesh-controller"}})
|
|
console := mt.MembershipOf("node-tools", "desk", false, nil)
|
|
console.State = mt.ConsoleReads()
|
|
mesh.Issue(t, console)
|
|
mt.Until(t, func() error {
|
|
if m := nodeTools.Membership("node-tools"); m == nil || len(m.State) == 0 {
|
|
return fmt.Errorf("the console's reads are not issued yet")
|
|
}
|
|
return nil
|
|
})
|
|
stopAnn, err := announce.Serve(controller, announce.Service{Name: "mesh-controller", ID: "bench"}, func() []announce.Endpoint {
|
|
return []announce.Endpoint{{Kind: announce.KindSeat, Module: "mesh-controller", Seat: "mesh-controller", Scope: "mesh",
|
|
// As the live controller announces: a mesh seat's holder names no machine.
|
|
Tool: "nodes", Node: "", Description: "Every machine the mesh knows.", Schema: json.RawMessage(`{}`),
|
|
Subject: "mesh.seat.mesh-controller.tool.nodes"}}
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(stopAnn)
|
|
controller.Flush()
|
|
watcher.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"
|
|
|
|
// Seven tools, nothing else (ADR 0367).
|
|
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,mesh_runtimes,mesh_wait" {
|
|
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)
|
|
}
|
|
// Silence is named only where tools should have answered: epsilon declares tools on bench and
|
|
// nothing there announced it; delta declares none and is never a name.
|
|
if strings.Contains(overview, "mesh-controller on bench") {
|
|
t.Errorf("a mesh seat's holder that announced no machine is called silent on its machine:\n%s", overview)
|
|
}
|
|
if !strings.Contains(overview, "epsilon on bench") || strings.Contains(overview, "delta") {
|
|
t.Errorf("not answering: %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)
|
|
}
|
|
}
|
|
|
|
// Discovery itself asked nothing but the bus.
|
|
if n := asked.Load(); n != 0 {
|
|
t.Errorf("discovery asked a roster or a module's tools %d time(s); it asks the bus", n)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
// Its schema, which discovery no longer carries for a module's tool, asked of the runtime serving it.
|
|
if !strings.Contains(described, `"verbose"`) {
|
|
t.Errorf("describe lost the tool's arguments: %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))
|
|
mesh.Placed(t, tools, map[string][]string{"desk": {"alpha", "beta", "delta", "gamma"}, "bench": {"epsilon", "mesh-controller"}})
|
|
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)
|
|
}
|
|
|
|
// Only describing a module's tool asks its runtime — once, for the schema discovery no longer carries
|
|
// (2026-10-04: every tool's schema made a machine's discovery answer outgrow the bus).
|
|
if n := asked.Load(); n != 1 {
|
|
t.Errorf("asked a module's tools %d time(s); describing one tool asks once, and discovery never", n)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
}
|