Files
mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg/forge_test.go
T
jschoubben 13d960a120 F1: an owed act failing on a part away stays owed, and a record's acts are performed again
An owed act met by the forge away (401 while the store was replaced) ended
could not be performed and nothing performed it again. Each act is now a kept
call at the module's pace (kept-call-pace-first, kept-call-pace-max) until
owed-away-bound (60 minutes), then ends could not be performed naming every
try. Before each try the bridge reads the pull request through the seat git's
pull: one closed unmerged ends owed.ended not-needed, never performed. The
gate's owed event gains record (the delivery record's source revision), kept
with the act in performed, and bridge_owed_again by record and why performs
again every act of that record that ended could not be performed, written in
the hand-act log first.

Builds: design 47 H2 §807, §775, §819, H-A-432
2026-11-22 01:46:49 +01:00

114 lines
4.7 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"},
// Design 47 H2 §807 (H-A-432 (2)): an act whose pull request closed unmerged is said not-needed, naming it.
{"not needed, naming why", func(e *OwedEnded) { e.Outcome, e.Words = OwedNotNeeded, "novox/x#9 closed unmerged" }, ""},
{"not needed with no words", func(e *OwedEnded) { e.Outcome = OwedNotNeeded }, "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)
}
}
})
}