117 lines
6.0 KiB
Go
117 lines
6.0 KiB
Go
package main
|
|
|
|
import (
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
)
|
|
|
|
// novox/hq ADR 0360 §4, §5: a walk ends on its machines' reports — every machine sent has reported on its send,
|
|
// or is silent past ApplySilentAfter — and names a failed or refused apply; it never waits for a health reading.
|
|
func TestAWalkEndsOnItsMachinesReports(t *testing.T) {
|
|
now := time.Date(2026, 10, 14, 12, 0, 0, 0, time.UTC)
|
|
sent := now.Add(-time.Minute)
|
|
long := now.Add(-inventory.ApplySilentAfter - time.Minute)
|
|
at := now.Add(-10 * time.Second)
|
|
p := inventory.Plan{Modules: map[string]*inventory.PlanModule{
|
|
"app": {Rest: map[string]inventory.SentDeclaration{
|
|
"ace": {Digest: "d-ace", At: sent},
|
|
"novox": {Digest: "d-novox", At: sent},
|
|
"shanks": {Digest: "d-shanks", At: sent},
|
|
"laptop": {Digest: "d-laptop", At: long},
|
|
}},
|
|
"proxy": {Rest: map[string]inventory.SentDeclaration{"ace": {Digest: "d-ace", At: sent}}},
|
|
}}
|
|
reports := []inventory.Reported{
|
|
{Node: "ace", Outcome: inventory.OutcomeApplied, At: &at, Declared: "d-ace"},
|
|
{Node: "novox", Outcome: inventory.OutcomeFailed, At: &at, Declared: "d-novox"},
|
|
{Node: "shanks", Outcome: inventory.OutcomeApplied, At: &at, Declared: "d-before"},
|
|
}
|
|
waiting, failed, silent := walkReports(p, reports, now, nil)
|
|
if !slices.Equal(waiting, []string{"shanks"}) || !slices.Equal(failed, []string{"novox"}) ||
|
|
!slices.Equal(silent, []string{"laptop"}) {
|
|
t.Fatalf("waiting %v, failed %v, silent %v", waiting, failed, silent)
|
|
}
|
|
reports[2].Declared = "d-shanks"
|
|
if waiting, _, _ := walkReports(p, reports, now, nil); len(waiting) != 0 {
|
|
t.Fatalf("the walk still waits once every machine reported: %v", waiting)
|
|
}
|
|
}
|
|
|
|
// withTheGate turns the first-machine gate on for a test of its own path: kept for the walks a controller before
|
|
// novox/hq ADR 0360 started.
|
|
func withTheGate(t *testing.T) {
|
|
t.Helper()
|
|
was := gateFirstMachine
|
|
gateFirstMachine = true
|
|
t.Cleanup(func() { gateFirstMachine = was })
|
|
}
|
|
|
|
// Every machine heard from is sent at once and passed on its applied report, with no judging (novox/hq ADR 0360 §7);
|
|
// before, the first machine was judged before the rest were sent (ADR 0353 §1).
|
|
|
|
// A machine that reports its apply failed is named and fails the release, with nothing put back, and every other
|
|
// machine goes on to its own report (novox/hq ADR 0360 §5, §7); before, it was put back (ADR 0353 §3).
|
|
|
|
// A release's send kept before it was made, and made, is judged by the controller that takes over without being
|
|
// made again (ADR 0353 §8), with every machine sent at once (ADR 0360 §7).
|
|
|
|
// A machine of the rest that says nothing on its send is left silent after fifteen minutes: not failed, not put
|
|
// back; a rest that went silent whole ends failed, said as a condition (ADR 0353 §4); its step also sent anchor, so the release is done, not failed (ADR 0360 §7).
|
|
|
|
// Issue 840 (novox/hq ADR 0362 §1-5): a walk's end counts a machine's send of a provisioned module applied only once
|
|
// the engine and the machine's provisioner client both said so.
|
|
func TestAWalkEndWaitsForTheProvisioner(t *testing.T) {
|
|
now := time.Date(2026, 10, 15, 12, 0, 0, 0, time.UTC)
|
|
at := now.Add(-10 * time.Second)
|
|
plan := func(sentAt time.Time) inventory.Plan {
|
|
return inventory.Plan{Modules: map[string]*inventory.PlanModule{"app": {Rest: map[string]inventory.SentDeclaration{
|
|
"ace": {Digest: "d-ace", At: sentAt, Provisioned: map[string]string{"app": "t1"}},
|
|
"g14": {Digest: "d-g14", At: sentAt, Provisioned: map[string]string{"app": "t1"}},
|
|
}}}}
|
|
}
|
|
reports := []inventory.Reported{
|
|
{Node: "ace", Outcome: inventory.OutcomeApplied, At: &at, Declared: "d-ace"},
|
|
{Node: "g14", Outcome: inventory.OutcomeApplied, At: &at, Declared: "d-g14"},
|
|
}
|
|
says := map[string]inventory.ProvReport{}
|
|
prov := func(node, module string) (inventory.ProvReport, bool) { r, ok := says[node+"/"+module]; return r, ok }
|
|
applied := inventory.ProvReport{Status: inventory.ProvApplied, Templates: "t1", At: at}
|
|
|
|
// (a) the engine applied, the client has not said: the end waits on both.
|
|
waiting, failed, silent := walkReports(plan(now.Add(-time.Minute)), reports, now, prov)
|
|
if !slices.Equal(waiting, []string{"ace", "g14"}) || len(failed)+len(silent) != 0 {
|
|
t.Fatalf("a: waiting %v, failed %v, silent %v", waiting, failed, silent)
|
|
}
|
|
// ace's client applied, g14's failed on that build (b): ace done, g14 a failed apply naming the reason.
|
|
says["ace/app"] = applied
|
|
says["g14/app"] = inventory.ProvReport{Status: inventory.ProvFailed, Templates: "t1", Reason: "no value", At: at}
|
|
waiting, failed, silent = walkReports(plan(now.Add(-time.Minute)), reports, now, prov)
|
|
if len(waiting) != 0 || len(silent) != 0 || len(failed) != 1 || !strings.HasPrefix(failed[0], "g14 (") ||
|
|
!strings.Contains(failed[0], "no value") {
|
|
t.Fatalf("b: waiting %v, failed %v, silent %v", waiting, failed, silent)
|
|
}
|
|
// (c) no client report past ApplySilentAfter: named silent, never applied.
|
|
delete(says, "g14/app")
|
|
waiting, failed, silent = walkReports(plan(now.Add(-inventory.ApplySilentAfter-time.Minute)), reports, now, prov)
|
|
if len(waiting) != 0 || len(failed) != 0 || !slices.Equal(silent, []string{"g14"}) {
|
|
t.Fatalf("c: waiting %v, failed %v, silent %v", waiting, failed, silent)
|
|
}
|
|
// both said it: nothing waits.
|
|
says["g14/app"] = applied
|
|
if waiting, failed, silent = walkReports(plan(now.Add(-time.Minute)), reports, now, prov); len(waiting)+len(failed)+len(silent) != 0 {
|
|
t.Fatalf("both said: waiting %v, failed %v, silent %v", waiting, failed, silent)
|
|
}
|
|
// (d) a send handing nothing to the provisioner is the engine's report alone, as before.
|
|
bare := plan(now.Add(-time.Minute))
|
|
bare.Modules["app"].Rest = map[string]inventory.SentDeclaration{"ace": {Digest: "d-ace", At: now.Add(-time.Minute)}}
|
|
if waiting, failed, silent = walkReports(bare, reports, now, func(string, string) (inventory.ProvReport, bool) {
|
|
return inventory.ProvReport{}, false
|
|
}); len(waiting)+len(failed)+len(silent) != 0 {
|
|
t.Fatalf("d: waiting %v, failed %v, silent %v", waiting, failed, silent)
|
|
}
|
|
}
|