mesh-delivery/modules/mesh-delivery-forge-bridge/cmd/mesh-delivery-forge-bridge-tools/main_test.go

package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"strings"
	"testing"
	"time"

	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg"
	"git.novox.be/novox/mesh-sdk/go/delivery"

	"mesh-delivery-forge-bridge/internal/bridge"

	"mesh-delivery-forge-bridge/internal/groups"
)

// 1585/T18, T19 (ADR 0633 §4): bridge_groups names each group the gate holds with its members' state and whether its end is
// written (open or ended, with why), narrowed by group and by open; bridge_group_end_again writes an ask naming the group,
// who asked and why, and answers what the bridge answered.
func TestTheBridgeToolsReadTheGroupsAndAskTheEndAgain(t *testing.T) {
	h1, h2 := strings.Repeat("1", 40), strings.Repeat("2", 40)
	c1, c2 := strings.Repeat("c", 40), strings.Repeat("d", 40)
	enc := func(group string, state2 delivery.MergeState, c string) []byte {
		v, err := delivery.EncodeMerge(delivery.Merge{Group: group, Ask: "ask", Approved: map[string]string{"novox/a@1": h1, "novox/b@2": h2},
			Pulls: []delivery.MergePull{{Head: delivery.Head{Repository: "novox/a", Number: 1, Head: h1}, State: delivery.MergeMerged, Commit: c1},
				{Head: delivery.Head{Repository: "novox/b", Number: 2, Head: h2}, State: state2, Commit: c}}})
		if err != nil {
			t.Fatal(err)
		}
		return v
	}
	lone, _ := delivery.EncodeMerge(delivery.Merge{Group: "solo", Ask: "ask", Approved: map[string]string{"novox/a@5": h1},
		Pulls: []delivery.MergePull{{Head: delivery.Head{Repository: "novox/a", Number: 5, Head: h1}, State: delivery.MergeMerged, Commit: c1}}})
	merges := map[string][]byte{"ended": enc("ended", delivery.MergeMerged, c2), "ready": enc("ready", delivery.MergeMerged, c2),
		"gathered": enc("gathered", delivery.MergeMerging, ""), "solo": lone, "bad": []byte("{")}
	performed := map[string]bool{}
	for _, c := range []string{c1, c2} {
		performed[groups.PublishedKey("novox/a", 1, c)], performed[groups.PublishedKey("novox/b", 2, c)] = true, true
	}
	// The state end-asks keeps the last ask of the group ready, answered, and one that does not read.
	answeredAsk, _ := json.Marshal(groups.EndAsk{V: 1, Group: "ready", Why: "lost", By: "lead@shanks", At: time.Date(2026, 11, 4, 22, 0, 0, 0, time.UTC),
		Written: true, Answer: "the end of the group is written again", Answered: time.Date(2026, 11, 4, 22, 0, 1, 0, time.UTC)})
	asks := map[string][]byte{"ready": answeredAsk, "gathered": []byte("{")}
	var asked groups.EndAsk
	var askedKey string
	ask := func(key string, value []byte) (groups.EndAsk, error) {
		askedKey = key
		a, err := groups.DecodeEndAsk(value)
		a.Written, a.Answer, a.Answered = true, "the end of the group is written again", time.Now()
		asked = a
		return a, err
	}
	tools := Tools(ask, func() time.Time { return time.Date(2026, 11, 4, 23, 0, 0, 0, time.UTC) },
		func() ([]groups.Row, []string, error) {
			rows, unread := groups.Rows(merges, performed, map[string]uint64{"ended": 7}, asks)
			return rows, unread, nil
		}, nil)
	call := func(name string, args map[string]any) any {
		for _, tl := range tools {
			if tl.Name == name {
				out, err := tl.Run(args)
				if err != nil {
					t.Fatalf("%s: %v", name, err)
				}
				return out
			}
		}
		t.Fatalf("no tool %s", name)
		return nil
	}
	rowsOf := func(args map[string]any) map[string]groups.Row {
		raw, _ := json.Marshal(call(GroupsTool, args))
		var out struct {
			Groups []groups.Row `json:"groups"`
			Unread []string     `json:"unread"`
		}
		if err := json.Unmarshal(raw, &out); err != nil {
			t.Fatal(err)
		}
		m := map[string]groups.Row{}
		for _, r := range out.Groups {
			m[r.Group] = r
		}
		if len(args) == 0 && strings.Join(out.Unread, " ") != "bad end-asks.gathered" {
			t.Errorf("unread = %v, want bad and end-asks.gathered", out.Unread)
		}
		return m
	}
	all := rowsOf(map[string]any{})
	if len(all) != 3 || !all["ended"].Ended || all["ended"].EndedAt != 7 {
		t.Fatalf("groups = %+v", all)
	}
	if r := all["ready"]; !r.Open || !strings.Contains(r.Words, "bridge_group_end_again") || !r.Members[1].Published {
		t.Errorf("ready = %+v, want open, merged and published, its end the thing to say", r)
	}
	if a := all["ready"].LastEndAsk; a == nil || a.By != "lead@shanks" || a.Why != "lost" || !a.Written || a.Answer == "" || all["ended"].LastEndAsk != nil {
		t.Errorf("ready's last end ask = %+v, ended's %+v: want ready's ask and its answer, none for ended", a, all["ended"].LastEndAsk)
	}
	if r := all["gathered"]; !r.Open || !strings.Contains(r.Words, "gathered") || r.Members[1].State != string(delivery.MergeMerging) {
		t.Errorf("gathered = %+v", r)
	}
	if open := rowsOf(map[string]any{"open": true}); len(open) != 2 || open["ended"].Group != "" {
		t.Errorf("open = %+v, want ready and gathered", open)
	}
	if one := rowsOf(map[string]any{"group": "ready"}); len(one) != 1 {
		t.Errorf("group ready = %+v", one)
	}
	out := call(EndAgainTool, map[string]any{"group": "ready", "why": "the indexer never took it in"}).(map[string]any)
	if askedKey != "ready" || asked.Group != "ready" || asked.Why != "the indexer never took it in" || out["written"] != true {
		t.Errorf("the ask %q %+v, answered %v", askedKey, asked, out)
	}
	for _, tl := range tools {
		if tl.Name == EndAgainTool {
			if _, err := tl.Run(map[string]any{}); err == nil {
				t.Error("an ask naming no group was taken")
			}
		}
	}

	// 1585: bridge_merged_message answers the merged message as the bridge publishes it: for a lone pull request the same bytes
	// the event gives through Convert, for a member of a delivery group those with its group and members set as the process
	// sets them; a merge the gate does not hold, or a forge that does not answer, is said.
	t.Run("bridge_merged_message answers the merged message as published", func(t *testing.T) {
		h1, h2 := strings.Repeat("1", 40), strings.Repeat("2", 40)
		c1, c2 := strings.Repeat("c", 40), strings.Repeat("d", 40)
		trees := func(owner, repo, sha string) (string, map[string]string, error) {
			return "root-" + sha[:4], map[string]string{"": "r", "modules/a": "ta-" + sha[:4]}, nil
		}
		files := func(owner, repo, path, ref string) ([]byte, error) {
			if strings.HasSuffix(path, "module.json") {
				return []byte(`{"module":"a"}`), nil
			}
			return nil, bridge.ErrNotFound
		}
		published := func(repo string, number int, head, branch, merge string) forgemsg.Forge {
			body, _ := json.Marshal(map[string]any{"owner": "novox", "repo": repo, "number": number, "head": branch, "head_sha": head, "base": "main", "merge_commit_sha": merge})
			msg, err := bridge.Convert(bridge.MergedSubject, body, trees, files)
			if err != nil {
				t.Fatal(err)
			}
			f, err := forgemsg.DecodeForge(msg.Data)
			if err != nil {
				t.Fatal(err)
			}
			return f
		}
		lone, _ := delivery.EncodeMerge(delivery.Merge{Group: "solo", Ask: "a", Approved: map[string]string{"novox/a@5": h1},
			Pulls: []delivery.MergePull{{Head: delivery.Head{Repository: "novox/a", Number: 5, Head: h1}, State: delivery.MergeMerged, Commit: c1}}})
		group, _ := delivery.EncodeMerge(delivery.Merge{Group: "feat/g", Ask: "a", Approved: map[string]string{"novox/a@6": h1, "novox/b@7": h2},
			Pulls: []delivery.MergePull{{Head: delivery.Head{Repository: "novox/a", Number: 6, Head: h1}, State: delivery.MergeMerged, Commit: c1},
				{Head: delivery.Head{Repository: "novox/b", Number: 7, Head: h2}, State: delivery.MergeMerging}}})
		for _, c := range []struct {
			name       string
			raws       map[string][]byte
			repository string
			merge      string
			want       forgemsg.Forge
			fail       string
		}{
			{name: "a lone pull request", raws: map[string][]byte{"solo": lone}, repository: "novox/a", merge: c1, want: published("a", 5, h1, "solo", c1)},
			{name: "a member of a group", raws: map[string][]byte{"feat~g": group}, repository: "novox/a", merge: c1, want: func() forgemsg.Forge {
				f := published("a", 6, h1, "feat/g", c1)
				f.Group, f.Members = "feat/g", []delivery.Head{{Repository: "novox/a", Number: 6, Head: h1}, {Repository: "novox/b", Number: 7, Head: h2}}
				return f
			}()},
			{name: "a merge the gate does not hold", raws: map[string][]byte{"solo": lone, "bad": []byte("{")}, repository: "novox/a", merge: c2, fail: "hold no merge"},
		} {
			t.Run(c.name, func(t *testing.T) {
				raw, err := MergedOf(c.raws, c.repository, c.merge, trees, files)
				if c.fail != "" {
					if err == nil || !strings.Contains(err.Error(), c.fail) {
						t.Fatalf("err %v, want %q", err, c.fail)
					}
					return
				}
				want, _ := forgemsg.EncodeForge(c.want)
				if err != nil || !bytes.Equal(raw, want) {
					t.Fatalf("err %v, answer\n%s\nwant the published message\n%s", err, raw, want)
				}
			})
		}
		if _, err := MergedOf(map[string][]byte{"solo": lone}, "novox/a", c1, func(string, string, string) (string, map[string]string, error) {
			return "", nil, errors.New("the forge does not answer")
		}, files); err == nil || !strings.Contains(err.Error(), "does not answer") {
			t.Errorf("a forge that does not answer: %v", err)
		}
	})
}