jschoubben
bb8b3bb43b
announce.States on the module's own event subject mesh.mod.<m>.event.states, kept by the controller in mesh-controller_states-announced by module.
72 lines
2.6 KiB
Go
72 lines
2.6 KiB
Go
package announce
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// A module says on the bus which states it keeps and which of them others may read (novox/hq ADR 0495 clause 2), on its
|
|
// own event subject, in a versioned value the controller keeps by module.
|
|
func TestAnAnnouncementRoundTripsSortedAndSaysWhatIsReadable(t *testing.T) {
|
|
data, err := Encode(States{Module: "mesh-controller", Node: "novox", States: []State{
|
|
{Name: "plans-building", Readable: true}, {Name: "assignments", Readable: true}, {Name: "own"}}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
back, err := Decode(data)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if back.V != Version || back.Module != "mesh-controller" || back.Node != "novox" {
|
|
t.Fatalf("decoded %+v", back)
|
|
}
|
|
var names []string
|
|
for _, s := range back.States {
|
|
names = append(names, s.Name)
|
|
}
|
|
if strings.Join(names, ",") != "assignments,own,plans-building" {
|
|
t.Fatalf("the states are not sorted: %v", names)
|
|
}
|
|
if !back.Readable("plans-building") || back.Readable("own") || back.Readable("absent") {
|
|
t.Fatal("Readable does not say what was announced readable")
|
|
}
|
|
if !back.Keeps("own") || back.Keeps("absent") {
|
|
t.Fatal("Keeps does not say what was announced")
|
|
}
|
|
if Subject("mesh-controller") != "mesh.mod.mesh-controller.event.states" || SubjectAll != "mesh.mod.*.event.states" {
|
|
t.Fatalf("the subjects are %q and %q", Subject("mesh-controller"), SubjectAll)
|
|
}
|
|
if KeptBucket != "mesh-controller_states-announced" {
|
|
t.Fatalf("the kept bucket is %q", KeptBucket)
|
|
}
|
|
if k, err := Key("mesh-delivery-builder"); err != nil || k != "mesh-delivery-builder" {
|
|
t.Fatalf("Key = %q, %v", k, err)
|
|
}
|
|
if nothing, err := Encode(States{Module: "quiet"}); err != nil || !strings.Contains(string(nothing), `"states":[]`) {
|
|
t.Fatalf("a module keeping nothing: %s, %v", nothing, err)
|
|
}
|
|
}
|
|
|
|
func TestAnAnnouncementRefusesWhatNoBucketCouldBe(t *testing.T) {
|
|
for _, c := range []struct {
|
|
s States
|
|
says string
|
|
}{
|
|
{States{Module: ""}, "no module"},
|
|
{States{Module: "a.b"}, `"a.b"`},
|
|
{States{Module: "a", States: []State{{Name: "x_y"}}}, `"x_y"`},
|
|
{States{Module: "a", States: []State{{Name: ""}}}, `""`},
|
|
{States{Module: "a", States: []State{{Name: "x"}, {Name: "x", Readable: true}}}, "twice"},
|
|
} {
|
|
if _, err := Encode(c.s); err == nil || !strings.Contains(err.Error(), c.says) {
|
|
t.Errorf("%+v: %v, wanted a refusal saying %s", c.s, err, c.says)
|
|
}
|
|
}
|
|
if _, err := Decode([]byte(`{"v":2,"module":"a","states":[]}`)); err == nil {
|
|
t.Error("an unknown version was read")
|
|
}
|
|
if _, err := Key("a.b"); err == nil {
|
|
t.Error("a module with a dot became a key")
|
|
}
|
|
}
|