Beispiel #1
0
 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())
Beispiel #2
0
 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())
Beispiel #3
0
 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())
Beispiel #4
0
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
Beispiel #5
0
 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())
Beispiel #6
0
 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())
Beispiel #13
0
 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())
Beispiel #26
0
 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()
Beispiel #31
0
 def test_browserlayer(self):
     from santa.templates.browser.interfaces import ISantaTemplatesLayer
     from plone.browserlayer import utils
     self.failUnless(ISantaTemplatesLayer in utils.registered_layers())
Beispiel #32
0
 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())
Beispiel #34
0
 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())
Beispiel #36
0
 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
Beispiel #37
0
 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())
Beispiel #38
0
 def test_addon_layer(self):
     layers = [l.getName() for l in registered_layers()]
     self.assertTrue('ILineageBrowserLayer' in layers,
                     'add-on layer was not installed')
Beispiel #39
0
 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())
Beispiel #40
0
 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())
Beispiel #41
0
 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())
Beispiel #42
0
 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())
Beispiel #43
0
 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')
Beispiel #44
0
 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())
Beispiel #45
0
 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())
Beispiel #46
0
 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())
Beispiel #48
0
 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())
Beispiel #49
0
 def test_addon_layer_removed(self):
     layers = [l.getName() for l in registered_layers()]
     self.assertNotIn('ISocialLikeLayer', layers)
Beispiel #50
0
 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())
Beispiel #53
0
 def test_addon_layer_removed(self):
     """Validate that the browserlayer is removed."""
     layers = [l.getName() for l in registered_layers()]
     self.assertNotIn('IPsDiazoMlsnicaLayer', layers)
Beispiel #54
0
 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())
Beispiel #55
0
 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())
Beispiel #56
0
 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)
Beispiel #57
0
 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())
Beispiel #58
0
 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())
Beispiel #59
0
 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())
Beispiel #60
0
 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')