120 lines
4.5 KiB
Go
120 lines
4.5 KiB
Go
package viewstate
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-delivery/contracts/go/clients/meshdeliveryclient"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-assigner/asks"
|
|
"git.novox.be/novox/mesh-sdk/go/keys"
|
|
)
|
|
|
|
func sampleReach() Reach {
|
|
return Reach{V: keys.Version, Repository: "novox/mesh-catalog", Indexed: "cccc", Reached: "cccc", ReachedSrc: 9, Modules: map[string]ModuleReach{
|
|
"gitea": {FP: "src2:a", Nodes: 1, Floor: "cccc", Waiting: "gitea on ace runs src2:a and its health check failed", Changes: []Change{{Commit: "cccc", FP: "src2:a", Src: 9}, {Commit: "bbbb", FP: "src2:b", Src: 7}}},
|
|
"zsh": {FP: "src2:z", Changes: []Change{{Commit: "aaaa", FP: "src2:z"}}},
|
|
}}
|
|
}
|
|
|
|
// 1280: the reach value (ADR 0556) round-trips, and values that do not hold are refused, naming what is wrong.
|
|
func TestAReachValueRoundTripsAndRefusesWhatDoesNotHold(t *testing.T) {
|
|
wantErr := func(what string, err error, in string) {
|
|
t.Helper()
|
|
if err == nil || !strings.Contains(err.Error(), in) {
|
|
t.Errorf("%s: %v, want an error naming %q", what, err, in)
|
|
}
|
|
}
|
|
r := sampleReach()
|
|
data, err := EncodeReach(r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, err := DecodeReach(data); err != nil || !SameReach(got, r) {
|
|
t.Errorf("reach round trip: %+v %v", got, err)
|
|
}
|
|
r.Repository = ""
|
|
_, err = EncodeReach(r)
|
|
wantErr("reach without repository", err, "repository")
|
|
r = sampleReach()
|
|
m := r.Modules["gitea"]
|
|
m.Changes = append(m.Changes, Change{Commit: "dddd"})
|
|
r.Modules["gitea"] = m
|
|
_, err = EncodeReach(r)
|
|
wantErr("reach with a change naming no fingerprint", err, "gitea")
|
|
r = sampleReach()
|
|
m = r.Modules["gitea"]
|
|
m.Changes = make([]Change, MostChanges+1)
|
|
r.Modules["gitea"] = m
|
|
_, err = EncodeReach(r)
|
|
wantErr("reach keeping too many changes", err, "more than")
|
|
r = sampleReach()
|
|
r.ReachedSrc = 0
|
|
_, err = EncodeReach(r)
|
|
wantErr("reach with a head and no revision", err, "reached head")
|
|
}
|
|
|
|
func TestReachValuesDifferingInAnyPartAreNotTheSame(t *testing.T) {
|
|
if !SameReach(sampleReach(), sampleReach()) {
|
|
t.Error("equal reach values differ")
|
|
}
|
|
for name, change := range map[string]func(*Reach){
|
|
"indexed": func(r *Reach) { r.Indexed = "dddd" },
|
|
"floor": func(r *Reach) { m := r.Modules["gitea"]; m.Floor = "bbbb"; r.Modules["gitea"] = m },
|
|
"changes": func(r *Reach) { m := r.Modules["zsh"]; m.Changes = nil; r.Modules["zsh"] = m },
|
|
"modules": func(r *Reach) { delete(r.Modules, "zsh") },
|
|
"reached": func(r *Reach) { r.Reached, r.ReachedSrc = "bbbb", 7 },
|
|
"holds": func(r *Reach) { r.Holds = []string{"gitea on ace does not yet run src2:a"} },
|
|
} {
|
|
r := sampleReach()
|
|
change(&r)
|
|
if SameReach(r, sampleReach()) {
|
|
t.Errorf("reach values differing in %s are the same", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestViewAnswerRoundTrip(t *testing.T) {
|
|
t.Run("the key and the asking", func(t *testing.T) {
|
|
fp := "src2:" + strings.Repeat("ab", 32)
|
|
hold, _ := asks.HoldAskKey("gitea", fp)
|
|
key, err := ViewAnswerKey(hold)
|
|
if err != nil || key != hold+".view" {
|
|
t.Fatalf("ViewAnswerKey = %q, %v", key, err)
|
|
}
|
|
if back, err := ParseViewAnswerKey(key); err != nil || back != hold {
|
|
t.Errorf("ParseViewAnswerKey = %q, %v", back, err)
|
|
}
|
|
for _, bad := range []string{hold, "merge.g.d106c7950d28.view", "other.x.view"} {
|
|
if _, err := ParseViewAnswerKey(bad); err == nil {
|
|
t.Errorf("ParseViewAnswerKey(%q) reads a wrong key", bad)
|
|
}
|
|
}
|
|
if _, err := ViewAnswerKey("merge.g.d106c7950d28"); err == nil || !strings.Contains(err.Error(), "proof") {
|
|
t.Errorf("a merge ask is answered by the view: %v", err)
|
|
}
|
|
first := ViewAnswer{Asking: meshdeliveryclient.AskingID(hold, 0), Option: "release"}
|
|
if err := ViewAnswerFits(first, hold, asks.Ask{}); err != nil {
|
|
t.Errorf("an answer to the first asking is refused: %v", err)
|
|
}
|
|
if err := ViewAnswerFits(first, hold, asks.Ask{Asking: 2}); err == nil {
|
|
t.Error("an answer to an earlier asking is taken for the later one")
|
|
}
|
|
})
|
|
a := ViewAnswer{Asking: "hold-mesh-mail-aaaa-0123456789ab", Option: "release", Words: "fixed by #12"}
|
|
data, err := EncodeViewAnswer(a)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := DecodeViewAnswer(data)
|
|
a.V = keys.Version
|
|
if err != nil || !SameViewAnswer(got, a) {
|
|
t.Errorf("view answer came back %+v, %v", got, err)
|
|
}
|
|
if _, err := EncodeViewAnswer(ViewAnswer{Asking: "x", Option: " "}); err == nil {
|
|
t.Errorf("a view answer naming no option was accepted")
|
|
}
|
|
if _, err := EncodeViewAnswer(ViewAnswer{Option: "release"}); err == nil {
|
|
t.Errorf("a view answer naming no asking was accepted")
|
|
}
|
|
}
|