286 lines
10 KiB
Go
286 lines
10 KiB
Go
//go:build integration
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
|
sdkdelivery "git.novox.be/novox/mesh-sdk/go/delivery"
|
|
"github.com/nats-io/nats.go"
|
|
"github.com/novox/mesh-controller/internal/broker"
|
|
"github.com/novox/mesh-controller/internal/builderkeys"
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
"github.com/novox/mesh-controller/internal/link"
|
|
"github.com/novox/mesh-controller/internal/testbus"
|
|
)
|
|
|
|
func TestAWalkLetGoAndStoppedByVerbsIsSaidStartedAndEnded(t *testing.T) {
|
|
open := aMesh(t)
|
|
ctx := t.Context()
|
|
next := planMovedHeard(t)
|
|
register(t, open, catalogue.Manifest{Module: "app", Version: "1"})
|
|
if _, err := assign(ctx, open, "anchor", "app"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cut := time.Now().UTC()
|
|
waiting := inventory.Plan{ID: "plan-308-live", Repository: "novox/mesh-catalog", Branch: "main", Commit: "c8c8c8c8",
|
|
Created: cut, State: inventory.PlanBuilding, Tiers: [][]string{{"app"}},
|
|
Modules: map[string]*inventory.PlanModule{"app": {}},
|
|
Delivery: &inventory.PlanDelivery{Awaits: catalogue.DeliverySeat},
|
|
Times: &inventory.PlanTimes{Cut: &cut, Class: inventory.ClassLeaf}}
|
|
if err := open.inventory.SavePlan(ctx, &waiting); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := deliveryCommand(ctx, []string{"go", waiting.ID, "--why", "its turn"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
started := next(inventory.WalkStarted)
|
|
touches, _ := json.Marshal(started["touches"])
|
|
if started["walk"] != waiting.ID || string(touches) != `[{"machine":"anchor","modules":["app"]}]` ||
|
|
started["budget_class"] != inventory.ClassLeaf ||
|
|
started["bound_seconds"] != float64(2*deliveryBudgets[inventory.ClassLeaf]/time.Second) {
|
|
t.Fatalf("the start: %v", started)
|
|
}
|
|
if err := deliveryCommand(ctx, []string{"stop", waiting.ID, "--why", "a test", "--by", "a person"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ended := next(inventory.WalkEnded)
|
|
touches, _ = json.Marshal(ended["touches"])
|
|
if ended["walk"] != waiting.ID || ended["outcome"] != inventory.WalkStopped || string(touches) != `[]` {
|
|
t.Fatalf("the end, which sent nothing: %v", ended)
|
|
}
|
|
}
|
|
|
|
func planMovedHeard(t *testing.T) func(phase string) map[string]any {
|
|
t.Helper()
|
|
js, err := broker.Dial(testbus.URL(t))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(js.Close)
|
|
if err := broker.AssertMeshStreams(js); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before := handActConn
|
|
handActConn = js.Conn()
|
|
t.Cleanup(func() { handActConn = before })
|
|
heard := make(chan *nats.Msg, 64)
|
|
sub, err := js.Conn().ChanSubscribe(link.SeatEventSubject(link.MeshControllerSeat, link.KeyPlanMoved), heard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = sub.Unsubscribe() })
|
|
return func(phase string) map[string]any {
|
|
t.Helper()
|
|
deadline := time.After(5 * time.Second)
|
|
for {
|
|
select {
|
|
case m := <-heard:
|
|
var said map[string]any
|
|
if err := json.Unmarshal(m.Data, &said); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if said["phase"] == phase {
|
|
return said
|
|
}
|
|
case <-deadline:
|
|
t.Fatalf("no walk was said %s", phase)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAWalkStoppedOrClosedByAPersonIsSaidEndedStopped(t *testing.T) {
|
|
open := aMesh(t)
|
|
ctx := t.Context()
|
|
next := planMovedHeard(t)
|
|
register(t, open, catalogue.Manifest{Module: "app", Version: "1"})
|
|
if _, err := assign(ctx, open, "anchor", "app"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, verb := range []string{"stop", "close"} {
|
|
cut := time.Now().UTC()
|
|
walk := inventory.Plan{ID: "plan-308-" + verb, Repository: "novox/mesh-catalog", Branch: "main",
|
|
Commit: "c8c8c8c8", Created: cut, State: inventory.PlanBuilding, Tiers: [][]string{{"app"}},
|
|
Modules: map[string]*inventory.PlanModule{"app": {}},
|
|
Times: &inventory.PlanTimes{Cut: &cut, Started: &cut, Class: inventory.ClassLeaf}}
|
|
if err := open.inventory.SavePlan(ctx, &walk); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := plansCommand(ctx, []string{verb, walk.ID, "--why", "a test"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ended := next(inventory.WalkEnded)
|
|
if ended["walk"] != walk.ID || ended["outcome"] != inventory.WalkStopped {
|
|
t.Fatalf("plans %s: the end is %v", verb, ended)
|
|
}
|
|
p, err := open.inventory.PlanByID(ctx, walk.ID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if p.Outcome() != inventory.WalkStopped || p.Delivery == nil || p.Delivery.StoppedWhy != "a test" {
|
|
t.Fatalf("plans %s kept the walk %s, %+v", verb, p.Outcome(), p.Delivery)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAWalkRetriedByAPersonIsSaidStartedAgain(t *testing.T) {
|
|
open := aMesh(t)
|
|
ctx := t.Context()
|
|
asksRecorded(t)
|
|
next := planMovedHeard(t)
|
|
twoTiers(t, open)
|
|
before := time.Now().UTC().Add(-time.Hour)
|
|
ended := before.Add(time.Minute)
|
|
failed := inventory.Plan{ID: "plan-308-retry", Repository: "novox/a", Branch: "main", Commit: "c0ffee",
|
|
Created: before, State: inventory.PlanFailed, Tier: 0, Tiers: [][]string{{"a"}, {"b"}},
|
|
Note: "a failed to build in tier 0",
|
|
Modules: map[string]*inventory.PlanModule{"a": {State: "failed", AskedAt: &before, Build: "build-1",
|
|
Why: "killed by hand"}},
|
|
Times: &inventory.PlanTimes{Cut: &before, Started: &before, Ended: &ended, Class: inventory.ClassLeaf}}
|
|
if err := open.inventory.SavePlan(ctx, &failed); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := plansCommand(ctx, []string{"retry", failed.ID}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
started := next(inventory.WalkStarted)
|
|
if started["walk"] != failed.ID || started["budget_class"] != inventory.ClassLeaf {
|
|
t.Fatalf("the retried start: %v", started)
|
|
}
|
|
}
|
|
|
|
func TestABacklogReleasedByAPersonIsSaidStarted(t *testing.T) {
|
|
b := aBacklog(t)
|
|
next := planMovedHeard(t)
|
|
if err := backlogCommand(t.Context(), "release-backlog", []string{"--why", "a test"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
started := next(inventory.WalkStarted)
|
|
if p := b.release(t); started["walk"] != p.ID {
|
|
t.Fatalf("the release's start: %v", started)
|
|
}
|
|
}
|
|
|
|
func asTyped(t *testing.T, args ...string) error {
|
|
t.Helper()
|
|
was := os.Args
|
|
os.Args = append([]string{"mesh-controller"}, args...)
|
|
t.Cleanup(func() { os.Args = was })
|
|
err := run()
|
|
// run gives back the lease as the process would end; the test's process goes on, and takes it again.
|
|
theLease.mu.Lock()
|
|
theLease.held, theLease.kv, theLease.noBus = nil, nil, false
|
|
theLease.mu.Unlock()
|
|
return err
|
|
}
|
|
|
|
func TestAWalkStoppedByHandAndRetriedEndsFailedWhenItFailsAgain(t *testing.T) {
|
|
open := aMesh(t)
|
|
ctx := t.Context()
|
|
asksRecorded(t)
|
|
twoTiers(t, open)
|
|
for _, again := range [][]string{{"plans", "retry"}} {
|
|
before := time.Now().UTC().Add(-time.Hour)
|
|
walk := aStartedWalkAsking(t, open, "plan-308-again-"+again[0], "build-1", before)
|
|
if err := asTyped(t, "plans", "stop", walk.ID, "--why", "a test"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// The build asked before the stop fails after it.
|
|
p, _ := open.inventory.PlanByID(ctx, walk.ID)
|
|
p.Modules["a"].State, p.Modules["a"].Why = "failed", "it broke"
|
|
if err := open.inventory.SavePlan(ctx, &p); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
args := again
|
|
if again[0] == "plans" {
|
|
args = append(append([]string(nil), again...), walk.ID)
|
|
}
|
|
if err := asTyped(t, args...); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
p, _ = open.inventory.PlanByID(ctx, walk.ID)
|
|
if p.State != inventory.PlanBuilding || (p.Delivery != nil && p.Delivery.Stopped != "") {
|
|
t.Fatalf("%s: the walk is %s and keeps its stop: %+v", again[0], p.State, p.Delivery)
|
|
}
|
|
// The retry takes a from its key (it asks no build), at the commit the walk carries.
|
|
if a := p.Modules["a"]; a == nil || !a.Key || a.KeyAt != "c0ffee" {
|
|
t.Fatalf("%s: the retried walk does not take a from its key: %+v", again[0], a)
|
|
}
|
|
// The key fails again: the builder's record says so, and the look settles the walk from it.
|
|
wholeKeys := openPlanKeys
|
|
openPlanKeys = func() (planKeyReads, func(), error) {
|
|
all, done, err := wholeKeys()
|
|
return keysFailing{all, "a", "it broke again"}, done, err
|
|
}
|
|
t.Cleanup(func() { openPlanKeys = wholeKeys })
|
|
advancePlans(ctx, open)
|
|
if p, _ = open.inventory.PlanByID(ctx, walk.ID); p.State != inventory.PlanFailed || p.Outcome() != inventory.WalkFailed {
|
|
t.Fatalf("%s: failing again, the walk is %s and ends %s", again[0], p.State, p.Outcome())
|
|
}
|
|
}
|
|
}
|
|
|
|
// novox/hq ADR 0505 §2: a walk's start is said again, over the real bus and against the real store, with a machine it
|
|
// sends nothing to whose declaration differs from what it was last sent (here: assigned a module and never pushed),
|
|
// marked declared.
|
|
func TestAWalksStartIsSaidAgainWithAMachineWhoseDeclarationChanged(t *testing.T) {
|
|
open := aMesh(t)
|
|
ctx := t.Context()
|
|
next := planMovedHeard(t)
|
|
register(t, open, catalogue.Manifest{Module: "app", Version: "1"})
|
|
if _, err := assign(ctx, open, "anchor", "app"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
js, err := broker.Dial(testbus.URL(t))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(js.Close)
|
|
core, err := js.Conn().JetStream()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
body, err := json.Marshal(planMovedBody{Plan: inventory.Plan{ID: "plan-505", State: inventory.PlanBuilding},
|
|
walkSaid: &walkSaid{Walk: "plan-505", Phase: inventory.WalkStarted, BudgetClass: inventory.ClassLeaf,
|
|
BoundSeconds: 360, Touches: []walkTouch{}}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sayDeclared(ctx, link.OverNATS{Conn: js.Conn(), JS: core}, open, body)
|
|
again := next(inventory.WalkStarted)
|
|
raw, _ := json.Marshal(again["touches"])
|
|
var touches []walkTouch
|
|
_ = json.Unmarshal(raw, &touches)
|
|
anchor := false
|
|
for _, tc := range touches {
|
|
anchor = anchor || (tc.Machine == "anchor" && tc.Declared && len(tc.Modules) == 0)
|
|
if !tc.Declared {
|
|
t.Fatalf("a machine the walk sends nothing to was said sent: %s", raw)
|
|
}
|
|
}
|
|
if again["walk"] != "plan-505" || again[walkDeclaredRead] != true || !anchor {
|
|
t.Fatalf("said again: %v", again)
|
|
}
|
|
}
|
|
|
|
// keysFailing is the stand-in builder's keys but for one module, whose key is failed in these words.
|
|
type keysFailing struct {
|
|
planKeyReads
|
|
module string
|
|
words string
|
|
}
|
|
|
|
func (k keysFailing) Build(ctx context.Context, module, fp string) (builderkeys.Key, error) {
|
|
if module == k.module {
|
|
return builderkeys.Key{Module: module, Fingerprint: fp, Found: true, Revision: 1,
|
|
Build: sdkdelivery.BuilderBuild{State: sdkdelivery.BuildFailed, Error: k.words}}, nil
|
|
}
|
|
return k.planKeyReads.Build(ctx, module, fp)
|
|
}
|