package forgemsg import ( "encoding/json" "errors" "strings" "testing" "time" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient" "git.novox.be/novox/mesh-sdk/go/keys" ) const oddManifest = "{\n\t\"module\": \"a\",\n \"z\": 1, \"a\": [ \"x\",\"y\" ],\n \"why\": \"é — & \\n\"\n}\n\n" func sampleForges() []Forge { return []Forge{ {Kind: ForgePull, Repository: "novox/mesh-sdk", Branch: "feat/x", Number: 36, Head: "aaaa", Action: "opened"}, {Kind: ForgeMerged, Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa", Merge: "cccc", Trees: map[string]string{"modules/a": "t1"}, Root: "t0"}, {Kind: ForgeRefused, Repository: "novox/mesh-sdk", Act: "novox/mesh-sdk.36.aaaa.view", Words: "403 forbidden"}, {Kind: ForgeOpen, Open: []OpenPull{{Repository: "novox/mesh-sdk", Number: 36}, {Repository: "novox/mesh-control", Number: 7}}}, // 1585/T1: a group member's merged message names its group and every approved member (ADR 0633 §4). {Kind: ForgeMerged, Repository: "novox/mesh-sdk", Number: 37, Head: "dddd", Merge: "eeee", Root: "t0", Group: "feat/take-in", Members: []meshdeliveryclient.Head{{Repository: "novox/mesh-sdk", Number: 37, Head: "dddd"}, {Repository: "novox/mesh-delivery", Number: 9, Head: "ffff"}}}, // design 47 G §509, §714, A-236: a merged message names the watched branch it landed on; a pushed one its branch, new // head and head before. {Kind: ForgeMerged, Repository: "novox/mesh-sdk", Number: 38, Branch: "feat/y", Head: "aaaa", Merge: "bbbb", Base: "beta", Root: "t0"}, {Kind: ForgePushed, Repository: "novox/mesh-sdk", Branch: "beta", Head: "cccc", Before: "bbbb", Root: "t0", Trees: map[string]string{"modules/a": "t1"}}, } } func mergedWithInputs() Forge { return Forge{Kind: ForgeMerged, Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa", Merge: "cccc", Root: "t0", Trees: map[string]string{"a": "t1", "b": "t2"}, Manifests: map[string]string{"a": oddManifest}, Locks: map[string]map[string]string{"a": {"go.sum": strings.Repeat("ab", 32)}}} } // TestForge holds the forge bridge's contract, moved whole from mesh-sdk go/delivery with its tests (1200/AC1, AC3, // AC4; 1279/AC5; 1442/AC1-AC4; 1585/T1). func TestForge(t *testing.T) { t.Run("events", func(t *testing.T) { ev, err := ForgeEvent("novox/mesh-sdk", ForgeMerged) if err != nil || ev != "forge.novox.mesh-sdk.merged" { t.Fatalf("forge event = %q, %v", ev, err) } if repo, kind, err := ParseForgeEvent(ev); err != nil || repo != "novox/mesh-sdk" || kind != ForgeMerged { t.Fatalf("parse forge event = %q %q %v", repo, kind, err) } for _, bad := range []struct{ repo, kind string }{ {"", "pull"}, {"novox", "pull"}, {"a/b/c", "pull"}, {"/b", "pull"}, {"a/", "pull"}, {"a.b/c", "pull"}, {"a/b c", "pull"}, {"a/b", "closed"}, {"a/b", ""}, {"a/b", ForgeOpen}, } { if _, err := ForgeEvent(bad.repo, bad.kind); err == nil { t.Errorf("forge event %q %q accepted", bad.repo, bad.kind) } } for _, bad := range []string{"", "forge.a.b", "forge.a.b.closed", "x.a.b.pull", "forge.a.b.pull.x", "forge..b.pull", ForgeGroupEndEvent} { if _, _, err := ParseForgeEvent(bad); err == nil { t.Errorf("parse forge event %q accepted", bad) } } if repo, kind, err := ParseForgeEvent(OpenEvent()); OpenEvent() != "forge.open" || err != nil || repo != "" || kind != ForgeOpen { t.Errorf("open event %q = %q %q %v", OpenEvent(), repo, kind, err) } }) t.Run("round trip", func(t *testing.T) { fs := append(sampleForges(), mergedWithInputs()) for _, f := range fs { data, err := EncodeForge(f) if err != nil { t.Fatalf("%s: %v", f.Kind, err) } var probe map[string]any if err := json.Unmarshal(data, &probe); err != nil || probe["v"] != float64(1) { t.Fatalf("%s: json %s does not carry v:1", f.Kind, data) } f.V = Version if got, err := DecodeForge(data); err != nil || !SameForge(got, f) { t.Errorf("forge %s round trip: %+v %v", f.Kind, got, err) } } // An empty list is an open message too: nothing is open. if data, err := EncodeForge(Forge{Kind: ForgeOpen, Open: []OpenPull{}}); err != nil { t.Errorf("empty open: %v", err) } else if f, err := DecodeForge(data); err != nil || f.Kind != ForgeOpen || len(f.Open) != 0 { t.Errorf("empty open round trip: %+v %v", f, err) } ge := ForgeGroupEnd{Group: "feat/take-in", Members: []GroupMerge{{Repository: "novox/mesh-sdk", Number: 37, Merge: "eeee"}}} data, err := EncodeForgeGroupEnd(ge) ge.V = Version if got, err2 := DecodeForgeGroupEnd(data); err != nil || err2 != nil || !SameForgeGroupEnd(got, ge) { t.Errorf("group end round trip: %+v %v %v", got, err, err2) } // An older bridge's message reads, and is written back byte for byte. old := `{"v":1,"kind":"merged","repository":"novox/mesh-sdk","number":36,"head":"aaaa","merge":"cccc","trees":{"a":"t1"},"root":"t0"}` if f, err := DecodeForge([]byte(old)); err != nil || f.Manifests != nil { t.Fatalf("%+v, %v", f, err) } else if data, err := EncodeForge(f); err != nil || string(data) != old { t.Errorf("%s, %v, want exactly %s", data, err, old) } // A merge leaving the repository with no module.json is a message too (issue 1126). f := sampleForges()[1] f.Trees = nil if data, err := EncodeForge(f); err != nil { t.Errorf("a merged message with no trees is refused: %v", err) } else if got, err := DecodeForge(data); err != nil || len(got.Trees) != 0 { t.Errorf("a merged message with no trees comes back as %+v, %v", got, err) } for name, dec := range map[string]func([]byte) error{ "forge": func(b []byte) error { _, err := DecodeForge(b); return err }, "group end": func(b []byte) error { _, err := DecodeForgeGroupEnd(b); return err }, } { for _, in := range []string{`{"group":"g"}`, `{"v":2,"group":"g"}`} { if err := dec([]byte(in)); !errors.Is(err, keys.ErrUnknownVersion) { t.Errorf("%s decode of %s = %v, want keys.ErrUnknownVersion", name, in, err) } } } }) t.Run("refused", func(t *testing.T) { at := func(i int, mut func(*Forge)) Forge { f := sampleForges()[i]; mut(&f); return f } in := func(mut func(*Forge)) Forge { f := mergedWithInputs(); mut(&f); return f } pullIn := func(mut func(*Forge)) Forge { f := Forge{Kind: ForgePull, Repository: "novox/mesh-sdk", Number: 1, Head: "h", Action: PullOpened, Dirs: []string{"a"}, DirsKnown: true, Manifests: map[string]string{"a": oddManifest}, Locks: map[string]map[string]string{"a": {"go.sum": strings.Repeat("0", 64)}}} mut(&f) return f } for _, c := range []struct { name, want string f Forge }{ {"merged without merge commit", "merge", at(1, func(f *Forge) { f.Merge = "" })}, {"merged without root", "root", at(1, func(f *Forge) { f.Root = "" })}, {"merged with a manifest and no trees", "modules/a", at(1, func(f *Forge) { f.Trees = nil; f.Manifests = map[string]string{"modules/a": "{}"} })}, {"merged with an empty tree", "modules/a", at(1, func(f *Forge) { f.Trees = map[string]string{"modules/a": ""} })}, {"pull with an unknown action", "reopened", at(0, func(f *Forge) { f.Action = "reopened" })}, {"pull without head", "head", at(0, func(f *Forge) { f.Head = "" })}, {"refused without words", "words", at(2, func(f *Forge) { f.Words = "" })}, {"refused without act", "act", at(2, func(f *Forge) { f.Act = "" })}, {"unknown kind", "closed", Forge{Kind: "closed", Repository: "a/b"}}, {"bad repository", "nope", Forge{Kind: ForgePull, Repository: "nope", Number: 1, Head: "h", Action: "opened"}}, {"open with a repository", "only the open", Forge{Kind: ForgeOpen, Repository: "a/b", Open: []OpenPull{{Repository: "a/b", Number: 1}}}}, {"open with a bad entry", "", Forge{Kind: ForgeOpen, Open: []OpenPull{{Repository: "a", Number: 1}}}}, {"open with a zero number", "no number", Forge{Kind: ForgeOpen, Open: []OpenPull{{Repository: "a/b"}}}}, {"pull naming open pull requests", "only an open message", Forge{Kind: ForgePull, Repository: "a/b", Number: 1, Head: "h", Action: "updated", Open: []OpenPull{{Repository: "a/b", Number: 1}}}}, {"manifest outside trees", `"zz"`, in(func(f *Forge) { f.Manifests["zz"] = "{}" })}, {"locks outside trees", `"yy"`, in(func(f *Forge) { f.Locks["yy"] = map[string]string{"go.sum": "h"} })}, {"empty manifest", `"b"`, in(func(f *Forge) { f.Manifests["b"] = "" })}, {"empty lock hash", `"a"`, in(func(f *Forge) { f.Locks["a"]["go.sum"] = "" })}, {"named paths outside trees", `"other"`, in(func(f *Forge) { f.Paths = map[string]map[string]string{"other": {"src": "o"}} })}, {"a named path with no object", `"src"`, in(func(f *Forge) { f.Paths = map[string]map[string]string{"a": {"src": ""}} })}, {"assignments files", "mesh-module-assigner", in(func(f *Forge) { f.RetiredAssignments = []byte(`{"anchor":"{}"}`) })}, {"assignments read", "mesh-module-assigner", in(func(f *Forge) { f.RetiredRead = true })}, {"predefined not an object", "one JSON object", in(func(f *Forge) { f.Predefined = []byte(`["domain"]`) })}, {"predefined both", "says the merge holds none", in(func(f *Forge) { f.Predefined = []byte(`{}`); f.PredefinedRead = true })}, {"pull with the predefined list", "only a merged or pushed message", Forge{Kind: ForgePull, Repository: "novox/mesh-sdk", Number: 1, Head: "h", Action: PullOpened, PredefinedRead: true}}, {"pull manifest outside dirs", `"b"`, pullIn(func(f *Forge) { f.Manifests["b"] = "{}" })}, {"pull locks outside dirs", `"c"`, pullIn(func(f *Forge) { f.Locks["c"] = map[string]string{"go.sum": "h"} })}, {"refused with manifests", "no manifests", Forge{Kind: ForgeRefused, Repository: "a/b", Act: "x", Words: "no", Manifests: map[string]string{"a": "{}"}}}, {"open with locks", "only the open", Forge{Kind: ForgeOpen, Locks: map[string]map[string]string{"a": {"go.sum": "h"}}}}, // 1585/T1: a group only on a merged message, with its members, the message's own pull request among them. {"pull with a group", "only a merged message names its delivery group", at(0, func(f *Forge) { f.Group, f.Members = "g", []meshdeliveryclient.Head{{Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa"}} })}, {"merged with a group and no members", "together", at(4, func(f *Forge) { f.Members = nil })}, {"merged with members and no group", "together", at(4, func(f *Forge) { f.Group = "" })}, {"merged with members leaving itself out", "leave out", at(4, func(f *Forge) { f.Members = f.Members[1:] })}, {"merged with a member twice", "twice", at(4, func(f *Forge) { f.Members = append(f.Members, f.Members[0]) })}, {"open with a group", "only the open pull requests", Forge{Kind: ForgeOpen, Group: "g"}}, // design 47 G §509, A-236: a pushed message names its branch and no pull request, merge commit or base. {"pushed with a pull request", "names no pull request", Forge{Kind: ForgePushed, Repository: "a/b", Branch: "beta", Head: "h", Root: "r", Number: 3}}, {"pushed with no branch", "needs its branch", Forge{Kind: ForgePushed, Repository: "a/b", Head: "h", Root: "r"}}, } { if _, err := EncodeForge(c.f); err == nil || !strings.Contains(err.Error(), c.want) { t.Errorf("%s: %v, want a refusal naming %q", c.name, err, c.want) } } // A member's repository in another case still names the merged pull request (10c91fba). f := sampleForges()[4] f.Members[0].Repository = "Novox/Mesh-SDK" if _, err := EncodeForge(f); err != nil { t.Errorf("a member in another case: %v", err) } for _, c := range []struct { name, want string e ForgeGroupEnd }{ {"group end without members", "no member", ForgeGroupEnd{Group: "g"}}, {"group end without a group", "names its group", ForgeGroupEnd{Members: []GroupMerge{{Repository: "a/b", Number: 1, Merge: "m"}}}}, {"group end with a member without its merge", "merge commit", ForgeGroupEnd{Group: "g", Members: []GroupMerge{{Repository: "a/b", Number: 1}}}}, {"group end with a member twice", "twice", ForgeGroupEnd{Group: "g", Members: []GroupMerge{{Repository: "a/b", Number: 1, Merge: "m"}, {Repository: "a/b", Number: 1, Merge: "m"}}}}, } { if _, err := EncodeForgeGroupEnd(c.e); err == nil || !strings.Contains(err.Error(), c.want) { t.Errorf("%s: %v, want a refusal naming %q", c.name, err, c.want) } } }) // Design 47 G §164: an owed act's outcome names its seat, its id, one outcome and words for every outcome but // performed; an act the bridge cannot decode may name no id. 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) } } }) }