jschoubben
9859923664
Every method of builds, build requests, rollouts, merges and assignments reads and writes the chain alone: the else branches that read the tables, the movers and MoveChain with their tests, chain_moved reads, ChainReads and the flags that switched a kind, the store's assignments mirror (KeepAssignmentPlans needs none of it: it uses only the AssignmentMirrored type, mirrors.go, and AssignmentValues, provisioning.go) and its tick, the move code of the controller's start, and ForTest's chain_moved row. The listed store tests of the move go with their functions; the tests of the readers, requests, assignments and plans that lived beside them stay in chain_store_test.go. Tests that replayed old data migrations over the build, assignment and pin tables are removed with the tables. The static test that no plan is written but through SavePlansMoving now reads the plan's chain path.
73 lines
3.4 KiB
Go
73 lines
3.4 KiB
Go
package inventory
|
|
|
|
import (
|
|
"encoding/json"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-controller/internal/chain"
|
|
)
|
|
|
|
// **An assignment's key is `<node>.<module>`, as the bucket has always had it** (ADR 0408 §3): its readers parse nothing
|
|
// but it.
|
|
func TestAnAssignmentsKeyIsTheNodeAndTheModule(t *testing.T) {
|
|
if got := assignmentKey("anchor", "notes"); got != "anchor.notes" {
|
|
t.Fatalf("the key is %q", got)
|
|
}
|
|
if got := assignmentKey("g14.example", "dunst"); got != "g14.example.dunst" {
|
|
t.Fatalf("the key of a machine whose name holds a dot is %q", got)
|
|
}
|
|
}
|
|
|
|
// **A plan that is absent and a null one are one** (the provisioner's plan in an assignment's value): the pass that keeps
|
|
// the plans writes only where they differ.
|
|
func TestAnAbsentPlanAndANullOneAreTheSame(t *testing.T) {
|
|
for name, tc := range map[string]struct {
|
|
a, b json.RawMessage
|
|
same bool
|
|
}{
|
|
"both absent": {nil, nil, true},
|
|
"null and absent": {json.RawMessage(`null`), nil, true},
|
|
"the same plan": {json.RawMessage(`{"files":[]}`), json.RawMessage(` {"files":[]} `), true},
|
|
"another plan": {json.RawMessage(`{"files":[]}`), json.RawMessage(`{"files":[1]}`), false},
|
|
"a plan and none": {json.RawMessage(`{"files":[]}`), nil, false},
|
|
"none and a plan": {nil, json.RawMessage(`{"files":[]}`), false},
|
|
} {
|
|
if got := sameJSON(tc.a, tc.b); got != tc.same {
|
|
t.Errorf("%s: %v", name, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
// **A pass that keeps the plans never brings back an assignment that ended** (issue 1093): it reads what it wants and what
|
|
// the bucket holds in two reads, and an unassignment between them leaves a key that ended while the pass still wants it
|
|
// assigned.
|
|
func TestAPassThatKeepsThePlansNeverRevivesAnEndedAssignment(t *testing.T) {
|
|
at := time.Date(2026, 10, 18, 3, 0, 0, 0, time.UTC)
|
|
plan := json.RawMessage(`{"files":[]}`)
|
|
assigned := chain.Assignment{Node: "a", Module: "m", Assigned: at, Provisioning: plan}
|
|
ended := chain.Assignment{Node: "a", Module: "m", Assigned: at, Ended: at.Add(time.Minute)}
|
|
pulledIn := chain.Assignment{Node: "a", Module: "p", RequiredBy: "m", Provisioning: plan}
|
|
pulledInEnded := chain.Assignment{Node: "a", Module: "p", Ended: at}
|
|
waiting := chain.Assignment{Node: "a", Module: "p", State: chain.StatePending,
|
|
Pending: &chain.Pending{ID: "p-1", State: chain.PendingWaiting}}
|
|
for name, tc := range map[string]struct {
|
|
has bool
|
|
cur, next chain.Assignment
|
|
want string
|
|
}{
|
|
"the interleaving: wanted assigned, ended since": {true, ended, assigned, keepSkip},
|
|
"wanted assigned, not in the bucket yet": {false, chain.Assignment{}, assigned, keepSkip},
|
|
"a pulled-in module, not in the bucket": {false, chain.Assignment{}, pulledIn, keepCreate},
|
|
"a pulled-in module that ended, pulled again": {true, pulledInEnded, pulledIn, keepFresh},
|
|
"an assignment ended, a plan for it": {true, ended, chain.Assignment{Node: "a", Module: "m", RequiredBy: "x", Provisioning: plan}, keepSkip},
|
|
"a wait for a build, a plan for the module pulled in": {true, waiting, pulledIn, keepSkip},
|
|
"the plan is the same": {true, assigned, assigned, keepSkip},
|
|
"the plan changed": {true, chain.Assignment{Node: "a", Module: "m", Assigned: at}, assigned, keepField},
|
|
} {
|
|
if got := keepStep(tc.has, tc.cur, tc.next); got != tc.want {
|
|
t.Errorf("%s: %s, want %s", name, got, tc.want)
|
|
}
|
|
}
|
|
}
|