jschoubben
c3b88b9148
One name per thing, per the HQ glossary: the module/container/image/binary/repo becomes mesh-controller, the seat the-controller, and the store+broker pair the foundation (embedded base bundles, default template and example lock renamed with their go:embed directives). No behaviour change — a pure vocabulary rename. Claude-Session: https://claude.ai/code/session_01D6qtiYU3P9jk3pnAXyAFyx
75 lines
2.9 KiB
Go
75 lines
2.9 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// One machine that cannot be worked out is not a reason to leave the mesh unconverged.
|
|
//
|
|
// A whole-mesh push refused outright the moment any single node failed to resolve, so a module on
|
|
// the anchor requiring a provision nobody had assigned a provider for stopped every OTHER machine
|
|
// from being sent anything — machines with no relation to the fault, and nothing wrong with them.
|
|
// The failure and the punishment were on different machines.
|
|
//
|
|
// It is the same rule an un-hostable module already follows one level down (a92c11b: one module on
|
|
// the wrong machine no longer refuses the whole node), applied one level up.
|
|
func TestOneUnresolvableNodeStillLetsTheRestBeSent(t *testing.T) {
|
|
sending, refusals := composeEach(
|
|
[]string{"anchor", "home-server", "laptop"},
|
|
func(node string) ([]map[string]any, error) {
|
|
if node == "anchor" {
|
|
return nil, errors.New(`nothing provides "acme-ca", wanted by route-proxy`)
|
|
}
|
|
return []map[string]any{{"id": node + ".thing"}}, nil
|
|
})
|
|
|
|
var told []string
|
|
for _, s := range sending {
|
|
told = append(told, s.node)
|
|
}
|
|
if strings.Join(told, ",") != "home-server,laptop" {
|
|
t.Errorf("a machine with nothing wrong with it was not sent: %v", told)
|
|
}
|
|
if len(refusals) != 1 || !strings.Contains(refusals[0], "anchor") ||
|
|
!strings.Contains(refusals[0], "acme-ca") {
|
|
t.Errorf("the machine that could not be worked out was not named with its reason: %v",
|
|
refusals)
|
|
}
|
|
}
|
|
|
|
// And a machine assigned nothing is neither sent nor a refusal — it is nothing to say.
|
|
func TestAMachineAssignedNothingIsNotARefusal(t *testing.T) {
|
|
sending, refusals := composeEach([]string{"spare"},
|
|
func(string) ([]map[string]any, error) { return nil, nil })
|
|
if len(sending) != 0 || len(refusals) != 0 {
|
|
t.Errorf("a machine assigned nothing was treated as something: %v / %v", sending, refusals)
|
|
}
|
|
}
|
|
|
|
// A push that skipped a machine still ends badly, and says what was sent.
|
|
//
|
|
// **Skipping is not succeeding.** The mesh is not in the state somebody asked for, so the command
|
|
// exits non-zero — but it says how many machines it did reach, because the old message ("nothing
|
|
// was sent") was the very claim that had become untrue.
|
|
func TestASkippedMachineIsStillAnError(t *testing.T) {
|
|
if err := couldNotBeResolved(nil, 3); err != nil {
|
|
t.Fatalf("a push that resolved every machine reported a problem: %v", err)
|
|
}
|
|
|
|
err := couldNotBeResolved([]string{"anchor:\nnothing provides \"acme-ca\""}, 2)
|
|
if err == nil {
|
|
t.Fatal("a push that could not work out a machine reported success")
|
|
}
|
|
said := err.Error()
|
|
if strings.Contains(said, "nothing was sent") {
|
|
t.Errorf("the push says nothing was sent, and it sent two machines: %q", said)
|
|
}
|
|
for _, want := range []string{"anchor", "acme-ca", "2 other node(s) were"} {
|
|
if !strings.Contains(said, want) {
|
|
t.Errorf("the refusal does not say %q: %q", want, said)
|
|
}
|
|
}
|
|
}
|