jschoubben
4628ba26b4
mesh/delivery merged: source.main moved to novox/mesh-delivery@db53ec975f01
mesh/delivery-group group fix/1945-ask-again-and-why merged: every member is merged
mesh/check pass 4628ba26b41a on 73be3df28cd4 | unit 167 run, 443 kept | integration 177 run, 509 kept | composition passed on 3 machines
The open helpers were copied into seven parts; code shared between modules lives in mesh-sdk, so they are mesh-sdk process's now and the parts are pinned at fix/1945-optional-buckets (e0d1de04), moved to its main once it merges, one delivery group with mesh-sdk.
251 lines
11 KiB
Go
251 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"slices"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/process"
|
|
|
|
"github.com/nats-io/nats.go"
|
|
"github.com/nats-io/nats.go/jetstream"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
|
|
"mesh-delivery-forge-bridge/internal/bridge"
|
|
)
|
|
|
|
const head = "0123456789abcdef0123456789abcdef01234567"
|
|
|
|
type fakeMsg struct {
|
|
subject string
|
|
data []byte
|
|
acked, termd int
|
|
nak []time.Duration
|
|
}
|
|
|
|
func (f *fakeMsg) Subject() string { return f.subject }
|
|
func (f *fakeMsg) Data() []byte { return f.data }
|
|
func (f *fakeMsg) Headers() nats.Header { return nats.Header{"X-Event-Id": {"ev-1"}} }
|
|
func (f *fakeMsg) Ack() error { f.acked++; return nil }
|
|
func (f *fakeMsg) NakWithDelay(d time.Duration) error { f.nak = append(f.nak, d); return nil }
|
|
func (f *fakeMsg) Term() error { f.termd++; return nil }
|
|
|
|
type fakePub struct {
|
|
subjects []string
|
|
data [][]byte
|
|
err error
|
|
}
|
|
|
|
func (p *fakePub) Publish(_ context.Context, subject string, payload []byte, _ ...jetstream.PublishOpt) (*jetstream.PubAck, error) {
|
|
if p.err != nil {
|
|
return nil, p.err
|
|
}
|
|
p.subjects, p.data = append(p.subjects, subject), append(p.data, payload)
|
|
return &jetstream.PubAck{}, nil
|
|
}
|
|
|
|
// body is gitea.pull.updated as mesh-catalog modules/gitea/trunk.ts:233-250 writes it (the fields the bridge reads).
|
|
func body(m map[string]any) []byte {
|
|
base := map[string]any{"owner": "novox", "repo": "mesh-delivery", "number": 12, "head": "feat/x", "head_sha": head,
|
|
"module_dirs": []string{"modules/a"}, "module_dirs_said": true}
|
|
for k, v := range m {
|
|
if v == nil {
|
|
delete(base, k)
|
|
} else {
|
|
base[k] = v
|
|
}
|
|
}
|
|
b, _ := json.Marshal(base)
|
|
return b
|
|
}
|
|
|
|
func TestReadableEventIsWrittenOnForgeAndAcked(t *testing.T) { // 1235/AC2 (unit part; the bus is the integration test)
|
|
t.Run("1945: a refused bucket is said, or stops the start naming its grant", func(t *testing.T) {
|
|
refusal := errors.New("nats: permissions violation for publish to $JS.API.STREAM.INFO.KV_x")
|
|
var said []string
|
|
if kv := process.OptionalBucket(context.Background(), refusingBus{refusal}, "x", "x is not heard", func(f string, a ...any) { said = append(said, fmt.Sprintf(f, a...)) }); kv != nil || len(said) != 1 || !strings.Contains(said[0], "permissions violation") {
|
|
t.Errorf("an optional bucket refused: %v, said %v", kv, said)
|
|
}
|
|
if _, err := process.EssentialBucket(context.Background(), refusingBus{refusal}, "bridge", "x", "work"); err == nil || !strings.Contains(err.Error(), "grant of x") {
|
|
t.Errorf("an essential bucket refused: %v, want its grant named", err)
|
|
}
|
|
})
|
|
var logs bytes.Buffer
|
|
m, pub := &fakeMsg{subject: "mesh.mod.gitea.event.pull.updated", data: body(nil)}, &fakePub{}
|
|
handle(context.Background(), m, pub, nil, someFiles, log.New(&logs, "", 0))
|
|
if len(pub.subjects) != 1 || pub.subjects[0] != "mesh.stream.mesh-delivery-forge-bridge.event.forge.novox.mesh-delivery.pull" {
|
|
t.Fatalf("published on %v", pub.subjects)
|
|
}
|
|
f, err := delivery.DecodeForge(pub.data[0])
|
|
if err != nil || f.Number != 12 || f.Branch != "feat/x" || f.Head != head || f.Action != "updated" || !f.DirsKnown {
|
|
t.Errorf("message %+v err %v", f, err)
|
|
}
|
|
if m.acked != 1 || m.termd != 0 {
|
|
t.Errorf("acked %d terminated %d", m.acked, m.termd)
|
|
}
|
|
}
|
|
|
|
func TestUnreadableEventIsTerminatedAndLogged(t *testing.T) { // 1235/AC5
|
|
var logs bytes.Buffer
|
|
m, pub := &fakeMsg{subject: "mesh.mod.gitea.event.pull.updated", data: body(map[string]any{"head_sha": "short"})}, &fakePub{}
|
|
handle(context.Background(), m, pub, nil, someFiles, log.New(&logs, "", 0))
|
|
if len(pub.subjects) != 0 {
|
|
t.Errorf("a message was written: %v", pub.subjects)
|
|
}
|
|
if m.termd != 1 || m.acked != 0 {
|
|
t.Errorf("terminated %d acked %d, want terminated once", m.termd, m.acked)
|
|
}
|
|
if !strings.Contains(logs.String(), "mesh.mod.gitea.event.pull.updated") || !strings.Contains(logs.String(), "head") {
|
|
t.Errorf("log %q names neither the subject nor why", logs.String())
|
|
}
|
|
}
|
|
|
|
func TestUnwrittenMessageIsNotAcked(t *testing.T) { // 1235 (a failed write is redelivered by the server, not retried here)
|
|
var logs bytes.Buffer
|
|
m, pub := &fakeMsg{subject: "mesh.mod.gitea.event.pull.updated", data: body(nil)}, &fakePub{err: errors.New("no stream")}
|
|
handle(context.Background(), m, pub, nil, someFiles, log.New(&logs, "", 0))
|
|
if m.acked != 0 || m.termd != 0 {
|
|
t.Errorf("acked %d terminated %d, want neither", m.acked, m.termd)
|
|
}
|
|
if !strings.Contains(logs.String(), "no stream") {
|
|
t.Errorf("log %q", logs.String())
|
|
}
|
|
}
|
|
|
|
// mergedEvent is gitea.pull.merged as mesh-catalog modules/gitea/index.ts:186-207 writes it (the fields the bridge reads).
|
|
func mergedEvent() []byte {
|
|
b, _ := json.Marshal(map[string]any{"owner": "novox", "repo": "mesh-delivery", "number": 12, "head": "feat/x", "head_sha": head,
|
|
"base": "main", "merge_commit_sha": "89abcdef0123456789abcdef0123456789abcdef"})
|
|
return b
|
|
}
|
|
|
|
func TestTreesRefusedLeavesTheEventForTenSecondsAndLogs(t *testing.T) { // 1236/AC3
|
|
var logs bytes.Buffer
|
|
m, pub := &fakeMsg{subject: "mesh.mod.gitea.event.pull.merged", data: mergedEvent()}, &fakePub{}
|
|
call := func(context.Context, string, any) (json.RawMessage, error) {
|
|
return nil, errors.New("the tree listing of novox/mesh-delivery was cut")
|
|
}
|
|
handle(context.Background(), m, pub, treesVia(context.Background(), call), filesVia(context.Background(), call), log.New(&logs, "", 0))
|
|
if len(pub.subjects) != 0 {
|
|
t.Errorf("a message was written: %v", pub.subjects)
|
|
}
|
|
if m.acked != 0 || m.termd != 0 || len(m.nak) != 1 || m.nak[0] < 10*time.Second {
|
|
t.Errorf("acked %d terminated %d naks %v, want one nak of at least 10 s", m.acked, m.termd, m.nak)
|
|
}
|
|
for _, w := range []string{"novox/mesh-delivery", "89abcdef0123456789abcdef0123456789abcdef", "the tree listing of novox/mesh-delivery was cut"} {
|
|
if !strings.Contains(logs.String(), w) {
|
|
t.Errorf("log %q does not name %q", logs.String(), w)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMergeCallsTheToolOnceAndWritesTheMergedMessage(t *testing.T) { // 1236/AC1 (through the tool's request and answer)
|
|
var logs bytes.Buffer
|
|
m, pub := &fakeMsg{subject: "mesh.mod.gitea.event.pull.merged", data: mergedEvent()}, &fakePub{}
|
|
var keys []string
|
|
var args []any
|
|
var mu sync.Mutex // the files are asked for concurrently (issue 1458)
|
|
call := func(_ context.Context, key string, body any) (json.RawMessage, error) {
|
|
mu.Lock()
|
|
keys, args = append(keys, key), append(args, body)
|
|
mu.Unlock()
|
|
if key == "gitea.gitea_get_file" { // the manifests, 1448; the trees are what this test is about
|
|
return json.RawMessage(`{"file":{"path":"p","sha":"0123","size":2,"content":"{}"}}`), nil
|
|
}
|
|
return json.RawMessage(`{"root":"r0","trees":{"":"t0","modules/a":"t1"}}`), nil
|
|
}
|
|
handle(context.Background(), m, pub, treesVia(context.Background(), call), filesVia(context.Background(), call), log.New(&logs, "", 0))
|
|
if len(keys) == 0 || keys[0] != "gitea.gitea_commit_trees" || slices.Index(keys[1:], "gitea.gitea_commit_trees") >= 0 {
|
|
t.Fatalf("calls %v, want the trees once and first", keys)
|
|
}
|
|
if got, _ := json.Marshal(args[0]); string(got) != `{"owner":"novox","repo":"mesh-delivery","sha":"89abcdef0123456789abcdef0123456789abcdef"}` {
|
|
t.Errorf("arguments %s", got)
|
|
}
|
|
if len(pub.subjects) != 1 || pub.subjects[0] != "mesh.stream.mesh-delivery-forge-bridge.event.forge.novox.mesh-delivery.merged" {
|
|
t.Fatalf("published on %v", pub.subjects)
|
|
}
|
|
f, err := delivery.DecodeForge(pub.data[0])
|
|
if err != nil || f.Root != "r0" || f.Trees[""] != "t0" || f.Trees["modules/a"] != "t1" || f.Merge == "" {
|
|
t.Errorf("message %+v err %v", f, err)
|
|
}
|
|
if m.acked != 1 {
|
|
t.Errorf("acked %d", m.acked)
|
|
}
|
|
}
|
|
|
|
func TestAnAnswerWithoutARootIsNotUsed(t *testing.T) { // 1236 (a shape the tool does not answer)
|
|
call := func(context.Context, string, any) (json.RawMessage, error) {
|
|
return json.RawMessage(`{"trees":{"a":"t"}}`), nil
|
|
}
|
|
if _, _, err := treesVia(context.Background(), call)("o", "r", "s"); err == nil {
|
|
t.Error("an answer with no root was taken")
|
|
}
|
|
call = func(context.Context, string, any) (json.RawMessage, error) { return json.RawMessage(`[1]`), nil }
|
|
if _, _, err := treesVia(context.Background(), call)("o", "r", "s"); err == nil {
|
|
t.Error("an answer that is not an object was taken")
|
|
}
|
|
}
|
|
|
|
// The answer of gitea_get_file as mesh-catalog modules/gitea tools/index.ts and client.ts getFile write it, and the
|
|
// error of a path the forge does not have as client.ts request writes it (`Gitea API ${path}: ${status} ${text}`).
|
|
const getFileAnswer = `{"file":{"path":"modules/a/go.sum","ref":"89abcdef0123456789abcdef0123456789abcdef","sha":"0123","size":4,"content":"x y\n"}}`
|
|
const getFile404 = "Gitea API /repos/novox/mesh-delivery/contents/modules/a/go.sum?ref=89abcdef: 404 {\"message\":\"GetContentsOrList\",\"url\":\"https://forge.example/api/swagger\"}"
|
|
|
|
func TestFilesViaAsksByOwnerRepoPathRefAndTakesTheContent(t *testing.T) { // 1448/AC4
|
|
var keys []string
|
|
var args []any
|
|
call := func(_ context.Context, key string, body any) (json.RawMessage, error) {
|
|
keys, args = append(keys, key), append(args, body)
|
|
return json.RawMessage(getFileAnswer), nil
|
|
}
|
|
got, err := filesVia(context.Background(), call)("novox", "mesh-delivery", "modules/a/go.sum", "89abcdef0123456789abcdef0123456789abcdef")
|
|
if err != nil || string(got) != "x y\n" {
|
|
t.Fatalf("got %q err %v", got, err)
|
|
}
|
|
if len(keys) != 1 || keys[0] != "gitea.gitea_get_file" {
|
|
t.Fatalf("calls %v", keys)
|
|
}
|
|
if b, _ := json.Marshal(args[0]); string(b) != `{"owner":"novox","path":"modules/a/go.sum","ref":"89abcdef0123456789abcdef0123456789abcdef","repo":"mesh-delivery"}` {
|
|
t.Errorf("arguments %s", b)
|
|
}
|
|
}
|
|
|
|
func TestFilesViaTellsNotFoundFromOtherErrorsAndOtherShapes(t *testing.T) { // 1448/AC3
|
|
call := func(err error, raw string) caller {
|
|
return func(context.Context, string, any) (json.RawMessage, error) { return json.RawMessage(raw), err }
|
|
}
|
|
if _, err := filesVia(context.Background(), call(errors.New(getFile404), ""))("o", "r", "p", "s"); !errors.Is(err, bridge.ErrNotFound) {
|
|
t.Errorf("a 404 is %v, want ErrNotFound", err)
|
|
}
|
|
if _, err := filesVia(context.Background(), call(errors.New("Gitea API /repos/o/r/contents/p: 502 bad gateway"), ""))("o", "r", "p", "s"); err == nil || errors.Is(err, bridge.ErrNotFound) {
|
|
t.Errorf("a 502 is %v, want an error that is not ErrNotFound", err)
|
|
}
|
|
for _, raw := range []string{`{"file":null}`, `{}`, `[1]`, `{"file":{"path":"p"}}`} {
|
|
if _, err := filesVia(context.Background(), call(nil, raw))("o", "r", "p", "s"); err == nil || errors.Is(err, bridge.ErrNotFound) {
|
|
t.Errorf("the answer %s gave %v, want an error", raw, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// someFiles is a forge that has a module.json at every path and no other file, for the tests that are not about the files.
|
|
func someFiles(_, _, path, _ string) ([]byte, error) {
|
|
if strings.HasSuffix(path, "module.json") {
|
|
return []byte("{}"), nil
|
|
}
|
|
return nil, bridge.ErrNotFound
|
|
}
|
|
|
|
// refusingBus refuses every bucket with err (issue 1945).
|
|
type refusingBus struct{ err error }
|
|
|
|
func (r refusingBus) KeyValue(context.Context, string) (jetstream.KeyValue, error) { return nil, r.err }
|