jochen
be92762969
The live tests reached one shared bus and assert, read and remove the mesh's own objects by their fixed names, so packages run in parallel deleted what each other read and the suite passed only one package at a time; a red suite read as noise. internal/testbus starts a server per test, linked in at the nats-server release go.mod pins, and a test holds that pin to the catalogue's bus image and to the facts snapshot's bus when there is one, so the tests never run a bus the mesh does not. The waiter test read a timing (the most connections held at one look) and now reads the state it means (the fewest held across the wait). make check runs the packages in parallel under the race detector, with a timeout.
71 lines
2.3 KiB
Go
71 lines
2.3 KiB
Go
package link
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-controller/internal/broker"
|
|
|
|
"github.com/novox/mesh-controller/internal/testbus"
|
|
)
|
|
|
|
// novox/hq issue 213: while a machine hands its controller over, the new controller (the process)
|
|
// is started while the old one (the container) still holds the controller's consumers. It must not
|
|
// exit — the host would read that as a replacement that did not come up and never remove the
|
|
// container — and must not act on what the old one is handed. It stands by, and takes the consumers
|
|
// when the old one lets go.
|
|
func TestNatsASecondControllerStandsByAndTakesOverWhenTheFirstLetsGo(t *testing.T) {
|
|
js := aBus(t)
|
|
was := StandbyPoll
|
|
StandbyPoll = 50 * time.Millisecond
|
|
defer func() { StandbyPoll = was }()
|
|
|
|
old := &counted{}
|
|
_, stopOld := servingOn(t, js, old)
|
|
eventually(t, "the first controller binding its consumer", func() bool {
|
|
info, err := js.Context().ConsumerInfo("CONTROL", broker.ControllerName)
|
|
return err == nil && info.PushBound
|
|
})
|
|
|
|
// The new one, on a connection of its own as the process would have.
|
|
second, err := broker.Dial(testbus.URL(t))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(second.Close)
|
|
fresh := &counted{}
|
|
s := &Server{inbound: Nats(second), bus: OverNATS{Conn: second.Conn(), JS: second.Context()},
|
|
listener: fresh, log: quiet()}
|
|
ctx, stopNew := context.WithCancel(context.Background())
|
|
defer stopNew()
|
|
ended := make(chan error, 1)
|
|
go func() { ended <- s.Serve(ctx) }()
|
|
|
|
select {
|
|
case err := <-ended:
|
|
t.Fatalf("the second controller stopped instead of standing by: %v", err)
|
|
case <-time.After(500 * time.Millisecond):
|
|
}
|
|
|
|
report := func(declared string) {
|
|
body, _ := json.Marshal(Report{Node: "anchor", Declared: declared, Applied: []string{"store"}})
|
|
if _, err := js.Context().Publish(ReportSubject("anchor"), body); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
report("d1")
|
|
eventually(t, "the holding controller hearing the report", func() bool { return old.count() == 1 })
|
|
if fresh.count() != 0 {
|
|
t.Fatal("the controller standing by acted on a report the holder was handed")
|
|
}
|
|
|
|
stopOld()
|
|
report("d2")
|
|
eventually(t, "the second controller taking over once the first let go", func() bool { return fresh.count() == 1 })
|
|
if old.count() != 1 {
|
|
t.Errorf("the first controller heard %d reports", old.count())
|
|
}
|
|
}
|