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
111 lines
4.4 KiB
Go
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)
|
|
}
|
|
}
|
|
})
|
|
}
|