def test_version_lock_state_locked(self): """ A published version does not have an entry in the locked column in the admin """ published_version = factories.PollVersionFactory(state=PUBLISHED) self.assertEqual("", self.hijacked_admin.locked(published_version))
def test_unlock_link_only_present_for_draft_versions(self): draft_version = factories.PollVersionFactory( created_by=self.user_author) published_version = Version.objects.create( content=factories.PollContentFactory( poll=draft_version.content.poll), created_by=factories.UserFactory(), state=constants.PUBLISHED) draft_unlock_url = self.get_admin_url( self.versionable.version_model_proxy, 'unlock', draft_version.pk) draft_unlock_control = render_to_string( 'djangocms_version_locking/admin/unlock_icon.html', {'unlock_url': draft_unlock_url}) published_unlock_url = self.get_admin_url( self.versionable.version_model_proxy, 'unlock', published_version.pk) published_unlock_control = render_to_string( 'djangocms_version_locking/admin/unlock_icon.html', {'unlock_url': published_unlock_url}) changelist_url = version_list_url(draft_version.content) with self.login_user_context(self.superuser): response = self.client.post(changelist_url) # The draft version unlock control exists self.assertContains(response, draft_unlock_control, html=True) # The published version exists self.assertNotContains(response, published_unlock_control, html=True)
def test_version_is_locked_for_draft(self): """ A version lock is present when a content version is in a draft state """ draft_version = factories.PollVersionFactory(state=constants.DRAFT) self.assertTrue(hasattr(draft_version, 'versionlock'))
def test_version_lock_state_unlocked(self): """ A draft version does have an entry in the locked column in the and is not empty """ draft_version = factories.PollVersionFactory(state=DRAFT) self.assertNotEqual("", self.hijacked_admin.locked(draft_version))
def test_version_is_unlocked_for_publishing(self): """ A version lock is not present when a content version is in a published or unpublished state """ poll_version = factories.PollVersionFactory(state=constants.DRAFT) publish_url = self.get_admin_url(self.versionable.version_model_proxy, 'publish', poll_version.pk) unpublish_url = self.get_admin_url(self.versionable.version_model_proxy, 'unpublish', poll_version.pk) user = self.get_staff_user_with_no_permissions() with self.login_user_context(user): self.client.post(publish_url) updated_poll_version = Version.objects.get(pk=poll_version.pk) # The state is now PUBLISHED self.assertEqual(updated_poll_version.state, constants.PUBLISHED) # Version lock does not exist self.assertFalse(hasattr(updated_poll_version, 'versionlock')) with self.login_user_context(user): self.client.post(unpublish_url) updated_poll_version = Version.objects.get(pk=poll_version.pk) # The state is now UNPUBLISHED self.assertEqual(updated_poll_version.state, constants.UNPUBLISHED) # Version lock does not exist self.assertFalse(hasattr(updated_poll_version, 'versionlock'))
def test_draft_version_copy_creates_draft_lock(self): """ A version lock is created for a new draft version copied from a draft version """ user = factories.UserFactory() draft_version = factories.PollVersionFactory(state=constants.DRAFT) new_version = draft_version.copy(user) self.assertTrue(hasattr(new_version, 'versionlock'))
def test_published_version_copy_creates_draft_lock(self): """ A version lock is created for a published version copied from a draft version """ user = factories.UserFactory() published_version = factories.PollVersionFactory(state=constants.PUBLISHED) new_version = published_version.copy(user) self.assertTrue(hasattr(new_version, 'versionlock'))
def test_unlock_view_redirects_404_when_not_draft(self): poll_version = factories.PollVersionFactory(state=constants.PUBLISHED, created_by=self.superuser) unlock_url = self.get_admin_url(self.versionable.version_model_proxy, 'unlock', poll_version.pk) # 404 when not in draft with self.login_user_context(self.superuser): response = self.client.post(unlock_url, follow=True) self.assertEqual(response.status_code, 404)
def test_user_has_change_permission(self): """ Test that the user who created the version has permission to change it """ author = self.get_superuser() content = factories.PollVersionFactory(state=DRAFT, created_by=author) url = self.get_admin_url(PollContent, 'change', content.pk) with self.login_user_context(author): response = self.client.get(url) self.assertEqual(response.status_code, 200)
def test_version_locking_css_media_loaded(self): """ The verison locking css media is loaded on the page """ poll_version = factories.PollVersionFactory(created_by=self.superuser) changelist_url = version_list_url(poll_version.content) css_file = "djangocms_version_locking/css/version-locking.css" with self.login_user_context(self.superuser): response = self.client.post(changelist_url) self.assertContains(response, css_file)
def test_version_copy_adds_correct_locked_user(self): """ A copied version creates a lock for the user that copied the version. The users should not be the same. """ original_user = factories.UserFactory() original_version = factories.PollVersionFactory(created_by=original_user) copy_user = factories.UserFactory() copied_version = original_version.copy(copy_user) self.assertNotEqual(original_user, copy_user) self.assertEqual(original_version.versionlock.created_by, original_user) self.assertEqual(copied_version.versionlock.created_by, copy_user)
def test_user_has_change_permission(self): """ The user who created the version has permission to change it """ content = factories.PollVersionFactory( state=DRAFT, created_by=self.user_has_change_perms) url = self.get_admin_url(self.versionable.version_model_proxy, 'change', content.pk) with self.login_user_context(self.user_has_change_perms): response = self.client.get(url) self.assertEqual(response.status_code, 200)
def test_edit_action_link_disabled_state(self): """ The edit action is disabled for a different user to the locked user """ version = factories.PollVersionFactory(created_by=self.user_author) author_request = RequestFactory() author_request.user = self.user_author otheruser_request = RequestFactory() otheruser_request.user = self.superuser actual_disabled_state = self.version_admin._get_edit_link( version, otheruser_request) self.assertIn("inactive", actual_disabled_state)
def test_unlock_link_present_for_user_with_privileges(self): poll_version = factories.PollVersionFactory( state=constants.DRAFT, created_by=self.user_author) changelist_url = version_list_url(poll_version.content) unlock_url = self.get_admin_url(self.versionable.version_model_proxy, 'unlock', poll_version.pk) unlock_control = render_to_string( 'djangocms_version_locking/admin/unlock_icon.html', {'unlock_url': unlock_url}) with self.login_user_context(self.user_has_unlock_perms): response = self.client.post(changelist_url) self.assertContains(response, unlock_control, html=True)
def test_edit_action_link_enabled_state(self): """ The edit action is active """ version = factories.PollVersionFactory(created_by=self.user_author) author_request = RequestFactory() author_request.user = self.user_author otheruser_request = RequestFactory() otheruser_request.user = self.superuser actual_enabled_state = self.version_admin._get_edit_link( version, author_request) self.assertNotIn("inactive", actual_enabled_state)
def test_user_does_not_have_change_permission(self): """ A different user from the user who created the version does not have permission to change it """ author = factories.UserFactory(is_staff=True) content = factories.PollVersionFactory(state=DRAFT, created_by=author) url = self.get_admin_url(self.versionable.version_model_proxy, 'change', content.pk) with self.login_user_context(self.user_has_change_perms): response = self.client.get(url) self.assertEqual(response.status_code, 403)
def test_user_does_not_have_change_permission(self): """ Test that a different user from the user who created the version does not have permission to change it """ author = factories.UserFactory() editor = self.get_superuser() content = factories.PollVersionFactory(state=DRAFT, created_by=author) url = self.get_admin_url(PollContent, 'change', content.pk) with self.login_user_context(editor): response = self.client.get(url) self.assertEqual(response.status_code, 403)
def test_unlock_view_possible_for_user_with_permissions(self): poll_version = factories.PollVersionFactory( state=constants.DRAFT, created_by=self.user_author) unlock_url = self.get_admin_url(self.versionable.version_model_proxy, 'unlock', poll_version.pk) with self.login_user_context(self.user_has_unlock_perms): response = self.client.post(unlock_url, follow=True) self.assertEqual(response.status_code, 200) # Fetch the latest state of this version updated_poll_version = Version.objects.get(pk=poll_version.pk) # The version is not locked self.assertFalse(hasattr(updated_poll_version, 'versionlock'))
def test_version_unlock_keep_side_frame(self): """ When clicking on an versionables enabled unlock icon, the sideframe is kept open """ version = factories.PollVersionFactory(created_by=self.user_author) author_request = RequestFactory() author_request.user = self.user_author otheruser_request = RequestFactory() otheruser_request.user = self.superuser actual_enabled_state = self.version_admin._get_unlock_link( version, otheruser_request) # The url link should keep the sideframe open self.assertIn("js-versioning-keep-sideframe", actual_enabled_state) self.assertNotIn("js-versioning-close-sideframe", actual_enabled_state)
def test_archive_link_only_present_for_author_for_draft(self): draft_version = factories.PollVersionFactory( created_by=self.user_author) with self.login_user_context(self.superuser): request = RequestFactory() request.user = self.superuser archive_url = self.version_admin._get_archive_link( draft_version, request) self.assertIn("inactive", archive_url) with self.login_user_context(self.user_author): request = RequestFactory() request.user = self.user_author archive_url = self.version_admin._get_archive_link( draft_version, request) self.assertNotIn("inactive", archive_url)
def test_unlock_link_not_present_for_author(self): # FIXME: May be redundant now as this requirement was probably removed at a later date due # to the fact that an author may be asked to unlock their version for someone else to use! author = self.get_superuser() poll_version = factories.PollVersionFactory(state=constants.DRAFT, created_by=author) changelist_url = version_list_url(poll_version.content) unlock_url = self.get_admin_url(self.versionable.version_model_proxy, 'unlock', poll_version.pk) unlock_control = render_to_string( 'djangocms_version_locking/admin/unlock_icon.html', {'unlock_url': unlock_url}) with self.login_user_context(author): response = self.client.get(changelist_url) self.assertNotContains(response, unlock_control, html=True)
def test_unpublish_link_shoulnt_present_for_author_for_draft(self): draft_version = factories.PollVersionFactory( created_by=self.user_author) with self.login_user_context(self.superuser): request = RequestFactory() request.user = self.superuser unpublish_url = self.version_admin._get_unpublish_link( draft_version, request) self.assertIn("", unpublish_url) with self.login_user_context(self.user_author): request = RequestFactory() request.user = self.user_author unpublish_url = self.version_admin._get_unpublish_link( draft_version, request) self.assertIn("", unpublish_url)
def test_discard_link_only_present_for_author_for_draft(self): draft_version = factories.PollVersionFactory( created_by=self.user_author, state=constants.DRAFT) with self.login_user_context(self.superuser): request = RequestFactory() request.user = self.superuser discard_url = self.version_admin._get_discard_link( draft_version, request) self.assertIn("inactive", discard_url) with self.login_user_context(self.user_author): request = RequestFactory() request.user = self.user_author discard_url = self.version_admin._get_discard_link( draft_version, request) self.assertNotIn("inactive", discard_url)
def test_unlock_and_new_user_edit_creates_version_lock(self): """ When a version is unlocked a different user (or the same) can then visit the edit link and take ownership of the version, this creates a version lock for the editing user """ draft_version = factories.PollVersionFactory( created_by=self.user_author) draft_unlock_url = self.get_admin_url( self.versionable.version_model_proxy, 'unlock', draft_version.pk) # The version is owned by the author self.assertEqual(draft_version.created_by, self.user_author) # The version lock exists and is owned by the author self.assertEqual(draft_version.versionlock.created_by, self.user_author) # Unlock the version with a different user with unlock permissions with self.login_user_context(self.user_has_unlock_perms): self.client.post(draft_unlock_url, follow=True) updated_draft_version = Version.objects.get(pk=draft_version.pk) updated_draft_edit_url = self.get_admin_url( self.versionable.version_model_proxy, 'edit_redirect', updated_draft_version.pk) # The version is still owned by the author self.assertTrue(updated_draft_version.created_by, self.user_author) # The version lock does not exist self.assertFalse(hasattr(updated_draft_version, 'versionlock')) # Visit the edit page with a user without unlock permissions with self.login_user_context(self.user_has_no_unlock_perms): self.client.post(updated_draft_edit_url) updated_draft_version = Version.objects.get(pk=draft_version.pk) # The version is now owned by the user with no permissions self.assertTrue(updated_draft_version.created_by, self.user_has_no_unlock_perms) # The version lock exists and is now owned by the user with no permissions self.assertEqual(updated_draft_version.versionlock.created_by, self.user_has_no_unlock_perms)
def test_version_is_unlocked_for_archived(self): """ A version lock is not present when a content version is in an archived state """ poll_version = factories.PollVersionFactory(state=constants.DRAFT) archive_url = self.get_admin_url(self.versionable.version_model_proxy, 'archive', poll_version.pk) version_lock = version_is_locked(poll_version) user = self.get_superuser() version_lock.created_by = user version_lock.save() with self.login_user_context(user): self.client.post(archive_url) updated_poll_version = Version.objects.get(pk=poll_version.pk) # The state is now ARCHIVED self.assertEqual(updated_poll_version.state, constants.ARCHIVED) # Version lock does not exist self.assertFalse(hasattr(updated_poll_version, 'versionlock'))
def test_archive_link_not_present_for_published_version(self): draft_version = factories.PollVersionFactory( created_by=self.user_author) published_version = Version.objects.create( content=factories.PollContentFactory( poll=draft_version.content.poll), created_by=factories.UserFactory(), state=constants.PUBLISHED) with self.login_user_context(self.user_author): request = RequestFactory() request.user = self.user_author discard_url = self.version_admin._get_discard_link( published_version, request) self.assertEqual("", discard_url) with self.login_user_context(self.user_author): request = RequestFactory() request.user = self.user_author discard_url = self.version_admin._get_discard_link( published_version, request) self.assertEqual("", discard_url)