source: josm/trunk/test/unit/org/openstreetmap/josm/data/cache/JCSCachedTileLoaderJobTest.java@ 19050

Last change on this file since 19050 was 19050, checked in by taylor.smock, 6 weeks ago

Revert most var changes from r19048, fix most new compile warnings and checkstyle issues

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.
  • Property svn:eol-style set to native
File size: 26.4 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data.cache;
3
4import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
5import static com.github.tomakehurst.wiremock.client.WireMock.anyUrl;
6import static com.github.tomakehurst.wiremock.client.WireMock.get;
7import static com.github.tomakehurst.wiremock.client.WireMock.getRequestedFor;
8import static com.github.tomakehurst.wiremock.client.WireMock.head;
9import static com.github.tomakehurst.wiremock.client.WireMock.headRequestedFor;
10import static com.github.tomakehurst.wiremock.client.WireMock.status;
11import static com.github.tomakehurst.wiremock.client.WireMock.urlEqualTo;
12import static org.junit.jupiter.api.Assertions.assertArrayEquals;
13import static org.junit.jupiter.api.Assertions.assertEquals;
14import static org.junit.jupiter.api.Assertions.assertFalse;
15import static org.junit.jupiter.api.Assertions.assertTrue;
16
17import java.io.IOException;
18import java.net.MalformedURLException;
19import java.net.URL;
20import java.nio.charset.StandardCharsets;
21import java.util.concurrent.TimeUnit;
22
23import org.apache.commons.jcs3.access.behavior.ICacheAccess;
24import org.apache.commons.jcs3.engine.behavior.ICacheElement;
25import org.junit.jupiter.api.BeforeEach;
26import org.junit.jupiter.api.Test;
27import org.junit.jupiter.api.Timeout;
28import org.openstreetmap.josm.TestUtils;
29import org.openstreetmap.josm.data.cache.ICachedLoaderListener.LoadResult;
30import org.openstreetmap.josm.data.imagery.TileJobOptions;
31import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
32import org.openstreetmap.josm.testutils.annotations.BasicWiremock;
33import org.openstreetmap.josm.tools.Logging;
34
35import com.github.tomakehurst.wiremock.WireMockServer;
36import com.github.tomakehurst.wiremock.matching.UrlPattern;
37
38/**
39 * Unit tests for class {@link JCSCachedTileLoaderJob}.
40 */
41@BasicWiremock
42@BasicPreferences
43@Timeout(20)
44class JCSCachedTileLoaderJobTest {
45
46 /**
47 * mocked tile server
48 */
49 @BasicWiremock
50 WireMockServer tileServer;
51
52 private static class TestCachedTileLoaderJob extends JCSCachedTileLoaderJob<String, CacheEntry> {
53 private final String url;
54 private final String key;
55
56 TestCachedTileLoaderJob(String url, String key) {
57 this(url, key, (int) TimeUnit.DAYS.toSeconds(1));
58 }
59
60 TestCachedTileLoaderJob(String url, String key, int minimumExpiry) {
61 super(getCache(), new TileJobOptions(30000, 30000, null, minimumExpiry));
62
63 this.url = url;
64 this.key = key;
65 }
66
67 @Override
68 public String getCacheKey() {
69 return key;
70 }
71
72 @Override
73 public URL getUrl() {
74 try {
75 return new URL(url);
76 } catch (MalformedURLException e) {
77 throw new RuntimeException(e);
78 }
79 }
80
81 @Override
82 protected CacheEntry createCacheEntry(byte[] content) {
83 return new CacheEntry(content);
84 }
85 }
86
87 private static final class Listener implements ICachedLoaderListener {
88 private CacheEntryAttributes attributes;
89 private boolean ready;
90 private LoadResult result;
91 private byte[] data;
92
93 @Override
94 public synchronized void loadingFinished(CacheEntry data, CacheEntryAttributes attributes, LoadResult result) {
95 this.attributes = attributes;
96 this.ready = true;
97 this.result = result;
98 if (data != null) {
99 this.data = data.content;
100 }
101 this.notifyAll();
102 }
103 }
104
105 /**
106 * Always clear cache before tests
107 * @throws Exception when clearing fails
108 */
109 @BeforeEach
110 void clearCache() throws Exception {
111 getCache().clear();
112 }
113
114 /**
115 * Test status codes
116 * @throws InterruptedException in case of thread interruption
117 * @throws IOException in case of I/O error
118 */
119 @Test
120 void testStatusCodes() throws IOException, InterruptedException {
121 doTestStatusCode(200);
122 doTestStatusCode(401);
123 doTestStatusCode(402);
124 doTestStatusCode(403);
125 doTestStatusCode(404);
126 doTestStatusCode(405);
127 doTestStatusCode(500);
128 doTestStatusCode(501);
129 doTestStatusCode(502);
130 }
131
132 /**
133 * Test unknown host
134 * @throws IOException in case of I/O error
135 */
136 @Test
137 void testUnknownHost() throws IOException {
138 String key = "key_unknown_host";
139 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob("http://unkownhost.unkownhost/unkown", key);
140 Listener listener = submitJob(job);
141 assertEquals(LoadResult.FAILURE, listener.result); // because response will be cached, and that is checked below
142 assertEquals("java.net.UnknownHostException: unkownhost.unkownhost", listener.attributes.getErrorMessage());
143
144 ICacheAccess<String, CacheEntry> cache = getCache();
145 CacheEntry e = new CacheEntry(new byte[]{0, 1, 2, 3});
146 CacheEntryAttributes attributes = new CacheEntryAttributes();
147 attributes.setExpirationTime(2);
148 cache.put(key, e, attributes);
149
150 job = new TestCachedTileLoaderJob("http://unkownhost.unkownhost/unkown", key);
151 listener = submitJob(job);
152 assertEquals(LoadResult.SUCCESS, listener.result);
153 assertFalse(job.isCacheElementValid());
154 }
155
156 private void doTestStatusCode(int responseCode) throws IOException {
157 tileServer.stubFor(get(urlEqualTo("/httpstat/" + responseCode)).willReturn(aResponse().withStatus(responseCode)));
158 TestCachedTileLoaderJob job = getStatusLoaderJob(responseCode);
159 Listener listener = submitJob(job);
160 assertEquals(responseCode, listener.attributes.getResponseCode());
161 }
162
163 private Listener submitJob(TestCachedTileLoaderJob job) throws IOException {
164 return submitJob(job, true);
165 }
166
167 private Listener submitJob(TestCachedTileLoaderJob job, boolean force) throws IOException {
168 Listener listener = new Listener();
169 job.submit(listener, force);
170 synchronized (listener) {
171 while (!listener.ready) {
172 try {
173 listener.wait();
174 } catch (InterruptedException e) {
175 // do nothing, wait
176 Logging.trace(e);
177 }
178 }
179 }
180 return listener;
181 }
182
183 /**
184 * That no request is made when entry is in cache and force == false
185 * @throws IOException exception
186 */
187 @Test
188 void testNoRequestMadeWhenEntryInCache() throws IOException {
189 ICacheAccess<String, CacheEntry> cache = getCache();
190 long expires = TimeUnit.DAYS.toMillis(1);
191 long testStart = System.currentTimeMillis();
192 cache.put("test",
193 new CacheEntry("cached entry".getBytes(StandardCharsets.UTF_8)),
194 createEntryAttributes(expires, 200, testStart, "eTag")
195 );
196 createHeadGetStub(urlEqualTo("/test"), expires, testStart, "eTag", "mock entry");
197
198 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test");
199 Listener listener = submitJob(job, false);
200 tileServer.verify(0, getRequestedFor(anyUrl()));
201 assertArrayEquals("cached entry".getBytes(StandardCharsets.UTF_8), listener.data);
202 }
203
204 /**
205 * that request is made, when object is in cache, but force mode is used
206 * @throws IOException exception
207 */
208 @Test
209 void testRequestMadeWhenEntryInCacheAndForce() throws IOException {
210 ICacheAccess<String, CacheEntry> cache = getCache();
211 long expires = TimeUnit.DAYS.toMillis(1);
212 long testStart = System.currentTimeMillis();
213 cache.put("test",
214 new CacheEntry("cached dummy".getBytes(StandardCharsets.UTF_8)),
215 createEntryAttributes(expires, 200, testStart + expires, "eTag")
216 );
217 createHeadGetStub(urlEqualTo("/test"), expires, testStart, "eTag", "mock entry");
218
219 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test");
220 Listener listener = submitJob(job, true);
221 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
222 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
223 }
224
225 /**
226 * Mock returns no cache-control / expires headers
227 * Expire time should be set to DEFAULT_EXPIRE_TIME
228 * @throws IOException exception
229 */
230 @Test
231 void testSettingMinimumExpiryWhenNoExpires() throws IOException {
232 long testStart = System.currentTimeMillis();
233 tileServer.stubFor(get(urlEqualTo("/test")).willReturn(aResponse().withBody("mock entry")));
234
235 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test");
236 Listener listener = submitJob(job, false);
237 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
238
239 assertTrue(listener.attributes.getExpirationTime() >= testStart + JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME,
240 "Cache entry expiration is " + (listener.attributes.getExpirationTime() - testStart) + " which is not larger than " +
241 JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME + " (DEFAULT_EXPIRE_TIME)");
242
243 assertTrue(listener.attributes.getExpirationTime() <= System.currentTimeMillis() + JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME,
244 "Cache entry expiration is " +
245 (listener.attributes.getExpirationTime() - System.currentTimeMillis()) +
246 " which is not less than " +
247 JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME + " (DEFAULT_EXPIRE_TIME)"
248 );
249
250 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
251 }
252
253 /**
254 * Mock returns expires headers, but Cache-Control
255 * Expire time should be set to max-age
256 * @throws IOException exception
257 */
258 @Test
259 void testSettingExpireByMaxAge() throws IOException {
260 long testStart = System.currentTimeMillis();
261 long expires = TimeUnit.DAYS.toSeconds(1);
262 tileServer.stubFor(get(urlEqualTo("/test"))
263 .willReturn(aResponse()
264 .withHeader("Cache-control", "max-age=" + expires)
265 .withBody("mock entry")
266 )
267 );
268
269 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test");
270 Listener listener = submitJob(job, false);
271 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
272
273 assertTrue(listener.attributes.getExpirationTime() >= testStart + TimeUnit.SECONDS.toMillis(expires),
274 "Cache entry expiration is " + (listener.attributes.getExpirationTime() - testStart) + " which is not larger than " +
275 TimeUnit.SECONDS.toMillis(expires) + " (max-age)");
276
277 assertTrue(
278 listener.attributes.getExpirationTime() <= System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(expires),
279 "Cache entry expiration is " +
280 (listener.attributes.getExpirationTime() - System.currentTimeMillis()) +
281 " which is not less than " +
282 TimeUnit.SECONDS.toMillis(expires) + " (max-age)"
283 );
284
285 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
286 }
287
288 /**
289 * mock returns expiration: JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10
290 * minimum expire time: JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2
291 * @throws IOException exception
292 */
293 @Test
294 void testSettingMinimumExpiryByMinimumExpiryTimeLessThanDefault() throws IOException {
295 long testStart = System.currentTimeMillis();
296 int minimumExpiryTimeSeconds = (int) (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2);
297
298 createHeadGetStub(urlEqualTo("/test"), (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10), testStart, "eTag", "mock entry");
299
300 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test", minimumExpiryTimeSeconds);
301 Listener listener = submitJob(job, false);
302 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
303 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
304
305
306 assertTrue(
307 listener.attributes.getExpirationTime() >= testStart + TimeUnit.SECONDS.toMillis(minimumExpiryTimeSeconds),
308 "Cache entry expiration is " + (listener.attributes.getExpirationTime() - testStart) + " which is not larger than " +
309 TimeUnit.SECONDS.toMillis(minimumExpiryTimeSeconds) + " (minimumExpireTime)");
310
311 assertTrue(
312 listener.attributes.getExpirationTime() <= System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(minimumExpiryTimeSeconds),
313 "Cache entry expiration is " +
314 (listener.attributes.getExpirationTime() - System.currentTimeMillis()) +
315 " which is not less than " +
316 TimeUnit.SECONDS.toMillis(minimumExpiryTimeSeconds) + " (minimumExpireTime)"
317 );
318 }
319
320 /**
321 * mock returns expiration: JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10
322 * minimum expire time: JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME * 2
323 * @throws IOException exception
324 */
325
326 @Test
327 void testSettingMinimumExpiryByMinimumExpiryTimeGreaterThanDefault() throws IOException {
328 long testStart = System.currentTimeMillis();
329 int minimumExpiryTimeSeconds = (int) (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME * 2);
330
331 createHeadGetStub(urlEqualTo("/test"), (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10), testStart, "eTag", "mock entry");
332
333 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test", minimumExpiryTimeSeconds);
334 Listener listener = submitJob(job, false);
335 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
336 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
337
338
339 assertTrue(
340 listener.attributes.getExpirationTime() >= testStart + TimeUnit.SECONDS.toMillis(minimumExpiryTimeSeconds),
341 "Cache entry expiration is " + (listener.attributes.getExpirationTime() - testStart) + " which is not larger than " +
342 TimeUnit.SECONDS.toMillis(minimumExpiryTimeSeconds) + " (minimumExpireTime)");
343
344 assertTrue(
345 listener.attributes.getExpirationTime() <= System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(minimumExpiryTimeSeconds),
346 "Cache entry expiration is " +
347 (listener.attributes.getExpirationTime() - System.currentTimeMillis()) +
348 " which is not less than " +
349 TimeUnit.SECONDS.toMillis(minimumExpiryTimeSeconds) + " (minimumExpireTime)"
350 );
351 }
352
353 /**
354 * Check if Cache-Control takes precedence over max-age
355 * Expires is lower - JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10
356 * Cache control : JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2
357 *
358 * Both are smaller than DEFAULT_EXPIRE_TIME, so we can test, that it's not DEFAULT_EXPIRE_TIME that extended
359 * expiration
360 *
361 * @throws IOException exception
362 */
363
364 @Test
365 void testCacheControlVsExpires() throws IOException {
366 long testStart = System.currentTimeMillis();
367 int minimumExpiryTimeSeconds = 0;
368
369 tileServer.stubFor(get(urlEqualTo("/test"))
370 .willReturn(aResponse()
371 .withHeader("Expires", TestUtils.getHTTPDate(testStart + (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10)))
372 .withHeader("Cache-Control", "max-age=" +
373 TimeUnit.MILLISECONDS.toSeconds((JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2)))
374 .withBody("mock entry")
375 )
376 );
377 tileServer.stubFor(head(urlEqualTo("/test"))
378 .willReturn(aResponse()
379 .withHeader("Expires", TestUtils.getHTTPDate(testStart + (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10)))
380 .withHeader("Cache-Control", "max-age=" +
381 TimeUnit.MILLISECONDS.toSeconds((JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2)))
382 )
383 );
384 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test", minimumExpiryTimeSeconds);
385 Listener listener = submitJob(job, false);
386 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
387 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
388
389
390 assertTrue(
391 listener.attributes.getExpirationTime() >= testStart + (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10),
392 "Cache entry expiration is " + (listener.attributes.getExpirationTime() - testStart) + " which is not larger than " +
393 (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10) + " (Expires header)");
394
395 assertTrue(listener.attributes.getExpirationTime() <= System.currentTimeMillis() + (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2),
396 "Cache entry expiration is " +
397 (listener.attributes.getExpirationTime() - System.currentTimeMillis()) +
398 " which is not less than " +
399 (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2) + " (Cache-Control: max-age=)"
400 );
401 }
402
403 /**
404 * Check if Cache-Control s-max-age is honored
405 * mock returns expiration: JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10
406 * minimum expire time: JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME * 2
407 *
408 * @throws IOException exception
409 */
410 @Test
411 void testMaxAgeVsSMaxAge() throws IOException {
412 long testStart = System.currentTimeMillis();
413 int minimumExpiryTimeSeconds = 0;
414
415 tileServer.stubFor(get(urlEqualTo("/test"))
416 .willReturn(aResponse()
417 .withHeader("Cache-Control", "" +
418 "max-age=" + TimeUnit.MILLISECONDS.toSeconds((JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10)) + "," +
419 "s-max-age=" + TimeUnit.MILLISECONDS.toSeconds((JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2))
420 )
421 .withBody("mock entry")
422 )
423 );
424 tileServer.stubFor(head(urlEqualTo("/test"))
425 .willReturn(aResponse()
426 .withHeader("Cache-Control", "" +
427 "max-age=" + TimeUnit.MILLISECONDS.toSeconds((JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10)) + "," +
428 "s-max-age=" + TimeUnit.MILLISECONDS.toSeconds((JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2))
429 )
430 ));
431 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test", minimumExpiryTimeSeconds);
432 Listener listener = submitJob(job, false);
433 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
434 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
435
436 assertTrue(
437 listener.attributes.getExpirationTime() >= testStart + (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10),
438 "Cache entry expiration is " + (listener.attributes.getExpirationTime() - testStart) + " which is not larger than " +
439 (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 10) + " (Cache-Control: max-age)");
440
441 assertTrue(listener.attributes.getExpirationTime() <= System.currentTimeMillis() + (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2),
442 "Cache entry expiration is " +
443 (listener.attributes.getExpirationTime() - System.currentTimeMillis()) +
444 " which is not less than " +
445 (JCSCachedTileLoaderJob.DEFAULT_EXPIRE_TIME / 2) + " (Cache-Control: s-max-age)"
446 );
447 }
448
449 /**
450 * Check if verifying cache entries using HEAD requests work properly
451 * @throws IOException exception
452 */
453 @Test
454 void testCheckUsingHead() throws IOException {
455 ICacheAccess<String, CacheEntry> cache = getCache();
456 long expires = TimeUnit.DAYS.toMillis(1);
457 long testStart = System.currentTimeMillis();
458 cache.put("test",
459 new CacheEntry("cached dummy".getBytes(StandardCharsets.UTF_8)),
460 createEntryAttributes(-1 * expires, 200, testStart, "eTag--gzip") // Jetty adds --gzip to etags when compressing output
461 );
462
463 tileServer.stubFor(get(urlEqualTo("/test"))
464 .willReturn(aResponse()
465 .withHeader("Expires", TestUtils.getHTTPDate(testStart + expires))
466 .withHeader("Last-Modified", Long.toString(testStart))
467 .withHeader("ETag", "eTag") // Jetty adds "--gzip" suffix for compressed content
468 .withBody("mock entry")
469 )
470 );
471 tileServer.stubFor(head(urlEqualTo("/test"))
472 .willReturn(aResponse()
473 .withHeader("Expires", TestUtils.getHTTPDate(testStart + expires))
474 .withHeader("Last-Modified", Long.toString(testStart))
475 .withHeader("ETag", "eTag--gzip") // but doesn't add to uncompressed
476 )
477 );
478
479 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test");
480 Listener listener = submitJob(job, false); // cache entry is expired, no need to force refetch
481 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
482 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
483
484 // cache entry should be retrieved from cache
485 listener = submitJob(job, false);
486 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
487 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
488
489 // invalidate entry in cache
490 ICacheElement<String, CacheEntry> cacheEntry = cache.getCacheElement("test");
491 CacheEntryAttributes attributes = (CacheEntryAttributes) cacheEntry.getElementAttributes();
492 attributes.setExpirationTime(testStart - TimeUnit.DAYS.toMillis(1));
493 cache.put("test", cacheEntry.getVal(), attributes);
494
495 // because cache entry is invalid - HEAD request shall be made
496 tileServer.verify(0, headRequestedFor(urlEqualTo("/test"))); // no head requests were made until now
497 listener = submitJob(job, false);
498 tileServer.verify(1, headRequestedFor(urlEqualTo("/test"))); // verify head requests were made
499 tileServer.verify(1, getRequestedFor(urlEqualTo("/test"))); // verify no more get requests were made
500 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
501 assertTrue(listener.attributes.getExpirationTime() >= testStart + expires);
502
503 // cache entry should be retrieved from cache
504 listener = submitJob(job, false); // cache entry is expired, no need to force refetch
505 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
506 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
507 assertArrayEquals("mock entry".getBytes(StandardCharsets.UTF_8), listener.data);
508 }
509
510 /**
511 * Check if server returns 304 - it will update cache attributes and not ask again for it
512 * @throws IOException exception
513 */
514 @Test
515 void testCheckUsing304() throws IOException {
516 ICacheAccess<String, CacheEntry> cache = getCache();
517 long expires = TimeUnit.DAYS.toMillis(1);
518 long testStart = System.currentTimeMillis();
519 cache.put("test",
520 new CacheEntry("cached dummy".getBytes(StandardCharsets.UTF_8)),
521 createEntryAttributes(-1 * expires, 200, testStart, "eTag")
522 );
523
524 tileServer.stubFor(get(urlEqualTo("/test"))
525 .willReturn(status(304)
526 .withHeader("Expires", TestUtils.getHTTPDate(testStart + expires))
527 .withHeader("Last-Modified", Long.toString(testStart))
528 .withHeader("ETag", "eTag")
529 )
530 );
531
532 TestCachedTileLoaderJob job = new TestCachedTileLoaderJob(tileServer.url("/test"), "test");
533 Listener listener = submitJob(job, false);
534 tileServer.verify(1, getRequestedFor(urlEqualTo("/test")));
535 assertArrayEquals("cached dummy".getBytes(StandardCharsets.UTF_8), listener.data);
536 assertTrue(testStart + expires <= listener.attributes.getExpirationTime());
537 submitJob(job, false);
538 tileServer.verify(1, getRequestedFor(urlEqualTo("/test"))); // no more requests were made
539 }
540
541 private void createHeadGetStub(UrlPattern url, long expires, long lastModified, String eTag, String body) {
542 tileServer.stubFor(get(url)
543 .willReturn(aResponse()
544 .withHeader("Expires", TestUtils.getHTTPDate(lastModified + expires))
545 .withHeader("Last-Modified", Long.toString(lastModified))
546 .withHeader("ETag", eTag)
547 .withBody(body)
548 )
549 );
550 tileServer.stubFor(head(url)
551 .willReturn(aResponse()
552 .withHeader("Expires", TestUtils.getHTTPDate(lastModified + expires))
553 .withHeader("Last-Modified", Long.toString(lastModified))
554 .withHeader("ETag", eTag)
555 )
556 );
557 }
558
559 private CacheEntryAttributes createEntryAttributes(long expirationTime, int responseCode, long lastModification, String eTag) {
560 CacheEntryAttributes entryAttributes = new CacheEntryAttributes();
561 entryAttributes.setExpirationTime(lastModification + expirationTime);
562 entryAttributes.setResponseCode(responseCode);
563 entryAttributes.setLastModification(lastModification);
564 entryAttributes.setEtag(eTag);
565 return entryAttributes;
566 }
567
568 private TestCachedTileLoaderJob getStatusLoaderJob(int responseCode) {
569 return new TestCachedTileLoaderJob(tileServer.url("/httpstat/" + responseCode), "key_" + responseCode);
570 }
571
572 private static ICacheAccess<String, CacheEntry> getCache() {
573 return JCSCacheManager.getCache("test");
574 }
575}
Note: See TracBrowser for help on using the repository browser.