jschoubben
14f405ece5
mesh/merge-gate head 14f405ece508 merged into trunk 5c807808e88a — pass: builds mesh-controller → novox; no bus step; every machine composes with the chang…
mesh/repo-check head 14f405ece508 merged into trunk 5c807808e88a — pass: its merge-check.sh passed
mesh/delivery delivered
103 lines
3.2 KiB
Go
103 lines
3.2 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
"github.com/novox/mesh-controller/internal/link"
|
|
)
|
|
|
|
// heldPublish is a bus that holds a plan-moved publish until it is let go, and keeps the body.
|
|
type heldPublish struct {
|
|
link.Bus
|
|
let chan struct{}
|
|
body chan []byte
|
|
}
|
|
|
|
func (h *heldPublish) PublishSeatEvent(_ context.Context, _, _ string, body []byte) error {
|
|
<-h.let
|
|
h.body <- body
|
|
return nil
|
|
}
|
|
|
|
func aWalkWithSteps() inventory.Plan {
|
|
built := time.Date(2026, 10, 19, 12, 0, 0, 0, time.UTC)
|
|
return inventory.Plan{ID: "plan-1", Repository: "novox/one", Commit: "abc", State: "walking", Tier: 1,
|
|
Created: built, Updated: built, Revision: 4,
|
|
Tiers: [][]string{{"alpha"}, {"beta", "gamma"}},
|
|
Modules: map[string]*inventory.PlanModule{
|
|
"alpha": {State: "built", BuiltAt: &built, Commit: "abc", First: []string{"ace"}},
|
|
"beta": {State: "asked", Why: "waiting"},
|
|
"gamma": {},
|
|
},
|
|
Times: &inventory.PlanTimes{Started: &built}, WalkSaid: inventory.WalkStarted}
|
|
}
|
|
|
|
func TestAnAnnouncementIsThePlanAsItWasWhenSaidWhatTheWalkDoesNext(t *testing.T) { // 1260/AC1
|
|
p := aWalkWithSteps()
|
|
bus := &heldPublish{let: make(chan struct{}), body: make(chan []byte, 1)}
|
|
sayPlanMoved(t.Context(), bus, nil, p)
|
|
|
|
// The walk goes on, writing its steps while the announcement is being made.
|
|
for i := 0; i < 2000; i++ {
|
|
step := p.Modules["beta"]
|
|
step.State, step.Why = "built", "changed after the call"
|
|
step.First = append(step.First[:0], "novox")
|
|
p.Modules["delta"] = &inventory.PlanModule{State: "asked"}
|
|
p.Tiers[1][0] = "changed"
|
|
p.Times.Started = nil
|
|
delete(p.Modules, "delta")
|
|
}
|
|
close(bus.let)
|
|
|
|
var said inventory.Plan
|
|
select {
|
|
case body := <-bus.body:
|
|
if err := json.Unmarshal(body, &said); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
case <-time.After(10 * time.Second):
|
|
t.Fatal("nothing was announced")
|
|
}
|
|
if said.Modules["beta"].State != "asked" || said.Modules["beta"].Why != "waiting" || said.Tiers[1][0] != "beta" ||
|
|
len(said.Modules) != 3 || said.Times == nil || said.Times.Started == nil {
|
|
t.Errorf("the announcement carries the walk as it went on, not as it was: %+v", said)
|
|
}
|
|
}
|
|
|
|
func TestAnAnnouncementOfAnUnchangedPlanIsTheBodyItWasBeforeTheCopy(t *testing.T) { // 1260/AC2
|
|
p := aWalkWithSteps()
|
|
bus := &heldPublish{let: make(chan struct{}), body: make(chan []byte, 1)}
|
|
close(bus.let)
|
|
sayPlanMoved(t.Context(), bus, nil, p)
|
|
var got []byte
|
|
select {
|
|
case got = <-bus.body:
|
|
case <-time.After(10 * time.Second):
|
|
t.Fatal("nothing was announced")
|
|
}
|
|
// What it was: the plan whole, its phases worked out, and what the walk says of itself.
|
|
q := p
|
|
q.Phases = q.WalkPhases(time.Now(), nil)
|
|
want, err := json.Marshal(planMovedBody{Plan: q, walkSaid: sayWalk(t.Context(), nil, q)})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var a, b map[string]any
|
|
if json.Unmarshal(got, &a) != nil || json.Unmarshal(want, &b) != nil {
|
|
t.Fatal("a body is not JSON")
|
|
}
|
|
delete(a, "phases") // worked out from the time of the call
|
|
delete(b, "phases")
|
|
if !reflect.DeepEqual(a, b) {
|
|
t.Errorf("the body changed:\n got %s\nwant %s", got, want)
|
|
}
|
|
if a["walk"] != "plan-1" {
|
|
t.Errorf("the walk's own words are not in the body: %s", got)
|
|
}
|
|
}
|