git.iko.soy/typeable/oauth2-proxy
on proxy-mapping help sign in
typeable/oauth2-proxy/pkg/requests/result_test.go
326 lines 8.8 kB history raw
1package requests
3import (
4 "errors"
5 "net/http"
7 . "github.com/onsi/ginkgo"
8 . "github.com/onsi/ginkgo/extensions/table"
9 . "github.com/onsi/gomega"
12var _ = Describe("Result suite", func() {
13 Context("with a result", func() {
14 type resultTableInput struct {
15 result Result
16 expectedError error
17 expectedStatusCode int
18 expectedHeaders http.Header
19 expectedBody []byte
20 }
22 DescribeTable("accessors should return expected results",
23 func(in resultTableInput) {
24 if in.expectedError != nil {
25 Expect(in.result.Error()).To(MatchError(in.expectedError))
26 } else {
27 Expect(in.result.Error()).To(BeNil())
28 }
30 Expect(in.result.StatusCode()).To(Equal(in.expectedStatusCode))
31 Expect(in.result.Headers()).To(Equal(in.expectedHeaders))
32 Expect(in.result.Body()).To(Equal(in.expectedBody))
33 },
34 Entry("with an empty result", resultTableInput{
35 result: &result{},
36 expectedError: nil,
37 expectedStatusCode: 0,
38 expectedHeaders: nil,
39 expectedBody: nil,
40 }),
41 Entry("with an error", resultTableInput{
42 result: &result{
43 err: errors.New("error"),
44 },
45 expectedError: errors.New("error"),
46 expectedStatusCode: 0,
47 expectedHeaders: nil,
48 expectedBody: nil,
49 }),
50 Entry("with a response with no headers", resultTableInput{
51 result: &result{
52 response: &http.Response{
53 StatusCode: http.StatusTeapot,
54 },
55 },
56 expectedError: nil,
57 expectedStatusCode: http.StatusTeapot,
58 expectedHeaders: nil,
59 expectedBody: nil,
60 }),
61 Entry("with a response with no status code", resultTableInput{
62 result: &result{
63 response: &http.Response{
64 Header: http.Header{
65 "foo": []string{"bar"},
66 },
67 },
68 },
69 expectedError: nil,
70 expectedStatusCode: 0,
71 expectedHeaders: http.Header{
72 "foo": []string{"bar"},
73 },
74 expectedBody: nil,
75 }),
76 Entry("with a response with a body", resultTableInput{
77 result: &result{
78 body: []byte("some body"),
79 },
80 expectedError: nil,
81 expectedStatusCode: 0,
82 expectedHeaders: nil,
83 expectedBody: []byte("some body"),
84 }),
85 Entry("with all fields", resultTableInput{
86 result: &result{
87 err: errors.New("some error"),
88 response: &http.Response{
89 StatusCode: http.StatusFound,
90 Header: http.Header{
91 "header": []string{"value"},
92 },
93 },
94 body: []byte("a body"),
95 },
96 expectedError: errors.New("some error"),
97 expectedStatusCode: http.StatusFound,
98 expectedHeaders: http.Header{
99 "header": []string{"value"},
100 },
101 expectedBody: []byte("a body"),
102 }),
103 )
104 })
106 Context("UnmarshalInto", func() {
107 type testStruct struct {
108 A string `json:"a"`
109 B int `json:"b"`
110 }
112 type unmarshalIntoTableInput struct {
113 result Result
114 expectedErr error
115 expectedOutput *testStruct
116 }
118 DescribeTable("with a result",
119 func(in unmarshalIntoTableInput) {
120 input := &testStruct{}
121 err := in.result.UnmarshalInto(input)
122 if in.expectedErr != nil {
123 Expect(err).To(MatchError(in.expectedErr))
124 } else {
125 Expect(err).ToNot(HaveOccurred())
126 }
127 Expect(input).To(Equal(in.expectedOutput))
128 },
129 Entry("with an error", unmarshalIntoTableInput{
130 result: &result{
131 err: errors.New("got an error"),
132 response: &http.Response{
133 StatusCode: http.StatusOK,
134 },
135 body: []byte("{\"a\": \"foo\"}"),
136 },
137 expectedErr: errors.New("got an error"),
138 expectedOutput: &testStruct{},
139 }),
140 Entry("with a 409 status code", unmarshalIntoTableInput{
141 result: &result{
142 err: nil,
143 response: &http.Response{
144 StatusCode: http.StatusConflict,
145 },
146 body: []byte("{\"a\": \"foo\"}"),
147 },
148 expectedErr: errors.New("unexpected status \"409\": {\"a\": \"foo\"}"),
149 expectedOutput: &testStruct{},
150 }),
151 Entry("when the response has a valid json response", unmarshalIntoTableInput{
152 result: &result{
153 err: nil,
154 response: &http.Response{
155 StatusCode: http.StatusOK,
156 },
157 body: []byte("{\"a\": \"foo\", \"b\": 1}"),
158 },
159 expectedErr: nil,
160 expectedOutput: &testStruct{A: "foo", B: 1},
161 }),
162 Entry("when the response body is empty", unmarshalIntoTableInput{
163 result: &result{
164 err: nil,
165 response: &http.Response{
166 StatusCode: http.StatusOK,
167 },
168 body: []byte(""),
169 },
170 expectedErr: errors.New("error unmarshalling body: unexpected end of JSON input"),
171 expectedOutput: &testStruct{},
172 }),
173 Entry("when the response body is not json", unmarshalIntoTableInput{
174 result: &result{
175 err: nil,
176 response: &http.Response{
177 StatusCode: http.StatusOK,
178 },
179 body: []byte("not json"),
180 },
181 expectedErr: errors.New("error unmarshalling body: invalid character 'o' in literal null (expecting 'u')"),
182 expectedOutput: &testStruct{},
183 }),
184 )
185 })
187 Context("UnmarshalJSON", func() {
188 type testStruct struct {
189 A string `json:"a"`
190 B int `json:"b"`
191 }
193 type unmarshalJSONTableInput struct {
194 result Result
195 expectedErr error
196 expectedOutput *testStruct
197 }
199 DescribeTable("with a result",
200 func(in unmarshalJSONTableInput) {
201 j, err := in.result.UnmarshalJSON()
202 if in.expectedErr != nil {
203 Expect(err).To(MatchError(in.expectedErr))
204 Expect(j).To(BeNil())
205 return
206 }
208 // No error so j should not be nil
209 Expect(err).ToNot(HaveOccurred())
211 input := &testStruct{
212 A: j.Get("a").MustString(),
213 B: j.Get("b").MustInt(),
214 }
215 Expect(input).To(Equal(in.expectedOutput))
216 },
217 Entry("with an error", unmarshalJSONTableInput{
218 result: &result{
219 err: errors.New("got an error"),
220 response: &http.Response{
221 StatusCode: http.StatusOK,
222 },
223 body: []byte("{\"a\": \"foo\"}"),
224 },
225 expectedErr: errors.New("got an error"),
226 expectedOutput: &testStruct{},
227 }),
228 Entry("with a 409 status code", unmarshalJSONTableInput{
229 result: &result{
230 err: nil,
231 response: &http.Response{
232 StatusCode: http.StatusConflict,
233 },
234 body: []byte("{\"a\": \"foo\"}"),
235 },
236 expectedErr: errors.New("unexpected status \"409\": {\"a\": \"foo\"}"),
237 expectedOutput: &testStruct{},
238 }),
239 Entry("when the response has a valid json response", unmarshalJSONTableInput{
240 result: &result{
241 err: nil,
242 response: &http.Response{
243 StatusCode: http.StatusOK,
244 },
245 body: []byte("{\"a\": \"foo\", \"b\": 1}"),
246 },
247 expectedErr: nil,
248 expectedOutput: &testStruct{A: "foo", B: 1},
249 }),
250 Entry("when the response body is empty", unmarshalJSONTableInput{
251 result: &result{
252 err: nil,
253 response: &http.Response{
254 StatusCode: http.StatusOK,
255 },
256 body: []byte(""),
257 },
258 expectedErr: errors.New("error reading json: EOF"),
259 expectedOutput: &testStruct{},
260 }),
261 Entry("when the response body is not json", unmarshalJSONTableInput{
262 result: &result{
263 err: nil,
264 response: &http.Response{
265 StatusCode: http.StatusOK,
266 },
267 body: []byte("not json"),
268 },
269 expectedErr: errors.New("error reading json: invalid character 'o' in literal null (expecting 'u')"),
270 expectedOutput: &testStruct{},
271 }),
272 )
273 })
275 Context("getBodyForUnmarshal", func() {
276 type getBodyForUnmarshalTableInput struct {
277 result *result
278 expectedErr error
279 expectedBody []byte
280 }
282 DescribeTable("when getting the body", func(in getBodyForUnmarshalTableInput) {
283 body, err := in.result.getBodyForUnmarshal()
284 if in.expectedErr != nil {
285 Expect(err).To(MatchError(in.expectedErr))
286 } else {
287 Expect(err).ToNot(HaveOccurred())
288 }
289 Expect(body).To(Equal(in.expectedBody))
290 },
291 Entry("when the result has an error", getBodyForUnmarshalTableInput{
292 result: &result{
293 err: errors.New("got an error"),
294 response: &http.Response{
295 StatusCode: http.StatusOK,
296 },
297 body: []byte("body"),
298 },
299 expectedErr: errors.New("got an error"),
300 expectedBody: nil,
301 }),
302 Entry("when the response has a 409 status code", getBodyForUnmarshalTableInput{
303 result: &result{
304 err: nil,
305 response: &http.Response{
306 StatusCode: http.StatusConflict,
307 },
308 body: []byte("body"),
309 },
310 expectedErr: errors.New("unexpected status \"409\": body"),
311 expectedBody: nil,
312 }),
313 Entry("when the response has a 200 status code", getBodyForUnmarshalTableInput{
314 result: &result{
315 err: nil,
316 response: &http.Response{
317 StatusCode: http.StatusOK,
318 },
319 body: []byte("body"),
320 },
321 expectedErr: nil,
322 expectedBody: []byte("body"),
323 }),
324 )
325 })
326})