def _create_alias(self,
plugins=None,
name='test alias',
category=None,
position=0,
language=None,
published=True):
if language is None:
language = self.language
if category is None:
category = self.category
if plugins is None:
plugins = []
alias = AliasModel.objects.create(
category=category,
position=position,
)
alias_content = AliasContent.objects.create(
alias=alias,
name=name,
language=language,
)
if is_versioning_enabled():
from djangocms_versioning.models import Version
version = Version.objects.create(content=alias_content,
created_by=self.superuser)
if published:
version.publish(self.superuser)
if plugins:
alias_content.populate(plugins=plugins)
return alias
def test_create_alias_wizard_form(self):
wizard = self._get_wizard_instance('CreateAliasWizard')
data = {
'name': 'Content #1',
'category': self.category.pk,
'site': get_current_site().pk
}
form_class = step2_form_factory(
mixin_cls=WizardStep2BaseForm,
entry_form_class=wizard.form,
)
form = form_class(**self._get_form_kwargs(data))
self.assertTrue(form.is_valid())
alias = form.save()
self.assertEqual(form.fields['site'].initial, get_current_site())
with self.login_user_context(self.superuser):
response = self.client.get(alias.get_absolute_url())
self.assertContains(response, data['name'])
if is_versioning_enabled():
from djangocms_versioning.models import Version
self.assertEqual(Version.objects.filter_by_grouper(alias).count(), 1)
def test_extra_plugin_items_for_alias_plugins(self):
alias = self._create_alias()
placeholder = self.placeholder
page_content = None
if is_versioning_enabled():
# Can only edit page/content that is in DRAFT
page_content = create_title(self.language,
'Draft Page',
self.page,
created_by=self.superuser)
placeholder = page_content.get_placeholders().get(slot='content')
alias_plugin = alias.get_content(self.language).populate(
replaced_placeholder=placeholder, )
extra_items = Alias.get_extra_plugin_menu_items(
self.get_page_request(page=self.page,
obj=page_content,
user=self.superuser),
alias_plugin,
)
self.assertEqual(len(extra_items), 2)
first, second = extra_items
self.assertEqual(first.name, 'Edit Alias')
self.assertEqual(first.url, alias.get_absolute_url())
self.assertEqual(second.name, 'Detach Alias')
self.assertEqual(second.action, 'modal')
self.assertEqual(
second.url,
self.get_detach_alias_plugin_endpoint(alias_plugin.pk),
)
def test_alias_pages_have_no_menu_nodes(self):
alias = self._create_alias()
with self.login_user_context(self.superuser):
response = self.client.get(self.get_category_list_endpoint())
self.assertInHTML('<ul class="nav"></ul>', response.content.decode())
response = self.client.get(alias.get_absolute_url())
if is_versioning_enabled():
self.assertNotContains(response, '<ul class="nav">')
else:
self.assertInHTML('<ul class="nav"></ul>', response.content.decode())
def test_language_filter(self):
"""
When rendering aliascontent manager language filter changing the language
should filter the results.
"""
category = Category.objects.create(name='Language Filter Category')
alias = AliasModel.objects.create(
category=category,
position=0,
)
expected_en_content = AliasContent.objects.create(
alias=alias,
name="EN Alias Content",
language="en",
)
expected_de_content = AliasContent.objects.create(
alias=alias,
name="DE Alias Content",
language="de",
)
# If versioning is enabled be sure to create a version
if is_versioning_enabled():
from djangocms_versioning.models import Version
Version.objects.create(content=expected_en_content, created_by=self.superuser)
Version.objects.create(content=expected_de_content, created_by=self.superuser)
base_url = self.get_admin_url(AliasContent, "changelist")
with self.login_user_context(self.superuser):
# en is the default language configured for the site
response_default = self.client.get(base_url)
# en should have a result
response_en = self.client.get(base_url + "?language=en")
# de should have a result
response_de = self.client.get(base_url + "?language=de")
# fr should have no result and be empty because nothing was created
response_fr = self.client.get(base_url + "?language=fr")
self.assertEqual(
set(response_default.context["cl"].queryset),
set([expected_en_content])
)
self.assertEqual(
set(response_en.context["cl"].queryset),
set([expected_en_content])
)
self.assertEqual(
set(response_de.context["cl"].queryset),
set([expected_de_content])
)
self.assertEqual(
set(response_fr.context["cl"].queryset),
set([])
)
def test_can_detach_has_permission(self):
user = self.get_staff_user_with_std_permissions()
alias = self._create_alias(self.placeholder.get_plugins())
placeholder = self.placeholder
if is_versioning_enabled():
placeholder = self._get_draft_page_placeholder()
self.assertTrue(
Alias.can_detach(
user,
placeholder,
alias.get_placeholder(self.language).get_plugins(),
), )
def _create_page(self,
title,
language=None,
site=None,
published=True,
**kwargs):
if language is None:
language = self.language
if is_versioning_enabled() and not kwargs.get('created_by'):
kwargs['created_by'] = self.superuser
page = create_page(title=title,
language=language,
template='page.html',
menu_title='',
in_navigation=True,
limit_visibility_in_menu=None,
site=site,
**kwargs)
if is_versioning_enabled() and published:
self._publish(page, language)
return page
def test_language_switcher_when_toolbar_object_isnt_alias_content(self):
request = self.get_page_request(
page=self.page,
user=self.superuser,
preview=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
expected_result = ['English', 'Deutsche', 'Française', 'Italiano']
# Versioning changes the toolbar language selector and only shows
# languages that have translations
if is_versioning_enabled():
expected_result = ['English']
# Dont change default language switcher that is used for Pages
self.assertEqual(
[item.name for item in language_menu.items], expected_result
)
def test_language_switcher_when_toolbar_object_is_alias_content(self):
alias = self._create_alias([self.plugin])
alias_content = alias.contents.create(name='test alias 2', language='fr')
expected_result = ['English', 'Française']
if is_versioning_enabled():
from djangocms_versioning.constants import DRAFT
from djangocms_versioning.models import Version
Version.objects.create(
content=alias_content, created_by=self.superuser, state=DRAFT)
alias_content.populate(replaced_placeholder=self.placeholder)
alias_content.alias.clear_cache()
request = self.get_alias_request(
alias=alias,
user=self.superuser,
preview=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual([item.name for item in language_menu.items], expected_result)
def test_alias_auto_creation_in_template(self):
"""
When a template discovers a static code that doesn't exist:
- A category is created if it doesn't exist
- An alias is created if one doesn't exist that matches the static_code
- The creation_method is recorded as created by a template
- If versioning is enabled the tag is only created for a user that is logged in
"""
alias_template = """{% load djangocms_alias_tags %}{% static_alias "category_unique_code" %}""" # noqa: E501
# No Alias or Category exist
category = Category.objects.filter(
translations__name=DEFAULT_STATIC_ALIAS_CATEGORY_NAME)
alias = AliasModel.objects.filter(static_code="category_unique_code")
self.assertEqual(category.count(), 0)
self.assertEqual(alias.count(), 0)
# If versioning is enabled the tag is only created for a user that is logged in
if is_versioning_enabled():
self.render_template_obj(alias_template, {}, self.get_request('/'))
self.assertEqual(category.count(), 0)
self.assertEqual(alias.count(), 0)
with self.login_user_context(self.superuser):
# A default category, and a new alias is created for the template tag
self.render_template_obj(alias_template, {}, self.get_request('/'))
category_result = category.first()
alias_result = alias.first()
self.assertEqual(category.count(), 1)
self.assertEqual(category_result.name,
DEFAULT_STATIC_ALIAS_CATEGORY_NAME)
self.assertEqual(alias.count(), 1)
self.assertEqual(alias_result.static_code, "category_unique_code")
self.assertEqual(alias_result.creation_method,
AliasModel.CREATION_BY_TEMPLATE)
class AliasTemplateTagsTestCase(BaseAliasPluginTestCase):
alias_template = """{% load djangocms_alias_tags %}{% render_alias plugin.alias %}""" # noqa: E501
def test_render_alias(self):
alias = self._create_alias()
alias_plugin = alias.get_content(self.language).populate(
replaced_placeholder=self.placeholder, )
output = self.render_template_obj(
self.alias_template,
{
'plugin': alias_plugin,
},
self.get_request('/'),
)
self.assertEqual(output, 'test')
def test_render_alias_includes_recursed_alias(self):
alias = self._create_alias()
alias_plugin = alias.get_content(self.language).populate(
replaced_placeholder=self.placeholder, )
add_plugin(
alias.get_placeholder(self.language),
Alias,
language=self.language,
alias=alias,
)
output = self.render_template_obj(
self.alias_template,
{
'plugin': alias_plugin,
},
self.get_request('/'),
)
self.assertEqual(output, 'test')
@skipUnless(is_versioning_enabled(), 'Test only relevant for versioning')
def test_render_alias_dont_render_draft_aliases(self):
alias = self._create_alias([self.plugin], published=False)
alias_plugin = add_plugin(
self.placeholder,
Alias,
language=self.language,
alias=alias,
)
output = self.render_template_obj(
self.alias_template,
{'plugin': alias_plugin},
self.get_request('/'),
)
self.assertEqual(output, '')
self._publish(alias)
alias.clear_cache()
output = self.render_template_obj(
self.alias_template,
{'plugin': alias_plugin},
self.get_request('/'),
)
self.assertEqual(output, 'test')
set(response_other_site.context["cl"].queryset),
set([another_site_alias_content])
)
# Only alias attached to the current site are shown when filtered by no site
self.assertEqual(
set(response_no_site.context["cl"].queryset),
set([no_site_alias_content])
)
# No are shown when filtered by an empty site
self.assertEqual(
set(response_empty_site.context["cl"].queryset),
set([])
)
@skipUnless(is_versioning_enabled(), 'Test only relevant for versioning')
class UnpublishedFiltersTestCase(BaseAliasPluginTestCase):
def test_unpublished_filter(self):
"""
When rendering aliascontent manager unpublished filter changing the show/hide unblished version option
should filter the results.
"""
from djangocms_versioning.constants import UNPUBLISHED
from djangocms_versioning.models import Version
category = Category.objects.create(name='Alias Filter Category')
alias = AliasModel.objects.create(
category=category,
position=0
)
class AliasContentManagerTestCase(CMSTestCase):
def setUp(self):
self.superuser = self.get_superuser()
@skipUnless(not is_versioning_enabled(),
'Test only relevant when no versioning')
def test_alias_content_manager_rendering_without_versioning_actions(self):
"""
When rendering aliascontent manager without versioning
"""
category = Category.objects.create(name='Language Filter Category')
alias = AliasModel.objects.create(
category=category,
position=0,
)
expected_en_content = AliasContent.objects.create(
alias=alias,
name="EN Alias Content",
language="en",
)
base_url = self.get_admin_url(AliasContent, "changelist")
with self.login_user_context(self.superuser):
# en is the default language configured for the site
response = self.client.get(base_url)
response_content_decoded = response.content.decode()
# Check Column Headings
self.assertInHTML(
'Category',
response_content_decoded,
)
# Check Alias content row values
self.assertIn(category.name, response_content_decoded)
self.assertIn(
expected_en_content.name,
response_content_decoded,
)
self.assertNotIn(
expected_en_content.get_absolute_url(),
response_content_decoded,
)
usage_url = admin_reverse(USAGE_ALIAS_URL_NAME,
args=[expected_en_content.alias.pk])
change_category_and_site_url = admin_reverse(
'{}_{}_change'.format(expected_en_content._meta.app_label,
expected_en_content.alias._meta.model_name),
args=(expected_en_content.alias.pk, ))
self.assertNotIn(
usage_url,
response_content_decoded,
)
self.assertNotIn(
change_category_and_site_url,
response_content_decoded,
)
# check for add content admin link
add_alias_link = admin_reverse('{}_{}_add'.format(
expected_en_content._meta.app_label,
expected_en_content._meta.model_name))
self.assertNotIn(
# It is not currently possible to add an alias from the django admin changelist issue #97
# https://github.com/django-cms/djangocms-alias/issues/97
add_alias_link,
response_content_decoded,
)
self.assertNotIn(
'<option value="delete_selected">Delete selected alias contents</option>', # noqa: E501
response_content_decoded)
@skipUnless(is_versioning_enabled(), 'Test only relevant for versioning')
def test_alias_content_manager_rendering_with_versioning_actions(self):
"""
When rendering aliascontent manager with versioning actions
"""
category = Category.objects.create(name='Language Filter Category')
alias = AliasModel.objects.create(
category=category,
position=0,
)
expected_en_content = AliasContent.objects.create(
alias=alias,
name="EN Alias Content",
language="en",
)
from djangocms_versioning.models import Version
Version.objects.create(content=expected_en_content,
created_by=self.superuser)
with self.login_user_context(self.superuser):
base_url = self.get_admin_url(AliasContent, "changelist")
# en is the default language configured for the site
response = self.client.get(base_url)
response_content_decoded = response.content.decode()
# Check Column Headings
self.assertInHTML(
'Category',
response_content_decoded,
)
self.assertInHTML(
'Author',
response_content_decoded,
)
self.assertInHTML(
'Modified',
response_content_decoded,
)
self.assertInHTML(
'State',
response_content_decoded,
)
self.assertInHTML(
'Actions',
response_content_decoded,
)
# Check Alias content row values
self.assertIn(category.name, response_content_decoded)
self.assertIn(
expected_en_content.name,
response_content_decoded,
)
latest_alias_content_version = expected_en_content.versions.all()[0]
self.assertInHTML(
f'<td class="field-get_author">{latest_alias_content_version.created_by.username}</td>', # noqa: E501
response_content_decoded,
)
self.assertIn(
latest_alias_content_version.get_state_display(),
response_content_decoded,
)
self.assertIn(
localize(localtime(latest_alias_content_version.modified)),
response_content_decoded,
)
usage_url = admin_reverse(USAGE_ALIAS_URL_NAME,
args=[expected_en_content.alias.pk])
change_category_and_site_url = admin_reverse(
'{}_{}_change'.format(expected_en_content._meta.app_label,
expected_en_content.alias._meta.model_name),
args=(expected_en_content.alias.pk, ))
rename_alias_url = admin_reverse('{}_{}_change'.format(
expected_en_content._meta.app_label,
expected_en_content._meta.model_name),
args=(expected_en_content.pk, ))
self.assertIn(
usage_url,
response_content_decoded,
)
self.assertIn(
rename_alias_url,
response_content_decoded,
)
self.assertIn(
change_category_and_site_url,
response_content_decoded,
)
@skipUnless(is_versioning_enabled(), 'Test only relevant for versioning')
def test_alias_content_manager_rendering_preview_add_url(self):
"""
When rendering aliascontent manager with versioning actions and preview
"""
category = Category.objects.create(name='Language Filter Category')
alias = AliasModel.objects.create(
category=category,
position=0,
)
expected_en_content = AliasContent.objects.create(
alias=alias,
name="EN Alias Content",
language="en",
)
from djangocms_versioning.models import Version
Version.objects.create(content=expected_en_content,
created_by=self.superuser)
with self.login_user_context(self.superuser):
base_url = self.get_admin_url(AliasContent, "changelist")
# en is the default language configured for the site
response = self.client.get(base_url)
response_content_decoded = response.content.decode()
self.assertIn(
expected_en_content.get_absolute_url(),
response_content_decoded,
)
self.assertNotIn(
'<option value="delete_selected">Delete selected alias contents</option>', # noqa: E501
response_content_decoded)
# check for add content admin link
add_aliascontent_url = admin_reverse('{}_{}_add'.format(
expected_en_content._meta.app_label,
expected_en_content._meta.model_name))
self.assertNotIn(
add_aliascontent_url,
response_content_decoded,
)
class CatergoryFiltersTestCase(BaseAliasPluginTestCase):
@skipUnless(not is_versioning_enabled(), 'Test only relevant when no versioning')
def test_category_filter_no_verisoning(self):
"""
When rendering aliascontent manager category filter, changing the category
should filter the results.
"""
category_one = Category.objects.create(name='one')
alias_one = AliasModel.objects.create(
category=category_one,
position=0,
)
expected_category_one_content = AliasContent.objects.create(
alias=alias_one,
name="EN Alias Content one",
language="en",
)
category_two = Category.objects.create(name='two')
alias_two = AliasModel.objects.create(
category=category_two,
position=1,
)
expected_category_two_content = AliasContent.objects.create(
alias=alias_two,
name="EN Alias Content two",
language="en",
)
base_url = self.get_admin_url(AliasContent, "changelist")
with self.login_user_context(self.superuser):
response_default = self.client.get(base_url)
# category one should have a result
category_one_filter_response = self.client.get(f"{base_url}?category={category_one.id}")
# category two should have a result
category_two_filter_response = self.client.get(f"{base_url}?category={category_two.id}")
# By default all alias contents are shown
self.assertEqual(
set(response_default.context["cl"].queryset),
set([
expected_category_one_content,
expected_category_two_content,
])
)
# show alias contents filter by category one
self.assertEqual(
set(category_one_filter_response.context["cl"].queryset),
set([expected_category_one_content])
)
# show alias contents filter by category two
self.assertEqual(
set(category_two_filter_response.context["cl"].queryset),
set([expected_category_two_content])
)
@skipUnless(is_versioning_enabled(), 'Test only relevant when versioning enabled')
def test_category_filter_with_verisoning(self):
"""
When rendering aliascontent manager category filter, changing the category
should filter the results.
"""
from djangocms_versioning.models import Version
category_one = Category.objects.create(name='one')
alias_one = AliasModel.objects.create(
category=category_one,
position=0,
)
expected_category_one_content = AliasContent.objects.create(
alias=alias_one,
name="EN Alias Content one",
language="en",
)
Version.objects.create(content=expected_category_one_content, created_by=self.superuser)
category_two = Category.objects.create(name='two')
alias_two = AliasModel.objects.create(
category=category_two,
position=1,
)
expected_category_two_content = AliasContent.objects.create(
alias=alias_two,
name="EN Alias Content two",
language="en",
)
Version.objects.create(content=expected_category_two_content, created_by=self.superuser)
base_url = self.get_admin_url(AliasContent, "changelist")
with self.login_user_context(self.superuser):
response_default = self.client.get(base_url)
# category one should have a result
category_one_filter_response = self.client.get(f"{base_url}?category={category_one.id}")
# categopry two should have a result
category_two_filter_response = self.client.get(f"{base_url}?category={category_two.id}")
# By default all alias contents are shown
self.assertEqual(
set(response_default.context["cl"].queryset),
set([
expected_category_one_content,
expected_category_two_content,
])
)
# show alias contents filter by category one
self.assertEqual(
set(category_one_filter_response.context["cl"].queryset),
set([expected_category_one_content])
)
# show alias contents filter by category two
self.assertEqual(
set(category_two_filter_response.context["cl"].queryset),
set([expected_category_two_content])
)
def test_category_filter_lookups_ordered_alphabetical(self):
"""
Category filter lookup choices should be ordered in alphabetical order
"""
category_one = Category.objects.create(name='b - category')
alias_one = AliasModel.objects.create(
category=category_one,
position=0,
)
AliasContent.objects.create(
alias=alias_one,
name="EN Alias Content one",
language="en",
)
category_two = Category.objects.create(name='a - category')
alias_two = AliasModel.objects.create(
category=category_two,
position=1,
)
AliasContent.objects.create(
alias=alias_two,
name="EN Alias Content two",
language="en",
)
version_admin = admin.site._registry[AliasContent]
category_filter = CategoryFilter(None, {"category": ""}, AliasContent, version_admin)
# Get the first choice in the filter lookup object
first_lookup_value = category_filter.lookup_choices[0][1]
# Lookup value should match the category name linked to alias content
self.assertEqual(
first_lookup_value, category_two.name
)
self.assertNotEqual(
first_lookup_value, category_one.name
)
def test_category_filter_lookup_should_only_show_aliases_linked_to_content(self):
"""
Category not linked to content should not be listed in the category filter lookups
"""
category_one = Category.objects.create(name='b - category')
alias_one = AliasModel.objects.create(
category=category_one,
position=0,
)
AliasContent.objects.create(
alias=alias_one,
name="EN Alias Content one",
language="en",
)
category_two = Category.objects.create(name='a - category')
AliasModel.objects.create(
category=category_two,
position=1,
)
version_admin = admin.site._registry[AliasContent]
category_filter = CategoryFilter(None, {"category": ""}, AliasContent, version_admin)
# Get the first choice in the filter lookup object
first_lookup_value = category_filter.lookup_choices[0][1]
# Lookup choices should only display the category linked to content
self.assertEqual(len(category_filter.lookup_choices), 1)
# Lookup value should match the category name linked to alias content
self.assertEqual(
first_lookup_value, category_one.name
)
# Category not linked to alias content should not be listed in the choices
self.assertNotEqual(
first_lookup_value, category_two.name
)
def test_alias_toolbar_language_menu(self):
request = self.get_page_request(self.page, user=self.superuser)
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
self.assertEqual(alias_menu, None)
alias = self._create_alias([self.plugin])
request = self.get_page_request(
page=None,
path=self.get_category_list_endpoint(),
user=self.superuser,
edit=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual(language_menu.get_item_count(), 4)
request = self.get_alias_request(
alias=alias,
user=self.superuser,
preview=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual(language_menu.get_item_count(), 1)
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual(language_menu.get_item_count(), 4)
language_menu_dict = {
menu.name: [menu_item.name for menu_item in menu.items]
for key, menu in language_menu.menus.items()
}
self.assertIn('Add Translation', language_menu_dict.keys())
self.assertIn('Delete Translation', language_menu_dict.keys())
self.assertEqual(
set(['Deutsche...', 'Française...', 'Italiano...']),
set(language_menu_dict['Add Translation']),
)
self.assertEqual(
set(['English...']),
set(language_menu_dict['Delete Translation']),
)
alias_content = alias.contents.create(name='test alias 2', language='fr')
alias_content.populate(replaced_placeholder=self.placeholder)
alias_content.alias.clear_cache()
if is_versioning_enabled():
from djangocms_versioning.constants import PUBLISHED
from djangocms_versioning.models import Version
Version.objects.create(
content=alias_content, created_by=self.superuser, state=PUBLISHED)
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual(language_menu.get_item_count(), 6)
language_menu_dict = {
menu.name: [menu_item.name for menu_item in menu.items]
for key, menu in language_menu.menus.items()
}
self.assertEqual(
set(['Deutsche...', 'Italiano...']),
set(language_menu_dict['Add Translation']),
)
self.assertEqual(
set(['Française...', 'English...']),
set(language_menu_dict['Delete Translation']),
)
self.assertEqual(
set(['from Française']),
set(language_menu_dict['Copy all plugins']),
)
language_menu_first_items = {
menu.name: next(filter(
lambda item: item.name in ['Française...', 'Deutsche...', 'from Française'],
menu.items,
))
for key, menu in language_menu.menus.items()
}
# First item is Deutsche... for Add Translation
self.assertIn(
'/en/admin/djangocms_alias/aliascontent/add/',
language_menu_first_items['Add Translation'].url,
)
self.assertIn(
'language=de',
language_menu_first_items['Add Translation'].url,
)
self.assertIn(
'alias={}'.format(alias.pk),
language_menu_first_items['Add Translation'].url,
)
self.assertEqual(
# First item is Française... for Delete Translation
'/en/admin/djangocms_alias/aliascontent/{}/delete/?language=fr'.format(
alias.get_content('fr').pk,
),
language_menu_first_items['Delete Translation'].url,
)
self.assertRegexpMatches(
language_menu_first_items['Copy all plugins'].action,
r'en\/admin\/([\w\/]+)\/copy-plugins\/',
)
class AliasToolbarTestCase(BaseAliasPluginTestCase):
def _get_wizard_create_button(self, request):
button_lists = [
result.item
for result in request.toolbar.find_items(item_type=ButtonList)
]
buttons = list(
# flatten the list
itertools.chain.from_iterable([
item.buttons
for item in button_lists
])
)
# There will always be this button, because we are in the context of
# alias app views
return [
button for button in buttons if button.name == 'Create'
][0]
def test_add_aliases_submenu_to_admin_menu_no_permission(self):
with self.login_user_context(self.get_staff_user_with_std_permissions()):
response = self.client.get(self.page.get_absolute_url())
self.assertNotContains(response, '<span>Aliases')
def test_add_aliases_submenu_to_admin_menu(self):
user = self.get_staff_user_with_std_permissions()
user.user_permissions.add(Permission.objects.get(
content_type__app_label='djangocms_alias',
codename='change_category'))
page_url = get_object_edit_url(self.page.get_title_obj(self.language))
with self.login_user_context(user):
response = self.client.get(page_url)
self.assertContains(response, '<span>Aliases')
def test_aliases_link_placement(self):
request = self.get_page_request(self.page, user=self.superuser)
admin_menu = request.toolbar.get_or_create_menu(ADMIN_MENU_IDENTIFIER)
break_item = admin_menu.find_first(Break, identifier=ADMINISTRATION_BREAK) # noqa: E501
item_positioned_before_admin_break = admin_menu.items[break_item.index - 1] # noqa: E501
self.assertEqual(item_positioned_before_admin_break.name, 'Aliases...')
def test_add_alias_menu_showing_only_on_alias_plugin_views(self):
alias = self._create_alias([self.plugin])
for endpoint in [
self.get_category_list_endpoint(),
self.get_list_aliases_endpoint(alias.category_id),
self.page.get_absolute_url(language=self.language),
]:
request = self.get_page_request(page=None, path=endpoint, user=self.superuser)
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
self.assertEqual(alias_menu, None)
def _test_alias_endpoint(**kwargs):
kwargs.update({
'alias': alias,
'path': endpoint,
'user': self.superuser,
})
# py34 compat
request = self.get_alias_request(**ChainMap(kwargs))
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
self.assertEqual(alias_menu.name, 'Alias')
_test_alias_endpoint()
_test_alias_endpoint(edit=True)
_test_alias_endpoint(preview=True)
def test_alias_toolbar_language_menu(self):
request = self.get_page_request(self.page, user=self.superuser)
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
self.assertEqual(alias_menu, None)
alias = self._create_alias([self.plugin])
request = self.get_page_request(
page=None,
path=self.get_category_list_endpoint(),
user=self.superuser,
edit=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual(language_menu.get_item_count(), 4)
request = self.get_alias_request(
alias=alias,
user=self.superuser,
preview=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual(language_menu.get_item_count(), 1)
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual(language_menu.get_item_count(), 4)
language_menu_dict = {
menu.name: [menu_item.name for menu_item in menu.items]
for key, menu in language_menu.menus.items()
}
self.assertIn('Add Translation', language_menu_dict.keys())
self.assertIn('Delete Translation', language_menu_dict.keys())
self.assertEqual(
set(['Deutsche...', 'Française...', 'Italiano...']),
set(language_menu_dict['Add Translation']),
)
self.assertEqual(
set(['English...']),
set(language_menu_dict['Delete Translation']),
)
alias_content = alias.contents.create(name='test alias 2', language='fr')
alias_content.populate(replaced_placeholder=self.placeholder)
alias_content.alias.clear_cache()
if is_versioning_enabled():
from djangocms_versioning.constants import PUBLISHED
from djangocms_versioning.models import Version
Version.objects.create(
content=alias_content, created_by=self.superuser, state=PUBLISHED)
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual(language_menu.get_item_count(), 6)
language_menu_dict = {
menu.name: [menu_item.name for menu_item in menu.items]
for key, menu in language_menu.menus.items()
}
self.assertEqual(
set(['Deutsche...', 'Italiano...']),
set(language_menu_dict['Add Translation']),
)
self.assertEqual(
set(['Française...', 'English...']),
set(language_menu_dict['Delete Translation']),
)
self.assertEqual(
set(['from Française']),
set(language_menu_dict['Copy all plugins']),
)
language_menu_first_items = {
menu.name: next(filter(
lambda item: item.name in ['Française...', 'Deutsche...', 'from Française'],
menu.items,
))
for key, menu in language_menu.menus.items()
}
# First item is Deutsche... for Add Translation
self.assertIn(
'/en/admin/djangocms_alias/aliascontent/add/',
language_menu_first_items['Add Translation'].url,
)
self.assertIn(
'language=de',
language_menu_first_items['Add Translation'].url,
)
self.assertIn(
'alias={}'.format(alias.pk),
language_menu_first_items['Add Translation'].url,
)
self.assertEqual(
# First item is Française... for Delete Translation
'/en/admin/djangocms_alias/aliascontent/{}/delete/?language=fr'.format(
alias.get_content('fr').pk,
),
language_menu_first_items['Delete Translation'].url,
)
self.assertRegex(
language_menu_first_items['Copy all plugins'].action,
r'en\/admin\/([\w\/]+)\/copy-plugins\/',
)
def test_language_switcher_when_toolbar_object_is_alias_content(self):
alias = self._create_alias([self.plugin])
alias_content = alias.contents.create(name='test alias 2', language='fr')
expected_result = ['English', 'Française']
if is_versioning_enabled():
from djangocms_versioning.constants import DRAFT
from djangocms_versioning.models import Version
Version.objects.create(
content=alias_content, created_by=self.superuser, state=DRAFT)
alias_content.populate(replaced_placeholder=self.placeholder)
alias_content.alias.clear_cache()
request = self.get_alias_request(
alias=alias,
user=self.superuser,
preview=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
self.assertEqual([item.name for item in language_menu.items], expected_result)
def test_language_switcher_when_toolbar_object_isnt_alias_content(self):
request = self.get_page_request(
page=self.page,
user=self.superuser,
preview=True,
)
language_menu = request.toolbar.get_menu(LANGUAGE_MENU_IDENTIFIER)
expected_result = ['English', 'Deutsche', 'Française', 'Italiano']
# Versioning changes the toolbar language selector and only shows
# languages that have translations
if is_versioning_enabled():
expected_result = ['English']
# Dont change default language switcher that is used for Pages
self.assertEqual(
[item.name for item in language_menu.items], expected_result
)
def test_change_alias_settings_button_is_visible_on_alias_edit_view(self):
button_label = 'Change alias settings...'
alias_change_viewname = 'djangocms_alias_alias_change'
alias = self._create_alias()
with force_language('en'):
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
search_result = alias_menu.find_first(item_type=ModalItem, name=button_label)
self.assertIsNotNone(search_result)
button = search_result.item
self.assertEqual(button.on_close, 'REFRESH_PAGE')
self.assertEqual(
button.url,
admin_reverse(
alias_change_viewname,
args=[alias.pk],
),
)
def test_alias_usage_button(self):
alias = self._create_alias()
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
button_label = 'View usage...'
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
search_result = alias_menu.find_first(item_type=ModalItem, name=button_label)
self.assertIsNotNone(search_result)
button = search_result.item
self.assertEqual(
button.url,
admin_reverse(
USAGE_ALIAS_URL_NAME,
args=[alias.pk],
),
)
self.assertEqual(
button.on_close,
'REFRESH_PAGE',
)
def test_create_wizard_button_enabled(self):
request = self.get_page_request(
page=None,
path=self.get_category_list_endpoint(),
user=self.superuser,
)
create_button = self._get_wizard_create_button(request)
self.assertEqual(create_button.disabled, False)
@skipUnless(not is_versioning_enabled(), 'Test only relevant when no versioning')
def test_delete_button_show_on_edit_alias_view_no_versioning(self):
"""
When versioning is not installed deletion should be possible. The delete button
should be available in the toolbar.
"""
alias = self._create_alias()
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
button_label = 'Delete alias...'
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
search_result = alias_menu.find_first(item_type=ModalItem, name=button_label)
self.assertIsNotNone(search_result)
button = search_result.item
self.assertEqual(button.name, button_label)
self.assertEqual(button.url, self.get_delete_alias_endpoint(alias.pk))
self.assertEqual(
button.on_close,
self.get_list_aliases_endpoint(alias.category_id),
)
@skipUnless(is_versioning_enabled(), 'Test only relevant for versioning')
def test_delete_button_not_shown_on_edit_alias_view_with_versioning(self):
"""
When versioning is installed no deletion should be possible. The delete button
should not be available in the toolbar.
"""
alias = self._create_alias()
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
button_label = 'Delete alias...'
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
search_result = alias_menu.find_first(item_type=ModalItem, name=button_label)
# No button should be found for delete
self.assertIsNone(search_result)
def test_rename_alias_show_on_edit_alias_view(self):
alias = self._create_alias()
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
button_label = 'Rename alias...'
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
search_result = alias_menu.find_first(item_type=ModalItem, name=button_label)
self.assertIsNotNone(search_result)
button = search_result.item
self.assertEqual(button.name, button_label)
self.assertEqual(button.url, admin_reverse(
'djangocms_alias_aliascontent_change',
args=[alias.get_content().pk],
))
self.assertEqual(button.on_close, 'REFRESH_PAGE')
def test_disable_buttons_when_in_preview_mode(self):
alias = self._create_alias()
request = self.get_alias_request(
alias=alias,
user=self.superuser,
preview=True,
)
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
search_results = alias_menu.find_items(item_type=ModalItem)
self.assertNotEqual(bool(search_results), False)
for result in search_results:
if result.item.name == 'View usage...':
self.assertEqual(result.item.disabled, False)
else:
self.assertEqual(result.item.disabled, True)
def test_disable_buttons_when_not_have_perms(self):
alias = self._create_alias()
staff_user = self._create_user("user1", is_staff=True, is_superuser=False)
request = self.get_alias_request(
alias=alias,
user=staff_user,
edit=True,
)
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
search_results = alias_menu.find_items(item_type=ModalItem)
self.assertNotEqual(bool(search_results), False)
for result in search_results:
if result.item.name == 'View usage...':
self.assertEqual(result.item.disabled, False)
else:
self.assertEqual(result.item.disabled, True)
def test_enable_buttons_when_on_edit_mode(self):
alias = self._create_alias()
request = self.get_alias_request(
alias=alias,
user=self.superuser,
edit=True,
)
alias_menu = request.toolbar.get_menu(ALIAS_MENU_IDENTIFIER)
search_results = alias_menu.find_items(item_type=ModalItem)
self.assertNotEqual(bool(search_results), False)
for result in search_results:
self.assertEqual(result.item.disabled, False)
def test_site_dropdown_url_renders_admin_changelist(self):
request = self.get_page_request(self.page, user=self.superuser)
admin_menu = request.toolbar.get_or_create_menu(ADMIN_MENU_IDENTIFIER)
site_aliases_url = admin_menu.items[3].url
with self.login_user_context(self.superuser):
response = self.client.get(
site_aliases_url,
)
content = response.content.decode('utf-8')
self.assertEqual(response.status_code, 200)
# Rendered content should contain admin changelist header
self.assertIn("Select alias content to change | Django site admin", content)
def test_site_dropdown_url_renders_admin_changelist_url(self):
request = self.get_page_request(self.page, user=self.superuser)
admin_menu = request.toolbar.get_or_create_menu(ADMIN_MENU_IDENTIFIER)
site_aliases_url = admin_menu.items[3].url
admin_changelist_aliases_url = reverse("admin:{}_aliascontent_changelist".format(
AliasContent._meta.app_label)
)
with self.login_user_context(self.superuser):
response = self.client.get(
site_aliases_url,
)
self.assertEqual(response.status_code, 200)
# Url from site menu renders Alias content
self.assertEqual(site_aliases_url, admin_changelist_aliases_url)
def test_aliases_using_alias(self):
root_alias = self._create_alias(name='root alias')
if not is_versioning_enabled():
# TODO: fix it after versioning will have multilanguage support
AliasContent.objects.create(
name='root alias de',
alias=root_alias,
language='de',
)
AliasContent.objects.create(
name='root alias it',
alias=root_alias,
language='it',
)
root_alias2 = self._create_alias(name='root alias 2')
alias1 = self._create_alias(name='alias 1')
alias2 = self._create_alias(name='alias 2')
alias3 = self._create_alias(name='alias 3')
alias4 = self._create_alias(name='alias 4')
add_plugin(
root_alias.get_placeholder(self.language),
'Alias',
language=self.language,
alias=alias1,
)
if not is_versioning_enabled():
# TODO: fix it after versioning will have multilanguage support
add_plugin(
root_alias.get_placeholder('de'),
'Alias',
language='de',
alias=alias1,
)
add_plugin(
root_alias.get_placeholder('it'),
'Alias',
language='it',
alias=alias1,
)
# Alias1 should show only once
add_plugin(
root_alias.get_placeholder(self.language),
'Alias',
language=self.language,
alias=alias2,
)
add_plugin(
root_alias2.get_placeholder(self.language),
'Alias',
language=self.language,
alias=alias2,
)
add_plugin(
alias2.get_placeholder(self.language),
'Alias',
language=self.language,
alias=alias3,
)
add_plugin(
alias3.get_placeholder(self.language),
'Alias',
language=self.language,
alias=alias4,
)
with self.assertNumQueries(3):
objects = alias1.objects_using
self.assertEqual(
sorted(obj.pk for obj in objects),
[root_alias.pk],
)
with self.assertNumQueries(3):
objects = alias2.objects_using
self.assertEqual(
sorted(obj.pk for obj in objects),
[root_alias.pk, root_alias2.pk],
)
with self.assertNumQueries(3):
objects = alias3.objects_using
self.assertEqual(
sorted(obj.pk for obj in objects),
[alias2.pk],
)
with self.assertNumQueries(3):
objects = alias4.objects_using
self.assertEqual(
sorted(obj.pk for obj in objects),
[alias3.pk],
)
def test_site_filter(self):
"""
When rendering aliascontent manager site filter changing the site
should filter the results.
"""
current_site = get_current_site()
another_site = Site.objects.create(
name="Other site",
domain="othersite.here"
)
empty_site = Site.objects.create(
name="Empty site",
domain="emptysite.here"
)
category = Category.objects.create(name='Site Filter Category')
current_site_alias = AliasModel.objects.create(
category=category,
site=current_site,
)
current_site_alias_content = AliasContent.objects.create(
alias=current_site_alias,
name="Current Site Alias Content",
language="en",
)
another_site_alias = AliasModel.objects.create(
category=category,
site=another_site,
)
another_site_alias_content = AliasContent.objects.create(
alias=another_site_alias,
name="Another Site Alias Content",
language="en",
)
no_site_alias = AliasModel.objects.create(
category=category,
)
no_site_alias_content = AliasContent.objects.create(
alias=no_site_alias,
name="No Site Alias Content",
language="en",
)
# If versioning is enabled be sure to create a version
if is_versioning_enabled():
from djangocms_versioning.models import Version
Version.objects.create(content=current_site_alias_content, created_by=self.superuser)
Version.objects.create(content=another_site_alias_content, created_by=self.superuser)
Version.objects.create(content=no_site_alias_content, created_by=self.superuser)
base_url = self.get_admin_url(AliasContent, "changelist")
with self.login_user_context(self.superuser):
# en is the default language configured for the site
response_default = self.client.get(base_url)
# filter by aliases with the current site
response_current_site = self.client.get(f"{base_url}?{SITE_FILTER_URL_PARAM}={current_site.pk}")
# filter by aliases with a different site set
response_other_site = self.client.get(f"{base_url}?{SITE_FILTER_URL_PARAM}={another_site.pk}")
# filter by aliases with an empty site set
response_empty_site = self.client.get(f"{base_url}?{SITE_FILTER_URL_PARAM}={empty_site.pk}")
# filter by aliases with no site set
response_no_site = self.client.get(f"{base_url}?{SITE_FILTER_URL_PARAM}={SITE_FILTER_NO_SITE_VALUE}")
# By default all alias are shown
self.assertEqual(
set(response_default.context["cl"].queryset),
set([
current_site_alias_content,
another_site_alias_content,
no_site_alias_content,
])
)
# Only alias attached to the current site are shown when filtered by the current site
self.assertEqual(
set(response_current_site.context["cl"].queryset),
set([current_site_alias_content])
)
# Only alias attached to the current site are shown when filtered by another site
self.assertEqual(
set(response_other_site.context["cl"].queryset),
set([another_site_alias_content])
)
# Only alias attached to the current site are shown when filtered by no site
self.assertEqual(
set(response_no_site.context["cl"].queryset),
set([no_site_alias_content])
)
# No are shown when filtered by an empty site
self.assertEqual(
set(response_empty_site.context["cl"].queryset),
set([])
)
class AliasPluginTestCase(BaseAliasPluginTestCase):
def test_extra_plugin_items_for_regular_plugins(self):
extra_items = Alias.get_extra_plugin_menu_items(
self.get_request(self.page.get_absolute_url()),
self.plugin,
)
self.assertEqual(len(extra_items), 1)
extra_item = extra_items[0]
self.assertEqual(extra_item.name, 'Create Alias')
self.assertEqual(extra_item.action, 'modal')
parsed_url = urlparse(extra_item.url)
self.assertEqual(parsed_url.path, self.get_create_alias_endpoint())
self.assertIn('plugin={}'.format(self.plugin.pk), parsed_url.query)
def test_extra_plugin_items_for_alias_plugins(self):
alias = self._create_alias()
placeholder = self.placeholder
page_content = None
if is_versioning_enabled():
# Can only edit page/content that is in DRAFT
page_content = create_title(self.language,
'Draft Page',
self.page,
created_by=self.superuser)
placeholder = page_content.get_placeholders().get(slot='content')
alias_plugin = alias.get_content(self.language).populate(
replaced_placeholder=placeholder, )
extra_items = Alias.get_extra_plugin_menu_items(
self.get_page_request(page=self.page,
obj=page_content,
user=self.superuser),
alias_plugin,
)
self.assertEqual(len(extra_items), 2)
first, second = extra_items
self.assertEqual(first.name, 'Edit Alias')
self.assertEqual(first.url, alias.get_absolute_url())
self.assertEqual(second.name, 'Detach Alias')
self.assertEqual(second.action, 'modal')
self.assertEqual(
second.url,
self.get_detach_alias_plugin_endpoint(alias_plugin.pk),
)
def test_extra_plugin_items_for_placeholder(self):
extra_items = Alias.get_extra_placeholder_menu_items(
self.get_page_request(page=self.page, user=self.superuser),
self.placeholder,
)
self.assertEqual(len(extra_items), 1)
extra_item = extra_items[0]
self.assertEqual(extra_item.name, 'Create Alias')
self.assertEqual(extra_item.action, 'modal')
parsed_url = urlparse(extra_item.url)
self.assertEqual(parsed_url.path, self.get_create_alias_endpoint())
self.assertIn(
'placeholder={}'.format(self.placeholder.pk),
parsed_url.query,
)
@skipUnless(is_versioning_enabled(), 'Test only relevant for versioning')
def test_extra_plugin_items_with_versioning_checks(self):
alias = self._create_alias()
alias_plugin = alias.get_content(self.language).populate(
replaced_placeholder=self.placeholder, )
extra_items = Alias.get_extra_plugin_menu_items(
self.get_page_request(page=self.page,
obj=self.page.get_title_obj(),
user=self.superuser),
alias_plugin,
)
self.assertEqual(len(extra_items), 1)
first = extra_items[0]
# We cannot detach alias on undraft page
self.assertEqual(first.name, 'Edit Alias')
self.assertEqual(first.url, alias.get_absolute_url())
def test_rendering_plugin_on_page(self):
alias = self._create_alias(published=True)
add_plugin(
alias.get_placeholder(self.language),
'TextPlugin',
language=self.language,
body='Content Alias 1234',
)
add_plugin(
alias.get_placeholder(self.language),
Alias,
language=self.language,
alias=alias,
)
add_plugin(
self.placeholder,
Alias,
language=self.language,
alias=alias,
)
with self.login_user_context(self.superuser):
response = self.client.get(
self.page.get_absolute_url(self.language))
self.assertContains(response, 'Content Alias 1234')
def test_detach_alias(self):
alias = self._create_alias()
alias_placeholder = alias.get_placeholder(self.language)
add_plugin(
alias_placeholder,
'TextPlugin',
language=self.language,
body='test 1',
)
add_plugin(
alias_placeholder,
'TextPlugin',
language=self.language,
body='test 2',
)
plugins = self.placeholder.get_plugins()
self.assertEqual(plugins.count(), 1)
alias_plugin = add_plugin(
self.placeholder,
Alias,
language=self.language,
alias=alias,
)
add_plugin(
alias_placeholder,
'TextPlugin',
language=self.language,
body='test 3',
)
self.assertEqual(plugins.count(), 2)
Alias.detach_alias_plugin(alias_plugin, self.language)
self.assertEqual(plugins.count(), 4)
def test_detach_alias_correct_position(self):
alias = self._create_alias([])
alias_placeholder = alias.get_placeholder(self.language)
add_plugin(
alias_placeholder,
'TextPlugin',
language=self.language,
body='test 1',
)
add_plugin(
alias_placeholder,
'TextPlugin',
language=self.language,
body='test 2',
)
plugins = self.placeholder.get_plugins()
self.assertEqual(plugins.count(), 1)
alias_plugin = add_plugin(
self.placeholder,
Alias,
language=self.language,
alias=alias,
)
add_plugin(
self.placeholder,
'TextPlugin',
language=self.language,
body='test 3',
)
self.assertEqual(plugins.count(), 3)
Alias.detach_alias_plugin(alias_plugin, self.language)
self.assertEqual(plugins.count(), 4)
ordered_plugins = sorted(
downcast_plugins(plugins),
key=attrgetter('position'),
)
self.assertEqual(
[str(plugin) for plugin in ordered_plugins],
['test', 'test 1', 'test 2', 'test 3'],
)
def test_create_alias_with_default_render_template(self):
alias = self._create_alias()
add_plugin(
self.placeholder,
Alias,
language=self.language,
alias=alias,
)
self.assertEqual(alias.cms_plugins.first().template, 'default')
def test_create_alias_with_custom_render_template(self):
alias_template = 'custom_alias_template'
alias = self._create_alias()
add_plugin(
self.placeholder,
Alias,
language=self.language,
alias=alias,
template=alias_template,
)
self.assertEqual(alias.cms_plugins.first().template, alias_template)
def test_create_alias_plugin_form_initial_category(self):
alias = self._create_alias(self.placeholder.get_plugins(), )
alias_plugin = add_plugin(
self.placeholder,
Alias,
language=self.language,
alias=alias,
)
form = AliasPluginForm(instance=alias_plugin)
self.assertEqual(form.fields['category'].initial, alias.category_id)
def test_create_alias_plugin_form_empty_category(self):
form = AliasPluginForm()
self.assertEqual(form.fields['category'].initial, None)
def test_alias_widget_attrs_include_select2_view_url(self):
widget = AliasSelectWidget()
attrs = widget.build_attrs({})
self.assertIn('data-select2-url', attrs)
self.assertEqual(
attrs['data-select2-url'],
admin_reverse(SELECT2_ALIAS_URL_NAME),
)
def test_create_alias_from_plugin_list(self):
plugins = self.placeholder.get_plugins()
alias = self._create_alias(plugins)
self.assertEqual(
plugins[0].plugin_type,
alias.get_placeholder(self.language).get_plugins()[0].plugin_type,
)
self.assertEqual(
plugins[0].get_bound_plugin().body,
alias.get_placeholder(
self.language).get_plugins()[0].get_bound_plugin().body,
)
def test_replace_plugin_with_alias(self):
alias = self._create_alias([self.plugin])
alias_content = alias.get_content(self.language)
alias_plugin = alias_content.populate(replaced_plugin=self.plugin, )
plugins = self.placeholder.get_plugins()
self.assertNotIn(
self.plugin,
plugins,
)
self.assertEqual(plugins[0].get_bound_plugin(), alias_plugin)
self.assertEqual(
alias_content.placeholder.get_plugins()[0].get_bound_plugin().body,
'test') # noqa: E501
def test_replace_plugin_with_alias_correct_position(self):
second_plugin = add_plugin(
self.placeholder,
'TextPlugin',
language=self.language,
body='test 2',
)
add_plugin(
self.placeholder,
'TextPlugin',
language=self.language,
body='test 3',
)
alias = self._create_alias()
alias_plugin = alias.get_content(
self.language).populate(replaced_plugin=second_plugin)
plugins = self.placeholder.get_plugins()
self.assertNotIn(
self.plugin,
plugins,
)
self.assertEqual(plugins[1].get_bound_plugin(), alias_plugin)
ordered_plugins = sorted(
downcast_plugins(plugins),
key=attrgetter('position'),
)
self.assertEqual(
[plugin.plugin_type for plugin in ordered_plugins],
['TextPlugin', 'Alias', 'TextPlugin'],
)
def test_replace_placeholder_content_with_alias(self):
add_plugin(
self.placeholder,
'TextPlugin',
language=self.language,
body='test 2',
)
alias = self._create_alias()
alias_content = alias.get_content(self.language)
alias_content.populate(replaced_placeholder=self.placeholder)
plugins = self.placeholder.get_plugins()
self.assertEqual(plugins.count(), 1)
self.assertEqual(alias_content.placeholder.get_plugins().count(), 2)
self.assertEqual(
alias_content.placeholder.get_plugins()[1].get_bound_plugin().body,
'test 2',
)
class AliasTemplateTagAliasPlaceholderTestCase(BaseAliasPluginTestCase):
alias_template = """{% load djangocms_alias_tags %}{% static_alias "some_unique_id" %}""" # noqa: E501
def test_no_alias_rendered_when_no_alias_exists(self):
alias = self._create_alias(static_code="")
alias_plugin = alias.get_content(self.language).populate(
replaced_placeholder=self.placeholder, )
add_plugin(
alias.get_placeholder(self.language),
'TextPlugin',
language=self.language,
body='Content Alias 1234',
)
output = self.render_template_obj(
self.alias_template,
{
'plugin': alias_plugin,
},
self.get_request('/'),
)
self.assertEqual(output, "")
def test_alias_rendered_when_alias_with_identifier_exists(self):
alias = self._create_alias(static_code="some_unique_id")
alias_plugin = alias.get_content(self.language).populate(
replaced_placeholder=self.placeholder, )
add_plugin(
alias.get_placeholder(self.language),
'TextPlugin',
language=self.language,
body='Content Alias 1234',
)
output = self.render_template_obj(
self.alias_template,
{
'plugin': alias_plugin,
},
self.get_request('/'),
)
self.assertEqual(output, "testContent Alias 1234")
def test_alias_auto_creation_in_template(self):
"""
When a template discovers a static code that doesn't exist:
- A category is created if it doesn't exist
- An alias is created if one doesn't exist that matches the static_code
- The creation_method is recorded as created by a template
- If versioning is enabled the tag is only created for a user that is logged in
"""
alias_template = """{% load djangocms_alias_tags %}{% static_alias "category_unique_code" %}""" # noqa: E501
# No Alias or Category exist
category = Category.objects.filter(
translations__name=DEFAULT_STATIC_ALIAS_CATEGORY_NAME)
alias = AliasModel.objects.filter(static_code="category_unique_code")
self.assertEqual(category.count(), 0)
self.assertEqual(alias.count(), 0)
# If versioning is enabled the tag is only created for a user that is logged in
if is_versioning_enabled():
self.render_template_obj(alias_template, {}, self.get_request('/'))
self.assertEqual(category.count(), 0)
self.assertEqual(alias.count(), 0)
with self.login_user_context(self.superuser):
# A default category, and a new alias is created for the template tag
self.render_template_obj(alias_template, {}, self.get_request('/'))
category_result = category.first()
alias_result = alias.first()
self.assertEqual(category.count(), 1)
self.assertEqual(category_result.name,
DEFAULT_STATIC_ALIAS_CATEGORY_NAME)
self.assertEqual(alias.count(), 1)
self.assertEqual(alias_result.static_code, "category_unique_code")
self.assertEqual(alias_result.creation_method,
AliasModel.CREATION_BY_TEMPLATE)
def test_alias_auto_creation_in_template_site_limited_alias(self):
"""
When a template discovers a static code for a site and with no site with the same static_code
entries are created for both scenarios
"""
unlimited_template = """{% load djangocms_alias_tags %}{% static_alias "limited_alias_code" %}""" # noqa: E501
site_limited_template = """{% load djangocms_alias_tags %}{% static_alias "limited_alias_code" site %}""" # noqa: E501
site_id = 1
with self.login_user_context(self.superuser):
# A default category, and a new alias is created for the template tag
self.render_template_obj(unlimited_template, {},
self.get_request('/'))
self.render_template_obj(site_limited_template, {},
self.get_request('/'))
alias = AliasModel.objects.filter(static_code="limited_alias_code")
self.assertEqual(len(alias), 2)
self.assertEqual(alias[0].static_code, "limited_alias_code")
self.assertEqual(alias[0].site, None)
self.assertEqual(alias[1].static_code, "limited_alias_code")
self.assertEqual(alias[1].site.pk, site_id)
# Render both templates again and be sure that the original tags are reused
self.render_template_obj(unlimited_template, {}, self.get_request('/'))
self.render_template_obj(site_limited_template, {},
self.get_request('/'))
alias_requery = AliasModel.objects.filter(
static_code="limited_alias_code")
self.assertEqual(alias_requery.count(), 2)
def test_site_limited_alias_displays_the_correct_contents(self):
"""
The correct contents are shown when viewing the static alias in different sites.
"""
unlimited_template = """{% load djangocms_alias_tags %}{% static_alias "site_limit_alias_code" %}""" # noqa: E501
site_limited_template = """{% load djangocms_alias_tags %}{% static_alias "site_limit_alias_code" site %}""" # noqa: E501
site1 = Site.objects.create(domain='site1.com', name='1')
site2 = Site.objects.create(domain='site2.com', name='2')
category = Category.objects.create(
name=DEFAULT_STATIC_ALIAS_CATEGORY_NAME)
unlimited_alias = self._create_alias(
plugins=None,
name='test alias',
category=category,
static_code="site_limit_alias_code",
site=None)
site_limited_alias = self._create_alias(
plugins=None,
name='test alias',
category=category,
static_code="site_limit_alias_code",
site=site2)
add_plugin(
unlimited_alias.get_placeholder(self.language),
'TextPlugin',
language=self.language,
body='unlimited text',
)
add_plugin(
site_limited_alias.get_placeholder(self.language),
'TextPlugin',
language=self.language,
body='site limited text',
)
# Should show the contents of the unlimited template
with override_settings(SITE_ID=site1.pk):
site1_unlimited_preview = self.render_template_obj(
unlimited_template, {}, self.get_request('/'))
site1_limited_preview = self.render_template_obj(
site_limited_template, {}, self.get_request('/'))
self.assertEqual(site1_unlimited_preview, "unlimited text")
self.assertEqual(site1_limited_preview, "")
# Should show the contents of the site limited template
with override_settings(SITE_ID=site2.pk):
site2_unlimited_preview = self.render_template_obj(
unlimited_template, {}, self.get_request('/'))
site2_limited_preview = self.render_template_obj(
site_limited_template, {}, self.get_request('/'))
self.assertEqual(site2_unlimited_preview, "unlimited text")
self.assertEqual(site2_limited_preview, "site limited text")
@skipUnless(is_versioning_enabled(), 'Test only relevant for versioning')
def test_static_alias_shows_correct_content_for_versioning_states(self):
"""
The correct contents are shown when viewing the static alias:
- A draft page shows draft content
- A published page shows published content or nothing at all
"""
from djangocms_versioning.constants import PUBLISHED
category = Category.objects.create(
name=DEFAULT_STATIC_ALIAS_CATEGORY_NAME)
alias = self._create_alias(
plugins=None,
name='test alias',
category=category,
published=True,
static_code="template_example_global_alias_code")
add_plugin(
alias.get_placeholder(language='en'),
'TextPlugin',
language='en',
body='Published content for: template_example_global_alias_code',
)
page = create_page(title="Static Code Test",
language='en',
template='static_alias.html',
limit_visibility_in_menu=None,
created_by=self.superuser)
# Publish the page and create a draft alias
self._publish(page, 'en')
version = self._get_version(alias, PUBLISHED, 'en')
draft = version.copy(self.superuser)
# Add draft content to the draft version
add_plugin(
draft.content.placeholder,
'TextPlugin',
language='en',
body=
'Updated Draft content for: template_example_global_alias_code',
)
page_content = page.get_title_obj("en")
page_live_url = page.get_absolute_url()
page_edit_url = get_object_edit_url(page_content, "en")
page_preview_url = get_object_preview_url(page_content, "en")
# The live page should still contain the published contents
live_response = self.client.get(page_live_url)
self.assertContains(
live_response,
'Published content for: template_example_global_alias_code')
self.assertNotContains(
live_response,
'Updated Draft content for: template_example_global_alias_code')
# The edit and preview url should show the draft contents
with self.login_user_context(self.superuser):
edit_response = self.client.get(page_edit_url)
preview_response = self.client.get(page_preview_url)
self.assertContains(
edit_response,
'Updated Draft content for: template_example_global_alias_code')
self.assertContains(
preview_response,
'Updated Draft content for: template_example_global_alias_code')
def test_pages_using_alias(self):
site1 = Site.objects.create(domain='site1.com', name='1')
site2 = Site.objects.create(domain='site2.com', name='2')
alias = self._create_alias(name='alias')
site1_page = self._create_page(
title='Site1',
language=self.language,
site=site1,
)
self.add_alias_plugin_to_page(site1_page, alias)
# Should show on the list
nested_page1 = self._create_page(
title='Site1 nested page 1',
language=self.language,
site=site1,
parent=site1_page,
)
self.add_alias_plugin_to_page(nested_page1, alias)
self.add_alias_plugin_to_page(nested_page1, alias)
# Should show on the list only once
nested_page2 = self._create_page(
title='Site1 nested page 2',
language=self.language,
site=site1,
parent=site1_page,
)
self.add_alias_plugin_to_page(nested_page2, alias)
# Should show on the list
nested_page3 = self._create_page(
title='Site1 nested page 3',
language=self.language,
site=site1,
parent=site1_page,
) # Not show on the list
deep_nested_page4 = self._create_page(
title='Site1 deep nested page 4',
language=self.language,
site=site1,
parent=nested_page3,
)
self.add_alias_plugin_to_page(deep_nested_page4, alias)
# Should show on the list
site2_page = self._create_page(
title='Site2',
language='de',
site=site2,
)
self.add_alias_plugin_to_page(site2_page, alias, 'de')
if is_versioning_enabled():
create_title('en',
'Site2 EN',
site2_page,
created_by=self.superuser)
self._publish(site2_page, 'en')
else:
create_title('en', 'Site2 EN', site2_page)
self.add_alias_plugin_to_page(site2_page, alias, 'en')
# Should show on the list only once
with self.assertNumQueries(3):
objects = alias.objects_using
self.assertEqual(sorted(obj.pk for obj in objects), [
site1_page.pk,
nested_page1.pk,
nested_page2.pk,
deep_nested_page4.pk,
site2_page.pk,
])
