tidy test/base, test/ex, test/ext

3 files changed, 201 insertions, 181 deletions

diff --git a/test/base/test_dependency.py b/test/base/test_dependency.py
index c24c3e5e8..aa4410576 100644
--- a/test/base/test_dependency.py
+++ b/test/base/test_dependency.py
@@ -3,20 +3,18 @@ from sqlalchemy.test import TestBase
 from sqlalchemy.test.testing import assert_raises, eq_
 from sqlalchemy import exc, util
 
+
 class DependencySortTest(TestBase):
+
     def assert_sort(self, tuples, allitems=None):
-        
         if allitems is None:
             allitems = self._nodes_from_tuples(tuples)
         else:
             allitems = self._nodes_from_tuples(tuples).union(allitems)
-            
         result = list(topological.sort(tuples, allitems))
-        
         deps = util.defaultdict(set)
         for parent, child in tuples:
             deps[parent].add(child)
-        
         assert len(result)
         for i, node in enumerate(result):
             for n in result[i:]:
@@ -27,7 +25,7 @@ class DependencySortTest(TestBase):
         for tup in tups:
             s.update(tup)
         return s
-        
+
     def test_sort_one(self):
         rootnode = 'root'
         node2 = 'node2'
@@ -46,8 +44,8 @@ class DependencySortTest(TestBase):
             (rootnode, node3),
             (rootnode, node4),
             (node4, subnode3),
-            (node4, subnode4)
-        ]
+            (node4, subnode4),
+            ]
         self.assert_sort(tuples)
 
     def test_sort_two(self):
@@ -58,13 +56,8 @@ class DependencySortTest(TestBase):
         node5 = 'node5'
         node6 = 'node6'
         node7 = 'node7'
-        tuples = [
-            (node1, node2),
-            (node3, node4),
-            (node4, node5),
-            (node5, node6),
-            (node6, node2)
-        ]
+        tuples = [(node1, node2), (node3, node4), (node4, node5),
+                  (node5, node6), (node6, node2)]
         self.assert_sort(tuples, [node7])
 
     def test_sort_three(self):
@@ -72,12 +65,8 @@ class DependencySortTest(TestBase):
         node2 = 'itemkeyowrds'
         node3 = 'items'
         node4 = 'hoho'
-        tuples = [
-            (node1, node2),
-            (node4, node1),
-            (node1, node3),
-            (node3, node2)
-        ]
+        tuples = [(node1, node2), (node4, node1), (node1, node3),
+                  (node3, node2)]
         self.assert_sort(tuples)
 
     def test_raise_on_cycle_one(self):
@@ -92,70 +81,71 @@ class DependencySortTest(TestBase):
             (node1, node2),
             (node2, node3),
             (node3, node1),
-            (node4, node1)
-        ]
+            (node4, node1),
+            ]
         allitems = self._nodes_from_tuples(tuples)
-        assert_raises(exc.CircularDependencyError, list, topological.sort(tuples, allitems))
+        assert_raises(exc.CircularDependencyError, list,
+                      topological.sort(tuples, allitems))
 
         # TODO: test find_cycles
 
     def test_raise_on_cycle_two(self):
-        # this condition was arising from ticket:362
-        # and was not treated properly by topological sort
+
+        # this condition was arising from ticket:362 and was not treated
+        # properly by topological sort
+
         node1 = 'node1'
         node2 = 'node2'
         node3 = 'node3'
         node4 = 'node4'
-        tuples = [
-            (node1, node2),
-            (node3, node1),
-            (node2, node4),
-            (node3, node2),
-            (node2, node3)
-        ]
+        tuples = [(node1, node2), (node3, node1), (node2, node4),
+                  (node3, node2), (node2, node3)]
         allitems = self._nodes_from_tuples(tuples)
-        assert_raises(exc.CircularDependencyError, list, topological.sort(tuples, allitems))
+        assert_raises(exc.CircularDependencyError, list,
+                      topological.sort(tuples, allitems))
 
         # TODO: test find_cycles
 
     def test_raise_on_cycle_three(self):
-        question, issue, providerservice, answer, provider = "Question", "Issue", "ProviderService", "Answer", "Provider"
-
-        tuples = [(question, issue), (providerservice, issue), (provider, question), 
-                    (question, provider), (providerservice, question), 
-                    (provider, providerservice), (question, answer), (issue, question)]
-
+        question, issue, providerservice, answer, provider = \
+            'Question', 'Issue', 'ProviderService', 'Answer', 'Provider'
+        tuples = [
+            (question, issue),
+            (providerservice, issue),
+            (provider, question),
+            (question, provider),
+            (providerservice, question),
+            (provider, providerservice),
+            (question, answer),
+            (issue, question),
+            ]
         allitems = self._nodes_from_tuples(tuples)
-        assert_raises(exc.CircularDependencyError, list, topological.sort(tuples, allitems))
-        
+        assert_raises(exc.CircularDependencyError, list,
+                      topological.sort(tuples, allitems))
+
         # TODO: test find_cycles
-        
+
     def test_large_sort(self):
         tuples = [(i, i + 1) for i in range(0, 1500, 2)]
         self.assert_sort(tuples)
 
     def test_ticket_1380(self):
+
         # ticket:1380 regression: would raise a KeyError
+
         tuples = [(id(i), i) for i in range(3)]
         self.assert_sort(tuples)
-        
+
     def test_find_cycle_one(self):
         node1 = 'node1'
         node2 = 'node2'
         node3 = 'node3'
         node4 = 'node4'
-        tuples = [
-            (node1, node2),
-            (node3, node1),
-            (node2, node4),
-            (node3, node2),
-            (node2, node3)
-        ]
-
-        eq_(
-            topological.find_cycles(tuples, self._nodes_from_tuples(tuples)),
-            set([node1, node2, node3])
-        )
+        tuples = [(node1, node2), (node3, node1), (node2, node4),
+                  (node3, node2), (node2, node3)]
+        eq_(topological.find_cycles(tuples,
+            self._nodes_from_tuples(tuples)), set([node1, node2,
+            node3]))
 
     def test_find_multiple_cycles_one(self):
         node1 = 'node1'
@@ -167,33 +157,41 @@ class DependencySortTest(TestBase):
         node7 = 'node7'
         node8 = 'node8'
         node9 = 'node9'
-        tuples = [
-            # cycle 1
+        tuples = [  # cycle 1 cycle 2 cycle 3 cycle 4, but only if cycle
+                    # 1 nodes are present
             (node1, node2),
             (node2, node4),
             (node4, node1),
-
-            # cycle 2
             (node9, node9),
-
-            # cycle 3
             (node7, node5),
             (node5, node7),
-
-            # cycle 4, but only if cycle 1 nodes are present
             (node1, node6),
             (node6, node8),
             (node8, node4),
-
             (node3, node1),
             (node3, node2),
-        ]
-        
-        allnodes = set([node1, node2, node3, node4, node5, node6, node7, node8, node9])
-        eq_(
-            topological.find_cycles(tuples, allnodes),
-            set(['node8', 'node1', 'node2', 'node5', 'node4', 'node7', 'node6', 'node9'])
-        )
+            ]
+        allnodes = set([
+            node1,
+            node2,
+            node3,
+            node4,
+            node5,
+            node6,
+            node7,
+            node8,
+            node9,
+            ])
+        eq_(topological.find_cycles(tuples, allnodes), set([
+            'node8',
+            'node1',
+            'node2',
+            'node5',
+            'node4',
+            'node7',
+            'node6',
+            'node9',
+            ]))
 
     def test_find_multiple_cycles_two(self):
         node1 = 'node1'
@@ -202,24 +200,25 @@ class DependencySortTest(TestBase):
         node4 = 'node4'
         node5 = 'node5'
         node6 = 'node6'
-        tuples = [
-            # cycle 1
+        tuples = [  # cycle 1 cycle 2
             (node1, node2),
             (node2, node4),
             (node4, node1),
-
-            # cycle 2
             (node1, node6),
             (node6, node2),
             (node2, node4),
             (node4, node1),
-        ]
-
-        allnodes = set([node1, node2, node3, node4, node5, node6])
-        eq_(
-            topological.find_cycles(tuples, allnodes),
-            set(['node1', 'node2', 'node4'])
-        )
+            ]
+        allnodes = set([
+            node1,
+            node2,
+            node3,
+            node4,
+            node5,
+            node6,
+            ])
+        eq_(topological.find_cycles(tuples, allnodes), set(['node1',
+            'node2', 'node4']))
 
     def test_find_multiple_cycles_three(self):
         node1 = 'node1'
@@ -228,33 +227,23 @@ class DependencySortTest(TestBase):
         node4 = 'node4'
         node5 = 'node5'
         node6 = 'node6'
-        tuples = [
-
-            # cycle 1
+        tuples = [  # cycle 1 cycle 2 cycle3 cycle4
             (node1, node2),
             (node2, node1),
-
-            # cycle 2
             (node2, node3),
             (node3, node2),
-
-            # cycle3
             (node2, node4),
             (node4, node2),
-            
-            # cycle4
             (node2, node5),
             (node5, node6),
-            (node6, node2)
-        ]
-
-        allnodes = set([node1, node2, node3, node4, node5, node6])
-        eq_(
-            topological.find_cycles(tuples, allnodes),
-            allnodes
-        )
-        
-        
-        
-
-
+            (node6, node2),
+            ]
+        allnodes = set([
+            node1,
+            node2,
+            node3,
+            node4,
+            node5,
+            node6,
+            ])
+        eq_(topological.find_cycles(tuples, allnodes), allnodes)
diff --git a/test/base/test_except.py b/test/base/test_except.py
index fbe0a05de..09a9eb7b4 100644
--- a/test/base/test_except.py
+++ b/test/base/test_except.py
@@ -1,92 +1,125 @@
 """Tests exceptions and DB-API exception wrapping."""
+
+
 from sqlalchemy import exc as sa_exceptions
 from sqlalchemy.test import TestBase
 
-# Py3K
-#StandardError = BaseException
-# Py2K
+# Py3K StandardError = BaseException Py2K
+
 from exceptions import StandardError, KeyboardInterrupt, SystemExit
+
 # end Py2K
 
+
 class Error(StandardError):
-    """This class will be old-style on <= 2.4 and new-style on >= 2.5."""
+    """This class will be old-style on <= 2.4 and new-style on >=
+    2.5."""
+
+
 class DatabaseError(Error):
     pass
+
+
 class OperationalError(DatabaseError):
     pass
+
+
 class ProgrammingError(DatabaseError):
     def __str__(self):
-        return "<%s>" % self.bogus
+        return '<%s>' % self.bogus
+
+
 class OutOfSpec(DatabaseError):
     pass
 
 
 class WrapTest(TestBase):
+
     def test_db_error_normal(self):
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                '', [], OperationalError())
+            raise sa_exceptions.DBAPIError.instance('', [],
+                    OperationalError())
         except sa_exceptions.DBAPIError:
             self.assert_(True)
-    
+
     def test_tostring(self):
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                'this is a message', None, OperationalError())
+            raise sa_exceptions.DBAPIError.instance('this is a message'
+                    , None, OperationalError())
         except sa_exceptions.DBAPIError, exc:
-            assert str(exc) == "(OperationalError)  'this is a message' None"
+            assert str(exc) \
+                == "(OperationalError)  'this is a message' None"
 
     def test_tostring_large_dict(self):
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                'this is a message', {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6, 'g':7, 'h':8, 'i':9, 'j':10, 'k':11}, OperationalError())
+            raise sa_exceptions.DBAPIError.instance('this is a message'
+                    , 
+                {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h':
+                8, 'i': 9, 'j': 10, 'k': 11,
+                }, OperationalError())
         except sa_exceptions.DBAPIError, exc:
-            assert str(exc).startswith("(OperationalError)  'this is a message' {")
+            assert str(exc).startswith("(OperationalError)  'this is a "
+                    "message' {")
 
     def test_tostring_large_list(self):
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                'this is a message', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], OperationalError())
+            raise sa_exceptions.DBAPIError.instance('this is a message', 
+                [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,], OperationalError())
         except sa_exceptions.DBAPIError, exc:
-            assert str(exc).startswith("(OperationalError)  'this is a message' [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]")
+            assert str(exc).startswith("(OperationalError)  'this is a "
+                    "message' [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]")
 
     def test_tostring_large_executemany(self):
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                'this is a message', [{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},], OperationalError())
+            raise sa_exceptions.DBAPIError.instance('this is a message', 
+                [{1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, 
+                {1: 1}, {1:1}, {1: 1}, {1: 1},], 
+                OperationalError())
         except sa_exceptions.DBAPIError, exc:
-            assert str(exc) == "(OperationalError)  'this is a message' [{1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}]", str(exc)
-
+            assert str(exc) \
+                == "(OperationalError)  'this is a message' [{1: 1}, "\
+                "{1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: "\
+                "1}, {1: 1}, {1: 1}]", str(exc)
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                'this is a message', [{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},{1:1},], OperationalError())
+            raise sa_exceptions.DBAPIError.instance('this is a message', [
+                {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, 
+                {1:1}, {1: 1}, {1: 1}, {1: 1},
+                ], OperationalError())
         except sa_exceptions.DBAPIError, exc:
-            assert str(exc) == "(OperationalError)  'this is a message' [{1: 1}, {1: 1}] ... and a total of 11 bound parameter sets"
-
+            assert str(exc) \
+                == "(OperationalError)  'this is a message' [{1: 1}, "\
+                "{1: 1}] ... and a total of 11 bound parameter sets"
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                'this is a message', [(1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,)], OperationalError())
+            raise sa_exceptions.DBAPIError.instance('this is a message', 
+                [
+                (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ),
+                (1, ),
+                ], OperationalError())
         except sa_exceptions.DBAPIError, exc:
-            assert str(exc) == "(OperationalError)  'this is a message' [(1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,)]"
-
+            assert str(exc) \
+                == "(OperationalError)  'this is a message' [(1,), "\
+                "(1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,)]"
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                'this is a message', [(1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), ], OperationalError())
+            raise sa_exceptions.DBAPIError.instance('this is a message', [
+                (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ),
+                (1, ), (1, ),
+                ], OperationalError())
         except sa_exceptions.DBAPIError, exc:
-            assert str(exc) == "(OperationalError)  'this is a message' [(1,), (1,)] ... and a total of 11 bound parameter sets"
-        
+            assert str(exc) \
+                == "(OperationalError)  'this is a message' [(1,), "\
+                "(1,)] ... and a total of 11 bound parameter sets"
+
     def test_db_error_busted_dbapi(self):
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                '', [], ProgrammingError())
+            raise sa_exceptions.DBAPIError.instance('', [],
+                    ProgrammingError())
         except sa_exceptions.DBAPIError, e:
             self.assert_(True)
             self.assert_('Error in str() of DB-API' in e.args[0])
 
     def test_db_error_noncompliant_dbapi(self):
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                '', [], OutOfSpec())
+            raise sa_exceptions.DBAPIError.instance('', [], OutOfSpec())
         except sa_exceptions.DBAPIError, e:
             self.assert_(e.__class__ is sa_exceptions.DBAPIError)
         except OutOfSpec:
@@ -94,9 +127,10 @@ class WrapTest(TestBase):
 
         # Make sure the DatabaseError recognition logic is limited to
         # subclasses of sqlalchemy.exceptions.DBAPIError
+
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                '', [], sa_exceptions.ArgumentError())
+            raise sa_exceptions.DBAPIError.instance('', [],
+                    sa_exceptions.ArgumentError())
         except sa_exceptions.DBAPIError, e:
             self.assert_(e.__class__ is sa_exceptions.DBAPIError)
         except sa_exceptions.ArgumentError:
@@ -104,8 +138,8 @@ class WrapTest(TestBase):
 
     def test_db_error_keyboard_interrupt(self):
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                '', [], KeyboardInterrupt())
+            raise sa_exceptions.DBAPIError.instance('', [],
+                    KeyboardInterrupt())
         except sa_exceptions.DBAPIError:
             self.assert_(False)
         except KeyboardInterrupt:
@@ -113,11 +147,9 @@ class WrapTest(TestBase):
 
     def test_db_error_system_exit(self):
         try:
-            raise sa_exceptions.DBAPIError.instance(
-                '', [], SystemExit())
+            raise sa_exceptions.DBAPIError.instance('', [],
+                    SystemExit())
         except sa_exceptions.DBAPIError:
             self.assert_(False)
         except SystemExit:
             self.assert_(True)
-
-
diff --git a/test/base/test_utils.py b/test/base/test_utils.py
index 68ccc6ba2..d083a8458 100644
--- a/test/base/test_utils.py
+++ b/test/base/test_utils.py
@@ -4,6 +4,8 @@ from sqlalchemy import util, sql, exc
 from sqlalchemy.test import TestBase
 from sqlalchemy.test.testing import eq_, is_, ne_
 from sqlalchemy.test.util import gc_collect, picklers
+from sqlalchemy.util import classproperty
+
 
 class OrderedDictTest(TestBase):
     def test_odict(self):
@@ -53,7 +55,8 @@ class OrderedDictTest(TestBase):
         eq_(o.values(), [1, 2, 3, 4, 5, 6])
 
     def test_odict_constructor(self):
-        o = util.OrderedDict([('name', 'jbe'), ('fullname', 'jonathan'), ('password', '')])
+        o = util.OrderedDict([('name', 'jbe'), ('fullname', 'jonathan'
+                             ), ('password', '')])
         eq_(o.keys(), ['name', 'fullname', 'password'])
 
     def test_odict_copy(self):
@@ -196,19 +199,23 @@ class ImmutableSubclass(str):
     pass
 
 class FlattenIteratorTest(TestBase):
+
     def test_flatten(self):
-        assert list(util.flatten_iterator([[1,2,3], [4,5,6], 7, 8])) == [1,2,3,4,5,6,7,8]
+        assert list(util.flatten_iterator([[1, 2, 3], [4, 5, 6], 7,
+                    8])) == [1, 2, 3, 4, 5, 6, 7, 8]
 
     def test_str_with_iter(self):
-        """ensure that a str object with an __iter__ method (like in PyPy) is not interpreted
-        as an iterable.
+        """ensure that a str object with an __iter__ method (like in
+        PyPy) is not interpreted as an iterable.
         
         """
         class IterString(str):
             def __iter__(self):
-                return iter(self + "")
+                return iter(self + '')
 
-        assert list(util.flatten_iterator([IterString("asdf"), [IterString("x"), IterString("y")]])) == ["asdf", "x", "y"]
+        assert list(util.flatten_iterator([IterString('asdf'),
+                    [IterString('x'), IterString('y')]])) == ['asdf',
+                'x', 'y']
                 
 class HashOverride(object):
     def __init__(self, value=None):
@@ -230,6 +237,7 @@ class EqOverride(object):
             return self.value != other.value
         else:
             return True
+            
 class HashEqOverride(object):
     def __init__(self, value=None):
         self.value = value
@@ -381,7 +389,8 @@ class OrderedIdentitySetTest(TestBase):
         elem = object
         eq_ = self.assert_eq
         
-        a, b, c, d, e, f, g = elem(), elem(), elem(), elem(), elem(), elem(), elem()
+        a, b, c, d, e, f, g = \
+                elem(), elem(), elem(), elem(), elem(), elem(), elem()
         
         s1 = util.OrderedIdentitySet([a, b, c])
         s2 = util.OrderedIdentitySet([d, e, f])
@@ -977,13 +986,11 @@ class AsInterfaceTest(TestBase):
 
     def test_dict(self):
         obj = {}
-
         assert_raises(TypeError, util.as_interface, obj,
-                          cls=self.Something)
-        assert_raises(TypeError, util.as_interface, obj,
-                          methods=('foo'))
+                      cls=self.Something)
+        assert_raises(TypeError, util.as_interface, obj, methods='foo')
         assert_raises(TypeError, util.as_interface, obj,
-                          cls=self.Something, required=('foo'))
+                      cls=self.Something, required='foo')
 
         def assertAdapted(obj, *methods):
             assert isinstance(obj, type)
@@ -994,34 +1001,29 @@ class AsInterfaceTest(TestBase):
             assert not found
 
         fn = lambda self: 123
-
         obj = {'foo': fn, 'bar': fn}
-
         res = util.as_interface(obj, cls=self.Something)
         assertAdapted(res, 'foo', 'bar')
-
-        res = util.as_interface(obj, cls=self.Something, required=self.Something)
+        res = util.as_interface(obj, cls=self.Something,
+                                required=self.Something)
         assertAdapted(res, 'foo', 'bar')
-
-        res = util.as_interface(obj, cls=self.Something, required=('foo',))
+        res = util.as_interface(obj, cls=self.Something, required=('foo'
+                                , ))
         assertAdapted(res, 'foo', 'bar')
-
         res = util.as_interface(obj, methods=('foo', 'bar'))
         assertAdapted(res, 'foo', 'bar')
-
         res = util.as_interface(obj, methods=('foo', 'bar', 'baz'))
         assertAdapted(res, 'foo', 'bar')
-
-        res = util.as_interface(obj, methods=('foo', 'bar'), required=('foo',))
+        res = util.as_interface(obj, methods=('foo', 'bar'),
+                                required=('foo', ))
         assertAdapted(res, 'foo', 'bar')
-
-        assert_raises(TypeError, util.as_interface, obj, methods=('foo',))
-
-        assert_raises(TypeError, util.as_interface, obj,
-                          methods=('foo', 'bar', 'baz'), required=('baz',))
-
+        assert_raises(TypeError, util.as_interface, obj, methods=('foo'
+                      , ))
+        assert_raises(TypeError, util.as_interface, obj, methods=('foo'
+                      , 'bar', 'baz'), required=('baz', ))
         obj = {'foo': 123}
-        assert_raises(TypeError, util.as_interface, obj, cls=self.Something)
+        assert_raises(TypeError, util.as_interface, obj,
+                      cls=self.Something)
 
 
 class TestClassHierarchy(TestBase):
@@ -1064,9 +1066,6 @@ class TestClassHierarchy(TestBase):
 class TestClassProperty(TestBase):
 
     def test_simple(self):
-
-        from sqlalchemy.util import classproperty
-
         class A(object):
             something = {'foo':1}