Skip to content

Commit 1eecb8b

Browse files
BegiBegi
committed
fix: tests
1 parent 5249c85 commit 1eecb8b

1 file changed

Lines changed: 128 additions & 82 deletions

File tree

‎executors/tavern/assert_test.go‎

Lines changed: 128 additions & 82 deletions
Original file line numberDiff line numberDiff line change
@@ -19,16 +19,20 @@ func TestAssertResponseType(t *testing.T) {
1919

2020
func TestAssertResponseStatusCode(t *testing.T) {
2121
result := Result{
22-
Expected: Response{StatusCode: 200},
23-
Actual: Response{StatusCode: 200},
22+
Actual: Actual{
23+
Expected: Response{StatusCode: 200},
24+
Actual: Response{StatusCode: 200},
25+
},
2426
}
2527
err := AssertResponse(result)
2628
if err != nil {
2729
t.Fatalf("should have succeeded: %v", err)
2830
}
2931
result = Result{
30-
Expected: Response{StatusCode: 200},
31-
Actual: Response{StatusCode: 201},
32+
Actual: Actual{
33+
Expected: Response{StatusCode: 200},
34+
Actual: Response{StatusCode: 201},
35+
},
3236
}
3337
err = AssertResponse(result)
3438
if err == nil {
@@ -42,13 +46,15 @@ func TestAssertResponseStatusCode(t *testing.T) {
4246
func TestAssertResponseHeaders(t *testing.T) {
4347
// nominal case (we accept additional headers in actual)
4448
result := Result{
45-
Expected: Response{
46-
Headers: Headers{"Foo": "Bar"},
47-
},
48-
Actual: Response{
49-
Headers: Headers{
50-
"Foo": "Bar",
51-
"Spam": "Eggs",
49+
Actual: Actual{
50+
Expected: Response{
51+
Headers: Headers{"Foo": "Bar"},
52+
},
53+
Actual: Response{
54+
Headers: Headers{
55+
"Foo": "Bar",
56+
"Spam": "Eggs",
57+
},
5258
},
5359
},
5460
}
@@ -58,14 +64,16 @@ func TestAssertResponseHeaders(t *testing.T) {
5864
}
5965
// missing header
6066
result = Result{
61-
Expected: Response{
62-
Headers: Headers{
63-
"Foo": "Bar",
64-
"Spam": "Eggs",
67+
Actual: Actual{
68+
Expected: Response{
69+
Headers: Headers{
70+
"Foo": "Bar",
71+
"Spam": "Eggs",
72+
},
73+
},
74+
Actual: Response{
75+
Headers: Headers{"Foo": "Bar"},
6576
},
66-
},
67-
Actual: Response{
68-
Headers: Headers{"Foo": "Bar"},
6977
},
7078
}
7179
err = AssertResponse(result)
@@ -77,11 +85,13 @@ func TestAssertResponseHeaders(t *testing.T) {
7785
}
7886
// bad header
7987
result = Result{
80-
Expected: Response{
81-
Headers: Headers{"Foo": "Bar"},
82-
},
83-
Actual: Response{
84-
Headers: Headers{"Foo": "Baz"},
88+
Actual: Actual{
89+
Expected: Response{
90+
Headers: Headers{"Foo": "Bar"},
91+
},
92+
Actual: Response{
93+
Headers: Headers{"Foo": "Baz"},
94+
},
8595
},
8696
}
8797
err = AssertResponse(result)
@@ -93,12 +103,14 @@ func TestAssertResponseHeaders(t *testing.T) {
93103
}
94104
// nominal case with regexp
95105
result = Result{
96-
Expected: Response{
97-
Headers: Headers{"Foo": "B.r"},
98-
HeadersRegexps: []string{"Foo"},
99-
},
100-
Actual: Response{
101-
Headers: Headers{"Foo": "Bar"},
106+
Actual: Actual{
107+
Expected: Response{
108+
Headers: Headers{"Foo": "B.r"},
109+
HeadersRegexps: []string{"Foo"},
110+
},
111+
Actual: Response{
112+
Headers: Headers{"Foo": "Bar"},
113+
},
102114
},
103115
}
104116
err = AssertResponse(result)
@@ -107,12 +119,14 @@ func TestAssertResponseHeaders(t *testing.T) {
107119
}
108120
// no match with regexp
109121
result = Result{
110-
Expected: Response{
111-
Headers: Headers{"Foo": "x.*"},
112-
HeadersRegexps: []string{"Foo"},
113-
},
114-
Actual: Response{
115-
Headers: Headers{"Foo": "Bar"},
122+
Actual: Actual{
123+
Expected: Response{
124+
Headers: Headers{"Foo": "x.*"},
125+
HeadersRegexps: []string{"Foo"},
126+
},
127+
Actual: Response{
128+
Headers: Headers{"Foo": "Bar"},
129+
},
116130
},
117131
}
118132
err = AssertResponse(result)
@@ -123,16 +137,20 @@ func TestAssertResponseHeaders(t *testing.T) {
123137

124138
func TestAssertResponseBody(t *testing.T) {
125139
result := Result{
126-
Expected: Response{Body: "Foo"},
127-
Actual: Response{Body: "Foo"},
140+
Actual: Actual{
141+
Expected: Response{Body: "Foo"},
142+
Actual: Response{Body: "Foo"},
143+
},
128144
}
129145
err := AssertResponse(result)
130146
if err != nil {
131147
t.Fatalf("should have succeeded: %v", err)
132148
}
133149
result = Result{
134-
Expected: Response{Body: "Foo"},
135-
Actual: Response{Body: "Bar"},
150+
Actual: Actual{
151+
Expected: Response{Body: "Foo"},
152+
Actual: Response{Body: "Bar"},
153+
},
136154
}
137155
err = AssertResponse(result)
138156
if err == nil {
@@ -145,16 +163,20 @@ func TestAssertResponseBody(t *testing.T) {
145163

146164
func TestAssertResponseBodyRegexp(t *testing.T) {
147165
result := Result{
148-
Expected: Response{BodyRegexp: "F.o"},
149-
Actual: Response{Body: "Foo"},
166+
Actual: Actual{
167+
Expected: Response{BodyRegexp: "F.o"},
168+
Actual: Response{Body: "Foo"},
169+
},
150170
}
151171
err := AssertResponse(result)
152172
if err != nil {
153173
t.Fatalf("should have succeeded")
154174
}
155175
result = Result{
156-
Expected: Response{BodyRegexp: "x.*"},
157-
Actual: Response{Body: "Foo"},
176+
Actual: Actual{
177+
Expected: Response{BodyRegexp: "x.*"},
178+
Actual: Response{Body: "Foo"},
179+
},
158180
}
159181
err = AssertResponse(result)
160182
if err == nil {
@@ -178,8 +200,10 @@ func TestAssertResponseJson(t *testing.T) {
178200
t.Fatalf("unmarshaling JSON: %v", err)
179201
}
180202
result := Result{
181-
Expected: Response{JSON: expected},
182-
Actual: Response{JSON: actual},
203+
Actual: Actual{
204+
Expected: Response{JSON: expected},
205+
Actual: Response{JSON: actual},
206+
},
183207
}
184208
err = AssertResponse(result)
185209
if err != nil {
@@ -191,8 +215,10 @@ func TestAssertResponseJson(t *testing.T) {
191215
t.Fatalf("unmarshaling JSON: %v", err)
192216
}
193217
result = Result{
194-
Expected: Response{JSON: expected},
195-
Actual: Response{JSON: actual},
218+
Actual: Actual{
219+
Expected: Response{JSON: expected},
220+
Actual: Response{JSON: actual},
221+
},
196222
}
197223
err = AssertResponse(result)
198224
if err == nil {
@@ -207,8 +233,10 @@ func TestAssertResponseJson(t *testing.T) {
207233
t.Fatalf("unmarshaling JSON: %v", err)
208234
}
209235
result = Result{
210-
Expected: Response{JSON: expected},
211-
Actual: Response{JSON: actual},
236+
Actual: Actual{
237+
Expected: Response{JSON: expected},
238+
Actual: Response{JSON: actual},
239+
},
212240
}
213241
err = AssertResponse(result)
214242
if err == nil {
@@ -232,11 +260,13 @@ func TestAssertResponseJsonExcludes(t *testing.T) {
232260
t.Fatalf("unmarshaling JSON: %v", err)
233261
}
234262
result := Result{
235-
Expected: Response{
236-
JSON: expected,
237-
JSONExcludes: []string{"foo"},
263+
Actual: Actual{
264+
Expected: Response{
265+
JSON: expected,
266+
JSONExcludes: []string{"foo"},
267+
},
268+
Actual: Response{JSON: actual},
238269
},
239-
Actual: Response{JSON: actual},
240270
}
241271
err = AssertResponse(result)
242272
if err != nil {
@@ -252,11 +282,13 @@ func TestAssertResponseJsonExcludes(t *testing.T) {
252282
t.Fatalf("unmarshaling JSON: %v", err)
253283
}
254284
result = Result{
255-
Expected: Response{
256-
JSON: expected,
257-
JSONExcludes: []string{"*/bar"},
285+
Actual: Actual{
286+
Expected: Response{
287+
JSON: expected,
288+
JSONExcludes: []string{"*/bar"},
289+
},
290+
Actual: Response{JSON: actual},
258291
},
259-
Actual: Response{JSON: actual},
260292
}
261293
err = AssertResponse(result)
262294
if err != nil {
@@ -272,11 +304,13 @@ func TestAssertResponseJsonExcludes(t *testing.T) {
272304
t.Fatalf("unmarshaling JSON: %v", err)
273305
}
274306
result = Result{
275-
Expected: Response{
276-
JSON: expected,
277-
JSONExcludes: []string{"0/*/bar"},
307+
Actual: Actual{
308+
Expected: Response{
309+
JSON: expected,
310+
JSONExcludes: []string{"0/*/bar"},
311+
},
312+
Actual: Response{JSON: actual},
278313
},
279-
Actual: Response{JSON: actual},
280314
}
281315
err = AssertResponse(result)
282316
if err != nil {
@@ -292,11 +326,13 @@ func TestAssertResponseJsonExcludes(t *testing.T) {
292326
t.Fatalf("unmarshaling JSON: %v", err)
293327
}
294328
result = Result{
295-
Expected: Response{
296-
JSON: expected,
297-
JSONExcludes: []string{"**/spam"},
329+
Actual: Actual{
330+
Expected: Response{
331+
JSON: expected,
332+
JSONExcludes: []string{"**/spam"},
333+
},
334+
Actual: Response{JSON: actual},
298335
},
299-
Actual: Response{JSON: actual},
300336
}
301337
err = AssertResponse(result)
302338
if err != nil {
@@ -317,11 +353,13 @@ func TestAssertResponseJsonRegexps(t *testing.T) {
317353
t.Fatalf("unmarshaling JSON: %v", err)
318354
}
319355
result := Result{
320-
Expected: Response{
321-
JSON: expected,
322-
JSONRegexps: []string{"foo"},
356+
Actual: Actual{
357+
Expected: Response{
358+
JSON: expected,
359+
JSONRegexps: []string{"foo"},
360+
},
361+
Actual: Response{JSON: actual},
323362
},
324-
Actual: Response{JSON: actual},
325363
}
326364
err = AssertResponse(result)
327365
if err != nil {
@@ -333,11 +371,13 @@ func TestAssertResponseJsonRegexps(t *testing.T) {
333371
t.Fatalf("unmarshaling JSON: %v", err)
334372
}
335373
result = Result{
336-
Expected: Response{
337-
JSON: expected,
338-
JSONRegexps: []string{"foo"},
374+
Actual: Actual{
375+
Expected: Response{
376+
JSON: expected,
377+
JSONRegexps: []string{"foo"},
378+
},
379+
Actual: Response{JSON: actual},
339380
},
340-
Actual: Response{JSON: actual},
341381
}
342382
err = AssertResponse(result)
343383
if err == nil {
@@ -506,9 +546,11 @@ func TestPathToRegexp(t *testing.T) {
506546
func TestCheckAssertions(t *testing.T) {
507547
// can't set both body and bodyRegexps assertions
508548
result := Result{
509-
Expected: Response{
510-
Body: "test",
511-
BodyRegexp: "test",
549+
Actual: Actual{
550+
Expected: Response{
551+
Body: "test",
552+
BodyRegexp: "test",
553+
},
512554
},
513555
}
514556
err := AssertResponse(result)
@@ -520,9 +562,11 @@ func TestCheckAssertions(t *testing.T) {
520562
}
521563
// field declared as regexp but not found in headers list
522564
result = Result{
523-
Expected: Response{
524-
Headers: Headers{"spam": "eggs"},
525-
HeadersRegexps: []string{"foo"},
565+
Actual: Actual{
566+
Expected: Response{
567+
Headers: Headers{"spam": "eggs"},
568+
HeadersRegexps: []string{"foo"},
569+
},
526570
},
527571
}
528572
err = AssertResponse(result)
@@ -534,9 +578,11 @@ func TestCheckAssertions(t *testing.T) {
534578
}
535579
// JSON field can't be excluded and declared as regexp
536580
result = Result{
537-
Expected: Response{
538-
JSONExcludes: []string{"foo"},
539-
JSONRegexps: []string{"foo"},
581+
Actual: Actual{
582+
Expected: Response{
583+
JSONExcludes: []string{"foo"},
584+
JSONRegexps: []string{"foo"},
585+
},
540586
},
541587
}
542588
err = AssertResponse(result)

0 commit comments

Comments
 (0)