Python ContentComparer.set_merge_stage示例

示例#1

    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"])

示例#2

文件： test_merge.py 项目： Wafflespeanut/gecko-dev

    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"])

示例#3

    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']
                        }
                    })]
                },
            })

示例#4

文件： test_merge.py 项目： sx5486510/rotor-browser

    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()

示例#5

文件： test_merge.py 项目： sx5486510/rotor-browser

    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()

示例#6

文件： test_merge.py 项目： AtulKumar2/gecko-dev

    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()

示例#7

文件： test_merge.py 项目： AtulKumar2/gecko-dev

    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()

示例#8

文件： test_merge.py 项目： sx5486510/rotor-browser

    def testMissing(self):
        self.assertTrue(os.path.isdir(self.tmp))
        l10n = os.path.join(self.tmp, "l10n.dtd")
        open(l10n, "w").write("""<!ENTITY bar 'lBar'>
""")
        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()
        mergefile = os.path.join(self.tmp, "merge", "l10n.dtd")
        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"])

示例#9

文件： test_merge.py 项目： AtulKumar2/gecko-dev

    def testMissing(self):
        self.assertTrue(os.path.isdir(self.tmp))
        l10n = os.path.join(self.tmp, "l10n.dtd")
        open(l10n, "w").write("""<!ENTITY bar 'lBar'>
""")
        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()
        mergefile = os.path.join(self.tmp, "merge", "l10n.dtd")
        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"])

示例#10

    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.set_merge_stage(os.path.join(self.tmp, "merge"))
        cc.compare(File(self.ref, "en-reference.dtd", ""),
                   File(self.l10n, "l10n.dtd", ""))
        self.assertDictEqual(
            cc.observer.toJSON(), {
                'summary': {
                    None: {
                        'errors': 1,
                        'missing': 1,
                        'unchanged': 2
                    }
                },
                'details': {
                    'children': [('l10n.dtd', {
                        'value': {
                            'error': [
                                u'Unparsed content "<!ENTY bar '
                                u'\'gimmick\'>" '
                                u'from line 2 colum 1 to '
                                u'line 2 column 22'
                            ],
                            'missingEntity': [u'bar']
                        }
                    })]
                }
            })
        mergefile = os.path.join(self.tmp, "merge", "l10n.dtd")
        self.assertTrue(os.path.isfile(mergefile))
        p = getParser(mergefile)
        p.readFile(mergefile)
        [m, n] = p.parse()
        self.assertEqual(map(lambda e: e.key, m), ["foo", "eff", "bar"])

示例#11

    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.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': 2,
                        'errors': 1,
                        'missing': 1
                    }
                },
                'details': {
                    'children': [('l10n.properties', {
                        'value': {
                            'error': [
                                u'argument 1 `S` should be `d` '
                                u'at line 1, column 7 for bar'
                            ],
                            'missingEntity': [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([e.key for e in m], ["eff", "foo", "bar"])
        self.assertEqual(m[n['bar']].val, '%d barVal')

示例#12

文件： test_merge.py 项目： Wafflespeanut/gecko-dev

    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.set_merge_stage(os.path.join(self.tmp, "merge"))
        cc.compare(File(self.ref, "en-reference.dtd", ""),
                   File(self.l10n, "l10n.dtd", ""))
        self.assertDictEqual(
            cc.observer.toJSON(),
            {'summary':
                {None: {
                    'errors': 1, 'missing': 1, 'unchanged': 2
                }},
             'details': {
                 'children': [
                     ('l10n.dtd',
                         {'value': {
                             'error': [u'Unparsed content "<!ENTY bar '
                                       u'\'gimmick\'>" '
                                       u'from line 2 colum 1 to '
                                       u'line 2 column 22'],
                             'missingEntity': [u'bar']}}
                      )
                 ]}
             }
        )
        mergefile = os.path.join(self.tmp, "merge", "l10n.dtd")
        self.assertTrue(os.path.isfile(mergefile))
        p = getParser(mergefile)
        p.readFile(mergefile)
        [m, n] = p.parse()
        self.assertEqual(map(lambda e: e.key,  m), ["foo", "eff", "bar"])

示例#13

    def testGood(self):
        self.assertTrue(os.path.isdir(self.tmp))
        self.reference("""foo = fooVal
bar = barVal
eff = effVal""")
        self.localized("""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(self.l10n, "l10n.properties", ""))
        self.assertDictEqual(cc.observer.toJSON(), {
            'summary': {
                None: {
                    'changed': 3
                }
            },
            'details': {}
        })
        self.assert_(not os.path.exists(
            os.path.join(cc.merge_stage, 'l10n.properties')))

示例#14

    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.set_merge_stage(os.path.join(self.tmp, "merge"))
        cc.compare(File(self.ref, "en-reference.dtd", ""),
                   File(self.l10n, "l10n.dtd", ""))
        self.assertDictEqual(cc.observer.toJSON(), {
            'summary': {
                None: {
                    'changed': 3
                }
            },
            'details': {}
        })
        self.assert_(
            not os.path.exists(os.path.join(cc.merge_stage, 'l10n.dtd')))

示例#15

文件： test_merge.py 项目： Wafflespeanut/gecko-dev

    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.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': 2, 'errors': 1, 'missing': 1
                }},
             'details': {
                 'children': [
                     ('l10n.properties',
                         {'value': {
                          'error': [u'argument 1 `S` should be `d` '
                                    u'at line 1, column 7 for bar'],
                          'missingEntity': [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([e.key for e in m], ["eff", "foo", "bar"])
        self.assertEqual(m[n['bar']].val, '%d barVal')

示例#16

文件： test_merge.py 项目： Wafflespeanut/gecko-dev

    def testGood(self):
        self.assertTrue(os.path.isdir(self.tmp))
        self.reference("""foo = fooVal
bar = barVal
eff = effVal""")
        self.localized("""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(self.l10n, "l10n.properties", ""))
        self.assertDictEqual(
            cc.observer.toJSON(),
            {'summary':
                {None: {
                    'changed': 3
                }},
             'details': {}
             }
        )
        self.assert_(not os.path.exists(os.path.join(cc.merge_stage,
                                                     'l10n.properties')))

示例#17

文件： test_merge.py 项目： Wafflespeanut/gecko-dev

    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.set_merge_stage(os.path.join(self.tmp, "merge"))
        cc.compare(File(self.ref, "en-reference.dtd", ""),
                   File(self.l10n, "l10n.dtd", ""))
        self.assertDictEqual(
            cc.observer.toJSON(),
            {'summary':
                {None: {
                    'changed': 3
                }},
             'details': {}
             }
        )
        self.assert_(
            not os.path.exists(os.path.join(cc.merge_stage, 'l10n.dtd')))

示例#18

文件： test_merge.py 项目： Wafflespeanut/gecko-dev

    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']}})]},
             }
        )