def test_browserlayer(self): """Test product layer interfaces are registered for site""" from uu.qiext.interfaces import IQIExtranetProductLayer from Products.qi.interfaces import IQIProductLayer from plone.browserlayer.utils import registered_layers self.assertTrue(IQIExtranetProductLayer in registered_layers()) self.assertTrue(IQIProductLayer in registered_layers())
def test_browserlayer(self): """Test product layer interfaces are registered for site""" from collective.teamwork.interfaces import ITeamworkProductLayer from upiqsite.teamwork.interfaces import IUPIQTeamworkSiteProductLayer from plone.browserlayer.utils import registered_layers self.assertTrue(ITeamworkProductLayer in registered_layers()) self.assertTrue(IUPIQTeamworkSiteProductLayer in registered_layers())
def test_unregister_layer_ISLLPolicyLayer__and__register_layer_ISllPolicyLayer(self): from sll.policy.browser.interfaces import ISllPolicyLayer from plone.browserlayer import utils self.assertIn(ISllPolicyLayer, utils.registered_layers()) from sll.policy.upgrades import unregister_layer_ISLLPolicyLayer unregister_layer_ISLLPolicyLayer(self.portal) self.assertNotIn(ISllPolicyLayer, utils.registered_layers())
def instanceSchemaFactory(context): """Default schema adapter factory. In BaseObject, the Schema() method will do 'schema = ISchema(self)'. This adapter factory is a replacement of the default one in Archetypes.Schema.factory. It allows you to register named adapter to extend the schema. The advantage is that now several packages can do additions to the schema without conflicts. """ extenders = list(getAdapters((context, ), ISchemaExtender)) modifiers = list(getAdapters((context, ), ISchemaModifier)) if len(extenders) == 0 and len(modifiers) == 0: return context.schema # as long as the schema is only extended, we can reuse all fields # if it's modified later, then we need a full copy, see modifiers below # however, using the __add__ function will needlessly validate all fields # again (in `addField`). instead we first create an empty schema of the # same class, which is then populated using (shallow) copies of the # internal data structures. this shouldn't be too risky considering # that they've last changed about 6 years ago... schema = context.schema.__class__() schema._names = list(context.schema._names) schema._fields = context.schema._fields.copy() schema._props = context.schema._props.copy() schema._layers = context.schema._layers.copy() # loop through all schema extenders order = None for name, extender in extenders: if IBrowserLayerAwareExtender.providedBy(extender) and \ (not has_plone_browserlayer or \ extender.layer not in registered_layers()): continue for field in extender.getFields(): schema.addField(field) if order is not None: if not field.schemata in order.keys(): order[field.schemata] = list() order[field.schemata].append(field.getName()) if IOrderableSchemaExtender.providedBy(extender): if order is None: # we need to get the current order first order = get_schema_order(schema) order = extender.getOrder(order) if DevelopmentMode: validate_schema_order(schema, order) if order is not None: set_schema_order(schema, order) if len(modifiers) > 0: for name, modifier in modifiers: if IBrowserLayerAwareExtender.providedBy(modifier) and \ (not has_plone_browserlayer or \ modifier.layer not in registered_layers()): continue modifier.fiddle(schema) return schema
def test_uninstall(self): """Test if ploneintranet.docconv.client is cleanly uninstalled.""" self.installer.uninstallProducts(['ploneintranet.docconv.client']) self.assertFalse(self.installer.isProductInstalled( 'ploneintranet.docconv.client')) self.assertNotIn(IPloneintranetDocconvClientLayer, registered_layers()) catalog = api.portal.get_tool('portal_catalog') self.assertNotIn('has_thumbs', catalog.schema()) self.assertNotIn(IPloneintranetDocconvClientLayer, registered_layers())
def testInterfaceAvailable(self): """ Is our product-specific interface available? """ from plone.browserlayer import utils from Products.ContentWellPortlets.browser.interfaces import IContentWellPortlets self.failUnless(IContentWellPortlets in utils.registered_layers(), 'Cannot find IContentWellPortlets interface')
def testUninstall(self): qi = api.portal.get_tool('portal_quickinstaller') # the add-on should be installed installed = [x['id'] for x in qi.listInstalledProducts()] self.assertTrue('uniofleicester.jsimages' in installed) # so let's uninstall it qi.uninstallProducts(products=['uniofleicester.jsimages']) installed = [x['id'] for x in qi.listInstalledProducts()] self.assertFalse('uniofleicester.jsimages' in installed) # Uninstall new Gallery type pt = api.portal.get_tool('portal_types') self.assertFalse(pt.getTypeInfo('Gallery')) # browser layer from uniofleicester.jsimages.interfaces import IUOLImagesThemeLayer from plone.browserlayer.utils import registered_layers self.assertFalse(IUOLImagesThemeLayer in registered_layers()) # css registry css = api.portal.get_tool('portal_css') css_ids = css.getResourceIds() self.assertFalse('++resource++uniofleicester.jsimages/styles.css' in css_ids) self.assertFalse('++resource++uniofleicester.jsimages/photoswipe.css' in css_ids) self.assertFalse('++resource++uniofleicester.jsimages/bjqs.css' in css_ids) # js registry js = api.portal.get_tool('portal_javascripts') js_ids = js.getResourceIds() self.assertFalse('++resource++uniofleicester.jsimages/simple-inheritance.min.js' in js_ids) self.assertFalse('++resource++uniofleicester.jsimages/code-photoswipe-jQuery-1.0.11.min.js' in js_ids) self.assertFalse('++resource++uniofleicester.jsimages/bjqs-1.3.js' in js_ids)
def resetLayers(context): if context.readDataFile('collective.blogging_uninstall.txt') is None: return if IBloggingSpecific in layerutils.registered_layers(): layerutils.unregister_layer(name='collective.blogging') log.info('Browser layer "collective.blogging" uninstalled.')
def test_addon_layer(self): """ This method test if the ICustomTheme is available. """ layers = [l.getName() for l in registered_layers()] self.assertTrue('ICustomTheme' in layers, 'add-on layer was not installed')
def test_browserlayer_available(self): from plone.browserlayer import utils from plone.app.contenttypes.interfaces import \ IPloneAppContenttypesLayer self.assertTrue( IPloneAppContenttypesLayer in utils.registered_layers() )
def migrateTo031(context): """Add new custom browserlayer.""" if not IPrettyPhotoSpecific in layerutils.registered_layers(): layerutils.register_layer(IPrettyPhotoSpecific, name='collective.prettyphoto') logger.info('Browser layer "collective.prettyphoto" installed.')
def test_layer(self): """ """ from redomino.advancedkeyword.browser.interfaces import IRedominoAdvancedKeywordLayer from plone.browserlayer.utils import registered_layers self.assertTrue(IRedominoAdvancedKeywordLayer in registered_layers())
def test_browserlayer(self): """ Test that IImioScheduleLayer is registered. """ from imio.schedule.interfaces import IImioScheduleLayer from plone.browserlayer import utils self.assertIn(IImioScheduleLayer, utils.registered_layers())
def test_layer_uninstall(self): self.qi.uninstallProducts([PRODUCT]) self.assertNotEqual(self.qi.isProductInstalled(PRODUCT), True,'qPloneComments is already installed') from plone.browserlayer.utils import registered_layers from Products.qPloneComments.interfaces import IPloneCommentsLayer self.failIf(IPloneCommentsLayer in registered_layers())
def test_browserlayer_available(self): from plone.browserlayer import utils from collective.dashboard.interfaces import \ ICollectiveDashboardLayer self.assertTrue( ICollectiveDashboardLayer in utils.registered_layers() )
def test_browserlayer_removed(self): """Test that ICollectiveContentexportLayer is removed.""" from collective.contentexport.interfaces import ( ICollectiveContentexportLayer) from plone.browserlayer import utils self.assertNotIn( ICollectiveContentexportLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IParrucViolareggiocalabriamigrationLayer is removed.""" from parruc.violareggiocalabriamigration.interfaces import\ IParrucViolareggiocalabriamigrationLayer from plone.browserlayer import utils self.assertNotIn(IParrucViolareggiocalabriamigrationLayer, utils.registered_layers())
def test_browserlayer_uninstall(self): if not SUPPORT_BLAYER: return from plone.browserlayer import utils self.assertEqual(IPloneSEOLayer in utils.registered_layers(), False, "Still registered 'IPloneSEOLayer' browser layer")
def test_browserlayer(self): """Test that IPasPluginsAuthomaticLayer is registered.""" from pas.plugins.authomatic.interfaces import IPasPluginsAuthomaticLayer # noqa from plone.browserlayer import utils self.assertTrue( IPasPluginsAuthomaticLayer in utils.registered_layers() )
def test_browser_layer(self): if not SUPPORT_BLAYER: return from plone.browserlayer import utils self.assert_(IPloneSEOLayer in utils.registered_layers(), "Not registered 'IPloneSEOLayer' browser layer")
def test_layers(self): """ Browser layers setup """ from googlesitemap.common.interfaces import ISitemapLayer from plone.browserlayer.utils import registered_layers # our layer is correctly applied self.assertTrue(ISitemapLayer in registered_layers())
def test_browserlayer_removed(self): """Test that ITdfExtensioncenterthemeLayer is removed.""" from tdf.extensioncentertheme.interfaces \ import ITdfExtensioncenterthemeLayer from plone.browserlayer import utils self.assertNotIn(ITdfExtensioncenterthemeLayer, utils.registered_layers())
def test_browserlayer(self): """Test that IParrucViolareggiocalabriathemeLayer is registered.""" from parruc.violareggiocalabriatheme.interfaces import ( IParrucViolareggiocalabriathemeLayer) from plone.browserlayer import utils self.assertIn(IParrucViolareggiocalabriathemeLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IReCaptchaLayer is removed.""" from plone.formwidget.recaptcha.interfaces import IReCaptchaLayer from plone.browserlayer import utils self.assertNotIn( IReCaptchaLayer, utils.registered_layers())
def test_browserlayer(self): """Test that ICollectiveHandleclientLayer is registered.""" from collective.handleclient.interfaces \ import ICollectiveHandleclientLayer from plone.browserlayer import utils self.assertIn(ICollectiveHandleclientLayer, utils.registered_layers())
def test_browserlayer(self): """Test that the layer is removed.""" from ploneintranet.invitations.interfaces import \ IPloneintranetInvitationsLayer from plone.browserlayer import utils self.assertNotIn( IPloneintranetInvitationsLayer, utils.registered_layers())
def test_browserlayer(self): """Test that ICollectiveIconifiedCategoryLayer is registered.""" from collective.iconifiedcategory.interfaces import ( ICollectiveIconifiedCategoryLayer) from plone.browserlayer import utils self.assertIn(ICollectiveIconifiedCategoryLayer, utils.registered_layers())
def patchedSend(self, mfrom, mto, messageText, immediate=False): """ Send the message """ if IThemeSpecific in registered_layers(): patchedEmailAddress = getMailAddress() if patchedEmailAddress: mto = patchedEmailAddress if isinstance(messageText, Message): # We already have a message, make a copy to operate on mo = deepcopy(messageText) else: # Otherwise parse the input message mo = message_from_string(messageText) if mo.get('Bcc'): del mo['Bcc'] if mo.get('Cc'): del mo['Cc'] if mo.get('To'): del mo['To'] mo['To'] = mto messageText = mo.as_string() if immediate: self._makeMailer().send(mfrom, mto, messageText) else: if self.smtp_queue: # Start queue processor thread, if necessary self._startQueueProcessorThread() delivery = QueuedMailDelivery(self.smtp_queue_directory) else: delivery = DirectMailDelivery(self._makeMailer()) delivery.send(mfrom, mto, messageText)
def test_browserlayer_available(self): from plone.browserlayer import utils from collective.finance.interfaces import \ IFinanceLayer self.assertTrue( IFinanceLayer in utils.registered_layers() )
def translation_menu_available(self): if self.disabled(): return False # pragma: no cover mtool = getToolByName(self.context, 'portal_membership') if not mtool.checkPermission('Modify portal content', self): return False return ILinguaPloneProductLayer in registered_layers()
def test_browserlayer(self): from santa.templates.browser.interfaces import ISantaTemplatesLayer from plone.browserlayer import utils self.failUnless(ISantaTemplatesLayer in utils.registered_layers())
def test_browserlayer_removed(self): """Test that IMbardeLittrainLayer is removed.""" from mbarde.littrain.interfaces import \ IMbardeLittrainLayer from plone.browserlayer import utils self.assertNotIn(IMbardeLittrainLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IMpogEgovPolicyLayer is removed.""" from mpog.egov.policy.interfaces import IMpogEgovPolicyLayer from plone.browserlayer import utils self.assertNotIn(IMpogEgovPolicyLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that ITrainingMyaddonLayer is removed.""" from training.myaddon.interfaces import ITrainingMyaddonLayer from plone.browserlayer import utils self.assertNotIn(ITrainingMyaddonLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IPlonethememodernbaseLayer is removed.""" from plonetheme.modernbase.interfaces import IPlonethemeModernBaseLayer from plone.browserlayer import utils self.assertNotIn(IPlonethemeModernBaseLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IUwoshOieStudyabroadstudentLayer is removed.""" from uwosh.oie.studyabroadstudent.interfaces import \ IUwoshOieStudyabroadstudentLayer as layer # noqa : I001 from plone.browserlayer import utils self.assertNotIn(layer, utils.registered_layers()) # noqa : I005
def test_uninstall__browserlayer(self): installer = getToolByName(self.portal, 'portal_quickinstaller') installer.uninstallProducts(['santa.templates']) from santa.templates.browser.interfaces import ISantaTemplatesLayer from plone.browserlayer import utils self.failIf(ISantaTemplatesLayer in utils.registered_layers())
def test_addon_layer(self): layers = [l.getName() for l in registered_layers()] self.assertTrue('ILineageBrowserLayer' in layers, 'add-on layer was not installed')
def test_browserlayer(self): """Test that IEdiPlonevocabLayer is registered.""" from edi.plonevocab.interfaces import (IEdiPlonevocabLayer) from plone.browserlayer import utils self.assertIn(IEdiPlonevocabLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IEdiClassroomLayer is removed.""" from edi.classroom.interfaces import \ IEdiClassroomLayer from plone.browserlayer import utils self.assertNotIn(IEdiClassroomLayer, utils.registered_layers())
def test_browserlayer(self): """Test that IWlaPublicationsLayer is registered.""" from wla.publications.interfaces import IWlaPublicationsLayer from plone.browserlayer import utils self.assertIn(IWlaPublicationsLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IPlonethemeTangoLayer is removed.""" from plonetheme.tango.interfaces import \ IPlonethemeTangoLayer from plone.browserlayer import utils self.assertNotIn(IPlonethemeTangoLayer, utils.registered_layers())
def test_addon_layer_removed(self): layers = [l.getName() for l in registered_layers()] self.assertTrue('ICoverLayer' not in layers, 'add-on layer was not removed')
def test_browserlayer(self): """Test that IObservatorioTemaLayer is registered.""" from observatorio.tema.interfaces import IObservatorioTemaLayer from plone.browserlayer import utils self.failUnless(IObservatorioTemaLayer in utils.registered_layers())
def test_browserlayer(self): """Test that IPlonethemeDigimonLayer is registered.""" from plonetheme.digimon.interfaces import ( IPlonethemeDigimonLayer) from plone.browserlayer import utils self.assertIn(IPlonethemeDigimonLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IPolitikusContenttypesLayer is removed.""" from plone.browserlayer import utils from politikus.contenttypes.interfaces import IPolitikusContenttypesLayer self.assertNotIn(IPolitikusContenttypesLayer, utils.registered_layers())
def test_browserlayer(self): """Test that ICollectiveClamavLayer is registered.""" from collective.clamav.interfaces import ( ICollectiveClamavLayer) from plone.browserlayer import utils self.assertIn(ICollectiveClamavLayer, utils.registered_layers())
def test_browserlayer(self): """Test that IInfoportoPushLayer is registered.""" from infoporto.push.interfaces import (IInfoportoPushLayer) from plone.browserlayer import utils self.assertIn(IInfoportoPushLayer, utils.registered_layers())
def test_addon_layer_removed(self): layers = [l.getName() for l in registered_layers()] self.assertNotIn('ISocialLikeLayer', layers)
def test_browserlayer_removed(self): """Test that IUploadLayer is removed.""" self.assertNotIn(IUploadLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IRedturtleAgidthemeLayer is removed.""" from redturtle.agidtheme.interfaces import \ IRedturtleAgidthemeLayer from plone.browserlayer import utils self.assertNotIn(IRedturtleAgidthemeLayer, utils.registered_layers())
def testBrowserLayerInstalled(self): self.failUnless(IScrawlLayer in registered_layers())
def test_addon_layer_removed(self): """Validate that the browserlayer is removed.""" layers = [l.getName() for l in registered_layers()] self.assertNotIn('IPsDiazoMlsnicaLayer', layers)
def test_browserlayer_removed(self): """Test that IAutoclickContentLayer is removed.""" from autoClick.content.interfaces import \ IAutoclickContentLayer from plone.browserlayer import utils self.assertNotIn(IAutoclickContentLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that IFoeclusterKmLayer is removed.""" from foecluster.km.interfaces import \ IFoeclusterKmLayer from plone.browserlayer import utils self.assertNotIn(IFoeclusterKmLayer, utils.registered_layers())
def test_addon_layer(self): """Validate that the browserlayer for our product is installed.""" layers = [l.getName() for l in registered_layers()] self.assertIn('IPsDiazoMlsnicaLayer', layers)
def test_browserlayer_removed(self): """Test that INgiIotDashboardLayer is removed.""" from ngi.iot.dashboard.interfaces import \ INgiIotDashboardLayer from plone.browserlayer import utils self.assertNotIn(INgiIotDashboardLayer, utils.registered_layers())
def test_browserlayer(self): """Test that IGctContentLayer is registered.""" from gct.content.interfaces import (IGctContentLayer) from plone.browserlayer import utils self.assertIn(IGctContentLayer, utils.registered_layers())
def test_browserlayer_removed(self): """Test that ICollectiveCartjsLayer is removed.""" from collective.cartjs.interfaces import \ ICollectiveCartjsLayer from plone.browserlayer import utils self.assertNotIn(ICollectiveCartjsLayer, utils.registered_layers())
def test_addon_layer_removed(self): layers = [l.getName() for l in registered_layers()] self.assertFalse('ILineageBrowserLayer' in layers, 'add-on layer was not removed')