189 lines
8.8 KiB
Go
189 lines
8.8 KiB
Go
package bridge
|
|
|
|
import (
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-delivery/contracts/go/clients/meshdeliveryclient"
|
|
seat "git.novox.be/novox/mesh-delivery/contracts/go/seats/meshdelivery"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg"
|
|
"git.novox.be/novox/mesh-sdk/go/keys"
|
|
)
|
|
|
|
const (
|
|
headA = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
headB = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
|
|
)
|
|
|
|
// owedValue is an owed value as the SDK writes it (mesh-sdk go/delivery EncodeOwed), and its key as OwedKey spells it.
|
|
func owedValue(t *testing.T, repository string, number int, act string, o seat.OwedByRepositoryNumberHeadActValue) (string, []byte) {
|
|
t.Helper()
|
|
key, err := meshdeliveryclient.OwedKey(repository, number, headA, act)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b, err := meshdeliveryclient.EncodeOwed(o)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return key, b
|
|
}
|
|
|
|
func TestOwedStatusIsACommitStatusCall(t *testing.T) { // 1341/AC1, K1
|
|
key, v := owedValue(t, "novox/mesh-delivery", 12, "status=mesh/merge-gate",
|
|
seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedStatus, Context: "mesh/merge-gate", State: "pending", Text: "waiting", Target: "https://forge.example/novox/mesh-delivery/pulls/12"})
|
|
a, err := OwedAct(key, v)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := Call{Tool: "gitea.gitea_commit_status", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "sha": headA,
|
|
"context": "mesh/merge-gate", "state": "pending", "description": "waiting", "target_url": "https://forge.example/novox/mesh-delivery/pulls/12"}}
|
|
if !reflect.DeepEqual(a.Call, want) {
|
|
t.Errorf("call = %+v, want %+v", a.Call, want)
|
|
}
|
|
if a.Repository != "novox/mesh-delivery" || a.Number != 12 || a.Head != headA || a.Name != "status=mesh/merge-gate" {
|
|
t.Errorf("act = %+v", a)
|
|
}
|
|
// R4e findings K1 and R2-1 (issue 1301 S4; ADR 0503 §3, ADR 0521): no tool writes mesh/check, since a tool is told no
|
|
// caller and node-tools invokes every tool; the forge module writes it from the checker's owed state, and the bridge
|
|
// performs no mesh/check act.
|
|
ck, cv := checkerKV(t, seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedStatus, Context: meshdeliveryclient.StatusContextCheck, State: "success", Text: "pass", Target: "https://view.example/checks/g.1"})
|
|
if a, err := OwedAct(ck, cv); err == nil || !strings.Contains(err.Error(), "mesh-delivery-checker.owed") {
|
|
t.Fatalf("OwedAct(mesh/check) = %+v, %v; want refused, naming where the forge module reads it", a, err)
|
|
}
|
|
// Nor through the gate's own owed bucket: the context is refused whichever key carries it.
|
|
gk, gv := owedValue(t, "novox/mesh-delivery", 12, "status=mesh/check",
|
|
seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedStatus, Context: meshdeliveryclient.StatusContextCheck, State: "success", Text: "pass", Target: "https://x.example"})
|
|
if a, err := OwedAct(gk, gv); err == nil || !strings.Contains(err.Error(), "mesh-delivery-checker.owed") {
|
|
t.Fatalf("OwedAct(gate's mesh/check) = %+v, %v; want refused", a, err)
|
|
}
|
|
}
|
|
|
|
// checkerKV is the status the checker owes, as it writes it (the gate's owed key with the act status=mesh/check).
|
|
func checkerKV(t *testing.T, o seat.OwedByRepositoryNumberHeadActValue) (string, []byte) {
|
|
t.Helper()
|
|
key, err := meshdeliveryclient.OwedKey("novox/mesh-delivery", 12, headA, "status=mesh/check")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
v, err := meshdeliveryclient.EncodeOwed(o)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return key, v
|
|
}
|
|
|
|
func TestOwedViewNoteAndCommentCalls(t *testing.T) { // 1341/AC2
|
|
cases := []struct {
|
|
act string
|
|
o seat.OwedByRepositoryNumberHeadActValue
|
|
want Call
|
|
}{
|
|
{"view", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedView, Text: "the view"},
|
|
Call{Tool: "gitea.gitea_delivery_view", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "number": 12, "body": "the view"}}},
|
|
{"note", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedNote, Text: "a line", Ref: "mesh-plan"},
|
|
Call{Tool: "gitea.gitea_note_append", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "sha": headA, "ref": "mesh-plan", "line": "a line"}}},
|
|
{"comment.2", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedComment, Text: "hello"},
|
|
Call{Tool: "gitea.gitea_add_comment", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "number": 12, "body": "hello"}}},
|
|
}
|
|
for _, c := range cases {
|
|
key, v := owedValue(t, "novox/mesh-delivery", 12, c.act, c.o)
|
|
a, err := OwedAct(key, v)
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", c.act, err)
|
|
}
|
|
if !reflect.DeepEqual(a.Call, c.want) {
|
|
t.Errorf("%s: call = %+v, want %+v", c.act, a.Call, c.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestOwedActWithoutAPullRequestNeedsOneOnlyWhereTheToolDoes(t *testing.T) {
|
|
key, v := owedValue(t, "novox/mesh-delivery", 0, "note", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedNote, Text: "l", Ref: "mesh-plan"})
|
|
if _, err := OwedAct(key, v); err != nil {
|
|
t.Errorf("a note on a commit no pull request names: %v", err)
|
|
}
|
|
key, v = owedValue(t, "novox/mesh-delivery", 0, "view", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedView, Text: "v"})
|
|
if _, err := OwedAct(key, v); err == nil {
|
|
t.Error("a view of no pull request was taken")
|
|
}
|
|
}
|
|
|
|
func TestOwedActThatDisagreesWithItsKeyIsRefused(t *testing.T) {
|
|
// A dotted repository's key is unescaped, and its act names the repository whole.
|
|
dk, dv := owedValue(t, "novox/my.repo", 3, "comment.1", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedComment, Text: "x"})
|
|
if a, err := OwedAct(dk, dv); err != nil || a.Call.Args["repo"] != "my.repo" || a.Repository != "novox/my.repo" {
|
|
t.Errorf("a dotted repository's act = %+v, %v", a, err)
|
|
}
|
|
key, _ := owedValue(t, "novox/mesh-delivery", 12, "view", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedView, Text: "v"})
|
|
v, _ := meshdeliveryclient.EncodeOwed(seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedComment, Text: "v"})
|
|
if _, err := OwedAct(key, v); err == nil {
|
|
t.Error("a comment under a view's key was taken")
|
|
}
|
|
if _, err := OwedAct("nonsense", v); err == nil {
|
|
t.Error("a key that is no owed key was taken")
|
|
}
|
|
if _, err := OwedAct(key, []byte(`{"v":1`)); err == nil {
|
|
t.Error("a value that is not json was taken")
|
|
}
|
|
}
|
|
|
|
func mergeValue(t *testing.T, m seat.MergesByGroupValue) []byte {
|
|
t.Helper()
|
|
b, err := meshdeliveryclient.EncodeMerge(m)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return b
|
|
}
|
|
|
|
func TestMergeActsHandOnlyTheMemberHandedWithEveryApprovedHead(t *testing.T) { // 1342/AC1
|
|
approved := map[string]string{meshdeliveryclient.ApprovedKey("novox/mesh-sdk", 4): headB, meshdeliveryclient.ApprovedKey("novox/mesh-delivery", 12): headA}
|
|
v := mergeValue(t, seat.MergesByGroupValue{Group: "g", Ask: "merge.g.0123456789ab", Approved: approved, Pulls: []seat.MergesByGroupValuePullsItem{
|
|
{Repository: "novox/mesh-sdk", Number: 4, Head: headB, State: string(meshdeliveryclient.MergeMerged), Commit: "c0"},
|
|
{Repository: "novox/mesh-delivery", Number: 12, Head: headA, State: string(meshdeliveryclient.MergeMerging)},
|
|
}})
|
|
acts, err := MergeActs(v)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(acts) != 1 {
|
|
t.Fatalf("%d acts, want 1 (the merged member is not merged again)", len(acts))
|
|
}
|
|
want := Call{Tool: "gitea.gitea_merge_pull_request", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "number": 12, "head": headA,
|
|
"approved_heads": []string{"novox/mesh-delivery@" + headA, "novox/mesh-sdk@" + headB}}}
|
|
if !reflect.DeepEqual(acts[0].Call, want) {
|
|
t.Errorf("call = %+v, want %+v", acts[0].Call, want)
|
|
}
|
|
if acts[0].Name != "merge" || acts[0].Number != 12 || acts[0].Head != headA {
|
|
t.Errorf("act = %+v", acts[0])
|
|
}
|
|
// A merge with no approved heads is refused: the forge's tool would refuse it with nothing to say which.
|
|
v = mergeValue(t, seat.MergesByGroupValue{Group: "g", Ask: "a", Pulls: []seat.MergesByGroupValuePullsItem{
|
|
{Repository: "novox/mesh-delivery", Number: 12, Head: headA, State: string(meshdeliveryclient.MergeMerging)}}})
|
|
if _, err := MergeActs(v); err == nil {
|
|
t.Error("a merge with no approved heads was taken")
|
|
}
|
|
}
|
|
|
|
func TestRefusedMessageNamesTheActAndTheForgesWords(t *testing.T) { // 1341/AC3, 1342/AC2
|
|
a := Act{Name: "merge", Repository: "novox/mesh-delivery", Number: 12, Head: headA}
|
|
m, err := RefusedMessage(a, "novox/mesh-delivery#12 is not merged: its head moved")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m.Event != "forge.novox.mesh-delivery.refused" {
|
|
t.Errorf("event = %q", m.Event)
|
|
}
|
|
f, err := forgemsg.DecodeForge(m.Data)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := forgemsg.Forge{V: keys.Version, Kind: forgemsg.ForgeRefused, Repository: "novox/mesh-delivery", Number: 12, Head: headA,
|
|
Act: "merge", Words: "novox/mesh-delivery#12 is not merged: its head moved"}
|
|
if !forgemsg.SameForge(f, want) {
|
|
t.Errorf("message = %+v", f)
|
|
}
|
|
}
|