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_removed_files(self): with patch.object( self.vcsrepository, 'execute', side_effect=self.execute_success ) as mock_execute: removed_files = self.vcsrepository.get_removed_files('/path', '1') assert_true(mock_execute.called) assert_equal(removed_files, ['removed_file1.properties', 'removed_file2.properties'])
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 assert_xml(xml_content, expected_xml=None, dtd_path=None): """Provided xml_content should be a valid XML string and be equal to expected_xml.""" def to_xml(string): """ A shortcut function to load xml. """ return etree.fromstring(string) def normalize_xml(xml_string): """ Helps to normalize different xml to the same format, indentation etc. At the same time, content is validated. """ return etree.tostring(to_xml(xml_content)) validated_xml = normalize_xml(xml_content) if dtd_path: dtd = etree.DTD(dtd_path) if not dtd.validate(to_xml(xml_content)): raise AssertionError(dtd.error_log) if expected_xml is not None: assert_equal(validated_xml, normalize_xml(expected_xml))
def test_resources_parse_error(self): """ If VCSResource() raises a ParseError while loading, log an error and skip the resource. """ self.vcs_project.relative_resource_paths = Mock(return_value=['failure', 'success']) # Fail only if the path is failure so we can test the ignore. def vcs_resource_constructor(project, path, locales=None): if path == 'failure': raise ParseError('error message') else: return 'successful resource' changed_vcs_resources = {'success': [], 'failure': []} with patch('pontoon.sync.vcs.models.VCSResource') as MockVCSResource, \ patch('pontoon.sync.vcs.models.log') as mock_log, \ patch.object( VCSProject, 'changed_files', new_callable=PropertyMock, return_value=changed_vcs_resources ): MockVCSResource.side_effect = vcs_resource_constructor assert_equal(self.vcs_project.resources, {'success': 'successful resource'}) mock_log.error.assert_called_with(CONTAINS('failure', 'error message'))
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_update_vcs_entity_unapproved(self): """ Do not update VCS with unapproved translations. If no approved translations exist, delete existing ones. """ self.update_main_vcs_entity(approved=False) assert_equal(self.main_vcs_translation.strings, {})
def test_shove_instances(self): instance1 = ShoveInstanceFactory.create(hostname='foo', active=True) instance2 = ShoveInstanceFactory.create(hostname='bar', active=True) ShoveInstanceFactory.create(hostname='baz', active=False) command = ScheduledCommandFactory(hostnames='foo,bar,baz') assert_equal(set(command.shove_instances), set([instance1, instance2]))
def test_python_new_format_placeables(self): """Test detection of the new format string in python strings.""" assert_equal( mark_placeables(u'Hello {name}'), u'Hello <mark class="placeable" title="Python format string">{name}</mark>' ) assert_equal( mark_placeables(u'Hello {name!s}'), u'Hello <mark class="placeable" title="Python format string">{name!s}</mark>' ) assert_equal( mark_placeables(u'Hello {someone.name}'), u'Hello <mark class="placeable" title="Python format string">{someone.name}</mark>' ) assert_equal( mark_placeables(u'Hello {name[0]}'), u'Hello <mark class="placeable" title="Python format string">{name[0]}</mark>' ) assert_equal( mark_placeables(u'Hello {someone.name[0]}'), u'Hello <mark class="placeable" title="Python format string">{someone.name[0]}</mark>' )
def test_connect_existing_persona_account(self): self.log_mock.side_effect = lambda provider: provider == 'persona' self.adapter.pre_social_login(MagicMock, self.get_sociallogin('fxa')) assert_true(self.sociallogin.account.pk) assert_equal(self.sociallogin.user, self.user)
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_connect_normal_auth_account(self): self.log_mock.return_value = False self.adapter.pre_social_login(MagicMock(), self.get_sociallogin('fxa')) assert_true(self.sociallogin.account.pk) assert_equal(self.sociallogin.user, self.user)
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_latest_datetime(self): larger = aware_datetime(2015, 1, 1) smaller = aware_datetime(2014, 1, 1) assert_is_none(latest_datetime([None, None, None])) assert_equal(latest_datetime([None, larger]), larger) assert_equal(latest_datetime([None, smaller, larger]), larger)
def test_homepage(self): response = self.client.get('/') data = json.loads(response.content) nt.assert_in('hello', data) nt.assert_equal('world', data['hello']) # new shit only in django-nose nt.assert_code(response, 200)
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 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_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_remove_duplicate_approvals(self): """ Ensure that duplicate approvals are removed. """ # Trigger creation of new approved translation. self.main_vcs_translation.strings[None] = 'New Translated String' self.main_vcs_translation.fuzzy = False # Translation approved after the sync started simulates the race # where duplicate translations occur. duplicate_translation = TranslationFactory.create( entity=self.main_db_entity, locale=self.translated_locale, string='Other New Translated String', approved=True, approved_date=aware_datetime(1970, 1, 3) ) ChangedEntityLocale.objects.filter(entity=self.main_db_entity).delete() with patch('pontoon.sync.tasks.VCSProject', return_value=self.vcs_project): sync_project_repo(self.db_project.pk, self.repository.pk, self.project_sync_log.pk, self.now) # Only one translation should be approved: the duplicate_translation. assert_equal(self.main_db_entity.translation_set.filter(approved=True).count(), 1) new_translation = self.main_db_entity.translation_set.get( string='New Translated String' ) assert_false(new_translation.approved) assert_true(new_translation.approved_date is None) duplicate_translation.refresh_from_db() assert_true(duplicate_translation.approved) assert_equal(duplicate_translation.approved_date, aware_datetime(1970, 1, 3))
def test_entity_filters(self): """ Tests if right filter calls right method in the Entity manager. """ filters = ( 'missing', 'fuzzy', 'suggested', 'translated', 'untranslated', 'has-suggestions', 'unchanged', ) for filter_ in filters: filter_name = filter_.replace('-', '_') with patch('pontoon.base.models.Entity.objects.{}'.format(filter_name), return_value=Entity.objects.all()) as filter_mock: self.client.post('/get-entities/', { 'project': self.resource.project.slug, 'locale': self.locale.code, 'paths[]': [self.resource.path], 'filter': filter_, 'limit': 1, }, HTTP_X_REQUESTED_WITH='XMLHttpRequest') assert_true(filter_mock.called) assert_equal(filter_mock.call_args, call(self.locale))
def test_basic_run(self): """ When the command is run, any scheduled commands that are due to run should be sent to shove. """ command1 = self._mock_command(is_due=False, command='foo') command2 = self._mock_command(is_due=True, command='bar') command3 = self._mock_command(is_due=True, command='baz') path = 'captain.projects.management.commands.process_command_schedule.ScheduledCommand' with patch(path) as MockScheduledCommand: MockScheduledCommand.objects.all.return_value = [command1, command2, command3] cmd = process_command_schedule.Command() cmd.handle() # Commands that aren't due shoudn't have been run. assert_false(command1.project.send_command.called) # Commands that are due should have been run, and should have been saved with an updated # last_run. command2.project.send_command.assert_called_with(None, 'bar') assert_equal(command2.last_run, self.now) command2.save.assert_called_with() command3.project.send_command.assert_called_with(None, 'baz') assert_equal(command3.last_run, self.now) command3.save.assert_called_with()
def test_handle_log_found(self, mock_log): """If a command log is found, save the given output to the log.""" command_log = CommandLogFactory.create() monitor_shove_logs.handle_log_event(command_log.pk, 6, 'asdf') mock_log.assert_called_with('asdf') command_log = CommandLog.objects.get(pk=command_log.pk) # Refresh from DB assert_equal(command_log.return_code, 6)
def test_format_builtin(self): """ Test that there exist built-in formats. We're not interested in testing "all" of them, just that the capability exists. """ with self.settings(TIME_ZONE='UTC'): datetime = aware_datetime(2015, 1, 1, 5, 7) assert_equal(format_datetime(datetime, 'time'), '05:07 UTC')
def test_timeline_join(self): """Last page of results should include informations about the when user joined pontoon.""" self.client.get('/contributors/{}/timeline/?page=3'.format(self.user.username)) assert_equal(self.mock_render.call_args[0][2]['events'][-1], { 'date': self.user.date_joined, 'type': 'join' })
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_given_period(self): """ Checks if view sets and returns data for right period. """ with patch('django.utils.timezone.now', wraps=now, return_value=aware_datetime(2015, 7, 5)): self.client.get('/contributors/?period=6') assert_equal(self.mock_render.call_args[0][0]['period'], 6) assert_equal(self.mock_translations_manager.call_args[0][0], aware_datetime(2015, 1, 5))
def test_pull(self): repo = RepositoryFactory.create(type=Repository.GIT, url="https://example.com") with patch("pontoon.base.models.update_from_vcs") as update_from_vcs, patch( "pontoon.base.models.get_revision" ) as mock_get_revision: mock_get_revision.return_value = "asdf" assert_equal(repo.pull(), {"single_locale": "asdf"}) update_from_vcs.assert_called_with(Repository.GIT, "https://example.com", repo.checkout_path)
def test_checkout_path_multi_locale(self): """ The checkout_path for multi-locale repos should not include the locale_code variable. """ repo = RepositoryFactory.create(url="https://example.com/path/to/{locale_code}/", project__slug="test-project") with self.settings(MEDIA_ROOT="/media/root"): assert_equal(repo.checkout_path, "/media/root/projects/test-project/path/to")
def test_locales_parts_stats_no_page_one_resource(self): """ Return empty list in no subpage and only one resource defined. """ project_details = self._fetch_locales_parts_stats() details = project_details.get(self.locale.code) assert_equal(details, [])
def test_load_utf8_bom(self): """ Ensure that the langfile parser can load UTF-8 files with an encoded BOM at the beginning of the file. See https://docs.python.org/2/library/codecs.html for details (search for the string "utf-8-sig"). """ current_dir = os.path.dirname(__file__) resource = lang.parse(os.path.join(current_dir, 'bom.lang')) assert_equal(len(resource.translations), 1) assert_attributes_equal(resource.translations[0], source_string='Source String', strings={None: 'Translated String'})
def test_translation_counts(self): """ Checks if translation counts are calculated properly. Tests creates 3 contributors with different numbers translations and checks if their counts match. """ first_contributor = self.create_contributor_with_translation_counts( approved=7, unapproved=3, needs_work=2) second_contributor = self.create_contributor_with_translation_counts( approved=5, unapproved=9, needs_work=2) third_contributor = self.create_contributor_with_translation_counts( approved=1, unapproved=2, needs_work=5) top_contributors = User.translators.with_translation_counts() assert_equal(top_contributors.count(), 3) assert_equal(top_contributors[0], second_contributor) assert_equal(top_contributors[1], first_contributor) assert_equal(top_contributors[2], third_contributor) assert_attributes_equal(top_contributors[0], translations_count=16, translations_approved_count=5, translations_unapproved_count=9, translations_needs_work_count=2) assert_attributes_equal(top_contributors[1], translations_count=12, translations_approved_count=7, translations_unapproved_count=3, translations_needs_work_count=2) assert_attributes_equal(top_contributors[2], translations_count=8, translations_approved_count=1, translations_unapproved_count=2, translations_needs_work_count=5)
def test_update_vcs_last_translation_no_translations(self): """ If there are no translations in the database, do not set the last_updated and last_translator fields on the VCS translation. """ self.main_db_translation.delete() self.changeset.update_vcs_entity(self.translated_locale, self.main_db_entity, self.main_vcs_entity) self.changeset.execute() assert_equal(self.main_vcs_translation.last_updated, None) assert_equal(self.main_vcs_translation.last_translator, None)
def test_project_top_contributors(self): """ Tests if view returns top contributors specific for given project. """ first_project = ProjectFactory.create() ResourceFactory.create(project=first_project) first_project_contributor = TranslationFactory.create( entity__resource__project=first_project).user second_project = ProjectFactory.create() ResourceFactory.create(project=second_project) second_project_contributor = TranslationFactory.create( entity__resource__project=second_project).user with patch.object(views.ProjectContributorsView, 'render_to_response', return_value=HttpResponse('')) as mock_render: self.client.get('/projects/{}/contributors/'.format( first_project.slug)) assert_equal(mock_render.call_args[0][0]['project'], first_project) assert_equal(list(mock_render.call_args[0][0]['contributors']), [first_project_contributor]) self.client.get('/projects/{}/contributors/'.format( second_project.slug)) assert_equal(mock_render.call_args[0][0]['project'], second_project) assert_equal(list(mock_render.call_args[0][0]['contributors']), [second_project_contributor])
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 test_minimal_quality(self): """ View shouldn't return any entries if 70% of quality at minimum. """ # Generate some random entries that shouldn't be similar TranslationMemoryFactory.create_batch(5) response = self.client.get('/translation-memory/', { 'text': 'no match', 'pk': 2, 'locale': 'en-GB' }) assert_code(response, 200) assert_equal(response.content, '[]')
def test_manage_project_strings_new_all_empty(self): """Test that sending empty data doesn't create empty strings in the database. """ project = ProjectFactory.create(data_source='database', repositories=[]) url = reverse('pontoon.admin.project.strings', args=(project.slug, )) # Test sending a well-formatted batch of strings. new_strings = " \n \n\n" 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), 0)
def test_resource_paths_without_pc_exclude_hidden( self, source_directory_path_mock): """ We should filter out resources that are contained in the hidden paths. """ source_directory_path_mock.return_value = '/root' hidden_paths = ( ('/root/.hidden_folder/templates', [], ('bar.pot', )), ('/root/templates', [], ('foo.pot', )), ) with patch('pontoon.sync.vcs.models.scandir.walk', wraps=scandir, return_value=hidden_paths): assert_equal(list(self.vcs_project.resource_paths_without_pc()), ['/root/templates/foo.pot'])
def test_release_lock_after_timeout(self): """ Tests if lock is released after specified timeout. """ with patch('pontoon.sync.core.cache') as mock_cache: @serial_task(3) def timeout_task(self): return 42 first_call = timeout_task.delay() assert_true(first_call.successful()) assert_equal(first_call.get(), 42) mock_cache.add.assert_called_with(ANY, ANY, timeout=3)
def test_create_repository_log(self): assert_false(RepositorySyncLog.objects.exists()) repo = RepositoryFactory.create() self.db_project.repositories = [repo] self.db_project.save() self.mock_pull_changes.return_value = [ True, {repo.pk: Locale.objects.filter(pk=self.translated_locale.pk)}, ] sync_translations(self.db_project.pk, self.project_sync_log.pk, self.now) log = RepositorySyncLog.objects.get(repository=repo.pk) assert_equal(log.repository, repo)
def test_unapprove_translation(self): """Check if unapprove view works properly.""" translation = TranslationFactory.create() translation.approved = True translation.save() response = self.client.ajax_post('/unapprove-translation/', { 'translation': translation.pk, 'paths': [], }) assert_code(response, 200) translation.refresh_from_db() assert_equal(translation.approved, False) assert_equal(translation.unapproved_user, self.user)
def test_relative_resource_paths_pot(self): """ If a resource ends in .pot, replace the extension with .po since relative paths are used within non-source locales that do not have .pot files. """ with patch.object(VCSProject, 'source_directory_path', new_callable=PropertyMock, return_value='/root/'): self.vcs_project.resources_for_path = Mock( return_value=['/root/foo.pot', '/root/meh/bar.pot']) assert_equal(list(self.vcs_project.relative_resource_paths()), ['foo.po', 'meh/bar.po'])
def test_given_period(self): """ Checks if view sets and returns data for right period. """ with patch( "django.utils.timezone.now", wraps=now, return_value=aware_datetime(2015, 7, 5), ): self.client.get("/contributors/?period=6") assert_equal(self.mock_render.call_args[0][0]["period"], 6) assert_equal( self.mock_users_with_translations_counts.call_args[0][0], aware_datetime(2015, 1, 5), )
def test_not_authed_public_project(self): """ If the user is not authenticated and we're translating project ID 1, return a 200. """ # Clear out existing project with ID=1 if necessary. Project.objects.filter(id=1).delete() locale = LocaleFactory.create(code='fakelocale') project = ProjectFactory.create(id=1, slug='valid-project', locales=[locale]) ResourceFactory.create(project=project) response = self.client.get('/fakelocale/valid-project/') assert_equal(response.status_code, 200)
def assert_attributes_equal(original, **expected_attrs): """ Assert that the given object has attributes matching the given values. """ if not expected_attrs: raise ValueError('Expected some attributes to check.') for key, value in expected_attrs.items(): original_value = getattr(original, key) assert_equal( original_value, value, ('Attribute `{key}` does not match: {original_value} != {value}'. format(key=key, original_value=original_value, value=value)), )
def test_end_time_skipped(self): """Include skipped repos in finding the latest end time.""" sync_log = SyncLogFactory.create() RepositorySyncLogFactory.create(project_sync_log__sync_log=sync_log, end_time=aware_datetime(2015, 1, 1)) ProjectSyncLogFactory.create(sync_log=sync_log, skipped=True, skipped_end_time=aware_datetime( 2015, 1, 2)) ProjectSyncLogFactory.create(sync_log=sync_log, skipped=True, skipped_end_time=aware_datetime( 2015, 1, 4)) assert_equal(sync_log.end_time, aware_datetime(2015, 1, 4))
def test_timeline(self): """Backend should return events filtered by page number requested by user.""" self.client.get('/contributors/{}/timeline/?page=2'.format( self.user.username)) assert_equal( self.mock_render.call_args[0][2]['events'], [{ 'date': dt, 'type': 'translation', 'count': count, 'project': self.project, 'translation': translations[0][0], } for (dt, count), translations in self.translations.items()[10:20] ])
def test_execute_log_error(self): """ If the return code from execute is non-zero and log_errors is True, log an error message. """ repo = VCSRepository('/path') with patch('pontoon.sync.vcs.repositories.execute') as mock_execute, \ patch('pontoon.sync.vcs.repositories.log') as mock_log: mock_execute.return_value = 1, 'output', 'stderr' assert_equal( repo.execute('command', cwd='working_dir', log_errors=True), (1, 'output', 'stderr')) mock_log.error.assert_called_with( CONTAINS('stderr', 'command', 'working_dir'))
def test_inplace_mode(self): """ Inplace mode of get_entites, should return all entities in a single batch. """ response = self.client.ajax_post('/get-entities/', { 'project': self.resource.project.slug, 'locale': self.locale.code, 'paths[]': [self.resource.path], 'inplace_editor': True, # Inplace mode shouldn't respect paging or limiting page 'limit': 1, }) assert_code(response, 200) assert_equal(response.json()['has_next'], False) assert_equal([e['pk'] for e in response.json()['entities']], self.entities_pks)
def test_timeline(self): """Backend should return events filtered by page number requested by user.""" self.client.get("/contributors/{}/timeline/?page=2".format( self.user.username)) assert_equal( self.mock_render.call_args[0][2]["events"], [{ "date": dt, "type": "translation", "count": count, "project": self.project, "translation": translations[0][0], } for (dt, count ), translations in list(self.translations.items())[10:20]], )
def assert_redirects(response, expected_url, status_code=302, host=None, secure=False): """ Assert that the given response redirects to the expected URL. The main difference between this and TestCase.assertRedirects is that this version doesn't follow the redirect. """ if host is None: host = "{}://{}".format("https" if secure else "http", host or "testserver") assert_equal(response.status_code, status_code) assert_equal(response["Location"], host + expected_url)
def test_invalid_slugs(self): """ If some of projects have invalid slug, we should warn user about them. """ handle_project = ProjectFactory.create() self.execute_command(handle_project.slug, 'aaa', 'bbb') self.mock_sync_project.delay.assert_called_with(handle_project.pk, ANY, no_pull=False, no_commit=False, force=False) assert_equal(self.command.stderr.getvalue(), 'Couldn\'t find projects with following slugs: aaa, bbb')
def test_mark_newline_escape_placeables(self): """Test detecting newline escape sequences""" assert_equal( mark_placeables(u'A string\\n'), u'A string<mark class="placeable" title="Escaped newline">\\n</mark>' ) assert_equal( mark_placeables(u'\\nA string'), u'<mark class="placeable" title="Escaped newline">\\n</mark>A string' ) assert_equal( mark_placeables(u'A\\nstring'), u'A<mark class="placeable" title="Escaped newline">\\n</mark>string' ) assert_equal(mark_placeables(u'A string'), u'A string') assert_equal(mark_placeables(u'A\nstring'), u'A\nstring')
def test_basic(self): # Check for self.main_db_resource to be updated and # self.other_db_resource to be created. self.main_db_resource.total_strings = 5000 self.main_db_resource.save() self.other_db_resource.delete() update_resources(self.db_project, self.vcs_project) self.main_db_resource.refresh_from_db() assert_equal(self.main_db_resource.total_strings, len(self.main_vcs_resource.entities)) other_db_resource = Resource.objects.get( path=self.other_vcs_resource.path) assert_equal(other_db_resource.total_strings, len(self.other_vcs_resource.entities))
def test_for_project_locale_order(self): """ Return entities in correct order. """ # First entity EntityFactory.create(order=1, resource=self.main_resource, string='Second String') # Second entity EntityFactory.create(order=0, resource=self.main_resource, string='First String') entities = Entity.for_project_locale(self.project, self.locale) assert_equal(entities[2]['original'], 'First String') assert_equal(entities[3]['original'], 'Second String')
def test_end_time(self): """ Return the latest end time among repo sync logs for this log. """ project = ProjectFactory.create(repositories=[]) repo1, repo2 = RepositoryFactory.create_batch(2, project=project) project_sync_log = ProjectSyncLogFactory.create(project=project) RepositorySyncLogFactory.create(project_sync_log=project_sync_log, repository=repo1, end_time=aware_datetime(2015, 1, 1)) RepositorySyncLogFactory.create(project_sync_log=project_sync_log, repository=repo2, end_time=aware_datetime(2015, 1, 2)) assert_equal(project_sync_log.end_time, aware_datetime(2015, 1, 2))
def test_contributors_order(self): """ Checks if users are ordered by count of contributions. """ contributors = [ self.create_contributor_with_translation_counts(2), self.create_contributor_with_translation_counts(4), self.create_contributor_with_translation_counts(9), self.create_contributor_with_translation_counts(1), self.create_contributor_with_translation_counts(6), ] assert_equal(list(User.translators.with_translation_counts()), [ contributors[2], contributors[4], contributors[1], contributors[0], contributors[3] ])
def test_moz_langpack_contributors(self): """ If a .inc file has a commented-out entity named MOZ_LANGPACK_CONTRIBUTORS, the parser should un-comment it and process it as an entity. """ input_string = dedent(""" #define String Some String # #define MOZ_LANGPACK_CONTRIBUTORS Contributor list """) path, resource = self.parse_string(input_string) assert_equal(len(resource.translations), 2) assert_attributes_equal(resource.translations[1], key='MOZ_LANGPACK_CONTRIBUTORS', strings={None: 'Contributor list'})
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_no_translations(self): """ We don't attribute anyone if there aren't any new translations. """ TranslationFactory.create( locale=self.translated_locale, entity=self.main_db_entity, approved=True, date=aware_datetime(2015, 1, 1) ) with patch.object(self.main_db_entity, 'has_changed', return_value=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], [])