From: Diana Clarke Date: Fri, 23 Nov 2012 16:09:57 +0000 (-0500) Subject: just a pep8 pass before I play with these tests X-Git-Tag: rel_0_8_0b2~27 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=66c5bc6c7094b39c1599c3bc074f9a15a52cb3c6;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git just a pep8 pass before I play with these tests --- diff --git a/test/sql/test_labels.py b/test/sql/test_labels.py index d6ebf3f801..8db7ecbee1 100644 --- a/test/sql/test_labels.py +++ b/test/sql/test_labels.py @@ -1,15 +1,16 @@ -from sqlalchemy.testing import assert_raises, assert_raises_message, eq_ -from sqlalchemy.testing.engines import testing_engine -from sqlalchemy.testing import fixtures, AssertsCompiledSQL -from sqlalchemy import testing from sqlalchemy import * from sqlalchemy import exc as exceptions +from sqlalchemy import testing from sqlalchemy.engine import default from sqlalchemy.sql import table, column +from sqlalchemy.testing import assert_raises, eq_ +from sqlalchemy.testing import fixtures, AssertsCompiledSQL +from sqlalchemy.testing.engines import testing_engine from sqlalchemy.testing.schema import Table, Column IDENT_LENGTH = 29 + class LabelTypeTest(fixtures.TestBase): def test_type(self): m = MetaData() @@ -20,24 +21,25 @@ class LabelTypeTest(fixtures.TestBase): assert isinstance(select([t.c.col2]).as_scalar().label('lala').type, Float) + class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): run_inserts = 'once' run_deletes = None @classmethod def define_tables(cls, metadata): - table1 = Table("some_large_named_table", metadata, - Column("this_is_the_primarykey_column", Integer, + table1 = Table('some_large_named_table', metadata, + Column('this_is_the_primarykey_column', Integer, primary_key=True, test_needs_autoincrement=True), - Column("this_is_the_data_column", String(30)) + Column('this_is_the_data_column', String(30)) ) - table2 = Table("table_with_exactly_29_characs", metadata, - Column("this_is_the_primarykey_column", Integer, + table2 = Table('table_with_exactly_29_characs', metadata, + Column('this_is_the_primarykey_column', Integer, primary_key=True, test_needs_autoincrement=True), - Column("this_is_the_data_column", String(30)) + Column('this_is_the_data_column', String(30)) ) cls.tables.table1 = table1 cls.tables.table2 = table2 @@ -47,14 +49,14 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): table1 = cls.tables.table1 table2 = cls.tables.table2 for data in [ - {"this_is_the_primarykey_column":1, - "this_is_the_data_column":"data1"}, - {"this_is_the_primarykey_column":2, - "this_is_the_data_column":"data2"}, - {"this_is_the_primarykey_column":3, - "this_is_the_data_column":"data3"}, - {"this_is_the_primarykey_column":4, - "this_is_the_data_column":"data4"} + {'this_is_the_primarykey_column':1, + 'this_is_the_data_column':'data1'}, + {'this_is_the_primarykey_column':2, + 'this_is_the_data_column':'data2'}, + {'this_is_the_primarykey_column':3, + 'this_is_the_data_column':'data3'}, + {'this_is_the_primarykey_column':4, + 'this_is_the_data_column':'data4'} ]: testing.db.execute( table1.insert(), @@ -62,8 +64,8 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): ) testing.db.execute( table2.insert(), - {"this_is_the_primary_key_column":1, - "this_is_the_data_column":"data"} + {'this_is_the_primary_key_column': 1, + 'this_is_the_data_column': 'data'} ) @classmethod @@ -79,7 +81,7 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): def test_too_long_name_disallowed(self): m = MetaData(testing.db) - t1 = Table("this_name_is_too_long_for_what_were_doing_in_this_test", + t1 = Table('this_name_is_too_long_for_what_were_doing_in_this_test', m, Column('foo', Integer)) assert_raises(exceptions.IdentifierError, m.create_all) assert_raises(exceptions.IdentifierError, m.drop_all) @@ -97,20 +99,18 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): for row in testing.db.execute(s) ] eq_(result, [ - (1, "data1"), - (2, "data2"), - (3, "data3"), - (4, "data4"), + (1, 'data1'), + (2, 'data2'), + (3, 'data3'), + (4, 'data4'), ]) def test_result_limit(self): table1 = self.tables.table1 - # some dialects such as oracle (and possibly ms-sql - # in a future version) - # generate a subquery for limits/offsets. - # ensure that the generated result map corresponds - # to the selected table, not - # the select query + # some dialects such as oracle (and possibly ms-sql in a future + # version) generate a subquery for limits/offsets. ensure that the + # generated result map corresponds to the selected table, not the + # select query s = table1.select(use_labels=True, order_by=[table1.c.this_is_the_primarykey_column]).\ limit(2) @@ -121,8 +121,8 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): for row in testing.db.execute(s) ] eq_(result, [ - (1, "data1"), - (2, "data2"), + (1, 'data1'), + (2, 'data2'), ]) @testing.requires.offset @@ -138,29 +138,32 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): for row in testing.db.execute(s) ] eq_(result, [ - (2, "data2"), - (3, "data3"), + (2, 'data2'), + (3, 'data3'), ]) def test_table_alias_1(self): table2 = self.tables.table2 if testing.against('oracle'): - self.assert_compile( - table2.alias().select(), - "SELECT table_with_exactly_29_c_1." - "this_is_the_primarykey_column, " - "table_with_exactly_29_c_1.this_is_the_data_column " - "FROM table_with_exactly_29_characs " - "table_with_exactly_29_c_1" + self.assert_compile(table2.alias().select(), + 'SELECT ' + 'table_with_exactly_29_c_1.' + 'this_is_the_primarykey_column, ' + 'table_with_exactly_29_c_1.this_is_the_data_column ' + 'FROM ' + 'table_with_exactly_29_characs ' + 'table_with_exactly_29_c_1' ) else: self.assert_compile( table2.alias().select(), - "SELECT table_with_exactly_29_c_1." - "this_is_the_primarykey_column, " - "table_with_exactly_29_c_1.this_is_the_data_column " - "FROM table_with_exactly_29_characs AS " - "table_with_exactly_29_c_1" + 'SELECT ' + 'table_with_exactly_29_c_1.' + 'this_is_the_primarykey_column, ' + 'table_with_exactly_29_c_1.this_is_the_data_column ' + 'FROM ' + 'table_with_exactly_29_characs ' + 'AS table_with_exactly_29_c_1' ) def test_table_alias_2(self): @@ -169,23 +172,27 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): ta = table2.alias() dialect = default.DefaultDialect() dialect.max_identifier_length = IDENT_LENGTH + on = table1.c.this_is_the_data_column == ta.c.this_is_the_data_column self.assert_compile( - select([table1, ta]).select_from( - table1.join(ta, - table1.c.this_is_the_data_column== - ta.c.this_is_the_data_column)).\ - where(ta.c.this_is_the_data_column=='data3'), - - "SELECT some_large_named_table.this_is_the_primarykey_column, " - "some_large_named_table.this_is_the_data_column, " - "table_with_exactly_29_c_1.this_is_the_primarykey_column, " - "table_with_exactly_29_c_1.this_is_the_data_column FROM " - "some_large_named_table JOIN table_with_exactly_29_characs " - "AS table_with_exactly_29_c_1 ON " - "some_large_named_table.this_is_the_data_column = " - "table_with_exactly_29_c_1.this_is_the_data_column " - "WHERE table_with_exactly_29_c_1.this_is_the_data_column = " - ":this_is_the_data_column_1", + select([table1, ta]).select_from(table1.join(ta, on)).\ + where(ta.c.this_is_the_data_column == 'data3'), + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column, ' + 'some_large_named_table.this_is_the_data_column, ' + 'table_with_exactly_29_c_1.this_is_the_primarykey_column, ' + 'table_with_exactly_29_c_1.this_is_the_data_column ' + 'FROM ' + 'some_large_named_table ' + 'JOIN ' + 'table_with_exactly_29_characs ' + 'AS ' + 'table_with_exactly_29_c_1 ' + 'ON ' + 'some_large_named_table.this_is_the_data_column = ' + 'table_with_exactly_29_c_1.this_is_the_data_column ' + 'WHERE ' + 'table_with_exactly_29_c_1.this_is_the_data_column = ' + ':this_is_the_data_column_1', dialect=dialect ) @@ -193,32 +200,32 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): table2 = self.tables.table2 eq_( testing.db.execute(table2.alias().select()).first(), - (1, "data") + (1, 'data') ) def test_colbinds(self): table1 = self.tables.table1 r = table1.select(table1.c.this_is_the_primarykey_column == 4).\ execute() - assert r.fetchall() == [(4, "data4")] + assert r.fetchall() == [(4, 'data4')] r = table1.select(or_( table1.c.this_is_the_primarykey_column == 4, table1.c.this_is_the_primarykey_column == 2 )).execute() - assert r.fetchall() == [(2, "data2"), (4, "data4")] + assert r.fetchall() == [(2, 'data2'), (4, 'data4')] @testing.provide_metadata def test_insert_no_pk(self): - t = Table("some_other_large_named_table", self.metadata, - Column("this_is_the_primarykey_column", Integer, - Sequence("this_is_some_large_seq"), + t = Table('some_other_large_named_table', self.metadata, + Column('this_is_the_primarykey_column', Integer, + Sequence('this_is_some_large_seq'), primary_key=True), - Column("this_is_the_data_column", String(30)) + Column('this_is_the_data_column', String(30)) ) t.create(testing.db, checkfirst=True) testing.db.execute(t.insert(), - **{"this_is_the_data_column":"data1"}) + **{'this_is_the_data_column': 'data1'}) @testing.requires.subqueries def test_subquery(self): @@ -240,17 +247,25 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): x = select([q], use_labels=True) self.assert_compile(x, - "SELECT anon_1.this_is_the_primarykey_column AS " - "anon_1_this_is_the_prim_1, anon_1.this_is_the_data_column " - "AS anon_1_this_is_the_data_2 " - "FROM (SELECT some_large_named_table." - "this_is_the_primarykey_column AS " - "this_is_the_primarykey_column, " - "some_large_named_table.this_is_the_data_column " - "AS this_is_the_data_column " - "FROM some_large_named_table " - "WHERE some_large_named_table.this_is_the_primarykey_column " - "= :this_is_the_primarykey__1) AS anon_1", + 'SELECT ' + 'anon_1.this_is_the_primarykey_column ' + 'AS anon_1_this_is_the_prim_1, ' + 'anon_1.this_is_the_data_column ' + 'AS anon_1_this_is_the_data_2 ' + 'FROM (' + 'SELECT ' + 'some_large_named_table.' + 'this_is_the_primarykey_column ' + 'AS this_is_the_primarykey_column, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS this_is_the_data_column ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :this_is_the_primarykey__1' + ') ' + 'AS anon_1', dialect=compile_dialect) eq_( @@ -261,25 +276,46 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): def test_adjustable(self): table1 = self.tables.table1 - q = table1.select(table1.c.this_is_the_primarykey_column == 4).alias('foo') + q = table1.select( + table1.c.this_is_the_primarykey_column == 4).alias('foo') x = select([q]) compile_dialect = default.DefaultDialect(label_length=10) self.assert_compile(x, - "SELECT foo.this_1, foo.this_2 FROM " - "(SELECT some_large_named_table." - "this_is_the_primarykey_column AS this_1, " - "some_large_named_table.this_is_the_data_column AS this_2 " - "FROM some_large_named_table WHERE " - "some_large_named_table.this_is_the_primarykey_column = :this_1) AS foo", + 'SELECT ' + 'foo.this_1, foo.this_2 ' + 'FROM (' + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column ' + 'AS this_1, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS this_2 ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :this_1' + ') ' + 'AS foo', dialect=compile_dialect) compile_dialect = default.DefaultDialect(label_length=4) - self.assert_compile(x, "SELECT foo._1, foo._2 FROM " - "(SELECT some_large_named_table.this_is_the_primarykey_column " - "AS _1, some_large_named_table.this_is_the_data_column AS _2 " - "FROM some_large_named_table WHERE " - "some_large_named_table.this_is_the_primarykey_column = :_1) AS foo", + self.assert_compile(x, + 'SELECT ' + 'foo._1, foo._2 ' + 'FROM (' + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column ' + 'AS _1, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS _2 ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :_1' + ') ' + 'AS foo', dialect=compile_dialect) q = table1.select(table1.c.this_is_the_primarykey_column == 4).alias() @@ -287,58 +323,84 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): compile_dialect = default.DefaultDialect(label_length=10) self.assert_compile(x, - "SELECT anon_1.this_2 AS anon_1, anon_1.this_4 AS anon_3 FROM " - "(SELECT some_large_named_table.this_is_the_primarykey_column " - "AS this_2, some_large_named_table.this_is_the_data_column AS this_4 " - "FROM some_large_named_table WHERE " - "some_large_named_table.this_is_the_primarykey_column = :this_1) AS anon_1", + 'SELECT ' + 'anon_1.this_2 AS anon_1, ' + 'anon_1.this_4 AS anon_3 ' + 'FROM (' + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column ' + 'AS this_2, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS this_4 ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :this_1' + ') ' + 'AS anon_1', dialect=compile_dialect) compile_dialect = default.DefaultDialect(label_length=4) - self.assert_compile(x, "SELECT _1._2 AS _1, _1._4 AS _3 FROM " - "(SELECT some_large_named_table.this_is_the_primarykey_column " - "AS _2, some_large_named_table.this_is_the_data_column AS _4 " - "FROM some_large_named_table WHERE " - "some_large_named_table.this_is_the_primarykey_column = :_1) AS _1", + self.assert_compile(x, + 'SELECT ' + '_1._2 AS _1, ' + '_1._4 AS _3 ' + 'FROM (' + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column ' + 'AS _2, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS _4 ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :_1' + ') ' + 'AS _1', dialect=compile_dialect) def test_adjustable_result_schema_column(self): table1 = self.tables.table1 - q = table1.select(table1.c.this_is_the_primarykey_column == 4).alias('foo') + q = table1.select( + table1.c.this_is_the_primarykey_column == 4).alias('foo') x = select([q]) - e = testing_engine(options={"label_length":10}) + e = testing_engine(options={'label_length': 10}) e.pool = testing.db.pool row = e.execute(x).first() eq_(row.this_is_the_primarykey_column, 4) eq_(row.this_1, 4) eq_(row['this_1'], 4) - q = table1.select(table1.c.this_is_the_primarykey_column == 4).alias('foo') + q = table1.select( + table1.c.this_is_the_primarykey_column == 4).alias('foo') row = e.execute(x).first() eq_(row.this_is_the_primarykey_column, 4) eq_(row.this_1, 4) def test_adjustable_result_lightweight_column(self): - table1 = table("some_large_named_table", - column("this_is_the_primarykey_column"), - column("this_is_the_data_column") + table1 = table('some_large_named_table', + column('this_is_the_primarykey_column'), + column('this_is_the_data_column') ) - q = table1.select(table1.c.this_is_the_primarykey_column == 4).alias('foo') + q = table1.select( + table1.c.this_is_the_primarykey_column == 4).alias('foo') x = select([q]) - e = testing_engine(options={"label_length":10}) + e = testing_engine(options={'label_length': 10}) e.pool = testing.db.pool row = e.execute(x).first() eq_(row.this_is_the_primarykey_column, 4) eq_(row.this_1, 4) def test_table_plus_column_exceeds_length(self): - """test that the truncation occurs if tablename / colname are only - greater than the max when concatenated.""" + '''test that the truncation occurs if tablename / colname are only + greater than the max when concatenated.''' compile_dialect = default.DefaultDialect(label_length=30) m = MetaData() @@ -361,36 +423,38 @@ class LongLabelsTest(fixtures.TablesTest, AssertsCompiledSQL): anon = a_table.alias() self.assert_compile( - select([other_table,anon]). - select_from( - other_table.outerjoin(anon) - ).apply_labels(), - "SELECT other_thirty_characters_table_.id AS " - "other_thirty_characters__1, " - "other_thirty_characters_table_.thirty_characters_table_id " - "AS other_thirty_characters__2, thirty_characters_table__1.id " - "AS thirty_characters_table__3 " - "FROM other_thirty_characters_table_ " - "LEFT OUTER JOIN thirty_characters_table_xxxxxx " - "AS thirty_characters_table__1 ON " - "thirty_characters_table__1.id = " - "other_thirty_characters_table_.thirty_characters_table_id", + select([other_table, anon]). + select_from(other_table.outerjoin(anon)).apply_labels(), + 'SELECT ' + 'other_thirty_characters_table_.id ' + 'AS other_thirty_characters__1, ' + 'other_thirty_characters_table_.thirty_characters_table_id ' + 'AS other_thirty_characters__2, ' + 'thirty_characters_table__1.id ' + 'AS thirty_characters_table__3 ' + 'FROM ' + 'other_thirty_characters_table_ ' + 'LEFT OUTER JOIN ' + 'thirty_characters_table_xxxxxx AS thirty_characters_table__1 ' + 'ON thirty_characters_table__1.id = ' + 'other_thirty_characters_table_.thirty_characters_table_id', dialect=compile_dialect) self.assert_compile( - select([other_table, anon]). - select_from( - other_table.outerjoin(anon) - ).apply_labels(), - "SELECT other_thirty_characters_table_.id AS " - "other_thirty_characters__1, " - "other_thirty_characters_table_.thirty_characters_table_id " - "AS other_thirty_characters__2, " - "thirty_characters_table__1.id AS thirty_characters_table__3 " - "FROM other_thirty_characters_table_ " - "LEFT OUTER JOIN thirty_characters_table_xxxxxx " - "AS thirty_characters_table__1 ON " - "thirty_characters_table__1.id = " - "other_thirty_characters_table_.thirty_characters_table_id", + select([other_table, anon]). + select_from(other_table.outerjoin(anon)).apply_labels(), + 'SELECT ' + 'other_thirty_characters_table_.id ' + 'AS other_thirty_characters__1, ' + 'other_thirty_characters_table_.thirty_characters_table_id ' + 'AS other_thirty_characters__2, ' + 'thirty_characters_table__1.id ' + 'AS thirty_characters_table__3 ' + 'FROM ' + 'other_thirty_characters_table_ ' + 'LEFT OUTER JOIN ' + 'thirty_characters_table_xxxxxx AS thirty_characters_table__1 ' + 'ON thirty_characters_table__1.id = ' + 'other_thirty_characters_table_.thirty_characters_table_id', dialect=compile_dialect ) diff --git a/test/sql/test_quote.py b/test/sql/test_quote.py index 766d9d4855..50a8a414b8 100644 --- a/test/sql/test_quote.py +++ b/test/sql/test_quote.py @@ -74,7 +74,7 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): result = select(columns).execute().fetchall() assert(result == [(1, 2, 3), (2, 2, 3), (4, 3, 2)]) - def test_basic_use_labels(self): + def test_use_labels(self): table1.insert().execute( {'lowercase': 1, 'UPPERCASE': 2, 'MixedCase': 3, 'a123': 4}, {'lowercase': 2, 'UPPERCASE': 2, 'MixedCase': 3, 'a123': 4},