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.4.0

Branches

Tags

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

Clone

HTTPS

Download ZIP

cloudflared/edgediscovery/allregions

edgediscovery/allregions/region_test.go

287lines · modecode

RawDownload
Latest commit unavailable.
1package allregions
2
3import (
4 "fmt"
5 "net"
6 "reflect"
7 "testing"
8)
9
10func TestRegion_New(t *testing.T) {
11 r := NewRegion([]*net.TCPAddr{&addr0, &addr1, &addr2})
12 fmt.Println(r.connFor)
13 if r.AvailableAddrs() != 3 {
14 t.Errorf("r.AvailableAddrs() == %v but want 3", r.AvailableAddrs())
15 }
16}
17
18func TestRegion_AddrUsedBy(t *testing.T) {
19 type fields struct {
20 connFor map[*net.TCPAddr]UsedBy
21 }
22 type args struct {
23 connID int
24 }
25 tests := []struct {
26 name string
27 fields fields
28 args args
29 want *net.TCPAddr
30 }{
31 {
32 name: "happy trivial test",
33 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
34 &addr0: InUse(0),
35 }},
36 args: args{connID: 0},
37 want: &addr0,
38 },
39 {
40 name: "sad trivial test",
41 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
42 &addr0: InUse(0),
43 }},
44 args: args{connID: 1},
45 want: nil,
46 },
47 {
48 name: "sad test",
49 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
50 &addr0: InUse(0),
51 &addr1: InUse(1),
52 &addr2: InUse(2),
53 }},
54 args: args{connID: 3},
55 want: nil,
56 },
57 {
58 name: "happy test",
59 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
60 &addr0: InUse(0),
61 &addr1: InUse(1),
62 &addr2: InUse(2),
63 }},
64 args: args{connID: 1},
65 want: &addr1,
66 },
67 }
68 for _, tt := range tests {
69 t.Run(tt.name, func(t *testing.T) {
70 r := &Region{
71 connFor: tt.fields.connFor,
72 }
73 if got := r.AddrUsedBy(tt.args.connID); !reflect.DeepEqual(got, tt.want) {
74 t.Errorf("Region.AddrUsedBy() = %v, want %v", got, tt.want)
75 }
76 })
77 }
78}
79
80func TestRegion_AvailableAddrs(t *testing.T) {
81 type fields struct {
82 connFor map[*net.TCPAddr]UsedBy
83 }
84 tests := []struct {
85 name string
86 fields fields
87 want int
88 }{
89 {
90 name: "contains addresses",
91 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
92 &addr0: InUse(0),
93 &addr1: Unused(),
94 &addr2: InUse(2),
95 }},
96 want: 1,
97 },
98 {
99 name: "all free",
100 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
101 &addr0: Unused(),
102 &addr1: Unused(),
103 &addr2: Unused(),
104 }},
105 want: 3,
106 },
107 {
108 name: "all used",
109 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
110 &addr0: InUse(0),
111 &addr1: InUse(1),
112 &addr2: InUse(2),
113 }},
114 want: 0,
115 },
116 {
117 name: "empty",
118 fields: fields{connFor: map[*net.TCPAddr]UsedBy{}},
119 want: 0,
120 },
121 }
122 for _, tt := range tests {
123 t.Run(tt.name, func(t *testing.T) {
124 r := Region{
125 connFor: tt.fields.connFor,
126 }
127 if got := r.AvailableAddrs(); got != tt.want {
128 t.Errorf("Region.AvailableAddrs() = %v, want %v", got, tt.want)
129 }
130 })
131 }
132}
133
134func TestRegion_GetUnusedIP(t *testing.T) {
135 type fields struct {
136 connFor map[*net.TCPAddr]UsedBy
137 }
138 type args struct {
139 excluding *net.TCPAddr
140 }
141 tests := []struct {
142 name string
143 fields fields
144 args args
145 want *net.TCPAddr
146 }{
147 {
148 name: "happy test with excluding set",
149 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
150 &addr0: Unused(),
151 &addr1: Unused(),
152 &addr2: InUse(2),
153 }},
154 args: args{excluding: &addr0},
155 want: &addr1,
156 },
157 {
158 name: "happy test with no excluding",
159 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
160 &addr0: InUse(0),
161 &addr1: Unused(),
162 &addr2: InUse(2),
163 }},
164 args: args{excluding: nil},
165 want: &addr1,
166 },
167 {
168 name: "sad test with no excluding",
169 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
170 &addr0: InUse(0),
171 &addr1: InUse(1),
172 &addr2: InUse(2),
173 }},
174 args: args{excluding: nil},
175 want: nil,
176 },
177 {
178 name: "sad test with excluding",
179 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
180 &addr0: Unused(),
181 &addr1: InUse(1),
182 &addr2: InUse(2),
183 }},
184 args: args{excluding: &addr0},
185 want: nil,
186 },
187 }
188 for _, tt := range tests {
189 t.Run(tt.name, func(t *testing.T) {
190 r := Region{
191 connFor: tt.fields.connFor,
192 }
193 if got := r.GetUnusedIP(tt.args.excluding); !reflect.DeepEqual(got, tt.want) {
194 t.Errorf("Region.GetUnusedIP() = %v, want %v", got, tt.want)
195 }
196 })
197 }
198}
199
200func TestRegion_GiveBack(t *testing.T) {
201 type fields struct {
202 connFor map[*net.TCPAddr]UsedBy
203 }
204 type args struct {
205 addr *net.TCPAddr
206 }
207 tests := []struct {
208 name string
209 fields fields
210 args args
211 wantOk bool
212 availableAfter int
213 }{
214 {
215 name: "sad test with excluding",
216 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
217 &addr1: InUse(1),
218 }},
219 args: args{addr: &addr1},
220 wantOk: true,
221 availableAfter: 1,
222 },
223 {
224 name: "sad test with excluding",
225 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
226 &addr1: InUse(1),
227 }},
228 args: args{addr: &addr2},
229 wantOk: false,
230 availableAfter: 0,
231 },
232 }
233 for _, tt := range tests {
234 t.Run(tt.name, func(t *testing.T) {
235 r := Region{
236 connFor: tt.fields.connFor,
237 }
238 if gotOk := r.GiveBack(tt.args.addr); gotOk != tt.wantOk {
239 t.Errorf("Region.GiveBack() = %v, want %v", gotOk, tt.wantOk)
240 }
241 if tt.availableAfter != r.AvailableAddrs() {
242 t.Errorf("Region.AvailableAddrs() = %v, want %v", r.AvailableAddrs(), tt.availableAfter)
243 }
244 })
245 }
246}
247
248func TestRegion_GetAnyAddress(t *testing.T) {
249 type fields struct {
250 connFor map[*net.TCPAddr]UsedBy
251 }
252 tests := []struct {
253 name string
254 fields fields
255 wantNil bool
256 }{
257 {
258 name: "Sad test -- GetAnyAddress should only fail if the region is empty",
259 fields: fields{connFor: map[*net.TCPAddr]UsedBy{}},
260 wantNil: true,
261 },
262 {
263 name: "Happy test (all addresses unused)",
264 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
265 &addr0: Unused(),
266 }},
267 wantNil: false,
268 },
269 {
270 name: "Happy test (GetAnyAddress can still return addresses used by proxy conns)",
271 fields: fields{connFor: map[*net.TCPAddr]UsedBy{
272 &addr0: InUse(2),
273 }},
274 wantNil: false,
275 },
276 }
277 for _, tt := range tests {
278 t.Run(tt.name, func(t *testing.T) {
279 r := Region{
280 connFor: tt.fields.connFor,
281 }
282 if got := r.GetAnyAddress(); tt.wantNil != (got == nil) {
283 t.Errorf("Region.GetAnyAddress() = %v, but should it return nil? %v", got, tt.wantNil)
284 }
285 })
286 }
287}
288