Round 2 T2, T3, T4, T5: the tool runner ends G with its merge-base test count; the wait test runs its rows side by side

The tests G added fold into existing ones as subtests (design 47 G §626, A-306: 171 tests down to 154, integration 9
down to 7). TestMeshWaitRefusesLoudlyAndNeverLoops runs its groups of one-second rows as parallel subtests, each
on a runtime of its own, 15 s down to 5 s (A-311: the one-second floor of a wait's timeout stands, no clock is
injected). The go.mod no longer requires meshconditionsclient, which no package loads (T4). Node names in the
lines G adds are role names (T5).

Builds: design 47 G §626, design 34 every-event §19, A-306, A-311; review round 2 findings T2, T3, T4, T5
Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h

node-tools/internal/bus/chunked_test.go

@@ -73,46 +73,45 @@ func TestAChunkedSeatAnswerIsReceivedByTheRunnerAndHandedWhole(t *testing.T) {
 	if body, err := base64.StdEncoding.DecodeString(ans.File); err != nil || string(body) != string(file) {
 		t.Errorf("the file handed is %d bytes, want the %d sent: %v", len(body), len(file), err)
 	}
-}
-
-// Design 47 G A-257, A-254: a bundle answers a chunked verb with the whole file in the member `file`; the runner that serves the
-// verb sends the file in chunks (each acknowledged before the next) and answers the count, so the bundle sends none, and the asker
-// of one node's verb receives it whole.
-func TestABundlesChunkedAnswerIsSentByTheRunner(t *testing.T) {
-	url := mt.URL(t)
-	holder := dial(t, url, "mesh-build-go", "anchor", "")
-	asker := dial(t, url, "mesh-delivery-indexer", "anchor", "")
-	file := make([]byte, buscalls.SeatChunkBytes*2+7)
-	for i := range file {
-		file[i] = byte(i * 7)
-	}
-	stop, err := holder.Handle("seat:node-build-go.output@anchor", func(body json.RawMessage) (any, error) {
-		answer := map[string]any{"ask": "a1", "file": base64.StdEncoding.EncodeToString(file)}
-		return holder.AnswerChunked("node-build-go", "output", body, answer)
+	// Design 47 G A-257, A-254: a bundle answers a chunked verb with the whole file in the member `file`; the runner that serves the
+	// verb sends the file in chunks (each acknowledged before the next) and answers the count, so the bundle sends none, and the asker
+	// of one node's verb receives it whole.
+	t.Run("ABundlesChunkedAnswerIsSentByTheRunner", func(t *testing.T) {
+		url := mt.URL(t)
+		holder := dial(t, url, "mesh-build-go", "anchor", "")
+		asker := dial(t, url, "mesh-delivery-indexer", "anchor", "")
+		file := make([]byte, buscalls.SeatChunkBytes*2+7)
+		for i := range file {
+			file[i] = byte(i * 7)
+		}
+		stop, err := holder.Handle("seat:node-build-go.output@anchor", func(body json.RawMessage) (any, error) {
+			answer := map[string]any{"ask": "a1", "file": base64.StdEncoding.EncodeToString(file)}
+			return holder.AnswerChunked("node-build-go", "output", body, answer)
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer stop()
+		holder.Flush() // the bus holds the verb's subscription before it is asked: the asker is another connection
+		got, err := asker.AskAsChunked("mesh-delivery-indexer", "seat:node-build-go.output@anchor", map[string]any{"ask": "a1"})
+		if err != nil {
+			t.Fatal(err)
+		}
+		var ans struct {
+			Ask    string `json:"ask"`
+			Chunks int    `json:"chunks"`
+			File   string `json:"file"`
+		}
+		if err := json.Unmarshal(got.Result, &ans); err != nil || ans.Ask != "a1" || ans.Chunks != 3 {
+			t.Fatalf("the answer %s: %v", got.Result, err)
+		}
+		if body, err := base64.StdEncoding.DecodeString(ans.File); err != nil || string(body) != string(file) {
+			t.Errorf("the file handed is %d bytes, want the %d sent: %v", len(body), len(file), err)
+		}
+		// an answer with no file is the verb's own: no chunks are sent
+		plain, err := holder.AnswerChunked("node-build-go", "output", json.RawMessage(`{"call":"c"}`), map[string]any{"ask": "x", "chunks": 0})
+		if m, _ := plain.(map[string]any); err != nil || m["chunks"] != 0 {
+			t.Fatalf("an answer with no file was %v, %v", plain, err)
+		}
 	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer stop()
-	holder.Flush() // the bus holds the verb's subscription before it is asked: the asker is another connection
-	got, err := asker.AskAsChunked("mesh-delivery-indexer", "seat:node-build-go.output@anchor", map[string]any{"ask": "a1"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	var ans struct {
-		Ask    string `json:"ask"`
-		Chunks int    `json:"chunks"`
-		File   string `json:"file"`
-	}
-	if err := json.Unmarshal(got.Result, &ans); err != nil || ans.Ask != "a1" || ans.Chunks != 3 {
-		t.Fatalf("the answer %s: %v", got.Result, err)
-	}
-	if body, err := base64.StdEncoding.DecodeString(ans.File); err != nil || string(body) != string(file) {
-		t.Errorf("the file handed is %d bytes, want the %d sent: %v", len(body), len(file), err)
-	}
-	// an answer with no file is the verb's own: no chunks are sent
-	plain, err := holder.AnswerChunked("node-build-go", "output", json.RawMessage(`{"call":"c"}`), map[string]any{"ask": "x", "chunks": 0})
-	if m, _ := plain.(map[string]any); err != nil || m["chunks"] != 0 {
-		t.Fatalf("an answer with no file was %v, %v", plain, err)
-	}
 }

node-tools/internal/bus/sent_test.go

@@ -1,27 +0,0 @@
-package bus
-
-import (
-	"strings"
-	"testing"
-
-	"git.novox.be/novox/mesh-sdk/go/buscalls"
-)
-
-// Design 47 G §347, §59, §462: a sent object is read by the reference that carried it, from a sender's sent store only; a
-// state's objects, and a reference that is none are refused before the bus is asked.
-func TestSentGetRefusesWhatIsNoSentObjectsReference(t *testing.T) {
-	digest := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-	for _, c := range []struct {
-		name string
-		req  buscalls.ObjectsSentGetRequest
-		want string
-	}{
-		{"no digest", buscalls.ObjectsSentGetRequest{Store: "m_sent-objects", Object: "o", Size: 3}, "named by the reference"},
-		{"a state's objects", buscalls.ObjectsSentGetRequest{Store: "m_asks-objects", Object: "o", Size: 3, Digest: digest}, "no sent store"},
-	} {
-		_, err := (&Conn{}).SentGet(c.req)
-		if err == nil || !strings.Contains(err.Error(), c.want) {
-			t.Errorf("%s: got %v, want an error containing %q", c.name, err, c.want)
-		}
-	}
-}

node-tools/internal/bus/state_watch_test.go

@@ -87,6 +87,74 @@ func TestAWatchHoldsWhileItsCurrentValuesKeepArriving(t *testing.T) {
 		}
 		return nil
 	})
+	// **A watch given up, or stopped, hands over nothing more** (issue 774). The runtime's watch stopped its watcher
+	// when the current values did not arrive within the bound, but the watcher still held values, and its goroutine
+	// went on handing them over: to a watch id the bundle no longer held (on the provisioner, 51 failed watches were
+	// followed by 1257 orphan changes). Each row blocks the bundle on its first value, gives the watch up, lets the
+	// bundle go and counts what it is still handed.
+	t.Run("AWatchGivenUpHandsOverNothingMore", func(t *testing.T) {
+		for _, tc := range []struct {
+			name    string
+			refused bool // the bound gives it up, or the caller stops it
+		}{
+			{"refused at the bound", true},
+			{"stopped by its caller", false},
+		} {
+			t.Run(tc.name, func(t *testing.T) {
+				was := bus.StateTimeout
+				bus.StateTimeout = 300 * time.Millisecond
+				t.Cleanup(func() { bus.StateTimeout = was })
+				conn, kv := owedWatcher(t)
+				put := func(i int) {
+					if _, err := kv.Put(fmt.Sprintf("novox/hq.%d.%040x.status=mesh/check", i+1, i), []byte(`{"v":1}`)); err != nil {
+						t.Fatal(err)
+					}
+				}
+				if tc.refused {
+					for i := 0; i < 4; i++ {
+						put(i)
+					}
+				}
+				var calls atomic.Int32
+				first := make(chan struct{}, 1)
+				release := make(chan struct{})
+				deliver := func(ch bus.StateChange) error {
+					if calls.Add(1) == 1 {
+						first <- struct{}{}
+						<-release
+					}
+					return nil
+				}
+				var stop func()
+				if tc.refused {
+					if _, err := conn.StateWatch("gitea", "mesh-delivery-checker.owed", "", deliver); err == nil {
+						t.Fatal("the watch whose bundle took nothing was not refused")
+					}
+				} else {
+					var err error
+					if stop, err = conn.StateWatch("gitea", "mesh-delivery-checker.owed", "", deliver); err != nil {
+						t.Fatal(err)
+					}
+					for i := 0; i < 4; i++ {
+						put(i)
+					}
+					select {
+					case <-first:
+					case <-time.After(5 * time.Second):
+						t.Fatal("the bundle was handed no change")
+					}
+					stop()
+				}
+				// Let the watcher's server side deliver what it held, then free the bundle.
+				time.Sleep(300 * time.Millisecond)
+				close(release)
+				time.Sleep(500 * time.Millisecond)
+				if n := calls.Load(); n != 1 {
+					t.Fatalf("the bundle was handed %d changes of a watch given up, want 1 (the one in hand)", n)
+				}
+			})
+		}
+	})
 }
 
 // A watch whose bundle takes nothing for longer than the bound is still refused, so a bundle that hangs
@@ -187,72 +255,3 @@ func owedWatcher(t *testing.T) (*bus.Conn, interface {
 	})
 	return conn, kv
 }
-
-// **A watch given up, or stopped, hands over nothing more** (issue 774). The runtime's watch stopped its watcher
-// when the current values did not arrive within the bound, but the watcher still held values, and its goroutine
-// went on handing them over: to a watch id the bundle no longer held (on the provisioner, 51 failed watches were
-// followed by 1257 orphan changes). Each row blocks the bundle on its first value, gives the watch up, lets the
-// bundle go and counts what it is still handed.
-func TestAWatchGivenUpHandsOverNothingMore(t *testing.T) {
-	for _, tc := range []struct {
-		name    string
-		refused bool // the bound gives it up, or the caller stops it
-	}{
-		{"refused at the bound", true},
-		{"stopped by its caller", false},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			was := bus.StateTimeout
-			bus.StateTimeout = 300 * time.Millisecond
-			t.Cleanup(func() { bus.StateTimeout = was })
-			conn, kv := owedWatcher(t)
-			put := func(i int) {
-				if _, err := kv.Put(fmt.Sprintf("novox/hq.%d.%040x.status=mesh/check", i+1, i), []byte(`{"v":1}`)); err != nil {
-					t.Fatal(err)
-				}
-			}
-			if tc.refused {
-				for i := 0; i < 4; i++ {
-					put(i)
-				}
-			}
-			var calls atomic.Int32
-			first := make(chan struct{}, 1)
-			release := make(chan struct{})
-			deliver := func(ch bus.StateChange) error {
-				if calls.Add(1) == 1 {
-					first <- struct{}{}
-					<-release
-				}
-				return nil
-			}
-			var stop func()
-			if tc.refused {
-				if _, err := conn.StateWatch("gitea", "mesh-delivery-checker.owed", "", deliver); err == nil {
-					t.Fatal("the watch whose bundle took nothing was not refused")
-				}
-			} else {
-				var err error
-				if stop, err = conn.StateWatch("gitea", "mesh-delivery-checker.owed", "", deliver); err != nil {
-					t.Fatal(err)
-				}
-				for i := 0; i < 4; i++ {
-					put(i)
-				}
-				select {
-				case <-first:
-				case <-time.After(5 * time.Second):
-					t.Fatal("the bundle was handed no change")
-				}
-				stop()
-			}
-			// Let the watcher's server side deliver what it held, then free the bundle.
-			time.Sleep(300 * time.Millisecond)
-			close(release)
-			time.Sleep(500 * time.Millisecond)
-			if n := calls.Load(); n != 1 {
-				t.Fatalf("the bundle was handed %d changes of a watch given up, want 1 (the one in hand)", n)
-			}
-		})
-	}
-}

node-tools/internal/bus/streams_internal_test.go

@@ -1,6 +1,11 @@
 package bus
 
-import "testing"
+import (
+	"strings"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/buscalls"
+)
 
 // novox/hq ADR 0363 §2, §3: an event goes to the stream whose pattern carries it, as the bus matches subjects.
 func TestAnEventFallsUnderAStreamsPatternAsTheBusMatchesIt(t *testing.T) {
@@ -22,6 +27,24 @@ func TestAnEventFallsUnderAStreamsPatternAsTheBusMatchesIt(t *testing.T) {
 			t.Errorf("%q under %q: %v, want %v", c.event, c.pattern, got, c.want)
 		}
 	}
+	// Design 47 G §347, §59, §462: a sent object is read by the reference that carried it, from a sender's sent store only; a
+	// state's objects, and a reference that is none are refused before the bus is asked.
+	t.Run("SentGetRefusesWhatIsNoSentObjectsReference", func(t *testing.T) {
+		digest := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+		for _, c := range []struct {
+			name string
+			req  buscalls.ObjectsSentGetRequest
+			want string
+		}{
+			{"no digest", buscalls.ObjectsSentGetRequest{Store: "m_sent-objects", Object: "o", Size: 3}, "named by the reference"},
+			{"a state's objects", buscalls.ObjectsSentGetRequest{Store: "m_asks-objects", Object: "o", Size: 3, Digest: digest}, "no sent store"},
+		} {
+			_, err := (&Conn{}).SentGet(c.req)
+			if err == nil || !strings.Contains(err.Error(), c.want) {
+				t.Errorf("%s: got %v, want an error containing %q", c.name, err, c.want)
+			}
+		}
+	})
 }
 
 // A membership naming no stream publishes every event on EVENTS, exactly as before (issue 725).