def test_invalid_project(self):
"""If the project is invalid, redirect home."""
LocaleFactory.create(code='fakelocale')
response = self.client.get('/fakelocale/invalid-project/')
assert_redirects(response, reverse('pontoon.home'))
assert_equal(self.client.session['translate_error'], {'none': None})
def test_pull_multi_locale(self):
"""
If the repo is multi-locale, pull all of the repos for the
active locales.
"""
locale1 = LocaleFactory.create(code='locale1')
locale2 = LocaleFactory.create(code='locale2')
repo = RepositoryFactory.create(
type=Repository.GIT,
url='https://example.com/{locale_code}/',
project__locales=[locale1, locale2])
repo.locale_url = lambda locale: 'https://example.com/' + locale.code
repo.locale_checkout_path = lambda locale: '/media/' + locale.code
with patch('pontoon.base.models.update_from_vcs') as update_from_vcs, \
patch('pontoon.base.models.get_revision') as mock_get_revision:
# Return path as the revision so different locales return
# different values.
mock_get_revision.side_effect = lambda type, path: path
assert_equal(repo.pull(), {
'locale1': '/media/locale1',
'locale2': '/media/locale2'
})
update_from_vcs.assert_has_calls([
call(Repository.GIT, 'https://example.com/locale1',
'/media/locale1'),
call(Repository.GIT, 'https://example.com/locale2',
'/media/locale2')
])
def test_pull_multi_locale(self):
"""
If the repo is multi-locale, pull all of the repos for the
active locales.
"""
locale1 = LocaleFactory.create(code="locale1")
locale2 = LocaleFactory.create(code="locale2")
repo = RepositoryFactory.create(
type=Repository.GIT, url="https://example.com/{locale_code}/", project__locales=[locale1, locale2]
)
repo.locale_url = lambda locale: "https://example.com/" + locale.code
repo.locale_checkout_path = lambda locale: "/media/" + locale.code
with patch("pontoon.base.models.update_from_vcs") as update_from_vcs, patch(
"pontoon.base.models.get_revision"
) as mock_get_revision:
# Return path as the revision so different locales return
# different values.
mock_get_revision.side_effect = lambda type, path: path
assert_equal(repo.pull(), {"locale1": "/media/locale1", "locale2": "/media/locale2"})
update_from_vcs.assert_has_calls(
[
call(Repository.GIT, "https://example.com/locale1", "/media/locale1"),
call(Repository.GIT, "https://example.com/locale2", "/media/locale2"),
]
)
def test_invalid_project(self):
"""If the project is invalid, redirect home."""
LocaleFactory.create(code='fakelocale')
response = self.client.get('/fakelocale/invalid-project/')
assert_redirects(response, reverse('pontoon.home'))
assert_equal(self.client.session['translate_error'], {'none': None})
def test_invalid_project(self):
"""If the project is invalid, redirect home."""
LocaleFactory.create(code="fakelocale")
response = self.client.get("/fakelocale/invalid-project/")
assert_redirects(response, reverse("pontoon.home"))
assert_equal(self.client.session["translate_error"], {"none": None})
def test_pull_multi_locale(self):
"""
If the repo is multi-locale, pull all of the repos for the
active locales.
"""
locale1 = LocaleFactory.create(code='locale1')
locale2 = LocaleFactory.create(code='locale2')
repo = RepositoryFactory.create(
type=Repository.GIT,
url='https://example.com/{locale_code}/',
project__locales=[locale1, locale2]
)
repo.locale_url = lambda locale: 'https://example.com/' + locale.code
repo.locale_checkout_path = lambda locale: '/media/' + locale.code
with patch('pontoon.base.models.update_from_vcs') as update_from_vcs, \
patch('pontoon.base.models.get_revision') as mock_get_revision:
# Return path as the revision so different locales return
# different values.
mock_get_revision.side_effect = lambda type, path: path
assert_equal(repo.pull(), {
'locale1': '/media/locale1',
'locale2': '/media/locale2'
})
update_from_vcs.assert_has_calls([
call(Repository.GIT, 'https://example.com/locale1', '/media/locale1'),
call(Repository.GIT, 'https://example.com/locale2', '/media/locale2')
])
def test_locale_top_contributors(self):
"""
Tests if view returns top contributors specific for given locale.
"""
first_locale = LocaleFactory.create()
first_locale_contributor = TranslationFactory.create(
locale=first_locale,
entity__resource__project__locales=[first_locale]).user
second_locale = LocaleFactory.create()
second_locale_contributor = TranslationFactory.create(
locale=second_locale,
entity__resource__project__locales=[second_locale]).user
with patch.object(views.LocaleContributorsView,
'render_to_response',
return_value=HttpResponse('')) as mock_render:
self.client.get('/{}/contributors/'.format(first_locale.code))
assert_equal(mock_render.call_args[0][0]['locale'], first_locale)
assert_equal(list(mock_render.call_args[0][0]['contributors']),
[first_locale_contributor])
self.client.get('/{}/contributors/'.format(second_locale.code))
assert_equal(mock_render.call_args[0][0]['locale'], second_locale)
assert_equal(list(mock_render.call_args[0][0]['contributors']),
[second_locale_contributor])
def setUp(self):
timezone_patch = patch.object(sync_projects, 'timezone')
self.mock_timezone = timezone_patch.start()
self.addCleanup(timezone_patch.stop)
self.mock_timezone.now.return_value = aware_datetime(1970, 1, 1)
self.translated_locale = LocaleFactory.create(code='translated-locale')
self.inactive_locale = LocaleFactory.create(code='inactive-locale')
self.repository = RepositoryFactory()
self.db_project = ProjectFactory.create(
name='db-project',
locales=[self.translated_locale],
repositories=[self.repository]
)
self.main_db_resource = ResourceFactory.create(
project=self.db_project,
path='main.lang',
format='lang'
)
self.other_db_resource = ResourceFactory.create(
project=self.db_project,
path='other.lang',
format='lang'
)
self.missing_db_resource = ResourceFactory.create(
project=self.db_project,
path='missing.lang',
format='lang'
)
# Load paths from the fake locale directory.
checkout_path_patch = patch.object(
Project,
'checkout_path',
new_callable=PropertyMock,
return_value=FAKE_CHECKOUT_PATH
)
checkout_path_patch.start()
self.addCleanup(checkout_path_patch.stop)
self.vcs_project = VCSProject(self.db_project)
self.main_vcs_resource = self.vcs_project.resources[self.main_db_resource.path]
self.other_vcs_resource = self.vcs_project.resources[self.other_db_resource.path]
self.missing_vcs_resource = self.vcs_project.resources[self.missing_db_resource.path]
self.main_vcs_entity = self.main_vcs_resource.entities['Source String']
self.main_vcs_translation = self.main_vcs_entity.translations['translated-locale']
# Mock VCSResource.save() for each resource to avoid altering
# the filesystem.
resource_save_patch = patch.object(VCSResource, 'save')
resource_save_patch.start()
self.addCleanup(resource_save_patch.stop)
self.changeset = sync_projects.ChangeSet(
self.db_project,
self.vcs_project,
aware_datetime(1970, 1, 1)
)
def setUp(self):
timezone_patch = patch.object(sync_projects, 'timezone')
self.mock_timezone = timezone_patch.start()
self.addCleanup(timezone_patch.stop)
self.mock_timezone.now.return_value = aware_datetime(1970, 1, 1)
self.translated_locale = LocaleFactory.create(code='translated-locale')
self.inactive_locale = LocaleFactory.create(code='inactive-locale')
self.db_project = ProjectFactory.create(
name='db-project',
locales=[self.translated_locale],
repository_type='git',
repository_url='https://example.com/git'
)
self.main_db_resource = ResourceFactory.create(
project=self.db_project,
path='main.lang',
format='lang'
)
self.other_db_resource = ResourceFactory.create(
project=self.db_project,
path='other.lang',
format='lang'
)
self.missing_db_resource = ResourceFactory.create(
project=self.db_project,
path='missing.lang',
format='lang'
)
# Load paths from the fake locale directory.
checkout_path_patch = patch.object(
Project,
'checkout_path',
new_callable=PropertyMock,
return_value=FAKE_CHECKOUT_PATH
)
checkout_path_patch.start()
self.addCleanup(checkout_path_patch.stop)
self.vcs_project = VCSProject(self.db_project)
self.main_vcs_resource = self.vcs_project.resources[self.main_db_resource.path]
self.other_vcs_resource = self.vcs_project.resources[self.other_db_resource.path]
self.missing_vcs_resource = self.vcs_project.resources[self.missing_db_resource.path]
self.main_vcs_entity = self.main_vcs_resource.entities['Source String']
self.main_vcs_translation = self.main_vcs_entity.translations['translated-locale']
# Mock VCSResource.save() for each resource to avoid altering
# the filesystem.
for resource in self.vcs_project.resources.values():
save_patch = patch.object(resource, 'save')
save_patch.start()
self.addCleanup(save_patch.stop)
self.changeset = sync_projects.ChangeSet(self.db_project, self.vcs_project)
def test_locale_not_available(self):
"""
If the requested locale is not available for this project,
redirect home.
"""
LocaleFactory.create(code='fakelocale')
ProjectFactory.create(slug='valid-project')
response = self.client.get('/fakelocale/valid-project/path/')
assert_equal(response.status_code, 404)
def test_locale_not_available(self):
"""
If the requested locale is not available for this project,
redirect home.
"""
LocaleFactory.create(code='fakelocale')
ProjectFactory.create(slug='valid-project')
response = self.client.get('/fakelocale/valid-project/path/')
assert_equal(response.status_code, 404)
def test_locale_not_available(self):
"""
If the requested locale is not available for this project,
redirect home.
"""
LocaleFactory.create(code='fakelocale')
ProjectFactory.create(slug='valid-project')
response = self.client.get('/fakelocale/valid-project/')
assert_redirects(response, reverse('pontoon.home'))
assert_equal(self.client.session['translate_error'], {'none': None})
def test_locale_not_available(self):
"""
If the requested locale is not available for this project,
redirect home.
"""
LocaleFactory.create(code="fakelocale")
ProjectFactory.create(slug="valid-project")
response = self.client.get("/fakelocale/valid-project/")
assert_redirects(response, reverse("pontoon.home"))
assert_equal(self.client.session["translate_error"], {"none": None})
def test_locale_not_available(self):
"""
If the requested locale is not available for this project,
redirect home.
"""
LocaleFactory.create(code='fakelocale')
ProjectFactory.create(slug='valid-project')
response = self.client.get('/fakelocale/valid-project/')
assert_redirects(response, reverse('pontoon.home'))
assert_equal(self.client.session['translate_error'], {'none': None})
def test_project_add_locale(self):
locale_kl = LocaleFactory.create(code='kl', name='Klingon')
locale_gs = LocaleFactory.create(code='gs', name='Geonosian')
project = ProjectFactory.create(
data_source='database',
locales=[locale_kl],
repositories=[],
)
_create_or_update_translated_resources(project, [locale_kl])
url = reverse('pontoon.admin.project', args=(project.slug, ))
# Boring data creation for FormSets. Django is painful with that,
# or I don't know how to handle that more gracefully.
form = ProjectForm(instance=project)
form_data = dict(form.initial)
del form_data['width']
del form_data['deadline']
del form_data['contact']
form_data.update({
'subpage_set-INITIAL_FORMS': '0',
'subpage_set-TOTAL_FORMS': '1',
'subpage_set-MIN_NUM_FORMS': '0',
'subpage_set-MAX_NUM_FORMS': '1000',
'externalresource_set-TOTAL_FORMS': '1',
'externalresource_set-MAX_NUM_FORMS': '1000',
'externalresource_set-MIN_NUM_FORMS': '0',
'externalresource_set-INITIAL_FORMS': '0',
'tag_set-TOTAL_FORMS': '1',
'tag_set-INITIAL_FORMS': '0',
'tag_set-MAX_NUM_FORMS': '1000',
'tag_set-MIN_NUM_FORMS': '0',
'repositories-INITIAL_FORMS': '0',
'repositories-MIN_NUM_FORMS': '0',
'repositories-MAX_NUM_FORMS': '1000',
'repositories-TOTAL_FORMS': '0',
# These are the values that actually matter.
'pk': project.pk,
'locales': [locale_kl.id, locale_gs.id],
})
response = self.client.post(url, form_data)
assert_code(response, 200)
assert_not_contains(response, '. Error.')
# Verify we have the right ProjectLocale objects.
pl = ProjectLocale.objects.filter(project=project)
assert_equal(len(pl), 2)
# Verify that TranslatedResource objects have been created.
resource = Resource.objects.get(project=project, path='database')
tr = TranslatedResource.objects.filter(resource=resource)
assert_equal(len(tr), 2)
def test_manage_project_strings_translated_resource(self):
"""Test that adding new strings to a project enables translation of that
project on all enabled locales.
"""
locales = [
LocaleFactory.create(code='kl', name='Klingon'),
LocaleFactory.create(code='gs', name='Geonosian'),
]
project = ProjectFactory.create(data_source='database',
locales=locales,
repositories=[])
locales_count = len(locales)
_create_or_update_translated_resources(project, locales)
url = reverse('pontoon.admin.project.strings', args=(project.slug, ))
new_strings = """
Morty, do you know what "Wubba lubba dub dub" means?
Oh that's just Rick's stupid non-sense catch phrase.
It's not.
In my people's tongue, it means "I am in great pain, please help me".
"""
strings_count = 4
response = self.client.post(url, {'new_strings': new_strings})
assert_code(response, 200)
# Verify no strings have been created as entities.
entities = list(Entity.objects.filter(resource__project=project))
assert_equal(len(entities), strings_count)
# Verify the resource has the right stats.
resources = Resource.objects.filter(project=project)
assert_equal(len(resources), 1)
resource = resources[0]
assert_equal(resource.total_strings, strings_count)
# Verify the correct TranslatedResource objects have been created.
translated_resources = TranslatedResource.objects.filter(
resource__project=project)
assert_equal(len(translated_resources), locales_count)
# Verify stats have been correctly updated on locale, project and resource.
for tr in translated_resources:
assert_equal(tr.total_strings, strings_count)
project = Project.objects.get(id=project.id)
assert_equal(project.total_strings, strings_count * locales_count)
for l in locales:
locale = Locale.objects.get(id=l.id)
assert_equal(locale.total_strings, strings_count)
def test_latest_activity(self):
"""Ensure that the latest_activity field is added to parts."""
locale = LocaleFactory.create(code='test')
project = ProjectFactory.create(locales=[locale], slug='test-project')
resource = ResourceFactory.create(project=project, path='has/stats.po')
translation = TranslationFactory.create(entity__resource=resource,
locale=locale)
StatsFactory.create(resource=resource,
locale=locale,
latest_translation=translation)
with patch.object(Project, 'locales_parts_stats') as mock_locales_parts_stats, \
patch('pontoon.base.views.render') as mock_render:
mock_locales_parts_stats.return_value = [{
'resource__path':
'has/stats.po'
}, {
'resource__path':
'no/stats.po'
}]
views.locale_project(self.factory.get('/'),
locale='test',
slug='test-project')
ctx = mock_render.call_args[0][2]
assert_equal(ctx['parts'], [{
'resource__path': 'has/stats.po',
'latest_activity': translation
}, {
'resource__path': 'no/stats.po',
'latest_activity': None
}])
def test_translation_counts(self):
"""
Translation memory should aggregate identical translations strings
from the different entities and count up their occurrences.
"""
new_locale = LocaleFactory.create()
memory_entry = TranslationMemoryFactory.create(source="aaaa", target="ccc", locale=new_locale)
TranslationMemoryFactory.create(source="abaa", target="ccc", locale=new_locale)
TranslationMemoryFactory.create(source="aaab", target="ccc", locale=new_locale)
TranslationMemoryFactory.create(source="aaab", target="ccc", locale=new_locale)
response = self.client.get('/translation-memory/', {
'text': 'aaaa',
'pk': memory_entry.entity.pk,
'locale': memory_entry.locale.code
})
result = response.json()
src_string = result[0].pop('source')
assert_true(src_string in ('abaa', 'aaab', 'aaab'))
assert_equal(
result,
[{
u'count': 3,
u'quality': 75.0,
u'target': u'ccc',
}]
)
def test_best_quality_entry(self):
"""
Translation memory should return results entries aggregated by
translation string.
"""
new_locale = LocaleFactory.create()
memory_entry = TranslationMemoryFactory.create(source="aaa",
target="ccc",
locale=new_locale)
TranslationMemoryFactory.create(source="aaa",
target="ddd",
locale=new_locale)
TranslationMemoryFactory.create(source="bbb",
target="ccc",
locale=new_locale)
response = self.client.get('/translation-memory/', {
'text': 'aaa',
'pk': memory_entry.entity.pk,
'locale': new_locale.code
})
assert_json(response, [{
"count": 1,
"source": "aaa",
"quality": 100.0,
"target": "ddd"
}])
def test_locale_checkout_path(self):
"""Append the locale code the the project's checkout_path."""
repo = RepositoryFactory.create(url="https://example.com/path/{locale_code}/", project__slug="test-project")
locale = LocaleFactory.create(code="test-locale")
with self.settings(MEDIA_ROOT="/media/root"):
assert_equal(repo.locale_checkout_path(locale), "/media/root/projects/test-project/path/test-locale")
def test_query_args_filtering(self):
"""
Tests if query args are honored properly and contributors are filtered.
"""
locale_first, locale_second = LocaleFactory.create_batch(2)
first_contributor = self.create_contributor_with_translation_counts(
approved=12, unapproved=1, needs_work=2, locale=locale_first)
second_contributor = self.create_contributor_with_translation_counts(
approved=11, unapproved=1, needs_work=2, locale=locale_second)
third_contributor = self.create_contributor_with_translation_counts(
approved=10, unapproved=12, needs_work=2, locale=locale_first)
# Testing filtering for the first locale
top_contributors = User.translators.with_translation_counts(aware_datetime(2015, 1, 1), Q(translation__locale=locale_first))
assert_equal(top_contributors.count(), 2)
assert_equal(top_contributors[0], third_contributor)
assert_attributes_equal(top_contributors[0], translations_count=24,
translations_approved_count=10, translations_unapproved_count=12,
translations_needs_work_count=2)
assert_equal(top_contributors[1], first_contributor)
assert_attributes_equal(top_contributors[1], translations_count=15,
translations_approved_count=12, translations_unapproved_count=1,
translations_needs_work_count=2)
# Testing filtering for the second locale
top_contributors = User.translators.with_translation_counts(aware_datetime(2015, 1, 1), Q(translation__locale=locale_second))
assert_equal(top_contributors.count(), 1)
assert_equal(top_contributors[0], second_contributor)
assert_attributes_equal(top_contributors[0], translations_count=14,
translations_approved_count=11, translations_unapproved_count=1,
translations_needs_work_count=2)
def setUp(self):
self.resource = ResourceFactory.create()
self.locale = LocaleFactory.create()
ProjectLocale.objects.create(project=self.resource.project, locale=self.locale)
TranslatedResource.objects.create(resource=self.resource, locale=self.locale)
self.entities = EntityFactory.create_batch(3, resource=self.resource)
self.entities_pks = [e.pk for e in self.entities]
def test_url_for_path(self):
"""
Return the first locale_checkout_path for locales active for the
repo's project that matches the given path.
"""
matching_locale = LocaleFactory.create(code="match")
non_matching_locale = LocaleFactory.create(code="nomatch")
repo = RepositoryFactory.create(
project__locales=[matching_locale, non_matching_locale],
project__slug="test-project",
url="https://example.com/path/to/{locale_code}/",
)
with self.settings(MEDIA_ROOT="/media/root"):
test_path = "/media/root/projects/test-project/path/to/match/foo/bar.po"
assert_equal(repo.url_for_path(test_path), "https://example.com/path/to/match/")
def test_get_latest_activity_without_latest(self):
"""
If the locale doesn't have a latest_translation and no project
is given, return None.
"""
locale = LocaleFactory.create(latest_translation=None)
assert_is_none(locale.get_latest_activity())
def setUp(self):
self.locale = LocaleFactory.create(cldr_plurals="0,1")
self.project = ProjectFactory.create(locales=[self.locale])
self.main_resource = ResourceFactory.create(project=self.project, path="main.lang")
self.other_resource = ResourceFactory.create(project=self.project, path="other.lang")
self.main_entity = EntityFactory.create(
resource=self.main_resource,
string="Source String",
string_plural="Plural Source String",
key="Source String",
)
self.other_entity = EntityFactory.create(
resource=self.other_resource,
string="Other Source String",
key="Key" + KEY_SEPARATOR + "Other Source String",
)
self.main_translation = TranslationFactory.create(
entity=self.main_entity, locale=self.locale, plural_form=0, string="Translated String"
)
self.main_translation_plural = TranslationFactory.create(
entity=self.main_entity, locale=self.locale, plural_form=1, string="Translated Plural String"
)
self.other_translation = TranslationFactory.create(
entity=self.other_entity, locale=self.locale, string="Other Translated String"
)
self.subpage = SubpageFactory.create(project=self.project, name="Subpage", resources=[self.main_resource])
def test_get_latest_activity_without_latest(self):
"""
If the locale doesn't have a latest_translation and no project
is given, return None.
"""
locale = LocaleFactory.create(latest_translation=None)
assert_is_none(locale.get_latest_activity())
def test_managers_group(self):
"""
Tests if user has permission to manage and translate locales after assigment.
"""
user = UserFactory.create()
[first_locale, second_locale] = LocaleFactory.create_batch(2)
assert_equal(user.has_perm("base.can_translate_locale"), False)
assert_equal(user.has_perm("base.can_translate_locale", first_locale), False)
assert_equal(user.has_perm("base.can_translate_locale", second_locale), False)
assert_equal(user.has_perm("base.can_manage_locale"), False)
assert_equal(user.has_perm("base.can_manage_locale", first_locale), False)
assert_equal(user.has_perm("base.can_manage_locale", second_locale), False)
user.groups.add(second_locale.managers_group)
assert_equal(user.has_perm("base.can_translate_locale"), False)
assert_equal(user.has_perm("base.can_translate_locale", first_locale), False)
assert_equal(user.has_perm("base.can_translate_locale", second_locale), True)
assert_equal(user.has_perm("base.can_manage_locale"), False)
assert_equal(user.has_perm("base.can_manage_locale", first_locale), False)
assert_equal(user.has_perm("base.can_manage_locale", second_locale), True)
user.groups.add(first_locale.managers_group)
assert_equal(user.has_perm("base.can_translate_locale"), False)
assert_equal(user.has_perm("base.can_translate_locale", first_locale), True)
assert_equal(user.has_perm("base.can_translate_locale", second_locale), True)
assert_equal(user.has_perm("base.can_manage_locale"), False)
assert_equal(user.has_perm("base.can_manage_locale", first_locale), True)
assert_equal(user.has_perm("base.can_manage_locale", second_locale), True)
def setUp(self):
self.locale = LocaleFactory.create(cldr_plurals="0,1")
self.project = ProjectFactory.create(locales=[self.locale])
self.main_resource = ResourceFactory.create(project=self.project,
path='main.lang')
self.other_resource = ResourceFactory.create(project=self.project,
path='other.lang')
self.main_entity = EntityFactory.create(
resource=self.main_resource,
string='Source String',
string_plural='Plural Source String',
key='Source String')
self.other_entity = EntityFactory.create(resource=self.other_resource,
string='Other Source String',
key='Key' + KEY_SEPARATOR +
'Other Source String')
self.main_translation = TranslationFactory.create(
entity=self.main_entity,
locale=self.locale,
plural_form=0,
string='Translated String')
self.main_translation_plural = TranslationFactory.create(
entity=self.main_entity,
locale=self.locale,
plural_form=1,
string='Translated Plural String')
self.other_translation = TranslationFactory.create(
entity=self.other_entity,
locale=self.locale,
string='Other Translated String')
self.subpage = SubpageFactory.create(project=self.project,
name='Subpage',
resources=[self.main_resource])
def test_translators_group(self):
"""
Tests if user has permission to translate locales after assigment.
"""
user = UserFactory.create()
[first_locale, second_locale] = LocaleFactory.create_batch(2)
assert_equal(user.has_perm('base.can_translate_locale'), False)
assert_equal(user.has_perm('base.can_translate_locale', first_locale),
False)
assert_equal(user.has_perm('base.can_translate_locale', second_locale),
False)
user.groups.add(second_locale.translators_group)
assert_equal(user.has_perm('base.can_translate_locale'), False)
assert_equal(user.has_perm('base.can_translate_locale', first_locale),
False)
assert_equal(user.has_perm('base.can_translate_locale', second_locale),
True)
user.groups.add(first_locale.translators_group)
assert_equal(user.has_perm('base.can_translate_locale'), False)
assert_equal(user.has_perm('base.can_translate_locale', first_locale),
True)
assert_equal(user.has_perm('base.can_translate_locale', second_locale),
True)
def test_translation_counts(self):
"""
Translation memory should aggregate identical translations strings
from the different entities and count up their occurrences.
"""
new_locale = LocaleFactory.create()
memory_entry = TranslationMemoryFactory.create(source="aaaa",
target="ccc",
locale=new_locale)
TranslationMemoryFactory.create(source="abaa",
target="ccc",
locale=new_locale)
TranslationMemoryFactory.create(source="aaab",
target="ccc",
locale=new_locale)
TranslationMemoryFactory.create(source="aaab",
target="ccc",
locale=new_locale)
response = self.client.get(
'/translation-memory/', {
'text': 'aaaa',
'pk': memory_entry.entity.pk,
'locale': memory_entry.locale.code
})
result = response.json()
src_string = result[0].pop('source')
assert_true(src_string in ('abaa', 'aaab', 'aaab'))
assert_equal(result, [{
u'count': 3,
u'quality': 75.0,
u'target': u'ccc',
}])
def test_save_latest_translation_update(self):
"""
When a translation is saved, update the latest_translation
attribute on the related project, locale, stats, and
project_locale objects.
"""
locale = LocaleFactory.create(latest_translation=None)
project = ProjectFactory.create(locales=[locale], latest_translation=None)
resource = ResourceFactory.create(project=project)
stats = StatsFactory.create(locale=locale, resource=resource, latest_translation=None)
project_locale = ProjectLocale.objects.get(locale=locale, project=project)
assert_is_none(locale.latest_translation)
assert_is_none(project.latest_translation)
assert_is_none(stats.latest_translation)
assert_is_none(project_locale.latest_translation)
translation = TranslationFactory.create(
locale=locale,
entity__resource=resource,
date=aware_datetime(1970, 1, 1)
)
self.assert_latest_translation(locale, translation)
self.assert_latest_translation(project, translation)
self.assert_latest_translation(stats, translation)
self.assert_latest_translation(project_locale, translation)
# Ensure translation is replaced for newer translations
newer_translation = TranslationFactory.create(
locale=locale,
entity__resource=resource,
date=aware_datetime(1970, 2, 1)
)
self.assert_latest_translation(locale, newer_translation)
self.assert_latest_translation(project, newer_translation)
self.assert_latest_translation(stats, newer_translation)
self.assert_latest_translation(project_locale, newer_translation)
# Ensure translation isn't replaced for older translations.
TranslationFactory.create(
locale=locale,
entity__resource=resource,
date=aware_datetime(1970, 1, 5)
)
self.assert_latest_translation(locale, newer_translation)
self.assert_latest_translation(project, newer_translation)
self.assert_latest_translation(stats, newer_translation)
self.assert_latest_translation(project_locale, newer_translation)
# Ensure approved_date is taken into consideration as well.
newer_approved_translation = TranslationFactory.create(
locale=locale,
entity__resource=resource,
approved_date=aware_datetime(1970, 3, 1)
)
self.assert_latest_translation(locale, newer_approved_translation)
self.assert_latest_translation(project, newer_approved_translation)
self.assert_latest_translation(stats, newer_approved_translation)
self.assert_latest_translation(project_locale, newer_approved_translation)
def test_save_latest_translation_update(self):
"""
When a translation is saved, update the latest_translation
attribute on the related project, locale, stats, and
project_locale objects.
"""
locale = LocaleFactory.create(latest_translation=None)
project = ProjectFactory.create(locales=[locale],
latest_translation=None)
resource = ResourceFactory.create(project=project)
stats = StatsFactory.create(locale=locale,
resource=resource,
latest_translation=None)
project_locale = ProjectLocale.objects.get(locale=locale,
project=project)
assert_is_none(locale.latest_translation)
assert_is_none(project.latest_translation)
assert_is_none(stats.latest_translation)
assert_is_none(project_locale.latest_translation)
translation = TranslationFactory.create(locale=locale,
entity__resource=resource,
date=aware_datetime(
1970, 1, 1))
self.assert_latest_translation(locale, translation)
self.assert_latest_translation(project, translation)
self.assert_latest_translation(stats, translation)
self.assert_latest_translation(project_locale, translation)
# Ensure translation is replaced for newer translations
newer_translation = TranslationFactory.create(
locale=locale,
entity__resource=resource,
date=aware_datetime(1970, 2, 1))
self.assert_latest_translation(locale, newer_translation)
self.assert_latest_translation(project, newer_translation)
self.assert_latest_translation(stats, newer_translation)
self.assert_latest_translation(project_locale, newer_translation)
# Ensure translation isn't replaced for older translations.
TranslationFactory.create(locale=locale,
entity__resource=resource,
date=aware_datetime(1970, 1, 5))
self.assert_latest_translation(locale, newer_translation)
self.assert_latest_translation(project, newer_translation)
self.assert_latest_translation(stats, newer_translation)
self.assert_latest_translation(project_locale, newer_translation)
# Ensure approved_date is taken into consideration as well.
newer_approved_translation = TranslationFactory.create(
locale=locale,
entity__resource=resource,
approved_date=aware_datetime(1970, 3, 1))
self.assert_latest_translation(locale, newer_approved_translation)
self.assert_latest_translation(project, newer_approved_translation)
self.assert_latest_translation(stats, newer_approved_translation)
self.assert_latest_translation(project_locale,
newer_approved_translation)
def setUp(self):
super(FormatTestsMixin, self).setUp()
self.locale = LocaleFactory.create(
code='test-locale',
name='Test Locale',
plural_rule='(n != 1)',
cldr_plurals='1,5',
)
def setUp(self):
super().setUp()
self.locale = LocaleFactory.create(
code="test-locale",
name="Test Locale",
plural_rule="(n != 1)",
cldr_plurals="1,5",
)
def test_locale_url(self):
"""Fill in the {locale_code} variable in the URL."""
repo = RepositoryFactory.create(
url='https://example.com/path/to/{locale_code}/',
)
locale = LocaleFactory.create(code='test-locale')
assert_equal(repo.locale_url(locale), 'https://example.com/path/to/test-locale/')
def test_url_for_path(self):
"""
Return the first locale_checkout_path for locales active for the
repo's project that matches the given path.
"""
matching_locale = LocaleFactory.create(code='match')
non_matching_locale = LocaleFactory.create(code='nomatch')
repo = RepositoryFactory.create(
project__locales=[matching_locale, non_matching_locale],
project__slug='test-project',
url='https://example.com/path/to/{locale_code}/',
multi_locale=True
)
with self.settings(MEDIA_ROOT='/media/root'):
test_path = '/media/root/projects/test-project/path/to/match/foo/bar.po'
assert_equal(repo.url_for_path(test_path), 'https://example.com/path/to/match/')
def setUp(self):
self.locale, self.locale_other = LocaleFactory.create_batch(2)
self.project = ProjectFactory.create(
locales=[self.locale, self.locale_other])
self.resource = ResourceFactory.create(project=self.project,
path='/main/path.po')
EntityFactory.create(resource=self.resource)
StatsFactory.create(resource=self.resource, locale=self.locale)
def test_locale_url(self):
"""Fill in the {locale_code} variable in the URL."""
repo = RepositoryFactory.create(
url='https://example.com/path/to/{locale_code}/', )
locale = LocaleFactory.create(code='test-locale')
assert_equal(repo.locale_url(locale),
'https://example.com/path/to/test-locale/')
def test_url_for_path(self):
"""
Return the first locale_checkout_path for locales active for the
repo's project that matches the given path.
"""
matching_locale = LocaleFactory.create(code='match')
non_matching_locale = LocaleFactory.create(code='nomatch')
repo = RepositoryFactory.create(
project__locales=[matching_locale, non_matching_locale],
project__slug='test-project',
url='https://example.com/path/to/{locale_code}/',
)
with self.settings(MEDIA_ROOT='/media/root'):
test_path = '/media/root/projects/test-project/path/to/match/foo/bar.po'
assert_equal(repo.url_for_path(test_path),
'https://example.com/path/to/match/')
def test_get_latest_activity_with_latest(self):
"""
If the locale has a latest_translation and no project is given,
return it.
"""
translation = TranslationFactory.create()
locale = LocaleFactory.create(latest_translation=translation)
assert_equal(locale.get_latest_activity(), translation.latest_activity)
def test_get_latest_activity_with_latest(self):
"""
If the locale has a latest_translation and no project is given,
return it.
"""
translation = TranslationFactory.create()
locale = LocaleFactory.create(latest_translation=translation)
assert_equal(locale.get_latest_activity(), translation.latest_activity)
def test_profileform_user_locales_order(member, settings_url):
locale1, locale2, locale3 = LocaleFactory.create_batch(3)
response = member.client.get(settings_url)
assert response.status_code == 200
response = member.client.post(
"/settings/",
{
"first_name": "contributor",
"email": member.user.email,
"locales_order": commajoin(
locale2.pk,
locale1.pk,
locale3.pk,
),
},
)
assert response.status_code == 200
assert list(
User.objects.get(pk=member.user.pk).profile.sorted_locales) == [
locale2,
locale1,
locale3,
]
# Test if you can clear all locales
response = member.client.post(
"/settings/",
{
"first_name": "contributor",
"email": member.user.email,
"locales_order": ""
},
)
assert response.status_code == 200
assert list(
User.objects.get(pk=member.user.pk).profile.sorted_locales) == []
# Test if form handles duplicated locales
response = member.client.post(
"/settings/",
{
"first_name": "contributor",
"email": member.user.email,
"locales_order": commajoin(
locale1.pk,
locale2.pk,
locale2.pk,
),
},
)
assert response.status_code, 200
assert list(
User.objects.get(pk=member.user.pk).profile.sorted_locales) == [
locale1,
locale2,
]
def test_user_locales_order(self):
locale1, locale2, locale3 = LocaleFactory.create_batch(3)
response = self.client.get(self.url)
assert_equal(response.status_code, 200)
response = self.client.post(
"/settings/",
{
"first_name": "contributor",
"email": self.user.email,
"locales_order": commajoin(
locale2.pk,
locale1.pk,
locale3.pk,
),
},
)
assert_equal(response.status_code, 200)
assert_equal(
list(User.objects.get(pk=self.user.pk).profile.sorted_locales),
[locale2, locale1, locale3],
)
# Test if you can clear all locales
response = self.client.post(
"/settings/",
{
"first_name": "contributor",
"email": self.user.email,
"locales_order": "",
},
)
assert_equal(response.status_code, 200)
assert_equal(
list(User.objects.get(pk=self.user.pk).profile.sorted_locales), [])
# Test if form handles duplicated locales
response = self.client.post(
"/settings/",
{
"first_name": "contributor",
"email": self.user.email,
"locales_order": commajoin(
locale1.pk,
locale2.pk,
locale2.pk,
),
},
)
assert_equal(response.status_code, 200)
assert_equal(
list(User.objects.get(pk=self.user.pk).profile.sorted_locales),
[locale1, locale2],
)
def test_locale_top_contributors(self):
"""
Tests if view returns top contributors specific for given locale.
"""
first_locale = LocaleFactory.create()
first_locale_contributor = TranslationFactory.create(locale=first_locale,
entity__resource__project__locales=[first_locale]).user
second_locale = LocaleFactory.create()
second_locale_contributor = TranslationFactory.create(locale=second_locale,
entity__resource__project__locales=[second_locale]).user
with patch.object(views.LocaleContributorsView, 'render_to_response', return_value=HttpResponse('')) as mock_render:
self.client.get('/{}/contributors/'.format(first_locale.code))
assert_equal(mock_render.call_args[0][0]['locale'], first_locale)
assert_equal(list(mock_render.call_args[0][0]['contributors']), [first_locale_contributor])
self.client.get('/{}/contributors/'.format(second_locale.code))
assert_equal(mock_render.call_args[0][0]['locale'], second_locale)
assert_equal(list(mock_render.call_args[0][0]['contributors']), [second_locale_contributor])
def setUp(self):
self.locale, self.locale_other = LocaleFactory.create_batch(2)
self.project = ProjectFactory.create(
locales=[self.locale, self.locale_other]
)
self.resource = ResourceFactory.create(
project=self.project,
path='/main/path.po'
)
EntityFactory.create(resource=self.resource)
StatsFactory.create(resource=self.resource, locale=self.locale)
def test_locale_checkout_path(self):
"""Append the locale code the the project's checkout_path."""
repo = RepositoryFactory.create(
url='https://example.com/path/{locale_code}/',
project__slug='test-project',
)
locale = LocaleFactory.create(code='test-locale')
with self.settings(MEDIA_ROOT='/media/root'):
assert_equal(repo.locale_checkout_path(locale),
'/media/root/projects/test-project/path/test-locale')
def test_get_latest_activity_with_locale(self):
"""
If a locale is given, defer to
ProjectLocale.get_latest_activity.
"""
locale = LocaleFactory.create()
project = ProjectFactory.create(locales=[locale])
with patch.object(ProjectLocale, "get_latest_activity") as mock_get_latest_activity:
mock_get_latest_activity.return_value = "latest"
assert_equal(locale.get_latest_activity(project=project), "latest")
mock_get_latest_activity.assert_called_with(project, locale)
def test_save_create_dirs(self):
"""
If the directories in a resource's path don't exist, create them
on save.
"""
path = os.path.join(tempfile.mkdtemp(), 'does', 'not', 'exist.dtd')
translated_resource = self.create_nonexistant_resource(path)
translated_resource.translations[0].strings = {None: 'New Translated String'}
translated_resource.save(LocaleFactory.create())
assert_true(os.path.exists(path))
def test_project_locale_added(self):
"""
When a locale is added to a project, has_changed should be set
to True.
"""
project = ProjectFactory.create(locales=[], has_changed=False)
assert_false(project.has_changed)
locale = LocaleFactory.create()
ProjectLocaleFactory.create(project=project, locale=locale)
project.refresh_from_db()
assert_true(project.has_changed)
def test_get_latest_activity_with_project(self):
"""
If a locale is given, defer to
ProjectLocale.get_latest_activity.
"""
locale = LocaleFactory.create()
project = ProjectFactory.create(locales=[locale])
with patch.object(ProjectLocale, 'get_latest_activity') as mock_get_latest_activity:
mock_get_latest_activity.return_value = 'latest'
assert_equal(locale.get_latest_activity(project=project), 'latest')
mock_get_latest_activity.assert_called_with(locale, project)
def test_save_create_dirs(self):
"""
If the directories in a resource's path don't exist, create them
on save.
"""
path = os.path.join(tempfile.mkdtemp(), 'does', 'not', 'exist.dtd')
translated_resource = self.create_nonexistant_resource(path)
translated_resource.translations[0].strings = {None: 'New Translated String'}
translated_resource.save(LocaleFactory.create())
assert_true(os.path.exists(path))
def test_project_locale_added(self):
"""
When a locale is added to a project, has_changed should be set
to True.
"""
project = ProjectFactory.create(locales=[], has_changed=False)
assert_false(project.has_changed)
locale = LocaleFactory.create()
ProjectLocaleFactory.create(project=project, locale=locale)
project.refresh_from_db()
assert_true(project.has_changed)
def setUp(self):
super(TranslationActionsTests, self).setUp()
project = ProjectFactory.create()
locale = LocaleFactory.create()
ProjectLocale.objects.create(project=project, locale=locale)
translation = TranslationFactory.create(locale=locale, entity__resource__project=project)
translation.approved = True
translation.save()
self.translation = translation
def test_user_locales_order(self):
locale1, locale2, locale3 = LocaleFactory.create_batch(3)
response = self.client.get(self.url)
assert_equal(response.status_code, 200)
response = self.client.post('/settings/', {
'first_name': 'contributor',
'email': self.user.email,
'locales_order': commajoin(
locale2.pk,
locale1.pk,
locale3.pk,
),
})
assert_equal(response.status_code, 200)
assert_equal(
list(User.objects.get(pk=self.user.pk).profile.sorted_locales),
[
locale2,
locale1,
locale3,
]
)
# Test if you can clear all locales
response = self.client.post('/settings/', {
'first_name': 'contributor',
'email': self.user.email,
'locales_order': '',
})
assert_equal(response.status_code, 200)
assert_equal(
list(User.objects.get(pk=self.user.pk).profile.sorted_locales),
[]
)
# Test if form handles duplicated locales
response = self.client.post('/settings/', {
'first_name': 'contributor',
'email': self.user.email,
'locales_order': commajoin(
locale1.pk,
locale2.pk,
locale2.pk,
)
})
assert_equal(response.status_code, 200)
assert_equal(
list(User.objects.get(pk=self.user.pk).profile.sorted_locales), [
locale1,
locale2,
]
)
def test_locale_view(self):
"""
Checks if locale page is returned properly.
"""
locale = LocaleFactory.create()
# Locale requires valid project with resources
ResourceFactory.create(project__locales=[locale])
with patch('pontoon.base.views.render', wraps=render) as mock_render:
self.client.get('/{}/'.format(locale.code))
assert_equal(mock_render.call_args[0][2]['locale'], locale)
def test_user_locales_order(self):
locale1, locale2, locale3 = LocaleFactory.create_batch(3)
response = self.client.get(self.url)
assert_equal(response.status_code, 200)
response = self.client.post('/settings/', {
'first_name': 'contributor',
'email': self.user.email,
'locales_order': commajoin(
locale2.pk,
locale1.pk,
locale3.pk,
),
})
assert_equal(response.status_code, 200)
assert_equal(
list(User.objects.get(pk=self.user.pk).profile.sorted_locales),
[
locale2,
locale1,
locale3,
]
)
# Test if you can clear all locales
response = self.client.post('/settings/', {
'first_name': 'contributor',
'email': self.user.email,
'locales_order': '',
})
assert_equal(response.status_code, 200)
assert_equal(
list(User.objects.get(pk=self.user.pk).profile.sorted_locales),
[]
)
# Test if form handles duplicated locales
response = self.client.post('/settings/', {
'first_name': 'contributor',
'email': self.user.email,
'locales_order': commajoin(
locale1.pk,
locale2.pk,
locale2.pk,
)
})
assert_equal(response.status_code, 200)
assert_equal(
list(User.objects.get(pk=self.user.pk).profile.sorted_locales), [
locale1,
locale2,
]
)
def test_locale_view(self):
"""
Checks if locale page is returned properly.
"""
locale = LocaleFactory.create()
# Locale requires valid project with resources
ResourceFactory.create(project__locales=[locale])
with patch('pontoon.base.views.render', wraps=render) as mock_render:
self.client.get('/{}/'.format(locale.code))
assert_equal(mock_render.call_args[0][2]['locale'], locale)
