class TestCacheVaryByAuthorization(object):
url = 'http://foo.com/bar'
def setup(self):
self.c = CacheController(
DictCache(),
serializer=NullSerializer(),
)
def req(self, headers):
mock_request = Mock(url=self.url, headers=headers)
return self.c.cached_request(mock_request)
def test_uses_auth_token_to_lookup_response(self):
req_headers = {'Authorization': 'Bearer some-token'}
resp_headers = {'Vary': 'Authorization'}
request = type('Request', (object, ), {
'headers': req_headers,
'url': self.url
})()
expected_key = CacheController.cache_key(request)
response = Mock(headers=resp_headers, status=301)
# we set the status to 301 so that it is immediately returned without performing any etag/date checks to see if
# cache eviction is required
self.c.cache = DictCache({expected_key: response})
assert self.req(headers=req_headers) == response
class TestCacheControlRequest(object):
url = "http://foo.com/bar"
def setup(self):
self.c = CacheController(DictCache(), serializer=NullSerializer())
def req(self, headers):
mock_request = Mock(url=self.url, headers=headers)
return self.c.cached_request(mock_request)
def test_cache_request_no_headers(self):
cached_resp = Mock(headers={
"ETag": "jfd9094r808",
"Content-Length": 100
})
self.c.cache = DictCache({self.url: cached_resp})
resp = self.req({})
assert not resp
def test_cache_request_no_cache(self):
resp = self.req({"cache-control": "no-cache"})
assert not resp
def test_cache_request_pragma_no_cache(self):
resp = self.req({"pragma": "no-cache"})
assert not resp
def test_cache_request_no_store(self):
resp = self.req({"cache-control": "no-store"})
assert not resp
def test_cache_request_max_age_0(self):
resp = self.req({"cache-control": "max-age=0"})
assert not resp
def test_cache_request_not_in_cache(self):
resp = self.req({})
assert not resp
def test_cache_request_fresh_max_age(self):
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={"cache-control": "max-age=3600", "date": now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_max_age(self):
earlier = time.time() - 3700 # epoch - 1h01m40s
now = time.strftime(TIME_FMT, time.gmtime(earlier))
resp = Mock(headers={"cache-control": "max-age=3600", "date": now})
self.c.cache = DictCache({self.url: resp})
r = self.req({})
assert not r
def test_cache_request_fresh_expires(self):
later = time.time() + 86400 # GMT + 1 day
expires = time.strftime(TIME_FMT, time.gmtime(later))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={"expires": expires, "date": now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_expires(self):
sooner = time.time() - 86400 # GMT - 1 day
expires = time.strftime(TIME_FMT, time.gmtime(sooner))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={"expires": expires, "date": now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert not r
def test_cached_request_with_bad_max_age_headers_not_returned(self):
now = time.strftime(TIME_FMT, time.gmtime())
# Not a valid header; this would be from a misconfigured server
resp = Mock(headers={"cache-control": "max-age=xxx", "date": now})
self.c.cache = DictCache({self.url: resp})
assert not self.req({})
class TestCacheControlRequest(object):
url = 'http://foo.com/bar'
def setup(self):
self.c = CacheController(
DictCache(),
serializer=NullSerializer(),
)
def req(self, headers):
return self.c.cached_request(Mock(url=self.url, headers=headers))
def test_cache_request_no_cache(self):
resp = self.req({'cache-control': 'no-cache'})
assert not resp
def test_cache_request_pragma_no_cache(self):
resp = self.req({'pragma': 'no-cache'})
assert not resp
def test_cache_request_no_store(self):
resp = self.req({'cache-control': 'no-store'})
assert not resp
def test_cache_request_max_age_0(self):
resp = self.req({'cache-control': 'max-age=0'})
assert not resp
def test_cache_request_not_in_cache(self):
resp = self.req({})
assert not resp
def test_cache_request_fresh_max_age(self):
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'cache-control': 'max-age=3600',
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_max_age(self):
earlier = time.time() - 3700 # epoch - 1h01m40s
now = time.strftime(TIME_FMT, time.gmtime(earlier))
resp = Mock(headers={'cache-control': 'max-age=3600',
'date': now})
self.c.cache = DictCache({self.url: resp})
r = self.req({})
assert not r
def test_cache_request_fresh_expires(self):
later = time.time() + 86400 # GMT + 1 day
expires = time.strftime(TIME_FMT, time.gmtime(later))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'expires': expires,
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_expires(self):
sooner = time.time() - 86400 # GMT - 1 day
expires = time.strftime(TIME_FMT, time.gmtime(sooner))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'expires': expires,
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert not r
class TestCacheControlRequest(object):
url = 'http://foo.com/bar'
def setup(self):
self.c = CacheController(DictCache())
def req(self, headers):
return self.c.cached_request(self.url, headers=headers)
def test_cache_request_no_cache(self):
resp = self.req({'cache-control': 'no-cache'})
assert not resp
def test_cache_request_pragma_no_cache(self):
resp = self.req({'pragma': 'no-cache'})
assert not resp
def test_cache_request_no_store(self):
resp = self.req({'cache-control': 'no-store'})
assert not resp
def test_cache_request_max_age_0(self):
resp = self.req({'cache-control': 'max-age=0'})
assert not resp
def test_cache_request_not_in_cache(self):
resp = self.req({})
assert not resp
def test_cache_request_fresh_max_age(self):
now = datetime.datetime.utcnow().strftime(TIME_FMT)
resp = Mock(headers={'cache-control': 'max-age=3600',
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_max_age(self):
earlier = time.time() - 3700
now = datetime.datetime.fromtimestamp(earlier).strftime(TIME_FMT)
resp = Mock(headers={'cache-control': 'max-age=3600',
'date': now})
self.c.cache = DictCache({self.url: resp})
r = self.req({})
assert not r
def test_cache_request_fresh_expires(self):
later = datetime.timedelta(days=1)
expires = (datetime.datetime.utcnow() + later).strftime(TIME_FMT)
now = datetime.datetime.utcnow().strftime(TIME_FMT)
resp = Mock(headers={'expires': expires,
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_expires(self):
later = datetime.timedelta(days=-1)
expires = (datetime.datetime.utcnow() + later).strftime(TIME_FMT)
now = datetime.datetime.utcnow().strftime(TIME_FMT)
resp = Mock(headers={'expires': expires,
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert not r
class TestCacheControlRequest(object):
url = 'http://foo.com/bar'
def setup(self):
self.c = CacheController(
DictCache(),
serializer=NullSerializer(),
)
def req(self, headers):
mock_request = Mock(url=self.url, headers=headers)
return self.c.cached_request(mock_request)
def test_cache_request_no_headers(self):
cached_resp = Mock(headers={
'ETag': 'jfd9094r808',
'Content-Length': 100
})
self.c.cache = DictCache({self.url: cached_resp})
resp = self.req({})
assert not resp
def test_cache_request_no_cache(self):
resp = self.req({'cache-control': 'no-cache'})
assert not resp
def test_cache_request_pragma_no_cache(self):
resp = self.req({'pragma': 'no-cache'})
assert not resp
def test_cache_request_no_store(self):
resp = self.req({'cache-control': 'no-store'})
assert not resp
def test_cache_request_max_age_0(self):
resp = self.req({'cache-control': 'max-age=0'})
assert not resp
def test_cache_request_not_in_cache(self):
resp = self.req({})
assert not resp
def test_cache_request_fresh_max_age(self):
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'cache-control': 'max-age=3600', 'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_max_age(self):
earlier = time.time() - 3700 # epoch - 1h01m40s
now = time.strftime(TIME_FMT, time.gmtime(earlier))
resp = Mock(headers={'cache-control': 'max-age=3600', 'date': now})
self.c.cache = DictCache({self.url: resp})
r = self.req({})
assert not r
def test_cache_request_fresh_expires(self):
later = time.time() + 86400 # GMT + 1 day
expires = time.strftime(TIME_FMT, time.gmtime(later))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'expires': expires, 'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_expires(self):
sooner = time.time() - 86400 # GMT - 1 day
expires = time.strftime(TIME_FMT, time.gmtime(sooner))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'expires': expires, 'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert not r
def test_cached_request_with_bad_max_age_headers_not_returned(self):
now = time.strftime(TIME_FMT, time.gmtime())
# Not a valid header; this would be from a misconfigured server
resp = Mock(headers={'cache-control': 'max-age=xxx', 'date': now})
self.c.cache = DictCache({self.url: resp})
assert not self.req({})
def test_cached_request_with_0_max_age_not_returned(self):
self.c.cache = DictCache({self.url: 1000000})
assert self.req({'cache-control': 'max-age=0'}) is False
def test_cached_request_without_date_and_etags_is_evicted(self):
resp = Mock(headers={'xx': 'this-value-is-unimportant'})
self.c.cache = DictCache({self.url: resp})
assert self.c.cache.get(self.url) is not None
assert self.req({}) is False
assert self.c.cache.get(self.url) is None
class TestCacheControlRequest(object):
url = 'http://foo.com/bar'
def setup(self):
self.c = CacheController(
DictCache(),
serializer=NullSerializer(),
)
def req(self, headers):
mock_request = Mock(url=self.url, headers=headers)
return self.c.cached_request(mock_request)
def test_cache_request_no_headers(self):
cached_resp = Mock(headers={'ETag': 'jfd9094r808', 'Content-Length': 100})
self.c.cache = DictCache({self.url: cached_resp})
resp = self.req({})
assert not resp
def test_cache_request_no_cache(self):
resp = self.req({'cache-control': 'no-cache'})
assert not resp
def test_cache_request_pragma_no_cache(self):
resp = self.req({'pragma': 'no-cache'})
assert not resp
def test_cache_request_no_store(self):
resp = self.req({'cache-control': 'no-store'})
assert not resp
def test_cache_request_max_age_0(self):
resp = self.req({'cache-control': 'max-age=0'})
assert not resp
def test_cache_request_not_in_cache(self):
resp = self.req({})
assert not resp
def test_cache_request_fresh_max_age(self):
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'cache-control': 'max-age=3600',
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_max_age(self):
earlier = time.time() - 3700 # epoch - 1h01m40s
now = time.strftime(TIME_FMT, time.gmtime(earlier))
resp = Mock(headers={'cache-control': 'max-age=3600',
'date': now})
self.c.cache = DictCache({self.url: resp})
r = self.req({})
assert not r
def test_cache_request_fresh_expires(self):
later = time.time() + 86400 # GMT + 1 day
expires = time.strftime(TIME_FMT, time.gmtime(later))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'expires': expires,
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_expires(self):
sooner = time.time() - 86400 # GMT - 1 day
expires = time.strftime(TIME_FMT, time.gmtime(sooner))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'expires': expires,
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert not r
def test_cached_request_with_bad_max_age_headers_not_returned(self):
now = time.strftime(TIME_FMT, time.gmtime())
# Not a valid header; this would be from a misconfigured server
resp = Mock(headers={'cache-control': 'max-age=xxx',
'date': now})
self.c.cache = DictCache({self.url: resp})
assert not self.req({})
class TestCacheControlRequest(object):
url = 'http://foo.com/bar'
def setup(self):
self.c = CacheController(
DictCache(),
serializer=NullSerializer(),
)
def req(self, headers):
mock_request = Mock(url=self.url, headers=headers)
return self.c.cached_request(mock_request)
def test_cache_request_no_headers(self):
cached_resp = Mock(headers={'ETag': 'jfd9094r808', 'Content-Length': 100})
self.c.cache = DictCache({self.url: cached_resp})
resp = self.req({})
assert not resp
def test_cache_request_no_cache(self):
resp = self.req({'cache-control': 'no-cache'})
assert not resp
def test_cache_request_pragma_no_cache(self):
resp = self.req({'pragma': 'no-cache'})
assert not resp
def test_cache_request_no_store(self):
resp = self.req({'cache-control': 'no-store'})
assert not resp
def test_cache_request_max_age_0(self):
resp = self.req({'cache-control': 'max-age=0'})
assert not resp
def test_cache_request_not_in_cache(self):
resp = self.req({})
assert not resp
def test_cache_request_fresh_max_age(self):
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'cache-control': 'max-age=3600',
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_max_age(self):
earlier = time.time() - 3700 # epoch - 1h01m40s
now = time.strftime(TIME_FMT, time.gmtime(earlier))
resp = Mock(headers={'cache-control': 'max-age=3600',
'date': now})
self.c.cache = DictCache({self.url: resp})
r = self.req({})
assert not r
def test_cache_request_fresh_expires(self):
later = time.time() + 86400 # GMT + 1 day
expires = time.strftime(TIME_FMT, time.gmtime(later))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'expires': expires,
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert r == resp
def test_cache_request_unfresh_expires(self):
sooner = time.time() - 86400 # GMT - 1 day
expires = time.strftime(TIME_FMT, time.gmtime(sooner))
now = time.strftime(TIME_FMT, time.gmtime())
resp = Mock(headers={'expires': expires,
'date': now})
cache = DictCache({self.url: resp})
self.c.cache = cache
r = self.req({})
assert not r
