def test_get_version_caching(self):
headers = self.add_authorization_header(username='******')
url = '{0}/{1}/en/{2}'.format(self._prefix,
str(self.xreport1.document_id),
str(self.xreport1_version.id))
cache_key = '{0}-{1}'.format(
get_cache_key(self.xreport1.document_id, 'en'),
self.xreport1_version.id)
cache_value = cache_document_version.get(cache_key)
self.assertEqual(cache_value, NO_VALUE)
# check that the response is cached
self.app.get(url, headers=headers, status=200)
cache_value = cache_document_version.get(cache_key)
self.assertNotEqual(cache_value, NO_VALUE)
# check that values are returned from the cache
fake_cache_value = {'document': 'fake doc'}
cache_document_version.set(cache_key, fake_cache_value)
response = self.app.get(url, headers=headers, status=200)
body = response.json
self.assertEqual(body, fake_cache_value)
def _get_version(self,
clazz,
document_type,
locale_clazz,
schema,
adapt_schema=None):
document_id = self.request.validated['id']
lang = self.request.validated['lang']
version_id = self.request.validated['version_id']
def create_response():
return self._load_version(document_id, lang, version_id, clazz,
locale_clazz, schema, adapt_schema)
base_cache_key = get_cache_key(document_id,
lang,
document_type=document_type)
if not base_cache_key:
raise HTTPNotFound(
'no version for document {0}'.format(document_id))
else:
cache_key = '{0}-{1}'.format(base_cache_key, version_id)
# set and check the etag: if the etag value provided in the
# request equals the current etag, return 'NotModified'
etag_cache(self.request, cache_key)
return get_or_create(cache_document_version, cache_key,
create_response)
def _get(self, clazz, schema, clazz_locale=None, adapt_schema=None,
include_maps=False, include_areas=True,
set_custom_associations=None, set_custom_fields=None,
custom_cache_key=None):
id = self.request.validated['id']
lang = self.request.validated.get('lang')
editing_view = self.request.GET.get('e', '0') != '0'
def create_response():
return self._get_in_lang(
id, lang, clazz, schema, editing_view, clazz_locale,
adapt_schema, include_maps, include_areas,
set_custom_associations, set_custom_fields)
if not editing_view:
cache_key = get_cache_key(id, lang, custom_cache_key)
if cache_key:
# set and check the etag: if the etag value provided in the
# request equals the current etag, return 'NotModified'
etag_cache(self.request, cache_key)
return get_or_create(
cache_document_detail, cache_key, create_response)
# don't cache if requesting a document for editing
return create_response()
def test_get_version_caching(self):
headers = self.add_authorization_header(username='******')
url = '{0}/{1}/en/{2}'.format(
self._prefix, str(self.xreport1.document_id),
str(self.xreport1_version.id))
cache_key = '{0}-{1}'.format(
get_cache_key(self.xreport1.document_id, 'en'),
self.xreport1_version.id)
cache_value = cache_document_version.get(cache_key)
self.assertEqual(cache_value, NO_VALUE)
# check that the response is cached
self.app.get(url, headers=headers, status=200)
cache_value = cache_document_version.get(cache_key)
self.assertNotEqual(cache_value, NO_VALUE)
# check that values are returned from the cache
fake_cache_value = {'document': 'fake doc'}
cache_document_version.set(cache_key, fake_cache_value)
response = self.app.get(url, headers=headers, status=200)
body = response.json
self.assertEqual(body, fake_cache_value)
def _get(self, clazz, schema, clazz_locale=None, adapt_schema=None,
include_maps=False, include_areas=True,
set_custom_associations=None, set_custom_fields=None,
custom_cache_key=None):
id = self.request.validated['id']
lang = self.request.validated.get('lang')
editing_view = self.request.GET.get('e', '0') != '0'
def create_response():
return self._get_in_lang(
id, lang, clazz, schema, editing_view, clazz_locale,
adapt_schema, include_maps, include_areas,
set_custom_associations, set_custom_fields)
if not editing_view:
cache_key = get_cache_key(id, lang, custom_cache_key)
if cache_key:
# set and check the etag: if the etag value provided in the
# request equals the current etag, return 'NotModified'
etag_cache(self.request, cache_key)
return get_or_create(
cache_document_detail, cache_key, create_response)
# don't cache if requesting a document for editing
return create_response()
def get_caching(self, reference, user=None):
headers = {} if not user else \
self.add_authorization_header(username=user)
url = '{0}/{1}'.format(self._prefix, str(reference.document_id))
cache_key = get_cache_key(reference.document_id,
None,
document_type=self._doc_type)
cache_value = cache_document_detail.get(cache_key)
self.assertEqual(cache_value, NO_VALUE)
# check that the response is cached
self.app.get(url, headers=headers, status=200)
cache_value = cache_document_detail.get(cache_key)
self.assertNotEqual(cache_value, NO_VALUE)
# check that values are returned from the cache
fake_cache_value = {'document': 'fake doc'}
cache_document_detail.set(cache_key, fake_cache_value)
response = self.app.get(url, headers=headers, status=200)
body = response.json
self.assertEqual(body, fake_cache_value)
# check that cache handles document types
prefix = "/routes" if self._prefix != "/routes" else "/waypoint"
url = '{0}/{1}'.format(prefix, str(reference.document_id))
self.app.get(url, headers=headers, status=404)
def _get(self,
document_config,
schema,
clazz_locale=None,
adapt_schema=None,
include_maps=False,
include_areas=True,
set_custom_associations=None,
set_custom_fields=None,
custom_cache_key=None):
id = self.request.validated['id']
lang = self.request.validated.get('lang')
editing_view = self.request.GET.get('e', '0') != '0'
cook = self.request.validated.get('cook')
if cook and lang:
raise HTTPBadRequest(
"You can't use cook service with explicit lang query")
if cook and editing_view:
raise HTTPBadRequest(
"You can't use cook service with edition mode")
if cook:
lang = cook
cache = cache_document_cooked if cook else cache_document_detail
def create_response():
return self._get_in_lang(id,
lang,
document_config.clazz,
schema,
editing_view,
clazz_locale,
adapt_schema,
include_maps,
include_areas,
set_custom_associations,
set_custom_fields,
cook_locale=cook)
if not editing_view:
cache_key = get_cache_key(
id,
lang,
document_type=document_config.document_type,
custom_cache_key=custom_cache_key)
if cache_key:
# set and check the etag: if the etag value provided in the
# request equals the current etag, return 'NotModified'
etag_cache(self.request, cache_key)
return get_or_create(cache, cache_key, create_response)
# don't cache if requesting a document for editing
return create_response()
def _get_document_info(self, clazz):
document_id = self.request.validated['id']
lang = self.request.validated['lang']
def create_response():
return self._load_document_info(document_id, lang, clazz)
cache_key = get_cache_key(document_id, lang)
if not cache_key:
raise HTTPNotFound(
'no version for document {0}'.format(document_id))
else:
etag_cache(self.request, cache_key)
return get_or_create(cache_document_info, cache_key,
create_response)
def _get_document_info(self, clazz):
document_id = self.request.validated['id']
lang = self.request.validated['lang']
def create_response():
return self._load_document_info(document_id, lang, clazz)
cache_key = get_cache_key(document_id, lang)
if not cache_key:
raise HTTPNotFound(
'no version for document {0}'.format(document_id))
else:
etag_cache(self.request, cache_key)
return get_or_create(
cache_document_info, cache_key, create_response)
def get(self):
document_id = self.request.validated['id']
lang = self.request.validated['lang']
def create_response():
return self._get_history(document_id, lang)
cache_key = get_cache_key(document_id, lang)
if not cache_key:
raise HTTPNotFound(
'no version for document {0}'.format(document_id))
else:
# set and check the etag: if the etag value provided in the
# request equals the current etag, return 'NotModified'
etag_cache(self.request, cache_key)
return get_or_create(
cache_document_history, cache_key, create_response)
def get(self):
document_id = self.request.validated['id']
lang = self.request.validated['lang']
def create_response():
return self._get_history(document_id, lang)
cache_key = get_cache_key(document_id, lang)
if not cache_key:
raise HTTPNotFound(
'no version for document {0}'.format(document_id))
else:
# set and check the etag: if the etag value provided in the
# request equals the current etag, return 'NotModified'
etag_cache(self.request, cache_key)
return get_or_create(
cache_document_history, cache_key, create_response)
def _get_version(self, clazz, locale_clazz, schema, adapt_schema=None):
document_id = self.request.validated['id']
lang = self.request.validated['lang']
version_id = self.request.validated['version_id']
def create_response():
return self._load_version(
document_id, lang, version_id, clazz, locale_clazz, schema,
adapt_schema)
base_cache_key = get_cache_key(document_id, lang)
if not base_cache_key:
raise HTTPNotFound(
'no version for document {0}'.format(document_id))
else:
cache_key = '{0}-{1}'.format(base_cache_key, version_id)
# set and check the etag: if the etag value provided in the
# request equals the current etag, return 'NotModified'
etag_cache(self.request, cache_key)
return get_or_create(
cache_document_version, cache_key, create_response)
def test_get_version_caching(self):
url = '{0}/{1}/en/{2}'.format(self._prefix,
str(self.book1.document_id),
str(self.book1_version.id))
cache_key = '{0}-{1}'.format(
get_cache_key(self.book1.document_id, 'en'), self.book1_version.id)
cache_value = cache_document_version.get(cache_key)
self.assertEqual(cache_value, NO_VALUE)
# check that the response is cached
self.app.get(url, status=200)
cache_value = cache_document_version.get(cache_key)
self.assertNotEqual(cache_value, NO_VALUE)
# check that values are returned from the cache
fake_cache_value = {'document': 'fake doc'}
cache_document_version.set(cache_key, fake_cache_value)
response = self.app.get(url, status=200)
body = response.json
self.assertEqual(body, fake_cache_value)
def test_get_version_caching(self):
url = '{0}/{1}/en/{2}'.format(
self._prefix, str(self.book1.document_id),
str(self.book1_version.id))
cache_key = '{0}-{1}'.format(
get_cache_key(self.book1.document_id, 'en'),
self.book1_version.id)
cache_value = cache_document_version.get(cache_key)
self.assertEqual(cache_value, NO_VALUE)
# check that the response is cached
self.app.get(url, status=200)
cache_value = cache_document_version.get(cache_key)
self.assertNotEqual(cache_value, NO_VALUE)
# check that values are returned from the cache
fake_cache_value = {'document': 'fake doc'}
cache_document_version.set(cache_key, fake_cache_value)
response = self.app.get(url, status=200)
body = response.json
self.assertEqual(body, fake_cache_value)
