Skip to content

Commit af2e4a9

Browse files
schzhnschzhn
committed
proxy: imp naming
1 parent b877057 commit af2e4a9

File tree

1 file changed

+92
-92
lines changed

1 file changed

+92
-92
lines changed

Diff for: ‎proxy/stats_test.go

+92-92
Original file line numberDiff line numberDiff line change
@@ -64,155 +64,155 @@ func TestCollectQueryStats(t *testing.T) {
6464
}
6565

6666
testCases := []struct {
67-
isExchangeErr assert.BoolAssertionFunc
68-
config *proxy.UpstreamConfig
69-
fallbackConfig *proxy.UpstreamConfig
70-
name string
71-
mode proxy.UpstreamMode
72-
mainCount int
73-
fallbackCount int
74-
isMainErr bool
75-
isFallbackErr bool
67+
wantErr assert.ErrorAssertionFunc
68+
wantMainErr assert.BoolAssertionFunc
69+
wantFallbackErr assert.BoolAssertionFunc
70+
config *proxy.UpstreamConfig
71+
fallbackConfig *proxy.UpstreamConfig
72+
name string
73+
mode proxy.UpstreamMode
74+
wantMainCount int
75+
wantFallbackCount int
7676
}{{
77-
isExchangeErr: assert.False,
77+
wantErr: assert.NoError,
78+
wantMainErr: assert.False,
79+
wantFallbackErr: assert.False,
7880
config: &proxy.UpstreamConfig{
7981
Upstreams: []upstream.Upstream{ups},
8082
},
8183
fallbackConfig: &proxy.UpstreamConfig{
8284
Upstreams: []upstream.Upstream{ups},
8385
},
84-
name: "load_balance_success",
85-
mode: proxy.UpstreamModeLoadBalance,
86-
mainCount: 1,
87-
fallbackCount: 0,
88-
isMainErr: false,
89-
isFallbackErr: false,
86+
name: "load_balance_success",
87+
mode: proxy.UpstreamModeLoadBalance,
88+
wantMainCount: 1,
89+
wantFallbackCount: 0,
9090
}, {
91-
isExchangeErr: assert.True,
91+
wantErr: assert.Error,
92+
wantMainErr: assert.True,
93+
wantFallbackErr: assert.True,
9294
config: &proxy.UpstreamConfig{
9395
Upstreams: []upstream.Upstream{failUps},
9496
},
9597
fallbackConfig: &proxy.UpstreamConfig{
9698
Upstreams: []upstream.Upstream{failUps, failUps},
9799
},
98-
name: "load_balance_bad",
99-
mode: proxy.UpstreamModeLoadBalance,
100-
mainCount: 1,
101-
fallbackCount: 2,
102-
isMainErr: true,
103-
isFallbackErr: true,
100+
name: "load_balance_bad",
101+
mode: proxy.UpstreamModeLoadBalance,
102+
wantMainCount: 1,
103+
wantFallbackCount: 2,
104104
}, {
105-
isExchangeErr: assert.False,
105+
wantErr: assert.NoError,
106+
wantMainErr: assert.False,
107+
wantFallbackErr: assert.False,
106108
config: &proxy.UpstreamConfig{
107109
Upstreams: []upstream.Upstream{ups, failUps},
108110
},
109111
fallbackConfig: &proxy.UpstreamConfig{
110112
Upstreams: []upstream.Upstream{ups},
111113
},
112-
name: "parallel_success",
113-
mode: proxy.UpstreamModeParallel,
114-
mainCount: 1,
115-
fallbackCount: 0,
116-
isMainErr: false,
117-
isFallbackErr: false,
114+
name: "parallel_success",
115+
mode: proxy.UpstreamModeParallel,
116+
wantMainCount: 1,
117+
wantFallbackCount: 0,
118118
}, {
119-
isExchangeErr: assert.False,
119+
wantErr: assert.NoError,
120+
wantMainErr: assert.True,
121+
wantFallbackErr: assert.False,
120122
config: &proxy.UpstreamConfig{
121123
Upstreams: []upstream.Upstream{failUps},
122124
},
123125
fallbackConfig: &proxy.UpstreamConfig{
124126
Upstreams: []upstream.Upstream{ups},
125127
},
126-
name: "parallel_bad_fallback_success",
127-
mode: proxy.UpstreamModeParallel,
128-
mainCount: 1,
129-
fallbackCount: 1,
130-
isMainErr: true,
131-
isFallbackErr: false,
128+
name: "parallel_bad_fallback_success",
129+
mode: proxy.UpstreamModeParallel,
130+
wantMainCount: 1,
131+
wantFallbackCount: 1,
132132
}, {
133-
isExchangeErr: assert.True,
133+
wantErr: assert.Error,
134+
wantMainErr: assert.True,
135+
wantFallbackErr: assert.True,
134136
config: &proxy.UpstreamConfig{
135137
Upstreams: []upstream.Upstream{failUps, failUps},
136138
},
137139
fallbackConfig: &proxy.UpstreamConfig{
138140
Upstreams: []upstream.Upstream{failUps, failUps, failUps},
139141
},
140-
name: "parallel_bad",
141-
mode: proxy.UpstreamModeParallel,
142-
mainCount: 2,
143-
fallbackCount: 3,
144-
isMainErr: true,
145-
isFallbackErr: true,
142+
name: "parallel_bad",
143+
mode: proxy.UpstreamModeParallel,
144+
wantMainCount: 2,
145+
wantFallbackCount: 3,
146146
}, {
147-
isExchangeErr: assert.False,
147+
wantErr: assert.NoError,
148+
wantMainErr: assert.False,
149+
wantFallbackErr: assert.False,
148150
config: &proxy.UpstreamConfig{
149151
Upstreams: []upstream.Upstream{ups},
150152
},
151153
fallbackConfig: &proxy.UpstreamConfig{
152154
Upstreams: []upstream.Upstream{ups},
153155
},
154-
name: "fastest_single_success",
155-
mode: proxy.UpstreamModeFastestAddr,
156-
mainCount: 1,
157-
fallbackCount: 0,
158-
isMainErr: false,
159-
isFallbackErr: false,
156+
name: "fastest_single_success",
157+
mode: proxy.UpstreamModeFastestAddr,
158+
wantMainCount: 1,
159+
wantFallbackCount: 0,
160160
}, {
161-
isExchangeErr: assert.False,
161+
wantErr: assert.NoError,
162+
wantMainErr: assert.False,
163+
wantFallbackErr: assert.False,
162164
config: &proxy.UpstreamConfig{
163165
Upstreams: []upstream.Upstream{ups, ups},
164166
},
165167
fallbackConfig: &proxy.UpstreamConfig{
166168
Upstreams: []upstream.Upstream{ups},
167169
},
168-
name: "fastest_multiple_success",
169-
mode: proxy.UpstreamModeFastestAddr,
170-
mainCount: 2,
171-
fallbackCount: 0,
172-
isMainErr: false,
173-
isFallbackErr: false,
170+
name: "fastest_multiple_success",
171+
mode: proxy.UpstreamModeFastestAddr,
172+
wantMainCount: 2,
173+
wantFallbackCount: 0,
174174
}, {
175-
isExchangeErr: assert.False,
175+
wantErr: assert.NoError,
176+
wantMainErr: assert.True,
177+
wantFallbackErr: assert.False,
176178
config: &proxy.UpstreamConfig{
177179
Upstreams: []upstream.Upstream{ups, failUps},
178180
},
179181
fallbackConfig: &proxy.UpstreamConfig{
180182
Upstreams: []upstream.Upstream{ups},
181183
},
182-
name: "fastest_mixed_success",
183-
mode: proxy.UpstreamModeFastestAddr,
184-
mainCount: 2,
185-
fallbackCount: 0,
186-
isMainErr: true,
187-
isFallbackErr: false,
184+
name: "fastest_mixed_success",
185+
mode: proxy.UpstreamModeFastestAddr,
186+
wantMainCount: 2,
187+
wantFallbackCount: 0,
188188
}, {
189-
isExchangeErr: assert.True,
189+
wantErr: assert.Error,
190+
wantMainErr: assert.True,
191+
wantFallbackErr: assert.True,
190192
config: &proxy.UpstreamConfig{
191193
Upstreams: []upstream.Upstream{failUps, failUps},
192194
},
193195
fallbackConfig: &proxy.UpstreamConfig{
194196
Upstreams: []upstream.Upstream{failUps, failUps, failUps},
195197
},
196-
name: "fastest_multiple_bad",
197-
mode: proxy.UpstreamModeFastestAddr,
198-
mainCount: 2,
199-
fallbackCount: 3,
200-
isMainErr: true,
201-
isFallbackErr: true,
198+
name: "fastest_multiple_bad",
199+
mode: proxy.UpstreamModeFastestAddr,
200+
wantMainCount: 2,
201+
wantFallbackCount: 3,
202202
}, {
203-
isExchangeErr: assert.False,
203+
wantErr: assert.NoError,
204+
wantMainErr: assert.True,
205+
wantFallbackErr: assert.False,
204206
config: &proxy.UpstreamConfig{
205207
Upstreams: []upstream.Upstream{failUps, failUps},
206208
},
207209
fallbackConfig: &proxy.UpstreamConfig{
208210
Upstreams: []upstream.Upstream{ups},
209211
},
210-
name: "fastest_bad_fallback_success",
211-
mode: proxy.UpstreamModeFastestAddr,
212-
mainCount: 2,
213-
fallbackCount: 1,
214-
isMainErr: true,
215-
isFallbackErr: false,
212+
name: "fastest_bad_fallback_success",
213+
mode: proxy.UpstreamModeFastestAddr,
214+
wantMainCount: 2,
215+
wantFallbackCount: 1,
216216
}}
217217

218218
for _, tc := range testCases {
@@ -227,16 +227,16 @@ func TestCollectQueryStats(t *testing.T) {
227227
d := &proxy.DNSContext{Req: testReq}
228228

229229
err = p.Resolve(d)
230-
tc.isExchangeErr(t, err != nil)
230+
tc.wantErr(t, err)
231231

232232
stats := d.QueryStatistics()
233233
assertQueryStats(
234234
t,
235235
stats,
236-
tc.mainCount,
237-
tc.isMainErr,
238-
tc.fallbackCount,
239-
tc.isFallbackErr,
236+
tc.wantMainCount,
237+
tc.wantMainErr,
238+
tc.wantFallbackCount,
239+
tc.wantFallbackErr,
240240
)
241241
})
242242
}
@@ -246,21 +246,21 @@ func TestCollectQueryStats(t *testing.T) {
246246
func assertQueryStats(
247247
t *testing.T,
248248
stats *proxy.QueryStatistics,
249-
mainCount int,
250-
isMainErr bool,
251-
fallbackCount int,
252-
isFallbackErr bool,
249+
wantMainCount int,
250+
wantMainErr assert.BoolAssertionFunc,
251+
wantFallbackCount int,
252+
wantFallbackErr assert.BoolAssertionFunc,
253253
) {
254254
t.Helper()
255255

256256
main := stats.Main()
257-
assert.Equalf(t, mainCount, len(main), "main stats count")
257+
assert.Lenf(t, main, wantMainCount, "main stats count")
258258

259259
fallback := stats.Fallback()
260-
assert.Equalf(t, fallbackCount, len(fallback), "fallback stats count")
260+
assert.Lenf(t, fallback, wantFallbackCount, "fallback stats count")
261261

262-
assert.Equalf(t, isMainErr, isErrorInStats(main), "main err")
263-
assert.Equalf(t, isFallbackErr, isErrorInStats(fallback), "fallback err")
262+
wantMainErr(t, isErrorInStats(main), "main err")
263+
wantFallbackErr(t, isErrorInStats(fallback), "fallback err")
264264
}
265265

266266
// isErrorInStats is a helper function for tests that returns true if the

0 commit comments

Comments
 (0)