Made tests a bit cleaner.

Author: Cito

Docs/ReleaseProcedures.phtml

@@ -62,8 +62,8 @@ Test the current version before releasing it:
     number in mod_webkit.c to the Webware version.
 
 [ ] Run the above tests on all supported Python versions (currently these are
-    versions 2.4-2.7 and PyPy 1.5) and on different platforms (e.g. various
-    flavors of Linux, MacOS, Windows).
+    Python versions 2.4 to 2.7 and also PyPy) and on different platforms (e.g.
+    various flavors of Linux, MacOS, Windows).
 </pre>
 
 

MiscUtils/MixIn.py

@@ -47,8 +47,8 @@ def foo(self):
             # now do whatever you want
 
     """
-    assert mixInClass is not pyClass, \
-        'mixInClass = %r, pyClass = %r' % (mixInClass, pyClass)
+    assert mixInClass is not pyClass, (
+        'mixInClass = %r, pyClass = %r' % (mixInClass, pyClass))
     if makeAncestor:
         if mixInClass not in pyClass.__bases__:
             pyClass.__bases__ = (mixInClass,) + pyClass.__bases__

MiscUtils/Tests/TestCSVParser.py

@@ -85,21 +85,24 @@ def testPositives(self):
             if '\n' not in input:
                 # single line
                 result = self.parse(input)
-                assert result == output, ('\ninput=%r\nresult=%r\noutput=%r'
+                self.assertEqual(result, output,
+                    '\ninput=%r\nresult=%r\noutput=%r'
                     % (input, result, output))
                 result = self.parse(input+'\n')
-                assert result == output, ('\ninput=%r\nresult=%r\noutput=%r'
+                self.assertEqual(result, output,
+                    '\ninput=%r\nresult=%r\noutput=%r'
                     % (input, result, output))
             else:
                 # multiple lines
                 gotFields = False
                 for line in input.splitlines():
-                    assert not gotFields
+                    self.assertFalse(gotFields)
                     result = self.parse(line)
                     if result is not None:
                         gotFields = True
-                assert gotFields
-                assert result == output, ('\ninput=%r\nresult=%r\noutput=%r'
+                self.assertTrue(gotFields)
+                self.assertEqual(result, output,
+                    '\ninput=%r\nresult=%r\noutput=%r'
                     % (input, result, output))
 
 

MiscUtils/Tests/TestDataTable.py

@@ -11,35 +11,35 @@ class TestTableColumn(unittest.TestCase):
 
     def testWithType(self):
         tc = TableColumn('foo:int')
-        assert tc.name() == 'foo'
-        assert tc.type() is int
+        self.assertEqual(tc.name(), 'foo')
+        self.assertTrue(tc.type() is int)
 
     def testWithoutType(self):
         tc = TableColumn('bar')
-        assert tc.name() == 'bar'
-        assert tc.type() is None
+        self.assertEqual(tc.name(), 'bar')
+        self.assertTrue(tc.type() is None)
 
     def testWrongSpec(self):
         self.assertRaises(DataTableError, TableColumn, 'foo:bar')
         self.assertRaises(DataTableError, TableColumn, 'foo:bar:baz')
 
     def testValueForRawValue(self):
         tc = TableColumn('foo:int')
-        assert tc.valueForRawValue('') == 0
-        assert tc.valueForRawValue('1') == 1
-        assert tc.valueForRawValue(2) == 2
-        assert tc.valueForRawValue(2.5) == 2
+        self.assertEqual(tc.valueForRawValue(''), 0)
+        self.assertEqual(tc.valueForRawValue('1'), 1)
+        self.assertEqual(tc.valueForRawValue(2), 2)
+        self.assertEqual(tc.valueForRawValue(2.5), 2)
         tc = TableColumn('bar:str')
-        assert tc.valueForRawValue('') == ''
-        assert tc.valueForRawValue('1') == '1'
-        assert tc.valueForRawValue(2) == '2'
-        assert tc.valueForRawValue('x') == 'x'
+        self.assertEqual(tc.valueForRawValue(''), '')
+        self.assertEqual(tc.valueForRawValue('1'), '1')
+        self.assertEqual( tc.valueForRawValue(2), '2')
+        self.assertEqual( tc.valueForRawValue('x'), 'x')
         tc = TableColumn('bar:float')
-        assert tc.valueForRawValue('') == 0.0
-        assert tc.valueForRawValue('1') == 1.0
-        assert tc.valueForRawValue('1.5') == 1.5
-        assert tc.valueForRawValue(2.5) == 2.5
-        assert tc.valueForRawValue(3) == 3.0
+        self.assertEqual(tc.valueForRawValue(''), 0.0)
+        self.assertEqual(tc.valueForRawValue('1'), 1.0)
+        self.assertEqual(tc.valueForRawValue('1.5'), 1.5)
+        self.assertEqual(tc.valueForRawValue(2.5), 2.5)
+        self.assertEqual(tc.valueForRawValue(3), 3.0)
 
 
 class Record(object):
@@ -61,7 +61,7 @@ def _testSource(self, name, src, headings, data):
         dt = DataTable()
         lines = src.splitlines()
         dt.readLines(lines)
-        assert [col.name() for col in dt.headings()] == headings
+        self.assertEqual([col.name() for col in dt.headings()], headings)
         for i, values in enumerate(dt):
             match = data[i]
             self.assertEqual(values.asList(), match,
@@ -101,14 +101,15 @@ def _testBasic(self):
         t.append(b)
         t.append(c)
         t.append(d)
-        assert t[-4]['name'] == 'John'
-        assert t[-3]['name'] == 'Mary'
-        assert t[-2]['name'] == 'Fred'
-        assert t[-1]['name'] == 'Wilma'
-        assert t[-4].asDict() == {'name': 'John', 'age': 26, 'rating': 7.25}
-        assert t[-3].asList() == b
-        assert t[-2].asDict() == c
-        assert t[-1].asList() == ['Wilma', 27, 9.5]
+        self.assertEqual(t[-4]['name'], 'John')
+        self.assertEqual(t[-3]['name'], 'Mary')
+        self.assertEqual(t[-2]['name'], 'Fred')
+        self.assertEqual(t[-1]['name'], 'Wilma')
+        self.assertEqual(t[-4].asDict(),
+            {'name': 'John', 'age': 26, 'rating': 7.25})
+        self.assertEqual(t[-3].asList(), b)
+        self.assertEqual(t[-2].asDict(), c)
+        self.assertEqual(t[-1].asList(), ['Wilma', 27, 9.5])
 
         # Printing
         # print t
@@ -124,13 +125,13 @@ def _testBasic(self):
         out = StringIO()
         t.writeFile(out)
         results = out.getvalue()
-        assert results == answer, '\n%r\n%r\n' % (results, answer)
+        self.assertEqual(results, answer, '\n%r\n%r\n' % (results, answer))
 
         # Accessing rows
         for row in t:
-            assert row['name'] == row[0]
-            assert row['age'] == row[1]
-            assert row['rating'] == row[2]
+            self.assertEqual(row['name'], row[0])
+            self.assertEqual(row['age'], row[1])
+            self.assertEqual(row['rating'], row[2])
             for item in row:
                 pass
 
@@ -139,7 +140,7 @@ def _testBasic(self):
         t.setHeadings(list('xyz'))
         t.append([1, 2, 3])
         t.append([4, 5, 6])
-        assert t[0]['x'] - t[1]['z'] == -5
+        self.assertEqual(t[0]['x'] - t[1]['z'], -5)
 
     def testBasics(self):
         # Basics
@@ -232,7 +233,7 @@ def _testExcel(self):
             # print 'Testing Excel...'
             xlsfile = os.path.join(os.path.dirname(__file__), 'Sample3.xls')
             t = DataTable(xlsfile)
-            assert t[0][0] == 1.0, t[0]
+            self.assertEqual(t[0][0], 1.0, t[0])
 
 
 if __name__ == '__main__':

MiscUtils/Tests/TestDateInterval.py

@@ -8,26 +8,26 @@
 class TestDateInterval(unittest.TestCase):
 
     def testTimeEncode(self):
-        assert timeEncode(1) == '1s'
-        assert timeEncode(60) == '1m'
-        assert timeEncode(176403) == '2d1h3s'
-        assert timeEncode(349380) == '4d1h3m'
-        assert timeEncode(38898367) == '1y2b3w4d5h6m7s'
+        self.assertEqual(timeEncode(1), '1s')
+        self.assertEqual(timeEncode(60), '1m')
+        self.assertEqual(timeEncode(176403), '2d1h3s')
+        self.assertEqual(timeEncode(349380), '4d1h3m')
+        self.assertEqual(timeEncode(38898367), '1y2b3w4d5h6m7s')
 
     def testTimeDecode(self):
-        assert timeDecode('1s') == 1
-        assert timeDecode('1h2d3s') == 176403
-        assert timeDecode('2d1h3s') == 176403
-        assert timeDecode('1h4d3m') == 349380
-        assert timeDecode('3m4d1h') == 349380
-        assert timeDecode('1y2b3w4d5h6m7s') == 38898367
-        assert timeDecode('0y1b2w3d4h5m6s') == 4075506
-        assert timeDecode('6s5m4h3d2w1b0y') == 4075506
-        assert timeDecode('(3s-2d-1h)') == 176403
+        self.assertEqual(timeDecode('1s'), 1)
+        self.assertEqual(timeDecode('1h2d3s'), 176403)
+        self.assertEqual(timeDecode('2d1h3s'), 176403)
+        self.assertEqual(timeDecode('1h4d3m'), 349380)
+        self.assertEqual(timeDecode('3m4d1h'), 349380)
+        self.assertEqual(timeDecode('1y2b3w4d5h6m7s'), 38898367)
+        self.assertEqual(timeDecode('0y1b2w3d4h5m6s'), 4075506)
+        self.assertEqual(timeDecode('6s5m4h3d2w1b0y'), 4075506)
+        self.assertEqual(timeDecode('(3s-2d-1h)'), 176403)
         try:
             timeDecode('1h5n')
         except ValueError, e:
-            assert str(e) == 'Invalid unit of time: n'
+            self.assertEqual(str(e), 'Invalid unit of time: n')
 
 
 if __name__ == '__main__':

MiscUtils/Tests/TestDateParser.py

@@ -19,11 +19,11 @@ class TestDateTimeParser(unittest.TestCase):
 
     def testReturnType(self):
         from datetime import datetime
-        assert type(parseDateTime(
-            'Mon Jul 21 02:56:20 1969')) is datetime
+        self.assertTrue(type(parseDateTime(
+            'Mon Jul 21 02:56:20 1969')) is datetime)
 
     def assertParses(self, s):
-        assert parseDateTime(s).isoformat() == '1969-07-21T02:56:20'
+        self.assertEqual(parseDateTime(s).isoformat(), '1969-07-21T02:56:20')
 
     def testDefaultFormat(self):
         self.assertParses('Mon Jul 21 02:56:20 1969')
@@ -63,11 +63,11 @@ class TestDateParser(unittest.TestCase):
 
     def testReturnType(self):
         from datetime import date
-        assert type(parseDate(
-            'Mon Jul 21 02:56:20 1969')) is date
+        self.assertTrue(type(parseDate(
+            'Mon Jul 21 02:56:20 1969')) is date)
 
     def assertParses(self, s):
-        assert parseDate(s).isoformat() == '1969-07-21'
+        self.assertEqual(parseDate(s).isoformat(), '1969-07-21')
 
     def testDefaultFormat(self):
         self.assertParses('Mon Jul 21 02:56:20 1969')
@@ -94,11 +94,11 @@ class TestTimeParser(unittest.TestCase):
 
     def testReturnType(self):
         from datetime import time
-        assert type(parseTime(
-            'Mon Jul 21 02:56:20 1969')) is time
+        self.assertTrue(type(parseTime(
+            'Mon Jul 21 02:56:20 1969')) is time)
 
     def assertParses(self, s):
-        assert parseTime(s).isoformat() == '02:56:20'
+        self.assertEqual(parseTime(s).isoformat(), '02:56:20')
 
     def testDefaultFormat(self):
         self.assertParses('Mon Jul 21 02:56:20 1969')

MiscUtils/Tests/TestDictForArgs.py

@@ -97,17 +97,17 @@ def testPyDictForArgs(self):
             if case:
                 source, answer = case.split('==', 1)
                 answer = eval(answer)
-                assert PyDictForArgs(source) == answer
+                self.assertEqual(PyDictForArgs(source), answer)
 
     def testExpandDictWithExtras(self):
         d = {'Name': 'foo', 'Extras': 'x=1 y=2'}
         result = ExpandDictWithExtras(d)
-        assert result == {'Name': 'foo', 'x': '1', 'y': '2'}
+        self.assertEqual(result, {'Name': 'foo', 'x': '1', 'y': '2'})
         d = {'Name': 'foo', 'bar': 'z = 3'}
         result = ExpandDictWithExtras(d)
-        assert result == d
+        self.assertEqual(result, d)
         result = ExpandDictWithExtras(d, key='bar', delKey=False)
-        assert result == {'Name': 'foo', 'bar': 'z = 3', 'z': '3'}
+        self.assertEqual(result, {'Name': 'foo', 'bar': 'z = 3', 'z': '3'})
 
 
 if __name__ == '__main__':

MiscUtils/Tests/TestError.py

@@ -55,18 +55,18 @@ def testValueDict(self):
         self.assertEqual('ERROR: ', str(err))
         self.assertEqual("ERROR(object=None; message=''; data={'a': 5, 'b': '.'})",
             repr(err).replace("{'b': '.', 'a': 5}", "{'a': 5, 'b': '.'}"))
-        assert err.keys() in [['a', 'b'], ['b', 'a']]
-        assert isinstance(err['a'], int)
-        assert isinstance(err['b'], str)
+        self.assertTrue(err.keys() in [['a', 'b'], ['b', 'a']])
+        self.assertTrue(isinstance(err['a'], int))
+        self.assertTrue(isinstance(err['b'], str))
 
     def testVarArgs(self):
         err = Error(None, '', {'a': 5}, b='.')
         self.assertEqual('ERROR: ', str(err))
         self.assertEqual("ERROR(object=None; message=''; data={'a': 5, 'b': '.'})",
             repr(err).replace("{'b': '.', 'a': 5}", "{'a': 5, 'b': '.'}"))
-        assert err.keys() in [['a', 'b'], ['b', 'a']]
-        assert isinstance(err['a'], int)
-        assert isinstance(err['b'], str)
+        self.assertTrue(err.keys() in [['a', 'b'], ['b', 'a']])
+        self.assertTrue(isinstance(err['a'], int))
+        self.assertTrue(isinstance(err['b'], str))
 
 
 if __name__ == '__main__':

MiscUtils/Tests/TestFuncs.py

@@ -85,7 +85,8 @@ def testHostName(self):
 
     def testLocalIP(self):
         ip = localIP()
-        self.assertTrue(ip and not ip.startswith('127.'))
+        self.assertTrue(ip)
+        self.assertFalse(ip.startswith('127.'))
         self.assertEqual(localIP(), ip) # second invocation
         self.assertEqual(localIP(useCache=None), ip)
         self.assertEqual(localIP(remote=None, useCache=None), ip,
@@ -173,7 +174,7 @@ def checkId(i, sha, past):
             self.assertEqual(len(i), sha and 40 or 32)
             for c in i:
                 self.assertTrue(c in '0123456789abcdef')
-            self.assertTrue(i not in past)
+            self.assertFalse(i in past)
             past[i] = i
 
         for sha in (False, True):

MiscUtils/Tests/TestNamedValueAccess.py

@@ -101,12 +101,12 @@ def checkBasicAccess(self):
         for obj in self.objs:
 
             value = func(obj, 'foo')
-            assert value == 1, 'value = %r, obj = %r' % (value, obj)
+            self.assertEqual(value, 1, 'value = %r, obj = %r' % (value, obj))
 
             self.assertRaises(NamedValueAccessError, func, obj, 'bar')
 
             value = func(obj, 'bar', 2)
-            assert value == 2, 'value = %r, obj = %r' % (value, obj)
+            self.assertEqual(value, 2, 'value = %r, obj = %r' % (value, obj))
 
     def checkBasicAccessRepeated(self):
         """Just repeat checkBasicAccess multiple times to check stability."""
@@ -137,22 +137,22 @@ def checkNamedValueAccess(self):
         # test the links
         for i in range(len(objs)):
             name = 'nextObject.' * i + 'foo'
-            assert self.lookup(objs[0], name) == 1
+            self.assertEqual(self.lookup(objs[0], name), 1)
 
     def checkDicts(self):
         d = {'origin': {'x': 1, 'y': 2},
             'size': {'width': 3, 'height': 4}}
         obj = self.objs[0]
         obj.rect = d
 
-        assert self.lookup(d, 'origin.x') == 1
-        assert self.lookup(obj, 'rect.origin.x')
+        self.assertEqual(self.lookup(d, 'origin.x'), 1)
+        self.assertTrue(self.lookup(obj, 'rect.origin.x'))
 
         self.assertRaises(NamedValueAccessError, self.lookup, d, 'bar')
         self.assertRaises(NamedValueAccessError, self.lookup, obj,  'bar')
 
-        assert self.lookup(d, 'bar', 2) == 2
-        assert self.lookup(obj, 'rect.bar', 2) == 2
+        self.assertEqual(self.lookup(d, 'bar', 2), 2)
+        self.assertEqual(self.lookup(obj, 'rect.bar', 2), 2)
 
 
 def makeTestSuite():