270 lines
9.7 KiB
Go
270 lines
9.7 KiB
Go
package view
|
|
|
|
import (
|
|
"errors"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
)
|
|
|
|
var t0 = time.Date(2026, 10, 18, 12, 0, 0, 0, time.UTC)
|
|
|
|
func have(t *testing.T, build string, phase delivery.Phase, health delivery.Health, detail string) []byte {
|
|
t.Helper()
|
|
b, err := delivery.EncodeHave(delivery.Have{Build: build, Phase: phase, Health: health, Detail: detail})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return b
|
|
}
|
|
|
|
func haveE(t *testing.T, node, module string, v []byte, at time.Time) Entry {
|
|
return Entry{Bucket: delivery.HaveBucket, Key: node + "." + module, Value: v, At: at}
|
|
}
|
|
|
|
// place is the seat's placement of node, as the assigner keeps it (ADR 0567): the modules placed there.
|
|
func place(t *testing.T, node string, modules ...string) Entry {
|
|
t.Helper()
|
|
p := delivery.Placement{Node: node}
|
|
for _, m := range modules {
|
|
p.Modules = append(p.Modules, delivery.PlacedModule{Module: m})
|
|
}
|
|
key, err := delivery.PlacementKey(node)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
v, err := delivery.EncodePlacement(p)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Entry{Bucket: delivery.PlacementBucket, Key: key, Value: v, At: t0}
|
|
}
|
|
|
|
func buildRec(module, id, extra string) []Entry {
|
|
rec := `{"id":"` + id + `","module":"` + module + `","commit":"c"` + extra + `}`
|
|
return []Entry{
|
|
{Bucket: BuildsBucket, Key: module + ".build." + id, Value: []byte(rec), At: t0},
|
|
{Bucket: BuildsBucket, Key: module + ".newest", Value: []byte(id), At: t0},
|
|
}
|
|
}
|
|
|
|
func find(t *testing.T, s Snapshot, node, module string) Row {
|
|
t.Helper()
|
|
for _, r := range s.Rows {
|
|
if r.Node == node && r.Module == module {
|
|
return r
|
|
}
|
|
}
|
|
t.Fatalf("no row for %s.%s in %+v", node, module, s.Rows)
|
|
return Row{}
|
|
}
|
|
|
|
func fill(m *Model, es ...Entry) {
|
|
for _, e := range es {
|
|
m.Apply(e)
|
|
}
|
|
}
|
|
|
|
// base: two nodes (a, b), three modules (x, y, z).
|
|
func base(t *testing.T) []Entry {
|
|
es := []Entry{
|
|
place(t, "a", "x", "y"), place(t, "b", "x", "z"),
|
|
haveE(t, "a", "x", have(t, "b1", delivery.PhaseRunning, delivery.HealthOK, ""), t0.Add(1*time.Minute)),
|
|
haveE(t, "b", "x", have(t, "b1", delivery.PhaseChecking, delivery.HealthWaits, "starting"), t0.Add(2*time.Minute)),
|
|
haveE(t, "b", "z", have(t, "b3", delivery.PhaseRunning, delivery.HealthOK, ""), t0.Add(3*time.Minute)),
|
|
}
|
|
es = append(es, buildRec("x", "b1", "")...)
|
|
es = append(es, buildRec("y", "b2", "")...)
|
|
es = append(es, buildRec("z", "b3", "")...)
|
|
return es
|
|
}
|
|
|
|
func TestRowsPerAssignedModuleAndNode(t *testing.T) { // 1134/AC1
|
|
m := New()
|
|
fill(m, base(t)...)
|
|
s := m.Snapshot()
|
|
if len(s.Rows) != 4 || s.Counted() != 4 {
|
|
t.Fatalf("want 4 rows, got %d counted %d: %+v", len(s.Rows), s.Counted(), s.Rows)
|
|
}
|
|
r := find(t, s, "b", "x")
|
|
want := Row{Node: "b", Module: "x", Status: StatusAssigned, Have: "b1", Phase: "checking", Health: "waits",
|
|
Since: t0.Add(2 * time.Minute), Detail: "starting"}
|
|
if !reflect.DeepEqual(r, want) {
|
|
t.Fatalf("row = %+v, want %+v", r, want)
|
|
}
|
|
y := find(t, s, "a", "y")
|
|
if y.Waits != "no have yet" || y.Have != "" {
|
|
t.Fatalf("a.y = %+v, want 'no have yet'", y)
|
|
}
|
|
}
|
|
|
|
func TestLeftBehindIsWhatThePlacementDoesNotPut(t *testing.T) { // 1134/AC3, issue 774 (the seat's placement)
|
|
m := New()
|
|
fill(m, base(t)...)
|
|
fill(m, place(t, "b", "x")) // z taken off b
|
|
s := m.Snapshot()
|
|
if r := find(t, s, "b", "z"); r.Status != StatusLeftBehind || s.Counted() != 3 {
|
|
t.Errorf("status = %q counted %d, want %q and 3", r.Status, s.Counted(), StatusLeftBehind)
|
|
}
|
|
m = New()
|
|
fill(m, base(t)...)
|
|
fill(m, haveE(t, "a", "w", have(t, "b9", delivery.PhaseRunning, delivery.HealthOK, ""), t0)) // placed nowhere
|
|
s = m.Snapshot()
|
|
if find(t, s, "a", "w").Status != StatusLeftBehind || s.Counted() != 4 {
|
|
t.Fatalf("a have with no placement: %+v counted %d", find(t, s, "a", "w"), s.Counted())
|
|
}
|
|
fill(m, Entry{Bucket: delivery.PlacementBucket, Key: "placement.b", Deleted: true})
|
|
if s := m.Snapshot(); s.Counted() != 2 || find(t, s, "b", "x").Status != StatusLeftBehind {
|
|
t.Fatalf("b's placement deleted: counted %d, %+v", s.Counted(), s.Rows)
|
|
}
|
|
}
|
|
|
|
func TestUnknownVersionSaysSo(t *testing.T) { // 1134/AC4
|
|
m := New()
|
|
fill(m, base(t)...)
|
|
before := m.Snapshot()
|
|
fill(m, haveE(t, "a", "x", []byte(`{"v":9,"phase":"running","health":"ok"}`), t0))
|
|
s := m.Snapshot()
|
|
r := find(t, s, "a", "x")
|
|
_, sdkErr := delivery.DecodeHave([]byte(`{"v":9,"phase":"running","health":"ok"}`))
|
|
if !errors.Is(sdkErr, delivery.ErrUnknownVersion) {
|
|
t.Fatal("test premise: the SDK must refuse version 9")
|
|
}
|
|
if r.Error != sdkErr.Error() || !strings.Contains(r.Error, "version 9") {
|
|
t.Fatalf("error = %q, want the SDK's %q", r.Error, sdkErr)
|
|
}
|
|
if r.Have != "" || r.Phase != "" || r.Health != "" {
|
|
t.Fatalf("an unreadable have must not be guessed: %+v", r)
|
|
}
|
|
for _, n := range [][2]string{{"a", "y"}, {"b", "x"}, {"b", "z"}} {
|
|
if !reflect.DeepEqual(find(t, s, n[0], n[1]), find(t, before, n[0], n[1])) {
|
|
t.Errorf("row %s.%s changed", n[0], n[1])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestOnlyTheAffectedRowChanges(t *testing.T) { // 1134/AC5
|
|
m := New()
|
|
fill(m, base(t)...)
|
|
before := m.Snapshot()
|
|
fill(m, haveE(t, "b", "x", have(t, "b1", delivery.PhaseRunning, delivery.HealthOK, ""), t0.Add(9*time.Minute)))
|
|
after := m.Snapshot()
|
|
for i := range before.Rows {
|
|
changed := !reflect.DeepEqual(before.Rows[i], after.Rows[i])
|
|
if changed != (before.Rows[i].Node == "b" && before.Rows[i].Module == "x") {
|
|
t.Errorf("row %s.%s changed = %v", before.Rows[i].Node, before.Rows[i].Module, changed)
|
|
}
|
|
}
|
|
if r := find(t, after, "b", "x"); r.Phase != "running" || r.Health != "ok" || !r.Since.Equal(t0.Add(9*time.Minute)) {
|
|
t.Fatalf("changed row = %+v", r)
|
|
}
|
|
// a want's change touches only its row
|
|
fill(m, wantE(t, "a", "y", delivery.Want{FP: fpNew}))
|
|
if r := find(t, m.Snapshot(), "a", "y"); r.Assigned != fpNew {
|
|
t.Fatalf("want change not seen: %+v", r)
|
|
}
|
|
if !reflect.DeepEqual(find(t, m.Snapshot(), "b", "z"), find(t, after, "b", "z")) {
|
|
t.Fatal("a want of another row changed b.z")
|
|
}
|
|
// a deleted key (a bucket's expiry) removes its value
|
|
m.Apply(Entry{Bucket: delivery.HaveBucket, Key: "a.x", Deleted: true})
|
|
if !strings.HasPrefix(find(t, m.Snapshot(), "a", "x").Waits, "no have yet") {
|
|
t.Fatal("a deleted have must read as no have")
|
|
}
|
|
// a restart rebuilds the same rows from last values
|
|
a, b := New(), New()
|
|
es := base(t)
|
|
fill(a, es...)
|
|
fill(b, es...)
|
|
if !reflect.DeepEqual(a.Snapshot(), b.Snapshot()) {
|
|
t.Fatal("the same last values must give the same rows")
|
|
}
|
|
}
|
|
|
|
func TestNodeRow(t *testing.T) { // 1134/AC1 (the node's own key gives a node row)
|
|
m := New()
|
|
v, _ := delivery.EncodeHaveNode(delivery.HaveNode{Windows: []byte(`[1,2]`), Busy: []byte(`{"a":1}`), Strays: []byte(`[]`)})
|
|
fill(m, Entry{Bucket: delivery.HaveBucket, Key: "a.node", Value: v, At: t0})
|
|
n := m.Snapshot().Nodes
|
|
if len(n) != 1 || n[0].Node != "a" || n[0].Windows != 2 || n[0].Busy != 1 || n[0].Strays != 0 {
|
|
t.Fatalf("nodes = %+v", n)
|
|
}
|
|
}
|
|
|
|
func presenceE(t *testing.T, key string, online bool, at time.Time) Entry {
|
|
t.Helper()
|
|
b, err := delivery.EncodePresence(delivery.Presence{Online: online})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Entry{Bucket: delivery.PresenceBucket, Key: key, Value: b, At: at}
|
|
}
|
|
|
|
func stuckE(t *testing.T, bucket, key, waited string, since time.Time, moved bool) Entry {
|
|
t.Helper()
|
|
b, err := delivery.EncodeStuck(delivery.Stuck{Bucket: bucket, Key: key, Waited: waited, Since: since, Moved: moved})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return Entry{Bucket: delivery.StuckBucket, Key: bucket + "." + key, Value: b, At: since}
|
|
}
|
|
|
|
func TestOfflineAndStuckAreListed(t *testing.T) { // 1168/AC2
|
|
m := New()
|
|
fill(m, base(t)...)
|
|
fill(m,
|
|
presenceE(t, "a", false, t0),
|
|
presenceE(t, "b", true, t0),
|
|
presenceE(t, "part.mesh-delivery-view.i1", false, t0.Add(time.Minute)),
|
|
stuckE(t, "node-engine_have", "a.x", "a report from a", t0.Add(2*time.Minute), false),
|
|
stuckE(t, "node-engine_have", "b.x", "a report from b", t0, true),
|
|
)
|
|
s := m.Snapshot()
|
|
want := []OfflineRow{{Kind: "node", Node: "a", Since: t0}, {Kind: "part", Part: "mesh-delivery-view", Instance: "i1", Since: t0.Add(time.Minute)}}
|
|
if !reflect.DeepEqual(s.Offline, want) {
|
|
t.Fatalf("offline = %+v, want %+v", s.Offline, want)
|
|
}
|
|
wantStuck := []StuckRow{{Bucket: "node-engine_have", Key: "a.x", Waited: "a report from a", Since: t0.Add(2 * time.Minute)}}
|
|
if !reflect.DeepEqual(s.Stuck, wantStuck) {
|
|
t.Fatalf("stuck = %+v, want %+v", s.Stuck, wantStuck)
|
|
}
|
|
// back online and moved leave the lists
|
|
fill(m, presenceE(t, "a", true, t0.Add(5*time.Minute)), presenceE(t, "part.mesh-delivery-view.i1", true, t0.Add(5*time.Minute)),
|
|
stuckE(t, "node-engine_have", "a.x", "a report from a", t0.Add(2*time.Minute), true))
|
|
s = m.Snapshot()
|
|
if len(s.Offline) != 0 || len(s.Stuck) != 0 {
|
|
t.Fatalf("offline %+v stuck %+v, want both empty", s.Offline, s.Stuck)
|
|
}
|
|
}
|
|
|
|
func TestUnknownWatchmanVersionIsUnreadableNotDropped(t *testing.T) { // 1168/AC3
|
|
m := New()
|
|
fill(m,
|
|
Entry{Bucket: delivery.PresenceBucket, Key: "c", Value: []byte(`{"v":9,"online":false}`), At: t0},
|
|
Entry{Bucket: delivery.StuckBucket, Key: "node-engine_have.c.x", Value: []byte(`{"v":9}`), At: t0},
|
|
presenceE(t, "a", false, t0),
|
|
)
|
|
s := m.Snapshot()
|
|
if len(s.Unreadable) != 2 || len(s.Offline) != 1 {
|
|
t.Fatalf("unreadable %+v offline %+v", s.Unreadable, s.Offline)
|
|
}
|
|
_, sdkErr := delivery.DecodePresence([]byte(`{"v":9,"online":false}`))
|
|
var got *UnreadableRow
|
|
for i := range s.Unreadable {
|
|
if s.Unreadable[i].Key == "c" {
|
|
got = &s.Unreadable[i]
|
|
}
|
|
}
|
|
if got == nil || got.Bucket != delivery.PresenceBucket || got.Error != sdkErr.Error() {
|
|
t.Fatalf("unreadable = %+v, want key c with the SDK's error %q", s.Unreadable, sdkErr)
|
|
}
|
|
// a good value later replaces the unreadable one
|
|
fill(m, presenceE(t, "c", true, t0))
|
|
if len(m.Snapshot().Unreadable) != 1 {
|
|
t.Fatal("a readable value must clear the unreadable mark")
|
|
}
|
|
}
|