def test_checkin_without_IRepositoryContent_adapter_should_raise(self):
manager = ICheckoutManager(self.content)
checked_out = manager.checkout()
self._tear_down_adapters()
manager = ICheckinManager(checked_out)
self.assertTrue(manager.canCheckin)
self.assertRaises(LookupError, manager.checkin)
def test_checkin_with_veto_should_raise(self):
self.assertEqual(1, len(self.workingcopy))
lsc = zeit.cms.content.interfaces.ISemanticChange(
self.repository['testcontent'])
changed = lsc.last_semantic_change
manager = ICheckinManager(self.checked_out)
with self.assertRaises(CheckinCheckoutError) as e:
manager.checkin()
self.assertIn('provoked veto', str(e.exception))
self.assertEqual(1, len(self.workingcopy))
lsc = zeit.cms.content.interfaces.ISemanticChange(
self.repository['testcontent'])
self.assertEqual(changed, lsc.last_semantic_change)
def test_checkin_does_not_unlock_while_publishing(self):
manager = ICheckoutManager(self.repository['testcontent'])
checked_out = manager.checkout()
manager = ICheckinManager(checked_out)
manager.checkin(publishing=True)
lockable = zope.app.locking.interfaces.ILockable(
self.repository['testcontent'])
self.assertTrue(lockable.locked())
def test_event_is_not_sent_for_temporary_workingcopy(self):
# thus, no validation is performed during publishing, for example
# XXX this needs to be conceptualized more clearly, see #12701
# undo setUp, since it doesn't apply for this test
manager = ICheckinManager(self.checked_out)
manager.delete()
manager = ICheckoutManager(self.repository['testcontent'])
checked_out = manager.checkout(temporary=True)
manager = ICheckinManager(checked_out)
self.assertTrue(manager.canCheckin)
def _ensure_unlocked(self, content):
lockable = zope.app.locking.interfaces.ILockable(content, None)
if not lockable:
return
if lockable.isLockedOut():
lockable.breaklock()
if lockable.ownLock():
checked_out = zeit.cms.interfaces.ICMSWCContent(
content.uniqueId, None)
if checked_out is not None:
ICheckinManager(checked_out).delete()
def add(self, object, container=None):
super(Add, self).add(object, container)
zeit.content.article.interfaces.IBreakingNews(
self._created_object).is_breaking = True
# We need to check out the new article so that AfterCheckout events are
# run (which e.g. set default values of ICommonMetadata fields), but
# the user won't want to edit anything right now, so we check in
# immediately (and redirect to a view that triggers publishing).
self._created_object = ICheckinManager(self._created_object).checkin()
self._checked_out = False
IPublishInfo(self._created_object).urgent = True
def test_validation_errors_should_veto_checkin(self):
from zeit.cms.checkout.interfaces import ICheckinManager
from zeit.cms.checkout.interfaces import ICheckoutManager
import zeit.content.article.article
self.repository['article'] = zeit.content.article.article.Article()
manager = ICheckoutManager(self.repository['article'])
co = manager.checkout()
manager = ICheckinManager(co)
self.assertFalse(manager.canCheckin)
errors = dict(manager.last_validation_error)
self.assertIsInstance(
errors['title'], zope.schema.ValidationError)
def test_security_proxied_fields_should_be_validated_correctly(self):
from zeit.cms.checkout.interfaces import ICheckinManager
from zeit.cms.checkout.interfaces import ICheckoutManager
import zeit.content.article.article
self.repository['article'] = zeit.content.article.article.Article()
manager = ICheckoutManager(self.repository['article'])
co = manager.checkout()
co = zope.security.proxy.ProxyFactory(co)
manager = ICheckinManager(co)
self.assertFalse(manager.canCheckin)
errors = dict(manager.last_validation_error)
# the default for keywords is an empty tuple
self.assertNotIn('keywords', errors)
def test_checkin_with_veto_should_raise(self):
self.assertEqual(1, len(self.workingcopy))
lsc = zeit.cms.content.interfaces.ISemanticChange(
self.repository['testcontent'])
changed = lsc.last_semantic_change
manager = ICheckinManager(self.checked_out)
self.assertRaisesRegexp(CheckinCheckoutError, '.*provoked veto.*',
manager.checkin)
self.assertEqual(1, len(self.workingcopy))
lsc = zeit.cms.content.interfaces.ISemanticChange(
self.repository['testcontent'])
self.assertEqual(changed, lsc.last_semantic_change)
def test_delete_issues_events_and_deletes_context(self):
manager = ICheckoutManager(self.content)
checked_out = manager.checkout()
parent = checked_out.__parent__
name = checked_out.__name__
manager = ICheckinManager(checked_out)
with mock.patch('zope.event.notify', mock.Mock()) as notify:
manager.delete()
self.assertNotIn(name, parent.keys())
self.assertEqual(2, len(notify.call_args_list))
before, after = notify.call_args_list
self.assertTrue(
zeit.cms.checkout.interfaces.IBeforeDeleteEvent.providedBy(
before[0][0]))
self.assertTrue(
zeit.cms.checkout.interfaces.IAfterDeleteEvent.providedBy(
after[0][0]))
def test_checkin_needs_adapter_to_IRepositoryContent(self):
manager = ICheckoutManager(self.content)
checked_out = manager.checkout()
manager = ICheckinManager(checked_out)
checked_in = manager.checkin()
self.assertFalse(checked_in.are_you_local)
def test_veto_message_is_available_on_manager(self):
manager = ICheckinManager(self.checked_out)
manager.canCheckin
self.assertEqual('provoked veto', manager.last_validation_error)
def test_veto_in_event_makes_canCheckin_return_false(self):
manager = ICheckinManager(self.checked_out)
self.assertFalse(manager.canCheckin)
