mesh-catalog/modules/nats/cmd/nats-tools/broker_test.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
	"testing"

	stdio "git.novox.be/novox/mesh-sdk/go"
	"git.novox.be/novox/mesh-sdk/go/catalogue"

	"nats-tools/internal/keeper"
)

// The seat's reading verbs and nats_history (design 25 § 12.3; CAT-N7): list and show answer every entry the keeper
// made with its settings asked and held and its fill against its cap; check names what is missing or differs; orphans
// what no manifest asks for; history one entry's events in order. Each from the keeper's own state and the bus's
// monitoring endpoint.
func TestTheSeatsReadingVerbsAnswerFromTheKeeperAndTheBus(t *testing.T) {
	plan := func(local, storage, template string, options string) keeper.Plan {
		e := catalogue.BusStateEntry{Name: local, Storage: storage, Template: template}
		if options != "" {
			_ = json.Unmarshal([]byte(options), &e.Options)
		}
		p, err := keeper.PlanOf("m", e)
		if err != nil {
			t.Fatal(err)
		}
		return p
	}
	held := map[string]keeper.Asked{"m": {Module: "m", Made: map[string]keeper.Made{
		"drafts": {Plan: plan("drafts", "key-value", "state", ""), Created: true},
		"log":    {Plan: plan("log", "stream", "log", `{"max-mib":16}`), Created: true, Drift: "m_log: max-bytes asked 16777216, held 33554432"},
		"old":    {Plan: plan("old", "stream", "events", ""), Created: true, Orphaned: true},
		"later":  {Plan: plan("later", "key-value", "state", ""), Waiting: "a grant not composed yet"},
	}}}
	jsz := `{"account_details":[{"stream_detail":[
	 {"name":"KV_m_drafts","config":{"name":"KV_m_drafts","retention":"limits","discard":"new","max_bytes":67108864,"max_msgs_per_subject":1,"max_msg_size":262144},"state":{"messages":3,"bytes":1048576}},
	 {"name":"OBJ_m_drafts-objects","config":{"name":"OBJ_m_drafts-objects","retention":"limits","discard":"new","max_bytes":16777216},"state":{"messages":0,"bytes":0}},
	 {"name":"m_log","config":{"name":"m_log","retention":"limits","discard":"new","max_bytes":33554432,"max_msg_size":262144},"state":{"messages":9,"bytes":9000}}]}]}`
	tools := map[string]stdio.Tool{}
	for _, tl := range brokerTools(func() (map[string]keeper.Asked, error) { return held, nil },
		func() (keeper.Status, error) {
			return keeper.Status{Limits: keeper.Limits{AccountBytes: 2048 << 20, ServerBytes: 4096 << 20}, OldBytes: 256 << 20}, nil
		},
		func() ([]byte, error) { return []byte(jsz), nil },
		func(module, local string, limit int) ([]keeper.Event, error) {
			return []keeper.Event{{Module: module, Local: local, Why: "first"}, {Module: module, Local: local, Why: "second"}}[:limit], nil
		}) {
		tools[tl.Name] = tl
	}
	for _, row := range []struct {
		tool string
		args map[string]any
		want []string
		err  string
	}{
		// Each answers the seat's contract (mesh-contracts meshbroker ListAnswer, Held, CheckAnswer, OrphansAnswer).
		{"mesh-broker.list", nil, []string{`"entries":[`, `"bus-name":"m_drafts"`, `"local-name":"drafts"`, `"storage-type":"key-value"`,
			`"KV_m_drafts":{"max-bytes":67108864`, `"fill":{"bytes":1048576,"cap":83886080,"count":3}`, `"options":{"max-mib":16}`,
			// The binding of an entry the bus holds is the one its created carries (design 25 bindings-first-view §2).
			`"binding":{"bucket":"m_drafts","local":"drafts","objects":"m_drafts-objects","storage":"key-value","template":"state"}`}, ""},
		// The sum of the caps against both limits (design 47 G §547, §591): drafts 64+16, log 16, old 1024 (orphaned, still
		// held), and the old sections the catalog graph's entries declare, 256; later is not made.
		{"mesh-broker.list", nil, []string{`"caps":{"account-limit-mib":2048,"server-limit-mib":4096,"sum-mib":1376`}, ""},
		{"mesh-broker.show", map[string]any{"module": "m", "local-name": "log"}, []string{`"bus-name":"m_log"`, `"template":"log"`,
			`"m_log":{"max-bytes":33554432`}, ""},
		{"mesh-broker.show", map[string]any{"module": "m", "local-name": "later"}, []string{`"local-name":"later"`}, ""},
		{"mesh-broker.show", map[string]any{"module": "m", "local-name": "none"}, nil, `made no entry "none" of "m"`},
		{"mesh-broker.check", nil, []string{`{"differences":[{`, `"local-name":"log"`, `"asked":{"m_log":{"max-bytes":16777216`,
			`"held":{"m_log":{"max-bytes":33554432`}, ""},
		{"mesh-broker.check", map[string]any{"module": "x"}, []string{`{"differences":[]}`}, ""},
		{"mesh-broker.orphans", nil, []string{`{"entries":[{`, `"local-name":"old"`}, ""},
		{"nats_history", map[string]any{"module": "m", "local": "log", "limit": float64(1)}, []string{`"why":"first"`}, ""},
		{"nats_history", map[string]any{"module": "m"}, nil, "names one entry"},
	} {
		t.Run(fmt.Sprintf("%s %v", row.tool, row.args), func(t *testing.T) {
			args := row.args
			if args == nil {
				args = map[string]any{}
			}
			out, err := tools[row.tool].Run(args)
			if row.err != "" {
				if err == nil || !strings.Contains(err.Error(), row.err) {
					t.Fatalf("answered %v (%v): refused, naming %q", out, err, row.err)
				}
				return
			}
			raw, _ := json.Marshal(out)
			for _, w := range row.want {
				if !strings.Contains(string(raw), w) {
					t.Errorf("%s lacks %s", raw, w)
				}
			}
			// list's binding is, field by field, the binding the entry's created carries (the event's body takes the plan's binding whole).
			if row.tool == "mesh-broker.list" {
				var got struct {
					Entries []struct {
						Local   string         `json:"local-name"`
						Binding map[string]any `json:"binding"`
					} `json:"entries"`
				}
				var created map[string]any
				wire, _ := json.Marshal(held["m"].Made["drafts"].Plan.Binding)
				_ = json.Unmarshal(raw, &got)
				_ = json.Unmarshal(wire, &created)
				for _, e := range got.Entries {
					if e.Local == "drafts" && !reflect.DeepEqual(e.Binding, created) {
						t.Errorf("list names the binding %v for drafts, its created carries %v", e.Binding, created)
					}
				}
			}
			// An entry the bus does not hold has no binding.
			if row.args["local-name"] == "later" && strings.Contains(string(raw), `"binding"`) {
				t.Errorf("show names a binding for later, whose objects the bus does not hold: %s", raw)
			}
			if row.tool == "mesh-broker.check" && strings.Contains(string(raw), `"local-name":"drafts"`) {
				t.Errorf("check names drafts, which the bus holds as asked: %s", raw)
			}
		})
	}
}

// The server's storage limit is read from the monitoring document's config (design 47 G §547); none is 0.
func TestTheServersStorageLimitIsReadFromItsMonitor(t *testing.T) {
	for doc, want := range map[string]int64{`{"config":{"max_storage":5368709120}}`: 5368709120, `{"config":{"max_storage":-1}}`: 0, `{}`: 0} {
		got, err := serverStorageLimit(func(context.Context, string) ([]byte, error) { return []byte(doc), nil })(context.Background())
		if err != nil || got != want {
			t.Errorf("%s: %d (%v), want %d", doc, got, err, want)
		}
	}
}

// nats_plans answers each module's entries as last planned, narrowed by a module (design 47 G §538).
func TestNatsPlansReadsTheKeepersPlans(t *testing.T) {
	read := func() (map[string]keeper.Planned, error) {
		return map[string]keeper.Planned{
			"a": {Module: "a", Digest: "sha256:1", Revision: 3, Entries: []catalogue.BusStateEntry{{Name: "drafts"}}},
			"b": {Module: "b", Digest: "sha256:2", Revision: 4},
		}, nil
	}
	tool := plansTool(read)
	out, err := tool.Run(map[string]any{"module": "a"})
	raw, _ := json.Marshal(out)
	if err != nil || !strings.Contains(string(raw), `"entries":["drafts"]`) || !strings.Contains(string(raw), `"digest":"sha256:1"`) || strings.Contains(string(raw), `"module":"b"`) {
		t.Errorf("nats_plans answered %s (%v)", raw, err)
	}
}