- Undeclared SAWarnings are now fatal to tests as well.

- Fixed typo that was killing runs of individual named tests.

1 files changed, 72 insertions, 71 deletions

diff --git a/test/sql/generative.py b/test/sql/generative.py
index 41b4caebf..c787d3404 100644
--- a/test/sql/generative.py
+++ b/test/sql/generative.py
@@ -11,10 +11,10 @@ from sqlalchemy.sql import util as sql_util
 class TraversalTest(AssertMixin):
     """test ClauseVisitor's traversal, particularly its ability to copy and modify
     a ClauseElement in place."""
-    
+
     def setUpAll(self):
         global A, B
-        
+
         # establish two ficticious ClauseElements.
         # define deep equality semantics as well as deep identity semantics.
         class A(ClauseElement):
@@ -23,16 +23,16 @@ class TraversalTest(AssertMixin):
 
             def is_other(self, other):
                 return other is self
-            
+
             def __eq__(self, other):
                 return other.expr == self.expr
-            
+
             def __ne__(self, other):
                 return other.expr != self.expr
-                
+
             def __str__(self):
                 return "A(%s)" % repr(self.expr)
-                
+
         class B(ClauseElement):
             def __init__(self, *items):
                 self.items = items
@@ -50,22 +50,22 @@ class TraversalTest(AssertMixin):
                     if i1 != i2:
                         return False
                 return True
-            
+
             def __ne__(self, other):
                 for i1, i2 in zip(self.items, other.items):
                     if i1 != i2:
                         return True
                 return False
-            
-            def _copy_internals(self, clone=_clone):    
+
+            def _copy_internals(self, clone=_clone):
                 self.items = [clone(i) for i in self.items]
 
             def get_children(self, **kwargs):
                 return self.items
-            
+
             def __str__(self):
                 return "B(%s)" % repr([str(i) for i in self.items])
-    
+
     def test_test_classes(self):
         a1 = A("expr1")
         struct = B(a1, A("expr2"), B(A("expr1b"), A("expr2b")), A("expr3"))
@@ -78,22 +78,22 @@ class TraversalTest(AssertMixin):
         assert struct != struct3
         assert not struct.is_other(struct2)
         assert not struct.is_other(struct3)
-        
-    def test_clone(self):    
+
+    def test_clone(self):
         struct = B(A("expr1"), A("expr2"), B(A("expr1b"), A("expr2b")), A("expr3"))
-        
+
         class Vis(ClauseVisitor):
             def visit_a(self, a):
                 pass
             def visit_b(self, b):
                 pass
-                
+
         vis = Vis()
         s2 = vis.traverse(struct, clone=True)
         assert struct == s2
         assert not struct.is_other(s2)
 
-    def test_no_clone(self):    
+    def test_no_clone(self):
         struct = B(A("expr1"), A("expr2"), B(A("expr1b"), A("expr2b")), A("expr3"))
 
         class Vis(ClauseVisitor):
@@ -106,7 +106,7 @@ class TraversalTest(AssertMixin):
         s2 = vis.traverse(struct, clone=False)
         assert struct == s2
         assert struct.is_other(s2)
-        
+
     def test_change_in_place(self):
         struct = B(A("expr1"), A("expr2"), B(A("expr1b"), A("expr2b")), A("expr3"))
         struct2 = B(A("expr1"), A("expr2modified"), B(A("expr1b"), A("expr2b")), A("expr3"))
@@ -136,41 +136,41 @@ class TraversalTest(AssertMixin):
         s3 = vis2.traverse(struct, clone=True)
         assert struct != s3
         assert struct3 == s3
-    
-        
+
+
 class ClauseTest(SQLCompileTest):
     """test copy-in-place behavior of various ClauseElements."""
-    
+
     def setUpAll(self):
         global t1, t2
-        t1 = table("table1", 
+        t1 = table("table1",
             column("col1"),
             column("col2"),
             column("col3"),
             )
-        t2 = table("table2", 
+        t2 = table("table2",
             column("col1"),
             column("col2"),
             column("col3"),
             )
-            
+
     def test_binary(self):
         clause = t1.c.col2 == t2.c.col2
         assert str(clause) == ClauseVisitor().traverse(clause, clone=True)
-    
+
     def test_join(self):
         clause = t1.join(t2, t1.c.col2==t2.c.col2)
         c1 = str(clause)
         assert str(clause) == str(ClauseVisitor().traverse(clause, clone=True))
-    
+
         class Vis(ClauseVisitor):
             def visit_binary(self, binary):
                 binary.right = t2.c.col3
-                
+
         clause2 = Vis().traverse(clause, clone=True)
         assert c1 == str(clause)
         assert str(clause2) == str(t1.join(t2, t1.c.col2==t2.c.col3))
-        
+
     def test_text(self):
         clause = text("select * from table where foo=:bar", bindparams=[bindparam('bar')])
         c1 = str(clause)
@@ -178,13 +178,13 @@ class ClauseTest(SQLCompileTest):
             def visit_textclause(self, text):
                 text.text = text.text + " SOME MODIFIER=:lala"
                 text.bindparams['lala'] = bindparam('lala')
-                
+
         clause2 = Vis().traverse(clause, clone=True)
         assert c1 == str(clause)
         assert str(clause2) == c1 + " SOME MODIFIER=:lala"
         assert clause.bindparams.keys() == ['bar']
         assert util.Set(clause2.bindparams.keys()) == util.Set(['bar', 'lala'])
-                
+
     def test_select(self):
         s2 = select([t1])
         s2_assert = str(s2)
@@ -201,7 +201,7 @@ class ClauseTest(SQLCompileTest):
         assert str(s2) == s3_assert
 
         print "------------------"
-        
+
         s4_assert = str(select([t1], and_(t1.c.col2==7, t1.c.col3==9)))
         class Vis(ClauseVisitor):
             def visit_select(self, select):
@@ -211,7 +211,7 @@ class ClauseTest(SQLCompileTest):
         print str(s4)
         assert str(s4) == s4_assert
         assert str(s3) == s3_assert
-        
+
         print "------------------"
         s5_assert = str(select([t1], and_(t1.c.col2==7, t1.c.col1==9)))
         class Vis(ClauseVisitor):
@@ -224,10 +224,10 @@ class ClauseTest(SQLCompileTest):
         print str(s5)
         assert str(s5) == s5_assert
         assert str(s4) == s4_assert
-    
+
     def test_binds(self):
         """test that unique bindparams change their name upon clone() to prevent conflicts"""
-        
+
         s = select([t1], t1.c.col1==bindparam(None, unique=True)).alias()
         s2 = ClauseVisitor().traverse(s, clone=True).alias()
         s3 = select([s], s.c.col2==s2.c.col2)
@@ -236,7 +236,7 @@ class ClauseTest(SQLCompileTest):
         "table1.col3 AS col3 FROM table1 WHERE table1.col1 = :param_1) AS anon_1, "\
         "(SELECT table1.col1 AS col1, table1.col2 AS col2, table1.col3 AS col3 FROM table1 WHERE table1.col1 = :param_2) AS anon_2 "\
         "WHERE anon_1.col2 = anon_2.col2")
-        
+
         s = select([t1], t1.c.col1==4).alias()
         s2 = ClauseVisitor().traverse(s, clone=True).alias()
         s3 = select([s], s.c.col2==s2.c.col2)
@@ -244,7 +244,8 @@ class ClauseTest(SQLCompileTest):
         "table1.col3 AS col3 FROM table1 WHERE table1.col1 = :table1_col1_1) AS anon_1, "\
         "(SELECT table1.col1 AS col1, table1.col2 AS col2, table1.col3 AS col3 FROM table1 WHERE table1.col1 = :table1_col1_2) AS anon_2 "\
         "WHERE anon_1.col2 = anon_2.col2")
-        
+
+    @testing.emits_warning('.*replaced by another column with the same key')
     def test_alias(self):
         subq = t2.select().alias('subq')
         s = select([t1.c.col1, subq.c.col1], from_obj=[t1, subq, t1.join(subq, t1.c.col1==subq.c.col2)])
@@ -260,38 +261,38 @@ class ClauseTest(SQLCompileTest):
 
         s4 = sql_util.ClauseAdapter(table('foo')).traverse(s3, clone=True)
         assert orig == str(s) == str(s3) == str(s4)
-        
+
     def test_correlated_select(self):
         s = select(['*'], t1.c.col1==t2.c.col1, from_obj=[t1, t2]).correlate(t2)
         class Vis(ClauseVisitor):
             def visit_select(self, select):
                 select.append_whereclause(t1.c.col2==7)
-                
+
         self.assert_compile(Vis().traverse(s, clone=True), "SELECT * FROM table1 WHERE table1.col1 = table2.col1 AND table1.col2 = :table1_col2_1")
 
 class ClauseAdapterTest(SQLCompileTest):
     def setUpAll(self):
         global t1, t2
-        t1 = table("table1", 
+        t1 = table("table1",
             column("col1"),
             column("col2"),
             column("col3"),
             )
-        t2 = table("table2", 
+        t2 = table("table2",
             column("col1"),
             column("col2"),
             column("col3"),
             )
-            
+
 
     def test_table_to_alias(self):
-        
+
         t1alias = t1.alias('t1alias')
-        
+
         vis = sql_util.ClauseAdapter(t1alias)
         ff = vis.traverse(func.count(t1.c.col1).label('foo'), clone=True)
         assert ff._get_from_objects() == [t1alias]
-        
+
         self.assert_compile(vis.traverse(select(['*'], from_obj=[t1]), clone=True), "SELECT * FROM table1 AS t1alias")
         self.assert_compile(vis.traverse(select(['*'], t1.c.col1==t2.c.col2), clone=True), "SELECT * FROM table1 AS t1alias, table2 WHERE t1alias.col1 = table2.col2")
         self.assert_compile(vis.traverse(select(['*'], t1.c.col1==t2.c.col2, from_obj=[t1, t2]), clone=True), "SELECT * FROM table1 AS t1alias, table2 WHERE t1alias.col1 = table2.col2")
@@ -306,17 +307,17 @@ class ClauseAdapterTest(SQLCompileTest):
         ff = vis.traverse(func.count(t1.c.col1).label('foo'), clone=True)
         self.assert_compile(ff, "count(t1alias.col1) AS foo")
         assert ff._get_from_objects() == [t1alias]
-        
+
 # TODO:
     #    self.assert_compile(vis.traverse(select([func.count(t1.c.col1).label('foo')]), clone=True), "SELECT count(t1alias.col1) AS foo FROM table1 AS t1alias")
-        
+
         t2alias = t2.alias('t2alias')
         vis.chain(sql_util.ClauseAdapter(t2alias))
         self.assert_compile(vis.traverse(select(['*'], t1.c.col1==t2.c.col2), clone=True), "SELECT * FROM table1 AS t1alias, table2 AS t2alias WHERE t1alias.col1 = t2alias.col2")
         self.assert_compile(vis.traverse(select(['*'], t1.c.col1==t2.c.col2, from_obj=[t1, t2]), clone=True), "SELECT * FROM table1 AS t1alias, table2 AS t2alias WHERE t1alias.col1 = t2alias.col2")
         self.assert_compile(vis.traverse(select(['*'], t1.c.col1==t2.c.col2, from_obj=[t1, t2]).correlate(t1), clone=True), "SELECT * FROM table2 AS t2alias WHERE t1alias.col1 = t2alias.col2")
         self.assert_compile(vis.traverse(select(['*'], t1.c.col1==t2.c.col2, from_obj=[t1, t2]).correlate(t2), clone=True), "SELECT * FROM table1 AS t1alias WHERE t1alias.col1 = t2alias.col2")
-    
+
     def test_include_exclude(self):
         m = MetaData()
         a=Table( 'a',m,
@@ -331,7 +332,7 @@ class ClauseAdapterTest(SQLCompileTest):
         e = sql_util.ClauseAdapter( b, include= set([ a.c.id ]),
           equivalents= { a.c.id: set([ a.c.id]) }
         ).traverse( e)
-        
+
         assert str(e) == "a_1.id = a.xxx_id"
 
     def test_join_to_alias(self):
@@ -363,7 +364,7 @@ class ClauseAdapterTest(SQLCompileTest):
                                  " LEFT OUTER JOIN d ON a_id = d.aid")
         j5 = j3.alias('foo')
         j6 = sql_util.ClauseAdapter(j5).copy_and_process([j4])[0]
-        
+
         # this statement takes c join(a join b), wraps it inside an aliased "select * from c join(a join b) AS foo".
         # the outermost right side "left outer join d" stays the same, except "d" joins against foo.a_id instead
         # of plain "a_id"
@@ -371,30 +372,30 @@ class ClauseAdapterTest(SQLCompileTest):
                                 "c JOIN (SELECT a.id AS a_id, b.id AS b_id, b.aid AS b_aid FROM a LEFT OUTER JOIN b ON a.id = b.aid) "
                                 "ON b_id = c.bid) AS foo"
                                 " LEFT OUTER JOIN d ON foo.a_id = d.aid")
-    
+
     def test_derived_from(self):
         assert select([t1]).is_derived_from(t1)
         assert not select([t2]).is_derived_from(t1)
         assert not t1.is_derived_from(select([t1]))
         assert t1.alias().is_derived_from(t1)
-        
-        
+
+
         s1 = select([t1, t2]).alias('foo')
         s2 = select([s1]).limit(5).offset(10).alias()
         assert s2.is_derived_from(s1)
         s2 = s2._clone()
         assert s2.is_derived_from(s1)
-        
+
     def test_aliasedselect_to_aliasedselect(self):
         # original issue from ticket #904
         s1 = select([t1]).alias('foo')
         s2 = select([s1]).limit(5).offset(10).alias()
 
-        self.assert_compile(sql_util.ClauseAdapter(s2).traverse(s1), 
+        self.assert_compile(sql_util.ClauseAdapter(s2).traverse(s1),
             "SELECT foo.col1, foo.col2, foo.col3 FROM (SELECT table1.col1 AS col1, table1.col2 AS col2, table1.col3 AS col3 FROM table1) AS foo  LIMIT 5 OFFSET 10")
-        
+
         j = s1.outerjoin(t2, s1.c.col1==t2.c.col1)
-        self.assert_compile(sql_util.ClauseAdapter(s2).traverse(j).select(), 
+        self.assert_compile(sql_util.ClauseAdapter(s2).traverse(j).select(),
             "SELECT anon_1.col1, anon_1.col2, anon_1.col3, table2.col1, table2.col2, table2.col3 FROM "\
             "(SELECT foo.col1 AS col1, foo.col2 AS col2, foo.col3 AS col3 FROM "\
             "(SELECT table1.col1 AS col1, table1.col2 AS col2, table1.col3 AS col3 FROM table1) AS foo  LIMIT 5 OFFSET 10) AS anon_1 "\
@@ -402,40 +403,40 @@ class ClauseAdapterTest(SQLCompileTest):
 
         talias = t1.alias('bar')
         j = s1.outerjoin(talias, s1.c.col1==talias.c.col1)
-        self.assert_compile(sql_util.ClauseAdapter(s2).traverse(j).select(), 
+        self.assert_compile(sql_util.ClauseAdapter(s2).traverse(j).select(),
             "SELECT anon_1.col1, anon_1.col2, anon_1.col3, bar.col1, bar.col2, bar.col3 FROM "\
             "(SELECT foo.col1 AS col1, foo.col2 AS col2, foo.col3 AS col3 FROM "\
             "(SELECT table1.col1 AS col1, table1.col2 AS col2, table1.col3 AS col3 FROM table1) AS foo  LIMIT 5 OFFSET 10) AS anon_1 "\
             "LEFT OUTER JOIN table1 AS bar ON anon_1.col1 = bar.col1")
-        
-        
+
+
 class SelectTest(SQLCompileTest):
     """tests the generative capability of Select"""
 
     def setUpAll(self):
         global t1, t2
-        t1 = table("table1", 
+        t1 = table("table1",
             column("col1"),
             column("col2"),
             column("col3"),
             )
-        t2 = table("table2", 
+        t2 = table("table2",
             column("col1"),
             column("col2"),
             column("col3"),
             )
-    
+
     def test_select(self):
-        self.assert_compile(t1.select().where(t1.c.col1==5).order_by(t1.c.col3), 
+        self.assert_compile(t1.select().where(t1.c.col1==5).order_by(t1.c.col3),
         "SELECT table1.col1, table1.col2, table1.col3 FROM table1 WHERE table1.col1 = :table1_col1_1 ORDER BY table1.col3")
-    
-        self.assert_compile(t1.select().select_from(select([t2], t2.c.col1==t1.c.col1)).order_by(t1.c.col3), 
+
+        self.assert_compile(t1.select().select_from(select([t2], t2.c.col1==t1.c.col1)).order_by(t1.c.col3),
             "SELECT table1.col1, table1.col2, table1.col3 FROM table1, (SELECT table2.col1 AS col1, table2.col2 AS col2, table2.col3 AS col3 "\
             "FROM table2 WHERE table2.col1 = table1.col1) ORDER BY table1.col3")
-        
+
         s = select([t2], t2.c.col1==t1.c.col1, correlate=False)
         s = s.correlate(t1).order_by(t2.c.col3)
-        self.assert_compile(t1.select().select_from(s).order_by(t1.c.col3), 
+        self.assert_compile(t1.select().select_from(s).order_by(t1.c.col3),
             "SELECT table1.col1, table1.col2, table1.col3 FROM table1, (SELECT table2.col1 AS col1, table2.col2 AS col2, table2.col3 AS col3 "\
             "FROM table2 WHERE table2.col1 = table1.col1 ORDER BY table2.col3) ORDER BY table1.col3")
 
@@ -444,7 +445,7 @@ class SelectTest(SQLCompileTest):
         self.assert_compile(s, "SELECT table1.col1, table1.col2, table1.col3 FROM table1")
         select_copy = s.column('yyy')
         self.assert_compile(select_copy, "SELECT table1.col1, table1.col2, table1.col3, yyy FROM table1")
-        assert s.columns is not select_copy.columns 
+        assert s.columns is not select_copy.columns
         assert s._columns is not select_copy._columns
         assert s._raw_columns is not select_copy._raw_columns
         self.assert_compile(s, "SELECT table1.col1, table1.col2, table1.col3 FROM table1")
@@ -464,8 +465,8 @@ class SelectTest(SQLCompileTest):
         self.assert_compile(s2, "SELECT table1.col1, table1.col2, table1.col3 FROM table1, "
                 "(SELECT table2.col1 AS col1, table2.col2 AS col2, table2.col3 AS col3 FROM table2 "
                 "WHERE table1.col1 = table2.col1) WHERE table1.col2 = col2")
-                
-        s3 = s.correlate(None)        
+
+        s3 = s.correlate(None)
         self.assert_compile(select([t1], t1.c.col2==s3.c.col2), "SELECT table1.col1, table1.col2, table1.col3 FROM table1, "
                 "(SELECT table2.col1 AS col1, table2.col2 AS col2, table2.col3 AS col3 FROM table2, table1 "
                 "WHERE table1.col1 = table2.col1) WHERE table1.col2 = col2")
@@ -479,7 +480,7 @@ class SelectTest(SQLCompileTest):
         self.assert_compile(select([t1], t1.c.col2==s3.c.col2), "SELECT table1.col1, table1.col2, table1.col3 FROM table1, "
                 "(SELECT table2.col1 AS col1, table2.col2 AS col2, table2.col3 AS col3 FROM table2, table1 "
                 "WHERE table1.col1 = table2.col1) WHERE table1.col2 = col2")
-    
+
     def test_prefixes(self):
         s = t1.select()
         self.assert_compile(s, "SELECT table1.col1, table1.col2, table1.col3 FROM table1")
@@ -488,4 +489,4 @@ class SelectTest(SQLCompileTest):
         self.assert_compile(s, "SELECT table1.col1, table1.col2, table1.col3 FROM table1")
 
 if __name__ == '__main__':
-    testbase.main()        
+    testbase.main()