@@ -91,226 +91,205 @@ func TestCacheHandler(t *testing.T) {
91
91
}{
92
92
{
93
93
name : "cacheLookup error should still forward request to downstream and store response" ,
94
- handler : handler {
95
- cfg : config.CacheConfig {
96
- DownstreamHost : mustURL (t , downstreamServer .URL ),
97
- },
98
- cacher : func () Cacher {
94
+ handler : newCacheHandler (
95
+ func () Cacher {
99
96
mock := NewMockCacher (ctrl )
100
97
mock .EXPECT ().LookUp (gomock .Any (), gomock .Any ()).Return (nil , errors .New ("test-error" ))
101
98
mock .EXPECT ().Store (gomock .Any (), gomock .Any (), gomock .Any ())
102
-
103
99
return mock
104
100
}(),
105
- metricsCollector : func () MetricsCollector {
101
+ func () MetricsCollector {
106
102
mock := NewMockMetricsCollector (ctrl )
107
103
mock .EXPECT ().CacheMiss ("GET" , proxied )
108
-
109
104
return mock
110
105
}(),
111
- },
112
-
106
+ nil ,
107
+ config.CacheConfig {
108
+ DownstreamHost : mustURL (t , downstreamServer .URL ),
109
+ },
110
+ ),
113
111
req : mustRequest (t , endpoint , "" ),
114
112
want : proxied ,
115
113
},
116
114
{
117
115
name : "cache miss" ,
118
- handler : handler {
119
- cfg : config.CacheConfig {
120
- DownstreamHost : mustURL (t , downstreamServer .URL ),
121
- },
122
- cacher : func () Cacher {
116
+ handler : newCacheHandler (
117
+ func () Cacher {
123
118
mock := NewMockCacher (ctrl )
124
119
mock .EXPECT ().LookUp (gomock .Any (), gomock .Any ()).Return (nil , nil ).Times (1 )
125
120
mock .EXPECT ().Store (gomock .Any (), gomock .Any (), newResponseMatcher (proxied , nil )).Return (nil ).Times (1 )
126
-
127
121
return mock
128
122
}(),
129
- metricsCollector : func () MetricsCollector {
123
+ func () MetricsCollector {
130
124
mock := NewMockMetricsCollector (ctrl )
131
125
mock .EXPECT ().CacheMiss ("GET" , proxied ).Times (1 )
132
-
133
126
return mock
134
127
}(),
135
- },
136
-
128
+ nil ,
129
+ config.CacheConfig {
130
+ DownstreamHost : mustURL (t , downstreamServer .URL ),
131
+ },
132
+ ),
137
133
req : mustRequest (t , endpoint , "" ),
138
134
want : proxied ,
139
135
},
140
136
{
141
137
name : "websockets will not be stored in cache" ,
142
- handler : handler {
143
- cfg : config.CacheConfig {
144
- DownstreamHost : mustURL (t , downstreamServer .URL ),
145
- },
146
- cacher : func () Cacher {
138
+ handler : newCacheHandler (
139
+ func () Cacher {
147
140
mock := NewMockCacher (ctrl )
148
141
mock .EXPECT ().LookUp (nil , nil ).Times (0 )
149
142
mock .EXPECT ().Store (nil , nil , nil ).Times (0 )
150
-
151
143
return mock
152
144
}(),
153
- metricsCollector : func () MetricsCollector {
145
+ func () MetricsCollector {
154
146
mock := NewMockMetricsCollector (ctrl )
155
147
mock .EXPECT ().CacheMiss (nil , nil ).Times (0 )
156
-
157
148
return mock
158
149
}(),
159
- },
160
-
150
+ nil ,
151
+ config.CacheConfig {
152
+ DownstreamHost : mustURL (t , downstreamServer .URL ),
153
+ },
154
+ ),
161
155
req : webSocketReq ,
162
156
want : proxied ,
163
157
},
164
158
{
165
159
name : "POST requests will not be stored in cache" ,
166
- handler : handler {
167
- cfg : config.CacheConfig {
168
- DownstreamHost : mustURL (t , downstreamServer .URL ),
169
- },
170
- cacher : func () Cacher {
160
+ handler : newCacheHandler (
161
+ func () Cacher {
171
162
mock := NewMockCacher (ctrl )
172
163
mock .EXPECT ().LookUp (nil , nil ).Times (0 )
173
164
mock .EXPECT ().Store (nil , nil , nil ).Times (0 )
174
-
175
165
return mock
176
166
}(),
177
- metricsCollector : func () MetricsCollector {
167
+ func () MetricsCollector {
178
168
mock := NewMockMetricsCollector (ctrl )
179
169
mock .EXPECT ().CacheMiss (nil , nil ).Times (0 )
180
-
181
170
return mock
182
171
}(),
183
- },
184
-
172
+ nil ,
173
+ config.CacheConfig {
174
+ DownstreamHost : mustURL (t , downstreamServer .URL ),
175
+ },
176
+ ),
185
177
req : mustRequest (t , endpoint , "POST" ),
186
178
want : proxied ,
187
179
},
188
180
{
189
181
name : "PUT requests will not be stored in cache" ,
190
- handler : handler {
191
- cfg : config.CacheConfig {
192
- DownstreamHost : mustURL (t , downstreamServer .URL ),
193
- },
194
- cacher : func () Cacher {
182
+ handler : newCacheHandler (
183
+ func () Cacher {
195
184
mock := NewMockCacher (ctrl )
196
185
mock .EXPECT ().LookUp (nil , nil ).Times (0 )
197
186
mock .EXPECT ().Store (nil , nil , nil ).Times (0 )
198
-
199
187
return mock
200
188
}(),
201
- metricsCollector : func () MetricsCollector {
189
+ func () MetricsCollector {
202
190
mock := NewMockMetricsCollector (ctrl )
203
191
mock .EXPECT ().CacheMiss (nil , nil ).Times (0 )
204
-
205
192
return mock
206
193
}(),
207
- },
208
-
194
+ nil ,
195
+ config.CacheConfig {
196
+ DownstreamHost : mustURL (t , downstreamServer .URL ),
197
+ },
198
+ ),
209
199
req : mustRequest (t , endpoint , "PUT" ),
210
200
want : proxied ,
211
201
},
212
202
{
213
203
name : "PATCH requests will not be stored in cache" ,
214
- handler : handler {
215
- cfg : config.CacheConfig {
216
- DownstreamHost : mustURL (t , downstreamServer .URL ),
217
- },
218
- cacher : func () Cacher {
204
+ handler : newCacheHandler (
205
+ func () Cacher {
219
206
mock := NewMockCacher (ctrl )
220
207
mock .EXPECT ().LookUp (nil , nil ).Times (0 )
221
208
mock .EXPECT ().Store (nil , nil , nil ).Times (0 )
222
-
223
209
return mock
224
210
}(),
225
- metricsCollector : func () MetricsCollector {
211
+ func () MetricsCollector {
226
212
mock := NewMockMetricsCollector (ctrl )
227
213
mock .EXPECT ().CacheMiss (nil , nil ).Times (0 )
228
-
229
214
return mock
230
215
}(),
231
- },
232
-
216
+ nil ,
217
+ config.CacheConfig {
218
+ DownstreamHost : mustURL (t , downstreamServer .URL ),
219
+ },
220
+ ),
233
221
req : mustRequest (t , endpoint , "PATCH" ),
234
222
want : proxied ,
235
223
},
236
224
{
237
225
name : "DELETE requests will not be stored in cache" ,
238
- handler : handler {
239
- cfg : config.CacheConfig {
240
- DownstreamHost : mustURL (t , downstreamServer .URL ),
241
- },
242
- cacher : func () Cacher {
226
+ handler : newCacheHandler (
227
+ func () Cacher {
243
228
mock := NewMockCacher (ctrl )
244
229
mock .EXPECT ().LookUp (nil , nil ).Times (0 )
245
230
mock .EXPECT ().Store (nil , nil , nil ).Times (0 )
246
-
247
231
return mock
248
232
}(),
249
- metricsCollector : func () MetricsCollector {
233
+ func () MetricsCollector {
250
234
mock := NewMockMetricsCollector (ctrl )
251
235
mock .EXPECT ().CacheMiss (nil , nil ).Times (0 )
252
-
253
236
return mock
254
237
}(),
255
- },
256
-
238
+ nil ,
239
+ config.CacheConfig {
240
+ DownstreamHost : mustURL (t , downstreamServer .URL ),
241
+ },
242
+ ),
257
243
req : mustRequest (t , endpoint , "DELETE" ),
258
244
want : proxied ,
259
245
},
260
246
{
261
247
name : "statusCode > 500 from downstream will not be stored in cache" ,
262
- handler : handler {
263
- cfg : config.CacheConfig {
264
- DownstreamHost : mustURL (t , downstreamServerNok .URL ),
265
- },
266
- cacher : func () Cacher {
248
+ handler : newCacheHandler (
249
+ func () Cacher {
267
250
mock := NewMockCacher (ctrl )
268
251
mock .EXPECT ().LookUp (gomock .Any (), gomock .Any ()).Return (nil , nil ).Times (1 )
269
252
mock .EXPECT ().Store (nil , nil , nil ).Times (0 )
270
-
271
253
return mock
272
254
}(),
273
- metricsCollector : func () MetricsCollector {
255
+ func () MetricsCollector {
274
256
mock := NewMockMetricsCollector (ctrl )
275
257
mock .EXPECT ().CacheMiss ("GET" , http .StatusInternalServerError ).Times (1 )
276
-
277
258
return mock
278
259
}(),
279
- },
280
-
260
+ nil ,
261
+ config.CacheConfig {
262
+ DownstreamHost : mustURL (t , downstreamServerNok .URL ),
263
+ },
264
+ ),
281
265
req : mustRequest (t , "/status/500?q=1" , "" ),
282
266
want : http .StatusInternalServerError ,
283
267
},
284
268
{
285
269
name : "cache hit" ,
286
- handler : handler {
287
- cfg : config.CacheConfig {
288
- DownstreamHost : mustURL (t , downstreamServer .URL ),
289
- },
290
- worker : func () Worker {
291
- mock := NewMockWorker (ctrl )
292
- mock .EXPECT ().Start (gomock .Any (), gomock .Any ())
293
-
294
- return mock
295
- }(),
296
- cacher : func () Cacher {
270
+ handler : newCacheHandler (
271
+ func () Cacher {
297
272
mock := NewMockCacher (ctrl )
298
273
mock .EXPECT ().LookUp (gomock .Any (), gomock .Any ()).Return (& model.Response {
299
274
Status : http .StatusOK ,
300
275
Body : []byte ("hello" ),
301
276
}, nil )
302
-
303
277
return mock
304
278
}(),
305
- metricsCollector : func () MetricsCollector {
279
+ func () MetricsCollector {
306
280
mock := NewMockMetricsCollector (ctrl )
307
281
mock .EXPECT ().CacheHit ("GET" , http .StatusOK )
308
- // mock.EXPECT().CacheMiss("GET", proxied)
309
-
310
282
return mock
311
283
}(),
312
- },
313
-
284
+ func () Worker {
285
+ mock := NewMockWorker (ctrl )
286
+ mock .EXPECT ().Start (gomock .Any (), gomock .Any ())
287
+ return mock
288
+ }(),
289
+ config.CacheConfig {
290
+ DownstreamHost : mustURL (t , downstreamServer .URL ),
291
+ },
292
+ ),
314
293
req : mustRequest (t , endpoint , "" ),
315
294
want : http .StatusOK ,
316
295
},
0 commit comments