147 lines
3.4 KiB
Go
147 lines
3.4 KiB
Go
package quorum
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"git.cer.sh/axodouble/quptime/internal/config"
|
|
"git.cer.sh/axodouble/quptime/internal/transport"
|
|
)
|
|
|
|
func threeNode(self string) (*config.ClusterConfig, *Manager) {
|
|
cluster := &config.ClusterConfig{Peers: []config.PeerInfo{
|
|
{NodeID: "a"}, {NodeID: "b"}, {NodeID: "c"},
|
|
}}
|
|
return cluster, New(self, cluster, nil)
|
|
}
|
|
|
|
func TestSoloNodeElectsItself(t *testing.T) {
|
|
cluster := &config.ClusterConfig{}
|
|
m := New("only", cluster, nil)
|
|
m.markLive("only")
|
|
m.recomputeMaster()
|
|
if m.Master() != "only" {
|
|
t.Errorf("Master=%q want %q", m.Master(), "only")
|
|
}
|
|
if !m.HasQuorum() {
|
|
t.Error("solo node should have quorum")
|
|
}
|
|
if m.Term() != 1 {
|
|
t.Errorf("Term=%d want 1 after first election", m.Term())
|
|
}
|
|
}
|
|
|
|
func TestThreeNodeElectsLowestNodeID(t *testing.T) {
|
|
_, m := threeNode("b")
|
|
m.markLive("a")
|
|
m.markLive("b")
|
|
m.markLive("c")
|
|
m.recomputeMaster()
|
|
if got := m.Master(); got != "a" {
|
|
t.Errorf("Master=%q want a", got)
|
|
}
|
|
if !m.HasQuorum() {
|
|
t.Error("expected quorum with 3 live of 3")
|
|
}
|
|
}
|
|
|
|
func TestNoQuorumClearsMaster(t *testing.T) {
|
|
_, m := threeNode("b")
|
|
m.markLive("b")
|
|
m.recomputeMaster()
|
|
if m.Master() != "" {
|
|
t.Errorf("Master=%q want empty (no quorum)", m.Master())
|
|
}
|
|
if m.HasQuorum() {
|
|
t.Error("1 of 3 live should not be quorum")
|
|
}
|
|
}
|
|
|
|
func TestTermBumpsOnMasterChange(t *testing.T) {
|
|
_, m := threeNode("b")
|
|
m.markLive("a")
|
|
m.markLive("b")
|
|
m.recomputeMaster()
|
|
termBefore := m.Term()
|
|
masterBefore := m.Master()
|
|
if masterBefore != "a" {
|
|
t.Fatalf("expected initial master a, got %q", masterBefore)
|
|
}
|
|
|
|
// "a" goes dead — we and "c" join up.
|
|
m.mu.Lock()
|
|
delete(m.lastSeen, "a")
|
|
m.mu.Unlock()
|
|
m.markLive("c")
|
|
m.recomputeMaster()
|
|
if m.Master() != "b" {
|
|
t.Errorf("after a-fail Master=%q want b", m.Master())
|
|
}
|
|
if m.Term() <= termBefore {
|
|
t.Errorf("Term did not bump: before=%d after=%d", termBefore, m.Term())
|
|
}
|
|
}
|
|
|
|
func TestHandleHeartbeatMarksSenderLive(t *testing.T) {
|
|
cluster, m := threeNode("a")
|
|
_ = cluster
|
|
resp := m.HandleHeartbeat(transport.HeartbeatRequest{
|
|
FromNodeID: "b",
|
|
Term: 7,
|
|
MasterID: "a",
|
|
Version: 3,
|
|
})
|
|
if resp.NodeID != "a" {
|
|
t.Errorf("response NodeID=%q want a", resp.NodeID)
|
|
}
|
|
if _, ok := m.Liveness()["b"]; !ok {
|
|
t.Error("sender was not recorded live")
|
|
}
|
|
}
|
|
|
|
func TestDeadAfterEvictsStaleLiveness(t *testing.T) {
|
|
_, m := threeNode("a")
|
|
m.deadAfter = 50 * time.Millisecond
|
|
m.markLive("a")
|
|
m.markLive("b")
|
|
m.markLive("c")
|
|
m.recomputeMaster()
|
|
if m.Master() != "a" {
|
|
t.Fatal("expected initial master a")
|
|
}
|
|
|
|
// Wait past the dead-after window — only self remains live.
|
|
time.Sleep(120 * time.Millisecond)
|
|
m.markLive("a")
|
|
m.recomputeMaster()
|
|
if m.Master() != "" {
|
|
t.Errorf("expected no master after peers timed out, got %q", m.Master())
|
|
}
|
|
}
|
|
|
|
func TestVersionObserverFiresOnHigherVersion(t *testing.T) {
|
|
cluster := &config.ClusterConfig{Version: 2}
|
|
m := New("a", cluster, nil)
|
|
|
|
var notified struct {
|
|
peerID string
|
|
peerVer uint64
|
|
count int
|
|
}
|
|
m.SetVersionObserver(func(peerID, _ string, peerVer uint64) {
|
|
notified.peerID = peerID
|
|
notified.peerVer = peerVer
|
|
notified.count++
|
|
})
|
|
|
|
m.maybeNotifyVersion("b", 5)
|
|
if notified.count != 1 || notified.peerID != "b" || notified.peerVer != 5 {
|
|
t.Errorf("expected observer fired with b=5, got %+v", notified)
|
|
}
|
|
|
|
m.maybeNotifyVersion("b", 1)
|
|
if notified.count != 1 {
|
|
t.Errorf("observer fired for stale version, count=%d", notified.count)
|
|
}
|
|
}
|