fluidB
/
fluidb-old
1
0
Fork 0
Code Pull Requests Activity

Make temp directories easier to track

Browse Source
master
Philip O'Toole 9 months ago
parent a4672c1cb1
commit 60da1377ba
4 changed files with 123 additions and 124 deletions
Show Stats Download Patch File Download Diff File

138
system_test/cluster_test.go
Unescape Escape View File

@ -17,15 +17,15 @@ import (
// Test_JoinLeaderNode tests a join operation between a leader and a new node.
func Test_JoinLeaderNode(t *testing.T) {
leader := mustNewLeaderNode()
leader := mustNewLeaderNode("leader1")
defer leader.Deprovision()
node := mustNewNode(false)
defer node.Deprovision()
if err := node.Join(leader); err != nil {
node2 := mustNewNode("node1", false)
defer node2.Deprovision()
if err := node2.Join(leader); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
}
_, err := node.WaitForLeader()
_, err := node2.WaitForLeader()
if err != nil {
t.Fatalf("failed waiting for leader: %s", err.Error())
}
@ -33,10 +33,10 @@ func Test_JoinLeaderNode(t *testing.T) {
// Test_MultiNodeCluster tests formation of a 3-node cluster, and its operation.
func Test_MultiNodeCluster(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -62,7 +62,7 @@ func Test_MultiNodeCluster(t *testing.T) {
t.Fatalf("got incorrect number of followers: %d", len(followers))
}
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
if err := node3.Join(leader); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -169,10 +169,10 @@ func Test_MultiNodeCluster(t *testing.T) {
// Test_MultiNodeClusterRANDOM tests operation of RANDOM() SQL rewriting. It checks that a rewritten
// statement is sent to follower.
func Test_MultiNodeClusterRANDOM(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -229,15 +229,15 @@ func Test_MultiNodeClusterRANDOM(t *testing.T) {
// Test_MultiNodeClusterBootstrap tests formation of a 3-node cluster via bootstraping,
// and its operation.
func Test_MultiNodeClusterBootstrap(t *testing.T) {
node1 := mustNewNode(false)
node1 := mustNewNode("node1", false)
node1.Store.BootstrapExpect = 3
defer node1.Deprovision()
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
node2.Store.BootstrapExpect = 3
defer node2.Deprovision()
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
node3.Store.BootstrapExpect = 3
defer node3.Deprovision()
@ -394,15 +394,15 @@ func Test_MultiNodeClusterBootstrap(t *testing.T) {
// Test_MultiNodeClusterBootstrapLaterJoin tests formation of a 3-node cluster and
// then checking a 4th node can join later with the bootstap parameters.
func Test_MultiNodeClusterBootstrapLaterJoin(t *testing.T) {
node1 := mustNewNode(false)
node1 := mustNewNode("node1", false)
node1.Store.BootstrapExpect = 3
defer node1.Deprovision()
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
node2.Store.BootstrapExpect = 3
defer node2.Deprovision()
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
node3.Store.BootstrapExpect = 3
defer node3.Deprovision()
@ -468,7 +468,7 @@ func Test_MultiNodeClusterBootstrapLaterJoin(t *testing.T) {
// Ensure a 4th node can join cluster with exactly same launch
// params. Under the cover it should just do a join.
node4 := mustNewNode(false)
node4 := mustNewNode("node4", false)
node4.Store.BootstrapExpect = 3
defer node4.Deprovision()
node4Bs := cluster.NewBootstrapper(provider, node4.Client)
@ -492,17 +492,17 @@ func Test_MultiNodeClusterBootstrapLaterJoin(t *testing.T) {
// Test_MultiNodeClusterBootstrapLaterJoinTLS tests formation of a 3-node cluster which
// uses HTTP and TLS,then checking a 4th node can join later with the bootstap parameters.
func Test_MultiNodeClusterBootstrapLaterJoinTLS(t *testing.T) {
node1 := mustNewNodeEncrypted(false, true, true)
node1 := mustNewNodeEncrypted("node1", false, true, true)
node1.Store.BootstrapExpect = 3
node1.EnableTLSClient()
defer node1.Deprovision()
node2 := mustNewNodeEncrypted(false, true, true)
node2 := mustNewNodeEncrypted("node2", false, true, true)
node2.Store.BootstrapExpect = 3
node2.EnableTLSClient()
defer node2.Deprovision()
node3 := mustNewNodeEncrypted(false, true, true)
node3 := mustNewNodeEncrypted("node3", false, true, true)
node3.Store.BootstrapExpect = 3
node3.EnableTLSClient()
defer node3.Deprovision()
@ -569,7 +569,7 @@ func Test_MultiNodeClusterBootstrapLaterJoinTLS(t *testing.T) {
// Ensure a 4th node can join cluster with exactly same launch
// params. Under the covers it should just do a join.
node4 := mustNewNodeEncrypted(false, true, true)
node4 := mustNewNodeEncrypted("node4", false, true, true)
node4.Store.BootstrapExpect = 3
node4.EnableTLSClient()
defer node3.Deprovision()
@ -633,7 +633,7 @@ func Test_MultiNodeClusterRaftAdv(t *testing.T) {
clstrDialer := tcp.NewDialer(cluster.MuxClusterHeader, nil)
// Start two nodes, and ensure a cluster can be formed.
node1 := mustNodeEncrypted(mustTempDir(), true, false, mux1, raftDialer, clstrDialer, "1")
node1 := mustNodeEncrypted("node1", mustTempDir("node1"), true, false, mux1, raftDialer, clstrDialer)
defer node1.Deprovision()
leader, err := node1.WaitForLeader()
if err != nil {
@ -643,7 +643,7 @@ func Test_MultiNodeClusterRaftAdv(t *testing.T) {
t.Fatalf("node return wrong leader from leader, exp: %s, got %s", exp, got)
}
node2 := mustNodeEncrypted(mustTempDir(), false, false, mux2, raftDialer, clstrDialer, "2")
node2 := mustNodeEncrypted("node2", mustTempDir("node2"), false, false, mux2, raftDialer, clstrDialer)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node2 failed to join leader: %s", err.Error())
@ -659,10 +659,10 @@ func Test_MultiNodeClusterRaftAdv(t *testing.T) {
// Test_MultiNodeClusterNodes checks nodes/ endpoint under various situations.
func Test_MultiNodeClusterNodes(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -679,7 +679,7 @@ func Test_MultiNodeClusterNodes(t *testing.T) {
t.Fatalf("failed to find cluster leader: %s", err.Error())
}
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
if err := node3.Join(leader); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -752,7 +752,7 @@ func Test_MultiNodeClusterNodes(t *testing.T) {
// Test_MultiNodeClusterQueuedWrites tests writing to a cluster using
// normal and queued writes.
func Test_MultiNodeClusterQueuedWrites(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
if _, err := node1.Execute(`CREATE TABLE foo (id integer not null primary key, name text)`); err != nil {
@ -760,7 +760,7 @@ func Test_MultiNodeClusterQueuedWrites(t *testing.T) {
}
// Join a second and third nodes
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -769,7 +769,7 @@ func Test_MultiNodeClusterQueuedWrites(t *testing.T) {
if err != nil {
t.Fatalf("failed waiting for leader: %s", err.Error())
}
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
if err := node3.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -853,7 +853,7 @@ func Test_MultiNodeClusterLargeQueuedWrites(t *testing.T) {
http.ResetStats()
queue.ResetStats()
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
if _, err := node1.Execute(`CREATE TABLE foo (id integer not null primary key, name text)`); err != nil {
@ -861,7 +861,7 @@ func Test_MultiNodeClusterLargeQueuedWrites(t *testing.T) {
}
// Join a second and third nodes
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -870,7 +870,7 @@ func Test_MultiNodeClusterLargeQueuedWrites(t *testing.T) {
if err != nil {
t.Fatalf("failed waiting for leader: %s", err.Error())
}
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
if err := node3.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -917,10 +917,10 @@ func Test_MultiNodeClusterLargeQueuedWrites(t *testing.T) {
// Test_MultiNodeClusterNodesNonVoter checks nodes/ endpoint with a non-voting node.
func Test_MultiNodeClusterNodesNonVoter(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -937,7 +937,7 @@ func Test_MultiNodeClusterNodesNonVoter(t *testing.T) {
t.Fatalf("failed to find cluster leader: %s", err.Error())
}
nonVoter := mustNewNode(false)
nonVoter := mustNewNode("nonvoter", false)
defer nonVoter.Deprovision()
if err := nonVoter.JoinAsNonVoter(leader); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -988,14 +988,14 @@ func Test_MultiNodeClusterNodesNonVoter(t *testing.T) {
// Test_MultiNodeClusterNodeEncrypted tests formation of a 3-node cluster, and its operation.
// This test enables inter-node encryption, but keeps the unencrypted HTTP API.
func Test_MultiNodeClusterNodeEncrypted(t *testing.T) {
node1 := mustNewNodeEncrypted(true, false, true)
node1 := mustNewNodeEncrypted("node1", true, false, true)
node1.EnableTLSClient()
defer node1.Deprovision()
if _, err := node1.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
}
node2 := mustNewNodeEncrypted(false, false, true)
node2 := mustNewNodeEncrypted("node2", false, false, true)
node2.EnableTLSClient()
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
@ -1022,7 +1022,7 @@ func Test_MultiNodeClusterNodeEncrypted(t *testing.T) {
t.Fatalf("got incorrect number of followers: %d", len(followers))
}
node3 := mustNewNodeEncrypted(false, false, true)
node3 := mustNewNodeEncrypted("node3", false, false, true)
node3.EnableTLSClient()
defer node3.Deprovision()
if err := node3.Join(leader); err != nil {
@ -1138,7 +1138,7 @@ func Test_MultiNodeClusterNodeEncrypted(t *testing.T) {
// Test_MultiNodeClusterSnapshot tests formation of a 3-node cluster, which involves sharing snapshots.
func Test_MultiNodeClusterSnapshot(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
if _, err := node1.Execute(`CREATE TABLE foo (id integer not null primary key, name text)`); err != nil {
@ -1179,7 +1179,7 @@ func Test_MultiNodeClusterSnapshot(t *testing.T) {
}
// Join a second node, check it gets the data via a snapshot.
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -1191,7 +1191,7 @@ func Test_MultiNodeClusterSnapshot(t *testing.T) {
testerFn(node2)
// Create and add a third node to the cluster.
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
if err := node3.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -1229,10 +1229,10 @@ func Test_MultiNodeClusterSnapshot(t *testing.T) {
// Test_MultiNodeClusterWithNonVoter tests formation of a 4-node cluster, one of which is
// a non-voter
func Test_MultiNodeClusterWithNonVoter(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -1249,7 +1249,7 @@ func Test_MultiNodeClusterWithNonVoter(t *testing.T) {
t.Fatalf("failed to find cluster leader: %s", err.Error())
}
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
if err := node3.Join(leader); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -1266,7 +1266,7 @@ func Test_MultiNodeClusterWithNonVoter(t *testing.T) {
t.Fatalf("failed to find cluster leader: %s", err.Error())
}
nonVoter := mustNewNode(false)
nonVoter := mustNewNode("nonvoter", false)
defer nonVoter.Deprovision()
if err := nonVoter.JoinAsNonVoter(leader); err != nil {
t.Fatalf("non-voting node failed to join leader: %s", err.Error())
@ -1367,7 +1367,7 @@ func Test_MultiNodeClusterWithNonVoter(t *testing.T) {
// Test_MultiNodeClusterRecoverSingle tests recovery of a single node from a 3-node cluster,
// which no longer has quorum.
func Test_MultiNodeClusterRecoverSingle(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
if _, err := node1.Execute(`CREATE TABLE foo (id integer not null primary key, name text)`); err != nil {
@ -1381,7 +1381,7 @@ func Test_MultiNodeClusterRecoverSingle(t *testing.T) {
}
// Join a second and third nodes, which will get database state via snapshots.
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -1394,7 +1394,7 @@ func Test_MultiNodeClusterRecoverSingle(t *testing.T) {
t.Fatalf("got incorrect results from node: %s", rows)
}
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
if err := node3.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -1425,7 +1425,7 @@ func Test_MultiNodeClusterRecoverSingle(t *testing.T) {
// quorum can't be met. This isn't quite right since the Raft address is also
// changing, but it generally proves it doesn't come up.
mux0, ln0 := mustNewOpenMux("127.0.0.1:10000")
failedSingle := mustNodeEncrypted(node1.Dir, true, false, mux0, raftDialer, clstrDialer, node1.Store.ID())
failedSingle := mustNodeEncrypted(node1.Store.ID(), node1.Dir, true, false, mux0, raftDialer, clstrDialer)
_, err = failedSingle.WaitForLeader()
if err == nil {
t.Fatalf("no error waiting for leader")
@ -1438,7 +1438,7 @@ func Test_MultiNodeClusterRecoverSingle(t *testing.T) {
peers := fmt.Sprintf(`[{"id": "%s","address": "%s"}]`, node1.Store.ID(), "127.0.0.1:10001")
mustWriteFile(node1.PeersPath, peers)
okSingle := mustNodeEncrypted(node1.Dir, true, false, mux1, raftDialer, clstrDialer, node1.Store.ID())
okSingle := mustNodeEncrypted(node1.Store.ID(), node1.Dir, true, false, mux1, raftDialer, clstrDialer)
_, err = okSingle.WaitForLeader()
if err != nil {
t.Fatalf("failed waiting for leader: %s", err.Error())
@ -1459,14 +1459,14 @@ func Test_MultiNodeClusterRecoverFull(t *testing.T) {
clstrDialer := tcp.NewDialer(cluster.MuxClusterHeader, nil)
mux1, ln1 := mustNewOpenMux("127.0.0.1:10001")
node1 := mustNodeEncrypted(mustTempDir(), true, false, mux1, raftDialer, clstrDialer, "1")
node1 := mustNodeEncrypted("node1", mustTempDir("node1"), true, false, mux1, raftDialer, clstrDialer)
_, err = node1.WaitForLeader()
if err != nil {
t.Fatalf("failed waiting for leader: %s", err.Error())
}
mux2, ln2 := mustNewOpenMux("127.0.0.1:10002")
node2 := mustNodeEncrypted(mustTempDir(), false, false, mux2, raftDialer, clstrDialer, "2")
node2 := mustNodeEncrypted("node2", mustTempDir("node2"), false, false, mux2, raftDialer, clstrDialer)
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
}
@ -1476,7 +1476,7 @@ func Test_MultiNodeClusterRecoverFull(t *testing.T) {
}
mux3, ln3 := mustNewOpenMux("127.0.0.1:10003")
node3 := mustNodeEncrypted(mustTempDir(), false, false, mux3, raftDialer, clstrDialer, "3")
node3 := mustNodeEncrypted("node3", mustTempDir("node3"), false, false, mux3, raftDialer, clstrDialer)
if err := node3.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
}
@ -1524,17 +1524,17 @@ func Test_MultiNodeClusterRecoverFull(t *testing.T) {
mustWriteFile(node3.PeersPath, peers)
mux4, ln4 := mustNewOpenMux("127.0.0.1:11001")
node4 := mustNodeEncrypted(node1.Dir, false, false, mux4, raftDialer, clstrDialer, "1")
node4 := mustNodeEncrypted("1", node1.Dir, false, false, mux4, raftDialer, clstrDialer)
defer node4.Deprovision()
defer ln4.Close()
mux5, ln5 := mustNewOpenMux("127.0.0.1:11002")
node5 := mustNodeEncrypted(node2.Dir, false, false, mux5, raftDialer, clstrDialer, "2")
node5 := mustNodeEncrypted("2", node2.Dir, false, false, mux5, raftDialer, clstrDialer)
defer node5.Deprovision()
defer ln5.Close()
mux6, ln6 := mustNewOpenMux("127.0.0.1:11003")
node6 := mustNodeEncrypted(node3.Dir, false, false, mux6, raftDialer, clstrDialer, "3")
node6 := mustNodeEncrypted("3", node3.Dir, false, false, mux6, raftDialer, clstrDialer)
defer node6.Deprovision()
defer ln6.Close()
@ -1561,7 +1561,7 @@ func Test_MultiNodeClusterReapNodes(t *testing.T) {
n.Store.ReapReadOnlyTimeout = time.Second
}
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
cfgStoreFn(node1)
_, err := node1.WaitForLeader()
@ -1569,7 +1569,7 @@ func Test_MultiNodeClusterReapNodes(t *testing.T) {
t.Fatalf("failed waiting for leader: %s", err.Error())
}
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
cfgStoreFn(node2)
if err := node2.Join(node1); err != nil {
@ -1587,7 +1587,7 @@ func Test_MultiNodeClusterReapNodes(t *testing.T) {
t.Fatalf("failed to find cluster leader: %s", err.Error())
}
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
cfgStoreFn(node3)
if err := node3.Join(leader); err != nil {
@ -1605,7 +1605,7 @@ func Test_MultiNodeClusterReapNodes(t *testing.T) {
t.Fatalf("failed to find cluster leader: %s", err.Error())
}
nonVoter := mustNewNode(false)
nonVoter := mustNewNode("nonvoter", false)
defer nonVoter.Deprovision()
cfgStoreFn(nonVoter)
if err := nonVoter.JoinAsNonVoter(leader); err != nil {
@ -1663,7 +1663,7 @@ func Test_MultiNodeClusterNoReap(t *testing.T) {
n.Store.ReapReadOnlyTimeout = 120 * time.Second
}
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
cfgStoreFn(node1)
_, err := node1.WaitForLeader()
@ -1671,7 +1671,7 @@ func Test_MultiNodeClusterNoReap(t *testing.T) {
t.Fatalf("failed waiting for leader: %s", err.Error())
}
nonVoter := mustNewNode(false)
nonVoter := mustNewNode("nonvoter", false)
defer nonVoter.Deprovision()
cfgStoreFn(nonVoter)
if err := nonVoter.JoinAsNonVoter(node1); err != nil {
@ -1708,7 +1708,7 @@ func Test_MultiNodeClusterNoReapZero(t *testing.T) {
n.Store.ReapTimeout = 0
}
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
cfgStoreFn(node1)
_, err := node1.WaitForLeader()
@ -1716,7 +1716,7 @@ func Test_MultiNodeClusterNoReapZero(t *testing.T) {
t.Fatalf("failed waiting for leader: %s", err.Error())
}
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
cfgStoreFn(node2)
if err := node2.Join(node1); err != nil {
@ -1734,7 +1734,7 @@ func Test_MultiNodeClusterNoReapZero(t *testing.T) {
t.Fatalf("failed to find cluster leader: %s", err.Error())
}
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
cfgStoreFn(node3)
if err := node3.Join(leader); err != nil {
@ -1779,7 +1779,7 @@ func Test_MultiNodeClusterNoReapReadOnlyZero(t *testing.T) {
n.Store.ReapReadOnlyTimeout = 0
}
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
cfgStoreFn(node1)
_, err := node1.WaitForLeader()
@ -1787,7 +1787,7 @@ func Test_MultiNodeClusterNoReapReadOnlyZero(t *testing.T) {
t.Fatalf("failed waiting for leader: %s", err.Error())
}
nonVoter := mustNewNode(false)
nonVoter := mustNewNode("2", false)
defer nonVoter.Deprovision()
cfgStoreFn(nonVoter)
if err := nonVoter.JoinAsNonVoter(node1); err != nil {
@ -1819,7 +1819,7 @@ func Test_MultiNodeClusterNoReapReadOnlyZero(t *testing.T) {
}
func Test_MultiNodeCluster_Boot(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
_, err := node1.Boot("testdata/auto-restore.sqlite")
@ -1828,7 +1828,7 @@ func Test_MultiNodeCluster_Boot(t *testing.T) {
}
// Join a second node, check it gets the data via a snapshot.
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())

21
system_test/helpers.go
Unescape Escape View File

@ -625,12 +625,12 @@ func Remove(n *Node, addr string) error {
return nil
}
func mustNewNode(enableSingle bool) *Node {
return mustNewNodeEncrypted(enableSingle, false, false)
func mustNewNode(id string, enableSingle bool) *Node {
return mustNewNodeEncrypted(id, enableSingle, false, false)
}
func mustNewNodeEncrypted(enableSingle, httpEncrypt, nodeEncrypt bool) *Node {
dir := mustTempDir()
func mustNewNodeEncrypted(id string, enableSingle, httpEncrypt, nodeEncrypt bool) *Node {
dir := mustTempDir(id)
var mux *tcp.Mux
var raftDialer *tcp.Dialer
var clstrDialer *tcp.Dialer
@ -644,10 +644,10 @@ func mustNewNodeEncrypted(enableSingle, httpEncrypt, nodeEncrypt bool) *Node {
clstrDialer = tcp.NewDialer(cluster.MuxClusterHeader, nil)
}
go mux.Serve()
return mustNodeEncrypted(dir, enableSingle, httpEncrypt, mux, raftDialer, clstrDialer, "")
return mustNodeEncrypted(id, dir, enableSingle, httpEncrypt, mux, raftDialer, clstrDialer)
}
func mustNodeEncrypted(dir string, enableSingle, httpEncrypt bool, mux *tcp.Mux, raftDialer, clstrDialer *tcp.Dialer, nodeID string) *Node {
func mustNodeEncrypted(id, dir string, enableSingle, httpEncrypt bool, mux *tcp.Mux, raftDialer, clstrDialer *tcp.Dialer) *Node {
nodeCertPath := rX509.CertExampleDotComFile(dir)
nodeKeyPath := rX509.KeyExampleDotComFile(dir)
httpCertPath := nodeCertPath
@ -667,7 +667,6 @@ func mustNodeEncrypted(dir string, enableSingle, httpEncrypt bool, mux *tcp.Mux,
raftLn := mux.Listen(cluster.MuxRaftHeader)
raftTn := tcp.NewLayer(raftLn, raftDialer)
id := nodeID
if id == "" {
id = raftTn.Addr().String()
}
@ -722,8 +721,8 @@ func mustNodeEncrypted(dir string, enableSingle, httpEncrypt bool, mux *tcp.Mux,
return node
}
func mustNewLeaderNode() *Node {
node := mustNewNode(true)
func mustNewLeaderNode(id string) *Node {
node := mustNewNode(id, true)
if _, err := node.WaitForLeader(); err != nil {
node.Deprovision()
panic("node never became leader")
@ -731,9 +730,9 @@ func mustNewLeaderNode() *Node {
return node
}
func mustTempDir() string {
func mustTempDir(s string) string {
var err error
path, err := os.MkdirTemp("", "rqlilte-system-test-")
path, err := os.MkdirTemp("", fmt.Sprintf("rqlilte-system-test-%s-", s))
if err != nil {
panic("failed to create temp dir")
}

12
system_test/request_forwarding_test.go
Unescape Escape View File

@ -24,7 +24,7 @@ var (
// RPC, and ensures results are the same for basically the same operation.
func Test_StoreClientSideBySide(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
leaderAddr, err := node.Store.LeaderAddr()
if err != nil {
@ -158,10 +158,10 @@ func Test_StoreClientSideBySide(t *testing.T) {
// Test_MultiNodeCluster tests formation of a 3-node cluster and query
// against all nodes to test requests are forwarded to leader transparently.
func Test_MultiNodeClusterRequestForwardOK(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -178,7 +178,7 @@ func Test_MultiNodeClusterRequestForwardOK(t *testing.T) {
t.Fatalf("failed to find cluster leader: %s", err.Error())
}
node3 := mustNewNode(false)
node3 := mustNewNode("node3", false)
defer node3.Deprovision()
if err := node3.Join(leader); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())
@ -247,10 +247,10 @@ func Test_MultiNodeClusterRequestForwardOK(t *testing.T) {
// Test_MultiNodeClusterQueuedRequestForwardOK tests that queued writes are forwarded
// correctly.
func Test_MultiNodeClusterQueuedRequestForwardOK(t *testing.T) {
node1 := mustNewLeaderNode()
node1 := mustNewLeaderNode("leader1")
defer node1.Deprovision()
node2 := mustNewNode(false)
node2 := mustNewNode("node2", false)
defer node2.Deprovision()
if err := node2.Join(node1); err != nil {
t.Fatalf("node failed to join leader: %s", err.Error())

76
system_test/single_node_test.go
Unescape Escape View File

@ -19,7 +19,7 @@ import (
)
func Test_SingleNodeBasicEndpoint(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("node1")
defer node.Deprovision()
// Ensure accessing endpoints in basic manner works
@ -28,12 +28,12 @@ func Test_SingleNodeBasicEndpoint(t *testing.T) {
t.Fatalf(`failed to retrieve status: %s`, err)
}
dir := mustTempDir()
dir := mustTempDir("node1")
mux, ln := mustNewOpenMux("")
defer ln.Close()
raftDialer := tcp.NewDialer(cluster.MuxRaftHeader, nil)
clstrDialer := tcp.NewDialer(cluster.MuxClusterHeader, nil)
node = mustNodeEncrypted(dir, true, false, mux, raftDialer, clstrDialer, "")
node = mustNodeEncrypted("node1", dir, true, false, mux, raftDialer, clstrDialer)
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
}
@ -65,7 +65,7 @@ func Test_SingleNodeBasicEndpoint(t *testing.T) {
}
func Test_SingleNodeNotReadyLive(t *testing.T) {
node := mustNewNode(false)
node := mustNewNode("node1", false)
defer node.Deprovision()
ready, err := node.Ready()
if err != nil {
@ -96,7 +96,7 @@ func Test_SingleNodeNotReadyLive(t *testing.T) {
}
func Test_SingleNode(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("node1")
defer node.Deprovision()
tests := []struct {
@ -159,7 +159,7 @@ func Test_SingleNode(t *testing.T) {
}
func Test_SingleNodeRequest(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
tests := []struct {
@ -208,7 +208,7 @@ func Test_SingleNodeRequest(t *testing.T) {
}
func Test_SingleNodeMulti(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
tests := []struct {
@ -270,7 +270,7 @@ func Test_SingleNodeMulti(t *testing.T) {
func Test_SingleNodeConcurrentRequests(t *testing.T) {
var err error
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
node.Store.SetRequestCompression(1024, 1024) // Ensure no compression
defer node.Deprovision()
@ -303,7 +303,7 @@ func Test_SingleNodeConcurrentRequests(t *testing.T) {
func Test_SingleNodeConcurrentRequestsCompressed(t *testing.T) {
var err error
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
node.Store.SetRequestCompression(0, 0) // Ensure compression
defer node.Deprovision()
@ -335,7 +335,7 @@ func Test_SingleNodeConcurrentRequestsCompressed(t *testing.T) {
}
func Test_SingleNodeParameterized(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
tests := []struct {
@ -378,7 +378,7 @@ func Test_SingleNodeParameterized(t *testing.T) {
}
func Test_SingleNodeRequestParameterized(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
tests := []struct {
@ -411,7 +411,7 @@ func Test_SingleNodeRequestParameterized(t *testing.T) {
}
func Test_SingleNodeParameterizedNull(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
tests := []struct {
@ -454,7 +454,7 @@ func Test_SingleNodeParameterizedNull(t *testing.T) {
}
func Test_SingleNodeParameterizedNamed(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
tests := []struct {
@ -499,7 +499,7 @@ func Test_SingleNodeParameterizedNamed(t *testing.T) {
// Test_SingleNodeParameterizedNamedConstraints tests that named parameters can be used with constraints
// See https://github.com/rqlite/rqlite/issues/1177
func Test_SingleNodeParameterizedNamedConstraints(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
_, err := node.ExecuteParameterized([]interface{}{"CREATE TABLE [TestTable] ([Id] int primary key, [Col1] int not null, [Col2] varchar(500), [Col3] int not null, [Col4] varchar(500))"})
@ -519,7 +519,7 @@ func Test_SingleNodeParameterizedNamedConstraints(t *testing.T) {
}
func Test_SingleNodeRewriteRandom(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
_, err := node.Execute(`CREATE TABLE foo (id integer not null primary key, name text)`)
@ -539,7 +539,7 @@ func Test_SingleNodeRewriteRandom(t *testing.T) {
}
func Test_SingleNodeQueued(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
_, err := node.Execute(`CREATE TABLE foo (id integer not null primary key, name text)`)
@ -599,7 +599,7 @@ LOOP:
// Test_SingleNodeQueuedBadStmt tests that a single bad SQL statement has the right outcome.
func Test_SingleNodeQueuedBadStmt(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
node.Service.DefaultQueueTx = false
@ -675,7 +675,7 @@ LOOP2:
}
func Test_SingleNodeQueuedEmptyNil(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
_, err := node.Execute(`CREATE TABLE foo (id integer not null primary key, name text)`)
@ -742,7 +742,7 @@ func Test_SingleNodeQueuedEmptyNil(t *testing.T) {
// Test_SingleNodeSQLInjection demonstrates that using the non-parameterized API is vulnerable to
// SQL injection attacks.
func Test_SingleNodeSQLInjection(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
tests := []struct {
@ -797,7 +797,7 @@ func Test_SingleNodeSQLInjection(t *testing.T) {
// Test_SingleNodeNoSQLInjection demonstrates that using the parameterized API protects
// against SQL injection attacks.
func Test_SingleNodeNoSQLInjection(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
tests := []struct {
@ -855,7 +855,7 @@ func Test_SingleNodeUpgrades_NoSnapshots(t *testing.T) {
upgradeFrom := func(dir string) {
// Deprovision of a node deletes the node's dir, so make a copy first.
srcdir := filepath.Join("testdata", dir)
destdir := mustTempDir()
destdir := mustTempDir("")
if err := os.Remove(destdir); err != nil {
t.Fatalf("failed to remove dest dir: %s", err)
}
@ -867,7 +867,7 @@ func Test_SingleNodeUpgrades_NoSnapshots(t *testing.T) {
defer ln.Close()
raftDialer := tcp.NewDialer(cluster.MuxRaftHeader, nil)
clstrDialer := tcp.NewDialer(cluster.MuxClusterHeader, nil)
node := mustNodeEncrypted(destdir, true, false, mux, raftDialer, clstrDialer, "node1")
node := mustNodeEncrypted("node1", destdir, true, false, mux, raftDialer, clstrDialer)
defer node.Deprovision()
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader with %s data:", dir)
@ -915,7 +915,7 @@ func Test_SingleNodeUpgrades_Snapshots(t *testing.T) {
upgradeFrom := func(dir string) {
// Deprovision of a node deletes the node's dir, so make a copy first.
srcdir := filepath.Join("testdata", dir)
destdir := mustTempDir()
destdir := mustTempDir("")
if err := os.Remove(destdir); err != nil {
t.Fatalf("failed to remove dest dir: %s", err)
}
@ -927,7 +927,7 @@ func Test_SingleNodeUpgrades_Snapshots(t *testing.T) {
defer ln.Close()
raftDialer := tcp.NewDialer(cluster.MuxRaftHeader, nil)
clstrDialer := tcp.NewDialer(cluster.MuxClusterHeader, nil)
node := mustNodeEncrypted(destdir, true, false, mux, raftDialer, clstrDialer, "node1")
node := mustNodeEncrypted("node1", destdir, true, false, mux, raftDialer, clstrDialer)
defer node.Deprovision()
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader with %s data:", dir)
@ -966,7 +966,7 @@ func Test_SingleNodeUpgrades_Snapshots(t *testing.T) {
}
func Test_SingleNodeNodes(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
// Access endpoints to ensure the code is covered.
@ -994,7 +994,7 @@ func Test_SingleNodeNodes(t *testing.T) {
}
func Test_SingleNodeCoverage(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
// Access endpoints to ensure the code is covered.
@ -1020,12 +1020,12 @@ func Test_SingleNodeCoverage(t *testing.T) {
// Test_SingleNodeReopen tests that a node can be re-opened OK.
func Test_SingleNodeReopen(t *testing.T) {
dir := mustTempDir()
dir := mustTempDir("node1")
mux, ln := mustNewOpenMux("")
defer ln.Close()
raftDialer := tcp.NewDialer(cluster.MuxRaftHeader, nil)
clstrDialer := tcp.NewDialer(cluster.MuxClusterHeader, nil)
node := mustNodeEncrypted(dir, true, false, mux, raftDialer, clstrDialer, "")
node := mustNodeEncrypted("node1", dir, true, false, mux, raftDialer, clstrDialer)
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
@ -1055,12 +1055,12 @@ func Test_SingleNodeReopen(t *testing.T) {
// Test_SingleNodeReopen tests that a node can be re-opened OK, with
// a non-database command in the log.
func Test_SingleNodeNoopReopen(t *testing.T) {
dir := mustTempDir()
dir := mustTempDir("node1")
mux, ln := mustNewOpenMux("")
defer ln.Close()
raftDialer := tcp.NewDialer(cluster.MuxRaftHeader, nil)
clstrDialer := tcp.NewDialer(cluster.MuxClusterHeader, nil)
node := mustNodeEncrypted(dir, true, false, mux, raftDialer, clstrDialer, "")
node := mustNodeEncrypted("node1", dir, true, false, mux, raftDialer, clstrDialer)
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
@ -1138,12 +1138,12 @@ func Test_SingleNodeNoopReopen(t *testing.T) {
// This tests that the code can handle a snapshot that doesn't
// contain database data. This shouldn't happen in real systems
func Test_SingleNodeNoopSnapReopen(t *testing.T) {
dir := mustTempDir()
dir := mustTempDir("node1")
mux, ln := mustNewOpenMux("")
defer ln.Close()
raftDialer := tcp.NewDialer(cluster.MuxRaftHeader, nil)
clstrDialer := tcp.NewDialer(cluster.MuxClusterHeader, nil)
node := mustNodeEncrypted(dir, true, false, mux, raftDialer, clstrDialer, "")
node := mustNodeEncrypted("node1", dir, true, false, mux, raftDialer, clstrDialer)
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
@ -1226,12 +1226,12 @@ func Test_SingleNodeNoopSnapReopen(t *testing.T) {
// This tests that the code can handle a snapshot that doesn't
// contain database data. This shouldn't happen in real systems
func Test_SingleNodeNoopSnapLogsReopen(t *testing.T) {
dir := mustTempDir()
dir := mustTempDir("node1")
mux, ln := mustNewOpenMux("")
defer ln.Close()
raftDialer := tcp.NewDialer(cluster.MuxRaftHeader, nil)
clstrDialer := tcp.NewDialer(cluster.MuxClusterHeader, nil)
node := mustNodeEncrypted(dir, true, false, mux, raftDialer, clstrDialer, "")
node := mustNodeEncrypted("node1", dir, true, false, mux, raftDialer, clstrDialer)
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
@ -1312,7 +1312,7 @@ func Test_SingleNodeNoopSnapLogsReopen(t *testing.T) {
}
func Test_SingleNodeAutoRestore(t *testing.T) {
dir := mustTempDir()
dir := mustTempDir("node1")
node := &Node{
Dir: dir,
PeersPath: filepath.Join(dir, "raft/peers.json"),
@ -1327,7 +1327,7 @@ func Test_SingleNodeAutoRestore(t *testing.T) {
node.Store = store.New(raftTn, &store.Config{
DBConf: store.NewDBConfig(),
Dir: node.Dir,
ID: raftTn.Addr().String(),
ID: "node1",
})
restoreFile := mustTempFile()
@ -1378,7 +1378,7 @@ func Test_SingleNodeAutoRestore(t *testing.T) {
}
func Test_SingleNodeBoot_OK(t *testing.T) {
node := mustNewLeaderNode()
node := mustNewLeaderNode("leader1")
defer node.Deprovision()
_, err := node.Boot(filepath.Join("testdata", "auto-restore.sqlite"))
@ -1396,7 +1396,7 @@ func Test_SingleNodeBoot_OK(t *testing.T) {
}
func Test_SingleNodeBoot_FailNotLeader(t *testing.T) {
node := mustNewNode(false)
node := mustNewNode("node1", false)
defer node.Deprovision()
_, err := node.Boot(filepath.Join("testdata", "auto-restore.sqlite"))
if err == nil {

Write Preview
Loading…
Cancel
Save