94 lines
4.2 KiB
Go
94 lines
4.2 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/novox/mesh-controller/internal/catalogue"
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
)
|
|
|
|
// The controller finds the delivery's owner by the claim of the seat mesh-delivery, never by the module's name
|
|
// (novox/hq ADR 0437 §3, issue 1210). The gate is a module named mesh-delivery-gate; this is only a fixture name.
|
|
|
|
func claimingTheSeat(module string) inventory.Entry {
|
|
return inventory.Entry{Manifest: catalogue.Manifest{Module: module,
|
|
Claims: []catalogue.Claim{{Name: catalogue.DeliverySeat, Scope: catalogue.ScopeMesh}}}, On: []string{"anchor"}}
|
|
}
|
|
|
|
func namedOnly(module string) inventory.Entry {
|
|
return inventory.Entry{Manifest: catalogue.Manifest{Module: module}, On: []string{"anchor"}}
|
|
}
|
|
|
|
// 1210/AC1: a module claiming the seat is on the controller's own path whatever its name, awaiting the delivery's
|
|
// word as today's module does; a module named mesh-delivery that claims no seat is not on it.
|
|
func TestTheModuleClaimingTheSeatIsOnTheControllersOwnPath(t *testing.T) {
|
|
gate := []inventory.Entry{claimingTheSeat("mesh-delivery-gate"), namedOnly("mesh-delivery")}
|
|
own := ownPathOf(gate)
|
|
if _, on := own["mesh-delivery-gate"]; !on {
|
|
t.Error("the module claiming the seat is not on the controller's own path")
|
|
}
|
|
if _, on := own["mesh-delivery"]; on {
|
|
t.Error("a module named mesh-delivery that claims no seat is on the controller's own path")
|
|
}
|
|
if d := awaitsFor(gate, []string{"gitea", "plex"}); d == nil || d.Awaits != catalogue.DeliverySeat {
|
|
t.Errorf("an ordinary walk awaits %+v with the gate holding the seat", d)
|
|
}
|
|
if d := awaitsFor(gate, []string{"mesh-delivery-gate", "gitea"}); d != nil {
|
|
t.Errorf("a walk moving the gate awaits %+v; the gate cannot gate itself", d)
|
|
}
|
|
if d := awaitsFor(gate, []string{"mesh-delivery", "gitea"}); d == nil {
|
|
t.Error("a walk moving a module named mesh-delivery that claims no seat starts at once")
|
|
}
|
|
if !ownWalk(walkOf("novox/one", "notes", "mesh-delivery-gate"), own) || ownWalk(walkOf("novox/one", "notes", "mesh-delivery"), own) {
|
|
t.Error("a walk is on the own path by the claim of the module it plans")
|
|
}
|
|
if ownPath([]inventory.Entry{claimingTheSeat("mesh-delivery-gate")}) != true || ownPath([]inventory.Entry{namedOnly("mesh-delivery")}) {
|
|
t.Error("a merge touches the own path by the claim of the module it touches")
|
|
}
|
|
if classOfModules([]string{"mesh-delivery-gate"}, gate) != inventory.ClassCore {
|
|
t.Error("the module claiming the seat is not core")
|
|
}
|
|
}
|
|
|
|
// 1210/AC2: the merge gate's rule of the module claiming the seat is one reading; a module claiming no delivery
|
|
// seat gets its ordinary rule.
|
|
func TestTheModuleClaimingTheSeatGetsTheDeliverysGateRule(t *testing.T) {
|
|
withTheGatesTimes(t)
|
|
claimant := claimingTheSeat("mesh-delivery-gate").Manifest
|
|
r := gateRuleOf("mesh-delivery-gate", claimant)
|
|
if r.passes != 1 || r.within != 0 || !strings.HasPrefix(r.said, "mesh-delivery's rule: one reading (novox/hq ADR 0351)") {
|
|
t.Errorf("the gate's rule is %+v", r)
|
|
}
|
|
r = gateRuleOf("mesh-delivery", catalogue.Manifest{Module: "mesh-delivery"})
|
|
if !strings.HasPrefix(r.said, "a leaf module's rule") {
|
|
t.Errorf("a module named mesh-delivery claiming no seat gets %q", r.said)
|
|
}
|
|
}
|
|
|
|
// 1210/AC3: with both today's module and the gate claiming the seat (R3d's group), both are on the own path and
|
|
// both get the delivery's rule.
|
|
func TestBothClaimantsAreOnTheOwnPathAndGetTheRule(t *testing.T) {
|
|
withTheGatesTimes(t)
|
|
both := []inventory.Entry{claimingTheSeat("mesh-delivery"), claimingTheSeat("mesh-delivery-gate")}
|
|
own := ownPathOf(both)
|
|
for _, m := range []string{"mesh-delivery", "mesh-delivery-gate"} {
|
|
if _, on := own[m]; !on {
|
|
t.Errorf("%s is not on the own path", m)
|
|
}
|
|
if r := gateRuleOf(m, claimingTheSeat(m).Manifest); r.passes != 1 || !strings.HasPrefix(r.said, "mesh-delivery's rule") {
|
|
t.Errorf("%s gets %+v", m, r)
|
|
}
|
|
if d := awaitsFor(both, []string{m, "gitea"}); d != nil {
|
|
t.Errorf("a walk moving %s awaits %+v", m, d)
|
|
}
|
|
}
|
|
}
|
|
|
|
// theDeliveryClaims is a catalogue whose one module claiming the seat is today's mesh-delivery, for the tests that
|
|
// announce a merge from it.
|
|
func theDeliveryClaims(context.Context) ([]inventory.Entry, error) {
|
|
return []inventory.Entry{claimingTheSeat("mesh-delivery")}, nil
|
|
}
|