jschoubben
20d5af9b2d
A newer sequence carrying an older view of the assignments undeclared four assigned modules on 2026-10-04; the sequence cannot tell it, the generation can. The engine keeps the highest generation it applied, refuses an older one before reading the machine unless the declaration is a gate's put-back, and says the refusal in its report so the controller can name the sender. A declaration without a generation is applied as before, and every report says it reads one, so the controller sends it only to engines that do.
60 lines
2.4 KiB
Go
60 lines
2.4 KiB
Go
package declaration
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// A declaration says where it stands — the controller's lease epoch and its sequence — inside what is
|
|
// signed (novox/hq to-be 45 §6). Absent is no claim; below zero is no order the mesh assigns.
|
|
|
|
func withOrder(order string) string {
|
|
return `{"declaration":1,` + order + `"resources":[{"id":"etc","type":"directory","path":"/etc/mesh","mode":"0755"}]}`
|
|
}
|
|
|
|
func TestADeclarationCarriesItsEpochAndSequence(t *testing.T) {
|
|
d, err := Parse([]byte(withOrder(`"epoch":57,"sequence":3,`)))
|
|
if err != nil {
|
|
t.Fatalf("a declaration carrying its order was refused: %v", err)
|
|
}
|
|
if d.Epoch != 57 || d.Sequence != 3 {
|
|
t.Fatalf("read epoch %d, sequence %d", d.Epoch, d.Sequence)
|
|
}
|
|
// An older controller's: no order, and no claim.
|
|
d, err = Parse([]byte(withOrder(``)))
|
|
if err != nil || d.Epoch != 0 || d.Sequence != 0 {
|
|
t.Fatalf("a declaration with no order read as %+v, %v", d, err)
|
|
}
|
|
}
|
|
|
|
func TestAnOrderBelowZeroIsRefused(t *testing.T) {
|
|
for _, order := range []string{`"epoch":-1,`, `"sequence":-4,`} {
|
|
refusal := refusalFor(t, withOrder(order))
|
|
if !strings.Contains(refusal.Error(), "below zero") {
|
|
t.Errorf("%s: refused for something else: %v", order, refusal)
|
|
}
|
|
}
|
|
}
|
|
|
|
// **The assignment generation it was composed from, and whether it is a put-back** (novox/hq issue 234):
|
|
// absent is no claim; below zero is none the mesh assigns; a carried bundle puts nothing back.
|
|
func TestADeclarationCarriesItsGenerationAndWhetherItIsAPutBack(t *testing.T) {
|
|
d, err := Parse([]byte(withOrder(`"sequence":3,"generation":41,"put_back":true,`)))
|
|
if err != nil {
|
|
t.Fatalf("a declaration carrying its generation was refused: %v", err)
|
|
}
|
|
if d.Generation != 41 || !d.PutBack {
|
|
t.Fatalf("read generation %d, put-back %v", d.Generation, d.PutBack)
|
|
}
|
|
if d, err = Parse([]byte(withOrder(``))); err != nil || d.Generation != 0 || d.PutBack {
|
|
t.Fatalf("a declaration with no generation read as %+v, %v", d, err)
|
|
}
|
|
if refusal := refusalFor(t, withOrder(`"generation":-2,`)); !strings.Contains(refusal.Error(), "below zero") {
|
|
t.Errorf("a generation below zero was refused for something else: %v", refusal)
|
|
}
|
|
if _, err := ParseTrusted([]byte(withOrder(`"generation":3,"put_back":true,`))); err == nil ||
|
|
!strings.Contains(err.Error(), "put-back") {
|
|
t.Errorf("a carried bundle said it was a put-back and was not refused for it: %v", err)
|
|
}
|
|
}
|