GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

cloudflare/cloudflared

Public

mirrored from https://github.com/cloudflare/cloudflaredAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
2020.3.0

Branches

Tags

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

Clone

HTTPS

Download ZIP

cloudflared/edgediscovery

edgediscovery/edgediscovery_test.go

148lines · modecode

RawDownload
Latest commit unavailable.
1package edgediscovery
2
3import (
4 "net"
5 "testing"
6
7 "github.com/sirupsen/logrus"
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 := logrus.New()
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 := logrus.New()
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 := logrus.New()
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 TestOnlyOneAddrLeft(t *testing.T) {
87 l := logrus.New()
88
89 // Make an edge with only one address
90 edge := MockEdge(l, []*net.TCPAddr{&addr0})
91
92 // Use the only address
93 const connID = 0
94 addr, err := edge.GetAddr(connID)
95 assert.NoError(t, err)
96 assert.NotNil(t, addr)
97
98 // If that edge address is "bad", there's no alternative address.
99 _, err = edge.GetDifferentAddr(connID)
100 assert.Error(t, err)
101}
102
103func TestNoAddrsLeft(t *testing.T) {
104 l := logrus.New()
105
106 // Make an edge with no addresses
107 edge := MockEdge(l, []*net.TCPAddr{})
108
109 _, err := edge.GetAddr(2)
110 assert.Error(t, err)
111 _, err = edge.GetAddrForRPC()
112 assert.Error(t, err)
113}
114
115func TestGetAddr(t *testing.T) {
116 l := logrus.New()
117 edge := MockEdge(l, []*net.TCPAddr{&addr0, &addr1, &addr2, &addr3})
118
119 // Give this connection an address
120 const connID = 0
121 addr, err := edge.GetAddr(connID)
122 assert.NoError(t, err)
123 assert.NotNil(t, addr)
124
125 // If the same connection requests another address, it should get the same one.
126 addr2, err := edge.GetAddr(connID)
127 assert.NoError(t, err)
128 assert.Equal(t, addr, addr2)
129}
130
131func TestGetDifferentAddr(t *testing.T) {
132 l := logrus.New()
133 edge := MockEdge(l, []*net.TCPAddr{&addr0, &addr1, &addr2, &addr3})
134
135 // Give this connection an address
136 assert.Equal(t, 4, edge.AvailableAddrs())
137 const connID = 0
138 addr, err := edge.GetAddr(connID)
139 assert.NoError(t, err)
140 assert.NotNil(t, addr)
141 assert.Equal(t, 3, edge.AvailableAddrs())
142
143 // If the same connection requests another address, it should get the same one.
144 addr2, err := edge.GetDifferentAddr(connID)
145 assert.NoError(t, err)
146 assert.NotEqual(t, addr, addr2)
147 assert.Equal(t, 3, edge.AvailableAddrs())
148}
149