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_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_malformed_virtual_url_parts(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest("/foo")
self.request["VIRTUAL_URL_PARTS"] = ("foo", )
self.assertEqual(["/foo"], self.rewriter("/foo"))
self.request["VIRTUAL_URL_PARTS"] = ()
self.assertEqual(["/foo"], self.rewriter("/foo"))
self.request["VIRTUAL_URL_PARTS"] = (
"http://example.com",
"",
"/foo",
"x",
)
self.assertEqual(["/foo"], self.rewriter("/foo"))
self.request["VIRTUAL_URL_PARTS"] = "foo"
self.assertEqual(["/foo"], self.rewriter("/foo"))
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 setUp(self):
provideAdapter(persistentFieldAdapter)
self.registry = Registry()
self.registry.registerInterface(ICachePurgingSettings)
provideUtility(self.registry, IRegistry)
self.settings = self.registry.forInterface(ICachePurgingSettings)
self.settings.enabled = True
self.settings.cachingProxies = ('http://localhost:1234', )
@implementer(IPurgePaths)
class FauxPurgePaths(object):
adapts(FauxContext)
def __init__(self, context):
self.context = context
def getRelativePaths(self):
return ['/foo', '/bar']
def getAbsolutePaths(self):
return []
provideAdapter(FauxPurgePaths, name="test1")
@implementer(IPurger)
class FauxPurger(object):
def purgeSync(self, url, httpVerb='PURGE'):
return "200 OK", "cached", None
provideUtility(FauxPurger())
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_purge(self):
request = FauxRequest()
alsoProvides(request, IAttributeAnnotatable)
IAnnotations(request)['plone.cachepurging.urls'] = set(
['/foo', '/bar'])
registry = Registry()
registry.registerInterface(ICloudflareSettings)
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings = registry.forInterface(ICloudflareSettings)
settings.apiKey = u'foobar'
settings.domains = (u'www.foobar.com', )
settings.email = u'*****@*****.**'
notify(PubSuccess(request))
self.assertEqual(len(self.purger.purged), 4)
self.assertEqual(
self.purger.purged[0],
('https://www.cloudflare.com/api_json.html?a=zone_file_purge&'
'tkn=foobar&url=http%2Fwww.foobar.com%2F%2Ffoo&'
'email=foo%40bar.com&z=www.foobar.com'))
def setUp(self):
super(RegJSONifyTestCase, self).setUp()
#gsm = getGlobalSiteManager()
#gsm.registerAdapter(UnknownFieldJSONAdapter, (IUnknown,), provided=IJSONFieldDumper)
self.registry = Registry()
self.registry.registerInterface(ITest)
self.proxy = self.registry.forInterface(ITest)
def test_request_not_annotatable(self):
request = FauxRequest()
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings.cachingProxies = ('http://localhost:1234',)
@implementer(IPurger)
class FauxPurger(object):
def __init__(self):
self.purged = []
def purgeAsync(self, url, httpVerb='PURGE'):
self.purged.append(url)
purger = FauxPurger()
provideUtility(purger)
notify(PubSuccess(request))
self.assertEqual([], purger.purged)
def test_request_not_annotatable(self):
context = FauxContext()
request = FauxRequest()
setRequest(request)
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings.cachingProxies = ('http://localhost:1234',)
@implementer(IPurgePaths)
@adapter(FauxContext)
class FauxPurgePaths(object):
def __init__(self, context):
self.context = context
def getRelativePaths(self):
return ['/foo', '/bar']
def getAbsolutePaths(self):
return []
provideAdapter(FauxPurgePaths, name="test1")
try:
notify(Purge(context))
except:
self.fail()
def setUp(self):
"""Additional test setup."""
self.portal = self.layer['portal']
alsoProvides(self.portal.REQUEST, IMLSSpecific)
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.registry = Registry()
self.registry.registerInterface(IMLSSettings)
def test_caching_disabled(self):
request = FauxRequest()
alsoProvides(request, IAttributeAnnotatable)
IAnnotations(request)["plone.cachepurging.urls"] = set(
["/foo", "/bar"])
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = False
settings.cachingProxies = ("http://localhost:1234", )
@implementer(IPurger)
class FauxPurger(object):
def __init__(self):
self.purged = []
def purgeAsync(self, url, httpVerb="PURGE"):
self.purged.append(url)
purger = FauxPurger()
provideUtility(purger)
notify(PubSuccess(request))
self.assertEqual([], purger.purged)
def setUp(self):
"""Custom shared utility setup for tests."""
self.app = self.layer['app']
self.portal = self.layer['portal']
self.qi = getToolByName(self.portal, 'portal_quickinstaller')
self.registry = Registry()
self.registry.registerInterface(IConteudoSettings)
def test_enabled(self):
context = FauxContext()
request = FauxRequest()
alsoProvides(request, IAttributeAnnotatable)
setRequest(request)
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings.cachingProxies = ('http://localhost:1234',)
@implementer(IPurgePaths)
@adapter(FauxContext)
class FauxPurgePaths(object):
def __init__(self, context):
self.context = context
def getRelativePaths(self):
return ['/foo', '/bar']
def getAbsolutePaths(self):
return []
provideAdapter(FauxPurgePaths, name="test1")
notify(Purge(context))
self.assertEqual({'plone.cachepurging.urls': set(['/foo', '/bar'])},
dict(IAnnotations(request)))
def test_purge(self):
request = FauxRequest()
alsoProvides(request, IAttributeAnnotatable)
IAnnotations(request)['plone.cachepurging.urls'] = set(
['/foo', '/bar'])
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings.cachingProxies = ('http://localhost:1234',)
@implementer(IPurger)
class FauxPurger(object):
def __init__(self):
self.purged = []
def purgeAsync(self, url, httpVerb='PURGE'):
self.purged.append(url)
purger = FauxPurger()
provideUtility(purger)
notify(PubSuccess(request))
self.assertEqual(
['http://localhost:1234/foo', 'http://localhost:1234/bar'],
purger.purged
)
def setUp(self):
"""Custom setup for tests."""
self.portal = self.layer['portal']
from plone.app.vocabularies.tests import base
context = base.create_context()
rids = ('1', '2',)
tool = base.DummyCatalog(rids)
context.portal_catalog = tool
context.portal_url = base.DummyUrlTool(context)
from Products.PluginIndexes.KeywordIndex.KeywordIndex import KeywordIndex # noqa
kwindex = KeywordIndex('Subject')
tool.indexes['Subject'] = kwindex
from Products.ExtendedPathIndex.ExtendedPathIndex import ExtendedPathIndex # noqa
pathindex = ExtendedPathIndex('path')
tool.indexes['path'] = pathindex
self.subjects_1 = ['Berlin', 'Wien', 'Paris', 'Barcelona']
self.subjects_2 = ['Montreal', 'Washington', 'Brasilia']
self.navroot1 = base.DummyContentWithParent('nr1', parent=context)
alsoProvides(self.navroot1, INavigationRoot)
self.navroot2 = base.DummyContentWithParent('nr2', parent=context)
alsoProvides(self.navroot2, INavigationRoot)
self.doc1 = base.DummyContentWithParent(
'doc1',
subjects=self.subjects_1,
parent=self.navroot1
)
kwindex._index_object(1, self.doc1, attr='Subject')
pathindex.index_object(1, self.doc1)
self.doc2 = base.DummyContentWithParent(
'doc2',
subjects=self.subjects_2,
parent=self.navroot2
)
kwindex._index_object(2, self.doc2, attr='Subject')
pathindex.index_object(2, self.doc2)
from plone.app.vocabularies.catalog import KeywordsVocabulary
self.vocab = KeywordsVocabulary()
# mock our registry
from plone.registry import Registry
from plone.registry.interfaces import IRegistry
from zope.component import getSiteManager
sm = getSiteManager()
from Products.CMFCore.interfaces import ICatalogTool
sm.registerUtility(tool, ICatalogTool)
registry = Registry()
sm.registerUtility(registry, IRegistry)
from Products.CMFCore.interfaces import IURLTool
sm.registerUtility(context.portal_url, IURLTool)
registry_patcher = mock.patch('plone.registry.registry.Registry.get')
self.addCleanup(registry_patcher.stop)
self.registry_mock = registry_patcher.start()
def test_passed_registry(self):
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
self.assertEqual(False, utils.isCachePurgingEnabled())
self.assertEqual(True, utils.isCachePurgingEnabled(registry))
def test_lookupOption_no_record(self):
provideUtility(Registry(), IRegistry)
result = lookupOption('plone.caching.tests',
'testrule',
'test',
default=_marker)
self.assertTrue(result is _marker)
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_enabled(self):
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
self.assertEqual(True, utils.isCachePurgingEnabled())
def test_empty_request(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self.request.clear()
self.assertEqual(['/foo'], self.rewriter('/foo'))
def setUp(self):
self.portal = self.layer['portal']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
# set up settings registry
self.registry = Registry()
self.registry.registerInterface(ISettings)
request = self.portal.REQUEST
alsoProvides(request, ILayer)
def test_virtual_hosting_disabled(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = False
self._prepareVHMRequest('/foo')
self.assertEqual(['/foo'], self.rewriter('/foo'))
def createRegistry(self, xml):
"""Create a registry from a minimal set of fields and operators"""
from plone.app.registry.exportimport.handler import RegistryImporter
gsm = getGlobalSiteManager()
self.registry = Registry()
gsm.registerUtility(self.registry, IRegistry)
importer = RegistryImporter(self.registry, self)
importer.importDocument(xml)
return self.registry
def test_passed_registry(self):
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings.cachingProxies = ('http://localhost:1234', )
self.assertEqual(False, utils.isCachePurgingEnabled())
self.assertEqual(True, utils.isCachePurgingEnabled(registry))
def test_no_virtual_url_parts(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest('/foo')
del self.request['VIRTUAL_URL_PARTS']
self.assertEqual(['/foo'], self.rewriter('/foo'))
def test_https(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest('/foo', domain='example.com:81', protocol='https')
self.assertEqual(['/VirtualHostBase/https/example.com:81/plone/VirtualHostRoot/foo'],
self.rewriter('/foo'))
def test_no_virtual_root_physical_path(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest('/foo')
del self.request['VirtualRootPhysicalPath']
self.assertEqual(['/foo'], self.rewriter('/foo'))
def setUp(self):
gsm = getGlobalSiteManager()
self.registry = Registry()
gsm.registerUtility(self.registry, IRegistry)
self.setFunctionForOperation(
'plone.app.querystring.operation.string.is.operation',
'plone.app.querystring.queryparser._equal')
self.setFunctionForOperation(
'plone.app.querystring.operation.string.path.operation',
'plone.app.querystring.queryparser._path')
def test_disabled(self):
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = False
settings.cachingProxies = ('http://localhost:1234', )
self.assertEqual(False, utils.isCachePurgingEnabled())
