def test_page_signals_publish_unpublish_example(self): """ The example in the docs provides the following example to the page publish and unpublish signals. """ signal_hits = list() # Signal example @receiver(post_version_operation, sender=PageContent) def do_something_on_page_publish_unpublsh(*args, **kwargs): if ( kwargs["operation"] == constants.OPERATION_PUBLISH or kwargs["operation"] == constants.OPERATION_UNPUBLISH ): # Storing the state of the operation and object at this moment to compare the state later obj = dict() obj["state"] = kwargs["obj"].state signal_hits.append(obj) version_1 = factories.PageVersionFactory( state=constants.DRAFT, content__template="" ) version_2 = factories.PageVersionFactory( state=constants.DRAFT, content__template="" ) version_1.publish(self.superuser) version_1.unpublish(self.superuser) version_2.archive(self.superuser) # Only the publish and unpublish signals should have had an affect self.assertEqual(len(signal_hits), 2) self.assertEqual(signal_hits[0].get("state"), constants.PUBLISHED) self.assertEqual(signal_hits[1].get("state"), constants.UNPUBLISHED)
def setUp(self): self.wf = WorkflowFactory(name="Workflow Test") self.collection = ModerationCollectionFactory( author=self.user, name="Collection Admin Actions", workflow=self.wf, status=constants.IN_REVIEW, ) pg1_version = factories.PageVersionFactory() pg2_version = factories.PageVersionFactory() self.mr1n = RootModerationRequestTreeNodeFactory( moderation_request__version=pg1_version, moderation_request__collection=self.collection, moderation_request__is_active=True, ) self.mr1 = self.mr1n.moderation_request self.wfst = self.wf.steps.create(role=self.role2, is_required=True, order=1) # this moderation request is approved self.mr1.actions.create(to_user=self.user2, by_user=self.user, action=constants.ACTION_STARTED) self.mr1action2 = self.mr1.actions.create( by_user=self.user, to_user=self.user2, action=constants.ACTION_APPROVED, step_approved=self.wfst, ) # this moderation request is not approved self.mr2n = RootModerationRequestTreeNodeFactory( moderation_request__version=pg2_version, moderation_request__collection=self.collection, moderation_request__is_active=True, ) self.mr2 = self.mr2n.moderation_request self.mr2.actions.create(to_user=self.user2, by_user=self.user, action=constants.ACTION_STARTED) self.url = reverse( "admin:djangocms_moderation_moderationrequest_changelist") self.url_with_filter = "{}?moderation_request__collection__id={}".format( self.url, self.collection.pk) self.mr_tree_admin = ModerationRequestTreeAdmin( ModerationRequest, admin.AdminSite()) self.mra = ModerationRequestAdmin(ModerationRequest, admin.AdminSite()) self.mca = ModerationCollectionAdmin(ModerationCollection, admin.AdminSite())
def test_add_plugins_from_placeholder(self): version = factories.PageVersionFactory() source_placeholder = factories.PlaceholderFactory(source=version.content) target_placeholder = factories.PlaceholderFactory(source=version.content) poll = factories.PollFactory() plugin = add_plugin( source_placeholder, "PollPlugin", version.content.language, poll=poll ) dt = datetime(2016, 6, 6, tzinfo=timezone.utc) with freeze_time(dt): endpoint = self.get_copy_plugin_uri(plugin) data = { "source_language": version.content.language, "source_placeholder_id": source_placeholder.pk, "target_language": version.content.language, "target_placeholder_id": target_placeholder.pk, } with self.login_user_context(self.get_superuser()): response = self.client.post(endpoint, data) self.assertEqual(response.status_code, 200) version = Version.objects.get(pk=version.pk) self.assertEqual(version.modified, dt)
def test_cut_plugin(self): version = factories.PageVersionFactory() placeholder = factories.PlaceholderFactory(source=version.content) poll = factories.PollFactory() user_settings = UserSettings.objects.create( language=version.content.language, user=self.get_superuser(), clipboard=Placeholder.objects.create(slot="clipboard"), ) plugin = add_plugin( placeholder, "PollPlugin", version.content.language, poll=poll ) dt = datetime(2016, 6, 6, tzinfo=timezone.utc) with freeze_time(dt): endpoint = self.get_move_plugin_uri(plugin) data = { "plugin_id": plugin.pk, "target_language": version.content.language, "placeholder_id": user_settings.clipboard_id, } with self.login_user_context(self.get_superuser()): response = self.client.post(endpoint, data) self.assertEqual(response.status_code, 200) version = Version.objects.get(pk=version.pk) self.assertEqual(version.modified, dt)
def test_notify_version_author_version_unlocked_email_contents_users_full_name_used( self): """ The email contains the full name of the author """ user = self.user_has_unlock_perms user.first_name = "Firstname" user.last_name = "Lastname" user.save() draft_version = factories.PageVersionFactory( content__template="", created_by=self.user_author) draft_unlock_url = self.get_admin_url( self.versionable.version_model_proxy, 'unlock', draft_version.pk) # Check that no emails exist self.assertEqual(len(mail.outbox), 0) # Unlock the version with a different user with unlock permissions with self.login_user_context(user): self.client.post(draft_unlock_url, follow=True) expected_body = "The following draft version has been unlocked by {by_user} for their use.".format( by_user=user.get_full_name()) self.assertEqual(len(mail.outbox), 1) self.assertTrue(expected_body in mail.outbox[0].body)
def test_notify_version_author_version_unlocked_email_sent_for_different_user( self): """ The user unlocking a version that is authored buy a different user should be sent a notification email """ draft_version = factories.PageVersionFactory( content__template="", created_by=self.user_author) draft_unlock_url = self.get_admin_url( self.versionable.version_model_proxy, 'unlock', draft_version.pk) # Check that no emails exist self.assertEqual(len(mail.outbox), 0) # 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) site = get_current_site() expected_subject = "[Django CMS] ({site_name}) {title} - {description}".format( site_name=site.name, title=draft_version.content, description=_("Unlocked"), ) expected_body = "The following draft version has been unlocked by {by_user} for their use.".format( by_user=self.user_has_unlock_perms) expected_version_url = get_absolute_url( get_object_preview_url(draft_version.content)) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].subject, expected_subject) self.assertEqual(mail.outbox[0].to[0], self.user_author.email) self.assertTrue(expected_body in mail.outbox[0].body) self.assertTrue(expected_version_url in mail.outbox[0].body)
def test_placeholders_are_copied(self): """The implementation of versioning for PageContent correctly copies placeholders """ original_version = factories.PageVersionFactory() original_placeholders = factories.PlaceholderFactory.create_batch( 2, source=original_version.content) original_version.content.placeholders.add(*original_placeholders) user = factories.UserFactory() new_version = original_version.copy(user) new_placeholders = new_version.content.placeholders.all() self.assertEqual(new_placeholders.count(), 2) self.assertNotEqual(new_placeholders[0].pk, original_placeholders[0].pk) self.assertEqual(new_placeholders[0].slot, original_placeholders[0].slot) self.assertEqual(new_placeholders[0].default_width, original_placeholders[0].default_width) self.assertEqual(new_placeholders[0].source, new_version.content) self.assertNotEqual(new_placeholders[1].pk, original_placeholders[1].pk) self.assertEqual(new_placeholders[1].slot, original_placeholders[1].slot) self.assertEqual(new_placeholders[1].default_width, original_placeholders[1].default_width) self.assertEqual(new_placeholders[1].source, new_version.content)
def test_grouper_selector_non_default_label_unpublished(self): """ Grouper selector shows the PageContent label format when PageContent is set """ version = factories.PageVersionFactory() form_class = grouper_form_factory(PageContent, version.content.language) label = "No available title (Unpublished)" self.assertIn((version.content.page.pk, label), form_class.base_fields["page"].choices)
def test_copy_plugins_method_used(self): original_version = factories.PageVersionFactory() placeholder = factories.PlaceholderFactory( source=original_version.content) original_version.content.placeholders.add(placeholder) user = factories.UserFactory() with patch("djangocms_versioning.cms_config.Placeholder.copy_plugins" ) as mocked_copy: new_version = original_version.copy(user) new_placeholder = new_version.content.placeholders.get() mocked_copy.assert_called_once_with(new_placeholder)
def test_clear_placeholder(self): version = factories.PageVersionFactory() placeholder = factories.PlaceholderFactory(source=version.content) dt = datetime(2016, 6, 6, tzinfo=timezone.utc) with freeze_time(dt): endpoint = self.get_clear_placeholder_url(placeholder) with self.login_user_context(self.get_superuser()): response = self.client.post(endpoint, {"test": 0}) self.assertEqual(response.status_code, 302) version = Version.objects.get(pk=version.pk) self.assertEqual(version.modified, dt)
def test_text_plugins_are_copied(self): """The implementation of versioning for PageContent correctly copies text plugins """ original_version = factories.PageVersionFactory() placeholder = factories.PlaceholderFactory( source=original_version.content) original_version.content.placeholders.add(placeholder) with freeze_time("2017-07-07"): # Make sure created in the past original_plugins = factories.TextPluginFactory.create_batch( 2, placeholder=placeholder) user = factories.UserFactory() new_version = original_version.copy(user) new_plugins = new_version.content.placeholders.get().cmsplugin_set.all( ) self.assertEqual(new_plugins.count(), 2) self.assertNotEqual(new_plugins[0].pk, original_plugins[0].pk) self.assertEqual(new_plugins[0].language, original_plugins[0].language) self.assertIsNone(new_plugins[0].parent) self.assertEqual(new_plugins[0].position, original_plugins[0].position) self.assertEqual(new_plugins[0].plugin_type, original_plugins[0].plugin_type) self.assertEqual( new_plugins[0].djangocms_text_ckeditor_text.body, original_plugins[0].djangocms_text_ckeditor_text.body, ) self.assertEqual(new_plugins[0].creation_date, original_plugins[0].creation_date) self.assertEqual(new_plugins[0].changed_date, now()) self.assertNotEqual(new_plugins[1].pk, original_plugins[1].pk) self.assertEqual(new_plugins[1].language, original_plugins[1].language) self.assertIsNone(new_plugins[1].parent) self.assertEqual(new_plugins[1].position, original_plugins[1].position) self.assertEqual(new_plugins[1].plugin_type, original_plugins[1].plugin_type) self.assertEqual( new_plugins[1].djangocms_text_ckeditor_text.body, original_plugins[1].djangocms_text_ckeditor_text.body, ) self.assertEqual(new_plugins[1].creation_date, original_plugins[1].creation_date) self.assertEqual(new_plugins[1].changed_date, now())
def test_add_plugin(self): version = factories.PageVersionFactory() placeholder = factories.PlaceholderFactory(source=version.content) poll = factories.PollFactory() dt = datetime(2016, 6, 6, tzinfo=timezone.utc) with freeze_time(dt): endpoint = self.get_add_plugin_uri( placeholder=placeholder, plugin_type="PollPlugin", language=version.content.language, ) data = {"poll": poll.pk} with self.login_user_context(self.get_superuser()): response = self.client.post(endpoint, data) self.assertEqual(response.status_code, 200) version = Version.objects.get(pk=version.pk) self.assertEqual(version.modified, dt)
def test_notify_version_author_version_unlocked_email_not_sent_for_different_user(self): """ The user unlocking a version that authored the version should not be sent a notification email """ draft_version = factories.PageVersionFactory(content__template="", created_by=self.user_author) draft_unlock_url = self.get_admin_url(self.versionable.version_model_proxy, 'unlock', draft_version.pk) # Check that no emails exist self.assertEqual(len(mail.outbox), 0) # Unlock the version the same user who authored it with self.login_user_context(self.user_author): self.client.post(draft_unlock_url, follow=True) # Check that no emails still exist self.assertEqual(len(mail.outbox), 0)
def setUp(self): self.site = Site.objects.get_current() self.user = self.get_superuser() self.language = 'en' self.title = 'test page' self.version = factories.PageVersionFactory( content__language='en', state=DRAFT, ) factories.PageUrlFactory( page=self.version.content.page, language='en', path=slugify(self.title), slug=slugify(self.title), ) self.page = self.version.content.page self.content = self.version.content
def test_grouper_selector_non_default_label(self): """ Grouper selector shows the PageContent label format when PageContent is set """ version = factories.PageVersionFactory() PageUrl.objects.create( page=version.content.page, language=version.content.language, path='test', slug='test', ) version.publish(version.created_by) form_class = grouper_form_factory(PageContent, version.content.language) label = "{title} (/{path}/)".format( title=version.content.title, path=version.content.page.get_path(version.content.language)) self.assertIn( (version.content.page.pk, label), form_class.base_fields['grouper'].choices, )
def test_page_content_object_gets_duplicated(self): """The implementation of versioning for PageContent correctly copies the PageContent object """ with freeze_time("2017-07-07"): # Make sure created in the past original_version = factories.PageVersionFactory() user = factories.UserFactory() new_version = original_version.copy(user) # Created a new content record self.assertNotEqual(original_version.content.pk, new_version.content.pk) # Has the same fields as the original version self.assertEqual(original_version.content.title, new_version.content.title) self.assertEqual(original_version.content.language, new_version.content.language) # new content should have a future date self.assertGreater(new_version.content.creation_date, original_version.content.creation_date) self.assertEqual(original_version.content.created_by, new_version.content.created_by) self.assertEqual(new_version.content.changed_date, now()) self.assertEqual(original_version.content.changed_by, new_version.content.changed_by) self.assertEqual(original_version.content.in_navigation, new_version.content.in_navigation) self.assertEqual(original_version.content.soft_root, new_version.content.soft_root) self.assertEqual(original_version.content.template, new_version.content.template) self.assertEqual( original_version.content.limit_visibility_in_menu, new_version.content.limit_visibility_in_menu, ) self.assertEqual(original_version.content.xframe_options, new_version.content.xframe_options) self.assertEqual(original_version.content.page, new_version.content.page)