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, ])