194 lines
8.3 KiB
Go
194 lines
8.3 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-controller/internal/catalogue"
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
"github.com/novox/mesh-controller/internal/link"
|
|
)
|
|
|
|
func aBrokerClaiming(module string) catalogue.Manifest {
|
|
return catalogue.Manifest{Module: module,
|
|
Provides: []catalogue.Offer{{Name: "mesh-bus", Scope: catalogue.ScopeMesh}},
|
|
Claims: []catalogue.Claim{{Name: "mesh-broker", Scope: catalogue.ScopeMesh}}}
|
|
}
|
|
|
|
func withBusSeat(t *testing.T) {
|
|
t.Helper()
|
|
was := catalogue.Seats()
|
|
t.Cleanup(func() { catalogue.UseSeats(was) })
|
|
catalogue.UseSeats([]catalogue.Seat{{Name: "mesh-broker", Scope: catalogue.ScopeMesh, Delivers: "mesh-bus", Decision: "test"}})
|
|
}
|
|
|
|
// 1317/AC1: the composition records the claimant as the holder and writes one hand act by the controller naming
|
|
// the seat, the former holder and the new one; the holdings it answers name the new holder.
|
|
func TestACompositionPassesTheSeatAndWritesOneHandActByTheController(t *testing.T) {
|
|
withBusSeat(t)
|
|
var passed []catalogue.SeatPass
|
|
var acts []link.HandAct
|
|
var said bytes.Buffer
|
|
sp := seatPassing{say: &said,
|
|
pass: func(_ context.Context, p catalogue.SeatPass) (bool, error) {
|
|
passed = append(passed, p)
|
|
return true, nil
|
|
},
|
|
act: func(_ context.Context, p catalogue.SeatPass) error {
|
|
acts = append(acts, seatPassHandAct(p))
|
|
return nil
|
|
},
|
|
}
|
|
holdings := []catalogue.Held{{Claim: "mesh-broker", Scope: catalogue.ScopeMesh, Node: "novox", Module: "old-broker"}}
|
|
got := passSeatsOn(t.Context(), sp, holdings, []catalogue.Assignment{{Node: "novox", Manifest: aBrokerClaiming("gate")}})
|
|
if len(got) != 1 || got[0].Module != "gate" || got[0].Node != "novox" {
|
|
t.Fatalf("the holdings after the composition do not name the gate: %+v", got)
|
|
}
|
|
if len(passed) != 1 || len(acts) != 1 {
|
|
t.Fatalf("passes=%d acts=%d, want one each", len(passed), len(acts))
|
|
}
|
|
a := acts[0]
|
|
text := strings.Join(append([]string{a.By, a.Verb, a.Why}, a.Args...), " ")
|
|
for _, want := range []string{"the controller", "mesh-broker", "novox/old-broker", "novox/gate"} {
|
|
if !strings.Contains(text, want) {
|
|
t.Fatalf("the hand act does not name %q: %+v", want, a)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1317/AC2: two claimants, nothing recorded, the refusal said.
|
|
func TestACompositionWithTwoClaimantsRecordsNoneAndSaysSo(t *testing.T) {
|
|
withBusSeat(t)
|
|
sp := seatPassing{say: &bytes.Buffer{},
|
|
pass: func(context.Context, catalogue.SeatPass) (bool, error) {
|
|
t.Fatal("a seat with two claimants was passed")
|
|
return false, nil
|
|
},
|
|
act: func(context.Context, catalogue.SeatPass) error { t.Fatal("an act was written"); return nil },
|
|
}
|
|
var said bytes.Buffer
|
|
sp.say = &said
|
|
holdings := []catalogue.Held{{Claim: "mesh-broker", Scope: catalogue.ScopeMesh, Node: "novox", Module: "old-broker"}}
|
|
got := passSeatsOn(t.Context(), sp, holdings, []catalogue.Assignment{
|
|
{Node: "novox", Manifest: aBrokerClaiming("gate")}, {Node: "ace", Manifest: aBrokerClaiming("other")}})
|
|
if len(got) != 1 || got[0].Module != "old-broker" {
|
|
t.Fatalf("the record changed: %+v", got)
|
|
}
|
|
if !strings.Contains(said.String(), "gate") || !strings.Contains(said.String(), "other") ||
|
|
!strings.Contains(said.String(), "seat mesh-broker --to") {
|
|
t.Fatalf("the refusal is not said with both and the remedy: %q", said.String())
|
|
}
|
|
}
|
|
|
|
// 1317/AC3 and AC4: nothing changes while the holder is assigned, nor with no claimant.
|
|
func TestACompositionChangesNothingWhileTheHolderIsAssignedOrNobodyClaims(t *testing.T) {
|
|
withBusSeat(t)
|
|
sp := seatPassing{say: &bytes.Buffer{},
|
|
pass: func(context.Context, catalogue.SeatPass) (bool, error) { t.Fatal("passed"); return false, nil },
|
|
act: func(context.Context, catalogue.SeatPass) error { t.Fatal("act"); return nil },
|
|
}
|
|
holdings := []catalogue.Held{{Claim: "mesh-broker", Scope: catalogue.ScopeMesh, Node: "novox", Module: "old-broker"}}
|
|
got := passSeatsOn(t.Context(), sp, holdings, []catalogue.Assignment{
|
|
{Node: "novox", Manifest: aBrokerClaiming("old-broker")}, {Node: "novox", Manifest: aBrokerClaiming("gate")}})
|
|
if len(got) != 1 || got[0].Module != "old-broker" {
|
|
t.Fatalf("holder assigned: record changed: %+v", got)
|
|
}
|
|
got = passSeatsOn(t.Context(), sp, holdings, nil)
|
|
if len(got) != 1 || got[0].Module != "old-broker" {
|
|
t.Fatalf("no claimant: record changed: %+v", got)
|
|
}
|
|
}
|
|
|
|
// A composition that lost the compare-and-set writes no act, and a failed write leaves the record.
|
|
func TestALostPassWritesNoActAndAFailedOneLeavesTheRecord(t *testing.T) {
|
|
withBusSeat(t)
|
|
holdings := []catalogue.Held{{Claim: "mesh-broker", Scope: catalogue.ScopeMesh, Node: "novox", Module: "old-broker"}}
|
|
as := []catalogue.Assignment{{Node: "novox", Manifest: aBrokerClaiming("gate")}}
|
|
lost := seatPassing{say: &bytes.Buffer{},
|
|
pass: func(context.Context, catalogue.SeatPass) (bool, error) { return false, nil },
|
|
act: func(context.Context, catalogue.SeatPass) error { t.Fatal("act without a pass"); return nil },
|
|
}
|
|
passSeatsOn(t.Context(), lost, holdings, as)
|
|
var said bytes.Buffer
|
|
sp := seatPassing{say: &said,
|
|
pass: func(context.Context, catalogue.SeatPass) (bool, error) { return false, context.DeadlineExceeded },
|
|
act: func(context.Context, catalogue.SeatPass) error { t.Fatal("act"); return nil },
|
|
}
|
|
got := passSeatsOn(t.Context(), sp, holdings, as)
|
|
if got[0].Module != "old-broker" || !strings.Contains(said.String(), "could not be passed") {
|
|
t.Fatalf("got %+v said %q", got, said.String())
|
|
}
|
|
}
|
|
|
|
// A pass is the mesh working as ADR 0449 §4 decided, never a repair: two of them raise no healer-wanted and
|
|
// count as no repair.
|
|
func TestTwoSeatPassesAreNoRepairAndRaiseNoHealerWanted(t *testing.T) {
|
|
withBusSeat(t)
|
|
now := time.Date(2026, 10, 19, 20, 0, 0, 0, time.UTC)
|
|
mk := func(at time.Time) link.HandAct {
|
|
a := seatPassHandAct(catalogue.SeatPass{Seat: catalogue.Seat{Name: "mesh-broker"},
|
|
From: catalogue.Held{Node: "novox", Module: "old"}, To: catalogue.Held{Node: "novox", Module: "gate"}})
|
|
a.At = at
|
|
return a
|
|
}
|
|
acts := []link.HandAct{mk(now.Add(-26 * time.Hour)), mk(now.Add(-time.Hour))}
|
|
if r := repairs(acts); len(r) != 0 {
|
|
t.Fatalf("a seat pass counts as a repair: %+v", r)
|
|
}
|
|
f := calm(now)
|
|
f.handActs = acts
|
|
if got := watchHandActs(f); len(got) != 0 {
|
|
t.Fatalf("two passes raised %+v", got)
|
|
}
|
|
}
|
|
|
|
// A failed read of one machine's assignments passes no seat: its holder would look assigned nowhere.
|
|
func TestNoSeatIsPassedWhenAMachinesAssignmentsCouldNotBeRead(t *testing.T) {
|
|
withBusSeat(t)
|
|
var said bytes.Buffer
|
|
ctx := leftOutSaidBy(t.Context(), &said)
|
|
holdings := []catalogue.Held{{Claim: "mesh-broker", Scope: catalogue.ScopeMesh, Node: "ace", Module: "old-broker"}}
|
|
shelf := map[string]catalogue.Manifest{"gate": aBrokerClaiming("gate")}
|
|
got := theMeshPassesSeatsOn(ctx, nil, shelf, map[string][]string{"novox": {"gate"}},
|
|
errors.New("ace: the bus did not answer"), holdings)
|
|
if len(got) != 1 || got[0].Module != "old-broker" {
|
|
t.Fatalf("the record moved: %+v", got)
|
|
}
|
|
if !strings.Contains(said.String(), "no seat is passed") || !strings.Contains(said.String(), "ace") {
|
|
t.Errorf("not said: %q", said.String())
|
|
}
|
|
}
|
|
|
|
// A holder that is assigned but missing from the shelf is still assigned.
|
|
func TestAHolderAssignedButNotOnTheShelfIsNotTakenForGone(t *testing.T) {
|
|
withBusSeat(t)
|
|
as := assignmentsOf(map[string]catalogue.Manifest{"gate": aBrokerClaiming("gate")},
|
|
map[string][]string{"novox": {"gate", "old-broker"}})
|
|
passes, _ := catalogue.SeatsToPassOn(
|
|
[]catalogue.Held{{Claim: "mesh-broker", Scope: catalogue.ScopeMesh, Node: "novox", Module: "old-broker"}}, as)
|
|
if len(passes) != 0 {
|
|
t.Fatalf("a holder missing from the shelf lost its seat: %+v", passes)
|
|
}
|
|
}
|
|
|
|
// The merge gate's throwaway mesh passes the seat in memory and writes nothing: no record, no hand act.
|
|
func TestAThrowawayMeshPassesTheSeatInMemoryAndWritesNothing(t *testing.T) {
|
|
withBusSeat(t)
|
|
inv := &inventory.Inventory{}
|
|
inv.MarkThrowaway()
|
|
var said bytes.Buffer
|
|
holdings := []catalogue.Held{{Claim: "mesh-broker", Scope: catalogue.ScopeMesh, Node: "novox", Module: "old-broker"}}
|
|
got := passSeatsOn(t.Context(), seatPassingOn(inv, &said), holdings,
|
|
[]catalogue.Assignment{{Node: "novox", Manifest: aBrokerClaiming("gate")}})
|
|
if len(got) != 1 || got[0].Module != "gate" {
|
|
t.Fatalf("the gate's view does not hold the pass: %+v", got)
|
|
}
|
|
if said.Len() != 0 {
|
|
t.Errorf("the throwaway composition said %q (a write was tried)", said.String())
|
|
}
|
|
}
|