FORGE-6: the seat git's whole test runs the forge module's bundle on a real bus

A Go integration test builds the TypeScript bundle and plays its tool
runner over stdin and stdout against a bus of its own and a fixture
forge: a call stopped after two of three merges says one merge-called at
the start; a failed required step refuses its head; two pull requests in
two repositories merge and say one merge-called; a forge refusing the
second merge says what landed and raises merge-partial, cleared by a
later call.

Builds: design 47 H §774 (forge module: tests 111, 114, 115), §734, §735, §736, §766, §767; H-A-61, H-A-87 (1)

Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy
This commit is contained in:
2026-11-20 03:58:00 +01:00
parent 815be6bdce
commit 15458aeb61
2 changed files with 486 additions and 0 deletions
+3
View File
@@ -0,0 +1,3 @@
// Package seatgit holds the whole test of the seat git as the forge module serves it (novox/hq design 47 H §774, H-A-87):
// the module's TypeScript bundle run against a bus of the test alone and a fixture forge. It has no code of its own.
package seatgit
@@ -0,0 +1,483 @@
//go:build integration
package seatgit
// The seat git whole, as the forge module serves it (novox/hq design 47 H §734 to §736, §766, §767, §774; acceptance tests
// 111, 114 and 115; H-A-61, H-A-87): the module's TypeScript bundle, built here and played over its real stdin and stdout
// as the node's tool runner plays it, its states key-value buckets of a nats-server of this test alone, its seat events
// published on that bus and read back from its stream, and the forge an httptest server.
//
// - At its start a call kept unsaid, stopped after the second of three merges, says one merge-called naming the two
// that landed, and is kept said (§766, test 111's stop case).
// - A runner's step-ended of a failed required step at a pull request's head and fingerprint is kept, and a merge call
// naming that head merges nothing and names the step (§735, test 114).
// - A call naming two pull requests in two repositories merges both, in order, and says one merge-called (§734, §736).
// - A forge that refuses the second merge gives one merge-called with the first member and `refused`, and merge-partial
// raised; a later call landing the refused member clears it (§767, test 115).
import (
"bufio"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"os"
"os/exec"
"path/filepath"
"regexp"
"strings"
"sync"
"testing"
"time"
"git.novox.be/novox/mesh-sdk/go/testbus"
"github.com/nats-io/nats.go"
"github.com/nats-io/nats.go/jetstream"
)
const within = 30 * time.Second
// pull is one pull request of the fixture forge.
type pull struct {
repo, base, head string
number int
merged, refuse bool
merge string
}
// forge is the fixture forge: the pull requests by `<owner>/<name>#<number>` and every merge asked.
type forge struct {
mu sync.Mutex
pulls map[string]*pull
merges []string
paths []string
}
func (f *forge) serve(w http.ResponseWriter, r *http.Request) {
f.mu.Lock()
defer f.mu.Unlock()
f.paths = append(f.paths, r.Method+" "+r.URL.Path)
m := regexp.MustCompile(`^/api/v1/repos/([^/]+/[^/]+)/pulls/(\d+)(/merge)?$`).FindStringSubmatch(r.URL.Path)
if m != nil {
p := f.pulls[m[1]+"#"+m[2]]
if p == nil {
http.Error(w, `{"message":"not found"}`, http.StatusNotFound)
return
}
if m[3] != "" && r.Method == http.MethodPost {
f.merges = append(f.merges, m[1]+"#"+m[2])
if p.refuse {
http.Error(w, `{"message":"merge conflict"}`, http.StatusConflict)
return
}
p.merged, p.merge = true, strings.Repeat(fmt.Sprint(p.number%10), 40)
return
}
body := map[string]any{"number": p.number, "title": "t", "state": "open", "merged": p.merged,
"base": map[string]any{"ref": p.base}, "head": map[string]any{"ref": "feat", "sha": p.head}}
if p.merged {
body["state"], body["merge_commit_sha"] = "closed", p.merge
}
_ = json.NewEncoder(w).Encode(body)
return
}
if c := regexp.MustCompile(`^/api/v1/repos/[^/]+/[^/]+/git/commits/([0-9a-f]+)$`).FindStringSubmatch(r.URL.Path); c != nil {
_ = json.NewEncoder(w).Encode(map[string]any{"sha": c[1], "parents": []any{map[string]any{"sha": c[1]}}})
return
}
http.Error(w, `{"message":"the fixture forge serves no `+r.URL.Path+`"}`, http.StatusNotFound)
}
func (f *forge) merged() []string {
f.mu.Lock()
defer f.mu.Unlock()
return append([]string(nil), f.merges...)
}
func (f *forge) asked(prefix string) bool {
f.mu.Lock()
defer f.mu.Unlock()
for _, p := range f.paths {
if strings.HasPrefix(p, prefix) {
return true
}
}
return false
}
// runtime is the half of the conversation the tool runner plays for the bundle.
type runtime struct {
t *testing.T
in io.WriteCloser
js jetstream.JetStream
kvs map[string]jetstream.KeyValue
mu sync.Mutex
next int
wait map[string]chan json.RawMessage
// regs are what the seat mesh-catalog's registrations answers; subs the patterns the bundle subscribed.
regs []map[string]any
subs []string
}
func (r *runtime) subscribed(pattern string) bool {
r.mu.Lock()
defer r.mu.Unlock()
for _, s := range r.subs {
if s == pattern {
return true
}
}
return false
}
func (r *runtime) say(m map[string]any) {
m["jsonrpc"] = "2.0"
raw, _ := json.Marshal(m)
r.mu.Lock()
defer r.mu.Unlock()
_, _ = r.in.Write(append(raw, '\n'))
}
func (r *runtime) read(out io.Reader) {
sc := bufio.NewScanner(out)
sc.Buffer(make([]byte, 1<<20), 1<<24)
for sc.Scan() {
var m struct {
ID json.RawMessage `json:"id"`
Method string `json:"method"`
Params json.RawMessage `json:"params"`
Result json.RawMessage `json:"result"`
}
if json.Unmarshal(sc.Bytes(), &m) != nil {
continue
}
if m.Method == "" {
var id string
_ = json.Unmarshal(m.ID, &id)
r.mu.Lock()
ch := r.wait[id]
delete(r.wait, id)
r.mu.Unlock()
if ch != nil {
ch <- m.Result
}
continue
}
go r.answer(m.ID, m.Method, m.Params)
}
}
// answer is the tool runner's answer to one method the bundle asks.
func (r *runtime) answer(id json.RawMessage, method string, params json.RawMessage) {
var p struct {
State string `json:"state"`
Key string `json:"key"`
Value json.RawMessage `json:"value"`
Subject string `json:"subject"`
Pattern string `json:"pattern"`
Body json.RawMessage `json:"body"`
ID string `json:"id"`
}
_ = json.Unmarshal(params, &p)
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
result, err := func() (any, error) {
kv := r.kvs[p.State]
switch method {
case "mesh/subscribe":
r.mu.Lock()
r.subs = append(r.subs, p.Pattern)
r.mu.Unlock()
return map[string]any{}, nil
case "mesh/publish", "mesh/state.watch", "mesh/seat.record":
return map[string]any{}, nil
case "mesh/capabilities":
return map[string]any{"words": []string{}}, nil
case "mesh/seat.publish":
// The seat's event, published on the bus under its id, as the runtime does.
_, err := r.js.Publish(ctx, p.Subject, p.Body, jetstream.WithMsgID(p.ID))
return map[string]any{}, err
case "mesh/ask":
var a struct {
Key string `json:"key"`
}
_ = json.Unmarshal(params, &a)
switch a.Key {
case "seat:mesh-catalog.registrations":
return map[string]any{"registrations": r.regs}, nil
case "seat:mesh-hand-acts.hand-act":
return map[string]any{}, nil
}
return nil, fmt.Errorf("the runtime answers no ask %s in this test", a.Key)
case "mesh/state.get":
if kv == nil {
return nil, fmt.Errorf("the state %q is not declared", p.State)
}
e, err := kv.Get(ctx, p.Key)
if errors.Is(err, jetstream.ErrKeyNotFound) {
return nil, nil
}
if err != nil {
return nil, err
}
return map[string]any{"key": p.Key, "value": json.RawMessage(e.Value()), "revision": e.Revision()}, nil
case "mesh/state.put":
if kv == nil {
return nil, fmt.Errorf("the state %q is not declared", p.State)
}
rev, err := kv.Put(ctx, p.Key, p.Value)
return map[string]any{"revision": rev}, err
case "mesh/state.delete":
if kv == nil {
return nil, fmt.Errorf("the state %q is not declared", p.State)
}
return map[string]any{}, kv.Delete(ctx, p.Key)
case "mesh/state.keys":
if kv == nil {
return nil, fmt.Errorf("the state %q is not declared", p.State)
}
keys, err := kv.Keys(ctx)
if errors.Is(err, jetstream.ErrNoKeysFound) {
return []string{}, nil
}
return keys, err
case "mesh/state.info":
return map[string]any{"bytes": 0, "keys": 0, "max_bytes": 0}, nil
}
return nil, fmt.Errorf("the runtime offers no %s to this bundle", method)
}()
if id == nil {
return
}
if err != nil {
r.say(map[string]any{"id": id, "error": map[string]any{"code": -32000, "message": err.Error()}})
return
}
r.say(map[string]any{"id": id, "result": result})
}
// ask sends the bundle one request and answers its result.
func (r *runtime) ask(method string, params map[string]any) json.RawMessage {
r.t.Helper()
r.mu.Lock()
r.next++
id := fmt.Sprintf("rt-%d", r.next)
ch := make(chan json.RawMessage, 1)
r.wait[id] = ch
r.mu.Unlock()
r.say(map[string]any{"id": id, "method": method, "params": params})
select {
case raw := <-ch:
return raw
case <-time.After(within):
r.t.Fatalf("%s was not answered in %s", method, within)
}
return nil
}
// mergePull calls the seat's verb as a proved caller and answers its result.
func (r *runtime) mergePull(pulls ...map[string]any) map[string]any {
r.t.Helper()
raw := r.ask("tools/call", map[string]any{"name": "git.merge-pull", "_meta": map[string]any{"mesh/caller": "shanks.claude-code"},
"arguments": map[string]any{"by": "lead@shanks", "pulls": pulls}})
var res struct {
Content []struct {
Text string `json:"text"`
} `json:"content"`
}
var out map[string]any
if json.Unmarshal(raw, &res) != nil || len(res.Content) == 0 || json.Unmarshal([]byte(res.Content[0].Text), &out) != nil {
r.t.Fatalf("merge-pull answered %s", raw)
}
return out
}
func until(t *testing.T, what string, ok func() bool) {
t.Helper()
deadline := time.Now().Add(within)
for !ok() {
if time.Now().After(deadline) {
t.Fatalf("within %s: %s did not happen", within, what)
}
select {
case <-time.After(20 * time.Millisecond):
}
}
}
// said is every merge-called on the bus so far, by call.
func said(t *testing.T, js jetstream.JetStream) map[string]map[string]any {
t.Helper()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
out := map[string]map[string]any{}
s, err := js.Stream(ctx, "SEAT_git_merge-called")
if err != nil {
t.Fatal(err)
}
info, err := s.Info(ctx)
if err != nil {
t.Fatal(err)
}
for seq := info.State.FirstSeq; seq <= info.State.LastSeq && info.State.Msgs > 0; seq++ {
m, err := s.GetMsg(ctx, seq)
if err != nil {
continue
}
var body map[string]any
_ = json.Unmarshal(m.Data, &body)
out[strings.TrimPrefix(m.Subject, "mesh.seat.git.event.merge-called.")] = body
}
return out
}
func numbers(v any) []float64 {
var out []float64
list, _ := v.([]any)
for _, m := range list {
n, _ := m.(map[string]any)["number"].(float64)
out = append(out, n)
}
return out
}
func TestTheSeatGitWholeOverARealBus(t *testing.T) {
dir, err := filepath.Abs(filepath.Join("..", ".."))
if err != nil {
t.Fatal(err)
}
if _, err := os.Stat(filepath.Join(dir, "node_modules", "@novox", "mesh-sdk")); err != nil {
t.Fatalf("the forge module's packages are not installed in %s (npm install first): %v", dir, err)
}
build := exec.Command("npm", "run", "build")
build.Dir = dir
if out, err := build.CombinedOutput(); err != nil {
t.Fatalf("the bundle does not build: %v\n%s", err, out)
}
nc, err := nats.Connect(testbus.URL(t))
if err != nil {
t.Fatal(err)
}
t.Cleanup(nc.Close)
js, _ := jetstream.New(nc)
ctx := context.Background()
// The seat's stream merge-called is kept on (the definition's keep); the template states as buckets.
if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "SEAT_git_merge-called", Subjects: []string{"mesh.seat.git.event.merge-called.*"}}); err != nil {
t.Fatal(err)
}
kvs := map[string]jetstream.KeyValue{}
for _, name := range []string{"bound", "announced", "findings", "first-views", "transfers", "idle", "failed-steps", "calls"} {
kv, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: "gitea_" + name})
if err != nil {
t.Fatal(err)
}
kvs[name] = kv
}
A, B, X := strings.Repeat("a", 40), strings.Repeat("b", 40), strings.Repeat("e", 40)
// A call stopped after the second of three merges, kept and not said (§766).
stopped, _ := json.Marshal(map[string]any{"by": "lead@shanks", "account": "shanks.claude-code", "at": "2026-11-20T03:00:00Z", "said": false,
"members": []any{
map[string]any{"repository": "novox/app", "number": 1, "branch": "main", "head": A, "state": "merged", "commit": strings.Repeat("1", 40)},
map[string]any{"repository": "novox/app", "number": 2, "branch": "main", "head": A, "state": "merged", "commit": strings.Repeat("2", 40)},
map[string]any{"repository": "novox/app", "number": 3, "branch": "main", "head": A, "state": "judged"}}})
if _, err := kvs["calls"].Put(ctx, "call.00000000000000cc", stopped); err != nil {
t.Fatal(err)
}
f := &forge{pulls: map[string]*pull{
"novox/app#5": {repo: "novox/app", base: "main", head: A, number: 5},
"novox/app#6": {repo: "novox/app", base: "main", head: X, number: 6},
"novox/app#7": {repo: "novox/app", base: "main", head: A, number: 7},
"novox/lib#9": {repo: "novox/lib", base: "main", head: B, number: 9, refuse: true},
"novox/lib#10": {repo: "novox/lib", base: "main", head: B, number: 10},
}}
srv := httptest.NewServer(http.HandlerFunc(f.serve))
t.Cleanup(srv.Close)
state := t.TempDir()
launch := `const sdk = await import("@novox/mesh-sdk/stdio"); await import("./dist/index.js"); await import("./dist/tools/index.js"); await sdk.serveRegisteredOverStdio("gitea");`
cmd := exec.Command("node", "--input-type=module", "-e", launch)
cmd.Dir = dir
cmd.Env = append(os.Environ(), "MESH_SERVED_MODULE=gitea", "MESH_MODULE=gitea", "MESH_NODE=test", "MESH_GITEA_URL="+srv.URL,
"GITEA_TOKEN=t", "MESH_GITEA_STATE_DIR="+state, "MESH_GITEA_HOOK_PORT=0", "MESH_GITEA_CONFIG_FILE="+filepath.Join(state, "config.json"))
in, _ := cmd.StdinPipe()
out, _ := cmd.StdoutPipe()
cmd.Stderr = testLog{t}
if err := cmd.Start(); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = in.Close(); _ = cmd.Process.Kill(); _ = cmd.Wait() })
rt := &runtime{t: t, in: in, js: js, kvs: kvs, wait: map[string]chan json.RawMessage{}, regs: []map[string]any{
{"module": "app", "origin": "novox/app", "branches": []string{"main"}},
{"module": "lib", "origin": "novox/lib", "branches": []string{"main"}}}}
go rt.read(out)
// At the start the stopped call says one merge-called naming the two that landed (§766).
until(t, "the stopped call's merge-called at the start", func() bool { return said(t, js)["00000000000000cc"] != nil })
if got := numbers(said(t, js)["00000000000000cc"]["members"]); fmt.Sprint(got) != "[1 2]" {
t.Fatalf("the stopped call names %v, not the two that landed", got)
}
until(t, "the stopped call kept said", func() bool {
e, err := kvs["calls"].Get(ctx, "call.00000000000000cc")
return err == nil && strings.Contains(string(e.Value()), `"said":true`)
})
// The registrations are read, and the heads with them, before a merge is judged against them.
until(t, "the watched heads read after the registrations", func() bool { return f.asked("GET /api/v1/repos/novox/app/branches") })
// A failed required step at a head's fingerprint refuses that head (§735, test 114), heard on the module's consumer.
until(t, "the runner's step-ended followed", func() bool { return rt.subscribed("mesh-pipeline-runner.step-ended.*.*.*") })
rt.ask("mesh/event", map[string]any{"envelope": map[string]any{"key": "mesh-pipeline-runner.step-ended.app.main." + X, "node": "test",
"body": map[string]any{"v": 1, "pipeline": "main.4", "module": "app", "branch": "main", "commit": X, "fingerprint": "fp-x",
"at": "2026-11-20T03:00:00Z", "result": map[string]any{"step": "unit", "status": "required", "outcome": "failed"}}}})
refused := rt.mergePull(map[string]any{"repository": "novox/app", "number": 6, "head": X})
members, _ := refused["members"].([]any)
if len(members) != 1 || members[0].(map[string]any)["state"] != "refused" ||
!strings.Contains(fmt.Sprint(members[0].(map[string]any)["why"]), "the unit step of app failed in run main.4") {
t.Fatalf("a head at a failed required step's fingerprint answered %v", refused)
}
if got := f.merged(); len(got) != 0 {
t.Fatalf("merged %v", got)
}
// Two pull requests in two repositories merge, in order, and say one merge-called (§734, §736).
both := rt.mergePull(map[string]any{"repository": "novox/app", "number": 7, "head": A}, map[string]any{"repository": "novox/lib", "number": 10, "head": B})
call, _ := both["call"].(string)
until(t, "the merge-called of the two", func() bool { return said(t, js)[call] != nil })
if got := numbers(said(t, js)[call]["members"]); fmt.Sprint(got) != "[7 10]" || fmt.Sprint(f.merged()) != "[novox/app#7 novox/lib#10]" {
t.Fatalf("the call of two said %v, merged %v", got, f.merged())
}
// The forge refuses the second merge: merge-called with the first and refused, merge-partial raised (§767, test 115).
partial := rt.mergePull(map[string]any{"repository": "novox/app", "number": 5, "head": A}, map[string]any{"repository": "novox/lib", "number": 9, "head": B})
pc, _ := partial["call"].(string)
until(t, "the partial call's merge-called", func() bool { return said(t, js)[pc] != nil })
body := said(t, js)[pc]
if fmt.Sprint(numbers(body["members"])) != "[5]" || fmt.Sprint(numbers(body["refused"])) != "[9]" {
t.Fatalf("the partial call said %v", body)
}
key := "delivery." + pc + ".merge-partial"
if e, err := kvs["findings"].Get(ctx, key); err != nil || !strings.Contains(string(e.Value()), `"severity":"urgent"`) {
t.Fatalf("merge-partial %s is not raised: %v", key, err)
}
// A later call landing the refused member clears it.
f.mu.Lock()
f.pulls["novox/lib#9"].refuse = false
f.mu.Unlock()
rt.mergePull(map[string]any{"repository": "novox/lib", "number": 9, "head": B})
until(t, "merge-partial cleared by the later call", func() bool {
_, err := kvs["findings"].Get(ctx, key)
return errors.Is(err, jetstream.ErrKeyNotFound)
})
}
type testLog struct{ t *testing.T }
func (w testLog) Write(p []byte) (int, error) {
defer func() { _ = recover() }()
w.t.Logf("bundle: %s", strings.TrimRight(string(p), "\n"))
return len(p), nil
}