mesh-controller/cmd/mesh-controller/plans_follow_test.go

package main

import (
	"context"
	"encoding/json"
	"strings"
	"testing"
	"time"

	"github.com/novox/mesh-controller/internal/inventory"
)

// A plan as the store would answer it at each read: the reads are counted, and each answers the next.
type planReads struct {
	plans []inventory.Plan
	n     int
}

func (r *planReads) read(context.Context) (inventory.Plan, error) {
	p := r.plans[min(r.n, len(r.plans)-1)]
	r.n++
	return p, nil
}

func followedPlan(rev int64, state string, tier int) inventory.Plan {
	return inventory.Plan{ID: "plan-1", Repository: "novox/x", Commit: "abc", State: state, Tier: tier,
		Tiers: [][]string{{"a"}, {"b"}}, Revision: rev}
}

// **`plans` waits for a plan, and says what ended the wait** (novox/hq issue 229): an agent following a
// rollout is told when the plan moved, reached its next tier or ended, or that the bound passed — in one
// call, without a loop of its own.
func TestAWaitForAPlanEndsWhenWhatItWaitsForHappens(t *testing.T) {
	cases := []struct {
		name  string
		until string
		reads []inventory.Plan
		came  string
		times int
	}{
		{"moved: any save", "moved", []inventory.Plan{
			followedPlan(1, inventory.PlanBuilding, 0), followedPlan(1, inventory.PlanBuilding, 0),
			followedPlan(2, inventory.PlanBuilding, 0)}, "moved", 3},
		{"tier: a save inside the tier is not enough", "tier", []inventory.Plan{
			followedPlan(1, inventory.PlanBuilding, 0), followedPlan(2, inventory.PlanBuilding, 0),
			followedPlan(3, inventory.PlanRolling, 1)}, "tier", 3},
		{"tier: a plan that ended has no next tier to wait for", "tier", []inventory.Plan{
			followedPlan(1, inventory.PlanBuilding, 0), followedPlan(2, inventory.PlanFailed, 0)}, "done", 2},
		{"done: a new tier is not the end", "done", []inventory.Plan{
			followedPlan(1, inventory.PlanBuilding, 0), followedPlan(2, inventory.PlanRolling, 1),
			followedPlan(3, inventory.PlanDone, 1)}, "done", 3},
		{"done: a plan already ended answers at once", "done", []inventory.Plan{
			followedPlan(4, inventory.PlanSuperseded, 1)}, "done", 1},
		{"the bound passes", "moved", []inventory.Plan{followedPlan(1, inventory.PlanBuilding, 0)}, "bound", -1},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			r := &planReads{plans: c.reads}
			p, came, err := waitOnPlan(context.Background(), r.read, c.until, 50*time.Millisecond, time.Millisecond)
			if err != nil {
				t.Fatal(err)
			}
			if came != c.came {
				t.Fatalf("the wait ended as %q, want %q", came, c.came)
			}
			if c.times > 0 && r.n != c.times {
				t.Errorf("read the plan %d times, want %d: it answered before or after what it waited for", r.n, c.times)
			}
			if want := c.reads[min(r.n, len(c.reads))-1]; p.Revision != want.Revision {
				t.Errorf("answered revision %d, not the plan as it was last read (%d)", p.Revision, want.Revision)
			}
		})
	}
}

// What a wait is asked for is checked before anything is read: what it waits until, and a bound no longer than
// a call is answered within.
func TestAWaitIsRefusedWhatItCannotDo(t *testing.T) {
	for _, bad := range []struct{ until, bound string }{{"landed", ""}, {"", "1h"}, {"", "-3s"}, {"", "soon"}} {
		if _, _, err := planWaitAsked(bad.until, bad.bound); err == nil {
			t.Errorf("until %q, bound %q was taken", bad.until, bad.bound)
		}
	}
	until, bound, err := planWaitAsked("", "")
	if err != nil || until != "moved" || bound != maxPlanWait {
		t.Fatalf("the defaults are %q %s %v, want moved and %s", until, bound, err, maxPlanWait)
	}
	if _, bound, _ := planWaitAsked("tier", "12"); bound != 12*time.Second {
		t.Errorf("a bare number is seconds; read %s", bound)
	}
}

// **The answer is data, with its prose as a field beside it** (novox/hq issue 229): the verb's `answer` carries
// the plan and what ended the wait, and its output is the line a person reads — never JSON inside a string.
func TestAWaitForAPlanAnswersAsData(t *testing.T) {
	p := followedPlan(7, inventory.PlanRolling, 1)
	st := planStatuses([]inventory.Plan{p}, time.Now(), tierBounds{})[0]
	doc := planWaitedDoc(p, st, "tier", "tier", 3*time.Second, "rolling, tier 2 of 2")
	stdout, _ := json.Marshal(doc)
	a := answerOf([]string{"plans", "wait", "plan-1"}, stdout, "", true)
	data, ok := a.Answer.(map[string]any)
	if !ok {
		t.Fatalf("the answer is not data: %v", a.Answer)
	}
	if data["came"] != "tier" || data["revision"] != float64(7) {
		t.Errorf("the data does not say what ended the wait: %v", data)
	}
	if plan, _ := data["plan"].(map[string]any); plan["state"] != "rolling" || plan["tier"] != float64(1) {
		t.Errorf("the data does not carry the plan: %v", data["plan"])
	}
	if _, text := data["text"]; text {
		t.Errorf("the prose is in the data too: %v", data)
	}
	if strings.Contains(a.Output, "{") || !strings.Contains(a.Output, "plan-1") || !strings.Contains(a.Output, "tier") {
		t.Errorf("the output is not the line a person reads: %q", a.Output)
	}
}

// The verb composes the wait, and asks for a window as long as its bound.
func TestThePlansVerbComposesAWait(t *testing.T) {
	argv, err := argvFor("plans", map[string]any{"wait": "plan-1", "until": "done", "bound": "15s"})
	if err != nil {
		t.Fatal(err)
	}
	if got := strings.Join(argv, " "); got != "plans wait plan-1 --until done --bound 15s" {
		t.Fatalf("composed %q", got)
	}
	if _, err := argvFor("plans", map[string]any{"until": "done"}); err == nil {
		t.Error("until without wait was taken")
	}
	if _, err := argvFor("plans", map[string]any{"wait": "plan-1", "bound": "1h"}); err == nil {
		t.Error("a bound past what a call can wait was taken")
	}
}

// Live, with the store: `plans wait` run as the verb runs it answers when the plan reaches its next tier, as
// data, and says the bound passed when nothing moved (novox/hq issue 229).

// The verb's schema says the longest bound in words, and the words are the value (review 75 on #266): the
// catalogue cannot read maxPlanWait, so this holds them together.
func TestThePlansSchemaSaysTheLongestBoundThereIs(t *testing.T) {
	v, ok := controllerVerb("plans")
	if !ok {
		t.Fatal("no plans verb")
	}
	props, _ := v.Input["properties"].(map[string]any)
	bound, _ := props["bound"].(map[string]any)
	said, _ := bound["description"].(string)
	if !strings.Contains(said, maxPlanWait.String()+", the default, is the longest") {
		t.Fatalf("the schema says %q; the longest bound is %s", said, maxPlanWait)
	}
}