def testGood(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""<!ENTITY foo 'fooVal'> <!ENTITY bar 'barVal'> <!ENTITY eff 'effVal'>""") self.localized("""<!ENTITY foo 'lFoo'> <!ENTITY bar 'lBar'> <!ENTITY eff 'lEff'> """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.dtd", ""), File(self.l10n, "l10n.dtd", ""), mozpath.join(self.tmp, "merge", "l10n.dtd")) self.assertDictEqual(cc.observers.toJSON(), { 'summary': { None: { 'changed': 3, 'changed_w': 3 } }, 'details': {} }) self.assertTrue( filecmp.cmp(self.l10n, mozpath.join(self.tmp, "merge", 'l10n.dtd')))
def testObsolete(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal eff = effVal""") self.localized("""foo = fooVal other = obsolete eff = leffVal """) cc = ContentComparer() cc.set_merge_stage(os.path.join(self.tmp, "merge")) cc.compare(File(self.ref, "en-reference.properties", ""), File(self.l10n, "l10n.properties", "")) self.assertDictEqual( cc.observer.toJSON(), { 'summary': { None: { 'changed': 1, 'obsolete': 1, 'unchanged': 1 } }, 'details': { 'children': [('l10n.properties', { 'value': { 'obsoleteEntity': [u'other'] } })] }, })
def testMissing(self): self.reference("""\ foo = fooVal bar = barVal eff = effVal """) self.localized("""\ foo = lFoo eff = lEff """) cc = ContentComparer([Observer()]) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers[0].toJSON(), { 'details': { 'l10n.ftl': [{ 'missingEntity': u'bar' }], }, 'summary': { None: { 'changed': 2, 'changed_w': 2, 'missing': 1, 'missing_w': 1 } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assert_(not os.path.exists(mergepath))
def test_reference_junk(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""<!ENTITY foo 'fooVal'> <!ENT bar 'bad val'> <!ENTITY eff 'effVal'>""") self.localized("""<!ENTITY foo 'fooVal'> <!ENTITY eff 'effVal'> """) cc = ContentComparer([Observer()]) cc.compare(File(self.ref, "en-reference.dtd", ""), File(self.l10n, "l10n.dtd", ""), mozpath.join(self.tmp, "merge", "l10n.dtd")) self.assertDictEqual( cc.observers[0].toJSON(), { 'summary': { None: { 'warnings': 1, 'unchanged': 2, 'unchanged_w': 2 } }, 'details': { 'l10n.dtd': [{ 'warning': 'Parser error in en-US' }] } })
def testGood(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal word bar = barVal word eff = effVal""") self.localized("""foo = lFoo bar = lBar eff = lEff word """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.properties", ""), File(self.l10n, "l10n.properties", ""), mozpath.join(self.tmp, "merge", "l10n.properties")) self.assertDictEqual(cc.observers.toJSON(), { 'summary': { None: { 'changed': 3, 'changed_w': 5 } }, 'details': {} }) self.assertTrue( filecmp.cmp(self.l10n, mozpath.join(self.tmp, "merge", 'l10n.properties')))
def test_reference_xml_error(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""<!ENTITY foo 'fooVal'> <!ENTITY bar 'bad &val'> <!ENTITY eff 'effVal'>""") self.localized("""<!ENTITY foo 'fooVal'> <!ENTITY bar 'good val'> <!ENTITY eff 'effVal'> """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.dtd", ""), File(self.l10n, "l10n.dtd", ""), mozpath.join(self.tmp, "merge", "l10n.dtd")) self.assertDictEqual( cc.observers.toJSON(), { 'summary': { None: { 'warnings': 1, 'unchanged': 2, 'unchanged_w': 2, 'changed': 1, 'changed_w': 2 } }, 'details': { 'l10n.dtd': [{ 'warning': u"can't parse en-US value at line 1, " u"column 0 for bar" }] } }) mergefile = mozpath.join(self.tmp, "merge", "l10n.dtd") self.assertTrue(filecmp.cmp(self.l10n, mergefile))
def testMatchingReferences(self): self.reference("""\ foo = Reference { bar } """) self.localized("""\ foo = Localized { bar } """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual(cc.observers.toJSON(), { 'details': {}, 'summary': { None: { 'changed': 1, 'changed_w': 1 } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertTrue(filecmp.cmp(self.l10n, mergepath))
def testMissing(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal bar = barVal eff = effVal""") self.localized("""bar = lBar """) cc = ContentComparer() cc.set_merge_stage(os.path.join(self.tmp, "merge")) cc.compare(File(self.ref, "en-reference.properties", ""), File(self.l10n, "l10n.properties", "")) self.assertDictEqual( cc.observer.toJSON(), {'summary': {None: { 'changed': 1, 'missing': 2 }}, 'details': { 'children': [ ('l10n.properties', {'value': {'missingEntity': [u'eff', u'foo']}} ) ]} } ) mergefile = os.path.join(self.tmp, "merge", "l10n.properties") self.assertTrue(os.path.isfile(mergefile)) p = getParser(mergefile) p.readFile(mergefile) [m, n] = p.parse() self.assertEqual(map(lambda e: e.key, m), ["bar", "eff", "foo"])
def test_missing_file(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal bar = barVal eff = effVal""") cc = ContentComparer() cc.observers.append(Observer()) cc.add(File(self.ref, "en-reference.properties", ""), File(self.l10n, "l10n.properties", ""), mozpath.join(self.tmp, "merge", "l10n.properties")) self.assertDictEqual( cc.observers.toJSON(), { 'summary': { None: { 'missingInFiles': 3, 'missing_w': 3 } }, 'details': { 'l10n.properties': [{ 'missingFile': 'error' }] } }) mergefile = mozpath.join(self.tmp, "merge", "l10n.properties") self.assertTrue(filecmp.cmp(self.ref, mergefile))
def testMissing(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal bar = barVal eff = effVal""") self.localized("""bar = lBar """) cc = ContentComparer([Observer()]) cc.compare(File(self.ref, "en-reference.properties", ""), File(self.l10n, "l10n.properties", ""), mozpath.join(self.tmp, "merge", "l10n.properties")) self.assertDictEqual( cc.observers[0].toJSON(), { 'summary': { None: { 'changed': 1, 'changed_w': 1, 'missing': 2, 'missing_w': 2 } }, 'details': { 'l10n.properties': [{ 'missingEntity': u'foo' }, { 'missingEntity': u'eff' }] } }) mergefile = mozpath.join(self.tmp, "merge", "l10n.properties") self.assertTrue(os.path.isfile(mergefile)) p = getParser(mergefile) p.readFile(mergefile) [m, n] = p.parse() self.assertEqual(map(lambda e: e.key, m), ["bar", "foo", "eff"])
def main(argv): parser = argparse.ArgumentParser(description="Merge l10n files.") parser.add_argument("--output", help="Path to write merged output") parser.add_argument("--ref-file", help="Path to reference file (en-US)") parser.add_argument("--l10n-file", help="Path to locale file") args = parser.parse_args(argv) from compare_locales.compare import ( ContentComparer, Observer, ) from compare_locales.paths import File cc = ContentComparer([Observer()]) cc.compare( File(args.ref_file, args.ref_file, ""), File(args.l10n_file, args.l10n_file, ""), args.output, ) ensureParentDir(args.output) if not os.path.exists(args.output): src = args.l10n_file if not os.path.exists(args.l10n_file): src = args.ref_file shutil.copy(src, args.output) return 0
def testObsoleteStandaloneComment(self): self.reference("""\ foo = fooVal bar = barVal """) self.localized("""\ foo = lFoo # Standalone Comment bar = lBar """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual(cc.observers.toJSON(), { 'details': {}, 'summary': { None: { 'changed': 2, 'changed_w': 2, } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertTrue(filecmp.cmp(self.l10n, mergepath))
def test_duplicate_attributes(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal .attr = good""") self.localized("""foo = localized .attr = not .attr = so .attr = good """) cc = ContentComparer([Observer()]) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers[0].toJSON(), { 'summary': { None: { 'warnings': 1, 'changed': 1, 'changed_w': 2 } }, 'details': { 'l10n.ftl': [{ 'warning': u'Attribute "attr" occurs 3 times ' u'at line 4, column 5 for foo' }] } }) mergefile = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertFalse(os.path.isfile(mergefile))
def test_duplicate(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal bar = barVal eff = effVal foo = other val for foo""") self.localized("""foo = localized bar = lBar eff = localized eff bar = duplicated bar """) cc = ContentComparer([Observer()]) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers[0].toJSON(), { 'summary': { None: { 'errors': 1, 'warnings': 1, 'changed': 3, 'changed_w': 6 } }, 'details': { 'l10n.ftl': [{ 'warning': u'foo occurs 2 times' }, { 'error': u'bar occurs 2 times' }] } }) mergefile = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertFalse(os.path.isfile(mergefile))
def testMissingAttachedComment(self): self.reference("""\ foo = fooVal // Attached Comment bar = barVal """) self.localized("""\ foo = lFoo bar = barVal """) cc = ContentComparer([Observer()]) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers[0].toJSON(), { 'details': {}, 'summary': { None: { 'changed': 1, 'changed_w': 1, 'unchanged': 1, 'unchanged_w': 1, } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assert_(not os.path.exists(mergepath))
def testGood(self): self.reference("""\ foo = fooVal bar = barVal -eff = effVal """) self.localized("""\ foo = lFoo bar = lBar -eff = lEff """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual(cc.observers.toJSON(), { 'summary': { None: { 'changed': 3, 'changed_w': 3 } }, 'details': {} }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertTrue(filecmp.cmp(self.l10n, mergepath))
def testObsolete(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal eff = effVal""") self.localized("""foo = fooVal other = obsolete eff = leffVal """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.properties", ""), File(self.l10n, "l10n.properties", ""), mozpath.join(self.tmp, "merge", "l10n.properties")) self.assertDictEqual( cc.observers.toJSON(), { 'summary': { None: { 'changed': 1, 'changed_w': 1, 'obsolete': 1, 'unchanged': 1, 'unchanged_w': 1 } }, 'details': { 'l10n.properties': [{ 'obsoleteEntity': u'other' }] } }) mergefile = mozpath.join(self.tmp, "merge", "l10n.properties") self.assertTrue(filecmp.cmp(self.l10n, mergefile))
def testMismatchingAttributes(self): self.reference(""" foo = Foo bar = Bar .tender = Attribute value eff = Eff """) self.localized("""\ foo = lFoo .obsolete = attr bar = lBar eff = lEff """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers.toJSON(), { 'details': { 'l10n.ftl': [ { 'error': u'Obsolete attribute: ' 'obsolete at line 2, column 3 for foo' }, { 'error': u'Missing attribute: tender at line 3,' ' column 1 for bar', }, ], }, 'summary': { None: { 'changed': 3, 'changed_w': 5, 'errors': 2 } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertTrue(os.path.exists(mergepath)) p = getParser(mergepath) p.readFile(mergepath) merged_entities = p.parse() self.assertEqual(list(merged_entities.keys()), ["eff"]) merged_eff = merged_entities['eff'] # eff should be l10n p.readFile(self.l10n) l10n_entities = p.parse() l10n_eff = l10n_entities['eff'] self.assertTrue(merged_eff.equals(l10n_eff))
def testMismatchingValues(self): self.reference(""" foo = Foo .foottr = something bar = .tender = Attribute value """) self.localized("""\ foo = .foottr = attr bar = lBar .tender = localized """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers.toJSON(), { 'details': { 'l10n.ftl': [ { 'error': u'Missing value at line 1, column 1 for foo' }, { 'error': u'Obsolete value at line 3, column 7 for bar', }, ] }, 'summary': { None: { 'errors': 2, 'warnings': 0, 'missing': 0, 'missing_w': 0, 'report': 0, 'obsolete': 0, 'changed': 2, 'changed_w': 4, 'unchanged': 0, 'unchanged_w': 0, 'keys': 0, } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertTrue(os.path.exists(mergepath)) p = getParser(mergepath) p.readFile(mergepath) merged_entities = p.parse() self.assertEqual(merged_entities, tuple())
def setUp(self): self.cfg = ProjectConfig(None) self.file = File( '/tmp/somedir/de/browser/one/two/file.ftl', 'file.ftl', module='browser', locale='de') self.other_file = File( '/tmp/somedir/de/toolkit/two/one/file.ftl', 'file.ftl', module='toolkit', locale='de')
def testMismatchingReferences(self): self.reference("""\ foo = Reference { bar } bar = Reference { baz } baz = Reference """) self.localized("""\ foo = Localized { qux } bar = Localized baz = Localized { qux } """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers.toJSON(), { 'details': { 'l10n.ftl': [ { 'warning': u'Missing message reference: bar ' u'at line 1, column 1 for foo' }, { 'warning': u'Obsolete message reference: qux ' u'at line 1, column 19 for foo' }, { 'warning': u'Missing message reference: baz ' u'at line 2, column 1 for bar' }, { 'warning': u'Obsolete message reference: qux ' u'at line 3, column 19 for baz' }, ], }, 'summary': { None: { 'changed': 3, 'changed_w': 3, 'warnings': 4 } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertTrue(filecmp.cmp(self.l10n, mergepath))
def test_term_attributes(self): self.reference(""" -foo = Foo -bar = Bar -baz = Baz .attr = Baz Attribute -qux = Qux .attr = Qux Attribute -missing = Missing .attr = An Attribute """) self.localized("""\ -foo = Localized Foo -bar = Localized Bar .attr = Locale-specific Bar Attribute -baz = Localized Baz -qux = Localized Qux .other = Locale-specific Qux Attribute """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers.toJSON(), { 'details': { 'l10n.ftl': [ { 'missingEntity': u'-missing' }, ], }, 'summary': { None: { 'errors': 0, 'warnings': 0, 'missing': 1, 'missing_w': 1, 'report': 0, 'obsolete': 0, 'changed': 4, 'changed_w': 4, 'unchanged': 0, 'unchanged_w': 0, 'keys': 0, } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertTrue(filecmp.cmp(self.l10n, mergepath))
def testGood(self): self.assertTrue(os.path.isdir(self.tmp)) l10n = os.path.join(self.tmp, "l10n.properties") open(l10n, "w").write("""foo = lFoo bar = lBar eff = lEff """) cc = ContentComparer() cc.set_merge_stage(os.path.join(self.tmp, "merge")) cc.compare(File(self.ref, "en-reference.properties", ""), File(l10n, "l10n.properties", "")) print cc.observer.serialize()
def testGood(self): self.assertTrue(os.path.isdir(self.tmp)) l10n = os.path.join(self.tmp, "l10n.dtd") open(l10n, "w").write("""<!ENTITY foo 'lFoo'> <!ENTITY bar 'lBar'> <!ENTITY eff 'lEff'> """) cc = ContentComparer() cc.set_merge_stage(os.path.join(self.tmp, "merge")) cc.compare(File(self.ref, "en-reference.dtd", ""), File(l10n, "l10n.dtd", "")) print cc.observer.serialize()
def test_duplicate_attributes(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal .attr = good""") self.localized("""foo = localized .attr = not .attr = so .attr = good """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers.toJSON(), { 'summary': { None: { 'errors': 0, 'warnings': 3, 'missing': 0, 'missing_w': 0, 'report': 0, 'obsolete': 0, 'changed': 1, 'changed_w': 2, 'unchanged': 0, 'unchanged_w': 0, 'keys': 0, } }, 'details': { 'l10n.ftl': [ { 'warning': u'Attribute "attr" is duplicated ' u'at line 2, column 5 for foo' }, { 'warning': u'Attribute "attr" is duplicated ' u'at line 3, column 5 for foo' }, { 'warning': u'Attribute "attr" is duplicated ' u'at line 4, column 5 for foo' }, ] } }) mergefile = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertTrue(filecmp.cmp(self.l10n, mergefile))
def testMissing(self): self.reference("""\ foo = fooVal bar = barVal -baz = bazVal eff = effVal """) self.localized("""\ foo = lFoo eff = lEff """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers.toJSON(), { 'details': { 'l10n.ftl': [ { 'missingEntity': u'bar' }, { 'missingEntity': u'-baz' }, ], }, 'summary': { None: { 'errors': 0, 'warnings': 0, 'missing': 2, 'missing_w': 2, 'report': 0, 'obsolete': 0, 'changed': 2, 'changed_w': 2, 'unchanged': 0, 'unchanged_w': 0, 'keys': 0, } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assertTrue(filecmp.cmp(self.l10n, mergepath))
def testJunk(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""<!ENTITY foo 'fooVal'> <!ENTITY bar 'barVal'> <!ENTITY eff 'effVal'>""") self.localized("""<!ENTITY foo 'fooVal'> <!ENTY bar 'gimmick'> <!ENTITY eff 'effVal'> """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.dtd", ""), File(self.l10n, "l10n.dtd", ""), mozpath.join(self.tmp, "merge", "l10n.dtd")) self.assertDictEqual( cc.observers.toJSON(), { 'summary': { None: { 'errors': 1, 'warnings': 0, 'missing': 1, 'missing_w': 1, 'report': 0, 'obsolete': 0, 'changed': 0, 'changed_w': 0, 'unchanged': 2, 'unchanged_w': 2, 'keys': 0, } }, 'details': { 'l10n.dtd': [{ 'error': u'Unparsed content "<!ENTY bar ' u'\'gimmick\'>\n" ' u'from line 2 column 1 to ' u'line 3 column 1' }, { 'missingEntity': u'bar' }] } }) mergefile = mozpath.join(self.tmp, "merge", "l10n.dtd") self.assertTrue(os.path.isfile(mergefile)) p = getParser(mergefile) p.readFile(mergefile) entities = p.parse() self.assertEqual(list(entities.keys()), ["foo", "eff", "bar"])
def testMismatchingValues(self): self.reference(""" foo = Foo .foottr = something bar .tender = Attribute value """) self.localized("""\ foo .foottr = attr bar = lBar .tender = localized """) cc = ContentComparer([Observer()]) cc.compare(File(self.ref, "en-reference.ftl", ""), File(self.l10n, "l10n.ftl", ""), mozpath.join(self.tmp, "merge", "l10n.ftl")) self.assertDictEqual( cc.observers[0].toJSON(), { 'details': { 'l10n.ftl': [ { 'error': u'Missing value at line 1, column 1 for foo' }, { 'error': u'Obsolete value at line 3, column 7 for bar', }, ] }, 'summary': { None: { 'changed': 2, 'changed_w': 4, 'errors': 2 } } }) # validate merge results mergepath = mozpath.join(self.tmp, "merge", "l10n.ftl") self.assert_(os.path.exists(mergepath)) p = getParser(mergepath) p.readFile(mergepath) merged_entities, _ = p.parse() self.assertEqual([e.key for e in merged_entities], [])
def test_good(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = 'fooVal';""") self.localized("""foo = 'lfoo';""") cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.js", ""), File(self.l10n, "l10n.js", ""), mozpath.join(self.tmp, "merge", "l10n.js")) self.assertDictEqual(cc.observers.toJSON(), { 'summary': {}, 'details': {} }) self.assertTrue( filecmp.cmp(self.l10n, mozpath.join(self.tmp, "merge", 'l10n.js')))
def testError(self): self.assertTrue(os.path.isdir(self.tmp)) self.reference("""foo = fooVal bar = %d barVal eff = effVal""") self.localized("""\ bar = %S lBar eff = leffVal """) cc = ContentComparer() cc.observers.append(Observer()) cc.compare(File(self.ref, "en-reference.properties", ""), File(self.l10n, "l10n.properties", ""), mozpath.join(self.tmp, "merge", "l10n.properties")) self.assertDictEqual( cc.observers.toJSON(), { 'summary': { None: { 'errors': 1, 'warnings': 0, 'missing': 1, 'missing_w': 1, 'report': 0, 'obsolete': 0, 'changed': 2, 'changed_w': 3, 'unchanged': 0, 'unchanged_w': 0, 'keys': 0, } }, 'details': { 'l10n.properties': [{ 'missingEntity': u'foo' }, { 'error': u'argument 1 `S` should be `d` ' u'at line 1, column 7 for bar' }] } }) mergefile = mozpath.join(self.tmp, "merge", "l10n.properties") self.assertTrue(os.path.isfile(mergefile)) p = getParser(mergefile) p.readFile(mergefile) entities = p.parse() self.assertEqual(list(entities.keys()), ["eff", "foo", "bar"]) self.assertEqual(entities['bar'].val, '%d barVal')