def test_defaults(self):
dummy = self.makeDummy()
request = FakeRequest()
field = dummy.Schema().fields()[0]
# Default
self.assertEqual(field.getDefault(dummy), None)
# Value
field.default = "Hello"
self.assertEqual(field.getDefault(dummy), 'Hello')
# Method
field.default = None
field.default_method = 'default_val'
self.assertEqual(field.getDefault(dummy), 'World')
# Adapter
field.default_method = None
class DefaultFor(object):
implements(IFieldDefaultProvider)
def __init__(self, context):
self.context = context
def __call__(self):
return "Adapted"
getSiteManager().registerAdapter(factory=DefaultFor, required=(Dummy,), name=field.__name__)
self.assertEqual(field.getDefault(dummy), 'Adapted')
getSiteManager().unregisterAdapter(factory=DefaultFor, required=(Dummy,), name=field.__name__)
def test_tracker261(self):
#
# Tracker issue #261 says that content in a deleted folder
# is not being uncatalogued. Try creating a subfolder with
# content object, and test.
#
from ..PortalFolder import PortalFolder
acl_users = self.site._setObject('acl_users', DummyUserFolder())
newSecurityManager(None, acl_users.all_powerful_Oz)
test = self._makeOne('test')
ctool = DummyCatalogTool()
getSiteManager().registerUtility(ctool, ICatalogTool)
self.assertEqual(len(ctool), 0)
test._setObject('sub', PortalFolder('sub', ''))
sub = test.sub
sub._setObject('foo', DummyContent('foo', catalog=1))
foo = sub.foo
self.assertTrue(foo.after_add_called)
self.assertFalse(foo.before_delete_called)
self.assertEqual(len(ctool), 1)
foo.reset()
test._delObject('sub')
self.assertFalse(foo.after_add_called)
self.assertTrue(foo.before_delete_called)
self.assertEqual(len(ctool), 0)
def tearDown(self):
root = self.layer.getRootFolder()
del root['page']
for product_id in self.product_ids:
component.getSiteManager().unregisterUtility(self.sdc, ISessionDataContainer,
name=product_id)
super(ZPTSessionTest, self).tearDown()
def test_publisher_with_metadata_tool(self):
PUBLISHER = 'Some Publisher'
site = DummySite('site').__of__(self.app)
tool = DummyMetadataTool(publisher=PUBLISHER)
getSiteManager().registerUtility(tool, IMetadataTool)
item = self._makeDummyContent('item').__of__(site)
self.assertEqual(item.Publisher(), PUBLISHER)
def test_enabled_uninstalled(self):
dsb = DummyStorageBackend()
getSiteManager().registerUtility(
dsb, IStorageBackend, name='dummy_storage')
utilities = queryUtility(IUtilityRegistry, 'repodono.storage.backends')
utilities.enable('dummy_storage')
vocab = queryUtility(
IVocabularyFactory, name='repodono.storage.backends')(None)
self.assertEqual(vocab.getTermByToken(
'dummy_storage').token, 'dummy_storage')
getSiteManager().unregisterUtility(
dsb, IStorageBackend, name='dummy_storage')
vocab = queryUtility(
IVocabularyFactory, name='repodono.storage.backends')(None)
self.assertEqual(list(vocab), [])
# registry should be untouched at this point
registry = queryUtility(IRegistry)
self.assertEqual(
registry['repodono.storage.backends'], [u'dummy_storage'])
# shouldn't break anything.
utilities.disable('unrelated')
self.assertEqual(list(vocab), [])
# The bad value is no longer stored.
self.assertEqual(registry['repodono.storage.backends'], [])
def uninstall(context):
# Note: this function is registered as a pre_handler instead of a
# post_handler, because otherwise toolset.xml has already been applied,
# which removes the portal_placeful_workflow tool.
portal = getToolByName(context, 'portal_url').getPortalObject()
tool = getattr(portal, 'portal_placeful_workflow', None)
if tool is not None:
getSiteManager(portal).unregisterUtility(
tool,
IPlacefulWorkflowTool)
logger.info('Unregistered portal_placeful_workflow')
# uninstall configlets
try:
cptool = getToolByName(portal, 'portal_controlpanel')
cptool.unregisterConfiglet(placeful_prefs_configlet['id'])
logger.info('Removing CMFPlacefulWorkflow Configlet')
except:
logger.info('Failed to remove CMFPlacefulWorkflow Configlet')
wf_tool = getToolByName(portal, 'portal_workflow')
if IPlacefulMarker.providedBy(wf_tool):
noLongerProvides(wf_tool, IPlacefulMarker)
logger.info('Removed placeful marker from portal_workflow.')
# Mark our base profile as uninstalled, because:
# 1. It is good practice.
# 2. Otherwise when the user installs CMFPlacefulWorkflow again,
# portal_setup will not apply our base profile.
portal_setup = getToolByName(portal, 'portal_setup')
portal_setup.unsetLastVersionForProfile(
'Products.CMFPlacefulWorkflow:base')
def setUp(self):
SecurityTest.setUp(self)
# setting up types tool
getSiteManager().registerUtility(TypesTool(), ITypesTool)
# setup portal
try:
self.app._delObject('test')
except AttributeError:
pass
self.app._setObject('test', PortalFolder('test', ''))
self.test = test = self.app.test
# setting up folders
test._setObject('folder', PortalFolder('folder', ''))
folder = self.folder = test.folder
folder._setObject('sub', PortalFolder('sub', ''))
sub = self.sub = folder.sub
#----- hacks to allow pasting (see also test_PortalFolder)
# WAAA! force sub to allow paste of Dummy object.
sub.all_meta_types = extra_meta_types()
# delete items if necessary
try:
folder._delObject('dummy')
except AttributeError:
pass
try:
sub._delObject('dummy')
except AttributeError:
pass
def test_local_utility_persitent():
db = DB(DemoStorage('test_storage'))
connection = db.open()
root = connection.root()
site = root['site'] = SimpleSite()
components.LocalSiteManager(site)
transaction.commit()
getSiteManager(context=site).registerUtility(PeculiarDummyUtil())
dummy = getUtility(IDummyUtil, context=site)
dummy.answer = 'no'
assert dummy.callme() == "Perculiarly, no"
transaction.commit()
del site
del dummy
connection = db.open()
site = connection.root()['site']
dummy = getUtility(IDummyUtil, context=site)
assert dummy.callme() == "Perculiarly, no"
# and aborting does not save state
dummy.answer = 'yes'
assert dummy.callme() == "Perculiarly, yes"
transaction.abort
connection = db.open()
site = connection.root()['site']
dummy = getUtility(IDummyUtil, context=site)
assert dummy.callme() == "Perculiarly, no"
db.close()
def _initSite(self, foo=2):
site = Folder(id='site').__of__(self.app)
ctool = CatalogTool()
getSiteManager().registerUtility(ctool, ICatalogTool)
for obj_id in ctool.objectIds():
ctool._delObject(obj_id)
for idx_id in ctool.indexes():
ctool.delIndex(idx_id)
for col in ctool.schema()[:]:
ctool.delColumn(col)
if foo > 0:
ctool._setObject('foo_plexicon', PLexicon('foo_plexicon'))
lex = ctool.foo_plexicon
lex._pipeline = (Splitter(), CaseNormalizer(), StopWordRemover())
extra = _extra()
extra.lexicon_id = 'foo_plexicon'
extra.index_type = 'Okapi BM25 Rank'
ctool.addIndex('foo_zctext', 'ZCTextIndex', extra)
ctool.addColumn('foo_zctext')
return site, ctool
def register_sequence(name, session, impl=SequenceImplementation):
"""
Register a sequence for later user.
:param name:
A string containing the name of the sequence.
:param session:
A :class:`~sqlalchemy.orm.session.Session` instance that
will be used to set up anything needed in the database
for the sequence to be functional. It will not be retained
and may be closed and discarded once this function has
returned.
:param impl:
A class whose instances implement
:class:`~mortar_rdb.interfaces.ISequence`.
Defaults to
:class:`mortar_rdb.sequence.generic.SequenceImplementation`.
"""
getSiteManager().registerUtility(
impl(name,session),
provided=ISequence,
name=name,
)
def registerBehavior(name, spec, factory, schema=None,
type = None, title='', description = '',
configContext=None, info=''):
usedName = spec.queryTaggedValue('__bh_name__')
if usedName and usedName != name:
raise TypeError(
"Can't use same interface for different behaviors (%s and %s)."%(
name, spec.getTaggedValue('__bh_name__')))
elif spec.queryTaggedValue('__sch_name__'):
raise TypeError(
"Can't use same interface for schema and behavior (%s and %s)."%(
name, spec.getTaggedValue('__sch_name__')))
spec.setTaggedValue('__bh_name__', name)
if schema is not None:
spec.setTaggedValue('__bh_schema__', schema)
if type is None:
type = (IBehavior,)
elif isinstance(type, InterfaceClass):
type = (type,)
bh = Behavior(name, title, spec, factory, schema, description)
for tp in type:
getSiteManager().registerUtility(bh, tp, name)
# register in internal registry
registry.registerBehavior(bh)
def test_createMemberArea(self):
site = self._makeSite()
mtool = site.portal_membership
members = site._setObject('Members', PortalFolder('Members'))
acl_users = site._setObject('acl_users', DummyUserFolder())
getSiteManager().registerUtility(DummyTool(), IWorkflowTool)
# permission
mtool.createMemberArea('user_foo')
self.assertFalse(hasattr(members.aq_self, 'user_foo'))
newSecurityManager(None, acl_users.user_bar)
mtool.createMemberArea('user_foo')
self.assertFalse(hasattr(members.aq_self, 'user_foo'))
newSecurityManager(None, acl_users.user_foo)
mtool.setMemberareaCreationFlag()
mtool.createMemberArea('user_foo')
self.assertFalse(hasattr(members.aq_self, 'user_foo'))
newSecurityManager(None, acl_users.all_powerful_Oz)
mtool.setMemberareaCreationFlag()
mtool.createMemberArea('user_foo')
self.assertTrue(hasattr(members.aq_self, 'user_foo'))
# default content
f = members.user_foo
ownership = acl_users.user_foo
localroles = (('user_foo', ('Owner',)),)
self.assertEqual(f.getOwner(), ownership)
self.assertEqual(f.get_local_roles(), localroles,
'CMF Collector issue #162 (LocalRoles broken): %s'
% str(f.get_local_roles()))
def test_getNextUtility(self):
# test local site vs. global site
global_dummy = DummyUtility()
provideUtility(global_dummy, IDummyUtility)
local_dummy = DummyUtility()
sm = getSiteManager()
sm.registerUtility(IDummyUtility, local_dummy)
self.assertEquals(zapi.getUtility(IDummyUtility), local_dummy)
self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
global_dummy)
# test local site vs. nested local site
manage_addDummySite(self.folder.site, 'subsite')
import warnings
showwarning = warnings.showwarning
warnings.showwarning = lambda *a, **k: None
enableLocalSiteHook(self.folder.site.subsite)
warnings.showwarning = showwarning
sublocal_dummy = DummyUtility()
sm = getSiteManager()
sm.registerUtility(IDummyUtility, sublocal_dummy)
self.assertEquals(zapi.getUtility(IDummyUtility), sublocal_dummy)
self.assertEquals(getNextUtility(self.folder.site.subsite, IDummyUtility),
local_dummy)
self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
global_dummy)
def test_query(self):
from zope.site import SiteManagerAdapter
from zope import component
component.provideAdapter(SiteManagerAdapter)
top_site = SiteManagerContainer()
top_sm = LocalSiteManager(top_site)
top_site.setSiteManager(top_sm)
assert_that(top_sm.__parent__, is_(top_site))
assert_that(top_site, provides(ISite))
interface.alsoProvides(top_site, ILocationInfo)
child_site = SiteManagerContainer()
child_site.__parent__ = top_site
child_site.getParent = lambda: child_site.__parent__
interface.alsoProvides(child_site, ILocationInfo)
child_sm = LocalSiteManager(child_site)
child_site.setSiteManager(child_sm)
assert_that(child_sm.__bases__, is_((top_sm,)))
class IFoo(Interface):
pass
@interface.implementer(IFoo)
class Foo(Contained):
pass
child_foo = Foo()
top_foo = Foo()
child_foo.__parent__ = child_site
top_foo.__parent__ = top_site
top_sm.registerUtility(top_foo, IFoo)
child_sm.registerUtility(child_foo, IFoo)
child_foo.__conform__ = lambda self, _: child_sm
from zope import component
component.getSiteManager(child_foo)
x = queryNextUtility(child_foo, IFoo)
assert_that(x, is_(top_foo))
class IBaz(Interface): pass
x = queryNextUtility(child_foo, IBaz)
assert_that(x, is_(none()))
x = queryNextUtility(top_foo, IFoo)
assert_that(x, is_(none()))
x = queryNextUtility(component.getGlobalSiteManager(), IFoo)
assert_that(x, is_(none()))
global_foo = Foo()
component.provideUtility(global_foo, IFoo)
x = queryNextUtility(component.getGlobalSiteManager(), IFoo)
assert_that(x, is_(global_foo))
def helper_test_sub(self, v):
""" Test that the event subscriber receives a tick. """
# global ugly variables work fow now
global success
success = False
def my_tick(event):
global success
success = True
component.getSiteManager().registerHandler(my_tick, [v[1]])
# First
self.loginAsPortalOwner()
portal = self.portal
view = portal.restrictedTraverse(v[0])
view()
self.assertEqual(success, True)
# All ticks have effect. Interval is handled by the external
# trigger (cron or clockserver)
success = False
view()
self.assertEqual(success, True)
# Must unregister, otherwise piclking errors - ZODB tries to store this entry?
component.getSiteManager().unregisterHandler(my_tick, [v[1]])
def snapshotPortal(self, portal):
portal_types = getToolByName(portal, 'portal_types')
portal_skins = getToolByName(portal, 'portal_skins')
portal_actions = getToolByName(portal, 'portal_actions')
portal_workflow = getToolByName(portal, 'portal_workflow')
type_registry = getToolByName(portal, 'content_type_registry')
state = {}
state['leftslots'] = getattr(portal, 'left_slots', [])
if callable(state['leftslots']):
state['leftslots'] = state['leftslots']()
state['rightslots'] = getattr(portal, 'right_slots', [])
if callable(state['rightslots']):
state['rightslots'] = state['rightslots']()
state['registrypredicates'] = [
pred[0] for pred in type_registry.listPredicates()
]
state['types'] = portal_types.objectIds()
state['skins'] = portal_skins.objectIds()
actions = set()
for category in portal_actions.objectIds():
for action in portal_actions[category].objectIds():
actions.add((category, action))
state['actions'] = actions
state['workflows'] = portal_workflow.objectIds()
state['portalobjects'] = portal.objectIds()
state['adapters'] = tuple(getSiteManager().registeredAdapters())
state['utilities'] = tuple(getSiteManager().registeredUtilities())
jstool = getToolByName(portal, 'portal_javascripts', None)
state['resources_js'] = jstool and jstool.getResourceIds() or []
csstool = getToolByName(portal, 'portal_css', None)
state['resources_css'] = csstool and csstool.getResourceIds() or []
return state
def test_portal_object(self):
view = self._makeOne()
portal = DummyContext()
tool = DummyURLTool()
tool.getPortalObject = lambda: portal
getSiteManager().registerUtility(tool, IURLTool)
self.assertTrue(view.portal_object is portal)
def test_contentPasteAllowedTypes(self):
#
# _verifyObjectPaste() should honor allowed content types
#
ttool = TypesTool()
getSiteManager().registerUtility(ttool, ITypesTool)
fti = FTIDATA_DUMMY[0].copy()
ttool._setObject('Dummy Content', FTI(**fti))
ttool._setObject('Folder', FTI(**fti))
sub1 = self._makeOne('sub1')
sub1._setObject('dummy', DummyContent('dummy'))
sub2 = self._makeOne('sub2')
sub2.all_meta_types = extra_meta_types()
# Allow adding of Dummy Content
ttool.Folder.manage_changeProperties(filter_content_types=False)
# Copy/paste should work fine
cookie = sub1.manage_copyObjects(ids=['dummy'])
sub2.manage_pasteObjects(cookie)
# Disallow adding of Dummy Content
ttool.Folder.manage_changeProperties(filter_content_types=True)
# Now copy/paste should raise a ValueError
cookie = sub1.manage_copyObjects(ids=('dummy',))
self.assertRaises(ValueError, sub2.manage_pasteObjects, cookie)
def test_subscription(self):
""" Test that the event subscriber receives a tick. """
# global ugly variables work fow now
global success
success = False
def my_tick(event):
global success
success = True
component.getSiteManager().registerHandler(my_tick, [ITickEvent])
# First
self.loginAsPortalOwner()
portal = self.portal
view = portal.restrictedTraverse("@@tick")
view()
self.assertEqual(success, True)
# Subsequent ticks should have no effect until interval has passed
success = False
view()
self.assertEqual(success, False)
# Must unregister, otherwise piclking errors - ZODB tries to store this entry?
component.getSiteManager().unregisterHandler(my_tick, [ITickEvent])
def _initSite(self, with_policy=False):
site = Folder(id='site').__of__(self.app)
cpm = CachingPolicyManager()
getSiteManager().registerUtility(cpm, ICachingPolicyManager)
if with_policy:
cpm.addPolicy(policy_id=self.POLICY_ID,
predicate=self.PREDICATE,
mtime_func=self.MTIME_FUNC,
max_age_secs=self.MAX_AGE_SECS,
no_cache=True,
no_store=True,
must_revalidate=True,
vary=self.VARY,
etag_func=self.ETAG_FUNC,
s_max_age_secs=self.S_MAX_AGE_SECS,
proxy_revalidate=True,
public=True,
private=True,
no_transform=True,
enable_304s=True,
last_modified=False,
pre_check=self.PRE_CHECK,
post_check=self.POST_CHECK)
return site, cpm
def test_getSyndicatableContent(self):
# http://www.zope.org/Collectors/CMF/369
# Make sure we use a suitable base class call when determining
# syndicatable content
from Products.CMFCore.PortalFolder import PortalFolder
from Products.CMFCore.CMFBTreeFolder import CMFBTreeFolder
from Products.CMFCore.TypesTool import TypesTool
PERIOD = 'hourly'
FREQUENCY = 4
NOW = datetime.now()
MAX_ITEMS = 42
getSiteManager().registerUtility(TypesTool(), ITypesTool)
self.app._setObject('pf', PortalFolder('pf'))
self.app._setObject('bf', CMFBTreeFolder('bf'))
tool = self._makeOne()
tool.period = PERIOD
tool.frequency = FREQUENCY
tool.base = NOW
tool.enabled = True
tool.max_items = MAX_ITEMS
self.assertEqual(len(tool.getSyndicatableContent(self.app.pf)), 0)
self.assertEqual(len(tool.getSyndicatableContent(self.app.bf)), 0)
def test_getSiteManager(self):
self.assertEqual(getSiteManager(None), getGlobalSiteManager())
self.assertEqual(getSiteManager(self.root), getGlobalSiteManager())
self.assertEqual(getSiteManager(self.f1), self.sm1)
self.assertEqual(getSiteManager(self.f2), self.sm2)
setSite(self.f2)
self.assertEqual(getSiteManager(None), self.sm2)
def test_index_html_with_304_and_caching(self):
# See collector #355
cpm = DummyCachingManager()
getSiteManager().registerUtility(cpm, ICachingPolicyManager)
original_len = len(self.RESPONSE.headers)
_path, ref = self._extractFile()
self.app.image = self._makeOne('test_image', 'test_image.gif', file=ref)
image = self.app.image
transaction.savepoint(optimistic=True)
mod_time = image.modified()
self.REQUEST.environ['IF_MODIFIED_SINCE'
] = '%s;' % rfc1123_date(mod_time + 1)
data = image.index_html(self.REQUEST, self.RESPONSE)
self.assertEqual(data, '')
self.assertEqual(self.RESPONSE.getStatus(), 304)
headers = self.RESPONSE.headers
self.failUnless(len(headers) >= original_len + 3)
self.failUnless('foo' in headers.keys())
self.failUnless('bar' in headers.keys())
self.assertEqual(headers['test_path'], '/test_image')
def setUp(self):
self.site = DummySite('site')
ttool = TypesTool()
getSiteManager().registerUtility(ttool, ITypesTool)
fti = FTIDATA_CMF[0].copy()
ttool._setObject( 'Dummy Content 15', FTI(**fti) )
self.site._setObject( 'foo', DummyContent() )
dummy_view = self.site._setObject( 'dummy_view', DummyObject() )
def register(self):
if not self.address:
return
if queryUtility(IMailInDestination, self.address) is not None:
raise MailInException(
'Mail-in email address already in use: %s'%self.address)
getSiteManager().registerUtility(self, IMailInDestination, self.address)
def _registerProvider(self, provider, name, context_iface=None):
from zope.interface import Interface
from contentlet.interfaces import IContentProvider
if context_iface is None:
context_iface = Interface
from zope.component import getSiteManager
getSiteManager().registerAdapter(
provider, (context_iface,), IContentProvider, name=name)
def test_portal_title(self):
view = self._makeOne()
portal = DummyContext()
portal.Title = lambda: 'TITLE'
tool = DummyURLTool()
tool.getPortalObject = lambda: portal
getSiteManager().registerUtility(tool, IURLTool)
self.assertEqual(view.portal_title, 'TITLE')
def handler(name, dependencies, required, provided, adapter_name, factory, info=''):
if dependencies:
for dep in dependencies:
if dep not in library_info:
raise ConfigurationError(
'Resource library "%s" has unsatisfied dependency on "%s".'
% (name, dep))
getSiteManager().registerAdapter(
factory, required, provided, adapter_name, info)
def test_page_title_w_match(self):
view = self._makeOne()
view.context.Title = lambda: 'MATCH'
portal = DummyContext()
portal.Title = lambda: 'MATCH'
tool = DummyURLTool()
tool.getPortalObject = lambda: portal
getSiteManager().registerUtility(tool, IURLTool)
self.assertEqual(view.page_title, 'MATCH')
def test_portal_title_nonascii(self):
NONASCII = u'B\xe4r'
context = self._makeContext()
view = self._makeOne(context)
context.Title = lambda: NONASCII.encode('latin-1')
context.portal_properties.default_charset = 'latin1'
tool = DummyURLTool()
tool.getPortalObject = lambda: context
getSiteManager().registerUtility(tool, IURLTool)
self.assertEqual(view.portal_title, NONASCII)
def exportComponentRegistry(context):
"""Export local components.
"""
sm = getSiteManager(context.getSite())
if sm is None or not IComponentRegistry.providedBy(sm):
logger = context.getLogger('componentregistry')
logger.debug("Nothing to export.")
return
exporter = queryMultiAdapter((sm, context), IBody)
if exporter:
body = exporter.body
if body is not None:
context.writeDataFile('componentregistry.xml', body,
exporter.mime_type)
def setUp(self):
from AccessControl.SecurityManagement import newSecurityManager
from zope.component.interfaces import IFactory
from .base.dummy import DummyFactory
from .base.dummy import DummyFolder
from .base.security import UserWithRoles
SecurityTest.setUp(self)
sm = getSiteManager()
sm.registerUtility(DummyFactory, IFactory, 'test.dummy')
self.f = DummyFolder()
Permission('addFoo', (), self.f).setRoles(('Manager', 'FooAdder'))
self.ti = self._makeOne('Foo', meta_type='Dummy', factory='test.dummy')
newSecurityManager(None, UserWithRoles('FooAdder').__of__(self.f))
def _setup(self):
PloneTestCase.PloneTestCase._setup(self)
# Replace normal mailhost with mock mailhost
self.portal._original_MailHost = self.portal.MailHost
self.portal.MailHost = mailhost = MockMailHost('MailHost')
sm = getSiteManager(context=self.portal)
sm.unregisterUtility(provided=IMailHost)
sm.registerUtility(mailhost, provided=IMailHost)
# Make sure our mock mailhost does not give a mailhost_warning
# in the overview-controlpanel.
mailhost.smtp_host = 'mock'
self.portal.email_from_address = '*****@*****.**'
# Setup session (not sure why)
self.app.REQUEST['SESSION'] = self.Session()
def getObject(self, REQUEST=None, restricted=True):
""" return the actual object corresponding to this flare while
mimicking what publisher's traversal does, i.e. potentially
allowing access to the final object even if intermediate objects
cannot be accessed (much like the original implementation in
`ZCatalog.CatalogBrains.AbstractCatalogBrain`) """
site = getSiteManager()
path = self.getPath()
if not path:
return None
path = path.split('/')
if restricted:
parent = site.unrestrictedTraverse(path[:-1])
return parent.restrictedTraverse(path[-1])
return site.unrestrictedTraverse(path)
def unregister(self):
index = self.request.form.get('index')
try:
index = int(index)
except (TypeError, ValueError):
index = None
if index is None:
#XXX: find right exception type
raise ValueError("Missing or invalid 'index' parameter.")
regs = self.viewRegistrations()
reg = regs[index]
components = getSiteManager(self.context)
components.unregisterAdapter(reg.factory, reg.required, reg.provided,
reg.name)
self.request.response.redirect('registrations.html')
def setUp(self):
super(TestWriteExtension, self).setUp()
sm = getSiteManager()
# Register the example extension
from wsapi4plone.core.interfaces import (IService, IServiceExtension)
sm.registerUtility(ICrashTestWriteExtension,
provided=IServiceExtension,
name=self.ext_key)
sm.registerAdapter(WriteCrashTestExtension,
required=(
IService,
Interface,
),
provided=ICrashTestWriteExtension,
name=self.ext_key)
def test_notifyModified(self):
site = DummySite('site').__of__(self.root)
sm = getSiteManager()
acl_users = site._setObject( 'acl_users', DummyUserFolder() )
site._setObject( 'portal_membership', MembershipTool() )
sm.registerUtility(site.portal_membership, IMembershipTool)
newSecurityManager(None, acl_users.user_foo)
item = self._makeDummyContent('item').__of__(site)
self.assertEqual( item.listCreators(), () )
item.setModificationDate(0)
initial_date = item.ModificationDate()
item.notifyModified()
self.assertEqual( item.listCreators(), ('user_foo',) )
self.assertNotEqual( item.ModificationDate(), initial_date )
def test_paste_with_restricted_item_content_type_not_allowed(self):
# Test from CMF Collector #216 (Plone #2186), for the case
# in which the item being pasted does not allow adding such
# objects to containers which do not explicitly grant access.
from Products.CMFCore.PortalFolder import PortalFolder
RESTRICTED_TYPE = 'Restricted Item'
UNRESTRICTED_TYPE = 'Unrestricted Container'
folder1, folder2 = self._initFolders()
folder1.portal_type = UNRESTRICTED_TYPE
folder2.portal_type = RESTRICTED_TYPE
self._initPolicyAndUser() # ensure that sec. machinery allows paste
ttool = TypesTool()
ttool._setObject(RESTRICTED_TYPE,
FTI(id=RESTRICTED_TYPE,
title=RESTRICTED_TYPE,
meta_type=PortalFolder.meta_type,
product='CMFCore',
factory='manage_addPortalFolder',
global_allow=0))
ttool._setObject(UNRESTRICTED_TYPE,
FTI(id=UNRESTRICTED_TYPE,
title=UNRESTRICTED_TYPE,
meta_type=PortalFolder.meta_type,
product='CMFCore',
factory='manage_addPortalFolder',
filter_content_types=0))
getSiteManager().registerUtility(ttool, ITypesTool)
# copy and pasting the object into the folder should raise
# an exception
copy_cookie = self.app.manage_copyObjects(ids=['folder2'])
self.assertRaises(ValueError, folder1.manage_pasteObjects, copy_cookie)
def test_constructContent_FTI_w_wftool_w_workflow_w_guard_denies(self):
from AccessControl import Unauthorized
from AccessControl.SecurityManagement import newSecurityManager
from AccessControl.SecurityManager import setSecurityPolicy
from ..TypesTool import FactoryTypeInformation as FTI
from .base.dummy import DummyFolder
from .base.tidata import FTIDATA_DUMMY
site = self._makeSite().__of__(self.app)
acl_users = site.acl_users
setSecurityPolicy(self._oldPolicy)
newSecurityManager(None, acl_users.all_powerful_Oz)
tool = self._makeOne().__of__(site)
fti = FTIDATA_DUMMY[0].copy()
tool._setObject('Dummy Content', FTI(**fti))
folder = DummyFolder(id='folder', fake_product=1).__of__(site)
tool.portal_workflow = DummyWorkflowTool(DummyWorkflow(False))
getSiteManager().registerUtility(tool.portal_workflow, IWorkflowTool)
self.assertRaises(Unauthorized,
tool.constructContent,
'Dummy Content', container=folder, id='page1')
getSiteManager().unregisterUtility(provided=IWorkflowTool)
def unregister_layer(name, site_manager=None):
"""Unregister the layer with the given name. If it cannot be found, a
KeyError is raised.
"""
existing = queryUtility(ILocalBrowserLayerType, name=name)
if existing is None:
raise KeyError("No browser layer with name %s is registered." % name)
if site_manager is None:
site_manager = getSiteManager()
site_manager.unregisterUtility(component=existing,
provided=ILocalBrowserLayerType,
name=name)
def test_defaults(self):
dummy = self.makeDummy()
request = FakeRequest()
field = dummy.Schema().fields()[0]
# Default
self.assertEqual(field.getDefault(dummy), None)
# Value
field.default = "Hello"
self.assertEqual(field.getDefault(dummy), 'Hello')
# Method
field.default = None
field.default_method = 'default_val'
self.assertEqual(field.getDefault(dummy), 'World')
# Adapter
field.default_method = None
class DefaultFor(object):
implements(IFieldDefaultProvider)
def __init__(self, context):
self.context = context
def __call__(self):
return "Adapted"
getSiteManager().registerAdapter(factory=DefaultFor,
required=(Dummy, ),
name=field.__name__)
self.assertEqual(field.getDefault(dummy), 'Adapted')
getSiteManager().unregisterAdapter(factory=DefaultFor,
required=(Dummy, ),
name=field.__name__)
def tearDown(self):
sm = getSiteManager()
# Unregister the example extension
from wsapi4plone.core.interfaces import (IService, IServiceExtension)
assert sm.unregisterUtility(component=ICrashTestWriteExtension,
provided=IServiceExtension,
name=self.ext_key)
assert sm.unregisterAdapter(factory=WriteCrashTestExtension,
required=(
IService,
Interface,
),
provided=ICrashTestWriteExtension,
name=self.ext_key)
super(TestWriteExtension, self).tearDown()
def test_index_html_with_304_and_caching(self):
# See collector #355
cpm = DummyCachingManager()
getSiteManager().registerUtility(cpm, ICachingPolicyManager)
original_len = len(self.RESPONSE.headers)
path, _ref = self._extractFile()
image = self._makeOne('test_image', 'test_image.gif')
image = image.__of__(self.app)
mod_time = os.stat(path)[8]
self.REQUEST.environ['IF_MODIFIED_SINCE'
] = '%s;' % rfc1123_date(mod_time + 3600)
data = image.index_html(self.REQUEST, self.RESPONSE)
self.assertEqual(data, '')
self.assertEqual(self.RESPONSE.getStatus(), 304)
headers = self.RESPONSE.headers
self.assertTrue(len(headers) >= original_len + 3)
self.assertTrue('foo' in headers.keys())
self.assertTrue('bar' in headers.keys())
self.assertEqual(headers['test_path'], '/test_image')
def test_registerUtilityWithZopeComponentAPI4(self):
# The Full kabob:
sm = getSiteManager()
dummy = DummyUtility()
sm.registerUtility(component=dummy,
provided=IDummyUtility,
name='dummy',
info=u'The Dummy',
event=True)
self.assertEquals(zapi.getUtility(IDummyUtility, name='dummy'), dummy)
self.assertEquals(list(zapi.getUtilitiesFor(IDummyUtility)),
[('dummy', dummy)])
self.assertEquals(
list(zapi.getAllUtilitiesRegisteredFor(IDummyUtility)), [dummy])
def setUp(self):
# Create and enable a local component registry
site = Folder()
createComponentRegistry(site)
setHooks()
setSite(site)
sm = getSiteManager()
tool = DummyTool()
site._setObject(tool.id, tool)
tool2 = DummyTool2()
site._setObject(tool2.id, tool2)
self._obj = sm
def test_CtorArgs(self):
utool = getSiteManager().getUtility(IURLTool)
target = self.site.target
self.assertEqual(self._makeOne('foo', title='Title').Title(), 'Title')
self.assertEqual(
self._makeOne('bar', description='Description').Description(),
'Description')
baz = self.site._setObject('foo',
self._makeOne('baz', remote_url='target'))
self.assertEqual(baz.getObject(), target)
self.assertEqual(baz.getRemoteUrl(), '%s/target' % utool())
self.assertEqual(baz.getIconURL(), target.getIconURL())
self.assertEqual(baz.icon(), target.icon())
def testMarkProductsInstalledForUninstallableProfiles(self):
from plone.app.upgrade.v43.final import \
markProductsInstalledForUninstallableProfiles
qi = getToolByName(self.portal, 'portal_quickinstaller', None)
if qi is None:
# Newer Plone without qi.
return
# Register a profile.
product_id = 'my.test.package'
profile_id = '{0}:default'.format(product_id)
profile_registry.registerProfile('default',
'title',
'description',
'/my/path',
product=product_id,
profile_type=EXTENSION)
# Hide the profile.
@implementer(INonInstallable)
class HiddenProfiles(object):
def getNonInstallableProfiles(self):
return [profile_id]
sm = getSiteManager()
sm.registerUtility(factory=HiddenProfiles, name='my.test.package')
# Check that nothing is installed at first.
setup = getToolByName(self.portal, 'portal_setup')
self.assertEqual(setup.getLastVersionForProfile(profile_id), 'unknown')
self.assertFalse(qi.isProductInstalled(product_id))
# Call our upgrade function. This should have no effect,
# because the profile is not installed.
markProductsInstalledForUninstallableProfiles(setup)
self.assertEqual(setup.getLastVersionForProfile(profile_id), 'unknown')
self.assertFalse(qi.isProductInstalled(product_id))
# Now fake that the profile is installed and try again.
setup.setLastVersionForProfile(profile_id, '1.0')
markProductsInstalledForUninstallableProfiles(setup)
self.assertEqual(setup.getLastVersionForProfile(profile_id),
('1', '0'))
self.assertTrue(qi.isProductInstalled(product_id))
# Cleanup test.
profile_registry.unregisterProfile('default', product_id)
def test_deleteReplies(self):
sm = getSiteManager()
dtool = self.site.portal_discussion
ctool = self.site._setObject( 'portal_catalog', CatalogTool() )
sm.registerUtility(ctool, ICatalogTool)
test = self._makeDummyContent('test')
test.allow_discussion = 1
# Create a structure 6 levels deep for testing
talkback = dtool.getDiscussionFor(test)
id1 = talkback.createReply(title='test1', text='blah')
reply1 = talkback.getReply(id1)
talkback1 = dtool.getDiscussionFor(reply1)
id2 = talkback1.createReply(title='test2', text='blah')
reply2 = talkback1.getReply(id2)
talkback2 = dtool.getDiscussionFor(reply2)
id3 = talkback2.createReply(title='test3', text='blah')
reply3 = talkback2.getReply(id3)
talkback3 = dtool.getDiscussionFor(reply3)
id4 = talkback3.createReply(title='test4', text='blah')
reply4 = talkback3.getReply(id4)
talkback4 = dtool.getDiscussionFor(reply4)
id5 = talkback4.createReply(title='test5', text='blah')
reply5 = talkback4.getReply(id5)
talkback5 = dtool.getDiscussionFor(reply5)
id6 = talkback5.createReply(title='test6', text='blah')
reply6 = talkback5.getReply(id6)
talkback6 = dtool.getDiscussionFor(reply6)
self.assertEqual(len(talkback.getReplies()), 1)
self.assertEqual(len(talkback1.getReplies()), 1)
self.assertEqual(len(talkback2.getReplies()), 1)
self.assertEqual(len(talkback3.getReplies()), 1)
self.assertEqual(len(talkback4.getReplies()), 1)
self.assertEqual(len(talkback5.getReplies()), 1)
self.assertEqual(len(talkback6.getReplies()), 0)
self.assertEqual(len(ctool), 7)
talkback3.deleteReply(id4)
self.assertEqual(len(talkback.getReplies()), 1)
self.assertEqual(len(talkback1.getReplies()), 1)
self.assertEqual(len(talkback2.getReplies()), 1)
self.assertEqual(len(talkback3.getReplies()), 0)
self.assertEqual(len(ctool), 4)
talkback.deleteReply(id1)
self.assertEqual(len(talkback.getReplies()), 0)
self.assertEqual(len(ctool), 1)
def test_storage_change(self):
# what is the current storage strategy ?
ss = self.portal.psc.getStorageStrategy()
self.assertEquals(ss, 'archetype')
# let's add a file to our project
self.release.invokeFactory('PSCFile', 'file')
self.release.file.update(**{'title': 'my file'})
# let's add a new strategy
from zope.interface import implements
class DummyStorage(object):
title = u"Dummy"
description = u"stores nothing"
implements(IPSCFileStorage)
storage = []
def __init__(self, context):
self.context = context
def set(self, *args, **kw):
self.storage.append('ok')
from zope.component import getSiteManager
from zope.interface import Interface
sm = getSiteManager()
sm.registerAdapter(factory=DummyStorage,
provided=IPSCFileStorage,
required=(Interface,),
name='dummy')
# let's see what kind of strategies are available
strats = sorted([s for s, a in
getFileStorageAdapters(self.portal.psc)])
for s in ['archetype', 'dummy']:
self.assert_(s in strats)
# let's add some content in the file
self.release.file.setDownloadableFile('xxxx')
# let's change the strategy
self.portal.psc.setStorageStrategy('dummy')
# it should trigger an event that changes
# the storage for all files
self.assert_(DummyStorage.storage, ['ok'])
def _initSite(self, use_changed=False):
from Products.MailHost.MailHost import MailHost
self.root.site = Folder(id='site')
site = self.root.site
mh = site.MailHost = MailHost('MailHost')
sm = getSiteManager()
sm.registerUtility(site.MailHost, IMailHost)
if use_changed:
mh.smtp_port = '1'
mh.smtp_pwd = "value1"
mh.smtp_host = "value2"
mh.smtp_uid = "value3"
return site
def testAvailableSizes(self):
# by default, no named scales are configured
self.assertEqual(self.scaling.available_sizes, {})
# a callable can be used to look up the available sizes
def custom_available_sizes():
return {'bar': (10, 10)}
sm = getSiteManager()
sm.registerUtility(component=custom_available_sizes,
provided=IAvailableSizes)
self.assertEqual(self.scaling.available_sizes, {'bar': (10, 10)})
sm.unregisterUtility(provided=IAvailableSizes)
# for testing purposes, the sizes may also be set directly on
# the scaling adapter
self.scaling.available_sizes = {'qux': (12, 12)}
self.assertEqual(self.scaling.available_sizes, {'qux': (12, 12)})
def testObjectImplements(self):
from Products.membrane.catalog import object_implements
# Some adapters are registered too broadly and don't actually
# succeed, some of those fail with TypeError and cause this
# test to fail. Use lookup() to retrieve the factory without
# calling it
lookup = component.getSiteManager().adapters.lookup
mt = self.mbtool
provided = (interface.providedBy(mt), )
interface_ids = object_implements(mt)()
for iid in interface_ids:
iface = resolveInterface(str(iid))
try:
lookup(provided, iface)
except TypeError:
self.fail("Can't adapt to %s" % iid)
def test_ec_context(self):
sm = getSiteManager()
sm.registerUtility(DummyMembershipTool(), IMembershipTool)
ec = createExprContext(self.folder, self.portal, self.object)
object = ec.contexts['object']
portal = ec.contexts['portal']
folder = ec.contexts['folder']
self.assertTrue(object)
self.assertEqual(object.id, 'bar')
self.assertEqual(object.absolute_url(), 'url_bar')
self.assertTrue(portal)
self.assertEqual(portal.id, 'portal')
self.assertEqual(portal.absolute_url(), 'url_portal')
self.assertTrue(folder)
self.assertEqual(folder.id, 'foo')
self.assertEqual(folder.absolute_url(), 'url_foo')
def setUp(self):
from zope.site.folder import Folder
ReferenceSetupMixin.setUp(self)
sm = getSiteManager(self.root)
self.utility = addUtility(sm, '1', IIntIds, IntIds())
self.root['folder1'] = Folder()
self.root._p_jar = ConnectionStub()
self.root['folder1']['folder1_1'] = self.folder1_1 = Folder()
self.root['folder1']['folder1_1']['folder1_1_1'] = Folder()
sm1_1 = createSiteManager(self.folder1_1)
self.utility1 = addUtility(sm1_1, '2', IIntIds, IntIds())
provideHandler(intIdEventNotify)
def test_wrapping3(self):
# DummyContent does not implement IIndexableObject
# wrapper registered - should look this up
def FakeWrapper(object, catalog):
return object
from zope.component import getSiteManager
self.sm = getSiteManager()
self.sm.registerAdapter(FakeWrapper, (IContentish, ICatalogTool),
IIndexableObject)
dummy = DummyContent(catalog=1)
ctool = self._makeOne()
ctool.catalog_object(dummy, '/dummy')
self.assertEqual(1, len(ctool._catalog.searchResults()))
def exportActionIconsTool(context):
""" Export caching policy manager settings as an XML file.
"""
site = context.getSite()
logger = context.getLogger('action-icons')
tool = getSiteManager(site).queryUtility(IActionIconsTool)
if tool is None:
logger.debug('Nothing to export.')
return
mhc = ActionIconsToolExportConfigurator(site).__of__(site)
text = mhc.generateXML()
context.writeDataFile(_FILENAME, text, 'text/xml')
logger.info('Action icons tool settings exported.')
def test_caching(self):
# Test HTTP caching headers.
from Products.CMFCore.tests.base.dummy import DummyCachingManager
self.root.caching_policy_manager = DummyCachingManager()
sm = getSiteManager(self.root)
sm.registerUtility(self.root.caching_policy_manager,
ICachingPolicyManager)
original_len = len(self.RESPONSE.headers)
script = self._makeOne('testReST', 'testReST.rst')
script = script.__of__(self.root)
script(self.REQUEST, self.RESPONSE)
self.failUnless(len(self.RESPONSE.headers) >= original_len + 2)
self.failUnless('foo' in self.RESPONSE.headers.keys())
self.failUnless('bar' in self.RESPONSE.headers.keys())
def members(context):
if context is None:
context = getSiteManager()
mship = getToolByName(context, 'portal_membership')
filter = getToolByName(context,
'portal_properties').site_properties.getProperty(
'ims_member_filter', ())
portal_state = getMultiAdapter((context, context.REQUEST),
name='plone_portal_state')
member = portal_state.member()
userid = member.getId()
return SimpleVocabulary([
SimpleTerm(m, m,
mship.getMemberInfo(m).get('fullname', m).decode('UTF-8'))
for m in mship.listMemberIds() if not m in filter and not m == userid
])
def setUp(self):
from Products.CMFUid.interfaces import IUniqueIdAnnotationManagement
from Products.CMFCore.utils import registerToolInterface
SecurityTest.setUp(self)
self.uidannotation = self._makeOne()
registerToolInterface('portal_uidhandler', IUniqueIdHandler)
sm = getSiteManager()
sm.registerUtility(self.uidannotation, IUniqueIdAnnotationManagement)
sm.registerUtility(DummyUniqueIdHandlerTool(), IUniqueIdHandler)
self.app._setObject('dummy', DummyContent(id='dummy'))
self.app._setObject('site', Folder('site'))
transaction.savepoint(optimistic=True)
def test_HomeFolder_methods(self):
from Products.CMFCore.interfaces import IMembershipTool
mtool = getSiteManager().getUtility(IMembershipTool)
setRequest(self.REQUEST)
self.assertEqual(mtool.getHomeFolder(id='member_foo'), None)
self.assertEqual(mtool.getHomeUrl(id='member_foo'), None)
self.site._setObject('Members', PortalFolder('Members'))
self.assertEqual(mtool.getHomeFolder(id='member_foo'), None)
self.assertEqual(mtool.getHomeUrl(id='member_foo'), None)
self.site.Members._setObject('member_foo', PortalFolder('member_foo'))
self.assertEqual(mtool.getHomeFolder(id='member_foo'),
self.site.Members.member_foo)
self.assertEqual(mtool.getHomeUrl(id='member_foo'),
'http://nohost/bar/site/Members/member_foo')
clearRequest()
