storage/test_xliff.py

   1 #!/usr/bin/env python
   2
   3 from translate.storage import xliff
   4 from translate.storage import test_base
   5
   6 class TestXLIFFUnit(test_base.TestTranslationUnit):
   7     UnitClass = xliff.xliffunit
   8
   9     def test_isfuzzy(self):
  10         """The default behaviour for XLIFF is different, so we adapt the test
  11         from test_base.py"""
  12         assert self.unit.isfuzzy()
  13
  14     def test_markreview(self):
  15         """Tests if we can mark the unit to need review."""
  16         unit = self.unit
  17         # We have to explicitly set the target to nothing, otherwise xliff
  18         # tests will fail.
  19         # Can we make it default behavior for the UnitClass?
  20         unit.target = ""
  21
  22         unit.addnote("Test note 1", origin="translator")
  23         unit.addnote("Test note 2", origin="translator")
  24         original_notes = unit.getnotes(origin="translator")
  25
  26         assert not unit.isreview()
  27         unit.markreviewneeded()
  28         assert unit.isreview()
  29         unit.markreviewneeded(False)
  30         assert not unit.isreview()
  31         assert unit.getnotes(origin="translator") == original_notes
  32         unit.markreviewneeded(explanation="Double check spelling.")
  33         assert unit.isreview()
  34         notes = unit.getnotes(origin="translator")
  35         assert notes.count("Double check spelling.") == 1
  36
  37     def test_errors(self):
  38         """Tests that we can add and retrieve error messages for a unit."""
  39         unit = self.unit
  40
  41         assert len(unit.geterrors()) == 0
  42         unit.adderror(errorname='test1', errortext='Test error message 1.')
  43         unit.adderror(errorname='test2', errortext='Test error message 2.')
  44         unit.adderror(errorname='test3', errortext='Test error message 3.')
  45         assert len(unit.geterrors()) == 3
  46         assert unit.geterrors()['test1'] == 'Test error message 1.'
  47         assert unit.geterrors()['test2'] == 'Test error message 2.'
  48         assert unit.geterrors()['test3'] == 'Test error message 3.'
  49         unit.adderror(errorname='test1', errortext='New error 1.')
  50         assert unit.geterrors()['test1'] == 'New error 1.'
  51
  52 class TestXLIFFfile(test_base.TestTranslationStore):
  53     StoreClass = xliff.xlifffile
  54     skeleton = '''<?xml version="1.0" encoding="utf-8"?>
  55 <xliff version="1.1" xmlns="urn:oasis:names:tc:xliff:document:1.1">
  56         <file original="doc.txt" source-language="en-US">
  57                 <body>
  58                         %s
  59                 </body>
  60         </file>
  61 </xliff>'''
  62
  63     def test_basic(self):
  64         xlifffile = xliff.xlifffile()
  65         assert xlifffile.units == []
  66         xlifffile.addsourceunit("Bla")
  67         assert len(xlifffile.units) == 1
  68         newfile = xliff.xlifffile.parsestring(str(xlifffile))
  69         print str(xlifffile)
  70         assert len(newfile.units) == 1
  71         assert newfile.units[0].source == "Bla"
  72         assert newfile.findunit("Bla").source == "Bla"
  73         assert newfile.findunit("dit") is None
  74
  75     def test_source(self):
  76         xlifffile = xliff.xlifffile()
  77         xliffunit = xlifffile.addsourceunit("Concept")
  78         xliffunit.source = "Term"
  79         newfile = xliff.xlifffile.parsestring(str(xlifffile))
  80         print str(xlifffile)
  81         assert newfile.findunit("Concept") is None
  82         assert newfile.findunit("Term") is not None
  83
  84     def test_target(self):
  85         xlifffile = xliff.xlifffile()
  86         xliffunit = xlifffile.addsourceunit("Concept")
  87         xliffunit.target = "Konsep"
  88         newfile = xliff.xlifffile.parsestring(str(xlifffile))
  89         print str(xlifffile)
  90         assert newfile.findunit("Concept").target == "Konsep"
  91
  92     def test_sourcelanguage(self):
  93         xlifffile = xliff.xlifffile(sourcelanguage="xh")
  94         xmltext = str(xlifffile)
  95         print xmltext
  96         assert xmltext.find('source-language="xh"')> 0
  97         #TODO: test that it also works for new files.
  98
  99     def test_targetlanguage(self):
 100         xlifffile = xliff.xlifffile(sourcelanguage="zu", targetlanguage="af")
 101         xmltext = str(xlifffile)
 102         print xmltext
 103         assert xmltext.find('source-language="zu"')> 0
 104         assert xmltext.find('target-language="af"')> 0
 105
 106     def test_notes(self):
 107         xlifffile = xliff.xlifffile()
 108         unit = xlifffile.addsourceunit("Concept")
 109         unit.addnote("Please buy bread")
 110         assert unit.getnotes() == "Please buy bread"
 111         notenodes = unit.xmlelement.findall(".//%s" % unit.namespaced("note"))
 112         assert len(notenodes) == 1
 113
 114         unit.addnote("Please buy milk", origin="Mom")
 115         notenodes = unit.xmlelement.findall(".//%s" % unit.namespaced("note"))
 116         assert len(notenodes) == 2
 117         assert not "from" in notenodes[0].attrib
 118         assert notenodes[1].get("from") == "Mom"
 119         assert unit.getnotes(origin="Mom") == "Please buy milk"
 120
 121         unit.addnote("Don't forget the beer", origin="Dad")
 122         notenodes = unit.xmlelement.findall(".//%s" % unit.namespaced("note"))
 123         assert len(notenodes) == 3
 124         assert notenodes[1].get("from") == "Mom"
 125         assert notenodes[2].get("from") == "Dad"
 126         assert unit.getnotes(origin="Dad") == "Don't forget the beer"
 127
 128         assert not unit.getnotes(origin="Bob") == "Please buy bread\nPlease buy milk\nDon't forget the beer"
 129         assert not notenodes[2].get("from") == "Mom"
 130         assert not "from" in notenodes[0].attrib
 131         assert unit.getnotes() == "Please buy bread\nPlease buy milk\nDon't forget the beer"
 132         assert unit.correctorigin(notenodes[2], "ad") == True
 133         assert unit.correctorigin(notenodes[2], "om") == False
 134
 135     def test_alttrans(self):
 136         """Test xliff <alt-trans> accessors"""
 137         xlifffile = xliff.xlifffile()
 138         unit = xlifffile.addsourceunit("Testing")
 139
 140         unit.addalttrans("ginmi")
 141         unit.addalttrans("shikenki")
 142         alternatives = unit.getalttrans()
 143         assert alternatives[0].source == "Testing"
 144         assert alternatives[0].target == "ginmi"
 145         assert alternatives[1].target == "shikenki"
 146
 147         unit.addalttrans("Tasting", origin="bob", lang="eng")
 148         alternatives = unit.getalttrans()
 149         assert alternatives[2].target == "Tasting"
 150
 151         alternatives = unit.getalttrans(origin="bob")
 152         assert alternatives[0].target == "Tasting"
 153
 154         unit.delalttrans(alternatives[0])
 155         assert len(unit.getalttrans(origin="bob")) == 0
 156         alternatives = unit.getalttrans()
 157         assert len(alternatives) == 2
 158         assert alternatives[0].target == "ginmi"
 159         assert alternatives[1].target == "shikenki"
 160
 161     def test_fuzzy(self):
 162         xlifffile = xliff.xlifffile()
 163         unit = xlifffile.addsourceunit("Concept")
 164         unit.markfuzzy()
 165         assert unit.isfuzzy()
 166         unit.target = "Konsep"
 167         assert unit.isfuzzy()
 168         unit.markfuzzy()
 169         assert unit.isfuzzy()
 170         unit.markfuzzy(False)
 171         assert not unit.isfuzzy()
 172         unit.markfuzzy(True)
 173         assert unit.isfuzzy()
 174
 175         #If there is no target, we can't really indicate fuzzyness, so we set
 176         #approved to "no". If we want isfuzzy() to reflect that, the line can
 177         #be uncommented
 178         unit.target = None
 179         assert unit.target is None
 180         print unit
 181         unit.markfuzzy(True)
 182         assert 'approved="no"' in str(unit)
 183         #assert unit.isfuzzy()
 184
 185     def test_parsing(self):
 186         xlfsource = self.skeleton \
 187           % '''<trans-unit id="1" xml:space="preserve">
 188                    <source>File</source>
 189                    <target/>
 190                </trans-unit>'''
 191         xlifffile = xliff.xlifffile.parsestring(xlfsource)
 192         assert xlifffile.units[0].istranslatable()
 193
 194         xlfsource = self.skeleton \
 195           % '''<trans-unit id="1" xml:space="preserve" translate="no">
 196                    <source>File</source>
 197                    <target/>
 198                </trans-unit>'''
 199         xlifffile = xliff.xlifffile.parsestring(xlfsource)
 200         assert not xlifffile.units[0].istranslatable()
 201
 202         xlfsource = self.skeleton \
 203           % '''<trans-unit id="1" xml:space="preserve" translate="yes">
 204                    <source>File</source>
 205                    <target/>
 206                </trans-unit>'''
 207         xlifffile = xliff.xlifffile.parsestring(xlfsource)
 208         assert xlifffile.units[0].istranslatable()
 209
 210