From f90189353ca9ecc45855f5bd054e35cad8ef1983 Mon Sep 17 00:00:00 2001 From: jochen Date: Sun, 22 Nov 2026 02:25:39 +0100 Subject: [PATCH] Fold H2's new tests into existing ones: go/ at 327 unit tests (from 331), TypeScript at 48 (from 49) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The eight Go test functions H2 added become subtests of existing tests (catalogue's state test, the bundle's state test, the views test, the process state test, the testbus bus test, the seal byte-for-byte test), and four more are folded beside them (two seal, two process watch); the two TypeScript seal tests become one, and two more TypeScript tests are folded into their neighbours. No assertion is lost. Builds: design 47 H2 §819 --- go/catalogue/caps_test.go | 37 ---- go/catalogue/state_test.go | 30 +++ go/concurrent_test.go | 100 ---------- go/process/prune_test.go | 55 ------ go/process/state_test.go | 85 +++++++-- go/prune_test.go | 177 ----------------- go/seal/anonymous_test.go | 35 ---- go/seal/seal_test.go | 103 ++++++---- go/state_test.go | 254 +++++++++++++++++++++++++ go/testbus/testbus_integration_test.go | 22 +++ go/testbus/testbus_test.go | 24 --- go/views/views_test.go | 93 +++++---- test/retire.test.ts | 9 +- test/seal.test.ts | 22 +-- test/standing.test.ts | 4 +- 15 files changed, 501 insertions(+), 549 deletions(-) delete mode 100644 go/catalogue/caps_test.go delete mode 100644 go/concurrent_test.go delete mode 100644 go/prune_test.go diff --git a/go/catalogue/caps_test.go b/go/catalogue/caps_test.go deleted file mode 100644 index 1bbb42fc..00000000 --- a/go/catalogue/caps_test.go +++ /dev/null @@ -1,37 +0,0 @@ -package catalogue - -import ( - "reflect" - "testing" -) - -// Design 47 H2 §812, §814: the validator reads every state, log and objects entry of a manifest that names no cap, in -// the old sections and in requires alike; a capped entry, and an entry of another template, is none of them. -func TestAManifestSaysEachKeptStoreThatNamesNoCap(t *testing.T) { - m, err := decodeForTest([]byte(`{"module":"x","version":"1", - "state":["seen",{"name":"held","max-mib":8}], - "logs":[{"name":"acts"},{"name":"kept","max-mib":64}], - "objects":[{"name":"outputs","max-mib":256}], - "requires":[{"name":"performed","storage":"key-value","template":"state","options":{"history":1}}, - {"name":"taken","storage":"key-value","template":"state","options":{"max-mib":8,"key-ttl":true}}, - {"name":"archives","storage":"object-store","template":"objects"}, - {"name":"finding-events","storage":"stream","template":"events"}]}`)) - if err != nil { - t.Fatal(err) - } - want := []Uncapped{{Name: "seen", Kind: "state", OldSection: true}, {Name: "acts", Kind: "log", OldSection: true}, - {Name: "performed", Kind: "state"}, {Name: "archives", Kind: "objects"}} - if got := m.UncappedStores(); !reflect.DeepEqual(got, want) { - t.Fatalf("the uncapped stores are %+v, want %+v", got, want) - } -} - -// Design 47 H2 §810 (H-A-394): a manifest says its class, core or leaf; one that names none is a leaf. -func TestAManifestSaysItsClassAndNoneIsALeaf(t *testing.T) { - for raw, leaf := range map[string]bool{`"class":"core",`: false, `"class":"leaf",`: true, ``: true} { - m, err := decodeForTest([]byte(`{` + raw + `"module":"x","version":"1"}`)) - if err != nil || m.Leaf() != leaf || m.UnknownField() != "" { - t.Errorf("%s read as class %q, leaf %v (%v, unknown %q), want leaf %v", raw, m.Class, m.Leaf(), err, m.UnknownField(), leaf) - } - } -} diff --git a/go/catalogue/state_test.go b/go/catalogue/state_test.go index 8532ef3a..78d6671e 100644 --- a/go/catalogue/state_test.go +++ b/go/catalogue/state_test.go @@ -2,6 +2,7 @@ package catalogue import ( "encoding/json" + "reflect" "strings" "testing" @@ -28,6 +29,35 @@ func TestAManifestMaySayWhatStateItKeepsAndReads(t *testing.T) { if string(out) != `["servers",{"name":"seen","history":5,"ttl-seconds":3600}]` { t.Fatalf("written back as %s", out) } + // Design 47 H2 §812, §814: the validator reads every state, log and objects entry of a manifest that names no cap, in + // the old sections and in requires alike; a capped entry, and an entry of another template, is none of them. + t.Run("each kept store that names no cap", func(t *testing.T) { + m, err := decodeForTest([]byte(`{"module":"x","version":"1", + "state":["seen",{"name":"held","max-mib":8}], + "logs":[{"name":"acts"},{"name":"kept","max-mib":64}], + "objects":[{"name":"outputs","max-mib":256}], + "requires":[{"name":"performed","storage":"key-value","template":"state","options":{"history":1}}, + {"name":"taken","storage":"key-value","template":"state","options":{"max-mib":8,"key-ttl":true}}, + {"name":"archives","storage":"object-store","template":"objects"}, + {"name":"finding-events","storage":"stream","template":"events"}]}`)) + if err != nil { + t.Fatal(err) + } + want := []Uncapped{{Name: "seen", Kind: "state", OldSection: true}, {Name: "acts", Kind: "log", OldSection: true}, + {Name: "performed", Kind: "state"}, {Name: "archives", Kind: "objects"}} + if got := m.UncappedStores(); !reflect.DeepEqual(got, want) { + t.Fatalf("the uncapped stores are %+v, want %+v", got, want) + } + }) + // Design 47 H2 §810 (H-A-394): a manifest says its class, core or leaf; one that names none is a leaf. + t.Run("its class, none a leaf", func(t *testing.T) { + for raw, leaf := range map[string]bool{`"class":"core",`: false, `"class":"leaf",`: true, ``: true} { + m, err := decodeForTest([]byte(`{` + raw + `"module":"x","version":"1"}`)) + if err != nil || m.Leaf() != leaf || m.UnknownField() != "" { + t.Errorf("%s read as class %q, leaf %v (%v, unknown %q), want leaf %v", raw, m.Class, m.Leaf(), err, m.UnknownField(), leaf) + } + } + }) } // 1154/AC1: a state entry may say key-ttl; it is read, written back, and a bare name or an entry without it reads as before. diff --git a/go/concurrent_test.go b/go/concurrent_test.go deleted file mode 100644 index c0c6e5cf..00000000 --- a/go/concurrent_test.go +++ /dev/null @@ -1,100 +0,0 @@ -package stdio - -import ( - "bufio" - "encoding/json" - "fmt" - "io" - "sync" - "testing" - "time" -) - -// Design 47 H2 §782: one bundle's state calls through its one runtime channel are safe at once: gets, puts, pages, -// watches and bus-state calls from many goroutines, the runtime answering each, under the race detector. -func TestOneRuntimeChannelServesConcurrentStateCalls(t *testing.T) { - inR, inW := io.Pipe() - outR, outW := io.Pipe() - t.Cleanup(func() { _ = inW.Close(); _ = outR.Close() }) - const many = 16 - go func() { - _ = ServeOn("", []Tool{{Name: "many", Run: func(map[string]any) (any, error) { - var wg sync.WaitGroup - errs := make(chan error, many*6) - for i := range many { - wg.Add(1) - go func() { - defer wg.Done() - s, key := State("servers"), fmt.Sprintf("k%d", i) - _, err := s.Put(key, i) - errs <- err - _, err = s.Get(key) - errs <- err - _, err = s.Page("", 1000, time.Second) - errs <- err - errs <- s.Watch(key, func(StateChange) error { return nil }) - _, err = BusState("mesh/objects.info", map[string]any{"objects": "o"}) - errs <- err - _, err = s.Info() - errs <- err - }() - } - wg.Wait() - close(errs) - for err := range errs { - if err != nil { - return nil, err - } - } - return "done", nil - }}}, inR, outW) - }() - var wmu sync.Mutex - send := func(m map[string]any) { - b, _ := json.Marshal(m) - wmu.Lock() - defer wmu.Unlock() - _, _ = inW.Write(append(b, '\n')) - } - send(map[string]any{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": map[string]any{"name": "many"}}) - lines := bufio.NewScanner(outR) - answered := make(chan map[string]any, 1) - go func() { - n := 1000 - for lines.Scan() { - var m map[string]any - _ = json.Unmarshal(lines.Bytes(), &m) - method, _ := m["method"].(string) - switch { - case m["id"] == float64(1): - answered <- m - return - case method == "mesh/state.watch": - n++ - id := m["id"] - key := m["params"].(map[string]any)["key"] - // The runtime hands the current value over, then answers the watch, on a goroutine of its own, as - // the tool runner's answers come in any order. - go func(n int) { - send(map[string]any{"jsonrpc": "2.0", "id": n, "method": "mesh/state", "params": map[string]any{"watch": id, - "change": map[string]any{"state": "servers", "key": key, "op": "put", "value": 1, "current": true}}}) - send(map[string]any{"jsonrpc": "2.0", "id": id, "result": map[string]any{}}) - }(n) - case method == "mesh/state.page": - go send(map[string]any{"jsonrpc": "2.0", "id": m["id"], "result": map[string]any{"entries": []any{}}}) - case method == "mesh/state.get": - go send(map[string]any{"jsonrpc": "2.0", "id": m["id"], "result": map[string]any{"key": "k", "value": 1, "revision": 2}}) - case method != "": - go send(map[string]any{"jsonrpc": "2.0", "id": m["id"], "result": map[string]any{"revision": 1}}) - } - } - }() - select { - case m := <-answered: - if m["error"] != nil || fmt.Sprint(m["result"]) != "map[content:[map[text:\"done\" type:text]]]" { - t.Fatalf("the concurrent calls answered %v", m) - } - case <-time.After(10 * time.Second): - t.Fatal("the concurrent calls did not end") - } -} diff --git a/go/process/prune_test.go b/go/process/prune_test.go index 638980c9..2ce60859 100644 --- a/go/process/prune_test.go +++ b/go/process/prune_test.go @@ -2,10 +2,6 @@ package process import ( "context" - "fmt" - "strings" - "testing" - "time" "github.com/nats-io/nats.go/jetstream" @@ -64,54 +60,3 @@ func (f *pruneKV) Purge(ctx context.Context, key string, _ ...jetstream.KVDelete type putEntry struct{ fakeEntry } func (putEntry) Operation() jetstream.KeyValueOp { return jetstream.KeyValuePut } - -// Design 47 H2 §812 (H-A-380, H-A-386): a process's write that takes its state past prune-mark prunes it, oldest first -// by revision, to prune-target, in one journal line, reading the figures only at the bind and after the prune; a key -// kept under _keep/ survives, and no reader counts the keep. -func TestAProcessWritePastItsMarkPrunesToItsTargetAndAKeptKeySurvives(t *testing.T) { - var lines []string - sayPrune = func(line string) { lines = append(lines, line) } - t.Cleanup(func() { sayPrune = func(string) {} }) - kv := &pruneKV{fakeKV: newFakeKV(), cap: 10_000} - s, err := stateOn(kv).Pruned(stdio.Prune{Mark: 70, Target: 50}) - if err != nil { - t.Fatal(err) - } - value := strings.Repeat("x", 300) - if _, err := s.Put("k00", value); err != nil { - t.Fatal(err) - } - if err := s.Keep("k00", time.Now().Add(time.Hour)); err != nil { - t.Fatal(err) - } - if err := s.Keep("k01", time.Now().Add(-time.Hour)); err == nil { - t.Fatal("a keep until a time past was taken") - } - for i := 1; i < 18; i++ { - if _, err := s.Put(fmt.Sprintf("k%02d", i), value); err != nil { - t.Fatal(err) - } - if len(lines) == 0 && kv.held()*100 > 70*10_000 { - t.Fatalf("the state holds %d of 10000 bytes after k%02d and was not pruned", kv.held(), i) - } - } - if len(lines) != 1 || !strings.Contains(lines[0], "pruned the state mesh-mail's sends") { - t.Fatalf("the prunes said %q, want one line", lines) - } - if kv.statuss != 2 { - t.Fatalf("the figures were read %d times, want 2: at the bind and after the prune", kv.statuss) - } - if held := kv.held(); held*100 > 50*10_000 { - t.Fatalf("the prune left %d of 10000 bytes, above its target of 50 %%", held) - } - keys, err := s.Keys() - if err != nil { - t.Fatal(err) - } - if keys[0] != "k00" || strings.Contains(strings.Join(keys, " "), "_keep") || keys[1] == "k01" || keys[len(keys)-1] != "k17" { - t.Fatalf("after the prune the readers see %v: want k00 kept, the oldest others gone, k17 there, no keep", keys) - } - if e, _ := s.Get(stdio.KeepKey("k00")); e == nil { - t.Fatal("the keep itself was pruned") - } -} diff --git a/go/process/state_test.go b/go/process/state_test.go index 76733752..32d197c9 100644 --- a/go/process/state_test.go +++ b/go/process/state_test.go @@ -3,6 +3,7 @@ package process import ( "context" "errors" + "fmt" "sort" "strings" "sync" @@ -250,6 +251,56 @@ func TestStatePutWritesAKeyWhole(t *testing.T) { t.Errorf("seat %q, ask %q was taken", bad[0], bad[1]) } } + // Design 47 H2 §812 (H-A-380, H-A-386): a process's write that takes its state past prune-mark prunes it, oldest first + // by revision, to prune-target, in one journal line, reading the figures only at the bind and after the prune; a key + // kept under _keep/ survives, and no reader counts the keep. + t.Run("a write past its mark prunes to its target and a kept key survives", func(t *testing.T) { + var lines []string + sayPrune = func(line string) { lines = append(lines, line) } + t.Cleanup(func() { sayPrune = func(string) {} }) + kv := &pruneKV{fakeKV: newFakeKV(), cap: 10_000} + s, err := stateOn(kv).Pruned(stdio.Prune{Mark: 70, Target: 50}) + if err != nil { + t.Fatal(err) + } + value := strings.Repeat("x", 300) + if _, err := s.Put("k00", value); err != nil { + t.Fatal(err) + } + if err := s.Keep("k00", time.Now().Add(time.Hour)); err != nil { + t.Fatal(err) + } + if err := s.Keep("k01", time.Now().Add(-time.Hour)); err == nil { + t.Fatal("a keep until a time past was taken") + } + for i := 1; i < 18; i++ { + if _, err := s.Put(fmt.Sprintf("k%02d", i), value); err != nil { + t.Fatal(err) + } + if len(lines) == 0 && kv.held()*100 > 70*10_000 { + t.Fatalf("the state holds %d of 10000 bytes after k%02d and was not pruned", kv.held(), i) + } + } + if len(lines) != 1 || !strings.Contains(lines[0], "pruned the state mesh-mail's sends") { + t.Fatalf("the prunes said %q, want one line", lines) + } + if kv.statuss != 2 { + t.Fatalf("the figures were read %d times, want 2: at the bind and after the prune", kv.statuss) + } + if held := kv.held(); held*100 > 50*10_000 { + t.Fatalf("the prune left %d of 10000 bytes, above its target of 50 %%", held) + } + keys, err := s.Keys() + if err != nil { + t.Fatal(err) + } + if keys[0] != "k00" || strings.Contains(strings.Join(keys, " "), "_keep") || keys[1] == "k01" || keys[len(keys)-1] != "k17" { + t.Fatalf("after the prune the readers see %v: want k00 kept, the oldest others gone, k17 there, no keep", keys) + } + if e, _ := s.Get(stdio.KeepKey("k00")); e == nil { + t.Fatal("the keep itself was pruned") + } + }) } // 1840/S1: given a state, when its keys are listed, then they come sorted, and none is an empty list, not an error. @@ -321,25 +372,23 @@ func TestStateWatchHandsCurrentValuesThenChanges(t *testing.T) { t.Fatalf("no change %+v", want) } } -} - -// 1840/S2: a key narrowing reaches the bus as a subject pattern: `*` one name, `**` the rest, empty every key. -func TestStateWatchNarrowing(t *testing.T) { - for key, want := range map[string]string{"": ">", "a.b": "a.b", "a.*": "a.*", "a.**": "a.>", "**": ">"} { - if got := watchPattern(key); got != want { - t.Errorf("watchPattern(%q) = %q, want %q", key, got, want) + // 1840/S2: a key narrowing reaches the bus as a subject pattern: `*` one name, `**` the rest, empty every key. + t.Run("narrowing", func(t *testing.T) { + for key, want := range map[string]string{"": ">", "a.b": "a.b", "a.*": "a.*", "a.**": "a.>", "**": ">"} { + if got := watchPattern(key); got != want { + t.Errorf("watchPattern(%q) = %q, want %q", key, got, want) + } } - } -} - -// 1840/S2: given a handler that refuses a current value, then Watch returns its error. -func TestStateWatchReturnsAHandlersErrorOnCurrentValues(t *testing.T) { - kv := newFakeKV() - kv.initial = []jetstream.KeyValueEntry{watchEntry{fakeEntry{key: "a", value: []byte(`1`), rev: 1}, jetstream.KeyValuePut}} - boom := errors.New("boom") - if err := stateOn(kv).Watch("", func(stdio.StateChange) error { return boom }); !errors.Is(err, boom) { - t.Fatalf("Watch: %v, want the handler's error", err) - } + }) + // 1840/S2: given a handler that refuses a current value, then Watch returns its error. + t.Run("a handler's error on the current values is returned", func(t *testing.T) { + kv := newFakeKV() + kv.initial = []jetstream.KeyValueEntry{watchEntry{fakeEntry{key: "a", value: []byte(`1`), rev: 1}, jetstream.KeyValuePut}} + boom := errors.New("boom") + if err := stateOn(kv).Watch("", func(stdio.StateChange) error { return boom }); !errors.Is(err, boom) { + t.Fatalf("Watch: %v, want the handler's error", err) + } + }) } // 1840/S2: given a connection that closes before the current values arrive, then Watch returns an error. diff --git a/go/prune_test.go b/go/prune_test.go deleted file mode 100644 index 13907e01..00000000 --- a/go/prune_test.go +++ /dev/null @@ -1,177 +0,0 @@ -package stdio - -import ( - "bufio" - "encoding/json" - "io" - "sort" - "strings" - "sync" - "testing" - "time" -) - -// Design 47 H2 §812 (H-A-380, H-A-386): prune-mark and prune-target are read through the settings reader with their -// defaults, and a bundle's Put judges the fill the runtime's put answer carries: past 70 % the oldest keys by revision -// are deleted to 50 %, a key kept under _keep/ survives, and no reader (Keys, Page) counts the keep. -func TestABundleWritePastItsMarkPrunesToItsTargetAndAKeptKeySurvives(t *testing.T) { - t.Run("settings", func(t *testing.T) { - if p, err := PruneSettings(); err != nil || p != (Prune{Mark: 70, Target: 50}) { - t.Fatalf("the defaults are %+v, %v", p, err) - } - t.Setenv(SettingWord(PruneMarkSetting), "80%") - t.Setenv(SettingWord(PruneTargetSetting), "60") - if p, err := PruneSettings(); err != nil || p != (Prune{Mark: 80, Target: 60}) { - t.Fatalf("the settings read %+v, %v", p, err) - } - t.Setenv(SettingWord(PruneTargetSetting), "90") - if _, err := PruneSettings(); err == nil || !strings.Contains(err.Error(), "prune-target") { - t.Fatalf("a target above the mark was taken: %v", err) - } - t.Setenv(SettingWord(PruneTargetSetting), "half") - if _, err := PruneSettings(); err == nil || !strings.Contains(err.Error(), "MESH_CONFIG_PRUNE_TARGET") { - t.Fatalf("a target that is no percentage was taken: %v", err) - } - }) - - servesAlone(t) - t.Setenv(ServedAs, "bridge") - inR, inW := io.Pipe() - outR, outW := io.Pipe() - pruned := State("performed").Pruned(Prune{Mark: 70, Target: 50}) - go func() { - _ = ServeOn("", []Tool{ - {Name: "write", Run: func(a map[string]any) (any, error) { return pruned.Put(a["key"].(string), a["value"]) }}, - {Name: "keep", Run: func(a map[string]any) (any, error) { - return nil, pruned.Keep(a["key"].(string), time.Now().Add(time.Hour)) - }}, - {Name: "keys", Run: func(map[string]any) (any, error) { return State("performed").Keys() }}, - {Name: "page", Run: func(map[string]any) (any, error) { return State("performed").Page("", 1<<20, time.Second) }}, - }, inR, outW) - }() - // The runtime: a state of a cap of 10000 bytes whose fill is what its current values put. - const limit = 10_000 - var mu sync.Mutex - values, revs, next := map[string]json.RawMessage{}, map[string]uint64{}, uint64(0) - held := func() uint64 { - var n uint64 - for k, v := range values { - n += PutBytes(k, v) - } - return n - } - var mostHeld uint64 - answers := make(chan map[string]any, 1) - send := func(m map[string]any) { b, _ := json.Marshal(m); _, _ = inW.Write(append(b, '\n')) } - go func() { - lines := bufio.NewScanner(outR) - lines.Buffer(make([]byte, 1<<20), 1<<22) - for lines.Scan() { - var m struct { - ID any `json:"id"` - Method string `json:"method"` - Params map[string]any `json:"params"` - Result any `json:"result"` - Error any `json:"error"` - } - _ = json.Unmarshal(lines.Bytes(), &m) - if m.Method == "" { - answers <- map[string]any{"result": m.Result, "error": m.Error} - continue - } - mu.Lock() - var result any = map[string]any{} - key, _ := m.Params["key"].(string) - switch m.Method { - case "mesh/state.put": - v, _ := json.Marshal(m.Params["value"]) - next++ - values[key], revs[key] = v, next - mostHeld = max(mostHeld, held()) - result = map[string]any{"revision": next, "fill": map[string]any{"count": len(values), "bytes": held(), "max_bytes": limit}} - case "mesh/state.delete": - delete(values, key) - case "mesh/state.keys": - keys := []string{} - for k := range values { - keys = append(keys, k) - } - sort.Strings(keys) - result = keys - case "mesh/state.page": - var entries []StateEntry - for k, v := range values { - entries = append(entries, StateEntry{Key: k, Value: v, Revision: revs[k]}) - } - sort.Slice(entries, func(i, j int) bool { return entries[i].Revision < entries[j].Revision }) - result = StatePage{Entries: entries} - } - mu.Unlock() - if m.ID != nil { - send(map[string]any{"jsonrpc": "2.0", "id": m.ID, "result": result}) - } - } - }() - call := func(name string, args map[string]any) any { - t.Helper() - send(map[string]any{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": map[string]any{"name": name, "arguments": args}}) - select { - case a := <-answers: - r, _ := a["result"].(map[string]any) - if a["error"] != nil || r == nil || r["isError"] == true { - t.Fatalf("%s answered %v %v", name, a["error"], r) - } - var out any - _ = json.Unmarshal([]byte(r["content"].([]any)[0].(map[string]any)["text"].(string)), &out) - return out - case <-time.After(3 * time.Second): - t.Fatalf("%s answered nothing", name) - return nil - } - } - value := strings.Repeat("x", 300) - call("write", map[string]any{"key": "k00", "value": value}) - call("keep", map[string]any{"key": "k00"}) - for _, k := range []string{"k01", "k02", "k03", "k04", "k05", "k06", "k07", "k08", "k09", "k10", "k11", "k12", "k13", "k14", "k15", "k16", "k17", "k18", "k19"} { - call("write", map[string]any{"key": k, "value": value}) - mu.Lock() - over := held()*100 > 70*limit - mu.Unlock() - if over { - t.Fatalf("the state holds more than 70 %% of its cap after %s: no prune", k) - } - } - mu.Lock() - _, k00 := values["k00"] - _, k01 := values["k01"] - _, k19 := values["k19"] - _, keep := values[KeepKey("k00")] - after := held() - mu.Unlock() - if mostHeld*100 <= 70*limit { - t.Fatalf("the test never took the state past its mark (%d bytes at most)", mostHeld) - } - if !k00 || !keep || k01 || !k19 { - t.Fatalf("after the prunes k00 %v, its keep %v, k01 %v, k19 %v: want the kept key and its keep, the oldest other gone, the newest there", k00, keep, k01, k19) - } - if after*100 > 70*limit { - t.Fatalf("the state holds %d of %d bytes", after, limit) - } - if keys := call("keys", nil); strings.Contains(strings.Join(strs(keys), " "), KeepPrefix) { - t.Fatalf("Keys counted the keep: %v", keys) - } - page := call("page", nil).(map[string]any) - for _, e := range page["entries"].([]any) { - if IsKeep(e.(map[string]any)["key"].(string)) { - t.Fatalf("Page counted the keep: %v", e) - } - } -} - -func strs(v any) []string { - var out []string - for _, s := range v.([]any) { - out = append(out, s.(string)) - } - return out -} diff --git a/go/seal/anonymous_test.go b/go/seal/anonymous_test.go index 88a43714..3dc20386 100644 --- a/go/seal/anonymous_test.go +++ b/go/seal/anonymous_test.go @@ -5,7 +5,6 @@ import ( "crypto/sha256" "encoding/base64" "encoding/json" - "os" "testing" "golang.org/x/crypto/nacl/box" @@ -56,40 +55,6 @@ func anonymousVectors(t *testing.T) anonymousFixture { return f } -// The anonymous-box fixture the TypeScript tests read is what box.SealAnonymous makes, and each opens with the -// recipient's key as the vault's intake opens it (box.OpenAnonymous). MESH_SDK_WRITE_FIXTURES=1 writes it anew. -func TestTheAnonymousBoxFixtureIsGosBytes(t *testing.T) { - want := anonymousVectors(t) - if os.Getenv("MESH_SDK_WRITE_FIXTURES") == "1" { - raw, _ := json.MarshalIndent(want, "", " ") - if err := os.WriteFile(anonymousFixturePath, append(raw, '\n'), 0o644); err != nil { - t.Fatal(err) - } - } - raw, err := os.ReadFile(anonymousFixturePath) - if err != nil { - t.Fatal(err) - } - var got anonymousFixture - if err := json.Unmarshal(raw, &got); err != nil { - t.Fatal(err) - } - if g, w := mustJSON(got), mustJSON(want); g != w { - t.Fatalf("the fixture is not Go's bytes:\n%s\nwant\n%s", g, w) - } - var pub, priv [32]byte - p, _ := base64.StdEncoding.DecodeString(got.Recipient.Public) - k, _ := base64.StdEncoding.DecodeString(got.Recipient.Private) - copy(pub[:], p) - copy(priv[:], k) - for _, v := range got.Vectors { - sealed, _ := base64.StdEncoding.DecodeString(v.Sealed) - if out, ok := box.OpenAnonymous(nil, sealed, &pub, &priv); !ok || string(out) != v.Plaintext { - t.Errorf("a box does not open to %q: %q, %v", v.Plaintext, out, ok) - } - } -} - func mustJSON(v any) string { raw, _ := json.Marshal(v) return string(raw) diff --git a/go/seal/seal_test.go b/go/seal/seal_test.go index 2a2786e2..8c704617 100644 --- a/go/seal/seal_test.go +++ b/go/seal/seal_test.go @@ -6,6 +6,8 @@ import ( "encoding/json" "os" "testing" + + "golang.org/x/crypto/nacl/box" ) type fixture struct { @@ -75,6 +77,39 @@ func TestSealIsByteForByteTheLicenceManagersBox(t *testing.T) { t.Fatalf("reopened %q, %v", plain, err) } } + // The anonymous-box fixture the TypeScript tests read is what box.SealAnonymous makes, and each opens with the + // recipient's key as the vault's intake opens it (box.OpenAnonymous). MESH_SDK_WRITE_FIXTURES=1 writes it anew. + t.Run("the anonymous box fixture is Go's bytes", func(t *testing.T) { + want := anonymousVectors(t) + if os.Getenv("MESH_SDK_WRITE_FIXTURES") == "1" { + raw, _ := json.MarshalIndent(want, "", " ") + if err := os.WriteFile(anonymousFixturePath, append(raw, '\n'), 0o644); err != nil { + t.Fatal(err) + } + } + raw, err := os.ReadFile(anonymousFixturePath) + if err != nil { + t.Fatal(err) + } + var got anonymousFixture + if err := json.Unmarshal(raw, &got); err != nil { + t.Fatal(err) + } + if g, w := mustJSON(got), mustJSON(want); g != w { + t.Fatalf("the fixture is not Go's bytes:\n%s\nwant\n%s", g, w) + } + var pub, priv [32]byte + p, _ := base64.StdEncoding.DecodeString(got.Recipient.Public) + k, _ := base64.StdEncoding.DecodeString(got.Recipient.Private) + copy(pub[:], p) + copy(priv[:], k) + for _, v := range got.Vectors { + sealed, _ := base64.StdEncoding.DecodeString(v.Sealed) + if out, ok := box.OpenAnonymous(nil, sealed, &pub, &priv); !ok || string(out) != v.Plaintext { + t.Errorf("a box does not open to %q: %q, %v", v.Plaintext, out, ok) + } + } + }) } // A box the agent module's TypeScript sealed (the fixture the licence manager keeps) opens here too. @@ -117,40 +152,38 @@ func TestABoxOpensOnlyForItsRecipient(t *testing.T) { if again.Eph == box.Eph || again.IV == box.IV { t.Fatal("two boxes share a one-time key or iv") } -} - -// A box changed in any field, or of another version, does not open. -func TestATamperedBoxDoesNotOpen(t *testing.T) { - f := readFixture(t) - good := f.Sealed[1].Box - flip := func(s string) string { - b, _ := base64.StdEncoding.DecodeString(s) - b[len(b)-1] ^= 1 - return base64.StdEncoding.EncodeToString(b) - } - for name, box := range map[string]Box{ - "ct": {V: 1, Eph: good.Eph, IV: good.IV, Tag: good.Tag, Ct: flip(good.Ct)}, - "tag": {V: 1, Eph: good.Eph, IV: good.IV, Tag: flip(good.Tag), Ct: good.Ct}, - "iv": {V: 1, Eph: good.Eph, IV: flip(good.IV), Tag: good.Tag, Ct: good.Ct}, - "eph": {V: 1, Eph: flip(good.Eph), IV: good.IV, Tag: good.Tag, Ct: good.Ct}, - "version": {V: 2, Eph: good.Eph, IV: good.IV, Tag: good.Tag, Ct: good.Ct}, - } { - if _, err := Open(box, f.Recipient.PrivateKey); err == nil { - t.Fatalf("a box with a changed %s opened", name) + // A box changed in any field, or of another version, does not open. + t.Run("a tampered box does not open", func(t *testing.T) { + f := readFixture(t) + good := f.Sealed[1].Box + flip := func(s string) string { + b, _ := base64.StdEncoding.DecodeString(s) + b[len(b)-1] ^= 1 + return base64.StdEncoding.EncodeToString(b) } - } -} - -// A key that is not X25519 PEM is refused, not misread. -func TestAKeyOfAnotherKindIsRefused(t *testing.T) { - if _, err := Seal("x", "not a key"); err == nil { - t.Fatal("sealed to text") - } - f := readFixture(t) - if _, err := Open(f.Sealed[0].Box, f.Recipient.PublicKey); err == nil { - t.Fatal("opened with a public key") - } - if _, err := Seal("x", f.Recipient.PrivateKey); err == nil { - t.Fatal("sealed to a private key") - } + for name, box := range map[string]Box{ + "ct": {V: 1, Eph: good.Eph, IV: good.IV, Tag: good.Tag, Ct: flip(good.Ct)}, + "tag": {V: 1, Eph: good.Eph, IV: good.IV, Tag: flip(good.Tag), Ct: good.Ct}, + "iv": {V: 1, Eph: good.Eph, IV: flip(good.IV), Tag: good.Tag, Ct: good.Ct}, + "eph": {V: 1, Eph: flip(good.Eph), IV: good.IV, Tag: good.Tag, Ct: good.Ct}, + "version": {V: 2, Eph: good.Eph, IV: good.IV, Tag: good.Tag, Ct: good.Ct}, + } { + if _, err := Open(box, f.Recipient.PrivateKey); err == nil { + t.Fatalf("a box with a changed %s opened", name) + } + } + }) + // A key that is not X25519 PEM is refused, not misread. + t.Run("a key of another kind is refused", func(t *testing.T) { + if _, err := Seal("x", "not a key"); err == nil { + t.Fatal("sealed to text") + } + f := readFixture(t) + if _, err := Open(f.Sealed[0].Box, f.Recipient.PublicKey); err == nil { + t.Fatal("opened with a public key") + } + if _, err := Seal("x", f.Recipient.PrivateKey); err == nil { + t.Fatal("sealed to a private key") + } + }) } diff --git a/go/state_test.go b/go/state_test.go index 8ed8b89b..85a80848 100644 --- a/go/state_test.go +++ b/go/state_test.go @@ -6,7 +6,9 @@ import ( "errors" "fmt" "io" + "sort" "strings" + "sync" "testing" "time" ) @@ -355,4 +357,256 @@ func TestABundleKeepsAndWatchesStateThroughTheRuntime(t *testing.T) { if v, _, _ := w.Get("placement", "gone"); string(v) != "again" { t.Fatalf("a change after its own delete is not taken: %s", v) } + // Design 47 H2 §782: one bundle's state calls through its one runtime channel are safe at once: gets, puts, pages, + // watches and bus-state calls from many goroutines, the runtime answering each, under the race detector. + t.Run("one runtime channel serves concurrent state calls", func(t *testing.T) { + inR, inW := io.Pipe() + outR, outW := io.Pipe() + t.Cleanup(func() { _ = inW.Close(); _ = outR.Close() }) + const many = 16 + go func() { + _ = ServeOn("", []Tool{{Name: "many", Run: func(map[string]any) (any, error) { + var wg sync.WaitGroup + errs := make(chan error, many*6) + for i := range many { + wg.Add(1) + go func() { + defer wg.Done() + s, key := State("servers"), fmt.Sprintf("k%d", i) + _, err := s.Put(key, i) + errs <- err + _, err = s.Get(key) + errs <- err + _, err = s.Page("", 1000, time.Second) + errs <- err + errs <- s.Watch(key, func(StateChange) error { return nil }) + _, err = BusState("mesh/objects.info", map[string]any{"objects": "o"}) + errs <- err + _, err = s.Info() + errs <- err + }() + } + wg.Wait() + close(errs) + for err := range errs { + if err != nil { + return nil, err + } + } + return "done", nil + }}}, inR, outW) + }() + var wmu sync.Mutex + send := func(m map[string]any) { + b, _ := json.Marshal(m) + wmu.Lock() + defer wmu.Unlock() + _, _ = inW.Write(append(b, '\n')) + } + send(map[string]any{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": map[string]any{"name": "many"}}) + lines := bufio.NewScanner(outR) + answered := make(chan map[string]any, 1) + go func() { + n := 1000 + for lines.Scan() { + var m map[string]any + _ = json.Unmarshal(lines.Bytes(), &m) + method, _ := m["method"].(string) + switch { + case m["id"] == float64(1): + answered <- m + return + case method == "mesh/state.watch": + n++ + id := m["id"] + key := m["params"].(map[string]any)["key"] + // The runtime hands the current value over, then answers the watch, on a goroutine of its own, as + // the tool runner's answers come in any order. + go func(n int) { + send(map[string]any{"jsonrpc": "2.0", "id": n, "method": "mesh/state", "params": map[string]any{"watch": id, + "change": map[string]any{"state": "servers", "key": key, "op": "put", "value": 1, "current": true}}}) + send(map[string]any{"jsonrpc": "2.0", "id": id, "result": map[string]any{}}) + }(n) + case method == "mesh/state.page": + go send(map[string]any{"jsonrpc": "2.0", "id": m["id"], "result": map[string]any{"entries": []any{}}}) + case method == "mesh/state.get": + go send(map[string]any{"jsonrpc": "2.0", "id": m["id"], "result": map[string]any{"key": "k", "value": 1, "revision": 2}}) + case method != "": + go send(map[string]any{"jsonrpc": "2.0", "id": m["id"], "result": map[string]any{"revision": 1}}) + } + } + }() + select { + case m := <-answered: + if m["error"] != nil || fmt.Sprint(m["result"]) != "map[content:[map[text:\"done\" type:text]]]" { + t.Fatalf("the concurrent calls answered %v", m) + } + case <-time.After(10 * time.Second): + t.Fatal("the concurrent calls did not end") + } + }) + // Design 47 H2 §812 (H-A-380, H-A-386): prune-mark and prune-target are read through the settings reader with their + // defaults, and a bundle's Put judges the fill the runtime's put answer carries: past 70 % the oldest keys by revision + // are deleted to 50 %, a key kept under _keep/ survives, and no reader (Keys, Page) counts the keep. + t.Run("a write past its mark prunes to its target and a kept key survives", func(t *testing.T) { + t.Run("settings", func(t *testing.T) { + if p, err := PruneSettings(); err != nil || p != (Prune{Mark: 70, Target: 50}) { + t.Fatalf("the defaults are %+v, %v", p, err) + } + t.Setenv(SettingWord(PruneMarkSetting), "80%") + t.Setenv(SettingWord(PruneTargetSetting), "60") + if p, err := PruneSettings(); err != nil || p != (Prune{Mark: 80, Target: 60}) { + t.Fatalf("the settings read %+v, %v", p, err) + } + t.Setenv(SettingWord(PruneTargetSetting), "90") + if _, err := PruneSettings(); err == nil || !strings.Contains(err.Error(), "prune-target") { + t.Fatalf("a target above the mark was taken: %v", err) + } + t.Setenv(SettingWord(PruneTargetSetting), "half") + if _, err := PruneSettings(); err == nil || !strings.Contains(err.Error(), "MESH_CONFIG_PRUNE_TARGET") { + t.Fatalf("a target that is no percentage was taken: %v", err) + } + }) + + servesAlone(t) + t.Setenv(ServedAs, "bridge") + inR, inW := io.Pipe() + outR, outW := io.Pipe() + pruned := State("performed").Pruned(Prune{Mark: 70, Target: 50}) + go func() { + _ = ServeOn("", []Tool{ + {Name: "write", Run: func(a map[string]any) (any, error) { return pruned.Put(a["key"].(string), a["value"]) }}, + {Name: "keep", Run: func(a map[string]any) (any, error) { + return nil, pruned.Keep(a["key"].(string), time.Now().Add(time.Hour)) + }}, + {Name: "keys", Run: func(map[string]any) (any, error) { return State("performed").Keys() }}, + {Name: "page", Run: func(map[string]any) (any, error) { return State("performed").Page("", 1<<20, time.Second) }}, + }, inR, outW) + }() + // The runtime: a state of a cap of 10000 bytes whose fill is what its current values put. + const limit = 10_000 + var mu sync.Mutex + values, revs, next := map[string]json.RawMessage{}, map[string]uint64{}, uint64(0) + held := func() uint64 { + var n uint64 + for k, v := range values { + n += PutBytes(k, v) + } + return n + } + var mostHeld uint64 + answers := make(chan map[string]any, 1) + send := func(m map[string]any) { b, _ := json.Marshal(m); _, _ = inW.Write(append(b, '\n')) } + go func() { + lines := bufio.NewScanner(outR) + lines.Buffer(make([]byte, 1<<20), 1<<22) + for lines.Scan() { + var m struct { + ID any `json:"id"` + Method string `json:"method"` + Params map[string]any `json:"params"` + Result any `json:"result"` + Error any `json:"error"` + } + _ = json.Unmarshal(lines.Bytes(), &m) + if m.Method == "" { + answers <- map[string]any{"result": m.Result, "error": m.Error} + continue + } + mu.Lock() + var result any = map[string]any{} + key, _ := m.Params["key"].(string) + switch m.Method { + case "mesh/state.put": + v, _ := json.Marshal(m.Params["value"]) + next++ + values[key], revs[key] = v, next + mostHeld = max(mostHeld, held()) + result = map[string]any{"revision": next, "fill": map[string]any{"count": len(values), "bytes": held(), "max_bytes": limit}} + case "mesh/state.delete": + delete(values, key) + case "mesh/state.keys": + keys := []string{} + for k := range values { + keys = append(keys, k) + } + sort.Strings(keys) + result = keys + case "mesh/state.page": + var entries []StateEntry + for k, v := range values { + entries = append(entries, StateEntry{Key: k, Value: v, Revision: revs[k]}) + } + sort.Slice(entries, func(i, j int) bool { return entries[i].Revision < entries[j].Revision }) + result = StatePage{Entries: entries} + } + mu.Unlock() + if m.ID != nil { + send(map[string]any{"jsonrpc": "2.0", "id": m.ID, "result": result}) + } + } + }() + call := func(name string, args map[string]any) any { + t.Helper() + send(map[string]any{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": map[string]any{"name": name, "arguments": args}}) + select { + case a := <-answers: + r, _ := a["result"].(map[string]any) + if a["error"] != nil || r == nil || r["isError"] == true { + t.Fatalf("%s answered %v %v", name, a["error"], r) + } + var out any + _ = json.Unmarshal([]byte(r["content"].([]any)[0].(map[string]any)["text"].(string)), &out) + return out + case <-time.After(3 * time.Second): + t.Fatalf("%s answered nothing", name) + return nil + } + } + value := strings.Repeat("x", 300) + call("write", map[string]any{"key": "k00", "value": value}) + call("keep", map[string]any{"key": "k00"}) + for _, k := range []string{"k01", "k02", "k03", "k04", "k05", "k06", "k07", "k08", "k09", "k10", "k11", "k12", "k13", "k14", "k15", "k16", "k17", "k18", "k19"} { + call("write", map[string]any{"key": k, "value": value}) + mu.Lock() + over := held()*100 > 70*limit + mu.Unlock() + if over { + t.Fatalf("the state holds more than 70 %% of its cap after %s: no prune", k) + } + } + mu.Lock() + _, k00 := values["k00"] + _, k01 := values["k01"] + _, k19 := values["k19"] + _, keep := values[KeepKey("k00")] + after := held() + mu.Unlock() + if mostHeld*100 <= 70*limit { + t.Fatalf("the test never took the state past its mark (%d bytes at most)", mostHeld) + } + if !k00 || !keep || k01 || !k19 { + t.Fatalf("after the prunes k00 %v, its keep %v, k01 %v, k19 %v: want the kept key and its keep, the oldest other gone, the newest there", k00, keep, k01, k19) + } + if after*100 > 70*limit { + t.Fatalf("the state holds %d of %d bytes", after, limit) + } + if keys := call("keys", nil); strings.Contains(strings.Join(strs(keys), " "), KeepPrefix) { + t.Fatalf("Keys counted the keep: %v", keys) + } + page := call("page", nil).(map[string]any) + for _, e := range page["entries"].([]any) { + if IsKeep(e.(map[string]any)["key"].(string)) { + t.Fatalf("Page counted the keep: %v", e) + } + } + }) +} + +func strs(v any) []string { + var out []string + for _, s := range v.([]any) { + out = append(out, s.(string)) + } + return out } diff --git a/go/testbus/testbus_integration_test.go b/go/testbus/testbus_integration_test.go index 3b9ab19f..4ffb2351 100644 --- a/go/testbus/testbus_integration_test.go +++ b/go/testbus/testbus_integration_test.go @@ -50,6 +50,28 @@ func TestBusAnswersPublishAndKeyValueCreate(t *testing.T) { if string(entry.Value()) != "v" { t.Errorf("read back %q, want %q", entry.Value(), "v") } + // Design 47 H2 §800, H-A-368: the setup bound is half of the level's bound, 30 s when the level has none, and a starved + // setup fails with the one line a build module reads. + t.Run("the setup bound is half the level's and a starved setup says so", func(t *testing.T) { + for _, c := range []struct { + level string + want time.Duration + fails bool + }{{"", 30 * time.Second, false}, {"10m", 5 * time.Minute, false}, {"ten", 0, true}, {"-1s", 0, true}} { + t.Setenv(levelBoundWord, c.level) + f := &failed{TB: t} + var got time.Duration + catch(f, func() { got = SetupBound(f) }) + if c.fails != (f.words != "") || (!c.fails && got != c.want) { + t.Errorf("level %q: bound %s, failed %q", c.level, got, f.words) + } + } + f := &failed{TB: t} + catch(f, func() { Starved(f, "the stream did not answer within 5s") }) + if f.words != "mesh: setup starved: the stream did not answer within 5s" { + t.Errorf("a starved setup said %q", f.words) + } + }) } // 1175/AC3, 1171/AC1: the bus is gone when the test that started it ends. diff --git a/go/testbus/testbus_test.go b/go/testbus/testbus_test.go index 382d9a99..5738fa2d 100644 --- a/go/testbus/testbus_test.go +++ b/go/testbus/testbus_test.go @@ -3,7 +3,6 @@ package testbus import ( "fmt" "testing" - "time" ) // failed is a testing.TB that keeps what a helper failed with, so the helper's own failure is read, not suffered. @@ -26,26 +25,3 @@ func catch(f *failed, run func()) { }() run() } - -// Design 47 H2 §800, H-A-368: the setup bound is half of the level's bound, 30 s when the level has none, and a starved -// setup fails with the one line a build module reads. -func TestTheSetupBoundIsHalfTheLevelsAndAStarvedSetupSaysSo(t *testing.T) { - for _, c := range []struct { - level string - want time.Duration - fails bool - }{{"", 30 * time.Second, false}, {"10m", 5 * time.Minute, false}, {"ten", 0, true}, {"-1s", 0, true}} { - t.Setenv(levelBoundWord, c.level) - f := &failed{TB: t} - var got time.Duration - catch(f, func() { got = SetupBound(f) }) - if c.fails != (f.words != "") || (!c.fails && got != c.want) { - t.Errorf("level %q: bound %s, failed %q", c.level, got, f.words) - } - } - f := &failed{TB: t} - catch(f, func() { Starved(f, "the stream did not answer within 5s") }) - if f.words != "mesh: setup starved: the stream did not answer within 5s" { - t.Errorf("a starved setup said %q", f.words) - } -} diff --git a/go/views/views_test.go b/go/views/views_test.go index 64912fde..d7b4af9f 100644 --- a/go/views/views_test.go +++ b/go/views/views_test.go @@ -1441,6 +1441,52 @@ func (s *pagedSource) Page(after string, _ int, _ time.Duration) ([]KeyedEntry, func TestViews(t *testing.T) { t.Run("Views", subViews) t.Run("StdioWriterPublishesAndListensThroughTheModulesOwnPlumbing", subStdioWriterPublishesAndListensThroughTheModulesOwnPlumbing) + // Design 47 H2 §782: one process reader's pictures are safe at once: gets, keys and watches from many goroutines while + // the owner's events change the picture and further views are followed, under the race detector. + t.Run("one process reader serves concurrent reads", func(t *testing.T) { + made := time.Date(2026, 11, 22, 0, 0, 0, 0, time.UTC) + r := &ProcessReader{Module: "reader", Call: func(string, any) (json.RawMessage, error) { + return json.Marshal(Answer{V: Version, Owner: "o", State: "s", Revision: 1, Created: made, Values: map[string]json.RawMessage{"a": json.RawMessage(`1`)}}) + }} + p, err := r.Follow("o", "s", "o.o_read") + if err != nil { + t.Fatal(err) + } + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + if err := p.Follower().Start(ctx); err != nil { + t.Fatal(err) + } + var wg sync.WaitGroup + wg.Add(1) + go func() { + defer wg.Done() + for i := range 200 { + p.Follower().Apply(Event{V: Version, Owner: "o", State: "s", Key: fmt.Sprintf("k%d", i%7), Revision: uint64(i + 2), Created: made, Value: json.RawMessage(`2`)}) + } + }() + for i := range 16 { + wg.Add(1) + go func() { + defer wg.Done() + w, err := p.Watch(ctx, ">") + if err != nil { + t.Error(err) + return + } + defer w.Stop() + for range 20 { + _, _ = p.Get(ctx, "a") + _, _ = p.Keys(ctx) + _ = r.Followers() + } + if _, err := r.Follow("o", fmt.Sprintf("s%d", i), "o.o_read"); err != nil { + t.Error(err) + } + }() + } + wg.Wait() + }) } type putRecorder struct{ puts map[string][]byte } @@ -1488,50 +1534,3 @@ func TestFirstViewsSayTheOwnBuild(t *testing.T) { t.Errorf("nothing kept: %v", read) } } - -// Design 47 H2 §782: one process reader's pictures are safe at once: gets, keys and watches from many goroutines while -// the owner's events change the picture and further views are followed, under the race detector. -func TestOneProcessReaderServesConcurrentReads(t *testing.T) { - made := time.Date(2026, 11, 22, 0, 0, 0, 0, time.UTC) - r := &ProcessReader{Module: "reader", Call: func(string, any) (json.RawMessage, error) { - return json.Marshal(Answer{V: Version, Owner: "o", State: "s", Revision: 1, Created: made, Values: map[string]json.RawMessage{"a": json.RawMessage(`1`)}}) - }} - p, err := r.Follow("o", "s", "o.o_read") - if err != nil { - t.Fatal(err) - } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - if err := p.Follower().Start(ctx); err != nil { - t.Fatal(err) - } - var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() - for i := range 200 { - p.Follower().Apply(Event{V: Version, Owner: "o", State: "s", Key: fmt.Sprintf("k%d", i%7), Revision: uint64(i + 2), Created: made, Value: json.RawMessage(`2`)}) - } - }() - for i := range 16 { - wg.Add(1) - go func() { - defer wg.Done() - w, err := p.Watch(ctx, ">") - if err != nil { - t.Error(err) - return - } - defer w.Stop() - for range 20 { - _, _ = p.Get(ctx, "a") - _, _ = p.Keys(ctx) - _ = r.Followers() - } - if _, err := r.Follow("o", fmt.Sprintf("s%d", i), "o.o_read"); err != nil { - t.Error(err) - } - }() - } - wg.Wait() -} diff --git a/test/retire.test.ts b/test/retire.test.ts index 4b6f4e71..2a5d4391 100644 --- a/test/retire.test.ts +++ b/test/retire.test.ts @@ -154,7 +154,9 @@ test("asked for again, a retired consumer is created again and announced re-enab } }); -test("five passes are not enough: the same set must also hold for stableForMs", async () => { +test("five passes are not enough: the same set must also hold for stableForMs, ten minutes by default", async () => { + const { STABLE_FOR_MS } = await import("../dist/provider-loop/index.js"); + assert.equal(STABLE_FOR_MS, 10 * 60_000); const HOLD = 400; const w = await world(["a", "b", "c"], { stableForMs: HOLD }); try { @@ -170,11 +172,6 @@ test("five passes are not enough: the same set must also hold for stableForMs", } }); -test("the default hold is ten minutes", async () => { - const { STABLE_FOR_MS } = await import("../dist/provider-loop/index.js"); - assert.equal(STABLE_FOR_MS, 10 * 60_000); -}); - test("an adapter without retire is MARK-ONLY: nothing changes in the backend, remove only on delete", async () => { const w = await world(["a", "b", "c"], { retire: false, del: false }); try { diff --git a/test/seal.test.ts b/test/seal.test.ts index 76d2b8d2..9f3e1322 100644 --- a/test/seal.test.ts +++ b/test/seal.test.ts @@ -13,7 +13,7 @@ const fixture = (name: string) => JSON.parse(readFileSync(join(testdata, name), // ADR 0206's box: every box Go's seal opens (the licence manager's, the agent module's TypeScript) opens here; given // the same one-time key and iv, seal makes Go's box byte for byte, so go/seal's Open opens it; another key and a // changed field are refused. -test("seal and open make and open go/seal's box byte for byte", () => { +test("seal and open make and open go/seal's box, and sealAnonymous Go's anonymous box, byte for byte", () => { const f = fixture("sealed-by-licence-manager.json"); for (const s of f.sealed as { plaintext: string; box: Box }[]) { assert.equal(open(s.box, f.recipient.privateKey), s.plaintext); @@ -33,19 +33,17 @@ test("seal and open make and open go/seal's box byte for byte", () => { assert.throws(() => open(box, b.privateKey), /does not open with this key/); assert.throws(() => open({ ...box, ct: Buffer.from("changed").toString("base64") }, a.privateKey), /does not open/); assert.throws(() => open({ ...box, v: 2 }, a.privateKey), /version 2/); -}); -// The NaCl anonymous box the vault's intake opens: given the same one-time key, sealAnonymous makes what -// golang.org/x/crypto/nacl/box's SealAnonymous made, byte for byte; a fresh one differs and is as long. -test("sealAnonymous makes Go's anonymous box byte for byte", () => { - const f = fixture("sealed-anonymous-by-go.json"); - assert.ok(f.vectors.length > 0); - for (const v of f.vectors as { plaintext: string; ephSecret: string; sealed: string }[]) { - assert.equal(sealAnonymousWith(v.plaintext, f.recipient.public, Buffer.from(v.ephSecret, "base64")), v.sealed); - assert.equal(sealAnonymousWith(Buffer.from(v.plaintext, "utf8"), f.recipient.public, Buffer.from(v.ephSecret, "base64")), v.sealed); + // The NaCl anonymous box the vault's intake opens: given the same one-time key, sealAnonymous makes what + // golang.org/x/crypto/nacl/box's SealAnonymous made, byte for byte; a fresh one differs and is as long. + const an = fixture("sealed-anonymous-by-go.json"); + assert.ok(an.vectors.length > 0); + for (const v of an.vectors as { plaintext: string; ephSecret: string; sealed: string }[]) { + assert.equal(sealAnonymousWith(v.plaintext, an.recipient.public, Buffer.from(v.ephSecret, "base64")), v.sealed); + assert.equal(sealAnonymousWith(Buffer.from(v.plaintext, "utf8"), an.recipient.public, Buffer.from(v.ephSecret, "base64")), v.sealed); } - const fresh = sealAnonymous("a token", f.recipient.public); - assert.notEqual(fresh, sealAnonymous("a token", f.recipient.public)); + const fresh = sealAnonymous("a token", an.recipient.public); + assert.notEqual(fresh, sealAnonymous("a token", an.recipient.public)); assert.equal(Buffer.from(fresh, "base64").length, 32 + 16 + "a token".length); assert.throws(() => sealAnonymous("x", "c2hvcnQ="), /not a raw X25519 public key/); }); diff --git a/test/standing.test.ts b/test/standing.test.ts index 658ec6b4..90bc3610 100644 --- a/test/standing.test.ts +++ b/test/standing.test.ts @@ -224,7 +224,7 @@ test("a failing consumer the mesh stopped asking for is said recovered when it i } }); -test("an error is classed by its words", () => { +test("an error is classed by its words, and an adapter that classes its own errors is believed", async () => { const table: Record = { 'Keycloak token request failed: 401 {"error":"invalid_grant"}': CLASS_CREDENTIALS, 'FATAL: password authentication failed for user "postgres"': CLASS_CREDENTIALS, @@ -235,9 +235,7 @@ test("an error is classed by its words", () => { 'extension "nope" is not available': CLASS_REFUSED, }; for (const [text, want] of Object.entries(table)) assert.equal(classOf(text), want, text); -}); -test("an adapter that classes its own errors is believed", async () => { const w = await world({ classify: true }); try { w.failing = new Error("anything");