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
114 lines
4.7 KiB
Go
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)
|
|
}
|
|
}
|
|
})
|
|
}
|