storage/test_base.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 """tests for storage base classes"""
   5
   6 from translate.storage import base
   7 from py import test
   8 import os
   9
  10 def test_force_override():
  11     """Tests that derived classes are not allowed to call certain functions"""
  12     class BaseClass:
  13         def test(self):
  14             base.force_override(self.test, BaseClass)
  15             return True
  16         def classtest(cls):
  17             base.force_override(cls.classtest, BaseClass)
  18             return True
  19         classtest = classmethod(classtest)
  20     class DerivedClass(BaseClass):
  21         pass
  22     baseobject = BaseClass()
  23     assert baseobject.test()
  24     assert baseobject.classtest()
  25     derivedobject = DerivedClass()
  26     assert test.raises(NotImplementedError, derivedobject.test)
  27     assert test.raises(NotImplementedError, derivedobject.classtest)
  28
  29 class TestTranslationUnit:
  30     """Tests a TranslationUnit.
  31     Derived classes can reuse these tests by pointing UnitClass to a derived Unit"""
  32     UnitClass = base.TranslationUnit
  33
  34     def setup_method(self, method):
  35         self.unit = self.UnitClass("Test String")
  36
  37     def test_isfuzzy(self):
  38         """Test that we can call isfuzzy() on a unit.
  39
  40         The default return value for isfuzzy() should be False.
  41         """
  42         assert not self.unit.isfuzzy()
  43
  44     def test_create(self):
  45         """tests a simple creation with a source string"""
  46         unit = self.unit
  47         print 'unit.source:', unit.source
  48         assert unit.source == "Test String"
  49
  50     def test_eq(self):
  51         """tests equality comparison"""
  52         unit1 = self.unit
  53         unit2 = self.UnitClass("Test String")
  54         unit3 = self.UnitClass("Test String")
  55         unit4 = self.UnitClass("Blessed String")
  56         unit5 = self.UnitClass("Blessed String")
  57         unit6 = self.UnitClass("Blessed String")
  58         assert unit1 == unit1
  59         assert unit1 == unit2
  60         assert unit1 != unit4
  61         unit1.target = "Stressed Ting"
  62         unit2.target = "Stressed Ting"
  63         unit5.target = "Stressed Bling"
  64         unit6.target = "Stressed Ting"
  65         assert unit1 == unit2
  66         assert unit1 != unit3
  67         assert unit4 != unit5
  68         assert unit1 != unit6
  69
  70     def test_target(self):
  71         unit = self.unit
  72         assert not unit.target
  73         unit.target = "Stressed Ting"
  74         assert unit.target == "Stressed Ting"
  75         unit.target = "Stressed Bling"
  76         assert unit.target == "Stressed Bling"
  77         unit.target = ""
  78         assert unit.target == ""
  79
  80     def test_escapes(self):
  81         """Test all sorts of characters that might go wrong in a quoting and
  82         escaping roundtrip."""
  83         unit = self.unit
  84         specials = ['Fish & chips', 'five < six', 'six > five', 'five &lt; six',
  85                     'Use &nbsp;', 'Use &amp;nbsp;', 'Use &amp;amp;nbsp;',
  86                     'A "solution"', "skop 'n bal", '"""', "'''", u'µ',
  87                     '\n', '\t', '\r', '\r\n', '\\r', '\\', '\\\r']
  88         for special in specials:
  89             unit.source = special
  90             print "unit.source:", repr(unit.source)
  91             print "special:", repr(special)
  92             assert unit.source == special
  93
  94     def test_difficult_escapes(self):
  95         """Test difficult characters that might go wrong in a quoting and
  96         escaping roundtrip."""
  97
  98         unit = self.unit
  99         specials = ['\\n', '\\t', '\\"', '\\ ',
 100                     '\\\n', '\\\t', '\\\\n', '\\\\t', '\\\\r', '\\\\"',
 101                     '\\r\\n', '\\\\r\\n', '\\r\\\\n', '\\\\n\\\\r']
 102         for special in specials:
 103             unit.source = special
 104             print "unit.source:", repr(unit.source) + '|'
 105             print "special:", repr(special) + '|'
 106             assert unit.source == special
 107
 108     def test_note_sanity(self):
 109         """Tests that all subclasses of the base behaves consistently with regards to notes."""
 110         unit = self.unit
 111
 112         unit.addnote("Test note 1", origin="translator")
 113         unit.addnote("Test note 2", origin="translator")
 114         unit.addnote("Test note 3", origin="translator")
 115         expected_notes = u"Test note 1\nTest note 2\nTest note 3"
 116         actual_notes = unit.getnotes(origin="translator")
 117         assert actual_notes == expected_notes
 118
 119         # Test with no origin.
 120         unit.removenotes()
 121         assert not unit.getnotes()
 122         unit.addnote("Test note 1")
 123         unit.addnote("Test note 2")
 124         unit.addnote("Test note 3")
 125         expected_notes = u"Test note 1\nTest note 2\nTest note 3"
 126         actual_notes = unit.getnotes()
 127         assert actual_notes == expected_notes
 128
 129 class TestTranslationStore:
 130     """Tests a TranslationStore.
 131     Derived classes can reuse these tests by pointing StoreClass to a derived Store"""
 132     StoreClass = base.TranslationStore
 133
 134     def setup_method(self, method):
 135         """Allocates a unique self.filename for the method, making sure it doesn't exist"""
 136         self.filename = "%s_%s.test" % (self.__class__.__name__, method.__name__)
 137         if os.path.exists(self.filename):
 138             os.remove(self.filename)
 139
 140     def teardown_method(self, method):
 141         """Makes sure that if self.filename was created by the method, it is cleaned up"""
 142         if os.path.exists(self.filename):
 143             os.remove(self.filename)
 144
 145     def test_create_blank(self):
 146         """Tests creating a new blank store"""
 147         store = self.StoreClass()
 148         assert len(store.units) == 0
 149
 150     def test_add(self):
 151         """Tests adding a new unit with a source string"""
 152         store = self.StoreClass()
 153         unit = store.addsourceunit("Test String")
 154         print str(unit)
 155         print str(store)
 156         assert len(store.units) == 1
 157         assert unit.source == "Test String"
 158
 159     def test_find(self):
 160         """Tests searching for a given source string"""
 161         store = self.StoreClass()
 162         unit1 = store.addsourceunit("Test String")
 163         unit2 = store.addsourceunit("Blessed String")
 164         assert store.findunit("Test String") == unit1
 165         assert store.findunit("Blessed String") == unit2
 166         assert store.findunit("Nest String") is None
 167
 168     def test_translate(self):
 169         """Tests the translate method and non-ascii characters."""
 170         store = self.StoreClass()
 171         unit = store.addsourceunit("scissor")
 172         unit.target = u"skêr"
 173         unit = store.addsourceunit(u"Beziér curve")
 174         unit.target = u"Beziér-kurwe"
 175         assert store.translate("scissor") == u"skêr"
 176         assert store.translate(u"Beziér curve") == u"Beziér-kurwe"
 177
 178     def reparse(self, store):
 179         """converts the store to a string and back to a store again"""
 180         storestring = str(store)
 181         newstore = self.StoreClass.parsestring(storestring)
 182         return newstore
 183
 184     def check_equality(self, store1, store2):
 185         """asserts that store1 and store2 are the same"""
 186         assert len(store1.units) == len(store2.units)
 187         for n, store1unit in enumerate(store1.units):
 188             store2unit = store2.units[n]
 189             match = store1unit == store2unit
 190             if not match:
 191                 print "match failed between elements %d of %d" % (n+1, len(store1.units))
 192                 print "store1:"
 193                 print str(store1)
 194                 print "store2:"
 195                 print str(store2)
 196                 print "store1.units[%d].__dict__:" % n, store1unit.__dict__
 197                 print "store2.units[%d].__dict__:" % n, store2unit.__dict__
 198                 assert store1unit == store2unit
 199
 200     def test_parse(self):
 201         """Tests converting to a string and parsing the resulting string"""
 202         store = self.StoreClass()
 203         unit1 = store.addsourceunit("Test String")
 204         unit1.target = "Test String"
 205         unit2 = store.addsourceunit("Test String 2")
 206         unit2.target = "Test String 2"
 207         newstore = self.reparse(store)
 208         self.check_equality(store, newstore)
 209
 210     def test_files(self):
 211         """Tests saving to and loading from files"""
 212         store = self.StoreClass()
 213         unit1 = store.addsourceunit("Test String")
 214         unit1.target = "Test String"
 215         unit2 = store.addsourceunit("Test String 2")
 216         unit2.target = "Test String 2"
 217         store.savefile(self.filename)
 218         newstore = self.StoreClass.parsefile(self.filename)
 219         self.check_equality(store, newstore)
 220
 221     def test_save(self):
 222         """Tests that we can save directly back to the original file."""
 223         store = self.StoreClass()
 224         unit1 = store.addsourceunit("Test String")
 225         unit1.target = "Test String"
 226         unit2 = store.addsourceunit("Test String 2")
 227         unit2.target = "Test String 2"
 228         store.savefile(self.filename)
 229         store.save()
 230         newstore = self.StoreClass.parsefile(self.filename)
 231         self.check_equality(store, newstore)
 232
 233     def test_markup(self):
 234         """Tests that markup survives the roundtrip. Most usefull for xml types."""
 235         store = self.StoreClass()
 236         unit = store.addsourceunit("<vark@hok.org> %d keer %2$s")
 237         assert unit.source == "<vark@hok.org> %d keer %2$s"
 238         unit.target = "bla"
 239         assert store.translate("<vark@hok.org> %d keer %2$s") == "bla"
 240
 241     def test_nonascii(self):
 242         store = self.StoreClass()
 243         unit = store.addsourceunit(u"Beziér curve")
 244         string = u"Beziér-kurwe"
 245         unit.target = string.encode("utf-8")
 246         answer = store.translate(u"Beziér curve")
 247         if isinstance(answer, str):
 248             answer = answer.decode("utf-8")
 249         assert answer == u"Beziér-kurwe"
 250         #Just test that __str__ doesn't raise exception:
 251         src = str(store)