mesh-delivery/modules/mesh-delivery-assigner/internal/assign/wants_test.go

package assign

import (
	"slices"
	"strings"
	"testing"
	"time"

	"git.novox.be/novox/mesh-sdk/go/catalogue"
	"git.novox.be/novox/mesh-sdk/go/delivery"
)

func fpOf(c byte) string { return delivery.SourcePrefix2 + strings.Repeat(string(c), 64) }

var (
	fNew = fpOf('b')
	fOld = fpOf('a')
)

// ready is a module mail at fNew on ace and g14 for which every rule holds: built, not held, granted, its provider
// store healthy on ace and the canary ace running fNew healthy.
func ready() (Module, Nodes) {
	m := Module{Name: "mail", FP: fNew, Built: true, Granted: true, Composed: composedEverywhere, Nodes: []string{"g14", "ace"},
		Manifest: catalogue.Manifest{Module: "mail", Requires: []string{"database"}}}
	n := Nodes{
		Online: map[string]bool{"ace": true, "g14": true},
		Haves: map[string]map[string]delivery.Have{
			"ace": {"mail": {FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}, "store": {FP: fpOf('s'), Phase: delivery.PhaseRunning, Health: delivery.HealthOK}},
			"g14": {"mail": {FP: fOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}},
		},
		Providers: map[string]map[string][]string{"database": {"store": {"ace"}}},
	}
	return m, n
}

// dig is the digest of the composition at a fingerprint in these tests: the fingerprint's last character repeated.
func dig(fp string) string { return "sha256:" + strings.Repeat(fp[len(fp)-1:], 64) }

// composedEverywhere is a Module.Composed with a composition for every node at every fingerprint, judged neither.
func composedEverywhere(_, fp string) (delivery.ComposedDigest, bool) {
	return delivery.ComposedDigest{Digest: dig(fp), Judgement: delivery.JudgedNeither}, true
}

func wantedOld() map[string]delivery.Want {
	return map[string]delivery.Want{"ace": {FP: fOld, Composed: dig(fOld)}, "g14": {FP: fOld, Composed: dig(fOld)}}
}

// 1297/B4: with every rule holding, both nodes' wants move to the new fingerprint (the canary ace runs it healthy, so
// g14 follows at once: step 0, ADR 0528 clause 3).
func TestEveryRuleHoldsSoTheWantsMove(t *testing.T) {
	m, n := ready()
	out := Wants(m, n, wantedOld(), nil)
	for _, node := range []string{"ace", "g14"} {
		if out.Wants[node].FP != fNew || out.Wants[node].Rule != 0 || out.Wants[node].Composed != dig(fNew) {
			t.Errorf("%s's want = %+v, want %s", node, out.Wants[node], fNew)
		}
	}
}

// 1297/B4, one test per rule: given every rule but N holds, no want moves to F, and the rule N is named.
func TestEachRuleHoldsTheWantBack(t *testing.T) {
	for rule, breakIt := range map[int]func(*Module, *Nodes){
		delivery.RuleBuildDone: func(m *Module, _ *Nodes) { m.Built = false },
		delivery.RuleNotHeld:   func(m *Module, _ *Nodes) { m.Held = true },
		delivery.RuleCanary: func(_ *Module, n *Nodes) {
			n.Haves["ace"]["mail"] = delivery.Have{FP: fOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
		},
		delivery.RuleProviders: func(_ *Module, n *Nodes) {
			n.Haves["ace"]["store"] = delivery.Have{FP: fpOf('s'), Phase: delivery.PhaseRunning, Health: delivery.HealthWaits}
		},
		delivery.RuleGrant: func(m *Module, _ *Nodes) { m.Granted = false },
		delivery.RuleComposed: func(m *Module, _ *Nodes) {
			m.Composed = func(string, string) (delivery.ComposedDigest, bool) { return delivery.ComposedDigest{}, false }
		},
	} {
		m, n := ready()
		breakIt(&m, &n)
		out := Wants(m, n, wantedOld(), nil)
		if w, ok := out.Wants["g14"]; ok && w.FP == fNew {
			t.Errorf("rule %d broken: g14's want moved to F", rule)
		}
		if got := out.Rules["g14"].Rule; got != rule {
			t.Errorf("rule %d broken: g14 is held back by rule %d (%s)", rule, got, out.Rules["g14"].Words)
		}
		if w := out.Wants["g14"]; w.FP != "" && (w.FP != fOld || w.Newest != fNew || w.Rule != rule) {
			t.Errorf("rule %d broken: g14's want is %+v", rule, w)
		}
	}
}

// 1297/B4, ADR 0435 §3: a canary that is offline is passed over: the next node by name is the canary, and moves first.
func TestAnOfflineCanaryIsPassedOver(t *testing.T) {
	m, n := ready()
	n.Online["ace"] = false
	n.Haves["ace"]["mail"] = delivery.Have{FP: fOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
	n.Providers["database"]["store"] = []string{"ace", "g14"}
	n.Haves["g14"]["store"] = delivery.Have{FP: fpOf('s'), Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
	if c := Canary(m.Nodes, n.Online); c != "g14" {
		t.Fatalf("canary = %q, want g14", c)
	}
	out := Wants(m, n, wantedOld(), nil)
	if out.Wants["g14"].FP != fNew {
		t.Errorf("the canary g14's want = %+v", out.Wants["g14"])
	}
	if out.Rules["ace"].Rule != delivery.RuleCanary {
		t.Errorf("ace, behind the canary g14, is held back by %+v", out.Rules["ace"])
	}
}

// 1297/B4: a failed health check of F holds F and sets the nodes that want it back to their last healthy fingerprint.
func TestAFailedHealthHoldsAndSetsBack(t *testing.T) {
	m, n := ready()
	n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthFailed, Detail: "connection refused"}
	m.Now = time.Date(2026, 10, 25, 1, 0, 0, 0, time.UTC)
	out := Wants(m, n, map[string]delivery.Want{"ace": {FP: fNew, Composed: dig(fNew)}, "g14": {FP: fOld, Composed: dig(fOld)}}, map[string]string{"ace": fOld})
	// 1906/H3: the held record keeps its cause in words: which machine (its node), which health, when, and the node's words.
	if out.Held == nil || out.Held.Node != "ace" || out.Held.Words != "health failed, phase running, seen at 2026-10-25T01:00:00Z: connection refused" {
		t.Fatalf("held = %+v", out.Held)
	}
	if w := out.Wants["ace"]; w.FP != fOld || w.Composed != dig(fOld) || w.Newest != fNew || w.Rule != delivery.RuleNotHeld {
		t.Errorf("ace's want = %+v, want set back to the last healthy fingerprint", w)
	}
	if w, ok := out.Wants["g14"]; ok && w.FP == fNew {
		t.Errorf("g14 moved to a held fingerprint: %+v", w)
	}
}

// 1297/B4: a module holding data is not set back; its want stays and says why.
func TestADataModuleIsNotSetBack(t *testing.T) {
	m, n := ready()
	m.Manifest.Data = &catalogue.Data{Own: []catalogue.DataItem{{ID: "mail", Class: catalogue.ClassIrreplaceable}}}
	n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthFailed}
	out := Wants(m, n, map[string]delivery.Want{"ace": {FP: fNew}}, map[string]string{"ace": fOld})
	if out.Held == nil {
		t.Fatal("F was not held")
	}
	if w := out.Wants["ace"]; w.FP != fNew || !strings.Contains(w.Words, "holds data") {
		t.Errorf("ace's want = %+v, want it left at F, saying it holds data", w)
	}
	// 1906/D3: and the node is to be asked whether to restore it
	if !slices.Equal(out.Restore, []string{"ace"}) {
		t.Errorf("restore asks = %v, want ace", out.Restore)
	}
}

// 1906/D3: a module without data is set back and asked about nothing.
func TestAModuleWithoutDataIsNotAskedToRestore(t *testing.T) {
	m, n := ready()
	n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthFailed}
	out := Wants(m, n, map[string]delivery.Want{"ace": {FP: fNew}}, map[string]string{"ace": fOld})
	if len(out.Restore) != 0 {
		t.Errorf("restore asks = %v", out.Restore)
	}
}

// 1297/B4, ADR 0408 §4: a node that leaves the module's nodes gets its want written removed, never deleted; a want that
// is already as the rules give it is not written again.
func TestALeavingNodeIsRemovedAndNothingIsWrittenTwice(t *testing.T) {
	m, n := ready()
	m.Nodes = []string{"ace"}
	out := Wants(m, n, map[string]delivery.Want{"ace": {V: 1, FP: fNew, Composed: dig(fNew)}, "g14": {FP: fOld, Composed: dig(fOld)}}, nil)
	if w := out.Wants["g14"]; !w.Removed {
		t.Errorf("g14's want = %+v, want removed", w)
	}
	if _, ok := out.Wants["ace"]; ok {
		t.Errorf("ace's want, unchanged, was written again: %+v", out.Wants["ace"])
	}
}

// 1906/D2 (ADR 0539 §6): the seventh rule. A want waits for the composition of the module for that node at F, and names its
// digest once it exists; a node with no want before still gets none until then.
func TestAWantWaitsForItsCompositionAndNamesItsDigest(t *testing.T) {
	m, n := ready()
	have := map[string]bool{}
	m.Composed = func(node, fp string) (delivery.ComposedDigest, bool) {
		if !have[node+"|"+fp] {
			return delivery.ComposedDigest{}, false
		}
		return composedEverywhere(node, fp)
	}
	out := Wants(m, n, wantedOld(), nil)
	for node, w := range out.Wants {
		if w.FP == fNew {
			t.Errorf("%s's want moved to F before its composition exists: %+v", node, w)
		}
	}
	if r := out.Rules["ace"]; r.Rule != delivery.RuleComposed || !strings.Contains(r.Words, "ace") {
		t.Errorf("ace is held back by %+v, want rule 7 naming the node", r)
	}
	// and a node that never had a want gets none
	if out := Wants(m, n, nil, nil); len(out.Wants) != 0 {
		t.Errorf("wants without a composition: %+v", out.Wants)
	}
	have["ace|"+fNew] = true
	out = Wants(m, n, wantedOld(), nil)
	if w := out.Wants["ace"]; w.FP != fNew || w.Composed != dig(fNew) {
		t.Errorf("ace's want = %+v, want F naming the composition's digest", w)
	}
	if w, ok := out.Wants["g14"]; ok && w.FP == fNew {
		t.Errorf("g14, whose composition does not exist, moved: %+v", w)
	}
}

// 1906/D2 (ADR 0539 §5): a new revision of the composition at the same fingerprint reaches the node only through a new want,
// by the same rules: written when they hold, and not while one does not.
func TestARevisionAtTheSameFingerprintIsAWantByTheSameRules(t *testing.T) {
	m, n := ready()
	revised := "sha256:" + strings.Repeat("9", 64)
	m.Composed = func(node, fp string) (delivery.ComposedDigest, bool) {
		return delivery.ComposedDigest{Digest: revised, Judgement: delivery.JudgedNeither}, true
	}
	running := map[string]delivery.Want{"ace": {FP: fNew, Composed: dig(fNew)}, "g14": {FP: fNew, Composed: dig(fNew)}}
	out := Wants(m, n, running, nil)
	for _, node := range []string{"ace", "g14"} {
		if w := out.Wants[node]; w.FP != fNew || w.Composed != revised {
			t.Errorf("%s's want = %+v, want F naming the revised digest", node, w)
		}
	}
	m.Granted = false
	out = Wants(m, n, running, nil)
	if w, ok := out.Wants["ace"]; ok && w.Composed == revised {
		t.Errorf("a revision was written while a rule holds: %+v", w)
	}
}

// 1906/D2: a set-back names the composition of the fingerprint it sets back to, and when that is gone the want stays and says so.
func TestASetBackNamesTheOlderCompositionOrStays(t *testing.T) {
	m, n := ready()
	n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthFailed, Detail: "x"}
	running := map[string]delivery.Want{"ace": {FP: fNew, Composed: dig(fNew)}}
	m.Composed = func(node, fp string) (delivery.ComposedDigest, bool) {
		if fp == fOld {
			return delivery.ComposedDigest{}, false
		}
		return composedEverywhere(node, fp)
	}
	out := Wants(m, n, running, map[string]string{"ace": fOld})
	if w := out.Wants["ace"]; w.FP == fOld {
		t.Errorf("set back to a fingerprint whose composition is gone: %+v", w)
	}
	m.Composed = composedEverywhere
	out = Wants(m, n, running, map[string]string{"ace": fOld})
	if w := out.Wants["ace"]; w.FP != fOld || w.Composed != dig(fOld) {
		t.Errorf("set-back want = %+v", w)
	}
}

// movingTo is a module ready to move, whose composition at F is judged j against the one it runs, and whose digest is dig(F).
func movingTo(j delivery.Judgement) (Module, Nodes, map[string]delivery.Want) {
	m, n := ready()
	m.Composed = func(node, fp string) (delivery.ComposedDigest, bool) {
		d := delivery.ComposedDigest{Digest: dig(fp), Judgement: j}
		if j != delivery.JudgedNeither {
			d.Against, d.Words = dig(fOld), "judged"
		}
		return d, true
	}
	return m, n, wantedOld()
}

func recording(m *Module) {
	m.Manifest.Upgrade = &catalogue.UpgradePolicy{Policy: catalogue.PolicyRecord, Why: "a person takes each build"}
}

// 1906/D4 (ADR 0539 §14): a module of policy record whose move is judged to recreate a container, to move data, or cannot be
// judged, is not written until its ask is answered yes; the same at a new revision of the same fingerprint.
func TestARecordModuleWaitsForItsAskWhenTheMoveIsNotJudgedNeither(t *testing.T) {
	for _, j := range []delivery.Judgement{delivery.JudgedRecreates, delivery.JudgedMovesData, delivery.JudgedCannot} {
		m, n, wanted := movingTo(j)
		recording(&m)
		out := Wants(m, n, wanted, nil)
		if w, ok := out.Wants["ace"]; ok {
			t.Errorf("%s: ace's want was written without the ask's yes: %+v", j, w)
		}
		var ace *RecordNeed
		for i := range out.Record {
			if out.Record[i].Node == "ace" {
				ace = &out.Record[i]
			}
		}
		if ace == nil || ace.Digest != dig(fNew) || ace.Judgement != j {
			t.Errorf("%s: the asks = %+v, want one for ace naming the digest and the judgement", j, out.Record)
		}
		// a new revision at the same fingerprint is asked too
		same := map[string]delivery.Want{"ace": {FP: fNew, Composed: dig(fOld)}}
		if out := Wants(m, n, same, nil); len(out.Record) == 0 || len(out.Wants) != 0 && out.Wants["ace"].Composed == dig(fNew) {
			t.Errorf("%s: a new revision at the same fingerprint: %+v", j, out)
		}
		m.Allowed = func(node, digest string) bool { return node == "ace" && digest == dig(fNew) }
		out = Wants(m, n, wanted, nil)
		if w := out.Wants["ace"]; w.FP != fNew || w.Composed != dig(fNew) {
			t.Errorf("%s: after the yes ace's want = %+v", j, w)
		}
	}
}

// 1906/D4: a move judged neither is written at once, whatever the policy; so is a module the node never ran; and a module
// that rolls (not record) is never asked.
func TestAMoveJudgedNeitherOrNeverRunOrNotRecordedIsWrittenAtOnce(t *testing.T) {
	m, n, wanted := movingTo(delivery.JudgedNeither)
	recording(&m)
	if out := Wants(m, n, wanted, nil); out.Wants["ace"].FP != fNew || len(out.Record) != 0 {
		t.Errorf("neither: %+v", out)
	}
	m, n, _ = movingTo(delivery.JudgedRecreates)
	recording(&m)
	delete(n.Haves["ace"], "mail")
	if out := Wants(m, n, nil, nil); out.Wants["ace"].FP != fNew || len(out.Record) != 0 {
		t.Errorf("a node that never ran it: %+v", out)
	}
	// but one that runs an older fingerprint with no want yet is asked like any other (one running F is not: N1 below)
	m, n, _ = movingTo(delivery.JudgedCannot)
	recording(&m)
	n.Haves["ace"]["mail"] = delivery.Have{FP: fOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
	if out := Wants(m, n, nil, nil); out.Wants["ace"].FP == fNew || len(out.Record) == 0 {
		t.Errorf("a node that runs it with no want: %+v", out)
	}
	m, n, wanted = movingTo(delivery.JudgedRecreates)
	if out := Wants(m, n, wanted, nil); out.Wants["ace"].FP != fNew || len(out.Record) != 0 {
		t.Errorf("a rolled module: %+v", out)
	}
}

// 1906/D4 (ADR 0539 §7, §15): the bus module's new fingerprint is never written by the assigner, but a revision of its
// composition at the same fingerprint that only changes the user list (judged neither) is written at once.
func TestTheBusIsNotMovedButItsUserListRevisionIsWrittenAtOnce(t *testing.T) {
	m, n, _ := movingTo(delivery.JudgedNeither)
	m.Manifest.Provides = []catalogue.Offer{{Name: "mesh-bus"}}
	if out := Wants(m, n, wantedOld(), nil); out.Wants["ace"].FP == fNew {
		t.Errorf("the bus moved to a new fingerprint: %+v", out.Wants["ace"])
	}
	running := map[string]delivery.Want{"ace": {FP: fNew, Composed: dig(fOld)}, "g14": {FP: fNew, Composed: dig(fOld)}}
	out := Wants(m, n, running, nil)
	if w := out.Wants["ace"]; w.FP != fNew || w.Composed != dig(fNew) {
		t.Errorf("a user-list revision of the bus: ace's want = %+v", w)
	}
	if len(out.Record) != 0 {
		t.Errorf("a user-list revision was asked: %+v", out.Record)
	}
}

// 1906/D4 (ADR 0539 §16): the answer to a failed backup stays in the want while its target stays.
func TestTheBackupAnswerStaysInTheWantWhileItsTargetStays(t *testing.T) {
	m, n := ready()
	running := map[string]delivery.Want{"ace": {FP: fNew, Composed: dig(fNew), Backup: delivery.BackupSkip, Words: BackupAnswerWords("skip", 0)}}
	if w, ok := Wants(m, n, running, nil).Wants["ace"]; ok {
		t.Errorf("the answer was erased: %+v", w)
	}
}

// 1906/D4 (ADR 0539 §19): a hold released by the operator is not held again by a health check that failed before, and the
// wants move by the rules again.
func TestAReleasedHoldIsNotHeldAgain(t *testing.T) {
	m, n := ready()
	n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthFailed, Detail: "x"}
	m.Released = true
	out := Wants(m, n, map[string]delivery.Want{"ace": {FP: fOld, Composed: dig(fOld), Newest: fNew, Rule: delivery.RuleNotHeld}}, map[string]string{"ace": fOld})
	if out.Held != nil {
		t.Errorf("a released fingerprint was held again: %+v", out.Held)
	}
	if w := out.Wants["ace"]; w.FP != fNew || w.Composed != dig(fNew) || w.Rule != 0 {
		t.Errorf("ace's want = %+v, want the held fingerprint written again", w)
	}
}

// 1906/D4: a data module whose restore ask the operator answered "restore" is set back like any other, losing the newer writes;
// answered "leave stopped" (or not answered) it stays.
func TestARestoreAnswerSetsADataModuleBack(t *testing.T) {
	m, n := ready()
	m.Manifest.Data = &catalogue.Data{Own: []catalogue.DataItem{{ID: "mail", Class: catalogue.ClassIrreplaceable}}}
	n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthFailed}
	running := map[string]delivery.Want{"ace": {FP: fNew, Composed: dig(fNew)}}
	m.Restored = func(node string) bool { return false }
	if w, ok := Wants(m, n, running, map[string]string{"ace": fOld}).Wants["ace"]; ok && w.FP == fOld {
		t.Errorf("set back without the operator's restore: %+v", w)
	}
	m.Restored = func(node string) bool { return node == "ace" }
	if w := Wants(m, n, running, map[string]string{"ace": fOld}).Wants["ace"]; w.FP != fOld || w.Composed != dig(fOld) {
		t.Errorf("after restore ace's want = %+v", w)
	}
}

// 1906/D4 (ADR 0539 §14): the policy the controller holds beside the composition decides, the operator's own choice included;
// a composition with none (made by hand) falls back to what the manifest derives.
func TestTheRecordPolicyIsTheOneTheControllerHolds(t *testing.T) {
	m, n, wanted := movingTo(delivery.JudgedMovesData)
	with := func(policy, from string) {
		inner := m.Composed
		m.Composed = func(node, fp string) (delivery.ComposedDigest, bool) {
			d, ok := inner(node, fp)
			d.Policy, d.PolicyFrom = policy, from
			return d, ok
		}
	}
	with(delivery.PolicyRecord, "person") // a roll module the operator set to record
	if out := Wants(m, n, wanted, nil); len(out.Record) == 0 || out.Wants["ace"].FP == fNew {
		t.Errorf("the operator's record policy was not honoured: %+v", out)
	}
	recording(&m) // the manifest says record, the operator chose roll
	with("roll", "person")
	if out := Wants(m, n, wanted, nil); len(out.Record) != 0 || out.Wants["ace"].FP != fNew {
		t.Errorf("the operator's roll policy was not honoured: %+v", out)
	}
	with("", "") // made by hand: the manifest decides
	if out := Wants(m, n, wanted, nil); len(out.Record) == 0 {
		t.Errorf("a hand-made composition fell through the manifest's record policy: %+v", out)
	}
}

// Review round 1, item 2 (ADR 0539 §15): a node that runs the bus with no readable want compares the new fingerprint with the one
// it runs, from its have: the same fingerprint is not a new one (written by the rules), another is barred.
func TestTheBusWithNoWantIsComparedWithWhatItRuns(t *testing.T) {
	m, n, _ := movingTo(delivery.JudgedNeither)
	m.Manifest.Provides = []catalogue.Offer{{Name: "mesh-bus"}}
	n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
	if w, ok := Wants(m, n, nil, nil).Wants["ace"]; !ok || w.FP != fNew {
		t.Errorf("the bus runs F with no want and was not given one: %+v %v", w, ok)
	}
	n.Haves["ace"]["mail"] = delivery.Have{FP: fOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
	if w, ok := Wants(m, n, nil, nil).Wants["ace"]; ok {
		t.Errorf("the bus was moved to a new fingerprint with no want: %+v", w)
	}
}

// Review round 1, item 1 (ADR 0539 §7): a revision of the bus module's composition that differs only in its user list is written
// at once, at the fingerprint the node runs, before the record hold, whatever the controller judges of the file's mount (it
// says recreates) and whatever policy the bus has (record, from the bus). The shape is the controller's: judged recreates against
// the composition the node runs, policy record, UserListOnly set.
func TestAUserListOnlyRevisionOfTheBusIsWrittenAtOnceBeforeTheRecordHold(t *testing.T) {
	m, n, _ := movingTo(delivery.JudgedRecreates)
	m.Manifest.Provides = []catalogue.Offer{{Name: "mesh-bus"}}
	userList := "sha256:" + strings.Repeat("7", 64)
	m.Composed = func(node, fp string) (delivery.ComposedDigest, bool) {
		d := delivery.ComposedDigest{Digest: dig(fp), Judgement: delivery.JudgedRecreates, Against: dig(fOld), Words: "the user list file is mounted",
			Policy: delivery.PolicyRecord, PolicyFrom: "the bus"}
		if fp == fOld {
			d.Digest, d.UserListOnly = userList, true // the composition at the fingerprint the node runs, with the new user list
		}
		return d, true
	}
	n.Haves["ace"]["mail"] = delivery.Have{FP: fOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
	for name, wanted := range map[string]map[string]delivery.Want{
		"a want at the fingerprint it runs": {"ace": {FP: fOld, Composed: dig(fOld)}},
		"no readable want":                  nil,
	} {
		out := Wants(m, n, wanted, nil)
		if w := out.Wants["ace"]; w.FP != fOld || w.Composed != userList {
			t.Errorf("%s: ace's want = %+v, want the running fingerprint naming the user-list revision", name, w)
		}
		if len(out.Record) != 0 {
			t.Errorf("%s: the user-list revision was asked: %+v", name, out.Record)
		}
	}
	// the same flag on a module that is not the bus changes nothing
	m.Manifest.Provides = nil
	if out := Wants(m, n, map[string]delivery.Want{"ace": {FP: fOld, Composed: dig(fOld)}}, nil); out.Wants["ace"].Composed == userList {
		t.Errorf("a module that is not the bus was written at once: %+v", out.Wants["ace"])
	}
}

// Review round 2, N1 (ADR 0539 §9, §11): right after the switch no node has a readable want and every have comes from the old node-engine
// with a fingerprint and no composition, so every move is judged cannot-judge. A node running F with such a have gets its want at F
// with no record hold, for a record module and for the bus alike (the node agent applies nothing when the composition equals the
// declaration it kept); a new fingerprint still waits for its ask.
func TestAHaveFromBeforeTheSwitchGetsItsWantWithNoRecordHold(t *testing.T) {
	for name, bus := range map[string]bool{"a record module": false, "the bus": true} {
		// only a composition the controller judged unchanged (it equals the declaration the node last applied, ADR 0540 §9) skips the hold
		unchanged := func(node, fp string) (delivery.ComposedDigest, bool) {
			return delivery.ComposedDigest{Digest: dig(fp), Judgement: delivery.JudgedUnchanged}, true
		}
		m, n, _ := movingTo(delivery.JudgedCannot)
		recording(&m)
		m.Nodes = []string{"ace"}
		if bus {
			m.Manifest.Provides = []catalogue.Offer{{Name: "mesh-bus"}}
		}
		m.Composed = unchanged
		n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthOK} // no composition named
		out := Wants(m, n, nil, nil)
		if w := out.Wants["ace"]; w.FP != fNew || w.Composed != dig(fNew) {
			t.Errorf("%s: ace's want = %+v, want F naming its composition", name, w)
		}
		if len(out.Record) != 0 {
			t.Errorf("%s: asked at the switch: %+v", name, out.Record)
		}
		// a composition that differs from the declaration the node kept (a changed setting or secret), and one the controller did not judge,
		// still wait for the ask
		for what, j := range map[string]delivery.Judgement{"differing": delivery.JudgedRecreates, "unjudged": delivery.JudgedCannot, "judged neither": delivery.JudgedNeither} {
			m2, n2, _ := movingTo(j)
			recording(&m2)
			m2.Nodes = []string{"ace"}
			if bus {
				m2.Manifest.Provides = []catalogue.Offer{{Name: "mesh-bus"}}
			}
			n2.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
			out := Wants(m2, n2, nil, nil)
			if j == delivery.JudgedNeither {
				if out.Wants["ace"].FP != fNew || len(out.Record) != 0 {
					t.Errorf("%s, %s: %+v", name, what, out)
				}
				continue
			}
			if w, ok := out.Wants["ace"]; ok || len(out.Record) == 0 {
				t.Errorf("%s, %s: written at the switch with no yes: %+v %+v", name, what, w, out.Record)
			}
		}
		// a have that names a composition is judged as before
		m.Composed = func(node, fp string) (delivery.ComposedDigest, bool) {
			return delivery.ComposedDigest{Digest: dig(fp), Judgement: delivery.JudgedRecreates, Against: dig(fOld), Words: "judged"}, true
		}
		n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Composed: dig(fOld), Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
		if out := Wants(m, n, nil, nil); out.Wants["ace"].FP == fNew && len(out.Record) == 0 {
			t.Errorf("%s: a have naming a composition skipped the hold: %+v", name, out)
		}
		// a new fingerprint still asks (the bus is barred instead)
		n.Haves["ace"]["mail"] = delivery.Have{FP: fOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
		out = Wants(m, n, nil, nil)
		if w, ok := out.Wants["ace"]; ok {
			t.Errorf("%s: a new fingerprint was written with no yes: %+v", name, w)
		}
		if !bus && len(out.Record) == 0 {
			t.Errorf("%s: a new fingerprint was not asked", name)
		}
	}
}

// 1906/H3: a failed check whose node gave no words is held saying so, never with empty words.
func TestAHoldOfAFailureWithoutWordsSaysSo(t *testing.T) {
	m, n := ready()
	n.Haves["ace"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthFailed}
	out := Wants(m, n, map[string]delivery.Want{"ace": {FP: fNew, Composed: dig(fNew)}}, map[string]string{"ace": fOld})
	if out.Held == nil || out.Held.Words != "health failed, phase running: the node gave no words" {
		t.Fatalf("held = %+v", out.Held)
	}
}

// 1906/H2: given a held fingerprint that every node running the module now runs healthy, when the assigner passes, then the
// hold is lifted by itself and the wants move to it by the rules again. A node set back to another fingerprint, a node whose
// check fails, or a hold the operator answered "keep" leaves it held; a node that does not run the module at all does not count.
func TestAHoldIsLiftedOnceEveryNodeRunsItHealthy(t *testing.T) {
	everywhere := func() (Module, Nodes) {
		m, n := ready()
		m.Held = true
		n.Haves["g14"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
		return m, n
	}
	m, n := everywhere()
	out := Wants(m, n, wantedOld(), map[string]string{"ace": fOld, "g14": fOld})
	if !out.Lifted || out.Held != nil {
		t.Fatalf("lifted = %v, held = %+v: want the hold lifted", out.Lifted, out.Held)
	}
	for _, node := range []string{"ace", "g14"} {
		if w := out.Wants[node]; w.FP != fNew || w.Rule != 0 {
			t.Errorf("%s's want = %+v, want it moved to the lifted fingerprint", node, w)
		}
	}

	m, n = everywhere()
	delete(n.Haves["g14"], "mail")
	if out := Wants(m, n, wantedOld(), nil); !out.Lifted {
		t.Error("a node that does not run the module kept the hold")
	}

	for name, change := range map[string]func(*Module, *Nodes){
		"set back": func(_ *Module, n *Nodes) {
			n.Haves["g14"]["mail"] = delivery.Have{FP: fOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
		},
		"failing": func(_ *Module, n *Nodes) {
			n.Haves["g14"]["mail"] = delivery.Have{FP: fNew, Phase: delivery.PhaseRunning, Health: delivery.HealthFailed}
		},
		"kept":     func(m *Module, _ *Nodes) { m.Kept = true },
		"no haves": func(_ *Module, n *Nodes) { delete(n.Haves["g14"], "mail"); delete(n.Haves["ace"], "mail") },
		"not held": func(m *Module, _ *Nodes) { m.Held = false },
	} {
		m, n := everywhere()
		change(&m, &n)
		if out := Wants(m, n, wantedOld(), map[string]string{"ace": fOld, "g14": fOld}); out.Lifted {
			t.Errorf("%s: the hold was lifted", name)
		}
	}
}