GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

cloudflare/cloudflared

Public

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

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
2021.10.2

Branches

Tags

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

Clone

HTTPS

Download ZIP

cloudflared/edgediscovery/allregions

edgediscovery/allregions/regions_test.go

181lines · modecode

RawDownload
Latest commit unavailable.
1package allregions
2
3import (
4 "net"
5 "testing"
6
7 "github.com/stretchr/testify/assert"
8)
9
10var (
11 addr0 = EdgeAddr{
12 TCP: &net.TCPAddr{
13 IP: net.ParseIP("123.4.5.0"),
14 Port: 8000,
15 Zone: "",
16 },
17 UDP: &net.UDPAddr{
18 IP: net.ParseIP("123.4.5.0"),
19 Port: 8000,
20 Zone: "",
21 },
22 }
23 addr1 = EdgeAddr{
24 TCP: &net.TCPAddr{
25 IP: net.ParseIP("123.4.5.1"),
26 Port: 8000,
27 Zone: "",
28 },
29 UDP: &net.UDPAddr{
30 IP: net.ParseIP("123.4.5.1"),
31 Port: 8000,
32 Zone: "",
33 },
34 }
35 addr2 = EdgeAddr{
36 TCP: &net.TCPAddr{
37 IP: net.ParseIP("123.4.5.2"),
38 Port: 8000,
39 Zone: "",
40 },
41 UDP: &net.UDPAddr{
42 IP: net.ParseIP("123.4.5.2"),
43 Port: 8000,
44 Zone: "",
45 },
46 }
47 addr3 = EdgeAddr{
48 TCP: &net.TCPAddr{
49 IP: net.ParseIP("123.4.5.3"),
50 Port: 8000,
51 Zone: "",
52 },
53 UDP: &net.UDPAddr{
54 IP: net.ParseIP("123.4.5.3"),
55 Port: 8000,
56 Zone: "",
57 },
58 }
59)
60
61func makeRegions() Regions {
62 r1 := NewRegion([]*EdgeAddr{&addr0, &addr1})
63 r2 := NewRegion([]*EdgeAddr{&addr2, &addr3})
64 return Regions{region1: r1, region2: r2}
65}
66
67func TestRegions_AddrUsedBy(t *testing.T) {
68 rs := makeRegions()
69 addr1 := rs.GetUnusedAddr(nil, 1)
70 assert.Equal(t, addr1, rs.AddrUsedBy(1))
71 addr2 := rs.GetUnusedAddr(nil, 2)
72 assert.Equal(t, addr2, rs.AddrUsedBy(2))
73 addr3 := rs.GetUnusedAddr(nil, 3)
74 assert.Equal(t, addr3, rs.AddrUsedBy(3))
75}
76
77func TestRegions_Giveback_Region1(t *testing.T) {
78 rs := makeRegions()
79 rs.region1.Use(&addr0, 0)
80 rs.region1.Use(&addr1, 1)
81 rs.region2.Use(&addr2, 2)
82 rs.region2.Use(&addr3, 3)
83
84 assert.Equal(t, 0, rs.AvailableAddrs())
85
86 rs.GiveBack(&addr0)
87 assert.Equal(t, &addr0, rs.GetUnusedAddr(nil, 3))
88}
89
90func TestRegions_Giveback_Region2(t *testing.T) {
91 rs := makeRegions()
92 rs.region1.Use(&addr0, 0)
93 rs.region1.Use(&addr1, 1)
94 rs.region2.Use(&addr2, 2)
95 rs.region2.Use(&addr3, 3)
96
97 assert.Equal(t, 0, rs.AvailableAddrs())
98
99 rs.GiveBack(&addr2)
100 assert.Equal(t, &addr2, rs.GetUnusedAddr(nil, 2))
101}
102
103func TestRegions_GetUnusedAddr_OneAddrLeft(t *testing.T) {
104 rs := makeRegions()
105
106 rs.region1.Use(&addr0, 0)
107 rs.region1.Use(&addr1, 1)
108 rs.region2.Use(&addr2, 2)
109
110 assert.Equal(t, 1, rs.AvailableAddrs())
111 assert.Equal(t, &addr3, rs.GetUnusedAddr(nil, 3))
112}
113
114func TestRegions_GetUnusedAddr_Excluding_Region1(t *testing.T) {
115 rs := makeRegions()
116
117 rs.region1.Use(&addr0, 0)
118 rs.region1.Use(&addr1, 1)
119
120 assert.Equal(t, 2, rs.AvailableAddrs())
121 assert.Equal(t, &addr3, rs.GetUnusedAddr(&addr2, 3))
122}
123
124func TestRegions_GetUnusedAddr_Excluding_Region2(t *testing.T) {
125 rs := makeRegions()
126
127 rs.region2.Use(&addr2, 0)
128 rs.region2.Use(&addr3, 1)
129
130 assert.Equal(t, 2, rs.AvailableAddrs())
131 assert.Equal(t, &addr1, rs.GetUnusedAddr(&addr0, 1))
132}
133
134func TestNewNoResolveBalancesRegions(t *testing.T) {
135 type args struct {
136 addrs []*EdgeAddr
137 }
138 tests := []struct {
139 name string
140 args args
141 }{
142 {
143 name: "one address",
144 args: args{addrs: []*EdgeAddr{&addr0}},
145 },
146 {
147 name: "two addresses",
148 args: args{addrs: []*EdgeAddr{&addr0, &addr1}},
149 },
150 }
151 for _, tt := range tests {
152 t.Run(tt.name, func(t *testing.T) {
153 regions := NewNoResolve(tt.args.addrs)
154 RegionsIsBalanced(t, regions)
155 })
156 }
157}
158
159func TestGetRegionalServiceName(t *testing.T) {
160 // Empty region should just go to origintunneld
161 globalServiceName := getRegionalServiceName("")
162 assert.Equal(t, srvService, globalServiceName)
163
164 // Non-empty region should go to the regional origintunneld variant
165 for _, region := range []string{"us", "pt", "am"} {
166 regionalServiceName := getRegionalServiceName(region)
167 assert.Equal(t, region+"-"+srvService, regionalServiceName)
168 }
169}
170
171func RegionsIsBalanced(t *testing.T, rs *Regions) {
172 delta := rs.region1.AvailableAddrs() - rs.region2.AvailableAddrs()
173 assert.True(t, abs(delta) <= 1)
174}
175
176func abs(x int) int {
177 if x >= 0 {
178 return x
179 }
180 return -x
181}
182