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 test_purge_no_config(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
class FauxPurger(object):
implements(IPurger)
def __init__(self):
self.purged = []
def purgeAsync(self, url, httpVerb="PURGE"):
self.purged.append(url)
purger = FauxPurger()
provideUtility(purger)
notify(PubSuccess(request))
self.assertEquals([], purger.purged)
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)
class TestQueuePurge(unittest.TestCase):
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',)
self.handler = Handler()
provideHandler(self.handler.handler)
def tearDown(self):
zope.component.testing.tearDown()
def test_disabled(self):
self.settings.enabled = False
view = QueuePurge(FauxContext(), FauxRequest())
self.assertEqual('Caching not enabled', view())
self.assertEqual([], self.handler.invocations)
def test_enabled(self):
self.settings.enabled = True
context = FauxContext()
view = QueuePurge(context, FauxRequest)
self.assertEqual('Queued', view())
self.assertEqual(1, len(self.handler.invocations))
self.assertTrue(self.handler.invocations[0].object is context)
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)))
class TestQueuePurge(unittest.TestCase):
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', )
self.handler = Handler()
provideHandler(self.handler.handler)
def tearDown(self):
zope.component.testing.tearDown()
def test_disabled(self):
self.settings.enabled = False
view = QueuePurge(FauxContext(), FauxRequest())
self.assertEqual('Caching not enabled', view())
self.assertEqual([], self.handler.invocations)
def test_enabled(self):
self.settings.enabled = True
context = FauxContext()
view = QueuePurge(context, FauxRequest)
self.assertEqual('Queued', view())
self.assertEqual(1, len(self.handler.invocations))
self.assertTrue(self.handler.invocations[0].object is context)
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 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 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 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"))
class TestSettings(unittest.TestCase):
layer = COLLECTIVE_MOBIFYJS_INTEGRATION_TESTING
def setUp(self):
self.portal = self.layer['portal']
self.registry = Registry()
self.registry.registerInterface(ISettings)
def test_setup(self):
pq = getToolByName(self.portal, 'portal_quickinstaller')
self.assertTrue(pq.isProductInstalled('collective.mobifyjs'))
def test_registry(self):
settings = self.registry.forInterface(ISettings)
self.assertEquals(settings.mobify_library_url, RESIZE_URL)
self.assertEquals(settings.mobify_resize_backend, None)
def test_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="collective.mobifyjs-settings")
self.assertEqual(view.__class__, SettingsView)
self.failUnless(view())
class TestControlPanel(unittest.TestCase):
"""Test installation of observatorio.conteudo into Plone."""
layer = INTEGRATION_TESTING
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_conteudo_controlpanel_view(self):
# Test the conteudo setting control panel view
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="conteudo-settings")
view = view.__of__(self.portal)
self.failUnless(view())
def test_conteudo_controlpanel_view_protected(self):
# Test that the conteudo setting control panel view can not be accessed
# by anonymous users
from AccessControl import Unauthorized
logout()
self.assertRaises(Unauthorized, self.portal.restrictedTraverse,
'@@conteudo-settings')
def test_conteudo_in_controlpanel(self):
# Check that there is an conteudo entry in the control panel
self.controlpanel = getToolByName(self.portal, "portal_controlpanel")
self.failUnless(
'conteudo' in
[a.getAction(self)['id'] for a in self.controlpanel.listActions()])
def test_record_area_tematica(self):
# Test that the area_tematica record is in the control panel
settings = self.registry.forInterface(IConteudoSettings)
record_area_tematica = settings.area_tematica
self.failUnless('area_tematica' in IConteudoSettings)
self.assertEquals(record_area_tematica, None)
def test_record_eixo_atuacao(self):
settings = self.registry.forInterface(IConteudoSettings)
record_eixo_atuacao = settings.eixo_atuacao
self.failUnless('eixo_atuacao' in IConteudoSettings)
self.assertEquals(record_eixo_atuacao, None)
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_enabled(self):
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
self.assertEqual(True, utils.isCachePurgingEnabled())
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_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_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 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_enabled(self):
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings.cachingProxies = ('http://localhost:1234',)
self.assertEquals(True, utils.isCachePurgingEnabled())
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_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 test_no_virtual_url(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest("/foo")
del self.request["VIRTUAL_URL"]
self.assertEqual(["/foo"], self.rewriter("/foo"))
class TestControlPanel(unittest.TestCase):
"""Test installation of observatorio.conteudo into Plone."""
layer = INTEGRATION_TESTING
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_conteudo_controlpanel_view(self):
# Test the conteudo setting control panel view
view = getMultiAdapter((self.portal, self.portal.REQUEST), name="conteudo-settings")
view = view.__of__(self.portal)
self.failUnless(view())
def test_conteudo_controlpanel_view_protected(self):
# Test that the conteudo setting control panel view can not be accessed
# by anonymous users
from AccessControl import Unauthorized
logout()
self.assertRaises(Unauthorized, self.portal.restrictedTraverse, '@@conteudo-settings')
def test_conteudo_in_controlpanel(self):
# Check that there is an conteudo entry in the control panel
self.controlpanel = getToolByName(self.portal, "portal_controlpanel")
self.failUnless('conteudo' in [a.getAction(self)['id'] for a in self.controlpanel.listActions()])
def test_record_area_tematica(self):
# Test that the area_tematica record is in the control panel
settings = self.registry.forInterface(IConteudoSettings)
record_area_tematica = settings.area_tematica
self.failUnless('area_tematica' in IConteudoSettings)
self.assertEquals(record_area_tematica, None)
def test_record_eixo_atuacao(self):
settings = self.registry.forInterface(IConteudoSettings)
record_eixo_atuacao = settings.eixo_atuacao
self.failUnless('eixo_atuacao' in IConteudoSettings)
self.assertEquals(record_eixo_atuacao, None)
def test_standard_vhm(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest('/foo')
self.assertEqual(['/VirtualHostBase/http/example.com/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 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_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_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())
def test_virtual_root_is_app_root(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest('/foo', root='/')
self.assertEquals(['/VirtualHostBase/http/example.com/VirtualHostRoot/foo'],
self.rewriter('/foo'))
def test_virtual_path_is_deep(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest('/foo/bar', root='/plone')
self.assertEqual(['/VirtualHostBase/http/example.com/plone/VirtualHostRoot/foo/bar'],
self.rewriter('/foo/bar'))
def test_inside_out_hosting(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest('/foo', root='/bar/plone', prefix='/foo/bar')
self.assertEquals(['/VirtualHostBase/http/example.com/bar/plone/VirtualHostRoot/_vh_foo/_vh_bar/foo'],
self.rewriter('/foo'))
class TestPurgeImmediately(unittest.TestCase):
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)
@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")
@implementer(IPurger)
class FauxPurger(object):
def purgeSync(self, url, httpVerb="PURGE"):
return "200 OK", "cached", None
provideUtility(FauxPurger())
def tearDown(self):
zope.component.testing.tearDown()
def test_disabled(self):
self.settings.enabled = False
view = PurgeImmediately(FauxContext(), FauxRequest())
self.assertEqual("Caching not enabled", view())
def test_purge(self):
view = PurgeImmediately(FauxContext(), FauxRequest())
self.assertEqual(
"Purged: http://localhost:1234/foo, "
"Status: 200 OK, "
"X-Cache: cached, "
"Error: None\n"
"Purged: http://localhost:1234/bar, "
"Status: 200 OK, "
"X-Cache: cached, "
"Error: None\n",
view(),
)
def test_caching_disabled(self):
request = FauxRequest()
alsoProvides(request, IAttributeAnnotatable)
IAnnotations(request)['plone.cachepurging.urls'] = set(
['/foo', '/bar'])
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
registry.registerInterface(ICloudflareSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = False
settings = registry.forInterface(ICloudflareSettings)
settings.apiKey = u'foobar'
settings.domains = (u'www.foobar.com', )
notify(PubSuccess(request))
self.assertEqual([], self.purger.purged)
def test_nonstandard_port(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest("/foo", domain="example.com:81")
self.assertEqual(
["/VirtualHostBase/http/example.com:81/plone/VirtualHostRoot/foo"],
self.rewriter("/foo"),
)
def test_domains_w_different_path_in_request(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
settings.domains = ('http://example.org:81', 'https://example.com:82')
self._prepareVHMRequest('/bar', domain='example.com:81', protocol='https')
self.assertEqual(['/VirtualHostBase/http/example.org:81/plone/VirtualHostRoot/foo',
'/VirtualHostBase/https/example.com:82/plone/VirtualHostRoot/foo'],
self.rewriter('/foo'))
def test_inside_out_hosting_root_empty_path(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest('/', root='/plone', prefix='/plone')
self.assertEqual(
['/VirtualHostBase/http/example.com/plone/VirtualHostRoot/_vh_plone'],
self.rewriter(''))
class TestPurgeImmediately(unittest.TestCase):
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)
@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")
@implementer(IPurger)
class FauxPurger(object):
def purgeSync(self, url, httpVerb="PURGE"):
return "200 OK", "cached", None
provideUtility(FauxPurger())
def tearDown(self):
zope.component.testing.tearDown()
def test_disabled(self):
self.settings.enabled = False
view = PurgeImmediately(FauxContext(), FauxRequest())
self.assertEqual("Caching not enabled", view())
def test_purge(self):
view = PurgeImmediately(FauxContext(), FauxRequest())
self.assertEqual(
"Purged: http://localhost:1234/foo, "
"Status: 200 OK, "
"X-Cache: cached, "
"Error: None\n"
"Purged: http://localhost:1234/bar, "
"Status: 200 OK, "
"X-Cache: cached, "
"Error: None\n",
view(),
)
def test_no_proxies(self):
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = False
settings.cachingProxies = None
self.assertEqual(False, utils.isCachePurgingEnabled())
settings.cachingProxies = ()
self.assertEqual(False, utils.isCachePurgingEnabled())
def test_virtual_root_is_app_root(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest("/foo", root="/")
self.assertEqual(
["/VirtualHostBase/http/example.com/VirtualHostRoot/foo"],
self.rewriter("/foo"),
)
def test_inside_out_hosting_root_empty_path(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest('/', root='/plone', prefix='/plone')
self.assertEqual(
['/VirtualHostBase/http/example.com/plone/'
'VirtualHostRoot/_vh_plone'],
self.rewriter(''))
def test_no_proxies(self):
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = False
settings.cachingProxies = None
self.assertEqual(False, utils.isCachePurgingEnabled())
settings.cachingProxies = ()
self.assertEqual(False, utils.isCachePurgingEnabled())
def test_virtual_path_is_empty(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest("", root="/plone")
self.assertEqual(
["/VirtualHostBase/http/example.com/plone/VirtualHostRoot"],
self.rewriter(""),
)
def setUp(self):
provideAdapter(persistentFieldAdapter)
registry = Registry()
registry.registerInterface(ISolrSettings)
provideUtility(registry, IRegistry)
self.settings = registry.forInterface(ISolrSettings)
self.settings.simple_search_term_pattern = (
u'Title:{term}^10 OR SearchableText:{term} OR '
u'SearchableText:{term}*')
self.settings.simple_search_phrase_pattern = (
u'Title:"{phrase}"^20 OR SearchableText:"{phrase}"^5 OR '
u'SearchableText:"{phrase}*"^2')
self.settings.complex_search_pattern = (
u'Title:({phrase})^10 OR SearchableText:({phrase})')
self.settings.local_query_parameters = u''
def test_inside_out_hosting(self):
registry = Registry()
provideUtility(registry, IRegistry)
registry.registerInterface(ICachePurgingSettings)
settings = registry.forInterface(ICachePurgingSettings)
settings.virtualHosting = True
self._prepareVHMRequest("/foo", root="/bar/plone", prefix="/foo/bar")
self.assertEqual(
[
"/VirtualHostBase/http/example.com/bar/plone/"
"VirtualHostRoot/_vh_foo/_vh_bar/foo"
],
self.rewriter("/foo"),
)
def test_no_purger(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',)
try:
notify(PubSuccess(request))
except:
self.fail()
def test_enabled_no_paths(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',)
notify(Purge(context))
self.assertEqual({'plone.cachepurging.urls': set()},
dict(IAnnotations(request)))
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'))
