class RegistryTest(unittest.TestCase):
layer = GENWEBCONTROLPANEL_INTEGRATION_TESTING
def setUp(self):
self.portal = self.layer['portal']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.registry = Registry()
self.registry.registerInterface(IGenwebControlPanelSettings)
def test_registry_registered(self):
registry = queryUtility(IRegistry)
self.assertTrue(registry.forInterface(IGenwebControlPanelSettings))
def test_discussion_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="genweb-controlpanel")
view = view.__of__(self.portal)
self.assertTrue(view())
def test_discussion_in_controlpanel(self):
# Check if discussion is in the control panel
self.controlpanel = getToolByName(self.portal, "portal_controlpanel")
self.assertTrue('genweb' in [a.getAction(self)['id']
for a in self.controlpanel.listActions()])
def test_unicode_values(self):
registry = queryUtility(IRegistry)
genweb_settings = registry.forInterface(IGenwebControlPanelSettings)
genweb_settings.html_title_ca = u"àéçÀÉ"
self.assertEqual(genweb_settings.html_title_ca, u"àéçÀÉ")
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 RegistryTest(ZeroCMSTestCase):
def afterSetUp(self):
# Set up the zerocms settings registry
self.loginAsPortalOwner()
self.registry = Registry()
self.registry.registerInterface(IZeroCMSSettings)
def test_zerocms_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="zerocms-settings")
view = view.__of__(self.portal)
self.failUnless(view())
def test_zerocms_controlpanel_view_protected(self):
from AccessControl import Unauthorized
self.logout()
self.assertRaises(Unauthorized,
self.portal.restrictedTraverse,
'@@zerocms-settings')
def test_record_zerocms_key(self):
# Test that the zerocms_key record is in the control panel
record_post_url = self.registry.records[
'Products.zerocms.interfaces.IZeroCMSSettings.post_url']
self.failUnless('post_url' in IZeroCMSSettings)
self.assertEquals(record_post_url.value, u"http://localhost/ZeroCMS/api/document/add")
def test_record_instance_url(self):
record_instance_url = self.registry.records[
'Products.zerocms.interfaces.IZeroCMSSettings.instance_url']
self.failUnless('instance_url' in IZeroCMSSettings)
self.assertEquals(record_instance_url.value, u"http://localhost:8080/zerorally")
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)
class TestControlpanel(base.BaseTestCase):
""" """
def afterSetUp(self):
self.loginAsPortalOwner()
self.registry = Registry()
self.registry.registerInterface(ISocialPublishControlPanel)
qi = self.portal.portal_quickinstaller
qi.installProduct('collective.socialpublish')
def test_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="socialpublish-settings")
view = view.__of__(self.portal)
self.failUnless(view())
def test_controlpanel_view_protected(self):
from AccessControl import Unauthorized
self.logout()
self.assertRaises(Unauthorized,
self.portal.restrictedTraverse,
'@@socialpublish-settings')
def test_in_controlpanel(self):
self.controlpanel = getToolByName(self.portal, "portal_controlpanel")
self.failUnless('socialpublish_settings' in [a.getAction(self)['id']
for a in self.controlpanel.listActions()])
def test_record_content_types(self):
record_content_types = self.registry.records[
'collective.socialpublish.controlpanel.interfaces.ISocialPublishControlPanel.content_types']
self.failUnless('content_types' in ISocialPublishControlPanel)
self.assertEquals(record_content_types.value, set())
class RegistryTest(unittest.TestCase):
layer = Routes_INTEGRATION_TESTING
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(IRoutesSettings)
def test_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST), name="routes-settings")
view = view.__of__(self.portal)
self.failUnless(view())
def test_controlpanel_view_is_protected(self):
from AccessControl import Unauthorized
logout()
self.assertRaises(Unauthorized, self.portal.restrictedTraverse, "@@routes-settings")
def test_action_in_controlpanel(self):
cp = getToolByName(self.portal, "portal_controlpanel")
actions = [a.getAction(self)["id"] for a in cp.listActions()]
self.failUnless("routes" in actions)
def test_routes_record(self):
record_routes = self.registry.records[BASE_REGISTRY % "routes"]
self.failUnless("routes" in IRoutesSettings)
self.assertEquals(record_routes.value, set([]))
class TestMLSContactInfoControlPanel(unittest.TestCase):
"""Validate contact info control panel is available."""
layer = INTEGRATION_TESTING
def setUp(self):
"""Additional test setup."""
self.portal = self.layer['portal']
alsoProvides(self.portal.REQUEST, IPloneMLSLayer)
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.registry = Registry()
self.registry.registerInterface(IMLSContactInfoSettings)
def test_controlpanel_view(self):
"""Validate that the configuration view is available."""
view = getMultiAdapter(
(self.portal, self.portal.REQUEST),
name='mls-controlpanel-contact-info',
)
view = view.__of__(self.portal)
self.assertTrue(view())
def test_controlpanel_view_protected(self):
"""Validate that the configuration view needs authentication."""
from AccessControl import Unauthorized
logout()
self.assertRaises(
Unauthorized,
self.portal.restrictedTraverse,
'@@mls-controlpanel-contact-info',
)
class TestToolkitControlPanel(unittest.TestCase):
"""Control Panel Test Case for theming.toolkit.core."""
layer = THEMING_TOOLKIT_CORE_INTEGRATION_TESTING
def setUp(self):
"""Additional test setup."""
self.portal = self.layer['portal']
directlyProvides(self.portal.REQUEST, IThemingToolkitCore)
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.registry = Registry()
self.registry.registerInterface(IToolkitSettings)
def test_toolkit_controlpanel_view(self):
"""Test that the toolkit configuration view is available."""
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name='toolkit-controlpanel')
view = view.__of__(self.portal)
self.assertTrue(view())
def test_toolkit_controlpanel_view_protected(self):
"""Test that the toolkit configuration view needs authentication."""
from AccessControl import Unauthorized
logout()
self.assertRaises(Unauthorized, self.portal.restrictedTraverse,
'@@toolkit-controlpanel')
def test_toolkit_in_controlpanel(self):
"""Check that there is an toolkit entry in the control panel."""
self.controlpanel = getToolByName(self.portal, 'portal_controlpanel')
self.assertTrue('propertyshelf_toolkit' in [a.getAction(self)['id']
for a in self.controlpanel.listActions()])
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)
class TestMLSControlPanel(unittest.TestCase):
"""Control Panel Test Case for plone.mls.core."""
layer = PLONE_MLS_CORE_INTEGRATION_TESTING
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_mls_controlpanel_view(self):
"""Test that the MLS configuration view is available."""
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name='mls-controlpanel')
view = view.__of__(self.portal)
self.assertTrue(view())
def test_mls_controlpanel_view_protected(self):
"""Test that the MLS configuration view needs authentication."""
from AccessControl import Unauthorized
logout()
self.assertRaises(Unauthorized, self.portal.restrictedTraverse,
'@@mls-controlpanel')
def test_mls_in_controlpanel(self):
"""Check that there is an MLS entry in the control panel."""
controlpanel = api.portal.get_tool(name='portal_controlpanel')
actions = [
a.getAction(self)['id'] for a in controlpanel.listActions()
]
self.assertTrue('propertyshelf_mls' in actions)
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_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 ControlPanelTestCase(BaseTestCase):
def afterSetUp(self):
# Set up the iservices.controlpanel settings registry
self.loginAsPortalOwner()
self.registry = Registry()
self.registry.registerInterface(ISettingsSchema)
def test_iservices_controlpanel_view(self):
# Test the iservices setting control panel view
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="iservices-controlpanel")
view = view.__of__(self.portal)
self.failUnless(view())
def test_controlpanel_view_protected(self):
from AccessControl import Unauthorized
self.logout()
self.assertRaises(Unauthorized,
self.portal.restrictedTraverse,
'@@iservices-controlpanel')
def test_controlpanel_keys(self):
# Test that all the keys declared in the Interface are avilable
for key_name in ISettingsSchema.names():
rkey_name = self.registry.records[
'iservices.controlpanel.interfaces.ISettingsSchema.%s'%key_name]
self.assertEquals(rkey_name.value, ISettingsSchema[key_name].default)
class ControlPanelTestCase(unittest.TestCase):
layer = INTEGRATION_TESTING
def setUp(self):
self.portal = self.layer['portal']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.registry = Registry()
self.registry.registerInterface(INewsFlashSettings)
def test_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name='newsflash-settings')
view = view.__of__(self.portal)
self.assertTrue(view())
def test_controlpanel_view_is_protected(self):
from AccessControl import Unauthorized
logout()
self.assertRaises(Unauthorized,
self.portal.restrictedTraverse,
'@@newsflash-settings')
def test_action_in_controlpanel(self):
cp = api.portal.get_tool('portal_controlpanel')
actions = [a.getAction(self)['id'] for a in cp.listActions()]
self.assertIn('newsflash', actions)
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_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):
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_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_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_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_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_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_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_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_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'))
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_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.assertIsNone(ContentItemLookup(published, request)())
def test_structure(self):
registry = Registry()
record = Record(field.TextLine(title="Foo Bar"), "Lorem Ipsum")
registry.records["foo.bar"] = record
obj = self.serialize(registry)
item = obj["items"][0]
self.assertEqual(set(item), {"name", "value", "schema"})
self.assertEqual(set(item["schema"]), {"properties"})
self.assertEqual(item["name"], "foo.bar")
self.assertEqual(item["value"], "Lorem Ipsum")
def test_lookupOption_default(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.records['plone.caching.tests.test'] = Record(
field.TextLine(), u"default")
result = lookupOption('plone.caching.tests',
'testrule',
'test',
default=_marker)
self.assertEquals(u"default", result)
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_structure(self):
registry = Registry()
record = Record(field.TextLine(title=u"Foo Bar"), u"Lorem Ipsum")
registry.records['foo.bar'] = record
obj = self.serialize(registry)
item = obj['items'][0]
self.assertEqual(set(item), set(['name', 'value', 'schema']))
self.assertEqual(set(item['schema']), set(['properties']))
self.assertEqual(item['name'], 'foo.bar')
self.assertEqual(item['value'], u"Lorem Ipsum")
def test_no_records(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
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_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))
class TestMailchimpSettingsControlPanel(unittest.TestCase):
layer = COLLECTIVE_MAILCHIMP_INTEGRATION_TESTING
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
self.registry = Registry()
self.registry.registerInterface(IMailchimpSettings)
def test_mailchimp_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="mailchimp-settings")
view = view.__of__(self.portal)
self.failUnless(view())
def test_mailchimp_controlpanel_view_protected(self):
from AccessControl import Unauthorized
logout()
self.assertRaises(
Unauthorized,
self.portal.restrictedTraverse,
'@@mailchimp-settings'
)
def test_mailchimp_in_controlpanel(self):
self.controlpanel = getToolByName(self.portal, "portal_controlpanel")
self.failUnless(
'mailchimp' in [
a.getAction(self)['id']
for a in self.controlpanel.listActions()
]
)
def test_record_api_key(self):
record = self.registry.records[
'collective.mailchimp.interfaces.IMailchimpSettings.api_key']
self.failUnless('api_key' in IMailchimpSettings)
self.assertEquals(record.value, u"")
def test_disabled(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished()
GZipTransform(published, request).transformUnicode(u"", "utf-8")
self.assertEqual(0, response.enableHTTPCompression(query=True))
class FunctionalTest(unittest.TestCase):
layer = ADDTHIS_FUNCTIONAL_TESTING
def setUp(self):
self.portal = self.layer['portal']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.registry = Registry()
self.registry.registerInterface(IAddThisSettings)
directlyProvides(self.portal.REQUEST, IAddThisBrowserLayer)
def test_registry_event_listener(self):
pj = getToolByName(self.portal, 'portal_javascripts')
BASE = 'collective.addthis.interfaces.IAddThisSettings.%s'
rec = self.registry.records
rec[BASE % 'addthis_load_asynchronously'].value = True
transaction.commit()
addthis = pj.getResource('++resource++collective.addthis/addthis.js')
self.assertTrue(addthis.getEnabled())
rec[BASE % 'addthis_load_asynchronously'].value = False
transaction.commit()
self.assertFalse(addthis.getEnabled())
def test_not_listed(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.purgedContentTypes = (
'File',
'Image',
)
content = DummyContent()
self.assertEqual(False, isPurged(content))
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.assertEqual('rule1', ContentItemLookup(published, request)())
class TestAuthomaticSettingsControlPanel(unittest.TestCase):
layer = PAS_PLUGINS_Authomatic_PLONE_INTEGRATION_TESTING
def setUp(self):
self.portal = self.layer["portal"]
self.request = self.layer["request"]
self.registry = Registry()
self.registry.registerInterface(IPasPluginsAuthomaticSettings)
def test_authomatic_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="authomatic-controlpanel")
# view = view.__of__(self.portal)
self.assertTrue(view())
def test_authomatic_controlpanel_view_protected(self):
from AccessControl import Unauthorized
logout()
self.assertRaises(
Unauthorized,
self.portal.restrictedTraverse,
"@@authomatic-controlpanel",
)
def test_authomatic_in_controlpanel(self):
self.controlpanel = getToolByName(self.portal, "portal_controlpanel")
self.assertTrue(
"authomatic" in
[a.getAction(self)["id"] for a in self.controlpanel.listActions()])
def test_record_config_property(self):
record = self.registry.records[
"pas.plugins.authomatic.interfaces." +
"IPasPluginsAuthomaticSettings.json_config"]
self.assertTrue("json_config" in IPasPluginsAuthomaticSettings)
self.assertGreater(len(record.value), 20)
def test_lookupOption_override(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.records['plone.caching.tests.test'] = r = Record(
field.TextLine(), u'default')
registry.records['plone.caching.tests.testrule.test'] = Record(
FieldRef(r.__name__, r.field), u'override')
result = lookupOption('plone.caching.tests',
'testrule',
'test',
default=_marker)
self.assertEqual(u'override', result)
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 setUp(self):
self.context = None
self.example_vocab = SimpleVocabulary.fromValues([1, 2, 3, 4])
self.example_source = ExampleSource(
[SimpleTerm(1),
SimpleTerm(2),
SimpleTerm(3),
SimpleTerm(4)])
registry = getVocabularyRegistry()
registry.register('example-vocab', ExampleVocabFactory)
plone_registry = Registry()
provideUtility(plone_registry, IRegistry)
class DecoControlPanelIntegrationTest(PloneTestCase):
layer = PLONE_APP_TILES_INTEGRATION_TESTING
def setUp(self):
self.portal = self.layer['portal']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.registry = Registry()
self.registry.registerInterface(IDecoSettings)
def test_deco_registry_registered(self):
self.assertTrue(self.registry.forInterface(IDecoSettings))
def test_deco_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="deco-controlpanel")
view = view.__of__(self.portal)
self.assertTrue(view())
self.assertTrue("Deco Controlpanel" in view())
def test_akismet_controlpanel_view_protected(self):
from AccessControl import Unauthorized
self.logout()
self.assertRaises(Unauthorized, self.portal.restrictedTraverse,
'@@deco-controlpanel')
def test_akismet_in_controlpanel(self):
self.controlpanel = getToolByName(self.portal, "portal_controlpanel")
self.assertTrue(
'deco' in
[a.getAction(self)['id'] for a in self.controlpanel.listActions()])
def test_available_tiles_key(self):
record_available_tiles = self.registry.records[
'plone.app.tiles.interfaces.IDecoSettings.available_tiles']
self.assertTrue('available_tiles' in IDecoSettings)
self.assertEqual(record_available_tiles.value, ())
def setUp(self):
self.handler = Handler()
provideHandler(self.handler.handler)
provideHandler(objectEventNotify)
provideHandler(purgeOnModified)
provideHandler(purgeOnMovedOrRemoved)
provideAdapter(persistentFieldAdapter)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.purgedContentTypes = ('testtype', )
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_lookupOptions_no_records(self):
provideUtility(Registry(), IRegistry)
@provider(ICachingOperationType)
class DummyOperation(object):
title = u''
description = u''
prefix = 'plone.caching.tests'
options = (
'test1',
'test2',
)
result = lookupOptions(DummyOperation, 'testrule', default=_marker)
self.assertEqual({'test1': _marker, 'test2': _marker}, result)
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())
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_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_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_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_GZip_enabled(self):
from plone.app.caching.operations.etags import GZip
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.enableCompression = True
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished(DummyContext())
request.environ['HTTP_ACCEPT_ENCODING'] = 'deflate; gzip'
etag = GZip(published, request)
self.assertEqual('1', etag())