chainlink-framework/multinode/node_selector_random_rpc_test.go at 6b8bcaa1313da1250e202af66c7e611be0392bf7 · smartcontractkit/chainlink-framework · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package multinode

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestRandomRPCNodeSelectorName(t *testing.T) {
	selector := newNodeSelector[ID, RPCClient[ID, Head]](NodeSelectionModeRandomRPC, nil)
	assert.Equal(t, NodeSelectionModeRandomRPC, selector.Name())
}

func TestRandomRPCNodeSelector(t *testing.T) {
	t.Parallel()

	type nodeClient RPCClient[ID, Head]
	var nodes []Node[ID, nodeClient]

	for i := 0; i < 3; i++ {
		node := newMockNode[ID, nodeClient](t)
		if i == 0 {
			node.On("State").Return(nodeStateOutOfSync)
			node.On("UnsubscribeAllExceptAliveLoop")
		} else {
			node.On("State").Return(nodeStateAlive)
		}
		nodes = append(nodes, node)
	}

	selector := newNodeSelector(NodeSelectionModeRandomRPC, nodes)

	// All selections should be from alive nodes only
	for i := 0; i < 20; i++ {
		selected := selector.Select()
		assert.NotNil(t, selected)
		assert.Contains(t, []Node[ID, nodeClient]{nodes[1], nodes[2]}, selected)
	}
}

func TestRandomRPCNodeSelector_None(t *testing.T) {
	t.Parallel()

	type nodeClient RPCClient[ID, Head]
	var nodes []Node[ID, nodeClient]

	for i := 0; i < 3; i++ {
		node := newMockNode[ID, nodeClient](t)
		if i == 0 {
			node.On("State").Return(nodeStateOutOfSync)
		} else {
			node.On("State").Return(nodeStateUnreachable)
		}
		node.On("UnsubscribeAllExceptAliveLoop")
		nodes = append(nodes, node)
	}

	selector := newNodeSelector(NodeSelectionModeRandomRPC, nodes)
	assert.Nil(t, selector.Select())
}

func TestRandomRPCNodeSelector_Distribution(t *testing.T) {
	t.Parallel()

	type nodeClient RPCClient[ID, Head]
	var nodes []Node[ID, nodeClient]

	const nAlive = 3
	for i := 0; i < nAlive; i++ {
		node := newMockNode[ID, nodeClient](t)
		node.On("State").Return(nodeStateAlive)
		nodes = append(nodes, node)
	}

	selector := newNodeSelector(NodeSelectionModeRandomRPC, nodes)

	const iterations = 1000
	counts := make(map[Node[ID, nodeClient]]int, nAlive)
	for i := 0; i < iterations; i++ {
		selected := selector.Select()
		assert.NotNil(t, selected)
		counts[selected]++
	}

	// Each node should be selected at least once with overwhelming probability
	for _, n := range nodes {
		assert.Positive(t, counts[n], "expected every alive node to be selected at least once")
	}
}

func TestRandomRPCNodeSelector_SingleNode(t *testing.T) {
	t.Parallel()

	type nodeClient RPCClient[ID, Head]

	node := newMockNode[ID, nodeClient](t)
	node.On("State").Return(nodeStateAlive)

	selector := newNodeSelector(NodeSelectionModeRandomRPC, []Node[ID, nodeClient]{node})

	for i := 0; i < 5; i++ {
		assert.Same(t, node, selector.Select())
	}
}