def assertSiteRoot(self):
self.selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
transaction.commit()
# Check EN root
self.assertEqual(selector_languages[0]['url'],
(self.portal.absolute_url() +
'/@@multilingual-selector/notg/en?set_language=en'))
self.browser.open(selector_languages[0]['url'])
self.assertIn(u'lang="en"'.encode("utf-8"), self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA root
self.assertEqual(selector_languages[1]['url'],
(self.portal.absolute_url() +
'/@@multilingual-selector/notg/ca?set_language=ca'))
self.browser.open(selector_languages[1]['url'])
self.assertIn(u'lang="ca"'.encode("utf-8"), self.browser.contents)
# Check ES root
self.browser.open(selector_languages[2]['url'])
self.assertEqual(selector_languages[2]['url'],
(self.portal.absolute_url() +
'/@@multilingual-selector/notg/es?set_language=es'))
self.assertIn(u'lang="es"'.encode("utf-8"), self.browser.contents)
def languages(self):
context = aq_inner(self.context)
ls = LanguageSelector(context, self.request, None, None)
ls.update()
results = ls.languages()
supported_langs = [v['code'] for v in results]
missing = set([str(c) for c in supported_langs])
lsv = LanguageSelectorViewlet(context, self.request, None, None)
translations = lsv._translations(missing)
# We want to see the babel_view
append_path = ('', 'babel_view',)
non_viewable = set()
for data in results:
code = str(data['code'])
data['translated'] = code in translations.keys()
appendtourl = '/'.join(append_path)
if data['translated']:
trans, direct, has_view_permission = translations[code]
if not has_view_permission:
# shortcut if the user cannot see the item
non_viewable.add((data['code']))
continue
data['url'] = trans.absolute_url() + appendtourl
else:
non_viewable.add((data['code']))
# filter out non-viewable items
results = [r for r in results if r['code'] not in non_viewable]
return results
def test_selector_viewlet_is_available_but_tool_is_not(self):
selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
selector_viewlet.update()
selector_viewlet.tool = None
self.assertFalse(selector_viewlet.available())
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.language_tool = getToolByName(self.portal, 'portal_languages')
self.language_tool.addSupportedLanguage('ca')
self.language_tool.addSupportedLanguage('es')
self.selector = LanguageSelectorViewlet(self.portal, self.request,
None, None)
def test_languages_partially_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone")
self.settings.selector_lookup_translations_policy = 'dialog'
# Setup content
self.setUpPartiallyTranslatedContent()
a_en = self.portal['en']['test-folder']['test-document']
selector = LanguageSelectorViewlet(a_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
# Check that EN translation is found
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
a_en.absolute_url()+'?set_language=en'
)
# But extra check, because English is the default?
self.assertIn(u'lang="en"'.encode("utf-8"), self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
tgid = selector_languages[1]['url'].split('/')[-2]
# Check that CA is not yet translated
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url() +
NOT_TRANSLATED_YET_TEMPLATE +
'/' + tgid + '?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check that ES is not yet translated
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url() +
NOT_TRANSLATED_YET_TEMPLATE +
'/' + tgid + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_selector_data_not_modified_by_viewlet(self):
selector_viewlet = \
LanguageSelectorViewlet(self.portal, self.request, None, None)
selector_viewlet.update()
selector_viewlet_languages = selector_viewlet.languages()
selector_adapter = \
LanguageSelector(self.portal, self.request, None, None)
selector_adapter.update()
selector_adapter_languages = selector_adapter.languages()
self.assertNotEquals(selector_adapter_languages,
selector_viewlet_languages)
def assertLanguagesPreserveQuery(self, policy):
self.setUpPartiallyTranslatedContent()
self.request['PATH_INFO'] = '/plone/en/test-folder/contact-info'
self.request.form['uni'] = u'pres\xd8rved'
self.request.form['int'] = '1'
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
tgid = selector_languages[2]['url'].split('/')[-3]
untranslated_url = {
'closest': (self.portal['es'].absolute_url() +
'?int=1&uni=pres%C3%98rved&set_language=es'),
'dialog':
(self.portal.absolute_url() + NOT_TRANSLATED_YET_TEMPLATE + '/' +
tgid + '?int=1&uni=pres%C3%98rved&set_language=es')
}
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
(f_en.absolute_url() +
'/contact-info?int=1&uni=pres%C3%98rved&set_language=en'))
self.assertIn(u'lang="en"'.encode("utf-8"), self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
(f_ca.absolute_url() +
'/contact-info?int=1&uni=pres%C3%98rved&set_language=ca'))
self.assertIn(u'lang="ca"'.encode("utf-8"), self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
self.assertEqual(self.browser.url, untranslated_url[policy])
self.assertIn(u'lang="es"'.encode("utf-8"), self.browser.contents)
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.language_tool = getToolByName(self.portal, 'portal_languages')
self.language_tool.addSupportedLanguage('ca')
self.language_tool.addSupportedLanguage('es')
self.selector = LanguageSelectorViewlet(self.portal,
self.request, None, None)
def test_languages_partially_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
self.setUpPartiallyTranslatedContent()
selector = LanguageSelectorViewlet(
self.portal.en.folder.document,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.document.absolute_url()+'?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
tgid = selector_languages[1]['url'].split('/')[-2]
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url() + \
NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid + '?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url() + \
NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_partially_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone")
self.settings.selector_lookup_translations_policy = 'closest'
# Setup content
self.setUpPartiallyTranslatedContent()
a_en = self.portal['en']['test-folder']['test-document']
f_ca = self.portal['ca']['test-folder']
selector = LanguageSelectorViewlet(a_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
# Check that EN translation is found
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
a_en.absolute_url() + '?set_language=en'
)
self.assertIn(u'lang="en"'.encode("utf-8"), self.browser.contents)
# But extra check, because English is the default?
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check that CA translation is only partial and a parent folder
# is found
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url() + '?set_language=ca'
)
self.assertIn(u'lang="ca"'.encode("utf-8"), self.browser.contents)
# Check that ES translation is missing and only the LRF is found
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal['es'].absolute_url() + '?set_language=es'
)
self.assertIn(u'lang="es"'.encode("utf-8"), self.browser.contents)
def test_languages_full_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
doc1 = makeContent(self.portal, 'Document', id='doc1')
doc1.setLanguage('en')
doc1_ca = makeTranslation(doc1, 'ca')
doc1_ca.edit(title="Foo", language='ca')
doc1_es = makeTranslation(doc1, 'es')
doc1_es.edit(title="Foo", language='es')
self.selector = LanguageSelectorViewlet(doc1, self.request, None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [{
'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/doc1?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'
}, {
'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/doc1-ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'
}, {
'code': u'es',
u'name': u'Spanish',
'url': 'http://nohost/plone/doc1-es?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'
}])
def test_selector_viewlet_is_available_but_tool_is_not(self):
selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
selector_viewlet.update()
selector_viewlet.tool = None
self.assertFalse(selector_viewlet.available())
def test_languages_root_folders_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
workflowTool = getToolByName(self.portal, "portal_workflow")
workflowTool.setDefaultChain('simple_publication_workflow')
setupTool = SetupMultilingualSite()
setupTool.setupSite(self.portal)
self.selector = LanguageSelectorViewlet(self.portal.en, self.request,
None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [{
'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/en?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'
}, {
'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'
}, {
'code': u'es',
u'name': u'Spanish',
'url': 'http://nohost/plone/es?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'
}])
def languages(self):
""" Deprecated """
context = aq_inner(self.context)
ls = LanguageSelector(context, self.request, None, None)
ls.update()
results = ls.languages()
supported_langs = [v['code'] for v in results]
missing = set([str(c) for c in supported_langs])
lsv = LanguageSelectorViewlet(context, self.request, None, None)
translations = lsv._translations(missing)
# We want to see the babel_view
append_path = (
'',
'babel_view',
)
non_viewable = set()
for data in results:
code = str(data['code'])
data['translated'] = code in translations.keys()
appendtourl = '/'.join(append_path)
if data['translated']:
trans, direct, has_view_permission = translations[code]
if not has_view_permission:
# shortcut if the user cannot see the item
non_viewable.add((data['code']))
continue
data['url'] = trans.absolute_url() + appendtourl
else:
non_viewable.add((data['code']))
# filter out non-viewable items
results = [r for r in results if r['code'] not in non_viewable]
return results
def setUp(self):
self.portal = self.layer['portal']
self.portal.error_log._ignored_exceptions = ()
self.request = self.layer['request']
self.browser = Browser(self.layer['app'])
self.browser.handleErrors = False
self.portal_url = self.portal.absolute_url()
self.language_tool = getToolByName(self.portal, 'portal_languages')
self.language_tool.addSupportedLanguage('ca')
self.language_tool.addSupportedLanguage('es')
self.selector = LanguageSelectorViewlet(self.portal,
self.request, None, None)
def test_languages_partially_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.setUpPartiallyTranslatedContent()
selector = LanguageSelectorViewlet(
self.portal.en.folder.document,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.document.absolute_url()+'?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.folder.absolute_url()+'?set_language=ca'
)
self.assertIn(
u"Inici".encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url()+'?set_language=es'
)
self.assertIn(
u"Usted está aquí".encode("utf-8"),
self.browser.contents
)
def assertSiteRoot(self):
self.selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
transaction.commit()
# Check EN root
self.assertEqual(
selector_languages[0]['url'],
(self.portal.absolute_url()
+ '/@@multilingual-selector/notg/en?set_language=en')
)
self.browser.open(selector_languages[0]['url'])
self.assertIn(
u'lang="en"'.encode("utf-8"),
self.browser.contents
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA root
self.assertEqual(
selector_languages[1]['url'],
(self.portal.absolute_url()
+ '/@@multilingual-selector/notg/ca?set_language=ca')
)
self.browser.open(selector_languages[1]['url'])
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check ES root
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
selector_languages[2]['url'],
(self.portal.absolute_url()
+ '/@@multilingual-selector/notg/es?set_language=es')
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_full_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
doc1 = makeContent(self.portal, 'Document', id='doc1')
doc1.setLanguage('en')
doc1_ca = makeTranslation(doc1, 'ca')
doc1_ca.edit(title="Foo", language='ca')
doc1_es = makeTranslation(doc1, 'es')
doc1_es.edit(title="Foo", language='es')
self.selector = LanguageSelectorViewlet(doc1,
self.request, None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [
{'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/doc1?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'},
{'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/doc1-ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'},
{'code': u'es',
u'name': u'Spanish',
'url': 'http://nohost/plone/doc1-es?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'}
])
def test_site_root(self):
for policy in ['closest', 'dialog']:
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = policy
transaction.commit()
self.selector = LanguageSelectorViewlet(
self.portal,
self.request,
None,
None
)
self.selector.update()
selector_languages = self.selector.languages()
self.browser.open(selector_languages[0]['url'])
#self.assertEqual(
# self.browser.url,
# self.portal.absolute_url()+'?set_language=en'
#)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.assertEqual(
selector_languages[1]['url'],
self.portal.absolute_url()+'/@@multilingual-selector/notg/ca?set_language=ca'
)
self.browser.open(selector_languages[1]['url'])
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
selector_languages[2]['url'],
self.portal.absolute_url()+'/@@multilingual-selector/notg/es?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_root_folders_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
workflowTool = getToolByName(self.portal, "portal_workflow")
workflowTool.setDefaultChain('simple_publication_workflow')
setupTool = SetupMultilingualSite()
setupTool.setupSite(self.portal)
self.selector = LanguageSelectorViewlet(self.portal.en,
self.request, None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [
{'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/en?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'},
{'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'},
{'code': u'es',
u'name': u'Spanish',
'url': 'http://nohost/plone/es?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'}
])
def test_languages_preserve_query(self):
self.setUpPartiallyTranslatedContent()
self.registry = getUtility(IRegistry)
self.request['PATH_INFO'] = '/plone/en/folder/@@search'
self.request.form['uni'] = u'pres\xd8rved'
self.request.form['int'] = '1'
selector = LanguageSelectorViewlet(
self.portal.en.folder,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
tgid = selector_languages[2]['url'].split('/')[-3]
untraslated_url = {
'closest': self.portal.es.absolute_url() + \
'?int=1&uni=pres%C3%98rved&set_language=es',
'dialog': self.portal.absolute_url() + \
NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid + \
'?int=1&uni=pres%C3%98rved&set_language=es'
}
for policy in ['closest', 'dialog']:
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = policy
transaction.commit()
selector = LanguageSelectorViewlet(
self.portal.en.folder,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.absolute_url() + \
'/@@search?int=1&uni=pres%C3%98rved&set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.folder.absolute_url() + \
'/@@search?int=1&uni=pres%C3%98rved&set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Here @@search isn't preserved because we've got the dialog
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
untraslated_url[policy]
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_set_language_is_present(self):
""" test the presence of set_language parameter in the urls created in the language selector"""
self.settings.set_cookie_always = False
self.selector_viewlet = LanguageSelectorViewlet(
self.portal['en'], self.request, None, None
)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
tg = ITG(self.portal['en'])
self.assertListEqual(
selector_languages,
[
{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'en',
'query': '?set_language=en',
},
'selected': True,
'translated': True,
},
{
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'ca',
'query': '?set_language=ca',
},
'selected': False,
'translated': True,
},
{
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'es',
'query': '?set_language=es',
},
'selected': False,
'translated': True,
},
],
)
class TestLanguageSelectorBasics(unittest.TestCase):
layer = PAM_FUNCTIONAL_TESTING
def setUp(self):
# Set test variables
self.portal = self.layer['portal']
self.portal_url = self.portal.absolute_url()
self.request = self.layer['request']
alsoProvides(self.layer['request'], IPloneAppMultilingualInstalled)
# Setup testbrowser
self.browser = Browser(self.layer['app'])
self.browser.handleErrors = False
def test_selector_viewlet_is_available(self):
selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
selector_viewlet.update()
self.assertTrue(selector_viewlet.available())
def test_selector_viewlet_is_available_but_tool_is_not(self):
selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
selector_viewlet.update()
selector_viewlet.tool = None
self.assertFalse(selector_viewlet.available())
def test_selector_data_not_modified_by_viewlet(self):
selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
selector_viewlet.update()
selector_viewlet_languages = selector_viewlet.languages()
selector_adapter = LanguageSelector(
self.portal, self.request, None, None
)
selector_adapter.update()
selector_adapter_languages = selector_adapter.languages()
self.assertNotEquals(
selector_adapter_languages, selector_viewlet_languages
)
def assertFullyTranslatedPages(self):
a = createContentInContainer(
self.portal['en'], 'Document', title=u"Test document"
)
a_ca = api.translate(a, 'ca')
a_ca.setTitle(u"Test Document (CA)")
a_es = api.translate(a, 'es')
a_es.setTitle(u"Test Document (ES)")
wftool = getToolByName(self.portal, 'portal_workflow')
wftool.doActionFor(a, 'publish')
wftool.doActionFor(a_ca, 'publish')
wftool.doActionFor(a_es, 'publish')
notify(ObjectModifiedEvent(a))
notify(ObjectModifiedEvent(a_ca))
notify(ObjectModifiedEvent(a_es))
selector_viewlet = LanguageSelectorViewlet(a, self.request, None, None)
selector_viewlet.update()
selector_viewlet_languages = selector_viewlet.languages()
self.assertEqual(
selector_viewlet_languages,
[
{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'en',
'query': '?set_language=en',
},
'selected': True,
'translated': True,
},
{
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'ca',
'query': '?set_language=ca',
},
'selected': False,
'translated': True,
},
{
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'es',
'query': '?set_language=es',
},
'selected': False,
'translated': True,
},
],
)
transaction.commit()
self.browser.open(selector_viewlet_languages[0]['url'])
self.assertEqual(
self.browser.url, a.absolute_url() + '?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_viewlet_languages[1]['url'])
self.assertEqual(
self.browser.url, a_ca.absolute_url() + '?set_language=ca'
)
self.assertIn('lang="ca"', self.browser.contents)
self.browser.open(selector_viewlet_languages[2]['url'])
self.assertEqual(
self.browser.url, a_es.absolute_url() + '?set_language=es'
)
self.assertIn('lang="es"', self.browser.contents)
def test_languages_fully_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertFullyTranslatedPages()
def test_languages_fully_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertFullyTranslatedPages()
def setUpPartiallyTranslatedContent(self):
wftool = getToolByName(self.portal, 'portal_workflow')
f_en = createContentInContainer(
self.portal['en'], 'Folder', title=u"Test folder"
)
wftool.doActionFor(f_en, 'publish')
a_en = createContentInContainer(
self.portal['en']['test-folder'],
'Document',
title=u"Test document",
)
wftool.doActionFor(a_en, 'publish')
f_ca = api.translate(f_en, 'ca')
f_ca.setTitle(u"Test folder CA")
wftool.doActionFor(f_ca, 'publish')
transaction.commit()
def setUpFullyTranslatedContent(self):
wftool = getToolByName(self.portal, 'portal_workflow')
self.setUpPartiallyTranslatedContent()
a_ca = api.translate(
self.portal['en']['test-folder']['test-document'], 'ca'
)
a_ca.setTitle(u"Test document CA")
wftool.doActionFor(a_ca, 'publish')
f_es = api.translate(self.portal['en']['test-folder'], 'es')
f_es.setTitle(u"Test folder ES")
wftool.doActionFor(f_es, 'publish')
a_es = api.translate(
self.portal['en']['test-folder']['test-document'], 'es'
)
a_es.setTitle(u"Test document ES")
wftool.doActionFor(a_es, 'publish')
transaction.commit()
def test_languages_untranslated_by_closest(self):
# Define selector policy
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
wftool = getToolByName(self.portal, "portal_workflow")
a_ca = createContentInContainer(
self.portal['ca'], 'Document', title=u"Test document"
)
a_ca.setLanguage('ca')
wftool.doActionFor(a_ca, 'publish')
view = selector_view(a_ca, self.request)
view.tg = ITG(a_ca)
# Check that the 'original' language gets the created document
view.lang = 'ca'
url = view.getClosestDestination()
self.assertEqual(url, a_ca.absolute_url())
# Check that untranslated languages get the nearest translated parent
view.lang = 'es'
url = view.getClosestDestination()
self.assertEqual(url, self.portal['es'].absolute_url())
view.lang = 'en'
url = view.getClosestDestination()
self.assertEqual(url, self.portal['en'].absolute_url())
# Check that translating content updates the closest destination
a_es = api.translate(a_ca, 'es')
view.lang = 'es'
url = view.getClosestDestination()
self.assertEqual(url, a_es.absolute_url())
def test_languages_partially_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
# Setup content
self.setUpPartiallyTranslatedContent()
a_en = self.portal['en']['test-folder']['test-document']
f_ca = self.portal['ca']['test-folder']
selector = LanguageSelectorViewlet(a_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
# Check that EN translation is found
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url, a_en.absolute_url() + '?set_language=en'
)
self.assertIn('lang="en"', self.browser.contents)
# But extra check, because English is the default?
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check that CA translation is only partial and a parent folder
# is found
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url, f_ca.absolute_url() + '?set_language=ca'
)
self.assertIn('lang="ca"', self.browser.contents)
# Check that ES translation is missing and only the LRF is found
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal['es'].absolute_url() + '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
def test_languages_partially_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
# Setup content
self.setUpPartiallyTranslatedContent()
a_en = self.portal['en']['test-folder']['test-document']
selector = LanguageSelectorViewlet(a_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
# Check that EN translation is found
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url, a_en.absolute_url() + '?set_language=en'
)
# But extra check, because English is the default?
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
tgid = selector_languages[1]['url'].split('/')[-2]
# Check that CA is not yet translated
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE
+ '/'
+ tgid
+ '?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check that ES is not yet translated
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE
+ '/'
+ tgid
+ '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
def assertSiteRoot(self):
self.selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
transaction.commit()
# Check EN root
self.assertEqual(
selector_languages[0]['url'],
(
self.portal.absolute_url()
+ '/@@multilingual-selector/notg/en?set_language=en'
),
)
self.browser.open(selector_languages[0]['url'])
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA root
self.assertEqual(
selector_languages[1]['url'],
(
self.portal.absolute_url()
+ '/@@multilingual-selector/notg/ca?set_language=ca'
),
)
self.browser.open(selector_languages[1]['url'])
self.assertIn('lang="ca"', self.browser.contents)
# Check ES root
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
selector_languages[2]['url'],
(
self.portal.absolute_url()
+ '/@@multilingual-selector/notg/es?set_language=es'
),
)
self.assertIn('lang="es"', self.browser.contents)
def test_siteroot_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertSiteRoot()
def test_siteroot_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertSiteRoot()
def assertRootFolders(self):
self.selector_viewlet = LanguageSelectorViewlet(
self.portal['en'], self.request, None, None
)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
tg = ITG(self.portal['en'])
self.assertEqual(
selector_languages,
[
{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'en',
'query': '?set_language=en',
},
'selected': True,
'translated': True,
},
{
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'ca',
'query': '?set_language=ca',
},
'selected': False,
'translated': True,
},
{
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'es',
'query': '?set_language=es',
},
'selected': False,
'translated': True,
},
],
)
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal['en'].absolute_url() + '?set_language=en',
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.absolute_url() + '?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url() + '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
def test_languages_root_folders_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertRootFolders()
def test_languages_root_folders_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertRootFolders()
def test_languages_preserve_view(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.setUpPartiallyTranslatedContent()
f_en = self.portal['en']['test-folder']
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
self.request['PATH_INFO'] = '/plone/en/test-folder/contact-info'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url() + '/contact-info?set_language=en',
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url() + '/contact-info?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've gone up a level
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url() + '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
# Shouldn't do for the not-translated-yet thingie when dialog is on
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url() + '/contact-info?set_language=en',
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url() + '/contact-info?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
tgid = selector_languages[2]['url'].split('/')[-3]
self.assertEqual(
self.browser.url,
self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE
+ '/'
+ tgid
+ '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
def assertLanguagesPreserveQuery(self, policy):
self.setUpPartiallyTranslatedContent()
self.request['PATH_INFO'] = '/plone/en/test-folder/contact-info'
self.request.form['uni'] = u'pres\xd8rved'
self.request.form['int'] = '1'
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
tgid = selector_languages[2]['url'].split('/')[-3]
untranslated_url = {
'closest': (
self.portal['es'].absolute_url()
+ '?int=1&uni=pres%C3%98rved&set_language=es'
),
'dialog': (
self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE
+ '/'
+ tgid
+ '?int=1&uni=pres%C3%98rved&set_language=es'
),
}
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertUrlsEqual(
self.browser.url,
(
f_en.absolute_url()
+ '/contact-info?int=1&uni=pres%C3%98rved&set_language=en'
),
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertUrlsEqual(
self.browser.url,
(
f_ca.absolute_url()
+ '/contact-info?int=1&uni=pres%C3%98rved&set_language=ca'
),
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
url = self.browser.url
if six.PY2 and isinstance(url, six.binary_type):
url = url.decode('utf8')
self.assertUrlsEqual(url, untranslated_url[policy])
self.assertIn('lang="es"', self.browser.contents)
def test_languages_preserve_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertLanguagesPreserveQuery('closest')
def test_languages_preserve_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertLanguagesPreserveQuery('dialog')
# XXX: this seems to me like a demented use case.
# If you put the VH _after_ the jail,
# for example mapping mysite.cat to /plone/ca and mysite.com to /plone/en,
# then I can't possibly make the whole language switcher work
# because I have no idea to which domain I should reroute the request
# (that information is sitting in nginx|apache config,
# therefore I cannot conceivably gather it).
# Therefore, while PAM knows which is the translation object,
# it can't figure out its URL correctly.
# At most, it can leverage acquisition so that,
# if you switch from mysite.com/my/object to catalan,
# it goes to mysite.com/ca/my/object
# (which has a path of /plone/en/my/object/ca/my/object),
# but that is too fragile and sucky for me to take care of supporting it.
#
# The original test case is below: if you wrote it,
# I'll be glad to hear which was the use case
# and what is your idea to make it work.
#
# def test_languages_vhr(self):
# registry = getUtility(IRegistry)
# settings = registry.forInterface(IMultiLanguageExtraOptionsSchema)
# settings.selector_lookup_translations_policy = 'dialog'
#
# from Products.CMFCore.interfaces import ISiteRoot
# from zope.interface import alsoProvides
# provideAdapter(DummyState, adapts=(Dummy, DummyRequest),
# provides=Interface, name="plone_context_state")
# context = Dummy()
# context.__parent__ = self.portal
# context.portal_url = Dummy()
# container = Dummy()
# context = context.__of__(container)
# alsoProvides(container, ISiteRoot)
# request = DummyRequest()
# selector = LanguageSelectorViewlet(context, request, None, None)
# context.physicalpath = ['', 'fake', 'path']
# vbase = '/VirtualHostBase/http/127.0.0.1/'
# request.PATH_INFO = vbase + 'fake/path/VirtualHostRoot/to/object'
# request.form['uni'] = u'pres\xd8rved'
# request.form['int'] = '1'
# notify(ObjectCreatedEvent(context))
# IUUID(context, None)
# selector.update()
# selector.tool = MockLanguageTool()
# base = 'object_url/to/object?int=1&uni='
# expected = [
# {'code': 'nl',
# 'translated': True,
# 'selected': False,
# 'url': base + 'pres%C3%98rved&set_language=nl'},
# {'code': 'en',
# 'translated': True,
# 'selected': True,
# 'url': base + 'pres%C3%98rved&set_language=en'},
# {'code': 'no',
# 'translated': False,
# 'selected': False,
# 'url': base + 'pres%C3%98rved&set_language=no'}]
# self.assertEqual(selector.languages(), expected)
def assertUrlsEqual(self, url1, url2):
"""The order of query-strings is sometimes random in python 3
This compares urls disregarding the order.
"""
parsed_url_1 = urlparse(safe_nativestring(url1))
parse_qs_1 = parse_qs(parsed_url_1.query)
parsed_url_2 = urlparse(safe_nativestring(url2))
parse_qs_2 = parse_qs(parsed_url_2.query)
self.assertEqual(parsed_url_1[0], parsed_url_2[0])
self.assertEqual(parsed_url_1[1], parsed_url_2[1])
self.assertEqual(parsed_url_1[2], parsed_url_2[2])
self.assertEqual(parsed_url_1[3], parsed_url_2[3])
self.assertEqual(parse_qs_1, parse_qs_2)
def assertFullyTranslatedPages(self):
a = createContentInContainer(
self.portal['en'], 'Document', title=u"Test document"
)
a_ca = api.translate(a, 'ca')
a_ca.setTitle(u"Test Document (CA)")
a_es = api.translate(a, 'es')
a_es.setTitle(u"Test Document (ES)")
wftool = getToolByName(self.portal, 'portal_workflow')
wftool.doActionFor(a, 'publish')
wftool.doActionFor(a_ca, 'publish')
wftool.doActionFor(a_es, 'publish')
notify(ObjectModifiedEvent(a))
notify(ObjectModifiedEvent(a_ca))
notify(ObjectModifiedEvent(a_es))
selector_viewlet = LanguageSelectorViewlet(a, self.request, None, None)
selector_viewlet.update()
selector_viewlet_languages = selector_viewlet.languages()
self.assertEqual(
selector_viewlet_languages,
[
{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'en',
'query': '?set_language=en',
},
'selected': True,
'translated': True,
},
{
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'ca',
'query': '?set_language=ca',
},
'selected': False,
'translated': True,
},
{
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'es',
'query': '?set_language=es',
},
'selected': False,
'translated': True,
},
],
)
transaction.commit()
self.browser.open(selector_viewlet_languages[0]['url'])
self.assertEqual(
self.browser.url, a.absolute_url() + '?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_viewlet_languages[1]['url'])
self.assertEqual(
self.browser.url, a_ca.absolute_url() + '?set_language=ca'
)
self.assertIn('lang="ca"', self.browser.contents)
self.browser.open(selector_viewlet_languages[2]['url'])
self.assertEqual(
self.browser.url, a_es.absolute_url() + '?set_language=es'
)
self.assertIn('lang="es"', self.browser.contents)
class TestLanguageSelectorSetLanguage(unittest.TestCase):
layer = PAM_INTEGRATION_PRESET_TESTING
def setUp(self):
# Set test variables
self.portal = self.layer['portal']
self.portal_url = self.portal.absolute_url()
self.request = self.layer['request']
alsoProvides(self.layer['request'], IPloneAppMultilingualInstalled)
registry = getUtility(IRegistry)
self.settings = registry.forInterface(ILanguageSchema, prefix="plone")
def test_set_language_is_present(self):
""" test the presence of set_language parameter in the urls created in the language selector"""
self.settings.set_cookie_always = False
self.selector_viewlet = LanguageSelectorViewlet(
self.portal['en'], self.request, None, None
)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
tg = ITG(self.portal['en'])
self.assertListEqual(
selector_languages,
[
{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'en',
'query': '?set_language=en',
},
'selected': True,
'translated': True,
},
{
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'ca',
'query': '?set_language=ca',
},
'selected': False,
'translated': True,
},
{
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'es',
'query': '?set_language=es',
},
'selected': False,
'translated': True,
},
],
)
def test_set_language_is_not_present_when_always_set_cookie_is_set(self):
""" test the absence of set_language parameter in the urls created in the language selector"""
self.settings.set_cookie_always = True
self.selector_viewlet = LanguageSelectorViewlet(
self.portal['en'], self.request, None, None
)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
tg = ITG(self.portal['en'])
self.assertListEqual(
selector_languages,
[
{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'en',
'query': '',
},
'selected': True,
'translated': True,
},
{
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'ca',
'query': '',
},
'selected': False,
'translated': True,
},
{
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'es',
'query': '',
},
'selected': False,
'translated': True,
},
],
)
def test_selector_viewlet_is_available(self):
selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
selector_viewlet.update()
self.assertTrue(selector_viewlet.available())
class TestLanguageSelectorBasics(unittest.TestCase):
layer = PAM_FUNCTIONAL_TESTING
def setUp(self):
# Set test variables
self.portal = self.layer['portal']
self.portal_url = self.portal.absolute_url()
self.request = self.layer['request']
# Setup testbrowser
self.browser = Browser(self.layer['app'])
self.browser.handleErrors = False
def test_selector_viewlet_is_available(self):
selector_viewlet = \
LanguageSelectorViewlet(self.portal, self.request, None, None)
selector_viewlet.update()
self.assertTrue(selector_viewlet.available())
def test_selector_viewlet_is_available_but_tool_is_not(self):
selector_viewlet = \
LanguageSelectorViewlet(self.portal, self.request, None, None)
selector_viewlet.update()
selector_viewlet.tool = None
self.assertFalse(selector_viewlet.available())
def test_selector_data_not_modified_by_viewlet(self):
selector_viewlet = \
LanguageSelectorViewlet(self.portal, self.request, None, None)
selector_viewlet.update()
selector_viewlet_languages = selector_viewlet.languages()
selector_adapter = \
LanguageSelector(self.portal, self.request, None, None)
selector_adapter.update()
selector_adapter_languages = selector_adapter.languages()
self.assertNotEquals(selector_adapter_languages,
selector_viewlet_languages)
def assertFullyTranslatedPages(self):
a = createContentInContainer(
self.portal['en'], 'Document', title=u"Test document")
a_ca = api.translate(a, 'ca')
a_ca.setTitle(u"Test Document (CA)")
a_es = api.translate(a, 'es')
a_es.setTitle(u"Test Document (ES)")
wftool = getToolByName(self.portal, 'portal_workflow')
wftool.doActionFor(a, 'publish')
wftool.doActionFor(a_ca, 'publish')
wftool.doActionFor(a_es, 'publish')
notify(ObjectModifiedEvent(a))
notify(ObjectModifiedEvent(a_ca))
notify(ObjectModifiedEvent(a_es))
selector_viewlet =\
LanguageSelectorViewlet(a, self.request, None, None)
selector_viewlet.update()
selector_viewlet_languages = selector_viewlet.languages()
self.assertEqual(selector_viewlet_languages, [{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'en',
'query': '?set_language=en'
},
'selected': True,
'translated': True,
}, {
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'ca',
'query': '?set_language=ca'
},
'selected': False,
'translated': True,
}, {
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'es',
'query': '?set_language=es'
},
'selected': False,
'translated': True,
}])
transaction.commit()
self.browser.open(selector_viewlet_languages[0]['url'])
self.assertEqual(self.browser.url,
a.absolute_url() + '?set_language=en')
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_viewlet_languages[1]['url'])
self.assertEqual(self.browser.url,
a_ca.absolute_url() + '?set_language=ca')
self.assertIn(u'lang="ca"'.encode("utf-8"), self.browser.contents)
self.browser.open(selector_viewlet_languages[2]['url'])
self.assertEqual(self.browser.url,
a_es.absolute_url() + '?set_language=es')
self.assertIn(u'lang="es"'.encode("utf-8"), self.browser.contents)
def test_languages_fully_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertFullyTranslatedPages()
def test_languages_fully_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertFullyTranslatedPages()
def setUpPartiallyTranslatedContent(self):
wftool = getToolByName(self.portal, 'portal_workflow')
f_en = createContentInContainer(
self.portal['en'], 'Folder', title=u"Test folder")
wftool.doActionFor(f_en, 'publish')
a_en = createContentInContainer(
self.portal['en']['test-folder'], 'Document',
title=u"Test document")
wftool.doActionFor(a_en, 'publish')
f_ca = api.translate(f_en, 'ca')
f_ca.setTitle(u"Test folder CA")
wftool.doActionFor(f_ca, 'publish')
transaction.commit()
def setUpFullyTranslatedContent(self):
wftool = getToolByName(self.portal, 'portal_workflow')
self.setUpPartiallyTranslatedContent()
a_ca = api.translate(
self.portal['en']['test-folder']['test-document'], 'ca')
a_ca.setTitle(u"Test document CA")
wftool.doActionFor(a_ca, 'publish')
f_es = api.translate(
self.portal['en']['test-folder'], 'es')
f_es.setTitle(u"Test folder ES")
wftool.doActionFor(f_es, 'publish')
a_es = api.translate(
self.portal['en']['test-folder']['test-document'], 'es')
a_es.setTitle(u"Test document ES")
wftool.doActionFor(a_es, 'publish')
transaction.commit()
def test_languages_untranslated_by_closest(self):
# Define selector policy
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
wftool = getToolByName(self.portal, "portal_workflow")
a_ca = createContentInContainer(
self.portal['ca'], 'Document', title=u"Test document")
a_ca.setLanguage('ca')
wftool.doActionFor(a_ca, 'publish')
view = selector_view(a_ca, self.request)
view.tg = ITG(a_ca)
# Check that the 'original' language gets the created document
view.lang = 'ca'
url = view.getClosestDestination()
self.assertEqual(url, a_ca.absolute_url())
# Check that untranslated languages get the nearest translated parent
view.lang = 'es'
url = view.getClosestDestination()
self.assertEqual(url, self.portal['es'].absolute_url())
view.lang = 'en'
url = view.getClosestDestination()
self.assertEqual(url, self.portal['en'].absolute_url())
# Check that translating content updates the closest destination
a_es = api.translate(a_ca, 'es')
view.lang = 'es'
url = view.getClosestDestination()
self.assertEqual(url, a_es.absolute_url())
def test_languages_partially_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
# Setup content
self.setUpPartiallyTranslatedContent()
a_en = self.portal['en']['test-folder']['test-document']
f_ca = self.portal['ca']['test-folder']
selector = LanguageSelectorViewlet(a_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
# Check that EN translation is found
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
a_en.absolute_url() + '?set_language=en'
)
self.assertIn(u'lang="en"'.encode("utf-8"), self.browser.contents)
# But extra check, because English is the default?
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check that CA translation is only partial and a parent folder
# is found
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url() + '?set_language=ca'
)
self.assertIn(u'lang="ca"'.encode("utf-8"), self.browser.contents)
# Check that ES translation is missing and only the LRF is found
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal['es'].absolute_url() + '?set_language=es'
)
self.assertIn(u'lang="es"'.encode("utf-8"), self.browser.contents)
def test_languages_partially_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
# Setup content
self.setUpPartiallyTranslatedContent()
a_en = self.portal['en']['test-folder']['test-document']
selector = LanguageSelectorViewlet(a_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
# Check that EN translation is found
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
a_en.absolute_url()+'?set_language=en'
)
# But extra check, because English is the default?
self.assertIn(u'lang="en"'.encode("utf-8"), self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
tgid = selector_languages[1]['url'].split('/')[-2]
# Check that CA is not yet translated
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url() +
NOT_TRANSLATED_YET_TEMPLATE +
'/' + tgid + '?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check that ES is not yet translated
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url() +
NOT_TRANSLATED_YET_TEMPLATE +
'/' + tgid + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def assertSiteRoot(self):
self.selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
transaction.commit()
# Check EN root
self.assertEqual(
selector_languages[0]['url'],
(self.portal.absolute_url()
+ '/@@multilingual-selector/notg/en?set_language=en')
)
self.browser.open(selector_languages[0]['url'])
self.assertIn(
u'lang="en"'.encode("utf-8"),
self.browser.contents
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA root
self.assertEqual(
selector_languages[1]['url'],
(self.portal.absolute_url()
+ '/@@multilingual-selector/notg/ca?set_language=ca')
)
self.browser.open(selector_languages[1]['url'])
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check ES root
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
selector_languages[2]['url'],
(self.portal.absolute_url()
+ '/@@multilingual-selector/notg/es?set_language=es')
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_siteroot_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertSiteRoot()
def test_siteroot_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertSiteRoot()
def assertRootFolders(self):
self.selector_viewlet = LanguageSelectorViewlet(
self.portal['en'], self.request, None, None)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
tg = ITG(self.portal['en'])
self.assertEqual(selector_languages, [{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'en',
'query': '?set_language=en'
},
'selected': True,
'translated': True,
}, {
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'ca',
'query': '?set_language=ca'
},
'selected': False,
'translated': True,
}, {
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'es',
'query': '?set_language=es'
},
'selected': False,
'translated': True,
}])
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal['en'].absolute_url()+'?set_language=en'
)
self.assertIn(
u'lang="en"'.encode("utf-8"),
self.browser.contents
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.absolute_url()+'?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check ES
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url()+'?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_root_folders_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertRootFolders()
def test_languages_root_folders_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertRootFolders()
def test_languages_preserve_view(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.setUpPartiallyTranslatedContent()
f_en = self.portal['en']['test-folder']
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
self.request['PATH_INFO'] = '/plone/en/test-folder/@@search'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url()+'/@@search?set_language=en'
)
self.assertIn(
u'lang="en"'.encode("utf-8"),
self.browser.contents
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url()+'/@@search?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've gone up a level
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url()+'?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
# Shouldn't do for the not-translated-yet thingie when dialog is on
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url()+'/@@search?set_language=en'
)
self.assertIn(
u'lang="en"'.encode("utf-8"),
self.browser.contents
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url()+'/@@search?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
tgid = selector_languages[2]['url'].split('/')[-3]
self.assertEqual(
self.browser.url,
self.portal.absolute_url() +
NOT_TRANSLATED_YET_TEMPLATE +
'/' + tgid + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def assertLanguagesPreserveQuery(self, policy):
self.setUpPartiallyTranslatedContent()
self.request['PATH_INFO'] = '/plone/en/test-folder/@@search'
self.request.form['uni'] = u'pres\xd8rved'
self.request.form['int'] = '1'
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
tgid = selector_languages[2]['url'].split('/')[-3]
untranslated_url = {
'closest': (self.portal['es'].absolute_url()
+ '?int=1&uni=pres%C3%98rved&set_language=es'),
'dialog': (self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid
+ '?int=1&uni=pres%C3%98rved&set_language=es')
}
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
(f_en.absolute_url()
+ '/@@search?int=1&uni=pres%C3%98rved&set_language=en')
)
self.assertIn(
u'lang="en"'.encode("utf-8"),
self.browser.contents
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
(f_ca.absolute_url()
+ '/@@search?int=1&uni=pres%C3%98rved&set_language=ca')
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
self.assertEqual(
self.browser.url,
untranslated_url[policy]
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_preserve_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertLanguagesPreserveQuery('closest')
def test_languages_preserve_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertLanguagesPreserveQuery('dialog')
def test_languages_preserve_view(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguageExtraOptionsSchema, prefix="plone")
self.settings.selector_lookup_translations_policy = 'closest'
self.setUpPartiallyTranslatedContent()
f_en = self.portal['en']['test-folder']
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
self.request['PATH_INFO'] = '/plone/en/test-folder/contact-info'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url()+'/contact-info?set_language=en'
)
self.assertIn(
u'lang="en"'.encode("utf-8"),
self.browser.contents
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url()+'/contact-info?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've gone up a level
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url()+'?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
# Shouldn't do for the not-translated-yet thingie when dialog is on
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguageExtraOptionsSchema, prefix="plone")
self.settings.selector_lookup_translations_policy = 'dialog'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url()+'/contact-info?set_language=en'
)
self.assertIn(
u'lang="en"'.encode("utf-8"),
self.browser.contents
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url()+'/contact-info?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
tgid = selector_languages[2]['url'].split('/')[-3]
self.assertEqual(
self.browser.url,
self.portal.absolute_url() +
NOT_TRANSLATED_YET_TEMPLATE +
'/' + tgid + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_preserve_view(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.setUpPartiallyTranslatedContent()
f_en = self.portal['en']['test-folder']
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
self.request['PATH_INFO'] = '/plone/en/test-folder/contact-info'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url() + '/contact-info?set_language=en',
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url() + '/contact-info?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've gone up a level
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url() + '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
# Shouldn't do for the not-translated-yet thingie when dialog is on
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url() + '/contact-info?set_language=en',
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url() + '/contact-info?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
tgid = selector_languages[2]['url'].split('/')[-3]
self.assertEqual(
self.browser.url,
self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE
+ '/'
+ tgid
+ '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
def assertRootFolders(self):
self.selector = LanguageSelectorViewlet(self.portal.en,
self.request, None, None)
tg = ITG(self.portal.en)
self.selector.update()
selector_languages = self.selector.languages()
self.assertEqual(selector_languages, [
{
'code': u'en',
u'name': u'English',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'en',
'query': '?set_language=en'
},
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'},
{
'code': u'ca',
u'name': u'Catalan',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'ca',
'query': '?set_language=ca'
},
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'
},
{
'code': u'es',
u'name': u'Spanish',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'es',
'query': '?set_language=es'
},
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'
}
])
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.absolute_url()+'?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.absolute_url()+'?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url()+'?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_preserve_view(self):
self.setUpPartiallyTranslatedContent()
self.registry = getUtility(IRegistry)
self.request['PATH_INFO'] = '/plone/en/folder/@@search'
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
transaction.commit()
selector = LanguageSelectorViewlet(
self.portal.en.folder,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.absolute_url()+'/@@search?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.folder.absolute_url()+'/@@search?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Here @@search isn't preserved because we've gone up a level
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url()+'?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
# Shouldn't do for the not-translated-yet thingie when dialog is on
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
transaction.commit()
selector = LanguageSelectorViewlet(
self.portal.en.folder,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.absolute_url()+'/@@search?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.folder.absolute_url()+'/@@search?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Here @@search isn't preserved because we've got the dialog
self.browser.open(selector_languages[2]['url'])
tgid = selector_languages[2]['url'].split('/')[-3]
self.assertEqual(
self.browser.url,
self.portal.absolute_url() + \
NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
class TestLanguageSelectorBasics(unittest.TestCase):
layer = PLONEAPPMULTILINGUAL_INTEGRATION_TESTING
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.language_tool = getToolByName(self.portal, 'portal_languages')
self.language_tool.addSupportedLanguage('ca')
self.language_tool.addSupportedLanguage('es')
self.selector = LanguageSelectorViewlet(self.portal, self.request,
None, None)
def test_available(self):
self.selector.update()
self.assertEquals(self.selector.available(), True)
def test_available_no_tool(self):
self.selector.update()
self.selector.tool = None
self.assertEquals(self.selector.available(), False)
def test_original_selector_data_not_modified_by_viewlet(self):
self.selector.update()
multilingual_lang_info = self.selector.languages()
original_selector = LanguageSelector(self.portal, self.request, None,
None)
original_selector.update()
original_lang_info = original_selector.languages()
self.assertNotEquals(original_lang_info, multilingual_lang_info)
def test_languages_full_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
doc1 = makeContent(self.portal, 'Document', id='doc1')
doc1.setLanguage('en')
doc1_ca = makeTranslation(doc1, 'ca')
doc1_ca.edit(title="Foo", language='ca')
doc1_es = makeTranslation(doc1, 'es')
doc1_es.edit(title="Foo", language='es')
self.selector = LanguageSelectorViewlet(doc1, self.request, None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [{
'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/doc1?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'
}, {
'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/doc1-ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'
}, {
'code': u'es',
u'name': u'Spanish',
'url': 'http://nohost/plone/doc1-es?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'
}])
def test_languages_partially_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
p1 = makeContent(self.portal, 'Document', id='partial')
p1.setLanguage('en')
p1_ca = makeTranslation(p1, 'ca')
p1_ca.edit(title="Foo ca", language='ca')
self.selector = LanguageSelectorViewlet(p1, self.request, None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [{
'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/partial?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'
}, {
'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/partial-ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'
}, {
'code': u'es',
u'name': u'Spanish',
'url':
'http://nohost/plone/partial/not_translated_yet?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': False,
u'native': u'Espa\xf1ol'
}])
def test_languages_root_folders_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
workflowTool = getToolByName(self.portal, "portal_workflow")
workflowTool.setDefaultChain('simple_publication_workflow')
setupTool = SetupMultilingualSite()
setupTool.setupSite(self.portal)
self.selector = LanguageSelectorViewlet(self.portal.en, self.request,
None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [{
'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/en?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'
}, {
'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'
}, {
'code': u'es',
u'name': u'Spanish',
'url': 'http://nohost/plone/es?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'
}])
def test_selector_viewlet_is_available(self):
selector_viewlet = \
LanguageSelectorViewlet(self.portal, self.request, None, None)
selector_viewlet.update()
self.assertTrue(selector_viewlet.available())
def assertFullyTranslatedPages(self):
a = createContentInContainer(
self.portal['en'], 'Document', title=u"Test document")
a_ca = api.translate(a, 'ca')
a_ca.setTitle(u"Test Document (CA)")
a_es = api.translate(a, 'es')
a_es.setTitle(u"Test Document (ES)")
wftool = getToolByName(self.portal, 'portal_workflow')
wftool.doActionFor(a, 'publish')
wftool.doActionFor(a_ca, 'publish')
wftool.doActionFor(a_es, 'publish')
notify(ObjectModifiedEvent(a))
notify(ObjectModifiedEvent(a_ca))
notify(ObjectModifiedEvent(a_es))
selector_viewlet =\
LanguageSelectorViewlet(a, self.request, None, None)
selector_viewlet.update()
selector_viewlet_languages = selector_viewlet.languages()
self.assertEqual(selector_viewlet_languages, [{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'en',
'query': '?set_language=en'
},
'selected': True,
'translated': True,
}, {
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'ca',
'query': '?set_language=ca'
},
'selected': False,
'translated': True,
}, {
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'es',
'query': '?set_language=es'
},
'selected': False,
'translated': True,
}])
transaction.commit()
self.browser.open(selector_viewlet_languages[0]['url'])
self.assertEqual(self.browser.url,
a.absolute_url() + '?set_language=en')
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_viewlet_languages[1]['url'])
self.assertEqual(self.browser.url,
a_ca.absolute_url() + '?set_language=ca')
self.assertIn(u'lang="ca"'.encode("utf-8"), self.browser.contents)
self.browser.open(selector_viewlet_languages[2]['url'])
self.assertEqual(self.browser.url,
a_es.absolute_url() + '?set_language=es')
self.assertIn(u'lang="es"'.encode("utf-8"), self.browser.contents)
def setUp(self):
self.selector = LanguageSelectorViewlet(None, None, None, None)
self.fp = self.selector._findpath
def assertLanguagesPreserveQuery(self, policy):
self.setUpPartiallyTranslatedContent()
self.request['PATH_INFO'] = '/plone/en/test-folder/@@search'
self.request.form['uni'] = u'pres\xd8rved'
self.request.form['int'] = '1'
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
tgid = selector_languages[2]['url'].split('/')[-3]
untranslated_url = {
'closest': (self.portal['es'].absolute_url()
+ '?int=1&uni=pres%C3%98rved&set_language=es'),
'dialog': (self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid
+ '?int=1&uni=pres%C3%98rved&set_language=es')
}
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
(f_en.absolute_url()
+ '/@@search?int=1&uni=pres%C3%98rved&set_language=en')
)
self.assertIn(
u'lang="en"'.encode("utf-8"),
self.browser.contents
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
(f_ca.absolute_url()
+ '/@@search?int=1&uni=pres%C3%98rved&set_language=ca')
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
self.assertEqual(
self.browser.url,
untranslated_url[policy]
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
class TestLanguageSelectorBasics(unittest.TestCase):
layer = PLONEAPPMULTILINGUAL_FUNCTIONAL_TESTING
def setUp(self):
self.portal = self.layer['portal']
self.portal.error_log._ignored_exceptions = ()
self.request = self.layer['request']
self.browser = Browser(self.layer['app'])
self.browser.handleErrors = False
self.portal_url = self.portal.absolute_url()
self.language_tool = getToolByName(self.portal, 'portal_languages')
self.language_tool.addSupportedLanguage('ca')
self.language_tool.addSupportedLanguage('es')
self.selector = LanguageSelectorViewlet(self.portal,
self.request, None, None)
def test_available(self):
self.selector.update()
self.assertEquals(self.selector.available(), True)
def test_available_no_tool(self):
self.selector.update()
self.selector.tool = None
self.assertEquals(self.selector.available(), False)
def test_original_selector_data_not_modified_by_viewlet(self):
self.selector.update()
multilingual_lang_info = self.selector.languages()
original_selector = LanguageSelector(self.portal,
self.request, None, None)
original_selector.update()
original_lang_info = original_selector.languages()
self.assertNotEquals(original_lang_info, multilingual_lang_info)
def assertFullyTranslatedPages(self):
doc1 = makeContent(self.portal, 'Document', id='doc1')
doc1.setLanguage('en')
doc1_tg = ITG(doc1)
doc1_ca = makeTranslation(doc1, 'ca')
doc1_ca.edit(title="Foo", language='ca')
doc1_es = makeTranslation(doc1, 'es')
doc1_es.edit(title="Foo", language='es')
self.selector = LanguageSelectorViewlet(doc1,
self.request, None, None)
self.selector.update()
selector_languages = self.selector.languages()
self.assertEqual(selector_languages, [
{
'code': u'en',
u'name': u'English',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': doc1_tg,
'lang': 'en',
'query': '?set_language=en'
},
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'
},
{
'code': u'ca',
u'name': u'Catalan',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': doc1_tg,
'lang': 'ca',
'query': '?set_language=ca'
},
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'
},
{
'code': u'es',
u'name': u'Spanish',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': doc1_tg,
'lang': 'es',
'query': '?set_language=es'
},
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'
}
])
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
doc1.absolute_url() + '?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
doc1_ca.absolute_url() + '?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
doc1_es.absolute_url() + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_full_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertFullyTranslatedPages()
def test_languages_full_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertFullyTranslatedPages()
def setUpPAMFolders(self):
workflowTool = getToolByName(self.portal, "portal_workflow")
workflowTool.setDefaultChain('simple_publication_workflow')
setupTool = SetupMultilingualSite()
setupTool.setupSite(self.portal)
transaction.commit()
return workflowTool
def setUpPartiallyTranslatedContent(self):
wftool = self.setUpPAMFolders()
folder = makeContent(self.portal.en, 'Folder', id='folder')
folder.setLanguage('en')
wftool.doActionFor(folder, 'publish')
document = makeContent(folder, 'Document', id='document')
document.setLanguage('en')
wftool.doActionFor(document, 'publish')
folder_ca = makeTranslation(folder, 'ca')
folder_ca.edit(title="Foo", language='ca')
wftool.doActionFor(folder_ca, 'publish')
transaction.commit()
return wftool
def setUpFullyTranslatedContent(self):
wftool = self.setUpPartiallyTranslatedContent()
document_ca = makeTranslation(self.portal.en.folder.document, 'ca')
document_ca.edit(title="Foo", language='ca')
wftool.doActionFor(document_ca, 'publish')
folder_es = makeTranslation(self.portal.en.folder, 'es')
folder_es.edit(title="Foo", language='es')
wftool.doActionFor(folder_es, 'publish')
document_es = makeTranslation(self.portal.en.folder.document, 'es')
document_es.edit(title="Foo", language='es')
wftool.doActionFor(document_es, 'publish')
transaction.commit()
return wftool
def test_languages_untranslated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.setUpPAMFolders()
document = makeContent(self.portal.ca, 'Document', id='untranslated')
document.setLanguage('ca')
wftool = getToolByName(self.portal, "portal_workflow")
wftool.doActionFor(document, 'publish')
transaction.commit()
view = selector_view(document, self.layer['request'])
view.lang = 'es'
view.tg = ITG(document)
url = view.getClosestDestination()
self.assertEqual(url, self.portal.es.absolute_url())
view.lang = 'it'
url = view.getClosestDestination()
self.assertEqual(url, self.portal.absolute_url())
def test_languages_partially_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.setUpPartiallyTranslatedContent()
selector = LanguageSelectorViewlet(
self.portal.en.folder.document,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.document.absolute_url()+'?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.folder.absolute_url()+'?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url()+'?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_partially_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
self.setUpPartiallyTranslatedContent()
selector = LanguageSelectorViewlet(
self.portal.en.folder.document,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.document.absolute_url()+'?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
tgid = selector_languages[1]['url'].split('/')[-2]
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url() + \
NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid + '?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url() + \
NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_site_root(self):
for policy in ['closest', 'dialog']:
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = policy
transaction.commit()
self.selector = LanguageSelectorViewlet(
self.portal,
self.request,
None,
None
)
self.selector.update()
selector_languages = self.selector.languages()
self.browser.open(selector_languages[0]['url'])
#self.assertEqual(
# self.browser.url,
# self.portal.absolute_url()+'?set_language=en'
#)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.assertEqual(
selector_languages[1]['url'],
self.portal.absolute_url()+'/@@multilingual-selector/notg/ca?set_language=ca'
)
self.browser.open(selector_languages[1]['url'])
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
selector_languages[2]['url'],
self.portal.absolute_url()+'/@@multilingual-selector/notg/es?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def assertRootFolders(self):
self.selector = LanguageSelectorViewlet(self.portal.en,
self.request, None, None)
tg = ITG(self.portal.en)
self.selector.update()
selector_languages = self.selector.languages()
self.assertEqual(selector_languages, [
{
'code': u'en',
u'name': u'English',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'en',
'query': '?set_language=en'
},
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'},
{
'code': u'ca',
u'name': u'Catalan',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'ca',
'query': '?set_language=ca'
},
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'
},
{
'code': u'es',
u'name': u'Spanish',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'es',
'query': '?set_language=es'
},
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'
}
])
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.absolute_url()+'?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.absolute_url()+'?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url()+'?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_root_folders_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
self.setUpPAMFolders()
self.assertRootFolders()
def test_languages_root_folders_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
self.setUpPAMFolders()
self.assertRootFolders()
def test_languages_preserve_view(self):
self.setUpPartiallyTranslatedContent()
self.registry = getUtility(IRegistry)
self.request['PATH_INFO'] = '/plone/en/folder/@@search'
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
transaction.commit()
selector = LanguageSelectorViewlet(
self.portal.en.folder,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.absolute_url()+'/@@search?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.folder.absolute_url()+'/@@search?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Here @@search isn't preserved because we've gone up a level
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url()+'?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
# Shouldn't do for the not-translated-yet thingie when dialog is on
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
transaction.commit()
selector = LanguageSelectorViewlet(
self.portal.en.folder,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.absolute_url()+'/@@search?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.folder.absolute_url()+'/@@search?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Here @@search isn't preserved because we've got the dialog
self.browser.open(selector_languages[2]['url'])
tgid = selector_languages[2]['url'].split('/')[-3]
self.assertEqual(
self.browser.url,
self.portal.absolute_url() + \
NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def test_languages_preserve_query(self):
self.setUpPartiallyTranslatedContent()
self.registry = getUtility(IRegistry)
self.request['PATH_INFO'] = '/plone/en/folder/@@search'
self.request.form['uni'] = u'pres\xd8rved'
self.request.form['int'] = '1'
selector = LanguageSelectorViewlet(
self.portal.en.folder,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
tgid = selector_languages[2]['url'].split('/')[-3]
untraslated_url = {
'closest': self.portal.es.absolute_url() + \
'?int=1&uni=pres%C3%98rved&set_language=es',
'dialog': self.portal.absolute_url() + \
NOT_TRANSLATED_YET_TEMPLATE + '/' + tgid + \
'?int=1&uni=pres%C3%98rved&set_language=es'
}
for policy in ['closest', 'dialog']:
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = policy
transaction.commit()
selector = LanguageSelectorViewlet(
self.portal.en.folder,
self.request,
None,
None
)
selector.update()
selector_languages = selector.languages()
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal.en.folder.absolute_url() + \
'/@@search?int=1&uni=pres%C3%98rved&set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.folder.absolute_url() + \
'/@@search?int=1&uni=pres%C3%98rved&set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
# Here @@search isn't preserved because we've got the dialog
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
untraslated_url[policy]
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
class TestLanguageSelectorBasics(unittest.TestCase):
layer = PLONEAPPMULTILINGUAL_INTEGRATION_TESTING
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.language_tool = getToolByName(self.portal, 'portal_languages')
self.language_tool.addSupportedLanguage('ca')
self.language_tool.addSupportedLanguage('es')
self.selector = LanguageSelectorViewlet(self.portal,
self.request, None, None)
def test_available(self):
self.selector.update()
self.assertEquals(self.selector.available(), True)
def test_available_no_tool(self):
self.selector.update()
self.selector.tool = None
self.assertEquals(self.selector.available(), False)
def test_original_selector_data_not_modified_by_viewlet(self):
self.selector.update()
multilingual_lang_info = self.selector.languages()
original_selector = LanguageSelector(self.portal,
self.request, None, None)
original_selector.update()
original_lang_info = original_selector.languages()
self.assertNotEquals(original_lang_info, multilingual_lang_info)
def test_languages_full_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'closest'
doc1 = makeContent(self.portal, 'Document', id='doc1')
doc1.setLanguage('en')
doc1_ca = makeTranslation(doc1, 'ca')
doc1_ca.edit(title="Foo", language='ca')
doc1_es = makeTranslation(doc1, 'es')
doc1_es.edit(title="Foo", language='es')
self.selector = LanguageSelectorViewlet(doc1,
self.request, None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [
{'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/doc1?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'},
{'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/doc1-ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'},
{'code': u'es',
u'name': u'Spanish',
'url': 'http://nohost/plone/doc1-es?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'}
])
def test_languages_partially_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
p1 = makeContent(self.portal, 'Document', id='partial')
p1.setLanguage('en')
p1_ca = makeTranslation(p1, 'ca')
p1_ca.edit(title="Foo ca", language='ca')
self.selector = LanguageSelectorViewlet(p1,
self.request, None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [
{'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/partial?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'},
{'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/partial-ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'},
{'code': u'es',
u'name': u'Spanish',
'url': 'http://nohost/plone/partial/not_translated_yet?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': False,
u'native': u'Espa\xf1ol'}
])
def test_languages_root_folders_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(IMultiLanguagePolicies)
self.settings.selector_lookup_translations_policy = 'dialog'
workflowTool = getToolByName(self.portal, "portal_workflow")
workflowTool.setDefaultChain('simple_publication_workflow')
setupTool = SetupMultilingualSite()
setupTool.setupSite(self.portal)
self.selector = LanguageSelectorViewlet(self.portal.en,
self.request, None, None)
self.selector.update()
self.assertEqual(self.selector.languages(), [
{'code': u'en',
u'name': u'English',
'url': 'http://nohost/plone/en?set_language=en',
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'},
{'code': u'ca',
u'name': u'Catalan',
'url': 'http://nohost/plone/ca?set_language=ca',
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'},
{'code': u'es',
u'name': u'Spanish',
'url': 'http://nohost/plone/es?set_language=es',
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'}
])
class TestLanguageSelectorBasics(unittest.TestCase):
layer = PAM_FUNCTIONAL_TESTING
def setUp(self):
# Set test variables
self.portal = self.layer['portal']
self.portal_url = self.portal.absolute_url()
self.request = self.layer['request']
alsoProvides(self.layer['request'], IPloneAppMultilingualInstalled)
# Setup testbrowser
self.browser = Browser(self.layer['app'])
self.browser.handleErrors = False
def test_selector_viewlet_is_available(self):
selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
selector_viewlet.update()
self.assertTrue(selector_viewlet.available())
def test_selector_viewlet_is_available_but_tool_is_not(self):
selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
selector_viewlet.update()
selector_viewlet.tool = None
self.assertFalse(selector_viewlet.available())
def test_selector_data_not_modified_by_viewlet(self):
selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
selector_viewlet.update()
selector_viewlet_languages = selector_viewlet.languages()
selector_adapter = LanguageSelector(
self.portal, self.request, None, None
)
selector_adapter.update()
selector_adapter_languages = selector_adapter.languages()
self.assertNotEqual(
selector_adapter_languages, selector_viewlet_languages
)
def assertFullyTranslatedPages(self):
a = createContentInContainer(
self.portal['en'], 'Document', title=u"Test document"
)
a_ca = api.translate(a, 'ca')
a_ca.setTitle(u"Test Document (CA)")
a_es = api.translate(a, 'es')
a_es.setTitle(u"Test Document (ES)")
wftool = getToolByName(self.portal, 'portal_workflow')
wftool.doActionFor(a, 'publish')
wftool.doActionFor(a_ca, 'publish')
wftool.doActionFor(a_es, 'publish')
notify(ObjectModifiedEvent(a))
notify(ObjectModifiedEvent(a_ca))
notify(ObjectModifiedEvent(a_es))
selector_viewlet = LanguageSelectorViewlet(a, self.request, None, None)
selector_viewlet.update()
selector_viewlet_languages = selector_viewlet.languages()
self.assertEqual(
selector_viewlet_languages,
[
{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'en',
'query': '?set_language=en',
},
'selected': True,
'translated': True,
},
{
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'ca',
'query': '?set_language=ca',
},
'selected': False,
'translated': True,
},
{
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal_url,
'tg': ITG(a),
'lang': 'es',
'query': '?set_language=es',
},
'selected': False,
'translated': True,
},
],
)
transaction.commit()
self.browser.open(selector_viewlet_languages[0]['url'])
self.assertEqual(
self.browser.url, a.absolute_url() + '?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_viewlet_languages[1]['url'])
self.assertEqual(
self.browser.url, a_ca.absolute_url() + '?set_language=ca'
)
self.assertIn('lang="ca"', self.browser.contents)
self.browser.open(selector_viewlet_languages[2]['url'])
self.assertEqual(
self.browser.url, a_es.absolute_url() + '?set_language=es'
)
self.assertIn('lang="es"', self.browser.contents)
def test_languages_fully_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertFullyTranslatedPages()
def test_languages_fully_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertFullyTranslatedPages()
def setUpPartiallyTranslatedContent(self):
wftool = getToolByName(self.portal, 'portal_workflow')
f_en = createContentInContainer(
self.portal['en'], 'Folder', title=u"Test folder"
)
wftool.doActionFor(f_en, 'publish')
a_en = createContentInContainer(
self.portal['en']['test-folder'],
'Document',
title=u"Test document",
)
wftool.doActionFor(a_en, 'publish')
f_ca = api.translate(f_en, 'ca')
f_ca.setTitle(u"Test folder CA")
wftool.doActionFor(f_ca, 'publish')
transaction.commit()
def setUpFullyTranslatedContent(self):
wftool = getToolByName(self.portal, 'portal_workflow')
self.setUpPartiallyTranslatedContent()
a_ca = api.translate(
self.portal['en']['test-folder']['test-document'], 'ca'
)
a_ca.setTitle(u"Test document CA")
wftool.doActionFor(a_ca, 'publish')
f_es = api.translate(self.portal['en']['test-folder'], 'es')
f_es.setTitle(u"Test folder ES")
wftool.doActionFor(f_es, 'publish')
a_es = api.translate(
self.portal['en']['test-folder']['test-document'], 'es'
)
a_es.setTitle(u"Test document ES")
wftool.doActionFor(a_es, 'publish')
transaction.commit()
def test_languages_untranslated_by_closest(self):
# Define selector policy
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
wftool = getToolByName(self.portal, "portal_workflow")
a_ca = createContentInContainer(
self.portal['ca'], 'Document', title=u"Test document"
)
a_ca.setLanguage('ca')
wftool.doActionFor(a_ca, 'publish')
view = selector_view(a_ca, self.request)
view.tg = ITG(a_ca)
# Check that the 'original' language gets the created document
view.lang = 'ca'
url = view.getClosestDestination()
self.assertEqual(url, a_ca.absolute_url())
# Check that untranslated languages get the nearest translated parent
view.lang = 'es'
url = view.getClosestDestination()
self.assertEqual(url, self.portal['es'].absolute_url())
view.lang = 'en'
url = view.getClosestDestination()
self.assertEqual(url, self.portal['en'].absolute_url())
# Check that translating content updates the closest destination
a_es = api.translate(a_ca, 'es')
view.lang = 'es'
url = view.getClosestDestination()
self.assertEqual(url, a_es.absolute_url())
def test_languages_partially_translated_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
# Setup content
self.setUpPartiallyTranslatedContent()
a_en = self.portal['en']['test-folder']['test-document']
f_ca = self.portal['ca']['test-folder']
selector = LanguageSelectorViewlet(a_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
# Check that EN translation is found
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url, a_en.absolute_url() + '?set_language=en'
)
self.assertIn('lang="en"', self.browser.contents)
# But extra check, because English is the default?
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check that CA translation is only partial and a parent folder
# is found
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url, f_ca.absolute_url() + '?set_language=ca'
)
self.assertIn('lang="ca"', self.browser.contents)
# Check that ES translation is missing and only the LRF is found
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal['es'].absolute_url() + '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
def test_languages_partially_translated_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
# Setup content
self.setUpPartiallyTranslatedContent()
a_en = self.portal['en']['test-folder']['test-document']
selector = LanguageSelectorViewlet(a_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
# Check that EN translation is found
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url, a_en.absolute_url() + '?set_language=en'
)
# But extra check, because English is the default?
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
tgid = selector_languages[1]['url'].split('/')[-2]
# Check that CA is not yet translated
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE
+ '/'
+ tgid
+ '?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check that ES is not yet translated
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE
+ '/'
+ tgid
+ '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
def assertSiteRoot(self):
self.selector_viewlet = LanguageSelectorViewlet(
self.portal, self.request, None, None
)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
transaction.commit()
# Check EN root
self.assertEqual(
selector_languages[0]['url'],
(
self.portal.absolute_url()
+ '/@@multilingual-selector/notg/en?set_language=en'
),
)
self.browser.open(selector_languages[0]['url'])
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA root
self.assertEqual(
selector_languages[1]['url'],
(
self.portal.absolute_url()
+ '/@@multilingual-selector/notg/ca?set_language=ca'
),
)
self.browser.open(selector_languages[1]['url'])
self.assertIn('lang="ca"', self.browser.contents)
# Check ES root
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
selector_languages[2]['url'],
(
self.portal.absolute_url()
+ '/@@multilingual-selector/notg/es?set_language=es'
),
)
self.assertIn('lang="es"', self.browser.contents)
def test_siteroot_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertSiteRoot()
def test_siteroot_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertSiteRoot()
def assertRootFolders(self):
self.selector_viewlet = LanguageSelectorViewlet(
self.portal['en'], self.request, None, None
)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
tg = ITG(self.portal['en'])
self.assertEqual(
selector_languages,
[
{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'en',
'query': '?set_language=en',
},
'selected': True,
'translated': True,
},
{
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'ca',
'query': '?set_language=ca',
},
'selected': False,
'translated': True,
},
{
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'es',
'query': '?set_language=es',
},
'selected': False,
'translated': True,
},
],
)
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal['en'].absolute_url() + '?set_language=en',
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.absolute_url() + '?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url() + '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
def test_languages_root_folders_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertRootFolders()
def test_languages_root_folders_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertRootFolders()
def test_languages_preserve_view(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.setUpPartiallyTranslatedContent()
f_en = self.portal['en']['test-folder']
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
self.request['PATH_INFO'] = '/plone/en/test-folder/contact-info'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url() + '/contact-info?set_language=en',
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url() + '/contact-info?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've gone up a level
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url() + '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
# Shouldn't do for the not-translated-yet thingie when dialog is on
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
f_en.absolute_url() + '/contact-info?set_language=en',
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
f_ca.absolute_url() + '/contact-info?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
tgid = selector_languages[2]['url'].split('/')[-3]
self.assertEqual(
self.browser.url,
self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE
+ '/'
+ tgid
+ '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
def assertLanguagesPreserveQuery(self, policy):
self.setUpPartiallyTranslatedContent()
self.request['PATH_INFO'] = '/plone/en/test-folder/contact-info'
self.request.form['uni'] = u'pres\xd8rved'
self.request.form['int'] = '1'
f_en = self.portal['en']['test-folder']
f_ca = self.portal['ca']['test-folder']
selector = LanguageSelectorViewlet(f_en, self.request, None, None)
selector.update()
selector_languages = selector.languages()
tgid = selector_languages[2]['url'].split('/')[-3]
untranslated_url = {
'closest': (
self.portal['es'].absolute_url()
+ '?int=1&uni=pres%C3%98rved&set_language=es'
),
'dialog': (
self.portal.absolute_url()
+ NOT_TRANSLATED_YET_TEMPLATE
+ '/'
+ tgid
+ '?int=1&uni=pres%C3%98rved&set_language=es'
),
}
transaction.commit()
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertUrlsEqual(
self.browser.url,
(
f_en.absolute_url()
+ '/contact-info?int=1&uni=pres%C3%98rved&set_language=en'
),
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertUrlsEqual(
self.browser.url,
(
f_ca.absolute_url()
+ '/contact-info?int=1&uni=pres%C3%98rved&set_language=ca'
),
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
# Here @@search isn't preserved because we've got the dialog
url = self.browser.url
if six.PY2 and isinstance(url, six.binary_type):
url = url.decode('utf8')
self.assertUrlsEqual(url, untranslated_url[policy])
self.assertIn('lang="es"', self.browser.contents)
def test_languages_preserve_by_closest(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'closest'
self.assertLanguagesPreserveQuery('closest')
def test_languages_preserve_by_dialog(self):
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema, prefix="plone"
)
self.settings.selector_lookup_translations_policy = 'dialog'
self.assertLanguagesPreserveQuery('dialog')
# XXX: this seems to me like a demented use case.
# If you put the VH _after_ the jail,
# for example mapping mysite.cat to /plone/ca and mysite.com to /plone/en,
# then I can't possibly make the whole language switcher work
# because I have no idea to which domain I should reroute the request
# (that information is sitting in nginx|apache config,
# therefore I cannot conceivably gather it).
# Therefore, while PAM knows which is the translation object,
# it can't figure out its URL correctly.
# At most, it can leverage acquisition so that,
# if you switch from mysite.com/my/object to catalan,
# it goes to mysite.com/ca/my/object
# (which has a path of /plone/en/my/object/ca/my/object),
# but that is too fragile and sucky for me to take care of supporting it.
#
# The original test case is below: if you wrote it,
# I'll be glad to hear which was the use case
# and what is your idea to make it work.
#
# def test_languages_vhr(self):
# registry = getUtility(IRegistry)
# settings = registry.forInterface(IMultiLanguageExtraOptionsSchema)
# settings.selector_lookup_translations_policy = 'dialog'
#
# from Products.CMFCore.interfaces import ISiteRoot
# from zope.interface import alsoProvides
# provideAdapter(DummyState, adapts=(Dummy, DummyRequest),
# provides=Interface, name="plone_context_state")
# context = Dummy()
# context.__parent__ = self.portal
# context.portal_url = Dummy()
# container = Dummy()
# context = context.__of__(container)
# alsoProvides(container, ISiteRoot)
# request = DummyRequest()
# selector = LanguageSelectorViewlet(context, request, None, None)
# context.physicalpath = ['', 'fake', 'path']
# vbase = '/VirtualHostBase/http/127.0.0.1/'
# request.PATH_INFO = vbase + 'fake/path/VirtualHostRoot/to/object'
# request.form['uni'] = u'pres\xd8rved'
# request.form['int'] = '1'
# notify(ObjectCreatedEvent(context))
# IUUID(context, None)
# selector.update()
# selector.tool = MockLanguageTool()
# base = 'object_url/to/object?int=1&uni='
# expected = [
# {'code': 'nl',
# 'translated': True,
# 'selected': False,
# 'url': base + 'pres%C3%98rved&set_language=nl'},
# {'code': 'en',
# 'translated': True,
# 'selected': True,
# 'url': base + 'pres%C3%98rved&set_language=en'},
# {'code': 'no',
# 'translated': False,
# 'selected': False,
# 'url': base + 'pres%C3%98rved&set_language=no'}]
# self.assertEqual(selector.languages(), expected)
def assertUrlsEqual(self, url1, url2):
"""The order of query-strings is sometimes random in python 3
This compares urls disregarding the order.
"""
parsed_url_1 = urlparse(safe_nativestring(url1))
parse_qs_1 = parse_qs(parsed_url_1.query)
parsed_url_2 = urlparse(safe_nativestring(url2))
parse_qs_2 = parse_qs(parsed_url_2.query)
self.assertEqual(parsed_url_1[0], parsed_url_2[0])
self.assertEqual(parsed_url_1[1], parsed_url_2[1])
self.assertEqual(parsed_url_1[2], parsed_url_2[2])
self.assertEqual(parsed_url_1[3], parsed_url_2[3])
self.assertEqual(parse_qs_1, parse_qs_2)
def setUp(self):
self.selector = LanguageSelectorViewlet(None, None, None, None)
self.fv = self.selector._formvariables
def assertFullyTranslatedPages(self):
doc1 = makeContent(self.portal, 'Document', id='doc1')
doc1.setLanguage('en')
doc1_tg = ITG(doc1)
doc1_ca = makeTranslation(doc1, 'ca')
doc1_ca.edit(title="Foo", language='ca')
doc1_es = makeTranslation(doc1, 'es')
doc1_es.edit(title="Foo", language='es')
self.selector = LanguageSelectorViewlet(doc1,
self.request, None, None)
self.selector.update()
selector_languages = self.selector.languages()
self.assertEqual(selector_languages, [
{
'code': u'en',
u'name': u'English',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': doc1_tg,
'lang': 'en',
'query': '?set_language=en'
},
'selected': True,
u'flag': u'/++resource++country-flags/gb.gif',
'translated': True,
u'native': u'English'
},
{
'code': u'ca',
u'name': u'Catalan',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': doc1_tg,
'lang': 'ca',
'query': '?set_language=ca'
},
'selected': False,
u'flag': u'/++resource++language-flags/ca.gif',
'translated': True,
u'native': u'Catal\xe0'
},
{
'code': u'es',
u'name': u'Spanish',
'url': SELECTOR_VIEW_TEMPLATE % {
'url': self.portal_url,
'tg': doc1_tg,
'lang': 'es',
'query': '?set_language=es'
},
'selected': False,
u'flag': u'/++resource++country-flags/es.gif',
'translated': True,
u'native': u'Espa\xf1ol'
}
])
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
doc1.absolute_url() + '?set_language=en'
)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
doc1_ca.absolute_url() + '?set_language=ca'
)
self.assertIn(
u'lang="ca"'.encode("utf-8"),
self.browser.contents
)
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
doc1_es.absolute_url() + '?set_language=es'
)
self.assertIn(
u'lang="es"'.encode("utf-8"),
self.browser.contents
)
def assertRootFolders(self):
self.selector_viewlet = LanguageSelectorViewlet(
self.portal['en'], self.request, None, None
)
self.selector_viewlet.update()
selector_languages = self.selector_viewlet.languages()
tg = ITG(self.portal['en'])
self.assertEqual(
selector_languages,
[
{
'code': u'en',
u'flag': u'/++resource++country-flags/gb.gif',
u'name': u'English',
u'native': u'English',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'en',
'query': '?set_language=en',
},
'selected': True,
'translated': True,
},
{
'code': u'ca',
u'flag': u'/++resource++language-flags/ca.gif',
u'name': u'Catalan',
u'native': u'Catal\xe0',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'ca',
'query': '?set_language=ca',
},
'selected': False,
'translated': True,
},
{
'code': u'es',
u'flag': u'/++resource++country-flags/es.gif',
u'name': u'Spanish',
u'native': u'Espa\xf1ol',
'url': SELECTOR_VIEW_TEMPLATE
% {
'url': self.portal.absolute_url(),
'tg': tg,
'lang': 'es',
'query': '?set_language=es',
},
'selected': False,
'translated': True,
},
],
)
# Check EN
self.browser.open(selector_languages[0]['url'])
self.assertEqual(
self.browser.url,
self.portal['en'].absolute_url() + '?set_language=en',
)
self.assertIn('lang="en"', self.browser.contents)
self.assertRegexpMatches(self.browser.contents, r"You\s*are here")
# Check CA
self.browser.open(selector_languages[1]['url'])
self.assertEqual(
self.browser.url,
self.portal.ca.absolute_url() + '?set_language=ca',
)
self.assertIn('lang="ca"', self.browser.contents)
# Check ES
self.browser.open(selector_languages[2]['url'])
self.assertEqual(
self.browser.url,
self.portal.es.absolute_url() + '?set_language=es',
)
self.assertIn('lang="es"', self.browser.contents)
