jschoubben
0e0c775bfa
mesh/merge-gate head 0e0c775bfa5e merged into trunk f10fbda1f619 — pass: builds build-agent, mesh-controller → ace, g14, novox, shanks; no bus step; every …
mesh/repo-check head 0e0c775bfa5e merged into trunk f10fbda1f619 — pass: its merge-check.sh passed
mesh/delivery delivered
199 lines
8.5 KiB
Go
199 lines
8.5 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
)
|
|
|
|
// heldElsewhere is the plans held by another act for longer than any test runs: waiting for them ends only with the
|
|
// context, and a look that does not wait is told at once that they are busy.
|
|
func heldElsewhere(ctx context.Context, wait bool) (func(), error) {
|
|
if !wait {
|
|
return nil, inventory.ErrPlansBusy
|
|
}
|
|
<-ctx.Done()
|
|
return nil, inventory.ErrPlansBusy
|
|
}
|
|
|
|
// 1708/AC1: given the plans held by another act, when the event loop takes a build's outcome, then it returns at
|
|
// once, without waiting the plans' two minutes (on 2026-10-21 at 14:20:45 nodered's outcome held the loop until
|
|
// 14:22:45, and the operator was told the controller stopped listening).
|
|
func TestAnOutcomeDoesNotWaitForThePlansAnotherActHolds(t *testing.T) {
|
|
ctx, cancel := context.WithTimeout(t.Context(), 3*time.Second)
|
|
defer cancel()
|
|
start := time.Now()
|
|
release, err := holdPlansForOutcome(ctx, heldElsewhere)
|
|
if took := time.Since(start); took > time.Second {
|
|
t.Fatalf("taking an outcome waited %s for plans another act holds; the event loop takes nothing meanwhile", took)
|
|
}
|
|
if err == nil || release != nil {
|
|
t.Fatalf("plans another act holds were said to be held: release %v, err %v", release != nil, err)
|
|
}
|
|
}
|
|
|
|
// 1708/AC4: given the plans free, when the event loop takes a build's outcome, then it holds them and marks the plan
|
|
// from the outcome directly, as before.
|
|
func TestAnOutcomeHoldsThePlansWhenTheyAreFree(t *testing.T) {
|
|
let := false
|
|
release, err := holdPlansForOutcome(t.Context(), func(context.Context, bool) (func(), error) {
|
|
return func() { let = true }, nil
|
|
})
|
|
if err != nil || release == nil {
|
|
t.Fatalf("free plans were not held: %v", err)
|
|
}
|
|
release()
|
|
if !let {
|
|
t.Fatal("the hold given was not the one taken")
|
|
}
|
|
}
|
|
|
|
// withLooker installs a looker that is never run, and answers it, so a test can read whether a look was asked.
|
|
func withLooker(t *testing.T) *looker {
|
|
t.Helper()
|
|
l := newLooker(func(context.Context) bool { return false })
|
|
lookerMu.Lock()
|
|
before := theLooker
|
|
theLooker = l
|
|
lookerMu.Unlock()
|
|
t.Cleanup(func() {
|
|
lookerMu.Lock()
|
|
theLooker = before
|
|
lookerMu.Unlock()
|
|
})
|
|
return l
|
|
}
|
|
|
|
// 1708/AC2: given an outcome left to the build records because the plans were held, when it is left, then the look
|
|
// at the plans is asked for, so the records settle it once the holder lets go rather than at the next event.
|
|
func TestAnOutcomeLeftToTheRecordsAsksForTheLook(t *testing.T) {
|
|
l := withLooker(t)
|
|
leaveToRecords("nodered", "build-1708-ac2", "", "", inventory.ErrPlansBusy)
|
|
select {
|
|
case <-l.signal:
|
|
default:
|
|
t.Fatal("an outcome left to the build records asked for no look: the plan waits for whatever event comes next")
|
|
}
|
|
}
|
|
|
|
// 1708/AC3: given an outcome left to the records that said what the build did (ADR 0350 §4), when the look settles
|
|
// the plan from the build records by that build's id, then the module keeps those words, once.
|
|
func TestTheRecordsSettleAnOutcomeWithWhatTheBuildDid(t *testing.T) {
|
|
withLooker(t)
|
|
asked := time.Date(2026, 10, 21, 12, 15, 0, 0, time.UTC)
|
|
plan := func() inventory.Plan {
|
|
return inventory.Plan{ID: "plan-1708", Tiers: [][]string{{"nodered"}},
|
|
Modules: map[string]*inventory.PlanModule{"nodered": {State: "asked", AskedAt: &asked, Build: "build-1708-ac3"}}}
|
|
}
|
|
byID := map[string]inventory.Build{"build-1708-ac3": {ID: "build-1708-ac3", Module: "nodered", Commit: "4efac366",
|
|
At: asked.Add(5 * time.Minute)}}
|
|
leaveToRecords("nodered", "build-1708-ac3", "reused from build-1708-check", "", inventory.ErrPlansBusy)
|
|
|
|
p := plan()
|
|
if !settleFromRecords(&p, p.Tiers[0], nil, byID) || p.Modules["nodered"].State != "built" {
|
|
t.Fatalf("the records did not settle the outcome: %+v", p.Modules["nodered"])
|
|
}
|
|
if got := p.Modules["nodered"].Made; got != "reused from build-1708-check" {
|
|
t.Fatalf("settled from the records, the module says %q of what its build did, not the outcome's words", got)
|
|
}
|
|
again := plan()
|
|
settleFromRecords(&again, again.Tiers[0], nil, byID)
|
|
if got := again.Modules["nodered"].Made; got != "" {
|
|
t.Fatalf("an outcome's words were kept for a second settle: %q", got)
|
|
}
|
|
}
|
|
|
|
// 1708/AC5: given a serving controller (its look at the plans running), when an outcome was taken into the plans,
|
|
// then moving them (a release's sends, which may retry for minutes) is left to the look, off the event loop
|
|
// (2026-10-21 14:28:40 to 14:32:10: the loop sent okioki's release to g14 after mesh-delivery-builder's outcome).
|
|
func TestAnOutcomeLeavesMovingThePlansToTheLook(t *testing.T) {
|
|
l := withLooker(t)
|
|
moved := false
|
|
advanceAfterOutcome(func() { moved = true })
|
|
if moved {
|
|
t.Fatal("the plans were moved on the event loop after an outcome, where a send that retries holds every message")
|
|
}
|
|
select {
|
|
case <-l.signal:
|
|
default:
|
|
t.Fatal("the look was not asked to move the plans after an outcome")
|
|
}
|
|
}
|
|
|
|
// 1708/AC5: given no look running (a command, which has no event loop), when an outcome was taken, then the plans are
|
|
// moved at once, as before.
|
|
func TestAnOutcomeMovesThePlansWhereNoLookRuns(t *testing.T) {
|
|
lookerMu.Lock()
|
|
before := theLooker
|
|
theLooker = nil
|
|
lookerMu.Unlock()
|
|
t.Cleanup(func() {
|
|
lookerMu.Lock()
|
|
theLooker = before
|
|
lookerMu.Unlock()
|
|
})
|
|
moved := false
|
|
advanceAfterOutcome(func() { moved = true })
|
|
if !moved {
|
|
t.Fatal("with no look running, an outcome left the plans unmoved")
|
|
}
|
|
}
|
|
|
|
// 1708/AC6: given a registration the mesh refused (its build recorded as worked, the outcome failed), left to the
|
|
// records because the plans were held, when the look settles the plan from the records, then the module and the plan
|
|
// are failed, never built: settled as built, the tier would be sent the version from before (reviewer-1708@shanks).
|
|
func TestARefusedRegistrationLeftToTheRecordsFailsThePlan(t *testing.T) {
|
|
withLooker(t)
|
|
asked := time.Date(2026, 10, 21, 12, 15, 0, 0, time.UTC)
|
|
p := inventory.Plan{ID: "plan-1708-ac6", State: inventory.PlanBuilding, Tiers: [][]string{{"nodered"}},
|
|
Modules: map[string]*inventory.PlanModule{"nodered": {State: "asked", AskedAt: &asked, Build: "build-1708-ac6"}}}
|
|
byID := map[string]inventory.Build{"build-1708-ac6": {ID: "build-1708-ac6", Module: "nodered", Commit: "4efac366",
|
|
At: asked.Add(5 * time.Minute)}}
|
|
leaveToRecords("nodered", "build-1708-ac6", "", "the mesh does not register it: a port is taken", inventory.ErrPlansBusy)
|
|
|
|
overlayRefusals(nil, byID, refusalsKeptFor([]string{"build-1708-ac6"}))
|
|
settleFromRecords(&p, p.Tiers[0], nil, byID)
|
|
if s := p.Modules["nodered"]; s.State != "failed" || p.State != inventory.PlanFailed {
|
|
t.Fatalf("a refused registration left to the records settled as %q, the plan %q", s.State, p.State)
|
|
}
|
|
if !strings.Contains(p.Modules["nodered"].Why, "a port is taken") {
|
|
t.Fatalf("the refusal's words were lost: %q", p.Modules["nodered"].Why)
|
|
}
|
|
}
|
|
|
|
// 1708/AC6: a refusal kept in the store (a controller replaced before the settle) fails the record as one kept in
|
|
// the process does.
|
|
func TestARefusalFromTheStoreFailsTheRecord(t *testing.T) {
|
|
recorded := map[string][]inventory.Build{"nodered": {{ID: "b-store", Module: "nodered"}, {ID: "b-other", Module: "nodered"}}}
|
|
byID := map[string]inventory.Build{"b-store": {ID: "b-store", Module: "nodered"}}
|
|
overlayRefusals(recorded, byID, map[string]string{"b-store": "not registered"})
|
|
if recorded["nodered"][0].Worked() || byID["b-store"].Worked() {
|
|
t.Fatal("a build whose registration was refused still reads as worked")
|
|
}
|
|
if !recorded["nodered"][1].Worked() {
|
|
t.Fatal("a build nobody refused was failed")
|
|
}
|
|
}
|
|
|
|
// 1708/AC7: given the records settle a module as deleted at its source, or fail the plan, when the look settles, then
|
|
// it does what taking the outcome directly does: the deleted module is named to be forgotten, and the plan's failure
|
|
// is said (reviewer-1708@shanks).
|
|
func TestSettlingFromTheRecordsDoesWhatTakingTheOutcomeDoes(t *testing.T) {
|
|
p := inventory.Plan{State: inventory.PlanFailed, Modules: map[string]*inventory.PlanModule{
|
|
"gone": {State: planDeleted}, "x": {State: "failed"}, "y": {State: "built"}}}
|
|
before := map[string]string{"gone": "asked", "x": "asked", "y": "built"}
|
|
deleted, failed := settledEffects(before, &p, inventory.PlanBuilding)
|
|
if len(deleted) != 1 || deleted[0] != "gone" {
|
|
t.Fatalf("the module the records found deleted is not forgotten: %v", deleted)
|
|
}
|
|
if !failed {
|
|
t.Fatal("the plan the records failed is not said as failed")
|
|
}
|
|
if d, f := settledEffects(map[string]string{"gone": planDeleted}, &p, inventory.PlanFailed); len(d) != 0 || f {
|
|
t.Fatalf("what was deleted or failed before the settle is acted on again: %v %v", d, f)
|
|
}
|
|
}
|