wip e2e tests

checked_node_test.go

@@ -100,11 +100,11 @@ func TestCheckNodes(t *testing.T) {
 			}
 
 			switch mq.name {
-			case "primary":
+			case node1.db.name:
 				return NodeInfo{ClusterRole: NodeRolePrimary, NetworkLatency: 100}, nil
-			case "standby1":
+			case node2.db.name:
 				return NodeInfo{ClusterRole: NodeRoleStandby, NetworkLatency: 50}, nil
-			case "standby2":
+			case node3.db.name:
 				return NodeInfo{ClusterRole: NodeRoleStandby, NetworkLatency: 70}, nil
 			default:
 				return NodeInfo{}, nil
@@ -204,11 +204,11 @@ func TestCheckNodes(t *testing.T) {
 			}
 
 			switch mq.name {
-			case "primary":
+			case node1.db.name:
 				return NodeInfo{ClusterRole: NodeRolePrimary, NetworkLatency: 100}, nil
-			case "standby1":
+			case node2.db.name:
 				return NodeInfo{ClusterRole: NodeRoleStandby, NetworkLatency: 50}, nil
-			case "standby2":
+			case node3.db.name:
 				return nil, io.EOF
 			default:
 				return NodeInfo{}, nil
@@ -266,11 +266,11 @@ func TestCheckNodes(t *testing.T) {
 			}
 
 			switch mq.name {
-			case "primary":
+			case node1.db.name:
 				return nil, io.EOF
-			case "standby1":
+			case node2.db.name:
 				return NodeInfo{ClusterRole: NodeRoleStandby, NetworkLatency: 70}, nil
-			case "standby2":
+			case node3.db.name:
 				return NodeInfo{ClusterRole: NodeRoleStandby, NetworkLatency: 50}, nil
 			default:
 				return NodeInfo{}, nil

cluster_test.go

@@ -37,11 +37,9 @@ func TestNewCluster(t *testing.T) {
 		db, _, err := sqlmock.New()
 		require.NoError(t, err)
 
-		nodes := []*Node[*sql.DB]{
-			NewNode("shimba", db),
-		}
+		node := NewNode("shimba", db)
 
-		cl, err := NewCluster(NewStaticNodeDiscoverer(nodes), PostgreSQLChecker)
+		cl, err := NewCluster(NewStaticNodeDiscoverer(node), PostgreSQLChecker)
 		assert.NoError(t, err)
 		assert.NotNil(t, cl)
 	})
@@ -59,16 +57,14 @@ func TestCluster_Close(t *testing.T) {
 		dbmock1.ExpectClose()
 		dbmock2.ExpectClose()
 
-		nodes := []*Node[*sql.DB]{
-			NewNode("shimba", db1),
-			NewNode("boomba", db2),
-		}
+		node1 := NewNode("shimba", db1)
+		node2 := NewNode("boomba", db2)
 
-		cl, err := NewCluster(NewStaticNodeDiscoverer(nodes), PostgreSQLChecker)
+		cl, err := NewCluster(NewStaticNodeDiscoverer(node1, node2), PostgreSQLChecker)
 		require.NoError(t, err)
 
 		cl.checkedNodes.Store(CheckedNodes[*sql.DB]{
-			discovered: nodes,
+			discovered: []*Node[*sql.DB]{node1, node2},
 		})
 
 		assert.NoError(t, cl.Close())
@@ -85,16 +81,14 @@ func TestCluster_Close(t *testing.T) {
 		dbmock1.ExpectClose().WillReturnError(io.EOF)
 		dbmock2.ExpectClose().WillReturnError(sql.ErrTxDone)
 
-		nodes := []*Node[*sql.DB]{
-			NewNode("shimba", db1),
-			NewNode("boomba", db2),
-		}
+		node1 := NewNode("shimba", db1)
+		node2 := NewNode("boomba", db2)
 
-		cl, err := NewCluster(NewStaticNodeDiscoverer(nodes), PostgreSQLChecker)
+		cl, err := NewCluster(NewStaticNodeDiscoverer(node1, node2), PostgreSQLChecker)
 		require.NoError(t, err)
 
 		cl.checkedNodes.Store(CheckedNodes[*sql.DB]{
-			discovered: nodes,
+			discovered: []*Node[*sql.DB]{node1, node2},
 		})
 
 		err = cl.Close()

e2e_test.go

@@ -0,0 +1,80 @@
+/*
+   Copyright 2020 YANDEX LLC
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package hasql_test
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+	"time"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"golang.yandex/hasql/v2"
+)
+
+// TestEnd2End_AliveCluster setups 3 node cluster, waits for at least one
+// alive node, then picks primary and secondary node. Nodes are always alive.
+func TestEnd2End_AliveCluster(t *testing.T) {
+	// create three database pools
+	db1, mock1, err := sqlmock.New()
+	require.NoError(t, err)
+	db2, mock2, err := sqlmock.New()
+	require.NoError(t, err)
+	db3, mock3, err := sqlmock.New()
+	require.NoError(t, err)
+
+	// set db1 to be primary node
+	primaryRows := sqlmock.NewRows([]string{"role", "lag"}).AddRow(0, 0)
+	mock1.ExpectQuery(`SELECT.*pg_is_in_recovery`).WillReturnRows(primaryRows)
+
+	// set db2 and db3 to be standby nodes
+	standbyRows := sqlmock.NewRows([]string{"role", "lag"}).AddRow(1, 0)
+	mock2.ExpectQuery(`SELECT.*pg_is_in_recovery`).WillReturnRows(standbyRows)
+	mock3.ExpectQuery(`SELECT.*pg_is_in_recovery`).WillReturnRows(standbyRows)
+
+	// all pools must be closed in the end
+	mock1.ExpectClose()
+	mock2.ExpectClose()
+	mock3.ExpectClose()
+
+	// register pools as nodes
+	node1 := hasql.NewNode("ololo", db1)
+	node2 := hasql.NewNode("trololo", db2)
+	node3 := hasql.NewNode("shimba", db3)
+	discoverer := hasql.NewStaticNodeDiscoverer(node1, node2, node3)
+
+	// create test cluster
+	cl, err := hasql.NewCluster(discoverer, hasql.PostgreSQLChecker,
+		hasql.WithUpdateInterval[*sql.DB](10*time.Millisecond),
+	)
+	require.NoError(t, err)
+
+	// close cluster and all underlying pools in the end
+	defer func() {
+		assert.NoError(t, cl.Close())
+	}()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	// wait for any alive node
+	waitNode, err := cl.WaitForNode(ctx, hasql.Alive)
+	assert.NoError(t, err)
+	assert.Contains(t, []*hasql.Node[*sql.DB]{node1, node2, node3}, waitNode)
+}

node_discoverer.go

@@ -37,7 +37,7 @@ type StaticNodeDiscoverer[T Querier] struct {
 }
 
 // NewStaticNodeDiscoverer returns new staticNodeDiscoverer instance
-func NewStaticNodeDiscoverer[T Querier](nodes []*Node[T]) StaticNodeDiscoverer[T] {
+func NewStaticNodeDiscoverer[T Querier](nodes ...*Node[T]) StaticNodeDiscoverer[T] {
 	return StaticNodeDiscoverer[T]{nodes: nodes}
 }
 

node_discoverer_test.go

@@ -25,28 +25,24 @@ import (
 )
 
 func TestNewStaticNodeDiscoverer(t *testing.T) {
-	nodes := []*Node[*sql.DB]{
-		NewNode("shimba", new(sql.DB)),
-		NewNode("boomba", new(sql.DB)),
-	}
+	node1 := NewNode("shimba", new(sql.DB))
+	node2 := NewNode("boomba", new(sql.DB))
 
-	d := NewStaticNodeDiscoverer(nodes)
+	d := NewStaticNodeDiscoverer(node1, node2)
 	expected := StaticNodeDiscoverer[*sql.DB]{
-		nodes: nodes,
+		nodes: []*Node[*sql.DB]{node1, node2},
 	}
 
 	assert.Equal(t, expected, d)
 }
 
 func TestStaticNodeDiscoverer_DiscoverNodes(t *testing.T) {
-	nodes := []*Node[*sql.DB]{
-		NewNode("shimba", new(sql.DB)),
-		NewNode("boomba", new(sql.DB)),
-	}
+	node1 := NewNode("shimba", new(sql.DB))
+	node2 := NewNode("boomba", new(sql.DB))
 
-	d := NewStaticNodeDiscoverer(nodes)
+	d := NewStaticNodeDiscoverer(node1, node2)
 
 	discovered, err := d.DiscoverNodes(context.Background())
 	assert.NoError(t, err)
-	assert.Equal(t, nodes, discovered)
+	assert.Equal(t, []*Node[*sql.DB]{node1, node2}, discovered)
 }