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)