def test_render_protected_content(self):
"""Test rendering a protected content.
"""
with Transaction():
factory = self.root.manage_addProduct['Silva']
factory.manage_addLink(
'link', 'Infrae', relative=False, url='http://infrae.com')
factory.manage_addGhost('ghost', None, haunted=self.root.link)
IAccessSecurity(self.root.link).minimum_role = 'Viewer'
IPublicationWorkflow(self.root.link).publish()
IPublicationWorkflow(self.root.ghost).publish()
with self.layer.get_browser(public_settings) as browser:
browser.options.follow_redirect = False
self.assertEqual(
browser.open('/root/ghost'),
401)
self.assertEqual(
browser.inspect.title,
['Protected area'])
browser.login('viewer')
self.assertEqual(
browser.open('/root/ghost'),
302)
self.assertEqual(
browser.headers['Location'],
'http://infrae.com')
def test_modification_time(self):
"""Test that the ghost modification_time is the same than the
document.
"""
with Transaction():
factory = self.root.manage_addProduct['Silva']
factory.manage_addGhost('ghost', None)
ghost = self.root.ghost
target = self.root.document
self.assertEqual(ghost.get_modification_datetime(), None)
with Transaction():
ghost.get_editable().set_haunted(target)
self.assertEqual(ghost.get_modification_datetime(), None)
with Transaction():
IPublicationWorkflow(ghost).publish()
self.assertEqual(ghost.get_modification_datetime(),
target.get_modification_datetime())
with Transaction():
IPublicationWorkflow(ghost).new_version()
ghost.get_editable().set_haunted(0)
self.assertEqual( # We still see publlised version
ghost.get_modification_datetime(),
target.get_modification_datetime())
with Transaction():
IPublicationWorkflow(ghost).publish()
self.assertEqual(ghost.get_modification_datetime(), None)
def test_new_version_pusblish_with_expiration_datetime_in_future(self):
"""If you make a new version of a published version that have
an expiration date in the future it is kept.
"""
content = self.root.test
expiration_time = DateTime() + 30
content.set_unapproved_version_expiration_datetime(expiration_time)
publisher = IPublicationWorkflow(content)
publisher.publish()
self.assertTrue(content.is_published())
self.assertEqual(content.get_public_version(), '0')
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), None)
self.assertEqual(content.get_last_closed_version(), None)
publisher.new_version()
self.assertTrue(content.is_published())
self.assertEqual(content.get_public_version(), '0')
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), '1')
self.assertEqual(content.get_last_closed_version(), None)
self.assertEqual(
content.get_unapproved_version_expiration_datetime(),
expiration_time)
self.assertEqual(
content.get_unapproved_version_publication_datetime(),
None)
def test_new_version_published(self):
"""Create a new version while there is a published version.
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
publisher.publish()
self.assertTrue(content.is_published())
self.assertEqual(content.get_public_version(), '0')
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), None)
self.assertEqual(content.get_last_closed_version(), None)
publisher.new_version()
self.assertTrue(content.is_published())
self.assertEqual(content.get_public_version(), '0')
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), '1')
self.assertEqual(content.get_last_closed_version(), None)
self.assertEqual(
content.get_unapproved_version_expiration_datetime(),
None)
self.assertEqual(
content.get_unapproved_version_publication_datetime(),
None)
def test_new_version_closed_with_expiration_datetime_in_past(self):
"""If you make a new version out of a published version that
have an expiration date in the past, it is not kept.
"""
content = self.root.test
expiration_time = DateTime() - 30
content.set_unapproved_version_expiration_datetime(expiration_time)
publisher = IPublicationWorkflow(content)
publisher.publish()
self.assertFalse(content.is_published())
# The version is directly closed, because it is expired.
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), None)
self.assertEqual(content.get_last_closed_version(), '0')
publisher.new_version()
self.assertFalse(content.is_published())
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), '1')
self.assertEqual(content.get_last_closed_version(), '0')
self.assertEqual(
content.get_unapproved_version_expiration_datetime(),
None)
self.assertEqual(
content.get_unapproved_version_publication_datetime(),
None)
def test_closed(self):
"""Test viewing a closed link. You should get a message that
it isn't viewable.
"""
factory = self.root.manage_addProduct['Silva']
factory.manage_addMockupVersionedContent('test', 'Test Content')
factory.manage_addFolder('folder', 'Folder')
factory.manage_addLink('infrae',
'Infrae',
relative=True,
target=self.root.test)
IPublicationWorkflow(self.root.infrae).publish()
IPublicationWorkflow(self.root.infrae).close()
with self.layer.get_browser(public_settings) as browser:
browser.options.follow_redirect = False
self.assertEqual(browser.open('/root/infrae'), 200)
self.assertEqual(browser.inspect.content,
['Sorry, this Silva Link is not viewable.'])
browser.login('editor')
self.assertEqual(browser.open('/root/++preview++/infrae'), 200)
self.assertEqual(browser.inspect.title, ['Infrae'])
self.assertIn(
'This link redirects to http://localhost/root/++preview++/test.',
browser.inspect.content[0])
def test_render_closed_content(self):
"""Test rendering a ghost that points to a content that is
closed.
"""
with Transaction():
factory = self.root.manage_addProduct['Silva']
factory.manage_addLink('link',
'Infrae',
relative=False,
url='http://infrae.com')
factory.manage_addGhost('ghost', None, haunted=self.root.link)
IPublicationWorkflow(self.root.link).publish()
IPublicationWorkflow(self.root.ghost).publish()
with self.layer.get_browser(public_settings) as browser:
browser.options.follow_redirect = False
self.assertEqual(browser.open('/root/ghost'), 302)
self.assertEqual(browser.headers['Location'], 'http://infrae.com')
with Transaction():
IPublicationWorkflow(self.root.link).close()
with self.layer.get_browser(public_settings) as browser:
browser.options.follow_redirect = False
self.assertEqual(browser.open('/root/ghost'), 200)
self.assertEqual(browser.inspect.content, [
"This content is unavailable. Please inform the site manager."
])
def test_new_approved(self):
IPublicationWorkflow(self.root.document).publish()
IPublicationWorkflow(self.root.document).new_version()
IPublicationWorkflow(self.root.document).approve(DateTime() + 60)
self.assertItemsEqual(self.search('/root'),
[('/root', 'unapproved'),
('/root/document', 'public'),
('/root/document/0', 'public'),
('/root/document/1', 'approved')])
def test_closed(self):
"""If you close a document, its version is no longer
catalogued, and the document appears as unapproved.
"""
IPublicationWorkflow(self.root.document).publish()
IPublicationWorkflow(self.root.document).close()
self.assertItemsEqual(self.search('/root'),
[('/root', 'unapproved'),
('/root/document', 'unapproved')])
def test_new(self):
"""If you create a new version of a published document, it
appears in the catalog.
"""
IPublicationWorkflow(self.root.document).publish()
IPublicationWorkflow(self.root.document).new_version()
self.assertItemsEqual(self.search('/root/document'),
[('/root/document', 'public'),
('/root/document/0', 'public'),
('/root/document/1', 'unapproved')])
def test_request_approval_published_version(self):
""" request approval on already publish version must fail with
exception.
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
publisher.publish()
with self.assertRaises(VersioningError):
publisher.request_approval("please approve.")
self.assertFalse(content.is_approval_requested())
def test_new_published(self):
"""If we published, make a new version and publish again the
document, it should be published.
"""
IPublicationWorkflow(self.root.document).publish()
IPublicationWorkflow(self.root.document).new_version()
IPublicationWorkflow(self.root.document).publish()
self.assertItemsEqual(self.search('/root/document'),
[('/root/document', 'public'),
('/root/document/1', 'public')])
def test_get_public_tree_all(self):
self.assertEqual(
ITreeContents(self.root).get_public_tree_all(),
[(0, self.root.folder), (1, self.root.folder.folder),
(0, self.root.publication)])
IPublicationWorkflow(self.root.document).publish()
IPublicationWorkflow(self.root.publication.document).publish()
self.assertEqual(
ITreeContents(self.root).get_public_tree_all(),
[(0, self.root.document), (0, self.root.folder),
(1, self.root.folder.folder), (0, self.root.publication),
(1, self.root.publication.document)])
def test_request_approval(self):
""" request approval on unapproved version (normal scenario)
"""
content = self.root.test
message = 'please approve.'
publisher = IPublicationWorkflow(content)
publisher.request_approval(message)
self.assertTrue(content.is_approval_requested())
with self.assertRaises(VersioningError):
publisher.request_approval("please approve.")
def setUp(self):
self.root = self.layer.get_application()
self.layer.login('editor')
factory = self.root.manage_addProduct['Silva']
factory.manage_addMockupVersionedContent('test', 'Test Content')
publisher = IPublicationWorkflow(self.root.test)
for version_id in range(1, 5):
publisher.publish()
publisher.new_version()
self.layer.login('author')
def update(self):
assert self.manager.ghost is not None
if IGhost.providedBy(self.manager.ghost):
publication = IPublicationWorkflow(self.manager.ghost)
if self.manager.ghost.get_editable() is None:
publication.new_version()
version = self.manager.ghost.get_editable()
version.set_haunted(
self.target, auto_delete=self.manager.auto_delete)
if self.manager.auto_publish:
publication.publish()
else:
self.recreate()
return self.manager.ghost
def test_is_published(self):
"""A folder is published if there is a published index.
"""
self.assertFalse(self.root.folder.is_published())
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addLink('index', 'Link')
self.assertFalse(self.root.folder.is_published())
# Publish the default to publish the folder
IPublicationWorkflow(self.root.folder.get_default()).publish()
self.assertTrue(self.root.folder.is_published())
# Close the default close the folder.
IPublicationWorkflow(self.root.folder.get_default()).close()
self.assertFalse(self.root.folder.is_published())
def test_view(self):
"""Test public view.
"""
factory = self.root.manage_addProduct['SilvaPoll']
factory.manage_addPollQuestion('poll', 'Poll Status')
version = self.root.poll.get_editable()
version.set_title('New Poll')
version.set_question('Does it poll ?')
version.set_answers(['Yeah baby', 'Well, not really'])
IPublicationWorkflow(self.root.poll).publish()
with self.layer.get_browser(poll_settings) as browser:
self.assertEqual(browser.open('/root/poll'), 200)
self.assertEqual(browser.inspect.title, ['New Poll'])
self.assertEqual(browser.inspect.vote_question, ['Does it poll ?'])
self.assertEqual(len(browser.inspect.forms), 1)
form = browser.inspect.forms[0]
self.assertIn('answer', form.controls)
self.assertIn('submit', form.controls)
self.assertEqual(form.controls['answer'].options,
['Yeah baby', 'Well, not really'])
form.controls['answer'].value = 'Yeah baby'
self.assertEqual(form.controls['submit'].click(), 200)
self.assertEqual(browser.inspect.title, ['New Poll'])
self.assertEqual(browser.inspect.results_question,
['Does it poll ?'])
self.assertEqual(len(browser.inspect.forms), 0)
def test_head_request(self):
"""Test HEAD requests on Ghosts.
"""
with Transaction():
factory = self.root.manage_addProduct['Silva']
factory.manage_addGhost('ghost', None, haunted=self.root.document)
with self.layer.get_browser() as browser:
self.assertEqual(browser.open('/root/ghost', method='HEAD'), 200)
self.assertEqual(browser.headers['Content-Type'],
'text/html;charset=utf-8')
# The ghost is broken, there is no modification date.
self.assertNotIn('Last-Modified', browser.headers)
with Transaction():
IPublicationWorkflow(self.root.ghost).publish()
with self.layer.get_browser() as browser:
self.assertEqual(browser.open('/root/ghost', method='HEAD'), 200)
self.assertEqual(browser.headers['Content-Type'],
'text/html;charset=utf-8')
# We see the modification date from the document.
self.assertEqual(browser.headers['Last-Modified'],
'Mon, 25 Apr 2011 12:00:00 GMT')
self.assertEqual(len(browser.contents), 0)
def test_ghost_haunt_add_ghosts_for_ghosts(self):
"""Test modification: adding ghost to the target will create
new ghosts in the ghost golder when it is haunted.
"""
factory = self.root.target.manage_addProduct['Silva']
factory.manage_addGhostFolder('ghost', None, haunted=self.root.folder)
ghost = self.root.target.ghost
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addGhost('notes',
None,
haunted=self.root.folder.document)
IPublicationWorkflow(self.root.folder.notes).publish()
self.assertFalse('notes' in ghost.objectIds())
self.assertTrue(ghost.haunt())
self.assertIn('notes', 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)
self.assertEqual(version.get_link_status(), None)
self.assertEqual(aq_chain(version.get_haunted()),
aq_chain(self.root.folder.document))
def test_link_closed_only_previewable(self):
"""Export only the previewable version of a link that have
multiple versions available, but none published.
"""
with Transaction():
link = self.root.folder.new.link
IPublicationWorkflow(link).publish()
IPublicationWorkflow(link).close()
exporter = self.assertExportEqual(self.root.folder,
'test_export_link_closed_2.silvaxml',
options={'only_previewable': True})
self.assertEqual(exporter.getZexpPaths(), [])
self.assertEqual(exporter.getAssetPaths(),
[(('', 'root', 'folder', 'file'), '1')])
self.assertEqual(exporter.getProblems(), [])
def test_ghost_haunt_remove_ghosts_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.document)
self.assertTrue('notes' in self.root.folder.objectIds())
self.assertEqual(self.root.folder.notes.get_haunted(), None)
self.assertFalse('notes' in ghost.objectIds())
# Nothing should change if the folder is ghosted (broken
# ghosts should not be created).
self.assertTrue(ghost.haunt())
self.assertIn('notes', self.root.folder.objectIds())
self.assertEqual(self.root.folder.notes.get_haunted(), None)
self.assertNotIn('notes', ghost.objectIds())
def test_public_view(self):
"""Render a folder publicly.
"""
with self.layer.get_browser(public_settings) as browser:
self.assertEqual(
browser.open('http://localhost/root/folder'),
200)
self.assertEqual(
browser.inspect.content,
['This container has no index.'])
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addMockupVersionedContent('index', 'Index')
with self.layer.get_browser(public_settings) as browser:
self.assertEqual(
browser.open('http://localhost/root/folder'),
200)
self.assertEqual(
browser.inspect.content,
['This container has no index.'])
IPublicationWorkflow(self.root.folder.index).publish()
with self.layer.get_browser(public_settings) as browser:
self.assertEqual(
browser.open('http://localhost/root/folder'),
200)
self.assertEqual(
browser.inspect.content,
['Index'])
def test_approved(self):
"""If you approve a document it is recatalogued.
"""
IPublicationWorkflow(self.root.document).approve(DateTime() + 60)
self.assertItemsEqual(self.search('/root/document'),
[('/root/document', 'approved'),
('/root/document/0', 'approved')])
def test_approved_transaction(self):
with CatalogTransaction():
IPublicationWorkflow(self.root.document).approve(DateTime() + 60)
self.assertItemsEqual(self.search('/root/document'),
[('/root/document', 'approved'),
('/root/document/0', 'approved')])
def test_publish(self):
"""If you publish a document, it is recataloged.
"""
IPublicationWorkflow(self.root.document).publish()
self.assertItemsEqual(self.search('/root/document'),
[('/root/document', 'public'),
('/root/document/0', 'public')])
def test_publish_unapproved(self):
"""Publish an unapproved content.
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), '0')
self.assertEqual(content.get_last_closed_version(), None)
publisher.publish()
self.assertTrue(content.is_published())
self.assertEqual(content.get_public_version(), '0')
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), None)
self.assertEqual(content.get_last_closed_version(), None)
def test_make_editable_with_approved(self):
"""Make an old version editable while having an approved and
yet not published version. This will not work.
"""
content = self.root.test
self.layer.login('editor')
publisher = IPublicationWorkflow(content)
publisher.approve(DateTime() + 50)
self.layer.login('author')
manager = IVersionManager(content.get_mockup_version(1))
with self.assertRaises(VersioningError):
manager.make_editable()
self.assertEqual(len(content.objectIds('Mockup Version')), 5)
def test_set_title_while_new_version(self):
document = self.root.document
IPublicationWorkflow(document).publish()
IPublicationWorkflow(document).new_version()
version = document.get_editable()
self.assertEqual(document.get_title(), 'Title')
self.assertEqual(document.get_title_or_id(), 'Title')
self.assertEqual(document.get_title_editable(), 'Title')
self.assertEqual(document.get_title_or_id_editable(), 'Title')
document.set_title('Other Title')
self.assertEqual(document.get_title(), 'Title')
self.assertEqual(document.get_title_or_id(), 'Title')
self.assertEqual(document.get_title_editable(), 'Other Title')
self.assertEqual(document.get_title_or_id_editable(), 'Other Title')
self.assertEqual(version.get_title(), 'Other Title')
def test_rename(self):
"""Rename a published document.
"""
IPublicationWorkflow(self.root.document).publish()
self.root.manage_renameObject('document', 'renamed_document')
self.assertItemsEqual(self.search('/root'),
[('/root', 'public'),
('/root/renamed_document', 'public'),
('/root/renamed_document/0', 'public')])
def test_revoke_approval_no_approved(self):
""" revoke approval on non-approved content must fail.
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), '0')
self.assertEqual(content.get_last_closed_version(), None)
with self.assertRaises(VersioningError):
publisher.revoke_approval()
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), '0')
self.assertEqual(content.get_last_closed_version(), None)
def test_new_version_unapproved(self):
"""Create a new version while there is a unapproved one
available. This is not possible.
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), '0')
self.assertEqual(content.get_last_closed_version(), None)
with self.assertRaises(VersioningError):
publisher.new_version()
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), '0')
self.assertEqual(content.get_last_closed_version(), None)
def test_revoke_approval(self):
""" revoke approval, on approved content (normal scenario)
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
publisher.approve(datetime.now() + timedelta(1))
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), '0')
self.assertEqual(content.get_unapproved_version(), None)
self.assertEqual(content.get_last_closed_version(), None)
self.assertTrue(publisher.revoke_approval())
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), '0')
self.assertEqual(content.get_last_closed_version(), None)
def test_get_title(self):
"""Test ghost get_title. It should return the title of the target.
"""
factory = self.root.manage_addProduct['Silva']
factory.manage_addGhost('ghost', None)
ghost = self.root.ghost
target = self.root.document
ghost.get_editable().set_haunted(target)
self.assertEqual(ghost.get_short_title_editable(), 'Document')
self.assertEqual(ghost.get_short_title(), 'ghost')
self.assertEqual(ghost.get_title_editable(), 'Document')
self.assertEqual(ghost.get_title(), '')
self.assertEqual(ghost.get_title_or_id(), 'ghost')
IPublicationWorkflow(target).publish()
self.assertEqual(ghost.get_short_title_editable(), 'Document')
self.assertEqual(ghost.get_short_title(), 'ghost')
self.assertEqual(ghost.get_title_editable(), 'Document')
self.assertEqual(ghost.get_title(), '')
self.assertEqual(ghost.get_title_or_id(), 'ghost')
IPublicationWorkflow(ghost).publish()
self.assertEqual(ghost.get_short_title_editable(), 'Document')
self.assertEqual(ghost.get_short_title(), 'Document')
self.assertEqual(ghost.get_title_editable(), 'Document')
self.assertEqual(ghost.get_title(), 'Document')
self.assertEqual(ghost.get_title_or_id(), 'Document')
IPublicationWorkflow(target).close()
self.assertEqual(ghost.get_short_title_editable(), 'Document')
self.assertEqual(ghost.get_short_title(), 'Ghost target is broken')
self.assertEqual(ghost.get_title_editable(), 'Document')
self.assertEqual(ghost.get_title(), 'Ghost target is broken')
self.assertEqual(ghost.get_title_or_id(), 'Ghost target is broken')
ghost.get_viewable().set_haunted(0)
self.assertEqual(ghost.get_short_title_editable(),
'Ghost target is broken')
self.assertEqual(ghost.get_short_title(), 'Ghost target is broken')
self.assertEqual(ghost.get_title_editable(), 'Ghost target is broken')
self.assertEqual(ghost.get_title(), 'Ghost target is broken')
self.assertEqual(ghost.get_title_or_id(), 'Ghost target is broken')
def test_get_short_title(self):
document = self.root.document
self.assertEqual(document.get_short_title(), 'document')
self.assertEqual(document.get_short_title_editable(), 'Title')
IPublicationWorkflow(document).publish()
self.assertEqual(document.get_short_title(), 'Title')
self.assertEqual(document.get_short_title_editable(), 'Title')
def test_metadata(self):
"""If you ask metadata about a ghost, you should get the
metadata about the haunted content, if available.
"""
service = getUtility(IMetadataService)
factory = self.root.manage_addProduct['Silva']
factory.manage_addGhost('ghost', None)
ghost = self.root.ghost
document = self.root.document
# Our ghost is broken, so we have no metadata
self.assertEqual(service.getMetadata(ghost), None)
ghost.get_editable().set_haunted(document)
# The document is not published, the Ghost don't have access
# to the document metadata.
self.assertEqual(service.getMetadata(ghost), None)
IPublicationWorkflow(document).publish()
# Now it should work, you should get the metadata of the document
ghost_binding = service.getMetadata(ghost)
self.assertNotEqual(ghost_binding, None)
self.assertEqual(
ghost_binding.get('silva-content', 'maintitle'),
"Document")
self.assertEqual(
service.getMetadataValue(ghost, 'silva-content', 'maintitle'),
"Document")
# You can't change the value
with self.assertRaises(ReadOnlyError):
ghost_binding.setValues('silva-content', {'maintitle': 'Ghost'})
# Nothing changed
ghost_binding = service.getMetadata(ghost)
self.assertEqual(
ghost_binding.get('silva-content', 'maintitle'),
"Document")
self.assertEqual(
service.getMetadataValue(ghost, 'silva-content', 'maintitle'),
"Document")
# Update document metadata
document_binding = service.getMetadata(document.get_viewable())
document_binding.setValues('silva-content', {'maintitle': "Changed"})
# You should see the values from the ghost point of view.
ghost_binding = service.getMetadata(ghost)
self.assertEqual(
ghost_binding.get('silva-content', 'maintitle'),
"Changed")
self.assertEqual(
service.getMetadataValue(ghost, 'silva-content', 'maintitle'),
"Changed")
def setUp(self):
self.root = self.layer.get_application()
self.layer.login('editor')
factory = self.root.manage_addProduct['Silva']
factory.manage_addFolder('folder', 'Folder')
factory.manage_addFolder('other', 'Other')
factory = self.root.other.manage_addProduct['Silva']
factory.manage_addIndexer('indexer', 'Indexer of nothing')
self.root.other.indexer.update()
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addAutoTOC('index', 'Index of the folder')
factory.manage_addMockupVersionedContent('alpha', 'Alpha')
factory.manage_addMockupVersionedContent('beta', 'Beta')
factory.manage_addMockupVersionedContent('gamma', 'Gamma')
factory.manage_addMockupVersionedContent('omega', 'Omega')
factory.manage_addMockupVersionedContent('kappa', 'Kappa')
factory.manage_addMockupVersionedContent('ultra', None) # no title
factory.manage_addGhost('ghost', None, haunted=self.root.folder.kappa)
# Add some anchors.
folder = self.root.folder
folder.alpha.set_entries([('anchor_alpha', 'Anchor Alpha'),
('anchor_empty', '')])
folder.beta.set_entries([('anchor_alpha', 'Anchor Beta'),
('anchor_beta', 'Anchor Tetra')])
folder.gamma.set_entries([('anchor_gamma', 'Anchor Gamma')])
folder.kappa.set_entries([('anchor_kappa', 'Anchor Tetra')])
folder.ultra.set_entries([('anchor_ultra', 'Anchor Ultra')])
# Publish some documents.
IPublicationWorkflow(folder.alpha).publish()
IPublicationWorkflow(folder.beta).publish()
IPublicationWorkflow(folder.kappa).publish()
IPublicationWorkflow(folder.ghost).publish()
IPublicationWorkflow(folder.ultra).publish()
# now create the indexer itself
factory.manage_addIndexer('indexer', 'Indexer of letters')
self.root.folder.indexer.update()
def test_link_closed_only_viewable(self):
"""Export only the viewable version of a link that have
multiple versions available, but none published.
"""
with Transaction():
link = self.root.folder.new.link
IPublicationWorkflow(link).publish()
IPublicationWorkflow(link).close()
# XXX This will trigger a bug on import. We need to find a
# solution that doesn't imply to change all importers again.
exporter = self.assertExportEqual(self.root.folder,
'test_export_link_closed.silvaxml',
options={'only_viewable': True})
self.assertEqual(exporter.getZexpPaths(), [])
self.assertEqual(exporter.getAssetPaths(),
[(('', 'root', 'folder', 'file'), '1')])
self.assertEqual(
exporter.getProblems(),
[(u'No versions are exportable for this content.', link)])
def test_revoke_approval_published(self):
""" datetime for approval is in the past so the content get
published and cannot be revoked.
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
publisher.approve(datetime.now() - timedelta(1))
self.assertEqual(content.get_public_version(), '0')
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), None)
self.assertEqual(content.get_last_closed_version(), None)
with self.assertRaises(VersioningError):
publisher.revoke_approval()
self.assertEqual(content.get_public_version(), '0')
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), None)
self.assertEqual(content.get_last_closed_version(), None)
def test_is_published(self):
"""Test whenever a Ghost is published or not. This depends if
the ghosted content is published or not.
"""
factory = self.root.manage_addProduct['Silva']
factory.manage_addGhost('ghost', None)
self.assertFalse(self.root.ghost.is_published())
IPublicationWorkflow(self.root.ghost).publish()
self.assertFalse(self.root.ghost.is_published())
self.assertEqual(self.root.ghost.get_editable(), None)
self.root.ghost.get_viewable().set_haunted(self.root.document)
self.assertFalse(self.root.ghost.is_published())
IPublicationWorkflow(self.root.document).publish()
self.assertTrue(self.root.ghost.is_published())
IPublicationWorkflow(self.root.document).close()
self.assertFalse(self.root.ghost.is_published())
def setUp(self):
with Transaction():
super(XMLExportVersionsTestCase, self).setUp()
self.layer.login('editor')
factory = self.root.manage_addProduct['Silva']
factory.manage_addFolder('folder', 'Export Folder')
factory = self.root.folder.manage_addProduct['Silva']
factory.manage_addFile('file', 'Torvald file')
factory.manage_addFolder('new', 'New changes')
factory = self.root.folder.new.manage_addProduct['Silva']
factory.manage_addLink('link',
'Initial file',
relative=True,
target=self.root.folder.file)
link = self.root.folder.new.link
IPublicationWorkflow(link).publish()
IPublicationWorkflow(link).new_version()
link.get_editable().set_title('Updated file')
IPublicationWorkflow(link).publish()
IPublicationWorkflow(link).new_version()
link.get_editable().set_title('Final version of the file')
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_request_approval(self):
factory = self.root.manage_addProduct["Silva"]
factory.manage_addMockupVersionedContent("document", "Document")
document = self.root.document
self.layer.login("author")
# Request approval
with AssertLog(self, [["author", "request approval", "/root/document/0"]]):
IPublicationWorkflow(document).request_approval("Ready")
# Withdraw approval
with AssertLog(self, [["author", "cancel request approval", "/root/document/0"]]):
adapter = IPublicationWorkflow(document)
adapter.withdraw_request("Not really ready")
IPublicationWorkflow(document).request_approval("Ready")
self.layer.login("chiefeditor")
# Reject approval
with AssertLog(self, [["chiefeditor", "reject request approval", "/root/document/0"]]):
IPublicationWorkflow(document).reject_request("Not really ready")
def test_reject_published(self):
""" rejecting a published content must fail.
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
publisher.request_approval('please approve')
publisher.publish()
self.assertFalse(content.is_approval_requested())
with self.assertRaises(VersioningError):
publisher.reject_request('u suck anyway')
def test_reject(self):
""" reject request for approval (normal scenario)
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
publisher.request_approval('please approve')
self.assertTrue(publisher.reject_request('u made a mistake'))
self.assertFalse(content.is_approval_requested())
with self.assertRaises(VersioningError):
publisher.reject_request('u suck anyway')
def test_withdraw(self):
""" withdraw request for approval (normal scenario)
"""
content = self.root.test
message = 'please approve.'
publisher = IPublicationWorkflow(content)
publisher.request_approval(message)
self.assertTrue(publisher.withdraw_request('made a mistake'))
self.assertFalse(content.is_approval_requested())
with self.assertRaises(VersioningError):
publisher.withdraw_request('make an other mistake')
def test_get_versions(self):
""" get versions ordered by id
"""
content = self.root.test
publisher = IPublicationWorkflow(content)
for i in range(0, 10):
publisher.publish()
publisher.new_version()
versions = publisher.get_versions()
self.assertEquals(11, len(versions))
for version in versions:
self.assertTrue(IVersion.providedBy(version))
self.assertTrue(content, version.get_content())
def test_close_published(self):
"""Close a published content
"""
content = self.root.test
# Need to publish content first.
publisher = IPublicationWorkflow(content)
publisher.publish()
self.assertEqual(content.get_public_version(), '0')
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), None)
self.assertEqual(content.get_last_closed_version(), None)
publisher = IPublicationWorkflow(content)
publisher.close()
self.assertFalse(content.is_published())
self.assertEqual(content.get_public_version(), None)
self.assertEqual(content.get_approved_version(), None)
self.assertEqual(content.get_unapproved_version(), None)
self.assertEqual(content.get_last_closed_version(), '0')
def getItems(self):
versions = IPublicationWorkflow(self.context).get_versions(False)
versions.sort(key=lambda v: int(v.getId()), reverse=True)
return versions
