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()