GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

cloudflare/cloudflared

Public

mirrored fromhttps://github.com/cloudflare/cloudflaredAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
2020.6.0

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

cloudflared/edgediscovery

edgediscovery/edgediscovery_test.go

177lines · modecode

RawDownload
Latest commit unavailable.
1package edgediscovery
2
3import (
4 "net"
5 "testing"
6
7 "github.com/cloudflare/cloudflared/logger"
8 "github.com/stretchr/testify/assert"
9)
10
11var (
12 addr0 = net.TCPAddr{
13 IP: net.ParseIP("123.0.0.0"),
14 Port: 8000,
15 Zone: "",
16 }
17 addr1 = net.TCPAddr{
18 IP: net.ParseIP("123.0.0.1"),
19 Port: 8000,
20 Zone: "",
21 }
22 addr2 = net.TCPAddr{
23 IP: net.ParseIP("123.0.0.2"),
24 Port: 8000,
25 Zone: "",
26 }
27 addr3 = net.TCPAddr{
28 IP: net.ParseIP("123.0.0.3"),
29 Port: 8000,
30 Zone: "",
31 }
32)
33
34func TestGiveBack(t *testing.T) {
35 l := logger.NewOutputWriter(logger.NewMockWriteManager())
36 edge := MockEdge(l, []*net.TCPAddr{&addr0, &addr1, &addr2, &addr3})
37
38 // Give this connection an address
39 assert.Equal(t, 4, edge.AvailableAddrs())
40 const connID = 0
41 addr, err := edge.GetAddr(connID)
42 assert.NoError(t, err)
43 assert.NotNil(t, addr)
44 assert.Equal(t, 3, edge.AvailableAddrs())
45
46 // Get it back
47 edge.GiveBack(addr)
48 assert.Equal(t, 4, edge.AvailableAddrs())
49}
50
51func TestRPCAndProxyShareSingleEdgeIP(t *testing.T) {
52 l := logger.NewOutputWriter(logger.NewMockWriteManager())
53
54 // Make an edge with a single IP
55 edge := MockEdge(l, []*net.TCPAddr{&addr0})
56 tunnelConnID := 0
57
58 // Use the IP for a tunnel
59 addrTunnel, err := edge.GetAddr(tunnelConnID)
60 assert.NoError(t, err)
61
62 // Ensure the IP can be used for RPC too
63 addrRPC, err := edge.GetAddrForRPC()
64 assert.NoError(t, err)
65 assert.Equal(t, addrTunnel, addrRPC)
66}
67
68func TestGetAddrForRPC(t *testing.T) {
69 l := logger.NewOutputWriter(logger.NewMockWriteManager())
70 edge := MockEdge(l, []*net.TCPAddr{&addr0, &addr1, &addr2, &addr3})
71
72 // Get a connection
73 assert.Equal(t, 4, edge.AvailableAddrs())
74 addr, err := edge.GetAddrForRPC()
75 assert.NoError(t, err)
76 assert.NotNil(t, addr)
77
78 // Using an address for RPC shouldn't consume it
79 assert.Equal(t, 4, edge.AvailableAddrs())
80
81 // Get it back
82 edge.GiveBack(addr)
83 assert.Equal(t, 4, edge.AvailableAddrs())
84}
85
86func TestOnePerRegion(t *testing.T) {
87 l := logger.NewOutputWriter(logger.NewMockWriteManager())
88
89 // Make an edge with only one address
90 edge := MockEdge(l, []*net.TCPAddr{&addr0, &addr1})
91
92 // Use the only address
93 const connID = 0
94 a1, err := edge.GetAddr(connID)
95 assert.NoError(t, err)
96 assert.NotNil(t, a1)
97
98 // if the first address is bad, get the second one
99 a2, err := edge.GetDifferentAddr(connID)
100 assert.NoError(t, err)
101 assert.NotNil(t, a2)
102 assert.NotEqual(t, a1, a2)
103
104 // now that second one is bad, get the first one again
105 a3, err := edge.GetDifferentAddr(connID)
106 assert.NoError(t, err)
107 assert.Equal(t, a1, a3)
108}
109
110func TestOnlyOneAddrLeft(t *testing.T) {
111 l := logger.NewOutputWriter(logger.NewMockWriteManager())
112
113 // Make an edge with only one address
114 edge := MockEdge(l, []*net.TCPAddr{&addr0})
115
116 // Use the only address
117 const connID = 0
118 addr, err := edge.GetAddr(connID)
119 assert.NoError(t, err)
120 assert.NotNil(t, addr)
121
122 // If that edge address is "bad", there's no alternative address.
123 _, err = edge.GetDifferentAddr(connID)
124 assert.Error(t, err)
125
126 // previously bad address should become available again on next iteration.
127 addr, err = edge.GetDifferentAddr(connID)
128 assert.NoError(t, err)
129 assert.NotNil(t, addr)
130}
131
132func TestNoAddrsLeft(t *testing.T) {
133 l := logger.NewOutputWriter(logger.NewMockWriteManager())
134
135 // Make an edge with no addresses
136 edge := MockEdge(l, []*net.TCPAddr{})
137
138 _, err := edge.GetAddr(2)
139 assert.Error(t, err)
140 _, err = edge.GetAddrForRPC()
141 assert.Error(t, err)
142}
143
144func TestGetAddr(t *testing.T) {
145 l := logger.NewOutputWriter(logger.NewMockWriteManager())
146 edge := MockEdge(l, []*net.TCPAddr{&addr0, &addr1, &addr2, &addr3})
147
148 // Give this connection an address
149 const connID = 0
150 addr, err := edge.GetAddr(connID)
151 assert.NoError(t, err)
152 assert.NotNil(t, addr)
153
154 // If the same connection requests another address, it should get the same one.
155 addr2, err := edge.GetAddr(connID)
156 assert.NoError(t, err)
157 assert.Equal(t, addr, addr2)
158}
159
160func TestGetDifferentAddr(t *testing.T) {
161 l := logger.NewOutputWriter(logger.NewMockWriteManager())
162 edge := MockEdge(l, []*net.TCPAddr{&addr0, &addr1, &addr2, &addr3})
163
164 // Give this connection an address
165 assert.Equal(t, 4, edge.AvailableAddrs())
166 const connID = 0
167 addr, err := edge.GetAddr(connID)
168 assert.NoError(t, err)
169 assert.NotNil(t, addr)
170 assert.Equal(t, 3, edge.AvailableAddrs())
171
172 // If the same connection requests another address, it should get the same one.
173 addr2, err := edge.GetDifferentAddr(connID)
174 assert.NoError(t, err)
175 assert.NotEqual(t, addr, addr2)
176 assert.Equal(t, 3, edge.AvailableAddrs())
177}
178