Files
mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg/forge_test.go
T
jschoubben 630c099972 B1: the forge bridge's one message, head-moved
forgemsg holds one message per move of a watched branch's head: head-moved with repository,
branch, head, before and start, on forge.<owner>.<name>.<escaped branch>.head-moved, refusing
a head equal to the one held and any field it does not have (trees, base). The messages pull,
merged, pushed, refused and open, their trees, inputs, group and members, and the group's end
forge.group.merged go; owed.ended stays.

Builds: design 47 H §739, §764 (the forge bridge: merged, pushed, base, the group's end); lead answers H-A-27, H-A-48

Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy
2026-11-20 03:13:15 +01:00

111 lines
4.4 KiB
Go

package forgemsg
import (
"errors"
"strings"
"testing"
"time"
"git.novox.be/novox/mesh-sdk/go/keys"
)
// design 47 H §739, H-A-27: the bridge's one message, head-moved, on forge.<owner>.<name>.<escaped branch>.head-moved,
// with repository, branch, head, before and start; a message naming trees, a base or another field is refused.
func TestForge(t *testing.T) {
t.Run("events", func(t *testing.T) {
ev, err := HeadMovedEvent("novox/mesh-sdk", "release.1")
if err != nil || ev != "forge.novox.mesh-sdk.release=2e1.head-moved" {
t.Fatalf("event %q, %v", ev, err)
}
if repo, branch, err := ParseHeadMovedEvent(ev); err != nil || repo != "novox/mesh-sdk" || branch != "release.1" {
t.Fatalf("parse %q: %s %s %v", ev, repo, branch, err)
}
if all := HeadMovedEvents(); all != "forge.*.*.*.head-moved" {
t.Fatalf("every head-moved is %q", all)
}
for _, bad := range []string{"forge.novox.mesh-sdk.merged", "forge.novox.mesh-sdk.main.merged", "forge.open",
"forge.novox.mesh-sdk.ma=zz.head-moved", "owed.ended", "forge.novox.mesh-sdk.main.x.head-moved"} {
if _, _, err := ParseHeadMovedEvent(bad); err == nil {
t.Errorf("%q parsed", bad)
}
}
for _, repo := range []string{"mesh-sdk", "a/b/c", "a./b"} {
if _, err := HeadMovedEvent(repo, "main"); err == nil {
t.Errorf("repository %q named", repo)
}
}
})
t.Run("round trip", func(t *testing.T) {
for _, h := range []HeadMoved{
{Repository: "novox/mesh-sdk", Branch: "main", Head: "cccc", Before: "bbbb"},
{Repository: "novox/mesh-sdk", Branch: "feat/x", Head: "aaaa", Start: true}, // the first time: no head held
} {
raw, err := EncodeHeadMoved(h)
if err != nil {
t.Fatal(err)
}
back, err := DecodeHeadMoved(raw)
h.V = Version
if err != nil || back != h {
t.Fatalf("read back %+v, %v; want %+v", back, err, h)
}
}
})
t.Run("refused", func(t *testing.T) {
for name, h := range map[string]HeadMoved{
"no repository": {Branch: "main", Head: "a"},
"no branch": {Repository: "novox/x", Head: "a"},
"no head": {Repository: "novox/x", Branch: "main"},
"head not moved": {Repository: "novox/x", Branch: "main", Head: "a", Before: "a"},
"repository form": {Repository: "x", Branch: "main", Head: "a"},
} {
if _, err := EncodeHeadMoved(h); err == nil {
t.Errorf("%s: written", name)
}
}
for name, raw := range map[string]string{
"trees": `{"v":1,"repository":"novox/x","branch":"main","head":"a","trees":{"m":"t"}}`,
"base": `{"v":1,"repository":"novox/x","branch":"main","head":"a","base":"main"}`,
"merged": `{"v":1,"kind":"merged","repository":"novox/x","number":3,"head":"a","merge":"b"}`,
"no version": `{"repository":"novox/x","branch":"main","head":"a"}`,
} {
if _, err := DecodeHeadMoved([]byte(raw)); err == nil {
t.Errorf("%s: read", name)
} else if name == "no version" && !errors.Is(err, keys.ErrUnknownVersion) {
t.Errorf("no version: %v", err)
}
}
})
t.Run("owed ended", func(t *testing.T) {
at := time.Date(2026, 11, 9, 20, 0, 0, 0, time.UTC)
ok := OwedEnded{Of: "mesh-delivery", ID: "g1.view.1", Outcome: OwedPerformed, At: at}
raw, err := EncodeOwedEnded(ok)
if back, derr := DecodeOwedEnded(raw); err != nil || derr != nil || back.V != Version || back.ID != ok.ID {
t.Fatalf("round trip: %s %v %v", raw, err, derr)
}
if _, err := DecodeOwedEnded([]byte(`{"v":99,"of":"x","id":"a","outcome":"performed","at":"2026-11-09T20:00:00Z"}`)); err == nil {
t.Errorf("an unknown version was read")
}
for _, c := range []struct {
name string
edit func(*OwedEnded)
want string
}{
{"no seat", func(e *OwedEnded) { e.Of = "" }, "no seat"},
{"an outcome of no kind", func(e *OwedEnded) { e.Outcome = "done" }, "none of"},
{"no id", func(e *OwedEnded) { e.ID = "" }, "no id"},
{"a refusal with no words", func(e *OwedEnded) { e.Outcome = OwedRefused }, "no words"},
{"dropped with no reason", func(e *OwedEnded) { e.Outcome = OwedDropped }, "no words"},
{"no time", func(e *OwedEnded) { e.At = time.Time{} }, "no time"},
{"undecodable with no id is said", func(e *OwedEnded) { e.ID, e.Outcome, e.Words = "", OwedUndecodable, "not json" }, ""},
} {
e := ok
c.edit(&e)
_, err := EncodeOwedEnded(e)
if (c.want == "") != (err == nil) || (err != nil && !strings.Contains(err.Error(), c.want)) {
t.Errorf("%s: %v, want %q", c.name, err, c.want)
}
}
})
}