298 lines
9.8 KiB
Go
298 lines
9.8 KiB
Go
package delivery
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/asks"
|
|
)
|
|
|
|
func gateHeads() []Head {
|
|
return []Head{
|
|
{Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa"},
|
|
{Repository: "novox/mesh-control", Number: 7, Head: "bbbb"},
|
|
}
|
|
}
|
|
|
|
func TestMergeKeys(t *testing.T) { // 1201/AC1
|
|
if k, err := MergesKey("feat/x"); err != nil || k != "feat/x" {
|
|
t.Fatalf("merges key = %q, %v", k, err)
|
|
}
|
|
if _, err := MergesKey("a.b"); err == nil {
|
|
t.Error("a group with a dot accepted")
|
|
}
|
|
hh, _ := HeadsHash(gateHeads())
|
|
key, err := MergeAskKey("feat/x", gateHeads())
|
|
if err != nil || key != "merge.feat/x."+hh {
|
|
t.Fatalf("ask key = %q, %v", key, err)
|
|
}
|
|
kind, group, hash, err := ParseAskKey(key)
|
|
if err != nil || kind != AskKindMerge || group != "feat/x" || hash != hh {
|
|
t.Fatalf("parse ask key = %q %q %q %v", kind, group, hash, err)
|
|
}
|
|
if AnswerKey(key) != key {
|
|
t.Error("the answer's key is not the ask's key")
|
|
}
|
|
if _, err := MergeAskKey("feat/x", nil); err == nil {
|
|
t.Error("an ask key without heads accepted")
|
|
}
|
|
if _, err := MergeAskKey("", gateHeads()); err == nil {
|
|
t.Error("an ask key without a group accepted")
|
|
}
|
|
for _, bad := range []string{"", "merge", "merge.g", "merge.g.h.x", "other.g.0123456789ab", "merge..0123456789ab", "merge.g.nothex"} {
|
|
if _, _, _, err := ParseAskKey(bad); err == nil {
|
|
t.Errorf("parse ask key %q accepted", bad)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAskID(t *testing.T) { // 1201/AC2
|
|
k1, _ := MergeAskKey("feat/x", gateHeads())
|
|
k2, _ := MergeAskKey("feat/y", gateHeads())
|
|
k3, _ := MergeAskKey("feat/x", gateHeads()[:1])
|
|
long, _ := MergeAskKey("feat/"+strings.Repeat("long-", 20), gateHeads())
|
|
long2, _ := MergeAskKey("feat/"+strings.Repeat("long-", 20)+"2", gateHeads())
|
|
seen := map[string]string{}
|
|
for _, k := range []string{k1, k2, k3, long, long2} {
|
|
id := AskID(k)
|
|
if strings.Contains(id, ".") {
|
|
t.Errorf("id %q holds a dot", id)
|
|
}
|
|
if !asks.UsableID(id) {
|
|
t.Errorf("id %q is not usable by the router", id)
|
|
}
|
|
if other, dup := seen[id]; dup {
|
|
t.Errorf("keys %q and %q give the id %q", k, other, id)
|
|
}
|
|
seen[id] = k
|
|
}
|
|
if AskID(k1) != AskID(k1) {
|
|
t.Error("the id is not stable")
|
|
}
|
|
}
|
|
|
|
func TestOwedKey(t *testing.T) { // 1201/AC3
|
|
for _, act := range []string{"status=mesh/merge-gate", "view", "note", "comment"} {
|
|
key, err := OwedKey("novox/mesh-sdk", 36, "aaaa", act)
|
|
if err != nil || key != "novox/mesh-sdk.36.aaaa."+act {
|
|
t.Fatalf("owed key for %s = %q, %v", act, key, err)
|
|
}
|
|
repo, number, head, gotAct, err := ParseOwedKey(key)
|
|
if err != nil || repo != "novox/mesh-sdk" || number != 36 || head != "aaaa" || gotAct != act {
|
|
t.Fatalf("parse %q = %q %d %q %q %v", key, repo, number, head, gotAct, err)
|
|
}
|
|
}
|
|
kind, context, err := ParseOwedAct("status=mesh/merge-gate")
|
|
if err != nil || kind != OwedStatus || context != "mesh/merge-gate" {
|
|
t.Errorf("owed act = %q %q %v", kind, context, err)
|
|
}
|
|
for _, bad := range []string{"", "merge", "status", "status=", "view=x", "status=a.b", "statuses=x"} {
|
|
if _, err := OwedKey("novox/mesh-sdk", 36, "aaaa", bad); err == nil {
|
|
t.Errorf("owed act %q accepted", bad)
|
|
}
|
|
}
|
|
if _, err := OwedKey("nope", 36, "aaaa", "view"); err == nil {
|
|
t.Error("a bad repository accepted")
|
|
}
|
|
if _, err := OwedKey("novox/mesh-sdk", 0, "aaaa", "view"); err == nil {
|
|
t.Error("pull request number 0 accepted")
|
|
}
|
|
if _, err := OwedKey("novox/mesh-sdk", 36, "", "view"); err == nil {
|
|
t.Error("an empty head accepted")
|
|
}
|
|
for _, bad := range []string{"", "novox/mesh-sdk.36.aaaa", "novox/mesh-sdk.x.aaaa.view", "novox/mesh-sdk.36.aaaa.merge", "a.b.36.aaaa.view"} {
|
|
if _, _, _, _, err := ParseOwedKey(bad); err == nil {
|
|
t.Errorf("parse owed key %q accepted", bad)
|
|
}
|
|
}
|
|
}
|
|
|
|
func sampleMerge() Merge {
|
|
return Merge{Group: "feat/x", Ask: "merge.feat/x.0123456789ab", Pulls: []MergePull{
|
|
{Head: gateHeads()[0], State: MergeMerged, Commit: "cccc"},
|
|
{Head: gateHeads()[1], State: MergeRefused, Words: "the forge says no"},
|
|
{Head: Head{Repository: "novox/other", Number: 1, Head: "dddd"}, State: MergeMerging},
|
|
}}
|
|
}
|
|
|
|
func sampleAsk() Ask {
|
|
key, _ := MergeAskKey("feat/x", gateHeads())
|
|
return Ask{Group: "feat/x", Heads: gateHeads(), Ask: asks.Ask{
|
|
ID: AskID(key), Headline: "Merge into main: group feat/x", Explanation: "The group passed its checks.",
|
|
Who: asks.Operator, Expires: time.Date(2026, 10, 20, 8, 0, 0, 0, time.UTC), OnExpiry: "nothing is merged",
|
|
Options: []asks.Option{{ID: "approve", Label: "Approve", Does: "merges", Level: asks.Approve, Binds: "sha256:00"}},
|
|
}}
|
|
}
|
|
|
|
func sampleOwed() []Owed {
|
|
return []Owed{
|
|
{Act: OwedStatus, Context: "mesh/merge-gate", State: "success"},
|
|
{Act: OwedView, Text: "the delivery reaches ace"},
|
|
{Act: OwedNote, Text: "plan: mesh-mail to ace", Ref: "mesh-plan"},
|
|
{Act: OwedComment, Text: "merged"},
|
|
}
|
|
}
|
|
|
|
func TestGateValuesRoundTrip(t *testing.T) { // 1201/AC4
|
|
hasV := func(name string, data []byte, err error) {
|
|
t.Helper()
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", name, err)
|
|
}
|
|
var probe map[string]any
|
|
if json.Unmarshal(data, &probe) != nil || probe["v"] != float64(1) {
|
|
t.Fatalf("%s: %s does not carry v:1", name, data)
|
|
}
|
|
}
|
|
m := sampleMerge()
|
|
data, err := EncodeMerge(m)
|
|
hasV("merge", data, err)
|
|
m.V = Version
|
|
if got, err := DecodeMerge(data); err != nil || !SameMerge(got, m) {
|
|
t.Errorf("merge round trip: %+v %v", got, err)
|
|
}
|
|
a := sampleAsk()
|
|
data, err = EncodeAsk(a)
|
|
hasV("ask", data, err)
|
|
a.V = Version
|
|
if got, err := DecodeAsk(data); err != nil || !SameAsk(got, a) {
|
|
t.Errorf("ask round trip: %+v %v", got, err)
|
|
}
|
|
an := Answer{Option: "approve", Warrant: "w-1", Words: "approved on telegram"}
|
|
data, err = EncodeAnswer(an)
|
|
hasV("answer", data, err)
|
|
an.V = Version
|
|
if got, err := DecodeAnswer(data); err != nil || !SameAnswer(got, an) {
|
|
t.Errorf("answer round trip: %+v %v", got, err)
|
|
}
|
|
for _, o := range sampleOwed() {
|
|
data, err = EncodeOwed(o)
|
|
hasV("owed "+o.Act, data, err)
|
|
o.V = Version
|
|
if got, err := DecodeOwed(data); err != nil || !SameOwed(got, o) {
|
|
t.Errorf("owed %s round trip: %+v %v", o.Act, got, err)
|
|
}
|
|
}
|
|
for name, dec := range map[string]func([]byte) error{
|
|
"merge": func(b []byte) error { _, err := DecodeMerge(b); return err },
|
|
"ask": func(b []byte) error { _, err := DecodeAsk(b); return err },
|
|
"answer": func(b []byte) error { _, err := DecodeAnswer(b); return err },
|
|
"owed": func(b []byte) error { _, err := DecodeOwed(b); return err },
|
|
} {
|
|
for _, in := range []string{`{"group":"g"}`, `{"v":2}`} {
|
|
if err := dec([]byte(in)); !errors.Is(err, ErrUnknownVersion) {
|
|
t.Errorf("%s decode of %s = %v, want ErrUnknownVersion", name, in, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGateValuesRefused(t *testing.T) { // 1201/AC5
|
|
wantErr := func(name string, err error, words ...string) {
|
|
t.Helper()
|
|
if err == nil {
|
|
t.Errorf("%s accepted", name)
|
|
return
|
|
}
|
|
for _, w := range words {
|
|
if !strings.Contains(err.Error(), w) {
|
|
t.Errorf("%s: error %q does not name %q", name, err, w)
|
|
}
|
|
}
|
|
}
|
|
m := sampleMerge()
|
|
m.Pulls[0].Commit = ""
|
|
_, err := EncodeMerge(m)
|
|
wantErr("merged without a merge commit", err, "commit")
|
|
m = sampleMerge()
|
|
m.Pulls[1].Words = ""
|
|
_, err = EncodeMerge(m)
|
|
wantErr("refused without words", err, "words")
|
|
m = sampleMerge()
|
|
m.Pulls[2].State = "done"
|
|
_, err = EncodeMerge(m)
|
|
wantErr("unknown state", err, "done")
|
|
m = sampleMerge()
|
|
m.Pulls = nil
|
|
_, err = EncodeMerge(m)
|
|
wantErr("merge without pulls", err, "pull")
|
|
m = sampleMerge()
|
|
m.Ask = ""
|
|
_, err = EncodeMerge(m)
|
|
wantErr("merge without its ask", err, "ask")
|
|
|
|
a := sampleAsk()
|
|
a.Ask.ID = "something-else"
|
|
_, err = EncodeAsk(a)
|
|
wantErr("ask with another id", err, "something-else", AskID("merge.feat/x."+mustHash(gateHeads())))
|
|
a = sampleAsk()
|
|
a.Ask.Options = nil
|
|
_, err = EncodeAsk(a)
|
|
wantErr("ask without options", err, "option")
|
|
a = sampleAsk()
|
|
a.Heads = nil
|
|
_, err = EncodeAsk(a)
|
|
wantErr("ask without heads", err, "pull request")
|
|
|
|
for name, an := range map[string]Answer{
|
|
"option": {Warrant: "w", Words: "x"},
|
|
"warrant": {Option: "approve", Words: "x"},
|
|
"words": {Option: "approve", Warrant: "w"},
|
|
} {
|
|
_, err = EncodeAnswer(an)
|
|
wantErr("answer without "+name, err, name)
|
|
}
|
|
|
|
for name, o := range map[string]Owed{
|
|
"context": {Act: OwedStatus, State: "success"},
|
|
"state": {Act: OwedStatus, Context: "mesh/merge-gate", State: "green"},
|
|
"text": {Act: OwedView},
|
|
"ref": {Act: OwedNote, Text: "line"},
|
|
"comment": {Act: OwedComment},
|
|
"act": {Act: "merge"},
|
|
} {
|
|
_, err = EncodeOwed(o)
|
|
wantErr("owed missing "+name, err)
|
|
}
|
|
_, err = EncodeOwed(Owed{Act: OwedNote, Text: "line"})
|
|
wantErr("note without ref", err, "ref")
|
|
_, err = EncodeOwed(Owed{Act: OwedStatus, State: "success"})
|
|
wantErr("status without context", err, "context")
|
|
}
|
|
|
|
func mustHash(h []Head) string { s, _ := HeadsHash(h); return s }
|
|
|
|
func TestGateSame(t *testing.T) { // 1201/AC6
|
|
if !SameMerge(sampleMerge(), sampleMerge()) || !SameAsk(sampleAsk(), sampleAsk()) {
|
|
t.Error("equal values differ")
|
|
}
|
|
m := sampleMerge()
|
|
m.Pulls[0].Commit = "other"
|
|
if SameMerge(m, sampleMerge()) {
|
|
t.Error("different merges are the same")
|
|
}
|
|
a := sampleAsk()
|
|
a.Ask.Headline = "other"
|
|
if SameAsk(a, sampleAsk()) {
|
|
t.Error("different asks are the same")
|
|
}
|
|
if !SameAnswer(Answer{Option: "a", Warrant: "w", Words: "x"}, Answer{Option: "a", Warrant: "w", Words: "x"}) ||
|
|
SameAnswer(Answer{Option: "a", Warrant: "w", Words: "x"}, Answer{Option: "b", Warrant: "w", Words: "x"}) {
|
|
t.Error("SameAnswer wrong")
|
|
}
|
|
if !SameOwed(sampleOwed()[0], sampleOwed()[0]) || SameOwed(sampleOwed()[0], sampleOwed()[1]) {
|
|
t.Error("SameOwed wrong")
|
|
}
|
|
}
|
|
|
|
func TestGateBuckets(t *testing.T) {
|
|
if MergesBucket != "mesh-delivery-gate_merges" || AsksBucket != "mesh-delivery-gate_asks" ||
|
|
OwedBucket != "mesh-delivery-gate_owed" || AnswersBucket != "mesh-delivery-teller_answers" ||
|
|
MergesHistory != 10 || AsksHistory != 5 || OwedHistory != 5 || AnswersHistory != 5 {
|
|
t.Error("a bucket or history differs from the decided layout")
|
|
}
|
|
}
|