def test_off_switch(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = False
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
return u"dummy"
provideAdapter(DummyOperation, name="op1")
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_off_switch(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = False
z3c.caching.registry.register(DummyView, "testrule")
settings.operationMapping = {"testrule": "op1"}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def interceptResponse(self, rulename, response):
return None
def modifyResponse(self, rulename, response):
response["X-Mutated"] = rulename
provideAdapter(DummyOperation, name="op1")
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u"", "utf-8")
self.assertEquals({"PUBLISHED": view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_off_switch(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = False
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
return u"dummy"
provideAdapter(DummyOperation, name="op1")
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_swallow_other_error(self):
@implementer(IRulesetLookup)
@adapter(Interface, Interface)
class DummyRulesetLookup(object):
def __init__(self, published, request):
self.published = published
self.request = request
def __call__(self):
raise AttributeError('Should be swallowed and logged')
provideAdapter(DummyRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
settings.operationMapping = {'foo': 'bar'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
try:
intercept(DummyEvent(request))
except Exception:
self.fail('Intercept should not raise')
def test_match_abort(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, "testrule")
settings.operationMapping = {"testrule": "op1"}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader("X-Cache-Foo", "test")
return None
provideAdapter(DummyOperation, name="op1")
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEquals({"PUBLISHED": view}, dict(request))
self.assertEquals({"X-Cache-Rule": ["testrule"], "X-Cache-Foo": ["test"]}, dict(request.response))
def test_dont_swallow_conflict_error(self):
@implementer(IRulesetLookup)
@adapter(Interface, Interface)
class DummyRulesetLookup(object):
def __init__(self, published, request):
self.published = published
self.request = request
def __call__(self):
raise ConflictError()
provideAdapter(DummyRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
settings.operationMapping = {'foo': 'bar'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
self.assertRaises(ConflictError, intercept, DummyEvent(request))
def test_match_abort(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
@implementer(ICachingOperation)
@adapter(Interface, Interface)
class DummyOperation(object):
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
return None
provideAdapter(DummyOperation, name='op1')
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({'X-Cache-Rule': ['testrule'],
'X-Cache-Foo': ['test']}, dict(request.response))
def test_off_switch(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = False
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def interceptResponse(self, rulename, response):
return None
def modifyResponse(self, rulename, response):
response['X-Mutated'] = rulename
provideAdapter(DummyOperation, name="op1")
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u"", "utf-8")
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_swallow_other_error(self):
@implementer(IRulesetLookup)
@adapter(Interface, Interface)
class DummyRulesetLookup(object):
def __init__(self, published, request):
self.published = published
self.request = request
def __call__(self):
raise AttributeError('Should be swallowed and logged')
provideAdapter(DummyRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
settings.operationMapping = {'foo': 'bar'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
try:
intercept(DummyEvent(request))
except Exception:
self.fail('Intercept should not raise')
def test_off_switch(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = False
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
@implementer(ICachingOperation)
@adapter(Interface, Interface)
class DummyOperation(object):
def __init__(self, published, request):
self.published = published
self.request = request
def interceptResponse(self, rulename, response):
return None
def modifyResponse(self, rulename, response):
response['X-Mutated'] = rulename
provideAdapter(DummyOperation, name='op1')
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u'', 'utf-8')
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def test_off_switch(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = False
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
@implementer(ICachingOperation)
@adapter(Interface, Interface)
class DummyOperation(object):
def __init__(self, published, request):
self.published = published
self.request = request
def interceptResponse(self, rulename, response):
return None
def modifyResponse(self, rulename, response):
response['X-Mutated'] = rulename
provideAdapter(DummyOperation, name='op1')
view = DummyView()
response = DummyResponse()
request = DummyRequest(view, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def test_no_mappings(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
published = ZopePageTemplate('someView')
request = DummyRequest(published, DummyResponse())
self.assertEqual(None, ContentItemLookup(published, request)())
def test_no_mappings(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
published = ZopePageTemplate("someView")
request = DummyRequest(published, DummyResponse())
self.assertEquals(None, ContentItemLookup(published, request)())
def test_template_lookup(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {"someView": "rule1"}
published = ZopePageTemplate("someView")
request = DummyRequest(published, DummyResponse())
self.assertEquals("rule1", ContentItemLookup(published, request)())
def test_template_lookup(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {'someView': 'rule1'}
published = ZopePageTemplate('someView')
request = DummyRequest(published, DummyResponse())
self.assertEqual('rule1', ContentItemLookup(published, request)())
def test_match_body_explicitly_enable_transform_chain(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
@implementer(ICachingOperation)
@adapter(Interface, Interface)
class DummyOperation(object):
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
response.setStatus(304)
self.request.environ['plone.transformchain.disable'] = False
return u'dummy'
provideAdapter(DummyOperation, name='op1')
view = DummyView()
request = DummyRequest(view, DummyResponse())
try:
intercept(DummyEvent(request))
self.fail()
except Intercepted as e:
self.assertEqual(u'dummy', e.responseBody)
self.assertEqual(304, e.status)
self.assertEqual(304, request.response.status)
self.assertEqual(True, request.response.locked)
except Exception as e:
self.fail(str(e))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual(
{'plone.transformchain.disable': False},
request.environ
)
self.assertEqual(
{'X-Cache-Rule': ['testrule'],
'X-Cache-Operation': ['op1'],
'X-Cache-Foo': ['test']},
dict(request.response)
)
def test_parent_not_content(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {'testtype': 'rule1'}
published = ZopePageTemplate('defaultView').__of__(DummyNotContent())
request = DummyRequest(published, DummyResponse())
self.assertEqual(None, ContentItemLookup(published, request)())
def test_contenttype_not_default_view(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {"testtype": "rule1"}
published = ZopePageTemplate("someView").__of__(DummyContent())
request = DummyRequest(published, DummyResponse())
self.assertEquals(None, ContentItemLookup(published, request)())
def test_parent_not_IBrowserDefault_default_method(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {"testtype": "rule1"}
published = ZopePageTemplate("defaultView").__of__(DummyNotBrowserDefault("testtype", "string:${object_url}/"))
request = DummyRequest(published, DummyResponse())
self.assertEquals("rule1", ContentItemLookup(published, request)())
def test_parent_not_content(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {'testtype': 'rule1'}
published = ZopePageTemplate('defaultView').__of__(DummyNotContent())
request = DummyRequest(published, DummyResponse())
self.assertEqual(None, ContentItemLookup(published, request)())
def test_no_published_object(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
request = DummyRequest(None, DummyResponse())
intercept(DummyEvent(request))
self.assertEqual({'PUBLISHED': None}, dict(request))
self.assertEqual({}, dict(request.response))
def test_no_published_object(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
request = DummyRequest(None, DummyResponse())
intercept(DummyEvent(request))
self.assertEqual({'PUBLISHED': None}, dict(request))
self.assertEqual({}, dict(request.response))
def test_parent_not_IBrowserDefault_actiononly(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {'testtype': 'rule1'}
published = ZopePageTemplate('defaultView').__of__(DummyNotBrowserDefault('testtype', 'string:${object_url}/defaultView'))
request = DummyRequest(published, DummyResponse())
self.assertEqual('rule1', ContentItemLookup(published, request)())
def test_no_published_object(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
request = DummyRequest(None, DummyResponse())
MutatorTransform(None, request).transformUnicode(u'', 'utf-8')
self.assertEqual({'PUBLISHED': None}, dict(request))
self.assertEqual({}, dict(request.response))
def test_contenttype_class_lookup_type_override(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {"testtype": "rule2"}
z3c.caching.registry.register(DummyContent, "rule1")
published = ZopePageTemplate("defaultView").__of__(DummyContent())
request = DummyRequest(published, DummyResponse())
self.assertEquals("rule2", ContentItemLookup(published, request)())
def test_contenttype_class_lookup_type_override(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {'testtype': 'rule2'}
z3c.caching.registry.register(DummyContent, 'rule1')
published = ZopePageTemplate('defaultView').__of__(DummyContent())
request = DummyRequest(published, DummyResponse())
self.assertEqual('rule2', ContentItemLookup(published, request)())
def test_no_published_object(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
request = DummyRequest(None, DummyResponse())
MutatorTransform(None, request).transformUnicode(u'', 'utf-8')
self.assertEqual({'PUBLISHED': None}, dict(request))
self.assertEqual({}, dict(request.response))
def test_parent_not_IBrowserDefault_actiononly(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {'testtype': 'rule1'}
published = ZopePageTemplate('defaultView').__of__(
DummyNotBrowserDefault('testtype',
'string:${object_url}/defaultView'))
request = DummyRequest(published, DummyResponse())
self.assertEqual('rule1', ContentItemLookup(published, request)())
def test_no_published_object(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
response = DummyResponse()
request = DummyRequest(None, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEquals({"PUBLISHED": None}, dict(request))
self.assertEquals({}, dict(request.response))
def test_no_cache_rule(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
settings.operationMapping = {'testrule': 'dummy'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def test_contenttype_class_lookup_browser_view(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {}
z3c.caching.registry.register(DummyContent, 'rule1')
published = DummyView(DummyContent(), None)
request = DummyRequest(published, DummyResponse())
published.request = published
self.assertEqual('rule1', ContentItemLookup(published, request)())
def test_no_cache_rule(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
settings.operationMapping = {'testrule': 'dummy'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def test_contenttype_class_lookup_browser_view(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.templateRulesetMapping = {}
ploneSettings.contentTypeRulesetMapping = {}
z3c.caching.registry.register(DummyContent, "rule1")
published = DummyView(DummyContent(), None)
request = DummyRequest(published, DummyResponse())
published.request = published
self.assertEquals("rule1", ContentItemLookup(published, request)())
def test_no_cache_rule(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
settings.operationMapping = {'testrule': 'dummy'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u"", "utf-8")
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_no_lookup_adapter(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'dummy'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u'', 'utf-8')
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def test_no_lookup_adapter(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'dummy'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u'', 'utf-8')
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def test_no_cache_rule(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
settings.operationMapping = {"testrule": "dummy"}
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u"", "utf-8")
self.assertEquals({"PUBLISHED": view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_no_mapping(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u"", "utf-8")
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_operation_not_found(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, "testrule")
settings.operationMapping = {"testrule": "notfound"}
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEquals({"PUBLISHED": view}, dict(request))
self.assertEquals({"X-Cache-Rule": ["testrule"]}, dict(request.response))
def test_operation_name_not_found(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'foo': 'bar'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u"", "utf-8")
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({'X-Cache-Rule': ['testrule']}, dict(request.response))
def test_operation_not_found(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'notfound'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({'X-Cache-Rule': ['testrule']},
dict(request.response))
def test_no_mapping(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
view = DummyView()
response = DummyResponse()
request = DummyRequest(view, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_no_cache_rule(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
settings.operationMapping = {"testrule": "dummy"}
view = DummyView()
response = DummyResponse()
request = DummyRequest(view, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEquals({"PUBLISHED": view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_no_lookup_adapter(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'dummy'}
view = DummyView()
response = DummyResponse()
request = DummyRequest(view, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def test_no_lookup_adapter(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'dummy'}
view = DummyView()
response = DummyResponse()
request = DummyRequest(view, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def test_operation_name_not_found(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'foo': 'bar'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformUnicode(u'', 'utf-8')
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({'X-Cache-Rule': ['testrule']},
dict(request.response))
def test_no_mapping(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
view = DummyView()
response = DummyResponse()
request = DummyRequest(view, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({}, dict(request.response))
def test_match_method(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyResource, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def interceptResponse(self, rulename, response):
return None
def modifyResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
provideAdapter(DummyOperation, name="op1")
resource = DummyResource()
response = DummyResponse()
request = DummyRequest(resource.index_html, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEquals({'PUBLISHED': resource.index_html}, dict(request))
self.assertEquals(
{
'X-Cache-Rule': ['testrule'],
'X-Cache-Operation': ['op1'],
'X-Cache-Foo': ['test']
}, dict(request.response))
def test_match_body_explicitly_enable_transform_chain(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, "testrule")
settings.operationMapping = {"testrule": "op1"}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader("X-Cache-Foo", "test")
response.setStatus(304)
self.request.environ["plone.transformchain.disable"] = False
return u"dummy"
provideAdapter(DummyOperation, name="op1")
view = DummyView()
request = DummyRequest(view, DummyResponse())
try:
intercept(DummyEvent(request))
self.fail()
except Intercepted, e:
self.assertEquals(u"dummy", e.responseBody)
self.assertEquals(304, e.status)
self.assertEquals(304, request.response.status)
self.assertEquals(True, request.response.locked)
def test_match_body_explicitly_enable_transform_chain(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
response.setStatus(304)
self.request.environ['plone.transformchain.disable'] = False
return u"dummy"
provideAdapter(DummyOperation, name="op1")
view = DummyView()
request = DummyRequest(view, DummyResponse())
try:
intercept(DummyEvent(request))
self.fail()
except Intercepted, e:
self.assertEquals(u"dummy", e.responseBody)
self.assertEquals(304, e.status)
self.assertEquals(304, request.response.status)
self.assertEquals(True, request.response.locked)
def test_match_body_method(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyResource, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
response.setStatus(200)
return u"dummy"
provideAdapter(DummyOperation, name="op1")
resource = DummyResource()
request = DummyRequest(resource.index_html, DummyResponse())
try:
intercept(DummyEvent(request))
self.fail()
except Intercepted, e:
self.assertEquals(u"dummy", e.responseBody)
self.assertEquals(200, e.status)
self.assertEquals(200, request.response.status)
self.assertEquals(True, request.response.locked)
def test_match_iterable(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def interceptResponse(self, rulename, response):
return None
def modifyResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
provideAdapter(DummyOperation, name="op1")
view = DummyView()
request = DummyRequest(view, DummyResponse())
MutatorTransform(view, request).transformIterable([""], "utf-8")
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals(
{
'X-Cache-Rule': ['testrule'],
'X-Cache-Operation': ['op1'],
'X-Cache-Foo': ['test']
}, dict(request.response))
def test_match_body_method(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyResource, "testrule")
settings.operationMapping = {"testrule": "op1"}
class DummyOperation(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader("X-Cache-Foo", "test")
response.setStatus(200)
return u"dummy"
provideAdapter(DummyOperation, name="op1")
resource = DummyResource()
request = DummyRequest(resource.index_html, DummyResponse())
try:
intercept(DummyEvent(request))
self.fail()
except Intercepted, e:
self.assertEquals(u"dummy", e.responseBody)
self.assertEquals(200, e.status)
self.assertEquals(200, request.response.status)
self.assertEquals(True, request.response.locked)
def test_match_body(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
@implementer(ICachingOperation)
@adapter(Interface, Interface)
class DummyOperation(object):
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
response.setStatus(304)
return u'dummy'
provideAdapter(DummyOperation, name='op1')
view = DummyView()
request = DummyRequest(view, DummyResponse())
try:
intercept(DummyEvent(request))
self.fail()
except Intercepted, e:
self.assertEqual(u'dummy', e.responseBody)
self.assertEqual(304, e.status)
self.assertEqual(304, request.response.status)
self.assertEqual(True, request.response.locked)
def test_dont_swallow_conflict_error(self):
@implementer(IRulesetLookup)
@adapter(Interface, Interface)
class DummyRulesetLookup(object):
def __init__(self, published, request):
self.published = published
self.request = request
def __call__(self):
raise ConflictError()
provideAdapter(DummyRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
settings.operationMapping = {'foo': 'bar'}
view = DummyView()
request = DummyRequest(view, DummyResponse())
self.assertRaises(ConflictError, intercept, DummyEvent(request))
def test_match_abort(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
@implementer(ICachingOperation)
@adapter(Interface, Interface)
class DummyOperation(object):
def __init__(self, published, request):
self.published = published
self.request = request
def modifyResponse(self, rulename, response):
pass
def interceptResponse(self, rulename, response):
response.addHeader('X-Cache-Foo', 'test')
return None
provideAdapter(DummyOperation, name='op1')
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual(
{
'X-Cache-Rule': ['testrule'],
'X-Cache-Foo': ['test']
}, dict(request.response))
