193 lines
8.1 KiB
Go
193 lines
8.1 KiB
Go
package view
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
)
|
|
|
|
const (
|
|
fpOld = "src2:1111111111111111111111111111111111111111111111111111111111111111"
|
|
fpNew = "src2:2222222222222222222222222222222222222222222222222222222222222222"
|
|
)
|
|
|
|
func wantE(t *testing.T, node, module string, w delivery.Want) Entry {
|
|
t.Helper()
|
|
key, err := delivery.WantKey(node, module)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !w.Removed {
|
|
w.Composed = "sha256:" + strings.Repeat("c", 64)
|
|
}
|
|
v, err := delivery.EncodeWant(w)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Entry{Bucket: delivery.AssignerWantsBucket, Key: key, Value: v, At: t0}
|
|
}
|
|
|
|
func haveFP(t *testing.T, node, module, fp string, health delivery.Health) Entry {
|
|
t.Helper()
|
|
b, err := delivery.EncodeHave(delivery.Have{FP: fp, Phase: delivery.PhaseRunning, Health: health})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Entry{Bucket: delivery.HaveBucket, Key: node + "." + module, Value: b, At: t0}
|
|
}
|
|
|
|
func moduleE(t *testing.T, module, fp string) Entry {
|
|
t.Helper()
|
|
v, err := delivery.EncodeModule(delivery.Module{FP2: fp, Manifest: strings.Repeat("a", 64), Repository: "novox/" + module, Commit: strings.Repeat("1", 40), Path: delivery.RootPath})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Entry{Bucket: delivery.ModulesBucket, Key: module, Value: v, At: t0}
|
|
}
|
|
|
|
func sourceE(t *testing.T, revision uint64) Entry {
|
|
t.Helper()
|
|
v, err := delivery.EncodeSource(delivery.Source{Group: "g", Heads: map[string]string{"novox/web": strings.Repeat("1", 40)}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Entry{Bucket: delivery.SourceBucket, Key: delivery.SourceMainKey, Value: v, At: t0, Revision: revision}
|
|
}
|
|
|
|
// 1906/D7 AC7: every want is a row beside the have of its node, with where it stands.
|
|
func TestEveryWantIsARowAgainstItsHave(t *testing.T) {
|
|
m := New()
|
|
fill(m,
|
|
wantE(t, "ace", "web", delivery.Want{FP: fpNew}), haveFP(t, "ace", "web", fpNew, delivery.HealthOK),
|
|
wantE(t, "ace", "mail", delivery.Want{FP: fpNew}), haveFP(t, "ace", "mail", fpOld, delivery.HealthOK),
|
|
wantE(t, "g14", "web", delivery.Want{FP: fpNew}), haveFP(t, "g14", "web", fpNew, delivery.HealthFailed),
|
|
wantE(t, "g14", "mail", delivery.Want{FP: fpOld, Newest: fpNew, Rule: delivery.RuleCanary, Words: "the canary ace does not run it healthy yet"}),
|
|
wantE(t, "g14", "old", delivery.Want{Removed: true}),
|
|
wantE(t, "novox", "web", delivery.Want{FP: fpNew}),
|
|
)
|
|
got := map[string]WantRow{}
|
|
for _, r := range m.Snapshot().Wants {
|
|
got[r.Node+"."+r.Module] = r
|
|
}
|
|
for key, state := range map[string]string{
|
|
"ace.web": WantApplied, "ace.mail": WantPending, "g14.web": WantFailed, "g14.mail": WantHeldBack, "g14.old": WantRemoved, "novox.web": WantPending,
|
|
} {
|
|
if got[key].State != state {
|
|
t.Errorf("%s = %+v, want state %s", key, got[key], state)
|
|
}
|
|
}
|
|
if r := got["g14.mail"]; r.Rule != delivery.RuleCanary || r.Newest != fpNew || r.Words == "" {
|
|
t.Errorf("the held-back row keeps its rule and words: %+v", r)
|
|
}
|
|
if r := got["ace.mail"]; r.Want != fpNew || r.Have != fpOld {
|
|
t.Errorf("a pending row shows both: %+v", r)
|
|
}
|
|
// a want taken away leaves the list
|
|
fill(m, Entry{Bucket: delivery.AssignerWantsBucket, Key: "want.novox.web", Deleted: true})
|
|
if n := len(m.Snapshot().Wants); n != 5 {
|
|
t.Errorf("wants = %d after a delete, want 5", n)
|
|
}
|
|
}
|
|
|
|
// 1906/D7 AC7: a source revision is delivered when every want equals its module's fingerprint and every have equals its
|
|
// want, healthy; one failed have shows it not delivered and names the module.
|
|
func TestASourceRevisionIsDerivedFromWantsAndHaves(t *testing.T) {
|
|
m := New()
|
|
fill(m, sourceE(t, 14355), moduleE(t, "web", fpNew), moduleE(t, "mail", fpNew),
|
|
assign("ace", "web", "b-1", ""), assign("g14", "web", "b-1", ""),
|
|
wantE(t, "ace", "web", delivery.Want{FP: fpNew}), haveFP(t, "ace", "web", fpNew, delivery.HealthOK),
|
|
wantE(t, "g14", "web", delivery.Want{FP: fpNew}), haveFP(t, "g14", "web", fpNew, delivery.HealthOK),
|
|
wantE(t, "ace", "mail", delivery.Want{FP: fpNew}), haveFP(t, "ace", "mail", fpNew, delivery.HealthOK))
|
|
s := m.Snapshot().Source
|
|
if s == nil || s.Revision != 14355 || s.State != SourceDelivered || len(s.Waiting) != 0 {
|
|
t.Fatalf("source = %+v, want revision 14355 delivered", s)
|
|
}
|
|
fill(m, haveFP(t, "g14", "web", fpNew, delivery.HealthFailed))
|
|
s = m.Snapshot().Source
|
|
if s.State != SourceNotDelivered || len(s.Waiting) != 1 || !strings.Contains(s.Waiting[0], "web") || !strings.Contains(s.Waiting[0], "g14") {
|
|
t.Errorf("a failed have: %+v", s)
|
|
}
|
|
fill(m, haveFP(t, "g14", "web", fpNew, delivery.HealthOK), wantE(t, "ace", "mail", delivery.Want{FP: fpOld}))
|
|
s = m.Snapshot().Source
|
|
if s.State != SourceNotDelivered || !strings.Contains(strings.Join(s.Waiting, ";"), "mail") {
|
|
t.Errorf("a want that is not the module's fingerprint: %+v", s)
|
|
}
|
|
fill(m, wantE(t, "ace", "mail", delivery.Want{FP: fpNew}), assign("novox", "web", "b-1", ""))
|
|
s = m.Snapshot().Source
|
|
if s.State != SourceNotDelivered || !strings.Contains(strings.Join(s.Waiting, ";"), "novox") {
|
|
t.Errorf("a node assigned the module with no want: %+v", s)
|
|
}
|
|
}
|
|
|
|
func TestNoSourceRevisionHeldMeansNoStateIsDerived(t *testing.T) {
|
|
if s := New().Snapshot().Source; s != nil {
|
|
t.Errorf("source = %+v", s)
|
|
}
|
|
}
|
|
|
|
func TestTheWantsPageSaysWantsAgainstHaves(t *testing.T) {
|
|
m := New()
|
|
fill(m, wantE(t, "ace", "web", delivery.Want{FP: fpNew}), haveFP(t, "ace", "web", fpOld, delivery.HealthOK))
|
|
text := wantText(m.Snapshot())
|
|
if len(text) != 1 || text[0][0] != "ace" || text[0][1] != "web" || text[0][2] != fpNew || text[0][3] != fpOld || text[0][4] != WantPending || text[0][5] != "none" {
|
|
t.Errorf("text = %v", text)
|
|
}
|
|
}
|
|
|
|
// 1906/D7 (ADR 0539 §14): the controller's judgement of the move a want names is shown beside it, with its words.
|
|
func TestTheJudgementOfTheMoveIsShownBesideTheWant(t *testing.T) {
|
|
m := New()
|
|
key, err := delivery.ComposedKey("ace", "web", fpNew)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
v, err := delivery.EncodeComposedDigest(delivery.ComposedDigest{Digest: "sha256:" + strings.Repeat("c", 64), Judgement: delivery.JudgedCannot, Words: "the composition it runs is gone"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fill(m, wantE(t, "ace", "web", delivery.Want{FP: fpNew}), Entry{Bucket: delivery.ControllerComposedBucket, Key: key, Value: v, At: t0})
|
|
rows := m.Snapshot().Wants
|
|
if len(rows) != 1 || rows[0].Judgement != string(delivery.JudgedCannot) || !strings.Contains(rows[0].Judged, "gone") {
|
|
t.Fatalf("rows = %+v", rows)
|
|
}
|
|
text := wantText(m.Snapshot())
|
|
if len(text[0]) != 7 || text[0][5] != "cannot-judge" {
|
|
t.Errorf("text = %v", text)
|
|
}
|
|
}
|
|
|
|
// 1906/D9 (asked by the lead for issue 1946): the view says, once for each source revision, that it is delivered: the event the
|
|
// issue tracker derives "fix delivered" from, in place of the gate's states that go in release 6 (ADR 0539 §17).
|
|
func TestTheViewSaysOnceThatASourceRevisionIsDelivered(t *testing.T) {
|
|
m := New()
|
|
var said []DeliveredEvent
|
|
m.SetDeliveredEvent(func(e DeliveredEvent) { said = append(said, e) })
|
|
fill(m, sourceE(t, 14355), moduleE(t, "web", fpNew), assign("ace", "web", "b-1", ""),
|
|
wantE(t, "ace", "web", delivery.Want{FP: fpNew}))
|
|
if len(said) != 0 {
|
|
t.Fatalf("said %v before any have", said)
|
|
}
|
|
fill(m, haveFP(t, "ace", "web", fpNew, delivery.HealthFailed))
|
|
if len(said) != 0 {
|
|
t.Fatalf("said %v for a failed have", said)
|
|
}
|
|
fill(m, haveFP(t, "ace", "web", fpNew, delivery.HealthOK))
|
|
if len(said) != 1 || said[0].Revision != 14355 || said[0].Group != "g" || said[0].Heads["novox/web"] == "" {
|
|
t.Fatalf("said = %+v, want revision 14355 once with its group and heads", said)
|
|
}
|
|
fill(m, haveFP(t, "ace", "web", fpNew, delivery.HealthOK), wantE(t, "ace", "web", delivery.Want{FP: fpNew}))
|
|
if len(said) != 1 {
|
|
t.Errorf("said again for the same revision: %v", said)
|
|
}
|
|
// a newer revision is delivered when its wants and haves are; a revision that goes bad and good again is not said twice
|
|
fill(m, sourceE(t, 14356))
|
|
if len(said) != 2 || said[1].Revision != 14356 {
|
|
t.Errorf("the next revision: %v", said)
|
|
}
|
|
fill(m, haveFP(t, "ace", "web", fpNew, delivery.HealthFailed), haveFP(t, "ace", "web", fpNew, delivery.HealthOK))
|
|
if len(said) != 2 {
|
|
t.Errorf("said again after a have failed and recovered: %v", said)
|
|
}
|
|
}
|