Python PersistentCoverTile Examples

Example #1

File: test_base_tile.py Project: Adniel/collective.cover

class BaseTileTestCase(unittest.TestCase):

    layer = INTEGRATION_TESTING

    def _register_tile(self):
        xmlconfig(StringIO(ZCML))

    def setUp(self):
        self.portal = self.layer['portal']
        self.request = self.layer['request']

        eventtesting.setUp()

        self._register_tile()
        self.tile = PersistentCoverTile(self.portal, self.request)
        # XXX: tile initialization
        self.tile.__name__ = 'collective.cover.base'

    def test_interface(self):
        self.assertTrue(IPersistentCoverTile.implementedBy(PersistentCoverTile))
        self.assertTrue(verifyClass(IPersistentCoverTile, PersistentCoverTile))
        # cover tiles inherit from plone.tile PersistentTile
        self.assertTrue(IPersistentTile.implementedBy(PersistentCoverTile))

        tile = PersistentCoverTile(None, None)
        self.assertTrue(IPersistentCoverTile.providedBy(tile))
        self.assertTrue(verifyObject(IPersistentCoverTile, tile))
        # cover tiles inherit from plone.tile PersistentTile
        self.assertTrue(IPersistentTile.providedBy(tile))
        #self.assertTrue(verifyObject(IPersistentTile, tile))

    def test_default_configuration(self):
        self.assertFalse(self.tile.is_configurable)
        self.assertTrue(self.tile.is_editable)
        self.assertTrue(self.tile.is_droppable)

    def test_all_content_types_accepted_by_default(self):
        self.assertEqual(self.tile.accepted_ct(), None)

    def test_delete_tile_persistent_data(self):
        eventtesting.clearEvents()
        # First, let's assign an id to the tile and store some data
        self.tile.id = 'test-tile'
        data_mgr = ITileDataManager(self.tile)
        data_mgr.set({'test': 'data'})

        # We see that the data persists
        self.assertIn('test', data_mgr.get())
        self.assertEqual(data_mgr.get()['test'], 'data')

        # Call the delete method
        self.tile.delete()

        # Now we should not see the stored data anymore
        self.assertNotIn('test', data_mgr.get())

        events = eventtesting.getEvents()

        # Finally, test that ObjectModifiedEvent was fired for the cover
        self.assertEqual(events[0].object, self.portal)

Example #2

File: test_base_tile.py Project: sixfeetup/collective.cover

 def setUp(self):
     super(BaseTileTestCase, self).setUp()
     eventtesting.setUp()
     self._register_tile()
     self.tile = PersistentCoverTile(self.cover, self.request)
     self.tile.__name__ = u'collective.cover.base'
     self.tile.id = u'test'

Example #3

    def setUp(self):
        self.portal = self.layer['portal']
        self.request = self.layer['request']

        eventtesting.setUp()

        self.tile = PersistentCoverTile(self.portal, self.request)

Example #4

File: test_base_tile.py Project: quyet-nguyen/collective.cover

    def setUp(self):
        self.portal = self.layer['portal']
        self.request = self.layer['request']

        eventtesting.setUp()

        self._register_tile()
        self.tile = PersistentCoverTile(self.portal, self.request)
        # XXX: tile initialization
        self.tile.__name__ = 'collective.cover.base'

Example #5

class BaseTileTestCase(unittest.TestCase):

    layer = INTEGRATION_TESTING

    def setUp(self):
        self.portal = self.layer['portal']
        self.request = self.layer['request']

        eventtesting.setUp()

        self.tile = PersistentCoverTile(self.portal, self.request)

    def test_interface(self):
        self.assertTrue(
            IPersistentCoverTile.implementedBy(PersistentCoverTile))
        self.assertTrue(verifyClass(IPersistentCoverTile, PersistentCoverTile))
        # cover tiles inherit from plone.tile PersistentTile
        self.assertTrue(IPersistentTile.implementedBy(PersistentCoverTile))

        tile = PersistentCoverTile(None, None)
        self.assertTrue(IPersistentCoverTile.providedBy(tile))
        self.assertTrue(verifyObject(IPersistentCoverTile, tile))
        # cover tiles inherit from plone.tile PersistentTile
        self.assertTrue(IPersistentTile.providedBy(tile))
        #self.assertTrue(verifyObject(IPersistentTile, tile))

    def test_default_configuration(self):
        self.assertFalse(self.tile.is_configurable)
        self.assertTrue(self.tile.is_editable)
        self.assertTrue(self.tile.is_droppable)

    def test_all_content_types_accepted_by_default(self):
        self.assertEqual(self.tile.accepted_ct(), None)

    def test_delete_tile_persistent_data(self):
        eventtesting.clearEvents()
        # First, let's assign an id to the tile and store some data
        self.tile.id = 'test-tile'
        data_mgr = ITileDataManager(self.tile)
        data_mgr.set({'test': 'data'})

        # We see that the data persists
        self.assertEqual(data_mgr.get(), {'test': 'data'})

        # Call the delete method
        self.tile.delete()

        # Now we should not see the stored data anymore
        self.assertEqual(data_mgr.get(), {})

        events = eventtesting.getEvents()

        # Finally, test that ObjectModifiedEvent was fired for the cover
        self.assertEqual(events[0].object, self.portal)

Example #6

    def populate_with_object(self, obj):
        PersistentCoverTile.populate_with_object(self, obj)

        if obj.portal_type not in self.accepted_ct():
            return

        data = {
            'title': safe_unicode(obj.Title()),
            'uuid': IUUID(obj),
        }
        data_mgr = ITileDataManager(self)
        data_mgr.set(data)

Example #7

class BaseTileTestCase(TestTileMixin, unittest.TestCase):

    def _register_tile(self):
        xmlconfig(StringIO(ZCML))

    def setUp(self):
        super(BaseTileTestCase, self).setUp()
        eventtesting.setUp()
        self._register_tile()
        self.tile = PersistentCoverTile(self.cover, self.request)
        self.tile.__name__ = u'collective.cover.base'
        self.tile.id = u'test'

    def test_interface(self):
        self.interface = IPersistentCoverTile
        self.klass = PersistentCoverTile
        super(BaseTileTestCase, self).test_interface()

    def test_tile_registration(self):
        pass

    def test_default_configuration(self):
        self.assertFalse(self.tile.is_configurable)
        self.assertTrue(self.tile.is_editable)
        self.assertTrue(self.tile.is_droppable)

    def test_accepted_content_types(self):
        self.assertEqual(self.tile.accepted_ct(), ALL_CONTENT_TYPES)

    def test_delete_tile_persistent_data(self):
        eventtesting.clearEvents()
        # First, let's store some data on the tile
        data_mgr = ITileDataManager(self.tile)
        data_mgr.set({'test': 'data'})

        # We see that the data persists
        self.assertIn('test', data_mgr.get())
        self.assertEqual(data_mgr.get()['test'], 'data')

        # Call the delete method
        self.tile.delete()

        # Now we should not see the stored data anymore
        self.assertNotIn('test', data_mgr.get())

        events = eventtesting.getEvents()

        # Finally, test that ObjectModifiedEvent was fired for the cover
        self.assertEqual(events[0].object, self.cover)

Example #8

File: test_base_tile.py Project: EricSchles/collective.cover

 def setUp(self):
     super(BaseTileTestCase, self).setUp()
     eventtesting.setUp()
     self._register_tile()
     self.tile = PersistentCoverTile(self.cover, self.request)
     self.tile.__name__ = u'collective.cover.base'
     self.tile.id = u'test'

Example #9

File: test_tile_base_class.py Project: digitalnatif/collective.cover

    def setUp(self):
        self.portal = self.layer['portal']
        self.request = self.layer['request']

        eventtesting.setUp()

        self.tile = PersistentCoverTile(self.portal, self.request)

Example #10

File: test_base_tile.py Project: Adniel/collective.cover

    def setUp(self):
        self.portal = self.layer['portal']
        self.request = self.layer['request']

        eventtesting.setUp()

        self._register_tile()
        self.tile = PersistentCoverTile(self.portal, self.request)
        # XXX: tile initialization
        self.tile.__name__ = 'collective.cover.base'

Example #11

File: test_base_tile.py Project: quyet-nguyen/collective.cover

    def test_interface(self):
        self.assertTrue(
            IPersistentCoverTile.implementedBy(PersistentCoverTile))
        self.assertTrue(verifyClass(IPersistentCoverTile, PersistentCoverTile))
        # cover tiles inherit from plone.tile PersistentTile
        self.assertTrue(IPersistentTile.implementedBy(PersistentCoverTile))

        tile = PersistentCoverTile(None, None)
        self.assertTrue(IPersistentCoverTile.providedBy(tile))
        self.assertTrue(verifyObject(IPersistentCoverTile, tile))
        # cover tiles inherit from plone.tile PersistentTile
        self.assertTrue(IPersistentTile.providedBy(tile))

Example #12

File: test_base_tile.py Project: collective/collective.cover

class BaseTileTestCase(TestTileMixin, unittest.TestCase):

    def _register_tile(self):
        xmlconfig(BytesIO(ZCML))

    def setUp(self):
        super(BaseTileTestCase, self).setUp()
        self._register_tile()
        self.tile = PersistentCoverTile(self.cover, self.request)
        self.tile.__name__ = u'collective.cover.base'
        self.tile.id = u'test'

    def test_interface(self):
        self.interface = IPersistentCoverTile
        self.klass = PersistentCoverTile
        super(BaseTileTestCase, self).test_interface()

    def test_tile_registration(self):
        pass

    def test_default_configuration(self):
        self.assertFalse(self.tile.is_configurable)
        self.assertTrue(self.tile.is_editable)
        self.assertTrue(self.tile.is_droppable)

    def test_accepted_content_types(self):
        self.assertEqual(self.tile.accepted_ct(), ALL_CONTENT_TYPES)

    def test_delete_tile_removes_persistent_data(self):
        # https://github.com/collective/collective.cover/issues/765
        from collective.cover.config import CONFIGURATION_PREFIX
        from collective.cover.config import PERMISSIONS_PREFIX
        from zope.annotation import IAnnotations
        from zope.component import eventtesting
        from zope.lifecycleevent import IObjectModifiedEvent
        eventtesting.setUp()
        annotations = IAnnotations(self.tile.context)

        data_mgr = ITileDataManager(self.tile)
        data_mgr.set({'test': 'data'})
        self.assertIn('test', data_mgr.get())
        self.assertEqual(data_mgr.get()['test'], 'data')

        permissions = getMultiAdapter(
            (self.cover, self.request, self.tile), ITilesPermissions)
        permissions.set_allowed_edit('masters_of_the_universe')
        self.assertIn(PERMISSIONS_PREFIX + '.test', annotations)

        configuration = getMultiAdapter(
            (self.cover, self.request, self.tile), ITilesConfigurationScreen)
        configuration.set_configuration({'uuid': 'c1d2e3f4g5jrw'})
        self.assertIn(CONFIGURATION_PREFIX + '.test', annotations)

        # Call the delete method
        eventtesting.clearEvents()
        self.tile.delete()

        # Now we should not see the persistent data anymore
        self.assertNotIn('test', data_mgr.get())
        self.assertNotIn(PERMISSIONS_PREFIX + '.test', annotations)
        self.assertNotIn(CONFIGURATION_PREFIX + '.test', annotations)

        # Finally, test that ObjectModifiedEvent was fired for the cover
        events = eventtesting.getEvents()
        self.assertEqual(len(events), 1)
        self.assertTrue(IObjectModifiedEvent.providedBy(events[0]))

Example #13

class BaseTileTestCase(TestTileMixin, unittest.TestCase):
    def _register_tile(self):
        xmlconfig(BytesIO(ZCML))

    def setUp(self):
        super(BaseTileTestCase, self).setUp()
        self._register_tile()
        self.tile = PersistentCoverTile(self.cover, self.request)
        self.tile.__name__ = u'collective.cover.base'
        self.tile.id = u'test'

    def test_interface(self):
        self.interface = IPersistentCoverTile
        self.klass = PersistentCoverTile
        super(BaseTileTestCase, self).test_interface()

    def test_tile_registration(self):
        pass

    def test_default_configuration(self):
        self.assertFalse(self.tile.is_configurable)
        self.assertTrue(self.tile.is_editable)
        self.assertTrue(self.tile.is_droppable)

    def test_accepted_content_types(self):
        self.assertEqual(self.tile.accepted_ct(), ALL_CONTENT_TYPES)

    def test_delete_tile_removes_persistent_data(self):
        # https://github.com/collective/collective.cover/issues/765
        from collective.cover.config import CONFIGURATION_PREFIX
        from collective.cover.config import PERMISSIONS_PREFIX
        from zope.annotation import IAnnotations
        from zope.component import eventtesting
        from zope.lifecycleevent import IObjectModifiedEvent
        eventtesting.setUp()
        annotations = IAnnotations(self.tile.context)

        data_mgr = ITileDataManager(self.tile)
        data_mgr.set({'test': 'data'})
        self.assertIn('test', data_mgr.get())
        self.assertEqual(data_mgr.get()['test'], 'data')

        permissions = getMultiAdapter((self.cover, self.request, self.tile),
                                      ITilesPermissions)
        permissions.set_allowed_edit('masters_of_the_universe')
        self.assertIn(PERMISSIONS_PREFIX + '.test', annotations)

        configuration = getMultiAdapter((self.cover, self.request, self.tile),
                                        ITilesConfigurationScreen)
        configuration.set_configuration({'uuid': 'c1d2e3f4g5jrw'})
        self.assertIn(CONFIGURATION_PREFIX + '.test', annotations)

        # Call the delete method
        eventtesting.clearEvents()
        self.tile.delete()

        # Now we should not see the persistent data anymore
        self.assertNotIn('test', data_mgr.get())
        self.assertNotIn(PERMISSIONS_PREFIX + '.test', annotations)
        self.assertNotIn(CONFIGURATION_PREFIX + '.test', annotations)

        # Finally, test that ObjectModifiedEvent was fired for the cover
        events = eventtesting.getEvents()
        self.assertEqual(len(events), 1)
        self.assertTrue(IObjectModifiedEvent.providedBy(events[0]))