def test_copy_filled_placeholder_force_copy(self): """ If an existing title in the target language has plugins in a placeholder and the command is called with *force-copy*, the plugins are copied on top of the existing one """ site = 1 number_start_plugins = CMSPlugin.objects.all().count() # create an empty title language root_page = Page.objects.on_site(site).get_home() create_title("de", "root page de", root_page) ph = root_page.placeholders.get(slot="body") add_plugin(ph, "TextPlugin", "de", body="Hello World") root_plugins = CMSPlugin.objects.filter(placeholder=ph) text_de_orig, _ = root_plugins.get(language='de', plugin_type='TextPlugin').get_plugin_instance() out = StringIO() management.call_command( 'cms', 'copy', 'lang', '--from-lang=en', '--to-lang=de', '--force', interactive=False, stdout=out ) CMSPlugin.objects.filter(placeholder=root_page.placeholders.get(slot="body")) self.assertEqual(CMSPlugin.objects.filter(language='en').count(), number_start_plugins) # we have an existing plugin in one placeholder, so we have one more self.assertEqual(CMSPlugin.objects.filter(language='de').count(), number_start_plugins+1)
def setUp(self): from django.core.cache import cache super(PlaceholderCacheTestCase, self).setUp() cache.clear() self.page = create_page( 'en test page', 'nav_playground.html', 'en', published=True) # Now create and publish as 'de' title create_title('de', "de test page", self.page) self.page.publish('de') self.placeholder = self.page.placeholders.filter(slot="body")[0] plugin_pool.register_plugin(VaryCacheOnPlugin) add_plugin(self.placeholder, 'TextPlugin', 'en', body='English') add_plugin(self.placeholder, 'TextPlugin', 'de', body='Deutsch') add_plugin(self.placeholder, 'VaryCacheOnPlugin', 'en') add_plugin(self.placeholder, 'VaryCacheOnPlugin', 'de') self.en_request = self.get_request('/en/') self.en_request.current_page = Page.objects.get(pk=self.page.pk) self.en_us_request = self.get_request('/en/') self.en_us_request.META['HTTP_COUNTRY_CODE'] = 'US' self.en_uk_request = self.get_request('/en/') self.en_uk_request.META['HTTP_COUNTRY_CODE'] = 'UK' self.de_request = self.get_request('/de/') self.de_request.current_page = Page.objects.get(pk=self.page.pk)
def setUp(self): self.template = get_cms_setting('TEMPLATES')[0][0] self.language = settings.LANGUAGES[0][0] self.root_page = api.create_page( 'root page', self.template, self.language, published=True ) self.app_config = ThingsConfig.objects.create( namespace='things', app_title='Things') self.page = api.create_page( 'Things', self.template, self.language, published=True, parent=self.root_page, apphook='ThingsApp', apphook_namespace=self.app_config.namespace ) self.placeholder = self.page.placeholders.all()[0] self.request = self.get_request('en') for page in [self.root_page, self.page]: for language, _ in settings.LANGUAGES[1:]: api.create_title(language, page.get_slug(), page) page.publish(language) super(TestToolbar, self).setUp()
def test_command_line_publishes_selected_language_drafts(self): # we need to create a superuser (the db is empty) get_user_model().objects.create_superuser('djangocms', '*****@*****.**', '123456') page = create_page("en title", "nav_playground.html", "en") title = create_title('de', 'de title', page) title.published = False title.save() title = create_title('fr', 'fr title', page) title.published = False title.save() pages_from_output = 0 published_from_output = 0 with StdoutOverride() as buffer: # Now we don't expect it to raise, but we need to redirect IO call_command('cms', 'publisher_publish', language='de', include_unpublished=True) lines = buffer.getvalue().split('\n') #NB: readlines() doesn't work for line in lines: if 'Total' in line: pages_from_output = int(line.split(':')[1]) elif 'Published' in line: published_from_output = int(line.split(':')[1]) self.assertEqual(pages_from_output, 1) self.assertEqual(published_from_output, 1) self.assertEqual(Page.objects.public().count(), 1) public = Page.objects.public()[0] languages = sorted(public.title_set.values_list('language', flat=True)) self.assertEqual(languages, ['de'])
def create_root_page(self): root_page = api.create_page( 'root page', self.template, self.language, published=True) api.create_title('de', 'root page de', root_page) root_page.publish('en') root_page.publish('de') return root_page.reload()
def test_apphook_on_root(self): with SettingsOverride(ROOT_URLCONF="cms.test_utils.project.urls_for_apphook_tests"): apphook_pool.clear() superuser = get_user_model().objects.create_superuser("admin", "*****@*****.**", "admin") page = create_page( "apphooked-page", "nav_playground.html", "en", created_by=superuser, published=True, apphook="SampleApp" ) blank_page = create_page( "not-apphooked-page", "nav_playground.html", "en", created_by=superuser, published=True, apphook="", slug="blankapp", ) english_title = page.title_set.all()[0] self.assertEqual(english_title.language, "en") create_title("de", "aphooked-page-de", page) self.assertTrue(page.publish("en")) self.assertTrue(page.publish("de")) self.assertTrue(blank_page.publish("en")) with force_language("en"): response = self.client.get(self.get_pages_root()) self.assertTemplateUsed(response, "sampleapp/home.html") response = self.client.get("/en/blankapp/") self.assertTemplateUsed(response, "nav_playground.html") apphook_pool.clear()
def setUp(self): super(TestEventViews, self).setUp() root_page = self.create_root_page() page = api.create_page( "Events en", self.template, "en", published=True, parent=root_page, apphook="EventListAppHook", apphook_namespace=self.app_config.namespace, publication_date=tz_datetime(2014, 1, 8), ) api.create_title("de", "Events de", page) page.publish("en") page.publish("de") page.reload() # aldryn apphook reload needs some time to reload test # server implementation so we will provide some time for him # otherwise test_event_detail_view is too quick, and fails. with override("en"): page_url = page.get_absolute_url() self.client.get(page_url) self.list_view_year_month = ("2015", "02")
def setUp(self): super(CMSRequestBasedTest, self).setUp() self.template = get_cms_setting('TEMPLATES')[0][0] self.language = settings.LANGUAGES[0][0] self.root_page = api.create_page( 'root page', self.template, self.language, published=True ) self.app_config = FaqConfig.objects.create(namespace='aldryn_faq', permalink_type='Bp', non_permalink_handling=301) self.page = api.create_page( 'faq', self.template, self.language, published=True, parent=self.root_page, apphook='FaqApp', apphook_namespace=self.app_config.namespace ) self.placeholder = self.page.placeholders.all()[0] for page in [self.root_page, self.page]: for language, _ in settings.LANGUAGES[1:]: api.create_title(language, page.get_slug(), page) page.publish(language)
def test_plugins_discarded_with_language_fallback(self): """ Tests side effect of language fallback: if fallback enabled placeholder existed, it discards all other existing plugins """ page_en = create_page('page_en', 'col_two.html', 'en') create_title("de", "page_de", page_en) placeholder_sidebar_en = page_en.placeholders.get(slot='col_sidebar') placeholder_en = page_en.placeholders.get(slot='col_left') add_plugin(placeholder_sidebar_en, TextPlugin, 'en', body='en body') context_en = SekizaiContext() context_en['request'] = self.get_request(language="en", page=page_en) conf = { 'col_left': { 'language_fallback': True, }, } with self.settings(CMS_PLACEHOLDER_CONF=conf): # call assign plugins first, as this is what is done in real cms life # for all placeholders in a page at once assign_plugins(context_en['request'], [placeholder_sidebar_en, placeholder_en], 'col_two.html') # if the normal, non fallback enabled placeholder still has content content_en = _render_placeholder(placeholder_sidebar_en, context_en) self.assertRegexpMatches(content_en, "^en body$") # remove the cached plugins instances del(placeholder_sidebar_en._plugins_cache) cache.clear()
def test_detail_view_fallback_language(self): ''' Ask for a page in elvish (doesn't exist), and assert that it fallsback to English ''' page = create_page("page1", "nav_playground.html", "en") with SettingsOverride(TEMPLATE_CONTEXT_PROCESSORS=[], CMS_LANGUAGES={ 1:[ {'code':'x-klingon', 'name':'Klingon', 'public':True, 'fallbacks':[]}, {'code':'x-elvish', 'name':'Elvish', 'public':True, 'fallbacks':['x-klingon', 'en', ]}, ]}, ): create_title("x-klingon", "futla ak", page, slug=page.get_slug()) page.publish() from cms.views import details request = AttributeObject( REQUEST={'language': 'x-elvish'}, GET=[], session={}, path='/', current_page=None, method='GET', COOKIES={}, META={}, user=User(), ) response = details(request, '') self.assertTrue(isinstance(response, HttpResponseRedirect))
def test_get_apps(self): """ Check that urlconf are dynamically loaded according to the different page the apphook is attached to """ titles = self.create_base_structure('VariableUrlsApp', ['en', 'de']) titles[0].page.reverse_id = 'page1' titles[0].page.save() self.reload_urls() # only one urlconf is configured given that only one page is created with force_language('de'): reverse('extra_first') with self.assertRaises(NoReverseMatch): reverse('sample2-root') self.reload_urls() self.apphook_clear() page2 = create_page('page2', 'nav_playground.html', 'en', created_by=self.superuser, published=True, parent=titles[0].page.parent, apphook='VariableUrlsApp', reverse_id='page2') create_title('de', 'de_title', page2, slug='slug') page2.publish('de') self.reload_urls() with force_language('de'): reverse('sample2-root') reverse('extra_first') self.apphook_clear()
def test_command_line_publishes_selected_language_drafts(self): # we need to create a superuser (the db is empty) get_user_model().objects.create_superuser("djangocms", "*****@*****.**", "123456") page = create_page("en title", "nav_playground.html", "en") title = create_title("de", "de title", page) title.published = False title.save() title = create_title("fr", "fr title", page) title.published = False title.save() pages_from_output = 0 published_from_output = 0 with StdoutOverride() as buffer: # Now we don't expect it to raise, but we need to redirect IO call_command("cms", "publisher_publish", language="de", include_unpublished=True) lines = buffer.getvalue().split("\n") # NB: readlines() doesn't work for line in lines: if "Total" in line: pages_from_output = int(line.split(":")[1]) elif "Published" in line: published_from_output = int(line.split(":")[1]) self.assertEqual(pages_from_output, 1) self.assertEqual(published_from_output, 1) self.assertEqual(Page.objects.public().count(), 1) public = Page.objects.public()[0] languages = sorted(public.title_set.values_list("language", flat=True)) self.assertEqual(languages, ["de"])
def _create_page(cls, page, lang, auto_title, cms_app=None, parent=None, namespace=None): """ Create a single page or titles :param page: Page instance :param lang: language code :param auto_title: title text for the newly created title :param cms_app: Apphook Class to be attached to the page :param parent: parent page (None when creating the home page) :param namespace: application instance name (as provided to the ApphookConfig) :return: draft copy of the created page """ from cms.api import create_page, create_title from cms.utils.conf import get_templates default_template = get_templates()[0][0] if page is None: page = create_page( auto_title, language=lang, parent=parent, template=default_template, in_navigation=True, published=True ) page.application_urls = cms_app page.application_namespace = namespace page.save() page.publish(lang) elif lang not in page.get_languages(): create_title( language=lang, title=auto_title, page=page ) page.publish(lang) return page.get_draft_object()
def create_page(self, title=None, slug=None, namespace=None): if namespace is None: namespace = self.app_config.namespace if title is None: title = 'Jobs' if slug is None: slug = 'jobs-app' page = api.create_page( title='{0} en'.format(title), slug='{0}-en'.format(slug), template=self.template, language=self.language, published=True, parent=self.root_page, apphook='JobsApp', apphook_namespace=namespace) api.create_title( 'de', '{0} de'.format(title), page, slug='{0}-de'.format(slug)) page.publish('en') page.publish('de') # unfortunately aphook reload doesn't restart server fast, # so we do an empty request otherwise tests might # fail because it can't get correct url with override('en'): empty_url = page.get_absolute_url() self.client.get(empty_url) return page.reload()
def test_get_page_for_apphook_on_preview_or_edit(self): if get_user_model().USERNAME_FIELD == "email": superuser = get_user_model().objects.create_superuser("admin", "*****@*****.**", "*****@*****.**") else: superuser = get_user_model().objects.create_superuser("admin", "*****@*****.**", "admin") page = create_page("home", "nav_playground.html", "en", created_by=superuser, published=True, apphook=APP_NAME) create_title("de", page.get_title(), page) page.publish("en") page.publish("de") public_page = page.get_public_object() with self.login_user_context(superuser): with force_language("en"): path = reverse("sample-settings") request = self.get_request(path + "?edit") request.LANGUAGE_CODE = "en" attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash self.assertEqual(attached_to_page.pk, public_page.pk) with force_language("de"): path = reverse("sample-settings") request = self.get_request(path + "?edit") request.LANGUAGE_CODE = "de" attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash self.assertEqual(attached_to_page.pk, public_page.pk)
def test_get_i18n_apphook_with_explicit_current_app(self): self.apphook_clear() titles = self.create_base_structure(NS_APP_NAME, ['en', 'de'], 'instance_1') public_de_title = titles[1] de_title = Title.objects.get(page=public_de_title.page.publisher_draft, language="de") de_title.slug = "de" de_title.save() de_title.page.publish('de') self.reload_urls() self.apphook_clear() page2 = create_page("page2", "nav_playground.html", "en", created_by=self.superuser, published=True, parent=de_title.page.parent, apphook=NS_APP_NAME, apphook_namespace="instance_2") create_title("de", "de_title", page2, slug="slug") page2.publish('de') clear_app_resolvers() clear_url_caches() if APP_MODULE in sys.modules: del sys.modules[APP_MODULE] self.reload_urls() with force_language("de"): reverse('namespaced_app_ns:current-app', current_app="instance_1") reverse('namespaced_app_ns:current-app', current_app="instance_2") reverse('namespaced_app_ns:current-app') with force_language("en"): reverse('namespaced_app_ns:current-app', current_app="instance_1") reverse('namespaced_app_ns:current-app', current_app="instance_2") reverse('namespaced_app_ns:current-app') self.apphook_clear()
def get_or_create_page(self, base_title=None, languages=None): """Creates a page with a given title, or, if it already exists, just retrieves and returns it.""" from cms.api import create_page, create_title if not base_title: # No title? Create one. base_title = self.rand_str(prefix="page", length=8) if not languages: # If no langs supplied, use'em all languages = self.languages # If there is already a page with this title, just return it. try: page_title = Title.objects.get(title=base_title) return page_title.page.get_draft_object() except: pass # No? Okay, create one. page = create_page(base_title, 'fullwidth.html', language=languages[0]) # If there are multiple languages, create the translations if len(languages) > 1: for lang in languages[1:]: title_lang = "{0}-{1}".format(base_title, lang) create_title(language=lang, title=title_lang, page=page) page.publish(lang) return page.get_draft_object()
def test_hide_untranslated(self): TESTLANG = get_primary_lanaguage() TESTLANG2 = get_secondary_lanaguage() page = create_page("mlpage-%s" % TESTLANG, "nav_playground.html", TESTLANG) create_title(TESTLANG2, "mlpage-%s" % TESTLANG2, page, slug=page.get_slug()) page2 = create_page("mlpage-2-%s" % TESTLANG, "nav_playground.html", TESTLANG, parent=page) page.publish(TESTLANG) page.publish(TESTLANG2) page2.publish(TESTLANG) menu = CMSMenu() lang_settings = copy.deepcopy(get_cms_setting('LANGUAGES')) request_1 = self.get_request('/%s/' % TESTLANG, TESTLANG) request_2 = self.get_request('/%s/' % TESTLANG2, TESTLANG2) lang_settings[1][1]['hide_untranslated'] = False with SettingsOverride(CMS_LANGUAGES=lang_settings): list_1 = [node.id for node in menu.get_nodes(request_1)] list_2 = [node.id for node in menu.get_nodes(request_2)] self.assertEqual(list_1, list_2) self.assertEqual(len(list_1), 2) lang_settings[1][1]['hide_untranslated'] = True with SettingsOverride(CMS_LANGUAGES=lang_settings): list_1 = [node.id for node in menu.get_nodes(request_1)] list_2 = [node.id for node in menu.get_nodes(request_2)] self.assertNotEqual(list_1, list_2) self.assertEqual(len(list_2), 1) self.assertEqual(len(list_1), 2)
def test_plugins_discarded_with_language_fallback(self): """ Tests side effect of language fallback: if fallback enabled placeholder existed, it discards all other existing plugins """ page_en = create_page("page_en", "col_two.html", "en") create_title("de", "page_de", page_en) placeholder_sidebar_en = page_en.placeholders.get(slot="col_sidebar") placeholder_en = page_en.placeholders.get(slot="col_left") add_plugin(placeholder_sidebar_en, TextPlugin, "en", body="en body") class NoPushPopContext(Context): def push(self): pass pop = push context_en = NoPushPopContext() context_en["request"] = self.get_request(language="en", page=page_en) conf = {"col_left": {"language_fallback": True}} with SettingsOverride(CMS_PLACEHOLDER_CONF=conf): # call assign plugins first, as this is what is done in real cms life # for all placeholders in a page at once assign_plugins(context_en["request"], [placeholder_sidebar_en, placeholder_en], "col_two.html") # if the normal, non fallback enabled placeholder still has content content_en = render_placeholder(placeholder_sidebar_en, context_en) self.assertRegexpMatches(content_en, "^en body$") # remove the cached plugins instances del (placeholder_sidebar_en._plugins_cache) cache.clear()
def test_setup_filled(self): # Tests starts with no page and no config self.assertFalse(Page.objects.exists()) self.assertFalse(BlogConfig.objects.exists()) langs = get_language_list() home = None for lang in langs: with override(lang): if not home: home = create_page( 'a new home', language=lang, template='blog.html', in_navigation=True, published=True ) else: create_title( language=lang, title='a new home', page=home ) home.publish(lang) # importing cms_app triggers the auto setup from djangocms_blog import cms_app # NOQA # Home and blog, published and draft self.assertEqual(Page.objects.count(), 4) self.assertEqual(BlogConfig.objects.count(), 1) home = Page.objects.get_home() for lang in langs: self.assertEqual(home.get_title(lang), 'a new home')
def create_pages(source, languages): """ Build pages according to the pages data provided by :py:meth:`get_pages_data` and returns the list of the draft version of each """ from cms.api import create_page, create_title pages = OrderedDict() has_apphook = False for page_data in source: main_data = deepcopy(page_data[languages[0]]) if 'publish' in main_data: main_data['published'] = main_data.pop('publish') main_data['language'] = languages[0] if main_data.get('parent', None): main_data['parent'] = pages[main_data['parent']] page = create_page(**main_data) has_apphook = has_apphook or 'apphook' in main_data for lang in languages[1:]: if lang in page_data: publish = False title_data = deepcopy(page_data[lang]) if 'publish' in title_data: publish = title_data.pop('publish') if 'published' in title_data: publish = title_data.pop('published') title_data['language'] = lang title_data['page'] = page create_title(**title_data) if publish: page.publish(lang) page = page.get_draft_object() pages[page.get_slug(languages[0])] = page if has_apphook: reload_urls(settings, cms_apps=True) return list(pages.values())
def test_detail_view_404_when_no_language_is_found(self): User = auth.get_user_model() page = create_page("page1", "nav_playground.html", "en") create_title("de", page.get_title(), page, slug=page.get_slug()) page.publish() with SettingsOverride(TEMPLATE_CONTEXT_PROCESSORS=[], CMS_LANGUAGES={ 1:[ {'code':'x-klingon', 'name':'Klingon','public':True, 'fallbacks':[]}, {'code':'x-elvish', 'name':'Elvish', 'public':True, 'fallbacks':[]}, ]}): from cms.views import details request = AttributeObject( REQUEST={'language': 'x-elvish'}, GET=[], session={}, path='/', current_page=None, method='GET', COOKIES={}, META={}, user=User(), ) self.assertRaises(Http404, details, request, '')
def test_get_page_for_apphook_on_preview_or_edit(self): if get_user_model().USERNAME_FIELD == 'email': superuser = get_user_model().objects.create_superuser('admin', '*****@*****.**', '*****@*****.**') else: superuser = get_user_model().objects.create_superuser('admin', '*****@*****.**', 'admin') page = create_page("home", "nav_playground.html", "en", created_by=superuser, published=True, apphook=APP_NAME) create_title('de', page.get_title(), page) page.publish('en') page.publish('de') page.save() public_page = page.get_public_object() with self.login_user_context(superuser): with force_language("en"): path = reverse('sample-settings') request = self.get_request(path + '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')) request.LANGUAGE_CODE = 'en' attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash response = self.client.get(path+"?edit") self.assertContains(response, '?redirect=') with force_language("de"): path = reverse('sample-settings') request = self.get_request(path + '?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')) request.LANGUAGE_CODE = 'de' attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash self.assertEqual(attached_to_page.pk, public_page.pk)
def test_command_line_publish_multiple_languages_check_count(self): """ Publishing one page with multiple languages still counts as one page. This test case checks whether it works as expected. """ # we need to create a superuser (the db is empty) get_user_model().objects.create_superuser('djangocms', '*****@*****.**', '123456') # Now, let's create a page with 2 languages. page = create_page("en title", "nav_playground.html", "en", published=True) create_title("de", "de title", page) page.publish("de") pages_from_output = 0 published_from_output = 0 with StdoutOverride() as buffer: # Now we don't expect it to raise, but we need to redirect IO call_command('cms', 'publisher_publish') lines = buffer.getvalue().split('\n') #NB: readlines() doesn't work for line in lines: if 'Total' in line: pages_from_output = int(line.split(':')[1]) elif 'Published' in line: published_from_output = int(line.split(':')[1]) self.assertEqual(pages_from_output, 1) self.assertEqual(published_from_output, 1)
def test_session_language(self): page = api.create_page("home", "nav_playground.html", "en", published=True) api.create_title('fr', "home", page) page.publish('fr') page.publish('en') response = self.client.get('/') self.assertEqual(response.status_code, 302) self.assertRedirects(response, '/en/') engine = import_module(settings.SESSION_ENGINE) store = engine.SessionStore() store.save() # we need to make load() work, or the cookie is worthless self.client.cookies[settings.SESSION_COOKIE_NAME] = store.session_key # ugly and long set of session session = self.client.session session[LANGUAGE_SESSION_KEY] = 'fr' session.save() response = self.client.get('/') self.assertEqual(response.status_code, 302) self.assertRedirects(response, '/fr/') self.client.get('/en/') self.assertEqual(self.client.session[LANGUAGE_SESSION_KEY], 'en') response = self.client.get('/') self.assertEqual(response.status_code, 302) self.assertRedirects(response, '/en/')
def test_calendar_plugin_with_not_existing_ns(self, timezone_mock): timezone_mock.now.return_value = tz_datetime(2014, 1, 2) self.create_base_pages() new_config = EventsConfig.objects.create(namespace='new_namespace') page = api.create_page('Plugin test en', self.template, 'en', published=True, slug='plugin-test-en') api.create_title('de', 'Plugin test de', page) ph = page.placeholders.get(slot='content') api.add_plugin(ph, 'CalendarPlugin', 'en', app_config=new_config) api.add_plugin(ph, 'CalendarPlugin', 'de', app_config=new_config) page.publish('en') page.publish('de') with force_language('en'): event = Event.objects.create( title='Test event namespace', slug='test-event-namespace', start_date=tz_datetime(2014, 1, 10), publish_at=tz_datetime(2014, 1, 1), app_config=new_config ) event.create_translation( 'de', title='Test event namespace de', slug='test-event-namespace-de') for language in ('en', 'de'): page_url = page.get_absolute_url(language) response = self.client.get(page_url) self.assertEqual(response.status_code, 200)
def create_essential_pages(page_publisher): languages = [entry[0] for entry in settings.LANGUAGES] if not Page.objects.count(): create_page( title='Home', template='cms/content-types/homepage.html', language=languages[0], published=True ) # Having the Home page in all languages is not essential. if not Page.objects.filter(reverse_id='search-results').exists(): search_page = create_page( title='Search', template='cms/content-types/page.html', language=languages[0], apphook='AldrynSearchApphook', reverse_id='search-results', published=True ) # The search results page must exist in all languages. for lang in languages[1:]: create_title(language=lang, title='Search', page=search_page) publish_page(page=search_page, user=page_publisher, language=lang)
def test_copy_existing_title(self): """ Even if a title already exists the copy is successfull, the original title remains untouched """ site = 1 number_start_plugins = CMSPlugin.objects.all().count() # create an empty title language root_page = Page.objects.on_site(site).get_home() create_title("de", "root page de", root_page) out = StringIO() management.call_command( 'cms', 'copy', 'lang', '--from-lang=en', '--to-lang=de', interactive=False, stdout=out ) pages = Page.objects.on_site(site).drafts() for page in pages: self.assertEqual(set((u'en', u'de')), set(page.get_languages())) # Original Title untouched self.assertEqual("root page de", Page.objects.on_site(site).get_home().get_title("de")) # Plugins still copied self.assertEqual(CMSPlugin.objects.all().count(), number_start_plugins*2) self.assertEqual(CMSPlugin.objects.filter(language='en').count(), number_start_plugins) self.assertEqual(CMSPlugin.objects.filter(language='de').count(), number_start_plugins)
def test_copy_existing_title(self): """ Even if a title already exists the copy is successfull, the original title remains untouched """ site = 1 number_start_plugins = CMSPlugin.objects.all().count() # create an empty title language root_page = Page.objects.on_site(site).get_home() create_title("de", "root page de", root_page) out = StringIO() command = cms.Command() command.stdout = out command.handle("copy-lang", "en", "de") pages = Page.objects.on_site(site).drafts() for page in pages: self.assertEqual(set((u'en', u'de')), set(page.get_languages())) # Original Title untouched self.assertEqual("root page de", Page.objects.on_site(site).get_home().get_title("de")) # Plugins still copied self.assertEqual(CMSPlugin.objects.all().count(), number_start_plugins*2) self.assertEqual(CMSPlugin.objects.filter(language='en').count(), number_start_plugins) self.assertEqual(CMSPlugin.objects.filter(language='de').count(), number_start_plugins)
def test_show_placeholder_lang_parameter(self): from django.core.cache import cache cache.clear() page = create_page('Test', 'col_two.html', 'en') create_title('fr', 'Fr Test', page) placeholder = page.placeholders.all()[0] add_plugin(placeholder, TextPlugin, 'en', body='<b>En Test</b>') add_plugin(placeholder, TextPlugin, 'fr', body='<b>Fr Test</b>') request = RequestFactory().get('/') request.user = AnonymousUser() request.current_page = page template = "{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'en' 1 %}{% render_block 'js' %}" output = self.render_template_obj(template, {'page': page, 'slot': placeholder.slot}, request) self.assertIn('<b>En Test</b>', output) template = "{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'fr' 1 %}{% render_block 'js' %}" output = self.render_template_obj(template, {'page': page, 'slot': placeholder.slot}, request) self.assertIn('<b>Fr Test</b>', output) # Cache is now primed for both languages template = "{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'en' 1 %}{% render_block 'js' %}" output = self.render_template_obj(template, {'page': page, 'slot': placeholder.slot}, request) self.assertIn('<b>En Test</b>', output) template = "{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'fr' 1 %}{% render_block 'js' %}" output = self.render_template_obj(template, {'page': page, 'slot': placeholder.slot}, request) self.assertIn('<b>Fr Test</b>', output)
def test_hide_untranslated(self): TESTLANG = get_primary_language() TESTLANG2 = get_secondary_language() page = create_page("mlpage-%s" % TESTLANG, "nav_playground.html", TESTLANG) create_title(TESTLANG2, "mlpage-%s" % TESTLANG2, page, slug=page.get_slug()) page2 = create_page("mlpage-2-%s" % TESTLANG, "nav_playground.html", TESTLANG, parent=page) page.publish(TESTLANG) page.publish(TESTLANG2) page2.publish(TESTLANG) menu = CMSMenu() lang_settings = copy.deepcopy(get_cms_setting('LANGUAGES')) request_1 = self.get_request('/%s/' % TESTLANG, TESTLANG) request_2 = self.get_request('/%s/' % TESTLANG2, TESTLANG2) lang_settings[1][1]['hide_untranslated'] = False with self.settings(CMS_LANGUAGES=lang_settings): list_1 = [node.id for node in menu.get_nodes(request_1)] list_2 = [node.id for node in menu.get_nodes(request_2)] self.assertEqual(list_1, list_2) self.assertEqual(len(list_1), 2) lang_settings[1][1]['hide_untranslated'] = True with self.settings(CMS_LANGUAGES=lang_settings): list_1 = [node.id for node in menu.get_nodes(request_1)] list_2 = [node.id for node in menu.get_nodes(request_2)] self.assertNotEqual(list_1, list_2) self.assertEqual(len(list_2), 1) self.assertEqual(len(list_1), 2)
def test_plugins_discarded_with_language_fallback(self): """ Tests side effect of language fallback: if fallback enabled placeholder existed, it discards all other existing plugins """ page_en = create_page('page_en', 'col_two.html', 'en') create_title("de", "page_de", page_en) placeholder_sidebar_en = page_en.placeholders.get(slot='col_sidebar') placeholder_en = page_en.placeholders.get(slot='col_left') add_plugin(placeholder_sidebar_en, TextPlugin, 'en', body='en body') class NoPushPopContext(Context): def push(self): pass pop = push context_en = NoPushPopContext() context_en['request'] = self.get_request(language="en", page=page_en) conf = { 'col_left': { 'language_fallback': True, }, } with SettingsOverride(CMS_PLACEHOLDER_CONF=conf): # call assign plugins first, as this is what is done in real cms life # for all placeholders in a page at once assign_plugins(context_en['request'], [placeholder_sidebar_en, placeholder_en], 'col_two.html') # if the normal, non fallback enabled placeholder still has content content_en = render_placeholder(placeholder_sidebar_en, context_en) self.assertRegexpMatches(content_en, "^en body$") # remove the cached plugins instances del(placeholder_sidebar_en._plugins_cache) cache.clear()
def test_command_line_publishes_selected_language_drafts(self): # we need to create a superuser (the db is empty) get_user_model().objects.create_superuser('djangocms', '*****@*****.**', '123456') page = create_page("en title", "nav_playground.html", "en") title = create_title('de', 'de title', page) title.published = False title.save() title = create_title('fr', 'fr title', page) title.published = False title.save() pages_from_output = 0 published_from_output = 0 with StdoutOverride() as buffer: # Now we don't expect it to raise, but we need to redirect IO call_command('publisher_publish', language='de', include_unpublished=True) lines = buffer.getvalue().split( '\n') #NB: readlines() doesn't work for line in lines: if 'Total' in line: pages_from_output = int(line.split(':')[1]) elif 'Published' in line: published_from_output = int(line.split(':')[1]) self.assertEqual(pages_from_output, 1) self.assertEqual(published_from_output, 1) self.assertEqual(Page.objects.public().count(), 1) public = Page.objects.public()[0] languages = sorted(public.title_set.values_list('language', flat=True)) self.assertEqual(languages, ['de'])
def setUp(self): User = get_user_model() self.admin, self.normal_guy = self._get_guys() if get_user_model().USERNAME_FIELD == 'email': self.no_page_permission_user = User.objects.create_user('no_page_permission', '*****@*****.**', '*****@*****.**') else: self.no_page_permission_user = User.objects.create_user('no_page_permission', '*****@*****.**', 'no_page_permission') self.no_page_permission_user.is_staff = True self.no_page_permission_user.is_active = True self.no_page_permission_user.save() [self.no_page_permission_user.user_permissions.add(p) for p in Permission.objects.filter( codename__in=[ 'change_mypageextension', 'change_mytitleextension', 'add_mypageextension', 'add_mytitleextension', 'delete_mypageextension', 'delete_mytitleextension', ] )] self.site = Site.objects.get(pk=1) self.page = create_page( 'My Extension Page', 'nav_playground.html', 'en', site=self.site, created_by=self.admin) self.page_title = self.page.get_title_obj('en') create_title('de', 'de title', self.page) self.page_extension = MyPageExtension.objects.create( extended_object=self.page, extra="page extension text") self.title_extension = MyTitleExtension.objects.create( extended_object=self.page.get_title_obj(), extra_title="title extension text") self.page_without_extension = create_page( 'A Page', 'nav_playground.html', 'en', site=self.site, created_by=self.admin) self.page_title_without_extension = self.page_without_extension.get_title_obj()
def create_cms_index_pages(placeholder_slot="content"): """ create cms home page and fill >content< placeholder with TextPlugin """ try: index_page = Page.objects.get(is_home=True, publisher_is_draft=False) except Page.DoesNotExist: log.debug('Create index page in "en" and...') index_page = create_page( title="index in English", template=TEMPLATE_INHERITANCE_MAGIC, language=settings.LANGUAGE_CODE, published=False, in_navigation=True, ) placeholder, created = index_page.placeholders.get_or_create( slot=placeholder_slot) for language_code, lang_name in settings.LANGUAGES: with translation.override(language_code): title = "index in %s" % lang_name log.info("create %r", title) if language_code != settings.LANGUAGE_CODE: create_title(language_code, title, index_page) add_plugin( placeholder=placeholder, plugin_type="TextPlugin", # djangocms_text_ckeditor language=language_code, body="index page in %s" % lang_name, ) index_page.publish(language_code) created = True else: created = False log.debug("Index page already exists.") return index_page, created
def test_page_language_url_for_apphook(self): apphook_pool.clear() superuser = User.objects.create_superuser('admin', '*****@*****.**', 'admin') page = create_page("home", "nav_playground.html", "en", created_by=superuser) create_title('de', page.get_title(), page) page.publish() child_page = create_page("child_page", "nav_playground.html", "en", created_by=superuser, parent=page) create_title('de', child_page.get_title(), child_page) child_page.publish() child_child_page = create_page("child_child_page", "nav_playground.html", "en", created_by=superuser, parent=child_page, apphook='SampleApp') create_title("de", '%s_de' % child_child_page.get_title(), child_child_page) child_child_page.publish() # publisher_public is set to draft on publish, issue with one to one reverse child_child_page = self.reload(child_child_page) with force_language("en"): path = reverse('extra_first') request = self.get_request(path) request.LANGUAGE_CODE = 'en' request.current_page = child_child_page fake_context = {'request': request} tag = DumbPageLanguageUrl() output = tag.get_context(fake_context, 'en') url = output['content'] self.assertEqual(url, '/en/child_page/child_child_page/extra_1/') output = tag.get_context(fake_context, 'de') url = output['content'] # look the extra "_de" self.assertEqual(url, '/de/child_page/child_child_page_de/extra_1/') output = tag.get_context(fake_context, 'fr') url = output['content'] self.assertEqual(url, '/fr/child_page/child_child_page/extra_1/') apphook_pool.clear()
def test_copy_existing_title(self): """ Even if a title already exists the copy is successfull, the original title remains untouched """ site = 1 number_start_plugins = CMSPlugin.objects.all().count() # create an empty title language root_page = Page.objects.get_home(site) create_title("de", "root page de", root_page) out = StringIO() management.call_command('cms', 'copy', 'lang', '--from-lang=en', '--to-lang=de', interactive=False, stdout=out) pages = Page.objects.on_site(site).drafts() for page in pages: self.assertEqual(set((u'en', u'de')), set(page.get_languages())) # Original Title untouched self.assertEqual("root page de", Page.objects.get_home(site).get_title("de")) # Plugins still copied self.assertEqual(CMSPlugin.objects.all().count(), number_start_plugins * 2) self.assertEqual( CMSPlugin.objects.filter(language='en').count(), number_start_plugins) self.assertEqual( CMSPlugin.objects.filter(language='de').count(), number_start_plugins)
def test_multi_edit(self): user = self.get_staff() page = create_page('Test', 'col_two.html', 'en', published=True) title = create_title("fr", "test", page) exm = MultilingualExample1() exm.translate("en") exm.char_1 = 'one' exm.char_2 = 'two' exm.save() exm.translate("fr") exm.char_1 = "un" exm.char_2 = "deux" exm.save() request = self.get_page_request(page, user, edit=True) response = detail_view_multi(request, exm.pk) self.assertContains( response, '<h1><span id="cms_placeholder-model-placeholderapp-%s-%s" class="cms_placeholder-generic">one</span></h1>' % (exm.pk, 'char_1')) self.assertContains( response, "/admin/placeholderapp/multilingualexample1/edit-field/%s/en/" % exm.pk) self.assertTrue( re.search(self.edit_fields_rx % "char_1", response.content.decode('utf8'))) self.assertTrue( re.search(self.edit_fields_rx % "char_1%2Cchar_2", response.content.decode('utf8'))) with SettingsOverride(LANGUAGE_CODE="fr"): request = self.get_page_request(title.page, user, edit=True, lang_code="fr") response = detail_view_multi(request, exm.pk) self.assertContains( response, '<h1><span id="cms_placeholder-model-placeholderapp-%s-%s" class="cms_placeholder-generic">un</span></h1>' % (exm.pk, 'char_1')) self.assertContains( response, "/admin/placeholderapp/multilingualexample1/edit-field/%s/fr/" % exm.pk) self.assertTrue( re.search(self.edit_fields_rx % "char_1%2Cchar_2", response.content.decode('utf8')))
def setUp(self): super(EventManagerAppConfigTestCase, self).setUp() # Ensure that all test events are assigned to an app_config self.events = [self.ev1, self.ev2, self.ev3, self.ev4, self.ev5, self.ev6, self.ev7] for event in self.events: event.app_config = self.app_config self.root_page = self.create_root_page() self.page = api.create_page( 'Events en', self.template, 'en', published=True, parent=self.root_page, apphook='EventListAppHook', apphook_namespace=self.app_config.namespace, publication_date=tz_datetime(2014, 1, 8) ) api.create_title('de', 'Events de', self.page) self.page.publish('en') self.page.publish('de') self.page.reload() # aldryn apphook reload needs a page load to work with override('en'): page_url = self.page.get_absolute_url() self.client.get(page_url)
def test_publish_admin(self): name = 'test_admin' drafts = Page.objects.drafts() public = Page.objects.public() page = self.create_page(name, published=False) create_title('de', 'de-page', page) create_title('fr', 'fr-page', page) self.assertNeverPublished(page) self.assertObjectExist(drafts, title_set__title=name) self.assertObjectDoesNotExist(public, title_set__title=name) self.assertObjectDoesNotExist(public.published(language="en"), title_set__title=name) with self.login_user_context(self.get_superuser()): response = self.client.post(admin_reverse("cms_page_publish_page", args=[page.pk, 'en'])) self.assertEqual(response.status_code, 302) page = page.reload() self.assertPublished(page) self.assertObjectExist(drafts, title_set__title=name) self.assertObjectExist(public, title_set__title=name) self.assertFalse(public.published(language="de").exists()) self.assertFalse(public.published(language="fr").exists()) self.assertSequenceEqual(page.publisher_public.get_languages(), ['en'])
def test_command_line_publish_multiple_languages(self): # we need to create a superuser (the db is empty) get_user_model().objects.create_superuser('djangocms', '*****@*****.**', '123456') # Create a draft page with two published titles page = create_page(u"The page!", "nav_playground.html", "en", published=False) title = create_title('de', 'ja', page) title.published = True title.save() title = create_title('fr', 'non', page) title.published = True title.save() with StdoutOverride(): # Now we don't expect it to raise, but we need to redirect IO call_command('cms', 'publisher-publish') public = Page.objects.public()[0] languages = sorted(public.title_set.values_list('language', flat=True)) self.assertEqual(languages, ['de', 'fr'])
def test_multilingual_page(self): TESTLANG = get_primary_language() TESTLANG2 = get_secondary_language() page = create_page("mlpage", "nav_playground.html", TESTLANG) create_title(TESTLANG2, page.get_title(), page, slug=page.get_slug()) page.rescan_placeholders() page = self.reload(page) placeholder = page.placeholders.all()[0] add_plugin(placeholder, "TextPlugin", TESTLANG2, body="test") add_plugin(placeholder, "TextPlugin", TESTLANG, body="test") self.assertEqual( placeholder.cmsplugin_set.filter(language=TESTLANG2).count(), 1) self.assertEqual( placeholder.cmsplugin_set.filter(language=TESTLANG).count(), 1) user = get_user_model().objects.create_superuser( 'super', '*****@*****.**', 'super') page = publish_page(page, user, TESTLANG) page = publish_page(page, user, TESTLANG2) public = page.publisher_public placeholder = public.placeholders.all()[0] self.assertEqual( placeholder.cmsplugin_set.filter(language=TESTLANG2).count(), 1) self.assertEqual( placeholder.cmsplugin_set.filter(language=TESTLANG).count(), 1)
def create_section_page(sender, instance, created, raw, using, update_fields, **kwargs): if not instance.slug: instance.slug = slugify(instance.name) if created: if instance.namespace == "" or not instance.namespace: instance.namespace = slugify(instance.name) if instance.create_page: page = create_page(title=instance.name, template=TEMPLATE_INHERITANCE_MAGIC, language=LANGUAGE_CODE, slug=instance.slug, apphook=PostApp, apphook_namespace=instance.namespace, published=True, in_navigation=True) for code, lang in LANGUAGES: if code != LANGUAGE_CODE: title = getattr(instance, "name_%s" % code, instance.name) slug = getattr(instance, "slug_%s" % code, instance.slug) try: create_title(language=code, title=title, page=page, slug=slug) except IntegrityError: pass instance.save()
def test_plugins_language_fallback(self): """ Tests language_fallback placeholder configuration """ page_en = create_page('page_en', 'col_two.html', 'en') title_de = create_title("de", "page_de", page_en) placeholder_en = page_en.placeholders.get(slot='col_left') placeholder_de = title_de.page.placeholders.get(slot='col_left') add_plugin(placeholder_en, TextPlugin, 'en', body='en body') class NoPushPopContext(Context): def push(self): pass pop = push context_en = NoPushPopContext() context_en['request'] = self.get_request(language="en", page=page_en) context_de = NoPushPopContext() context_de['request'] = self.get_request(language="de", page=page_en) # First test the default (non-fallback) behavior) ## English page should have the text plugin content_en = render_placeholder(placeholder_en, context_en) self.assertRegexpMatches(content_en, "^en body$") ## Deutsch page should have no text content_de = render_placeholder(placeholder_de, context_de) self.assertNotRegex(content_de, "^en body$") self.assertEqual(len(content_de), 0) conf = { 'col_left': { 'language_fallback': True, }, } with SettingsOverride(CMS_PLACEHOLDER_CONF=conf): ## Deutsch page should have no text del(placeholder_de._plugins_cache) cache.clear() content_de = render_placeholder(placeholder_de, context_de) self.assertRegexpMatches(content_de, "^en body$") # remove the cached plugins instances del(placeholder_de._plugins_cache) cache.clear() # Then we add a plugin to check for proper rendering add_plugin(placeholder_de, TextPlugin, 'de', body='de body') content_de = render_placeholder(placeholder_de, context_de) self.assertRegexpMatches(content_de, "^de body$")
def test_nested_plugins_language_fallback(self): """ Tests language_fallback placeholder configuration for nested plugins""" page_en = create_page('page_en', 'col_two.html', 'en') title_de = create_title("de", "page_de", page_en) placeholder_en = page_en.placeholders.get(slot='col_left') placeholder_de = title_de.page.placeholders.get(slot='col_left') link_en = add_plugin(placeholder_en, 'LinkPlugin', 'en', name='en name', external_link='http://example.com/en') add_plugin(placeholder_en, 'TextPlugin', 'en', target=link_en, body='en body') context_en = SekizaiContext() context_en['request'] = self.get_request(language="en", page=page_en) context_de = SekizaiContext() context_de['request'] = self.get_request(language="de", page=page_en) conf = { 'col_left': { 'language_fallback': True, }, } with self.settings(CMS_PLACEHOLDER_CONF=conf): content_de = _render_placeholder(placeholder_de, context_de) self.assertRegexpMatches(content_de, "<a href=\"http://example.com/en\"") self.assertRegexpMatches(content_de, "en body") context_de2 = SekizaiContext() request = self.get_request(language="de", page=page_en) request.session['cms_edit'] = True request.user = self.get_superuser() request.toolbar = CMSToolbar(request) context_de2['request'] = request del(placeholder_de._plugins_cache) cache.clear() content_de2 = _render_placeholder(placeholder_de, context_de2) self.assertFalse("en body" in content_de2) # remove the cached plugins instances del(placeholder_de._plugins_cache) cache.clear() # Then we add a plugin to check for proper rendering link_de = add_plugin( placeholder_en, 'LinkPlugin', language='de', name='de name', external_link='http://example.com/de', ) add_plugin(placeholder_en, 'TextPlugin', 'de', target=link_de, body='de body') content_de = _render_placeholder(placeholder_de, context_de) self.assertRegexpMatches(content_de, "<a href=\"http://example.com/de\"") self.assertRegexpMatches(content_de, "de body")
def test_publish_status(self): p1 = create_page("page", "nav_playground.html", "en", published=True) public = p1.get_public_object() draft = p1.get_draft_object() self.assertEqual(set(public.get_languages()), set(('en',))) self.assertEqual(set(public.get_published_languages()), set(('en',))) self.assertEqual(set(draft.get_languages()), set(('en',))) self.assertEqual(set(draft.get_published_languages()), set(('en',))) p1 = create_title('de', 'page de', p1).page public = p1.get_public_object() draft = p1.get_draft_object() self.assertEqual(set(public.get_languages()), set(('en',))) self.assertEqual(set(public.get_published_languages()), set(('en',))) self.assertEqual(set(draft.get_languages()), set(('en', 'de'))) self.assertEqual(set(draft.get_published_languages()), set(('en', 'de'))) p1.publish('de') p1 = p1.reload() public = p1.get_public_object() draft = p1.get_draft_object() self.assertEqual(set(public.get_languages()), set(('en', 'de'))) self.assertEqual(set(public.get_published_languages()), set(('en', 'de'))) self.assertEqual(set(draft.get_languages()), set(('en', 'de'))) self.assertEqual(set(draft.get_published_languages()), set(('en', 'de'))) p1.unpublish('de') p1 = p1.reload() public = p1.get_public_object() draft = p1.get_draft_object() self.assertEqual(set(public.get_languages()), set(('en', 'de'))) self.assertEqual(set(public.get_published_languages()), set(('en',))) self.assertEqual(set(draft.get_languages()), set(('en', 'de'))) self.assertEqual(set(draft.get_published_languages()), set(('en', 'de'))) p1.publish('de') p1 = p1.reload() p1.unpublish('en') p1 = p1.reload() public = p1.get_public_object() draft = p1.get_draft_object() self.assertEqual(set(public.get_languages()), set(('en', 'de'))) self.assertEqual(set(public.get_published_languages()), set(('de',))) self.assertEqual(set(draft.get_languages()), set(('en', 'de'))) self.assertEqual(set(draft.get_published_languages()), set(('en', 'de')))
def setUp(self): Site.objects.create(domain='example.org', name='example.org') self.page = create_page('Home', 'simple.html', 'en', published=True) self.italian_title = create_title('it', 'Home italian', self.page) self.placeholder = self.page.placeholders.all()[0] add_plugin(self.placeholder, 'TextPlugin', 'en', body='test') self.base_url = self.live_server_url self.user = self._create_user('admin', True, True, True) self.driver.implicitly_wait(5) super(PlaceholderBasicTests, self).setUp()
def create_title(self, page): """ Create page title in all other languages with cms.api.create_title() """ for language_code, lang_name in iter_languages(self.languages): try: title = Title.objects.get(page=page, language=language_code) except Title.DoesNotExist: slug = self.get_slug(language_code, lang_name) assert slug != "", "No slug for %r" % language_code title = create_title(language=language_code, title=self.get_title( language_code, lang_name), page=page, slug=slug) log.debug("Title created: %s", title) else: log.debug("Page title exist: %s", title)
def test_create_with_revision(self): page_c_type = ContentType.objects.get_for_model(Page) user = get_user_model().objects.create_user( username='******', email='*****@*****.**', password='******', ) page_attrs = self._get_default_create_page_arguments() page_attrs['language'] = 'en' page_attrs['created_by'] = user page_attrs['with_revision'] = True page = create_page(**page_attrs) latest_revision = Revision.objects.latest('pk') versions = (latest_revision.version_set.filter( content_type=page_c_type, object_id_int=page.pk)) # assert a new version for the page has been created self.assertEqual(1, versions.count()) # assert revision comment was set correctly self.assertEqual( latest_revision.comment, REVISION_INITIAL_COMMENT, ) # assert revision user was set correctly self.assertEqual( latest_revision.user_id, user.pk, ) title_c_type = ContentType.objects.get_for_model(Title) title = create_title('de', 'test de', page, with_revision=True) latest_revision = Revision.objects.latest('pk') versions = (latest_revision.version_set.filter( content_type=title_c_type, object_id_int=title.pk)) # assert a new version for the title has been created self.assertEqual(1, versions.count())
def test_frontend_lang(self): superuser = self.get_superuser() lang_settings = copy.deepcopy(get_cms_setting('LANGUAGES')) lang_settings[1][0]['public'] = False with self.settings(CMS_LANGUAGES=lang_settings, LANGUAGE_CODE="en"): page = create_page("page1", "nav_playground.html", "en") create_title("de", page.get_title(), page, slug=page.get_slug()) page2 = create_page("page2", "nav_playground.html", "en") create_title("de", page2.get_title(), page2, slug=page2.get_slug()) page3 = create_page("page2", "nav_playground.html", "en") create_title("de", page3.get_title(), page3, slug=page3.get_slug()) page4 = create_page("page4", "nav_playground.html", "de") page.publish('en') page.publish('de') page2.publish('en') page2.publish('de') page3.publish('de') page3.publish('en') page4.publish('de') page.set_as_homepage() # The "en" language is set to public -> False. # Because the request is to the root (homepage), # the page is redirected to the default language's homepage response = self.client.get("/en/") self.assertRedirects(response, '/de/') # Authenticated requests to a private language # will render the page normally as long as the language # is available on the page with self.login_user_context(superuser): response = self.client.get("/en/") self.assertEqual(response.status_code, 200) response = self.client.get("/en/page2/") self.assertEqual(response.status_code, 404) response = self.client.get("/de/") self.assertEqual(response.status_code, 200) response = self.client.get("/de/page2/") self.assertEqual(response.status_code, 200) # check if the admin can see non-public langs with self.login_user_context(self.get_superuser()): response = self.client.get("/en/page2/") self.assertEqual(response.status_code, 200) response = self.client.get("/en/page4/") self.assertEqual(response.status_code, 302) self.client.logout() response = self.client.get("/en/page4/") self.assertEqual(response.status_code, 404)
def test_get_page_for_apphook(self): with SettingsOverride(ROOT_URLCONF='cms.test_utils.project.second_urls_for_apphook_tests'): apphook_pool.clear() superuser = User.objects.create_superuser('admin', '*****@*****.**', 'admin') page = create_page("home", "nav_playground.html", "en", created_by=superuser, published=True) create_title('de', page.get_title(), page) child_page = create_page("child_page", "nav_playground.html", "en", created_by=superuser, published=True, parent=page) create_title('de', child_page.get_title(), child_page) child_child_page = create_page("child_child_page", "nav_playground.html", "en", created_by=superuser, published=True, parent=child_page, apphook='SampleApp') create_title("de", child_child_page.get_title(), child_child_page, apphook='SampleApp') child_child_page.publish() # publisher_public is set to draft on publish, issue with onetoone reverse child_child_page = self.reload(child_child_page) en_title = child_child_page.publisher_public.get_title_obj('en') path = reverse('en:sample-settings') request = self.get_request(path) request.LANGUAGE_CODE = 'en' attached_to_page = applications_page_check(request, path=path[1:]) # strip leading slash self.assertEquals(attached_to_page.pk, en_title.page.pk) response = self.client.get(path) self.assertEquals(response.status_code, 200) self.assertTemplateUsed(response, 'sampleapp/home.html') self.assertContains(response, en_title.title) de_title = child_child_page.publisher_public.get_title_obj('de') path = reverse('de:sample-settings') request = self.get_request(path) request.LANGUAGE_CODE = 'de' attached_to_page = applications_page_check(request, path=path[4:]) # strip leading slash and language prefix self.assertEquals(attached_to_page.pk, de_title.page.pk) response = self.client.get(path) self.assertEquals(response.status_code, 200) self.assertTemplateUsed(response, 'sampleapp/home.html') self.assertContains(response, de_title.title) apphook_pool.clear()
def test_get_i18n_apphook_with_explicit_current_app(self): with SettingsOverride( ROOT_URLCONF= 'cms.test_utils.project.second_urls_for_apphook_tests'): titles = self.create_base_structure(NS_APP_NAME, ['en', 'de'], 'instance_1') public_de_title = titles[1] de_title = Title.objects.get( page=public_de_title.page.publisher_draft, language="de") de_title.slug = "de" de_title.save() de_title.page.publish() page2 = create_page("page2", "nav_playground.html", "en", created_by=self.superuser, published=True, parent=de_title.page.parent, apphook=NS_APP_NAME, apphook_namespace="instance_2") de_title2 = create_title("de", "de_title", page2, slug="slug") page2.publish() clear_app_resolvers() clear_url_caches() if APP_MODULE in sys.modules: del sys.modules[APP_MODULE] self.reload_urls() with force_language("de"): path = reverse('namespaced_app_ns:current-app', current_app="instance_1") path = reverse('namespaced_app_ns:current-app', current_app="instance_2") path = reverse('namespaced_app_ns:current-app') with force_language("en"): path = reverse('namespaced_app_ns:current-app', current_app="instance_1") path = reverse('namespaced_app_ns:current-app', current_app="instance_2") path = reverse('namespaced_app_ns:current-app')
def create_translation(self, page): data = self.cleaned_data title_kwargs = { 'page': page, 'language': self._language, 'slug': data['slug'], 'path': data['path'], 'title': data['title'], } if 'menu_title' in data: title_kwargs['menu_title'] = data['menu_title'] if 'page_title' in data: title_kwargs['page_title'] = data['page_title'] if 'meta_description' in data: title_kwargs['meta_description'] = data['meta_description'] return api.create_title(**title_kwargs)
def get_pages(self): from cms.api import create_page, create_title page_1 = create_page('page one', 'page.html', language='en') page_2 = create_page('page two', 'page.html', language='en') page_3 = create_page('page three', 'page.html', language='en') create_title(language='fr', title='page un', page=page_1) create_title(language='it', title='pagina uno', page=page_1) create_title(language='fr', title='page trois', page=page_3) for lang in self.languages: page_1.publish(lang) page_2.publish('en') page_3.publish('en') page_3.publish('fr') return page_1.get_draft_object(), page_2.get_draft_object(), page_3.get_draft_object()
def test_add_change(self, admin_client): page = create_page('Test Page', 'INHERIT', 'en-us') title_de = create_title(language='de', page=page, title='Test Page de') title_en = page.get_title_obj(language='en-us') extension_de = ExtensionModel.objects.create(name='de', extended_object=title_de) expected_url_add = ( '/admin/cmsapp/extensionmodel/add/?extended_object={0}') expected_url_change = '/admin/cmsapp/extensionmodel/{0}/change/' response = admin_client.get('{0}?edit=on'.format( page.get_absolute_url())) toolbar = response.context['request'].toolbar menu = toolbar.get_menu('page') item = menu.items[5] extensions = {ext.name: ext for ext in item.items} assert extensions['English Extension...'].url == ( expected_url_add.format(title_en.pk)) assert extensions['German Extension...'].url == ( expected_url_change.format(extension_de.pk))
def test_add(self, admin_client): page = create_page('Test Page', 'INHERIT', 'en-us') title_de = create_title(language='de', page=page, title='Test Page de') title_en = page.get_title_obj(language='en-us') expected_url = '/admin/cmsapp/extensionmodel/add/?extended_object={0}' response = admin_client.get('{0}?edit=on'.format( page.get_absolute_url())) toolbar = response.context['request'].toolbar menu = toolbar.get_menu('page') item = menu.items[5] extensions = {ext.name: ext for ext in item.items} assert isinstance(item, SubMenu) assert item.name == 'Extension' assert len(item.items) == 2 assert 'English Extension...' in extensions assert 'German Extension...' in extensions assert extensions['English Extension...'].url == (expected_url.format( title_en.pk)) assert extensions['German Extension...'].url == (expected_url.format( title_de.pk))
def test_fallback_title_extension(self): page = create_page('Test Fallback Title Extension', "nav_playground.html", "en") title_en = page.get_title_obj('en') title_extension_en = MyTitleExtension(extended_object=title_en, extra_title='title extension EN') title_extension_en.save() page.publish('en') self.assertEqual( page.get_title_obj('en', True).mytitleextension.extra_title, 'title extension EN') title_de = create_title(title="de page", language="de", page=page) title_extension_de = MyTitleExtension(extended_object=title_de, extra_title='title extension DE') title_extension_de.save() page.publish('de') self.assertEqual( page.get_title_obj('de', True).mytitleextension.extra_title, 'title extension DE')
def create_base_structure(self, apphook, title_langs, reverse_id=None): apphook_pool.clear() superuser = User.objects.create_superuser('admin', '*****@*****.**', 'admin') page = create_page("home", "nav_playground.html", "en", created_by=superuser, published=True) create_title('de', page.get_title(), page) child_page = create_page("child_page", "nav_playground.html", "en", created_by=superuser, published=True, parent=page) create_title('de', child_page.get_title(), child_page) child_child_page = create_page("child_child_page", "nav_playground.html", "en", created_by=superuser, published=True, parent=child_page, apphook=apphook, reverse_id=reverse_id) create_title("de", child_child_page.get_title(), child_child_page, apphook=apphook) child_child_page.publish() # publisher_public is set to draft on publish, issue with onetoone reverse child_child_page = self.reload(child_child_page) if isinstance(title_langs, basestring): titles = child_child_page.publisher_public.get_title_obj( title_langs) else: titles = [ child_child_page.publisher_public.get_title_obj(l) for l in title_langs ] self.reload_urls() return titles
def test_edit_field_multilingual(self): from django.contrib.admin import site exadmin = site._registry[MultilingualExample1] user = self.get_superuser() page = create_page('Test', 'col_two.html', 'en', published=True) title = create_title("fr", "test", page) exm = MultilingualExample1() exm.translate("en") exm.char_1 = 'one' exm.char_2 = 'two' exm.save() exm.translate("fr") exm.char_1 = "un" exm.char_2 = "deux" exm.save() request = self.get_page_request(page, user, edit=True) request.GET['edit_fields'] = 'char_2' response = exadmin.edit_field(request, exm.pk, "en") self.assertContains(response, 'id="id_char_2"') self.assertContains(response, 'value="two"') response = exadmin.edit_field(request, exm.pk, "fr") self.assertContains(response, 'id="id_char_2"') self.assertContains(response, 'value="deux"') with SettingsOverride(LANGUAGE_CODE="fr"): request = self.get_page_request(title.page, user, edit=True, lang_code="fr") request.GET['edit_fields'] = 'char_2' response = exadmin.edit_field(request, exm.pk, "fr") self.assertContains(response, 'id="id_char_2"') self.assertContains(response, 'value="deux"')
def create_base_structure(self, apphook, title_langs, namespace=None): self.apphook_clear() superuser = get_user_model().objects.create_superuser( 'admin', '*****@*****.**', 'admin') self.superuser = superuser page = create_page("home", "nav_playground.html", "en", created_by=superuser, published=True) create_title('de', page.get_title(), page) page.publish('de') child_page = create_page("child_page", "nav_playground.html", "en", created_by=superuser, published=True, parent=page) create_title('de', child_page.get_title(), child_page) child_page.publish('de') child_child_page = create_page("child_child_page", "nav_playground.html", "en", created_by=superuser, published=True, parent=child_page, apphook=apphook, apphook_namespace=namespace) create_title("de", child_child_page.get_title(), child_child_page) child_child_page.publish('de') # publisher_public is set to draft on publish, issue with onetoone reverse child_child_page = self.reload(child_child_page) if isinstance(title_langs, six.string_types): titles = child_child_page.publisher_public.get_title_obj( title_langs) else: titles = [ child_child_page.publisher_public.get_title_obj(l) for l in title_langs ] self.reload_urls() return titles