def test_copy_outdated_ghost_folder(self):
"""Test creating a Ghost Folder and copying it when it is
outdated. We should get a new ghost folder, that is fully
ghost.
"""
factory = self.root.target.manage_addProduct['Silva']
factory.manage_addGhostFolder('ghost', None, haunted=self.root.folder)
self.assertEqual(self.root.target.ghost.get_link_status(), None)
# We delete something from the ghost
manager = IContainerManager(self.root.target.ghost)
with manager.deleter() as deleter:
deleter(self.root.target.ghost.index)
self.assertNotIn('index', self.root.target.ghost.objectIds())
# Copy the ghost in the root folder
with IContainerManager(self.root).copier() as copier:
self.assertNotEqual(copier(self.root.target.ghost), None)
# We should have a copy
self.assertIn('ghost', self.root.objectIds())
self.assertTrue(verifyObject(IGhostFolder, self.root.ghost))
self.assertEqual(self.root.ghost.get_link_status(), None)
self.assertEqual(self.root.ghost.get_haunted(), self.root.folder)
self.assertIn('index', self.root.ghost.objectIds())
self.assertTrue(verifyObject(IGhost, self.root.ghost.index))
self.assertEqual(self.root.ghost.index.get_link_status(), None)
self.assertEqual(
self.root.ghost.index.get_haunted(),
self.root.folder.index)
def test_move_content_id_already_in_use(self):
"""Move a content with an id that is already in use in the
target folder.
"""
factory = self.root.target.manage_addProduct['Silva']
factory.manage_addLink('toc', 'Link to AutoTOC')
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertNotEqual(
mover(self.root.source.toc),
None)
self.assertFalse('toc' in self.root.source.objectIds())
self.assertTrue('toc' in self.root.target.objectIds())
self.assertTrue('move_of_toc' in self.root.target.objectIds())
self.assertTrue(verifyObject(ILink, self.root.target.toc))
self.assertTrue(verifyObject(IAutoTOC, self.root.target.move_of_toc))
# Now if we move it back, the move_of_ will be stripped
manager = IContainerManager(self.root.source)
with assertTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertNotEqual(
mover(self.root.target.move_of_toc),
None)
self.assertTrue('toc' in self.root.source.objectIds())
self.assertFalse('move_of_toc' in self.root.target.objectIds())
self.assertTrue(verifyObject(IAutoTOC, self.root.source.toc))
def test_folder(self):
"""When pasting a folder as a ghost, its content is ghosted
and any versioned content (ghost) in it are published.
"""
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeAddedEvent',
'ObjectAddedEvent',
'ContainerModifiedEvent'):
with manager.ghoster() as ghoster:
ghost = ghoster(self.root.source)
self.assertTrue(verifyObject(IGhostFolder, ghost))
self.assertEqual(ghost.get_link_status(), None)
self.assertEqual(ghost.get_haunted(), self.root.source)
self.assertIn('source', self.root.target.objectIds())
# The ghost folder is created inside the target folder and is
# already haunting the source.
ghost = self.root.target.source
self.assertTrue(verifyObject(IGhostFolder, ghost))
self.assertEqual(ghost.get_link_status(), None)
self.assertEqual(ghost.get_haunted(), self.root.source)
self.assertItemsEqual(
ghost.objectIds(),
['toc', 'data', 'folder', 'logo'])
self.assertTrue(verifyObject(IGhost, ghost.toc))
self.assertEqual(ghost.toc.get_haunted(), self.root.source.toc)
self.assertTrue(verifyObject(IGhost, ghost.data))
self.assertEqual(ghost.data.get_haunted(), self.root.source.data)
self.assertEqual(ghost.data.is_published(), True)
self.assertTrue(verifyObject(IGhostFolder, ghost.folder))
self.assertEqual(ghost.folder.get_haunted(), self.root.source.folder)
def test_collect_quota_on_activation(self):
"""Test values update on activation.
"""
# Create some content
factory = self.root.manage_addProduct['Silva']
factory.manage_addFolder('folder1', 'FooFolder 1')
factory.manage_addFolder('folder2', 'FooFolder 2')
folder1 = self.root._getOb('folder1')
folder2 = self.root._getOb('folder2')
factory = folder1.manage_addProduct['Silva']
factory.manage_addFolder('subfolder', 'Sub FooFolder')
subfolder1 = folder1._getOb('subfolder')
factory = subfolder1.manage_addProduct['Silva']
with self.layer.open_fixture('test1.zip') as source:
factory.manage_addFile('zipfile1.zip', 'Zip File', source)
# After reading the file, position should be end of file
zip1_size = source.tell()
factory = folder2.manage_addProduct['Silva']
with self.layer.open_fixture('torvald.jpg') as source:
factory.manage_addImage('image1.jpg', 'Image File', source)
image1_size = source.tell()
# No counting should be done (extensions not activated)
self.assertEqual(self.root.used_space, 0)
self.assertEqual(folder1.used_space, 0)
self.assertEqual(folder2.used_space, 0)
# Activate the quota system
self.root.service_extensions.enable_quota_subsystem()
# Values should be updated
self.assertEqual(self.root.used_space, zip1_size + image1_size)
self.assertEqual(folder1.used_space, zip1_size)
self.assertEqual(subfolder1.used_space, zip1_size)
self.assertEqual(folder2.used_space, image1_size)
# Disable
self.root.service_extensions.disable_quota_subsystem()
# Do some changes
manager = IContainerManager(folder1)
with manager.deleter() as deleter:
deleter(folder1.subfolder)
with manager.copier() as copier:
copier(self.root.folder2)
# Nothing had change
self.assertEqual(self.root.used_space, zip1_size + image1_size)
self.assertEqual(folder1.used_space, zip1_size)
self.assertEqual(folder2.used_space, image1_size)
# Re-enable
self.root.service_extensions.enable_quota_subsystem()
# Values should be updated
self.assertEqual(self.root.used_space, (2 * image1_size))
self.assertEqual(folder1.used_space, image1_size)
self.assertEqual(folder2.used_space, image1_size)
def test_copy_not_addable_content(self):
"""Move a content that is not addable in the target folder.
This should not be possible (for everybody).
"""
self.root.target.set_silva_addables_allowed_in_container(["Silva Image", "Silva File"])
manager = IContainerManager(self.root.target)
with assertNotTriggersEvents("ObjectWillBeMovedEvent", "ObjectMovedEvent", "ContainerModifiedEvent"):
with manager.copier() as copier:
self.assertIsInstance(copier(self.root.source.toc), ContainerError)
self.assertEqual(self.root.target.objectIds(), [])
def test_delete_single(self):
manager = IContainerManager(self.root.folder)
with assertTriggersEvents(
'ObjectWillBeRemovedEvent',
'ObjectRemovedEvent',
'ContainerModifiedEvent'):
with manager.deleter() as deleter:
self.assertEqual(
deleter(self.root.folder.toc),
self.root.folder.toc)
self.assertFalse('toc' in self.root.folder.objectIds())
def test_move_content_same_container(self):
"""Move a single content into the same container than it is
already there.
"""
manager = IContainerManager(self.root.source)
with assertNotTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertIsInstance(
mover(self.root.source.toc),
ContainerError)
self.assertTrue('toc' in self.root.source.objectIds())
def test_asset(self):
"""Pasting an asset as a ghost asset.
"""
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeAddedEvent',
'ObjectAddedEvent',
'ContainerModifiedEvent'):
with manager.ghoster() as ghoster:
ghost = ghoster(self.root.source.logo)
self.assertTrue(verifyObject(IGhostAsset, ghost))
self.assertIn('logo', self.root.target.objectIds())
self.assertEqual(ghost.get_link_status(), None)
self.assertEqual(ghost.get_haunted(), self.root.source.logo)
def test_move_content(self):
"""Move a single item.
"""
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertNotEqual(
mover(self.root.source.toc),
None)
self.assertFalse('toc' in self.root.source.objectIds())
self.assertTrue('toc' in self.root.target.objectIds())
self.assertTrue(verifyObject(IAutoTOC, self.root.target.toc))
def test_other(self):
"""Pasting a content that doesn't have a ghost
implementation. It should be copied.
"""
factory = self.root.source.manage_addProduct['Silva']
factory.manage_addMockupNonPublishable('stuff', 'Stuff')
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeAddedEvent',
'ObjectAddedEvent',
'ContainerModifiedEvent'):
with manager.ghoster() as ghoster:
ghost = ghoster(self.root.source.stuff)
self.assertTrue(verifyObject(IMockupNonPublishable, ghost))
self.assertIn('stuff', self.root.target.objectIds())
def test_delete_published(self):
"""An author cannot delete published content.
"""
manager = IContainerManager(self.root.folder)
with assertNotTriggersEvents(
'ObjectWillBeRemovedEvent',
'ObjectRemovedEvent',
'ContainerModifiedEvent'):
with manager.deleter() as deleter:
self.assertIsInstance(
deleter(self.root.folder.published_link),
ContentError)
self.assertTrue('published_link' in self.root.folder.objectIds())
def test_delete_published_recursive(self):
"""An editor can delete a folder that contains published content.
"""
manager = IContainerManager(self.root)
with assertTriggersEvents(
'ObjectWillBeRemovedEvent',
'ObjectRemovedEvent',
'ContainerModifiedEvent'):
with manager.deleter() as deleter:
self.assertEqual(
deleter(self.root.folder),
self.root.folder)
self.assertFalse('folder' in self.root.objectIds())
def test_rename_title(self):
"""Rename only the title for a single non-publishable item.
"""
manager = IContainerManager(self.root.folder)
with assertNotTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.renamer() as renamer:
self.assertNotEqual(
renamer((self.root.folder.toc, None, 'New AutoTOC')),
None)
self.assertTrue('toc' in self.root.folder.objectIds())
self.assertTrue(verifyObject(IAutoTOC, self.root.folder.toc))
self.assertEqual(self.root.folder.toc.get_title(), 'New AutoTOC')
def test_invalid(self):
"""Pasting a content as a ghost folder that contains a content
with an invalid identifier.
"""
self.root.source.manage_renameObject('folder', 'index')
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeAddedEvent',
'ObjectAddedEvent',
'ContainerModifiedEvent'):
with manager.ghoster() as ghoster:
error = ghoster(self.root.source)
self.assertTrue(verifyObject(IContentErrorBundle, error))
self.assertEqual(error.content, self.root.target.source)
self.assertEqual(error.reason, u'Error while synchronizing the Ghost Folder: not all its content have been updated properly.')
self.assertEqual(len(error.errors), 1)
def test_rename_id_already_in_use(self):
"""Rename a content to an id which is already in use.
"""
manager = IContainerManager(self.root.folder)
with assertNotTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.renamer() as renamer:
self.assertIsInstance(
renamer((self.root.folder.toc, 'link', None)),
ContainerError)
self.assertTrue('toc' in self.root.folder.objectIds())
self.assertTrue('link' in self.root.folder.objectIds())
self.assertTrue(verifyObject(IAutoTOC, self.root.folder.toc))
self.assertTrue(verifyObject(ILink, self.root.folder.link))
def test_rename_not_published_content_id_and_title(self):
"""Rename id and title for a not published content.
"""
manager = IContainerManager(self.root.folder)
with assertTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.renamer() as renamer:
self.assertNotEqual(
renamer((self.root.folder.link, 'nice_link', 'Nice Link')),
None)
self.assertFalse('link' in self.root.folder.objectIds())
self.assertTrue('nice_link' in self.root.folder.objectIds())
self.assertTrue(verifyObject(ILink, self.root.folder.nice_link))
self.assertEqual(self.root.folder.nice_link.get_editable().get_title(), 'Nice Link')
def test_move_published_container(self):
"""Move a single published container.
Authors doesn't have the right to do it.
"""
manager = IContainerManager(self.root.target)
with assertNotTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertIsInstance(
mover(self.root.source),
ContentError)
self.assertTrue('source' in self.root.objectIds())
self.assertFalse('source' in self.root.target.objectIds())
self.assertTrue(verifyObject(IFolder, self.root.source))
def test_move_published_content(self):
"""Move a single published content.
Editors can do it. The link stays published.
"""
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertNotEqual(
mover(self.root.source.published_link),
None)
self.assertFalse('published_link' in self.root.source.objectIds())
self.assertTrue('published_link' in self.root.target.objectIds())
self.assertTrue(verifyObject(ILink, self.root.target.published_link))
self.assertNotEqual(self.root.target.published_link.get_viewable(), None)
def test_rename_published_container_id_and_title(self):
"""Rename a published container id and title.
An Editor has the right to change both the id and title.
"""
manager = IContainerManager(self.root)
with assertTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.renamer() as renamer:
self.assertNotEqual(
renamer((self.root.folder, 'archives', 'Archives')),
None)
self.assertFalse('folder' in self.root.objectIds())
self.assertTrue('archives' in self.root.objectIds())
self.assertTrue(verifyObject(IFolder, self.root.archives))
self.assertEqual(self.root.archives.get_title(), 'Archives')
def test_copy_content(self):
"""Copy a single content.
"""
manager = IContainerManager(self.root.target)
with assertTriggersEvents(
"ObjectCopiedEvent",
"ObjectWillBeAddedEvent",
"ObjectAddedEvent",
"ContainerModifiedEvent",
"ObjectClonedEvent",
):
with manager.copier() as copier:
self.assertNotEqual(copier(self.root.source.toc), None)
self.assertTrue("toc" in self.root.source.objectIds())
self.assertTrue("toc" in self.root.target.objectIds())
self.assertTrue(verifyObject(IAutoTOC, self.root.target.toc))
self.assertEqual(self.root.target.toc.get_title(), "AutoTOC")
def payload(self):
manager = IContainerManager(self.context)
with manager.copier() as copier:
with self.notifier(
copier,
u"Pasted as a copy ${contents}.",
u"Could not copy ${contents}: ${reason}") as notifier:
notifier.map(self.get_selected_contents('copied'))
with manager.mover() as mover:
with self.notifier(
mover,
u"Moved ${contents}.",
u"Could not move ${contents}: ${reason}") as notifier:
notifier.map(self.get_selected_contents('cutted'))
return {}
def test_rename_published_container_id_and_title(self):
"""Rename a published container it and title.
An author can only change the title.
"""
manager = IContainerManager(self.root)
with assertNotTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.renamer() as renamer:
self.assertNotEqual(
renamer((self.root.folder, 'archives', 'Archives')),
None)
self.assertTrue('folder' in self.root.objectIds())
self.assertFalse('archives' in self.root.objectIds())
self.assertTrue(verifyObject(IFolder, self.root.folder))
# Author got the permission to change the title.
self.assertEqual(self.root.folder.get_title(), 'Archives')
def test_rename_published_content_title(self):
"""Rename only the title on a published content. Nothing
happens (except an error).
"""
link = self.root.folder.published_link
manager = IContainerManager(self.root.folder)
with assertNotTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.renamer() as renamer:
self.assertIsInstance(
renamer((link, None, 'Updated Link')),
ContentError)
self.assertEqual(link, self.root.folder.published_link)
self.assertTrue('published_link' in self.root.folder.objectIds())
self.assertTrue(verifyObject(ILink, link))
self.assertEqual(link.get_title(), 'Published Link')
self.assertEqual(link.get_editable(), None)
def test_move_not_addable_content(self):
"""Move a content that is not addable in the target folder.
This should not be possible (for everybody).
"""
self.root.target.set_silva_addables_allowed_in_container(
['Silva Image', 'Silva File'])
manager = IContainerManager(self.root.target)
with assertNotTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertIsInstance(
mover(self.root.source.toc),
ContainerError)
self.assertTrue('toc' in self.root.source.objectIds())
self.assertEqual(self.root.target.objectIds(), [])
self.assertTrue(verifyObject(IAutoTOC, self.root.source.toc))
def test_rename_published_content_id_and_title(self):
"""Rename a published content id and title.
An author can't do anything, nothing is done.
"""
link = self.root.folder.published_link
manager = IContainerManager(self.root.folder)
with assertNotTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.renamer() as renamer:
self.assertIsInstance(
renamer((link, 'updated_link', 'Updated Link')),
ContentError)
self.assertEqual(link, self.root.folder.published_link)
self.assertTrue('published_link' in self.root.folder.objectIds())
self.assertFalse('updated_link' in self.root.folder.objectIds())
self.assertTrue(verifyObject(ILink, link))
self.assertEqual(link.get_title(), 'Published Link')
def test_copy_published_content(self):
"""Copy a content that is published. It is copied, but the
copy will be closed.
"""
manager = IContainerManager(self.root.target)
with assertTriggersEvents(
"ObjectCopiedEvent",
"ObjectWillBeAddedEvent",
"ObjectAddedEvent",
"ContainerModifiedEvent",
"ObjectClonedEvent",
):
with manager.copier() as copier:
self.assertNotEqual(copier(self.root.source.published_link), None)
self.assertTrue("published_link" in self.root.source.objectIds())
self.assertTrue("published_link" in self.root.target.objectIds())
self.assertTrue(verifyObject(ILink, self.root.target.published_link))
self.assertEqual(self.root.target.published_link.get_viewable(), None)
self.assertNotEqual(self.root.source.published_link.get_viewable(), None)
def test_delete_invalid(self):
manager = IContainerManager(self.root.folder)
with assertNotTriggersEvents(
'ObjectWillBeRemovedEvent',
'ObjectRemovedEvent',
'ContainerModifiedEvent'):
with manager.deleter() as deleter:
self.assertIsInstance(
deleter(self.root.publication),
ContentError)
self.assertIsInstance(
deleter(self.root.toc),
ContentError)
self.assertIsInstance(
deleter(self.root.folder),
ContentError)
self.assertTrue('publication' in self.root.objectIds())
self.assertTrue('toc' in self.root.objectIds())
self.assertTrue('folder' in self.root.objectIds())
def test_rename_new_version_content_title(self):
"""Rename only the title on a new version of a published content.
(The title is an utf-8 string, not unicode, to test encodings.)
"""
link = self.root.folder.published_link
manager = IContainerManager(self.root.folder)
IPublicationWorkflow(link).new_version()
with assertNotTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.renamer() as renamer:
self.assertEqual(
renamer((link, None, 'Updaté Link')),
link)
self.assertEqual(link, self.root.folder.published_link)
self.assertTrue('published_link' in self.root.folder.objectIds())
self.assertTrue(verifyObject(ILink, link))
self.assertEqual(link.get_title(), 'Published Link')
self.assertEqual(link.get_editable().get_title(), u'Updaté Link')
def test_content(self):
"""When pasting a content as a regular ghost, it doesn't get
published.
"""
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeAddedEvent',
'ObjectAddedEvent',
'ContainerModifiedEvent'):
with manager.ghoster() as ghoster:
ghost = ghoster(self.root.source.data)
self.assertTrue(verifyObject(IGhost, ghost))
self.assertIn('data', self.root.target.objectIds())
self.assertEqual(ghost.get_haunted(), self.root.source.data)
self.assertEqual(ghost.is_published(), False)
self.assertEqual(ghost.get_viewable(), None)
version = ghost.get_editable()
self.assertTrue(verifyObject(IGhostVersion, version))
self.assertEqual(version.get_link_status(), None)
self.assertEqual(version.get_haunted(), self.root.source.data)
def test_move_content_id_already_in_use(self):
"""Move a content with an id that is already in use in the
target folder.
"""
factory = self.root.target.manage_addProduct['Silva']
factory.manage_addLink('toc', 'Link to AutoTOC')
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeMovedEvent', 'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertNotEqual(mover(self.root.source.toc), None)
self.assertFalse('toc' in self.root.source.objectIds())
self.assertTrue('toc' in self.root.target.objectIds())
self.assertTrue('move_of_toc' in self.root.target.objectIds())
self.assertTrue(verifyObject(ILink, self.root.target.toc))
self.assertTrue(verifyObject(IAutoTOC, self.root.target.move_of_toc))
# Now if we move it back, the move_of_ will be stripped
manager = IContainerManager(self.root.source)
with assertTriggersEvents('ObjectWillBeMovedEvent', 'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertNotEqual(mover(self.root.target.move_of_toc), None)
self.assertTrue('toc' in self.root.source.objectIds())
self.assertFalse('move_of_toc' in self.root.target.objectIds())
self.assertTrue(verifyObject(IAutoTOC, self.root.source.toc))
def test_rename_multiple(self):
"""Rename multipe content in one time.
"""
manager = IContainerManager(self.root.folder)
with assertTriggersEvents('ObjectWillBeMovedEvent', 'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.renamer() as renamer:
self.assertNotEqual(
renamer((self.root.folder.toc, 'newtoc', None)), None)
self.assertNotEqual(
renamer((self.root.folder.link, 'nice_link', 'Nice Link')),
None)
self.assertFalse('toc' in self.root.folder.objectIds())
self.assertTrue('newtoc' in self.root.folder.objectIds())
self.assertTrue(verifyObject(IAutoTOC, self.root.folder.newtoc))
self.assertEqual(self.root.folder.newtoc.get_title(), 'AutoTOC')
self.assertFalse('link' in self.root.folder.objectIds())
self.assertTrue('nice_link' in self.root.folder.objectIds())
self.assertTrue(verifyObject(ILink, self.root.folder.nice_link))
self.assertEqual(self.root.folder.nice_link.get_editable().get_title(),
'Nice Link')
def test_move_published_container(self):
"""Move a single published container.
Authors doesn't have the right to do it.
"""
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectWillBeMovedEvent',
'ObjectMovedEvent',
'ContainerModifiedEvent'):
with manager.mover() as mover:
self.assertNotEqual(
mover(self.root.source),
None)
self.assertFalse('source' in self.root.objectIds())
self.assertTrue('source' in self.root.target.objectIds())
self.assertTrue(verifyObject(IFolder, self.root.target.source))
# Inner content is still there and published.
self.assertItemsEqual(
self.root.target.source.objectIds(),
['toc', 'link', 'published_link', 'folder'])
self.assertNotEqual(self.root.target.source.published_link.get_viewable(), None)
def test_copy(self):
"""Copy a published document. The copy should be catalogued
and not published.
"""
IPublicationWorkflow(self.root.document).publish()
with IContainerManager(self.root).copier() as copier:
copier(self.root.document)
self.assertItemsEqual(self.search('/root'),
[('/root', 'public'),
('/root/document', 'public'),
('/root/document/0', 'public'),
('/root/copy_of_document', 'unapproved')])
def test_moving(self):
"""Test moving published elements into a folder.
"""
IPublicationWorkflow(self.root.document).publish()
factory = self.root.manage_addProduct['Silva']
factory.manage_addFolder('folder', 'Folder')
with IContainerManager(self.root.folder).mover() as mover:
mover(self.root.document)
self.assertItemsEqual(self.search('/root'),
[('/root', 'public'), ('/root/folder', 'public'),
('/root/folder/document', 'public'),
('/root/folder/document/0', 'public')])
def test_ghost(self):
"""Test simple ghost creation and life time.
"""
factory = self.root.manage_addProduct['Silva']
factory.manage_addGhost('ghost', None, haunted=self.root.document)
version = self.root.ghost.get_editable()
self.assertTrue(verifyObject(IGhost, self.root.ghost))
self.assertTrue(verifyObject(IGhostVersion, version))
self.assertEqual(version.get_link_status(), None)
self.assertEqual(version.get_haunted(), self.root.document)
self.assertEqual(aq_chain(version.get_haunted()),
aq_chain(self.root.document))
manager = IContainerManager(self.root)
with manager.deleter() as deleter:
deleter(self.root.document)
self.assertEqual(version.get_haunted(), None)
self.assertEqual(version.get_link_status(),
errors.EmptyInvalidTarget())
def test_set_title(self):
"""Test ghost set_title. It should just trigger an error.
"""
factory = self.root.manage_addProduct['Silva']
factory.manage_addGhost('ghost', None, target=self.root.document)
# None is authorized as a title, because that is the value
# that it must passed to the factory.
self.root.ghost.set_title(None)
# Other value should raise an error
with self.assertRaises(ContentError):
self.root.ghost.set_title('Ghost')
# You sould be able to rename a ghost with the IContainerManager
with IContainerManager(self.root).renamer() as renamer:
self.assertEqual(renamer((self.root.ghost, 'ghost', None)),
self.root.ghost)
# But not to change its title.
with IContainerManager(self.root).renamer() as renamer:
self.assertIsInstance(renamer((self.root.ghost, 'ghost', 'Ghost')),
ContentError)
def test_copy_published_container(self):
"""Copy a container that contains published content. All
content will be copied, and published content will be closed.
"""
manager = IContainerManager(self.root.target)
with assertTriggersEvents('ObjectCopiedEvent',
'ObjectWillBeAddedEvent',
'ObjectAddedEvent',
'ContainerModifiedEvent',
'ObjectClonedEvent'):
with manager.copier() as copier:
self.assertNotEqual(copier(self.root.source), None)
self.assertTrue('source' in self.root.target.objectIds())
self.assertItemsEqual(
self.root.target.source.objectIds(),
['folder', 'link', 'published_link', 'toc'])
self.assertTrue(verifyObject(IFolder, self.root.target.source))
self.assertTrue(verifyObject(IAutoTOC, self.root.target.source.toc))
self.assertTrue(verifyObject(ILink, self.root.target.source.link))
self.assertTrue(verifyObject(ILink, self.root.target.source.published_link))
self.assertEqual(self.root.target.source.link.get_viewable(), None)
self.assertEqual(self.root.target.source.published_link.get_viewable(), None)
def test_reference(self):
"""Test the reference created by the ghost.
"""
factory = self.root.manage_addProduct['Silva']
factory.manage_addGhost('ghost', None, haunted=self.root.document)
ghost = self.root.ghost.get_editable()
reference = getUtility(IReferenceService).get_reference(
ghost, name="haunted")
self.assertTrue(verifyObject(IReferenceValue, reference))
self.assertEqual(
aq_chain(reference.target),
aq_chain(self.root.document))
self.assertEqual(
aq_chain(reference.source),
aq_chain(ghost))
manager = IContainerManager(self.root)
with manager.deleter() as deleter:
deleter(self.root.document)
reference = getUtility(IReferenceService).get_reference(
ghost, name="haunted")
self.assertEqual(reference, None)
def test_remove_add_publish_transaction(self):
"""Test removing a content, adding a new one with the same,
publishing it and remove it again.
"""
with CatalogTransaction():
with IContainerManager(self.root).deleter() as deleter:
deleter(self.root.document)
factory = self.root.manage_addProduct['Silva']
factory.manage_addMockupVersionedContent('document', 'Document')
IPublicationWorkflow(self.root.document).publish()
self.assertItemsEqual(self.search('/root'),
[('/root', 'public'),
('/root/document', 'public'),
('/root/document/0', 'public')])
def test_zip_import(self):
"""Test the import of Zip file with quota system activated.
"""
factory = self.root.manage_addProduct['Silva']
factory.manage_addFolder('folder', 'Folder')
self.assertEqual(self.root.used_space, 0)
self.assertEqual(self.root.folder.used_space, 0)
with self.layer.open_fixture('test1.zip') as source:
IArchiveFileImporter(self.root.folder).importArchive(source)
self.assertEqual(self.root.folder.used_space, 10950)
self.assertEqual(self.root.used_space, 10950)
with IContainerManager(self.root).deleter() as deleter:
deleter(self.root.folder)
self.assertEqual(self.root.used_space, 0)
def test_xml_import(self):
"""Test the import of a XML file with quota system activited.
"""
factory = self.root.manage_addProduct['Silva']
factory.manage_addFolder('folder', 'Folder')
self.assertEqual(self.root.used_space, 0)
self.assertEqual(self.root.folder.used_space, 0)
with self.layer.open_fixture('test_import_file.zip') as source:
importer = ZipImporter(self.root.folder, TestRequest())
importer.importStream(source)
self.assertEqual(self.root.folder.used_space, 35512)
self.assertEqual(self.root.used_space, 35512)
with IContainerManager(self.root).deleter() as deleter:
deleter(self.root.folder)
self.assertEqual(self.root.used_space, 0)
def test_add_published_rename_transaction(self):
"""Test adding a new content, publishing it and moving it.
"""
with CatalogTransaction():
factory = self.root.manage_addProduct['Silva']
factory.manage_addMockupVersionedContent('info', 'Content')
IPublicationWorkflow(self.root.info).publish()
with IContainerManager(self.root).renamer() as renamer:
self.assertNotEqual(
renamer((self.root.info, 'renamed', 'Renamed content')),
None)
self.assertItemsEqual(self.search('/root'),
[('/root', 'public'),
('/root/renamed', 'public'),
('/root/renamed/0', 'public'),
('/root/document', 'unapproved'),
('/root/document/0', 'unapproved')])
def test_copy_information(self):
"""Test that the information on a copy is properly
filled. Although the document have been created by editor, the
copy have been created by author.
"""
with Transaction():
self.layer.login('author')
with IContainerManager(self.root).copier() as copier:
copy = copier(self.root.document)
self.assertTrue(verifyObject(IVersionedContent, copy))
creator = copy.get_creator_info()
self.assertTrue(verifyObject(IMember, creator))
self.assertEqual(creator.userid(), 'author')
author = copy.get_last_author_info()
self.assertTrue(verifyObject(IMember, author))
self.assertEqual(author.userid(), 'author')
self.assertNotEqual(copy.get_creation_datetime(), None)
self.assertNotEqual(copy.get_modification_datetime(), None)
def test_copy_paste_over_quota(self):
""" Test an exception is raised when a copy is made.
"""
factory = self.root.manage_addProduct['Silva']
factory.manage_addFolder('folder', 'Folder')
self.assertEqual(self.root.folder.used_space, 0)
factory = self.root.folder.manage_addProduct['Silva']
with self.layer.open_fixture('test3.zip') as source:
factory.manage_addFile('zipfile1.zip', 'Zip File', source)
source.seek(0)
factory.manage_addFile('zipfile2.zip', 'Zip File', source)
factory = self.root.manage_addProduct['Silva']
factory.manage_addPublication('pub', 'Publication')
set_quota(self.root.pub, 1) # 1M
with self.assertRaises(OverQuotaException):
with IContainerManager(self.root.pub).copier() as copier:
copier(self.root.folder)
def test_ghost_haunt_remove_assets(self):
"""Test modifications: removing asssets in the target doesn't
remove them automatically in the ghost folder, but this is
done when the ghost folder is haunted.
"""
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addMockupAsset('data', 'Data set 1')
factory.manage_addMockupAsset('export', 'Export set 1')
factory = self.root.target.manage_addProduct['Silva']
factory.manage_addGhostFolder('ghost', None, haunted=self.root.folder)
ghost = self.root.target.ghost
self.assertIn('data', ghost.objectIds())
self.assertTrue(verifyObject(IGhostAsset, ghost.data))
self.assertEqual(
ghost.data.get_haunted(),
self.root.folder.data)
self.assertEqual(
aq_chain(ghost.data.get_haunted()),
aq_chain(self.root.folder.data))
self.assertIn('export', ghost.objectIds())
self.assertTrue(verifyObject(IGhostAsset, ghost.export))
self.assertEqual(
ghost.export.get_haunted(),
self.root.folder.export)
self.assertEqual(
aq_chain(ghost.export.get_haunted()),
aq_chain(self.root.folder.export))
with IContainerManager(self.root.folder).deleter() as deleter:
deleter(self.root.folder.data)
deleter(self.root.folder.export)
# Ghost should have been auto-deleted
self.assertNotIn('data', ghost.objectIds())
self.assertNotIn('export', ghost.objectIds())
# And they won't come back
self.assertTrue(ghost.haunt())
self.assertNotIn('data', ghost.objectIds())
self.assertNotIn('export', ghost.objectIds())
def test_ghost_haunt_remove_ghosted_content_for_ghosts(self):
"""Test modification: remove a target of a ghost that is
ghosted by the ghost folder. The ghost (in the ghost folder)
should be removed.
"""
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addGhost('notes',
None,
haunted=self.root.folder.document)
IPublicationWorkflow(self.root.folder.notes).publish()
factory = self.root.target.manage_addProduct['Silva']
factory.manage_addGhostFolder('ghost', None, haunted=self.root.folder)
ghost = self.root.target.ghost
self.assertTrue('notes' in ghost.objectIds())
self.assertTrue(verifyObject(IGhost, ghost.notes))
version = ghost.notes.get_editable()
self.assertIs(version, None)
version = ghost.notes.get_viewable()
self.assertIsNot(version, None)
self.assertEqual(version.get_haunted(), self.root.folder.document)
with IContainerManager(self.root.folder).deleter() as deleter:
deleter(self.root.folder.notes)
# The ghosted ghost is remove, and the ghost is not touched
# (the document is still there).
self.assertFalse('notes' in self.root.folder.objectIds())
self.assertTrue('notes' in ghost.objectIds())
self.assertTrue(verifyObject(IGhost, ghost.notes))
version = ghost.notes.get_editable()
self.assertIs(version, None)
version = ghost.notes.get_viewable()
self.assertIsNot(version, None)
self.assertEqual(version.get_haunted(), self.root.folder.document)
# Haunting should remove the ghost since it does no longer exists
self.assertTrue(ghost.haunt())
self.assertNotIn('notes', self.root.folder.objectIds())
self.assertNotIn('notes', ghost.objectIds())
def test_remove_nonorderable(self):
"""If we remove an nonorderable content nothing is changed.
"""
source = self.root.source
manager = IOrderManager(source)
self.assertEqual(manager.get_position(source.item1), 0)
self.assertEqual(manager.get_position(source.item2), 1)
self.assertEqual(manager.get_position(source.item3), 2)
self.assertEqual(manager.get_position(source.asset1), -1)
self.assertEqual(len(manager), 3)
with assertNotTriggersEvents('ContentOrderChangedEvent'):
with IContainerManager(source).deleter() as deleter:
self.assertEqual(deleter(source.asset1), source.asset1)
self.assertEqual(manager.get_position(source.item1), 0)
self.assertEqual(manager.get_position(source.item2), 1)
self.assertEqual(manager.get_position(source.item3), 2)
self.assertEqual(len(manager), 3)
asset1 = source._getOb('asset1', None)
self.assertEqual(asset1, None)
def test_rename_orderable(self):
"""If you rename a content, its order must be keept (and not
changed).
"""
source = self.root.source
manager = IOrderManager(source)
self.assertEqual(manager.get_position(source.item1), 0)
self.assertEqual(manager.get_position(source.item2), 1)
self.assertEqual(manager.get_position(source.item3), 2)
self.assertEqual(manager.get_position(source.asset1), -1)
self.assertEqual(len(manager), 3)
with assertNotTriggersEvents('ContentOrderChangedEvent'):
with IContainerManager(source).renamer() as renamer:
renamer((source.item2, 'super2', None))
self.assertEqual(manager.get_position(source.item1), 0)
self.assertEqual(manager.get_position(source.super2), 1)
self.assertEqual(manager.get_position(source.item3), 2)
self.assertEqual(manager.get_position(source.asset1), -1)
self.assertEqual(len(manager), 3)
# The order is valid, repair return False.
self.assertEqual(manager.repair(source.objectValues()), False)
def test_folder_action(self):
"""Test that folder action update used space.
Content structure:
root
|-- folder1
| `-- subfolder1
| `-- zipfile1.zip
`-- folder2
`-- image1.jpg
"""
# XXX this big hugre
factory = self.root.manage_addProduct['Silva']
factory.manage_addFolder('folder1', 'FooFolder 1')
factory.manage_addFolder('folder2', 'FooFolder 2')
folder1 = self.root._getOb('folder1')
folder2 = self.root._getOb('folder2')
factory = folder1.manage_addProduct['Silva']
factory.manage_addFolder('subfolder1', 'Sub FooFolder')
subfolder1 = folder1._getOb('subfolder1')
# By default, all used_space should be at 0
self.assertEqual(self.root.used_space, 0)
self.assertEqual(folder1.used_space, 0)
self.assertEqual(subfolder1.used_space, 0)
# Add a file
factory = subfolder1.manage_addProduct['Silva']
with self.layer.open_fixture('test2.zip') as source:
factory.manage_addFile('file.zip', 'Zip File', source)
zipfile_size = source.tell()
zipfile = subfolder1._getOb('file.zip')
self.assertTrue(verifyObject(IAsset, zipfile))
self.assertEqual(zipfile.get_file_size(), zipfile_size)
# And check used space
self.assertEqual(subfolder1.used_space, zipfile_size)
self.assertEqual(self.root.used_space, zipfile_size)
# Change file data
with self.layer.open_fixture('test1.zip') as source:
zipfile.set_file(source)
zipfile_size = source.tell()
self.assertEqual(zipfile.get_file_size(), zipfile_size)
# And check used space
self.assertEqual(subfolder1.used_space, zipfile_size)
self.assertEqual(self.root.used_space, zipfile_size)
self.assertEqual(folder2.used_space, 0)
# Add an image
factory = folder2.manage_addProduct['Silva']
with self.layer.open_fixture('torvald.jpg') as source:
factory.manage_addImage('image1.jpg', 'Image File', source)
image_size = source.tell()
# Verify added image
image = folder2._getOb('image1.jpg')
self.assertTrue(verifyObject(IAsset, image))
self.assertEqual(image.get_file_size(), image_size)
# And check used space
self.assertEqual(self.root.used_space, zipfile_size + image_size)
self.assertEqual(folder2.used_space, image_size)
# Change image and check size
with self.layer.open_fixture('testimage.gif') as source:
image.set_image(source)
image_size = source.tell()
# And check used space
self.assertEqual(image.get_file_size(), image_size)
self.assertEqual(subfolder1.used_space, zipfile_size)
self.assertEqual(self.root.used_space, zipfile_size + image_size)
self.assertEqual(folder2.used_space, image_size)
# Try cut and paste
manager2 = IContainerManager(folder2)
with manager2.mover() as mover:
mover(folder1['subfolder1'])
# And check used space
self.assertEqual(folder1.used_space, 0)
self.assertEqual(self.root.used_space, zipfile_size + image_size)
self.assertEqual(folder2.used_space, zipfile_size + image_size)
# Try cut and ghost paste
manager1 = IContainerManager(folder1)
with manager1.ghoster() as ghoster:
ghoster(folder2['subfolder1'])
# And check used space. Ghost Assets don't use any quota.
self.assertEqual(folder1.used_space, 0)
self.assertEqual(self.root.used_space, zipfile_size + image_size)
self.assertEqual(folder2.used_space, zipfile_size + image_size)
# Delete the ghost
with manager1.deleter() as deleter:
deleter(folder1['subfolder1'])
# And check used space
self.assertEqual(folder1.used_space, 0)
self.assertEqual(self.root.used_space, zipfile_size + image_size)
self.assertEqual(folder2.used_space, zipfile_size + image_size)
# Try copy and paste
with manager1.copier() as copier:
copier(folder2['image1.jpg'])
# And check used space
self.assertEqual(folder1.used_space, image_size)
self.assertEqual(self.root.used_space, zipfile_size + (2 * image_size))
self.assertEqual(folder2.used_space, zipfile_size + image_size)
# Clean, and check each time
manager = IContainerManager(self.root)
with manager.deleter() as deleter:
deleter(self.root['folder2'])
self.assertEqual(self.root.used_space, image_size)
with manager.deleter() as deleter:
deleter(self.root['folder1'])
self.assertEqual(self.root.used_space, 0)
def test_remove_indexer(self):
"""Verify that can remove everything without errors.
"""
with IContainerManager(self.root).deleter() as deleter:
deleter(self.root.folder)
self.assertFalse('folder' in self.root.objectIds())
