def test_is_obj_version_unlocked_after_publish(self): self.assertIsNotNone(Version) version = PageVersionFactory(created_by=self.user) self.assertTrue(is_obj_version_unlocked(version.content, self.user)) self.assertFalse(is_obj_version_unlocked(version.content, self.user2)) version.publish(self.user) # reload version to update cache version = Version.objects.get_for_content(version.content) self.assertTrue(is_obj_version_unlocked(version.content, self.user2)) # Make sure that we are actually calling the version-lock method and it # still exists with mock.patch( "djangocms_moderation.helpers.content_is_unlocked_for_user" ) as _mock: is_obj_version_unlocked(version.content, self.user2) _mock.assert_called_once_with(version.content, self.user2)
class MonkeypatchPageAdminCopyLanguageTestCase(CMSTestCase): def setUp(self): self.user = self.get_superuser() page = PageFactory() self.source_version = PageVersionFactory(content__page=page, content__language="en") self.target_version = PageVersionFactory(content__page=page, content__language="it") # Add default placeholders source_placeholder = PlaceholderFactory( source=self.source_version.content, slot="content") self.source_version.content.placeholders.add(source_placeholder) target_placeholder = PlaceholderFactory( source=self.target_version.content, slot="content") self.target_version.content.placeholders.add(target_placeholder) # Populate only the source placeholder as this is what we will be copying! TextPluginFactory(placeholder=source_placeholder) # Use the endpoint that the toolbar copy uses, this indirectly runs the monkey patched logic! # Simulating the user selecting in the Language menu "Copy all plugins" in the Versioned Page toolbar self.copy_url = admin_reverse('cms_pagecontent_copy_language', args=(self.source_version.content.pk, )) self.copy_url_data = {'source_language': "en", 'target_language': "it"} def test_page_copy_language_copies_source_draft_placeholder_plugins(self): """ A draft pages contents are copied to a different language """ with self.login_user_context(self.user): response = self.client.post(self.copy_url, self.copy_url_data) self.assertEqual(response.status_code, 200) original_plugins = self.source_version.content.placeholders.get( ).cmsplugin_set.all() new_plugins = self.target_version.content.placeholders.get( ).cmsplugin_set.all() self.assertEqual(new_plugins.count(), 1) self.assertNotEqual(new_plugins[0].pk, original_plugins[0].pk) self.assertNotEqual(new_plugins[0].language, original_plugins[0].language) self.assertEqual(new_plugins[0].language, "it") 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, ) def test_copy_language_copies_source_published_placeholder_plugins(self): """ A published pages contents are copied to a different language """ # Publish the source version self.source_version.publish(self.user) with self.login_user_context(self.user): response = self.client.post(self.copy_url, self.copy_url_data) self.assertEqual(response.status_code, 200) original_plugins = self.source_version.content.placeholders.get( ).cmsplugin_set.all() new_plugins = self.target_version.content.placeholders.get( ).cmsplugin_set.all() self.assertEqual(new_plugins.count(), 1) self.assertNotEqual(new_plugins[0].pk, original_plugins[0].pk) self.assertNotEqual(new_plugins[0].language, original_plugins[0].language) self.assertEqual(new_plugins[0].language, "it") 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, ) @skipIf(not DJANGO_GTE_21, "Django<2.1. Change permission checks are not ran on Django<2.1") def test_copy_language_cannot_copy_to_published_version(self): """ A pages contents cannot be copied to a published target version! """ # Publish the target version self.target_version.publish(self.user) with self.login_user_context(self.user): response = self.client.post(self.copy_url, self.copy_url_data) # the Target version should be protected and we should not be allowed to copy any plugins to it! self.assertEqual(response.status_code, 403) def test_copy_language_copies_from_page_with_different_placeholders(self): """ PageContents stores the template, this means that each PageContent can have a different template and placeholders. We should only copy plugins from common placeholders. This test contains different templates and a partially populated source and target placeholders. All plugins in the source should be left unnafected """ source_placeholder_1 = PlaceholderFactory( source=self.source_version.content, slot="source_placeholder_1") self.source_version.content.placeholders.add(source_placeholder_1) TextPluginFactory(placeholder=source_placeholder_1) target_placeholder_1 = PlaceholderFactory( source=self.target_version.content, slot="target_placeholder_1") self.target_version.content.placeholders.add(target_placeholder_1) TextPluginFactory(placeholder=target_placeholder_1) self.source_version.publish(self.user) with self.login_user_context(self.user): response = self.client.post(self.copy_url, self.copy_url_data) self.assertEqual(response.status_code, 200) source_placeholder_different = self.source_version.content.placeholders.get( slot="source_placeholder_1").cmsplugin_set.all() target_placeholder_different = self.target_version.content.placeholders.get( slot="target_placeholder_1").cmsplugin_set.all() self.assertEqual(source_placeholder_different.count(), 1) self.assertEqual(target_placeholder_different.count(), 1) self.assertNotEqual( source_placeholder_different[0].djangocms_text_ckeditor_text.body, target_placeholder_different[0].djangocms_text_ckeditor_text.body)
class CMSVersionedMenuTestCase(CMSTestCase): def setUp(self): super().setUp() self._page_1 = PageVersionFactory( content__title="page_content_1", content__menu_title="", content__in_navigation=True, content__limit_visibility_in_menu=None, content__language="en", content__page__node__path="0001", ) self._page_2 = PageVersionFactory( content__title="page_content_2", content__menu_title="", content__in_navigation=True, content__limit_visibility_in_menu=None, content__language="en", content__page__node__path="0002", ) self._page_2_1 = PageVersionFactory( content__title="page_content_2_1", content__menu_title="", content__in_navigation=True, content__limit_visibility_in_menu=None, content__language="en", content__page__node__path="00020001", content__page__node__parent=self._page_2.content.page.node, ) self._page_2_2 = PageVersionFactory( content__title="page_content_2_2", content__menu_title="", content__in_navigation=True, content__limit_visibility_in_menu=None, content__language="en", content__page__node__path="00020002", content__page__node__parent=self._page_2.content.page.node, ) self._page_3 = PageVersionFactory( content__title="page_content_3", content__menu_title="", content__in_navigation=True, content__limit_visibility_in_menu=None, content__language="en", content__page__node__path="0003", ) def _render_menu(self, user=None, **kwargs): request = RequestFactory().get("/") if not user: is_auth_user = kwargs.get("is_auth_user", True) user = self.get_superuser() if is_auth_user else AnonymousUser() request.user = user request.session = {} toolbar = CMSToolbar(request) if kwargs.get("edit_mode", False): toolbar.edit_mode_active = True toolbar.preview_mode_active = False elif kwargs.get("preview_mode", False): toolbar.edit_mode_active = False toolbar.preview_mode_active = True else: toolbar.edit_mode_active = False toolbar.preview_mode_active = False request.toolbar = toolbar context = {"request": request} template = Template("{% load menu_tags %}" "{% show_menu 0 100 100 100 %}") template.render(Context(context)) return context def _assert_node(self, node, version, edit_or_preview=True): content = version.content self.assertEqual(node.title, content.title) if edit_or_preview: self.assertEqual(node.url, get_object_preview_url(content)) else: self.assertEqual(node.url, content.get_absolute_url()) def test_core_cms_menu_is_removed(self): menu_pool.discover_menus() registered_menus = menu_pool.get_registered_menus(for_rendering=True) self.assertNotIn(OriginalCMSMenu, registered_menus.values()) self.assertIn(CMSMenu, registered_menus.values()) def test_no_menu_if_no_published_pages_in_public_mode(self): context = self._render_menu() nodes = context["children"] self.assertEqual(len(nodes), 0) def test_show_menu_with_draft_pages_in_edit_mode(self): context = self._render_menu(edit_mode=True) nodes = context["children"] self.assertEqual(len(nodes), 3) self._assert_node(nodes[0], self._page_1) self._assert_node(nodes[1], self._page_2) children = nodes[1].children self.assertEqual(len(children), 2) self._assert_node(children[0], self._page_2_1) self._assert_node(children[1], self._page_2_2) self._assert_node(nodes[2], self._page_3) def test_show_menu_with_draft_pages_in_preview_mode(self): context = self._render_menu(edit_mode=True) nodes = context["children"] self.assertEqual(len(nodes), 3) self._assert_node(nodes[0], self._page_1) self._assert_node(nodes[1], self._page_2) children = nodes[1].children self.assertEqual(len(children), 2) self._assert_node(children[0], self._page_2_1) self._assert_node(children[1], self._page_2_2) self._assert_node(nodes[2], self._page_3) def test_show_menu_with_published_nodes_only_in_public_mode(self): context = self._render_menu(preview_mode=True) nodes = context["children"] self.assertEqual(len(nodes), 3) self._assert_node(nodes[0], self._page_1) # Publish Page 1. self._page_1.publish(self.get_superuser()) context = self._render_menu() nodes = context["children"] self.assertEqual(len(nodes), 1) self._assert_node(nodes[0], self._page_1, False) def test_not_show_published_child_node_if_parent_is_draft_in_public_mode( self): # Publish Page 1. self._page_1.publish(self.get_superuser()) context = self._render_menu() nodes = context["children"] self.assertEqual(len(nodes), 1) self._assert_node(nodes[0], self._page_1, False) # Publish Page 2_1. This should not be rendered because # Page 2 is not published. self._page_2_1.publish(self.get_superuser()) context = self._render_menu() nodes = context["children"] self.assertEqual(len(nodes), 1) self._assert_node(nodes[0], self._page_1, False) def test_show_child_node_if_parent_is_published_in_public_mode(self): # Publish Page 2 and Page 2_1. self._page_2.publish(self.get_superuser()) self._page_2_1.publish(self.get_superuser()) context = self._render_menu() nodes = context["children"] self.assertEqual(len(nodes), 1) self._assert_node(nodes[0], self._page_2, False) children = nodes[0].children self.assertEqual(len(children), 1) self._assert_node(children[0], self._page_2_1, False) # Publish Page 2_1. self._page_2_2.publish(self.get_superuser()) context = self._render_menu() nodes = context["children"] self.assertEqual(len(nodes), 1) self._assert_node(nodes[0], self._page_2, False) children = nodes[0].children self.assertEqual(len(children), 2) self._assert_node(children[0], self._page_2_1, False) self._assert_node(children[1], self._page_2_2, False) def test_not_show_child_node_if_not_in_navigation(self): # Page 2_1 hidden in navigation. self._page_2_1.content.in_navigation = False self._page_2_1.content.save() context = self._render_menu(preview_mode=True) nodes = context["children"] self.assertEqual(len(nodes), 3) self._assert_node(nodes[0], self._page_1) self._assert_node(nodes[1], self._page_2) children = nodes[1].children self.assertEqual(len(children), 1) self._assert_node(children[0], self._page_2_2) self._assert_node(nodes[2], self._page_3) def test_not_show_nodes_if_hidden_in_navigation(self): # Hide Page 1 and Page 2_1 in navigation. self._page_1.content.in_navigation = False self._page_1.content.save() self._page_2_1.content.in_navigation = False self._page_2_1.content.save() context = self._render_menu(preview_mode=True) nodes = context["children"] self.assertEqual(len(nodes), 2) self._assert_node(nodes[0], self._page_2) children = nodes[0].children self.assertEqual(len(children), 1) self._assert_node(children[0], self._page_2_2) self._assert_node(nodes[1], self._page_3) def test_not_show_child_nodes_if_parent_not_in_navigation(self): # Page 2 hidden in navigation. self._page_2.content.in_navigation = False self._page_2.content.save() context = self._render_menu(preview_mode=True) nodes = context["children"] self.assertEqual(len(nodes), 2) self._assert_node(nodes[0], self._page_1) self._assert_node(nodes[1], self._page_3) def test_show_home_page_children_nodes_even_if_home_page_is_hidden_in_navigation( self): # Make Page 2 home and hide in navigation. self._page_2.content.page.is_home = True self._page_2.content.page.save() self._page_2.content.in_navigation = False self._page_2.content.save() context = self._render_menu(preview_mode=True) nodes = context["children"] self.assertEqual(len(nodes), 4) self._assert_node(nodes[0], self._page_1) self._assert_node(nodes[1], self._page_2_1) self._assert_node(nodes[2], self._page_2_2) self._assert_node(nodes[3], self._page_3) def test_show_published_nodes_if_draft_not_exist_in_non_public_mode(self): # Publish Page 2 and Page 2_2. self._page_2.publish(self.get_superuser()) self._page_2_2.publish(self.get_superuser()) context = self._render_menu(preview_mode=True) nodes = context["children"] self.assertEqual(len(nodes), 3) self._assert_node(nodes[0], self._page_1) self._assert_node(nodes[1], self._page_2) children = nodes[1].children self.assertEqual(len(children), 2) self._assert_node(children[0], self._page_2_1) self._assert_node(children[1], self._page_2_2) self._assert_node(nodes[2], self._page_3) def test_show_draft_nodes_if_draft_exist_in_non_public_mode(self): # Publish Page 2 and Page 2_2. self._page_2.publish(self.get_superuser()) self._page_2_2.publish(self.get_superuser()) # Create new drafts for both Page 2 and Page 2_2. _page_2_new_draft = self._page_2.copy(self.get_superuser()) _page_2_2_new_draft = self._page_2_2.copy(self.get_superuser()) # Make some changes to the new drafts (Just to verify). _page_2_new_draft.content.title = "page_content_2_new_draft" _page_2_new_draft.content.save() _page_2_2_new_draft.content.title = "page_content_2_2_new_draft" _page_2_2_new_draft.content.save() context = self._render_menu(preview_mode=True) nodes = context["children"] self.assertEqual(len(nodes), 3) self._assert_node(nodes[0], self._page_1) self._assert_node(nodes[1], _page_2_new_draft) children = nodes[1].children self.assertEqual(len(children), 2) self._assert_node(children[0], self._page_2_1) self._assert_node(children[1], _page_2_2_new_draft) self._assert_node(nodes[2], self._page_3) def test_attr_set_properly_to_node(self): # To test the attr.limit_visibility_in_menu we will set # to cms_constants.VISIBILITY_USERS, so anonymous users # cannot see the menu node for Page 1. self._page_1.content.limit_visibility_in_menu = cms_constants.VISIBILITY_USERS self._page_1.content.save() self._page_1.publish(self.get_superuser()) # Test for anonymous user. context = self._render_menu(is_auth_user=False) nodes = context["children"] self.assertEqual(len(nodes), 0) # Test for logged in user. context = self._render_menu() nodes = context["children"] self.assertEqual(len(nodes), 1) self._assert_node(nodes[0], self._page_1, False) @override_settings(CMS_PUBLIC_FOR="staff") def test_show_menu_only_visible_for_user(self): from django.contrib.auth.models import Group from cms.models import ACCESS_PAGE, PagePermission group = Group.objects.create(name="test_group") user = UserFactory() user.groups.add(group) q_args = {"grant_on": ACCESS_PAGE, "group": group} # Restrict pages for the user so that we can test # whether the can_view=True only pages are visible in the menu. PagePermission.objects.create(can_view=False, page=self._page_1.content.page, **q_args) PagePermission.objects.create(can_view=True, page=self._page_2.content.page, **q_args) PagePermission.objects.create(can_view=False, page=self._page_2_1.content.page, **q_args) PagePermission.objects.create(can_view=True, page=self._page_2_2.content.page, **q_args) PagePermission.objects.create(can_view=True, page=self._page_3.content.page, **q_args) context = self._render_menu(user=user, preview_mode=True) nodes = context["children"] # At this point, only Page 2, Page 2_2 and Page 3 should # be rendered in the menu. self.assertEqual(len(nodes), 2) self._assert_node(nodes[0], self._page_2) children = nodes[0].children self.assertEqual(len(children), 1) self._assert_node(children[0], self._page_2_2) self._assert_node(nodes[1], self._page_3)