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_update_db_existing_translation(self): """ Update an existing translation in the DB with changes from VCS. """ # Set up DB and VCS to differ and require an update. self.main_db_translation.fuzzy = True self.main_db_translation.extra = {} self.main_db_translation.save() self.main_vcs_entity.key = "Source String" self.main_vcs_entity.comments = ["first comment", "second"] self.main_vcs_entity.order = 7 self.main_vcs_entity.string_plural = "plural string" self.main_vcs_entity.source = ["foo.py:87"] self.main_vcs_translation.fuzzy = False # The test translation is from a langfile so we can use tags # for testing extra. self.main_vcs_translation.tags = set(["ok"]) self.update_main_db_entity() self.main_db_entity.refresh_from_db() assert_attributes_equal( self.main_db_entity, key="Source String", comment="first comment\nsecond", order=7, string_plural="plural string", source=["foo.py:87"], ) self.main_db_translation.refresh_from_db() assert_attributes_equal(self.main_db_translation, fuzzy=False, extra={"tags": ["ok"]})
def test_parse_hash_with_rule(self): source = ''' <sample_hash[@cldr.global($n)] { *one: "First string", other: "Second string" } first_attr: "First string attribute" > ''' _, resource = self.parse_string(source) assert_equal(len(resource.translations), 2) assert_attributes_equal(resource.translations[0], key=self.key('sample_hash'), source_string='First string', source_string_plural='Second string', strings={ 0: 'First string', 1: 'Second string', }, order=0) assert_attributes_equal(resource.translations[1], key=self.key('sample_hash.first_attr'), strings={None: 'First string attribute'}, order=1 )
def run_parse_multiple_comments( self, input_string, translation_index, comments=None, ): path, resource = self.parse_string(input_string) if comments is None: comments = ["First comment", "Second comment"] assert_attributes_equal( resource.translations[translation_index], comments=comments, source=[], key=self.key("Multiple Comments"), strings={None: "Translated Multiple Comments"}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string="Multiple Comments", source_string_plural="", )
def run_parse_multiple_comments( self, input_string, translation_index, comments=None, ): path, resource = self.parse_string(input_string) if comments is None: comments = ['First comment', 'Second comment'] assert_attributes_equal( resource.translations[translation_index], comments=comments, source=[], key=self.key('Multiple Comments'), strings={None: 'Translated Multiple Comments'}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string='Multiple Comments', source_string_plural='' )
def test_parse_hash_attributes(self): source = ''' <sample_hash { *one: "First string", other: "Second string" } first_attr: "First string attribute" > ''' _, resource = self.parse_string(source) assert_equal(len(resource.translations), 2) assert_attributes_equal(resource.translations[0], key=self.key('sample_hash'), source_string='First string', source_string_plural='Second string', strings={ 0: 'First string', 1: 'Second string', }, order=0) assert_attributes_equal(resource.translations[1], key=self.key('sample_hash.first_attr'), source_string='First string attribute', strings={None: 'First string attribute'}, order=1)
def test_update_db_existing_translation(self): """ Update an existing translation in the DB with changes from VCS. """ # Set up DB and VCS to differ and require an update. self.main_db_translation.fuzzy = True self.main_db_translation.extra = {} self.main_db_translation.save() self.main_vcs_entity.key = 'Source String' self.main_vcs_entity.comments = ['first comment', 'second'] self.main_vcs_entity.order = 7 self.main_vcs_entity.string_plural = 'plural string' self.main_vcs_entity.source = ['foo.py:87'] self.main_vcs_translation.fuzzy = False # The test translation is from a langfile so we can use tags # for testing extra. self.main_vcs_translation.tags = set(['ok']) self.update_main_db_entity() self.main_db_entity.refresh_from_db() assert_attributes_equal( self.main_db_entity, key='Source String', comment='first comment\nsecond', order=7, string_plural='plural string', source=['foo.py:87'], ) self.main_db_translation.refresh_from_db() assert_attributes_equal(self.main_db_translation, fuzzy=False, extra={'tags': ['ok']})
def test_create_db(self): """Create new entity in the database.""" self.main_db_entity.delete() self.main_vcs_entity.key = 'Source String' self.main_vcs_entity.comments = ['first comment', 'second'] self.main_vcs_entity.order = 7 self.main_vcs_translation.fuzzy = False self.main_vcs_entity.string_plural = 'plural string' self.main_vcs_entity.source = ['foo.py:87'] self.changeset.create_db_entity(self.main_vcs_entity) self.changeset.execute() new_entity = Entity.objects.get( resource__path=self.main_vcs_resource.path, string=self.main_vcs_entity.string) assert_attributes_equal( new_entity, resource=self.main_db_resource, string='Source String', key='Source String', comment='first comment\nsecond', order=7, string_plural='plural string', source=['foo.py:87'], ) new_translation = new_entity.translation_set.all()[0] assert_attributes_equal(new_translation, locale=self.translated_locale, string='Translated String', plural_form=None, approved=True, approved_date=aware_datetime(1970, 1, 1), fuzzy=False)
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_parse_multiline_comment(self): path, resource = self.parse_string(BASE_L20N_FILE) assert_attributes_equal( resource.translations[3], comments=["Multiline\nComment"], key=self.key('Multiline Comment'), strings={None: 'Multiline Comment'}, order=3, )
def test_update_db_unfuzzy_existing(self): """ Any existing fuzzy translations get unfuzzied. """ self.main_db_translation.fuzzy = True 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, fuzzy=False)
def test_parse_no_comments_no_sources(self): path, resource = self.parse_string(BASE_JSON_FILE) assert_attributes_equal( resource.translations[0], comments=[], source=[], key=self.key('["No Comments or Sources"]'), strings={None: "Translated No Comments or Sources"}, source_string_plural="", fuzzy=False, order=0, )
def test_parse_nested(self): path, resource = self.parse_string(BASE_JSON_FILE) assert_attributes_equal( resource.translations[1], comments=[], source=[], # Nested keys are internally using "\200" as a separator key=self.key('["Nested", "key"]'), strings={None: "value"}, fuzzy=False, order=1, )
def test_parse_basic(self): input_string = BASE_FTL_FILE translation_index = 0 path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=['Sample comment'], key=self.key('Source String'), strings={None: 'SourceString = Translated String\n'}, fuzzy=False, order=translation_index, )
def test_parse_multiple_comments(self): input_string = BASE_JSON_FILE translation_index = 1 path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=['Second comment'], source=[], key=self.key('Multiple Comments'), strings={None: 'Translated Multiple Comments'}, fuzzy=False, order=translation_index, )
def test_parse_multiple_comments(self): input_string = BASE_FTL_FILE translation_index = 1 path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=['First comment\nSecond comment'], source=[], key=self.key('Multiple Comments'), strings={None: 'MultipleComments = Translated Multiple Comments\n'}, fuzzy=False, order=translation_index, )
def test_parse_no_comments_no_sources(self): input_string = BASE_FTL_FILE translation_index = 2 path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key('No Comments Or Sources'), strings={None: 'NoCommentsOrSources = Translated No Comments or Sources\n'}, fuzzy=False, order=translation_index, )
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_parse_multiple_comments(self): input_string = BASE_FTL_FILE translation_index = 1 path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=["First comment\nSecond comment"], source=[], key=self.key("Multiple Comments"), strings={None: "MultipleComments = Translated Multiple Comments\n"}, fuzzy=False, order=translation_index, )
def test_update_db_approve_translation(self): """ Approve any un-approved translations that have counterparts in VCS. """ self.main_db_translation.approved = False self.main_db_translation.approved_date = None self.main_db_translation.save() self.update_main_db_entity() self.main_db_translation.refresh_from_db() assert_attributes_equal(self.main_db_translation, approved=True, approved_date=aware_datetime(1970, 1, 1))
def test_update_db_unfuzzy_existing(self): """ Any existing fuzzy translations get unfuzzied. """ self.main_db_translation.fuzzy = True 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, fuzzy=False )
def test_parse_no_comments_no_sources(self): input_string = BASE_FTL_FILE translation_index = 2 path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key("No Comments Or Sources"), strings={None: "NoCommentsOrSources = Translated No Comments or Sources\n"}, fuzzy=False, order=translation_index, )
def test_update_db_dont_approve_fuzzy(self): """ Do not approve un-approved translations that have non-fuzzy counterparts in VCS. """ self.main_db_translation.approved = False self.main_db_translation.approved_date = None self.main_db_translation.save() 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, approved=False, approved_date=None)
def test_key_and_context_format(self): input_string = dedent( """ { "Source": { "String": "Source String" } } """ ) path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[0], key='["Source", "String"]', context="Source.String", )
def run_parse_multiple_sources(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[('file.py', '2'), ('file.py', '3')], key=self.key('Multiple Sources'), strings={None: 'Translated Multiple Sources'}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal(resource.translations[translation_index], source_string='Multiple Sources', source_string_plural='')
def run_parse_missing_translation(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key('Missing Translation'), strings={}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal(resource.translations[translation_index], source_string='Missing Translation', source_string_plural='')
def test_update_db_approve_translation(self): """ Approve any un-approved translations that have counterparts in VCS. """ self.main_db_translation.approved = False self.main_db_translation.approved_date = None self.main_db_translation.save() self.update_main_db_entity() self.main_db_translation.refresh_from_db() assert_attributes_equal( self.main_db_translation, approved=True, approved_date=aware_datetime(1970, 1, 1) )
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 run_parse_fuzzy(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key('Fuzzy'), strings={None: 'Translated Fuzzy'}, fuzzy=True, order=translation_index, ) if self.supports_source_string: assert_attributes_equal(resource.translations[translation_index], source_string='Fuzzy', source_string_plural='')
def test_parse_placeholder(self): input_string = BASE_JSON_FILE translation_index = 3 path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=['Peer greeting'], source={"your_name": { "content": "$1", "example": "Cira" }}, key=self.key('placeholder'), strings={None: 'Hello $YOUR_NAME$'}, fuzzy=False, order=translation_index, )
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_parse_hash_entities(self): source = ''' /*Hash comment*/ <multiple_hash_items { *one: "One item", other: "Other items", }> ''' path, resource = self.parse_string(source) assert_attributes_equal(resource.translations[0], key=self.key('multiple_hash_items'), strings={ 0: "One item", 1: "Other items", }, comments=['Hash comment'], order=0)
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 run_parse_no_comments_no_sources(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key('No Comments or Sources'), strings={None: 'Translated No Comments or Sources'}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal(resource.translations[translation_index], source_string='No Comments or Sources', source_string_plural='')
def test_update_db_dont_approve_fuzzy(self): """ Do not approve un-approved translations that have non-fuzzy counterparts in VCS. """ self.main_db_translation.approved = False self.main_db_translation.approved_date = None self.main_db_translation.save() 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, approved=False, approved_date=None )
def test_update_db_new_translation(self): """ If a matching translation does not exist in the database, create a new one. """ self.main_db_translation.delete() self.update_main_db_entity() translation = self.main_db_entity.translation_set.all()[0] assert_attributes_equal(translation, locale=self.translated_locale, string='Translated String', plural_form=None, approved=True, approved_date=aware_datetime(1970, 1, 1), fuzzy=False, extra={'tags': []})
def run_parse_fuzzy(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key('Fuzzy'), strings={None: 'Translated Fuzzy'}, fuzzy=True, order=translation_index, ) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string='Fuzzy', source_string_plural='' )
def run_parse_no_comments_no_sources(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key('No Comments or Sources'), strings={None: 'Translated No Comments or Sources'}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string='No Comments or Sources', source_string_plural='' )
def run_parse_missing_traslation(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key('Missing Translation'), strings={}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string='Missing Translation', source_string_plural='' )
def test_parse_placeholder(self): input_string = BASE_JSON_FILE translation_index = 3 path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=['Peer greeting'], source={ "your_name": { "content": "$1", "example": "Cira" } }, key=self.key('placeholder'), strings={None: 'Hello $YOUR_NAME$'}, fuzzy=False, order=translation_index, )
def test_parse_hash_entities(self): source = ''' /*Hash comment*/ <multiple_hash_items { *one: "One item", other: "Other items", }> ''' path, resource = self.parse_string(source) assert_attributes_equal(resource.translations[0], key=self.key('multiple_hash_items'), strings={ 0: "One item", 1: "Other items", }, comments=['Hash comment'], order=0 )
def run_parse_empty_translation(self, input_string, translation_index): """Test that empty translations are parsed properly.""" path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key('Empty Translation'), strings={None: u''}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string='Empty Translation', )
def run_parse_multiple_sources(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[("file.py", "2"), ("file.py", "3")], key=self.key("Multiple Sources"), strings={None: "Translated Multiple Sources"}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string="Multiple Sources", source_string_plural="", )
def run_parse_multiple_sources(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[('file.py', '2'), ('file.py', '3')], key=self.key('Multiple Sources'), strings={None: 'Translated Multiple Sources'}, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string='Multiple Sources', source_string_plural='' )
def test_update_db_new_translation(self): """ If a matching translation does not exist in the database, create a new one. """ self.main_db_translation.delete() self.update_main_db_entity() translation = self.main_db_entity.translation_set.all()[0] assert_attributes_equal( translation, locale=self.translated_locale, string='Translated String', plural_form=None, approved=True, approved_date=aware_datetime(1970, 1, 1), fuzzy=False, extra={'tags': []} )
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_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 run_parse_plural_translation_missing(self, input_string, translation_index): path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=[], source=[], key=self.key('Plural %(count)s string with missing translations'), strings={ 1: 'Translated Plural %(count)s strings with missing translations' }, fuzzy=False, order=translation_index, ) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string='Plural %(count)s string with missing translations', source_string_plural='Plural %(count)s strings with missing translations', )
def test_period_filters(self): """ Total counts should be filtered by given date. Test creates 2 contributors with different activity periods and checks if they are filtered properly. """ first_contributor = self.create_contributor_with_translation_counts(approved=12, unapproved=1, needs_work=2, date=aware_datetime(2015, 3, 2)) # Second contributor self.create_contributor_with_translation_counts(approved=2, unapproved=11, needs_work=2, date=aware_datetime(2015, 6, 1)) TranslationFactory.create_batch(5, approved=True, user=first_contributor, date=aware_datetime(2015, 7, 2)) top_contributors = User.translators.with_translation_counts(aware_datetime(2015, 6, 10)) assert_equal(top_contributors.count(), 1) assert_attributes_equal(top_contributors[0], translations_count=5, translations_approved_count=5, translations_unapproved_count=0, translations_needs_work_count=0) top_contributors = User.translators.with_translation_counts(aware_datetime(2015, 5, 10)) assert_equal(top_contributors.count(), 2) assert_attributes_equal(top_contributors[0], translations_count=15, translations_approved_count=2, translations_unapproved_count=11, translations_needs_work_count=2) assert_attributes_equal(top_contributors[1], translations_count=5, translations_approved_count=5, translations_unapproved_count=0, translations_needs_work_count=0) top_contributors = User.translators.with_translation_counts(aware_datetime(2015, 1, 10)) assert_equal(top_contributors.count(), 2) assert_attributes_equal(top_contributors[0], translations_count=20, translations_approved_count=17, translations_unapproved_count=1, translations_needs_work_count=2) assert_attributes_equal(top_contributors[1], translations_count=15, translations_approved_count=2, translations_unapproved_count=11, translations_needs_work_count=2)
def run_parse_basic(self, input_string, translation_index): """Basic translation with a comment and source.""" path, resource = self.parse_string(input_string) assert_attributes_equal( resource.translations[translation_index], comments=['Sample comment'], key=self.key('Source String'), strings={None: 'Translated String'}, fuzzy=False, order=translation_index, ) if self.supports_source: assert_equal(resource.translations[translation_index].source, [('file.py', '1')]) if self.supports_source_string: assert_attributes_equal( resource.translations[translation_index], source_string='Source String', source_string_plural='' )
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_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_parse_string_attributes(self): source = ''' <multiple_attributes "Multiple attributes" first: "First attribute" second: "Second attribute"> ''' path, resource = self.parse_string(source) assert_attributes_equal(resource.translations[0], key=self.key('multiple_attributes'), strings={None: 'Multiple attributes'}, order=0, ) assert_attributes_equal(resource.translations[1], key=self.key('multiple_attributes.first'), strings={None: 'First attribute'}, order=1, ) assert_attributes_equal(resource.translations[2], key=self.key('multiple_attributes.second'), strings={None: 'Second attribute'}, order=2, )
def test_create_db(self): """Create new entity in the database.""" self.main_db_entity.delete() self.main_vcs_entity.key = 'string-key' self.main_vcs_entity.comments = ['first comment', 'second'] self.main_vcs_entity.order = 7 self.main_vcs_translation.fuzzy = False self.main_vcs_entity.string_plural = 'plural string' self.main_vcs_entity.source = ['foo.py:87'] self.changeset.create_db_entity(self.main_vcs_entity) self.changeset.execute() new_entity = Entity.objects.get( resource__path=self.main_vcs_resource.path, string=self.main_vcs_entity.string ) assert_attributes_equal( new_entity, resource=self.main_db_resource, string='Source String', key='string-key', comment='first comment\nsecond', order=7, string_plural='plural string', source=['foo.py:87'], ) new_translation = new_entity.translation_set.all()[0] assert_attributes_equal( new_translation, locale=self.translated_locale, string='Translated String', plural_form=None, approved=True, approved_date=aware_datetime(1970, 1, 1), fuzzy=False )
def test_update_db_existing_translation(self): """ Update an existing translation in the DB with changes from VCS. """ self.create_db_entities_translations() # Set up DB and VCS to differ and require an update. self.main_db_translation.fuzzy = True self.main_db_translation.extra = {} self.main_db_translation.save() self.main_vcs_entity.key = 'string-key' self.main_vcs_entity.comments = ['first comment', 'second'] self.main_vcs_entity.order = 7 self.main_vcs_entity.string_plural = 'plural string' self.main_vcs_entity.source = ['foo.py:87'] self.main_vcs_translation.fuzzy = False # The test translation is from a langfile so we can use tags # for testing extra. self.main_vcs_translation.tags = set(['ok']) self.update_main_db_entity() self.main_db_entity.refresh_from_db() assert_attributes_equal( self.main_db_entity, key='string-key', comment='first comment\nsecond', order=7, string_plural='plural string', source=['foo.py:87'], ) self.main_db_translation.refresh_from_db() assert_attributes_equal( self.main_db_translation, fuzzy=False, extra={'tags': ['ok']} )