def test_multiple_translations(self): """ If there are multiple translations to the same locale, only authors of the final approved version should be returned. """ first_author, second_author = UserFactory.create_batch(2) TranslationFactory.create( locale=self.translated_locale, entity=self.main_db_entity, user=first_author, approved=True ) TranslationFactory.create( locale=self.translated_locale, entity=self.main_db_entity, user=second_author, approved=False ) self.changeset.update_vcs_entity(self.translated_locale, self.main_db_entity, MagicMock()) self.changeset.execute_update_vcs() assert_equal( self.changeset.commit_authors_per_locale[self.translated_locale.code], [first_author] )
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 setUp(self): mock_persona_migration = patch.object(middleware.PersonaMigrationMiddleware, 'process_request', return_value=None) self.mock_persona_migration = mock_persona_migration.start() self.addCleanup(mock_persona_migration.stop) self.user = UserFactory.create() self.client.force_login(self.user)
def test_update_db_unapprove_existing(self): """ Any existing translations that don't match anything in VCS get unapproved, unless they were created after self.now. """ self.main_db_translation.approved = True self.main_db_translation.approved_date = aware_datetime(1970, 1, 1) self.main_db_translation.approved_user = UserFactory.create() self.main_db_translation.save() self.main_vcs_translation.strings[None] = 'New Translated String' created_after_translation = TranslationFactory.create( entity=self.main_db_entity, approved=True, approved_date=aware_datetime(1970, 1, 3) ) self.update_main_db_entity() self.main_db_translation.refresh_from_db() assert_attributes_equal( self.main_db_translation, approved=False, approved_user=None, approved_date=None ) created_after_translation.refresh_from_db() assert_attributes_equal( created_after_translation, approved=True, approved_date=aware_datetime(1970, 1, 3) )
def test_update_vcs_entity_user(self): """Track translation authors for use in the commit message.""" user = UserFactory.create() self.update_main_vcs_entity(user=user) assert_equal( self.changeset.commit_authors_per_locale['translated-locale'], [user])
def test_plural_translations(self): """ If entity has some plural translations and approved translations their authors should be included in commit message. """ first_author, second_author, third_author = UserFactory.create_batch(3) TranslationFactory.create( locale=self.translated_locale, entity=self.main_db_entity, user=first_author, approved=True ) TranslationFactory.create( locale=self.translated_locale, entity=self.main_db_entity, user=third_author, approved=True, plural_form=1 ) TranslationFactory.create( locale=self.translated_locale, entity=self.main_db_entity, user=second_author, approved=False ) self.changeset.update_vcs_entity(self.translated_locale, self.main_db_entity, MagicMock()) self.changeset.execute_update_vcs() assert_equal( set(self.changeset.commit_authors_per_locale[self.translated_locale.code]), {first_author, third_author} )
def test_update_db_unapprove_fuzzy(self): """ If an existing translation is fuzzy and doesn't match anything in VCS, unapprove and unfuzzy that translation without rejecting it. """ self.main_db_translation.fuzzy = True self.main_db_translation.approved = True self.main_db_translation.approved_date = aware_datetime(1970, 1, 1) self.main_db_translation.approved_user = UserFactory.create() self.main_db_translation.save() self.main_vcs_translation.strings[None] = "New Translated String" self.update_main_db_entity() self.main_db_translation.refresh_from_db() assert_attributes_equal( self.main_db_translation, approved=False, approved_user=None, approved_date=None, rejected=False, fuzzy=False, ) assert ActionLog.objects.filter( action_type="translation:unapproved", translation=self.main_db_translation.pk, ).exists()
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 test_multiple_authors(self): """ Commit message should include authors from translations of separate entities. """ first_author, second_author = UserFactory.create_batch(2) TranslationFactory.create(locale=self.translated_locale, entity=self.main_db_entity, user=first_author, approved=True) TranslationFactory.create(locale=self.translated_locale, entity=self.main_db_entity, approved=False) TranslationFactory.create(locale=self.translated_locale, entity=self.other_db_entity, user=second_author, approved=True) TranslationFactory.create(locale=self.translated_locale, entity=self.other_db_entity, approved=False) self.changeset.update_vcs_entity(self.translated_locale, self.main_db_entity, MagicMock()) self.changeset.update_vcs_entity(self.translated_locale, self.other_db_entity, MagicMock()) self.changeset.execute_update_vcs() assert_equal( self.changeset.commit_authors_per_locale[ self.translated_locale.code], [first_author, second_author])
def setUp(self): self.log_mock = MagicMock() self.user = UserFactory.create() mock_messages = patch('pontoon.base.adapter.messages') self.mock_messages = mock_messages.start() self.addCleanup(mock_messages.stop) self.adapter = PontoonSocialAdapter()
def test_timeline_non_active_contributor( contributor_translations, client, mock_profile_render ): """Test if backend is able return events for a user without contributions.""" nonactive_contributor = UserFactory.create() client.get("/contributors/{}/timeline/".format(nonactive_contributor.username)) assert mock_profile_render.call_args[0][2]["events"] == [ {"date": nonactive_contributor.date_joined, "type": "join"} ]
def create_contributor_with_translation_counts(self, approved=0, unapproved=0, needs_work=0, **kwargs): """ Helper method, creates contributor with given translations counts. """ contributor = UserFactory.create() TranslationFactory.create_batch(approved, user=contributor, approved=True, **kwargs) TranslationFactory.create_batch(unapproved, user=contributor, approved=False, fuzzy=False, **kwargs) TranslationFactory.create_batch(needs_work, user=contributor, fuzzy=True, **kwargs) return contributor
def test_non_active_contributor(self): """Test if backend is able return events for a user without contributions.""" nonactive_contributor = UserFactory.create() self.client.get('/contributors/{}/timeline/'.format( nonactive_contributor.username)) assert_equal(self.mock_render.call_args[0][2]['events'], [{ 'date': nonactive_contributor.date_joined, 'type': 'join' }])
def test_users_without_translations(self): """ Checks if user contributors without translations aren't returned. """ active_contributor = TranslationFactory.create(user__email="*****@*****.**").user inactive_contributor = UserFactory.create(email="*****@*****.**") top_contributors = User.translators.with_translation_counts() assert_true(active_contributor in top_contributors) assert_true(inactive_contributor not in top_contributors)
def test_non_active_contributor(self): """Test if backend is able return events for a user without contributions.""" nonactive_contributor = UserFactory.create() self.client.get( "/contributors/{}/timeline/".format(nonactive_contributor.username) ) assert_equal( self.mock_render.call_args[0][2]["events"], [{"date": nonactive_contributor.date_joined, "type": "join"}], )
def test_save_extra_metadata(self): """ If last_updated or last_translator is set on the latest translation, update the metadata for those fields. """ test_input = self.generate_pofile( dedent(""" msgid "Latest" msgstr "Latest" msgid "Older" msgstr "Older" """), revision_date='2012-01-01 00:00+0000', last_translator='last <*****@*****.**>' ) path, resource = self.parse_string(test_input) latest_translation, older_translation = resource.translations latest_translation.last_updated = aware_datetime(2015, 1, 1, 0, 0, 0) latest_translation.last_translator = UserFactory( first_name='New', email='*****@*****.**' ) older_translation.last_updated = aware_datetime(1970, 1, 1, 0, 0, 0) older_translation.last_translator = UserFactory( first_name='Old', email='*****@*****.**' ) resource.save(self.locale) self.assert_file_content(path, self.generate_pofile( dedent(""" msgid "Latest" msgstr "Latest" msgid "Older" msgstr "Older" """), revision_date='2015-01-01 00:00+0000', last_translator='New <*****@*****.**>' ))
def test_non_active_contributor(self): """Test if backend is able return events for a user without contributions.""" nonactive_contributor = UserFactory.create() self.client.get('/contributors/{}/timeline/'.format(nonactive_contributor.username)) assert_equal( self.mock_render.call_args[0][2]['events'], [ { 'date': nonactive_contributor.date_joined, 'type': 'join' } ])
def test_users_without_translations(self): """ Checks if user contributors without translations aren't returned. """ active_contributor = TranslationFactory.create( user__email='*****@*****.**').user inactive_contributor = UserFactory.create(email='*****@*****.**') top_contributors = User.translators.with_translation_counts() assert_true(active_contributor in top_contributors) assert_true(inactive_contributor not in top_contributors)
def test_basic(self): user = UserFactory.create() self.changeset.commit_authors_per_locale = { self.translated_locale.code: [user] } self.db_project.repository_for_path = Mock( return_value=self.repository) commit_changes(self.db_project, self.vcs_project, self.changeset) self.repository.commit.assert_called_with( CONTAINS(user.display_name), user, os.path.join(FAKE_CHECKOUT_PATH, self.translated_locale.code))
def test_basic(self): user = UserFactory.create() self.changeset.commit_authors_per_locale = { self.translated_locale.code: [user] } self.db_project.repository_for_path = Mock(return_value=self.repository) commit_changes(self.db_project, self.vcs_project, self.changeset) self.repository.commit.assert_called_with( CONTAINS(user.display_name), user, os.path.join(FAKE_CHECKOUT_PATH, self.translated_locale.code) )
def test_commit_changes(self): user = UserFactory.create() self.changeset.commit_authors_per_locale = { self.translated_locale.code: [user] } self.command.commit_changes(self.db_project, self.vcs_project, self.changeset) self.mock_commit_to_vcs.assert_called_with( 'git', os.path.join(FAKE_CHECKOUT_PATH, self.translated_locale.code), CONTAINS(user.display_name), user, 'https://example.com/git' )
def test_multiple_authors(self): """ Tests if multiple authors are passed to commit message. """ first_author, second_author = UserFactory.create_batch(2) self.changeset.commit_authors_per_locale = { self.translated_locale.code: [first_author, second_author] } self.db_project.repository_for_path = Mock(return_value=self.repository) commit_changes(self.db_project, self.vcs_project, self.changeset) self.repository.commit.assert_called_with( CONTAINS(first_author.display_name, second_author.display_name), first_author, os.path.join(FAKE_CHECKOUT_PATH, self.translated_locale.code) )
def test_author_with_multiple_contributions(self): """ Tests if author with multiple contributions occurs once in commit message. """ author = UserFactory.create() self.changeset.commit_authors_per_locale = {self.translated_locale.code: [author, author]} self.db_project.repository_for_path = Mock(return_value=self.repository) commit_changes(self.db_project, self.vcs_project, self.changeset, self.translated_locale) self.repository.commit.assert_called_with( CONTAINS(author.display_name_and_email), author, os.path.join(FAKE_CHECKOUT_PATH, self.translated_locale.code), ) commit_message = self.repository.commit.mock_calls[0][1][0] assert_equal(commit_message.count(author.display_name_and_email), 1)
def test_update_db_reject_approved(self): """ When a translation is submitted through VCS, reject any existing approved translations. """ self.main_db_translation.approved = True self.main_db_translation.approved_date = aware_datetime(1970, 1, 1) self.main_db_translation.approved_user = UserFactory.create() self.main_db_translation.rejected = False self.main_db_translation.save() self.main_vcs_translation.strings[None] = 'New Translated String' self.update_main_db_entity() self.main_db_translation.refresh_from_db() assert_attributes_equal( self.main_db_translation, rejected=True, )
def test_author_with_multiple_contributions(self): """ Tests if author with multiple contributions occurs once in commit message. """ author = UserFactory.create() self.changeset.commit_authors_per_locale = { self.translated_locale.code: [author, author] } self.db_project.repository_for_path = Mock( return_value=self.repository) commit_changes(self.db_project, self.vcs_project, self.changeset, self.translated_locale) self.repository.commit.assert_called_with( CONTAINS(author.display_name_and_email), author, os.path.join(FAKE_CHECKOUT_PATH, self.translated_locale.code)) commit_message = self.repository.commit.mock_calls[0][1][0] assert_equal(commit_message.count(author.display_name_and_email), 1)
def test_update_db_reject_approved_skip_fuzzy(self): """ When a translation is submitted through VCS, reject any existing approved translations. Unless the same translation is submitted and only made fuzzy. """ self.main_db_translation.approved = True self.main_db_translation.approved_date = aware_datetime(1970, 1, 1) self.main_db_translation.approved_user = UserFactory.create() self.main_db_translation.rejected = False self.main_db_translation.save() self.main_vcs_translation.strings[None] = self.main_db_translation.string self.main_vcs_translation.fuzzy = True self.update_main_db_entity() self.main_db_translation.refresh_from_db() assert_attributes_equal( self.main_db_translation, rejected=False, )
def test_multiple_authors(self): """ Tests if multiple authors are passed to commit message. The author with the most occurrences for the locale should be set as the commit author. """ first_author, second_author = UserFactory.create_batch(2) self.changeset.commit_authors_per_locale = { self.translated_locale.code: [first_author, first_author, second_author] } self.db_project.repository_for_path = Mock(return_value=self.repository) commit_changes(self.db_project, self.vcs_project, self.changeset, self.translated_locale) self.repository.commit.assert_called_with( CONTAINS(first_author.display_name_and_email, second_author.display_name_and_email), first_author, os.path.join(FAKE_CHECKOUT_PATH, self.translated_locale.code) )
def test_update_db_reject_approved(self): """ When a translation is submitted through VCS, reject any existing approved translations. """ self.main_db_translation.approved = True self.main_db_translation.approved_date = aware_datetime(1970, 1, 1) self.main_db_translation.approved_user = UserFactory.create() self.main_db_translation.rejected = False self.main_db_translation.save() self.main_vcs_translation.strings[None] = "New Translated String" self.update_main_db_entity() self.main_db_translation.refresh_from_db() assert_attributes_equal( self.main_db_translation, rejected=True, ) assert ActionLog.objects.filter( action_type=ActionLog.ActionType.TRANSLATION_REJECTED, translation=self.main_db_translation.pk, ).exists()
def test_manage_project_strings(self): project = ProjectFactory.create(data_source='database', repositories=[]) url = reverse('pontoon.admin.project.strings', args=(project.slug, )) # Test with anonymous user. response = self.client.get(url) assert_code(response, 403) # Test with a user that is not a superuser. user = UserFactory.create() self.client.force_login(user) response = self.client.get(url) assert_code(response, 403) # Test with a superuser. user.is_superuser = True user.save() response = self.client.get(url) assert_code(response, 200)
def test_multiple_authors(self): """ Commit message should include authors from translations of separate entities. """ first_author, second_author = UserFactory.create_batch(2) TranslationFactory.create( locale=self.translated_locale, entity=self.main_db_entity, user=first_author, approved=True ) TranslationFactory.create( locale=self.translated_locale, entity=self.main_db_entity, approved=False ) TranslationFactory.create( locale=self.translated_locale, entity=self.other_db_entity, user=second_author, approved=True ) TranslationFactory.create( locale=self.translated_locale, entity=self.other_db_entity, approved=False ) self.changeset.update_vcs_entity(self.translated_locale, self.main_db_entity, MagicMock()) self.changeset.update_vcs_entity(self.translated_locale, self.other_db_entity, MagicMock()) self.changeset.execute_update_vcs() assert_equal( self.changeset.commit_authors_per_locale[self.translated_locale.code], [first_author, second_author] )
def test_update_db_unapprove_existing(self): """ Any existing translations that don't match anything in VCS get unapproved, unless they were created after self.now. """ self.main_db_translation.approved = True self.main_db_translation.approved_date = aware_datetime(1970, 1, 1) self.main_db_translation.approved_user = UserFactory.create() self.main_db_translation.save() self.main_vcs_translation.strings[None] = "New Translated String" created_after_translation = TranslationFactory.create( entity=self.main_db_entity, approved=True, approved_date=aware_datetime(1970, 1, 3), ) self.update_main_db_entity() self.main_db_translation.refresh_from_db() assert_attributes_equal( self.main_db_translation, approved=False, approved_user=None, approved_date=None, ) assert ActionLog.objects.filter( action_type=ActionLog.ActionType.TRANSLATION_REJECTED, translation=self.main_db_translation.pk, ).exists() created_after_translation.refresh_from_db() assert_attributes_equal( created_after_translation, approved=True, approved_date=aware_datetime(1970, 1, 3), )
def setUp(self): self.user0, self.user1 = UserFactory.create_batch(2)
def setUp(self): self.user = UserFactory.create(is_superuser=True) self.client.force_login(self.user)
def setUp(self): self.user = UserFactory.create() self.client.force_login(self.user)
def setUp(self): self.user = UserFactory.create() # Sign in but don't migrate account to fxa self.client.force_login(self.user)
def test_update_vcs_entity_user(self): """Track translation authors for use in the commit message.""" user = UserFactory.create() self.update_main_vcs_entity(user=user) assert_equal(self.changeset.commit_authors_per_locale['translated-locale'], [user])