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_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 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.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
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_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_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_no_registry(self):
provideAdapter(DefaultRulesetLookup)
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def test_no_registry(self):
provideAdapter(DefaultRulesetLookup)
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, 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'}
@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_no_records(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
view = DummyView()
request = DummyRequest(view, DummyResponse())
intercept(DummyEvent(request))
self.assertEquals({"PUBLISHED": view}, dict(request))
self.assertEquals({}, 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_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_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_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_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_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_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_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_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_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)
