From 2f150bee28525d49e7f36d2e0c7fbeda2352bc3a Mon Sep 17 00:00:00 2001 From: Mike Bayer Date: Mon, 24 Mar 2014 11:33:53 -0400 Subject: - rename __multiple__ to __backend__, and apply __backend__ to a large number of tests. - move out logging tests from test_execute to test_logging --- test/engine/test_execute.py | 242 ++------------------------------------ test/engine/test_logging.py | 255 ++++++++++++++++++++++++++++++++++++++++ test/engine/test_reflection.py | 10 ++ test/engine/test_transaction.py | 8 ++ 4 files changed, 281 insertions(+), 234 deletions(-) create mode 100644 test/engine/test_logging.py (limited to 'test/engine') diff --git a/test/engine/test_execute.py b/test/engine/test_execute.py index c2dbb4a3b..aad43c1df 100644 --- a/test/engine/test_execute.py +++ b/test/engine/test_execute.py @@ -24,6 +24,8 @@ from contextlib import contextmanager users, metadata, users_autoinc = None, None, None class ExecuteTest(fixtures.TestBase): + __backend__ = True + @classmethod def setup_class(cls): global users, users_autoinc, metadata @@ -462,6 +464,8 @@ class ExecuteTest(fixtures.TestBase): eng.dispose() class ConvenienceExecuteTest(fixtures.TablesTest): + __backend__ = True + @classmethod def define_tables(cls, metadata): cls.table = Table('exec_test', metadata, @@ -617,6 +621,8 @@ class ConvenienceExecuteTest(fixtures.TablesTest): self._assert_no_data() class CompiledCacheTest(fixtures.TestBase): + __backend__ = True + @classmethod def setup_class(cls): global users, metadata @@ -648,240 +654,6 @@ class CompiledCacheTest(fixtures.TestBase): assert len(cache) == 1 eq_(conn.execute("select count(*) from users").scalar(), 3) -class LogParamsTest(fixtures.TestBase): - __only_on__ = 'sqlite' - __requires__ = 'ad_hoc_engines', - - def setup(self): - self.eng = engines.testing_engine(options={'echo':True}) - self.eng.execute("create table foo (data string)") - self.buf = logging.handlers.BufferingHandler(100) - for log in [ - logging.getLogger('sqlalchemy.engine'), - logging.getLogger('sqlalchemy.pool') - ]: - log.addHandler(self.buf) - - def teardown(self): - self.eng.execute("drop table foo") - for log in [ - logging.getLogger('sqlalchemy.engine'), - logging.getLogger('sqlalchemy.pool') - ]: - log.removeHandler(self.buf) - - def test_log_large_dict(self): - self.eng.execute( - "INSERT INTO foo (data) values (:data)", - [{"data":str(i)} for i in range(100)] - ) - eq_( - self.buf.buffer[1].message, - "[{'data': '0'}, {'data': '1'}, {'data': '2'}, {'data': '3'}, " - "{'data': '4'}, {'data': '5'}, {'data': '6'}, {'data': '7'}" - " ... displaying 10 of 100 total bound " - "parameter sets ... {'data': '98'}, {'data': '99'}]" - ) - - def test_log_large_list(self): - self.eng.execute( - "INSERT INTO foo (data) values (?)", - [(str(i), ) for i in range(100)] - ) - eq_( - self.buf.buffer[1].message, - "[('0',), ('1',), ('2',), ('3',), ('4',), ('5',), " - "('6',), ('7',) ... displaying 10 of 100 total " - "bound parameter sets ... ('98',), ('99',)]" - ) - - def test_error_large_dict(self): - assert_raises_message( - tsa.exc.DBAPIError, - r".*'INSERT INTO nonexistent \(data\) values \(:data\)' " - "\[{'data': '0'}, {'data': '1'}, {'data': '2'}, " - "{'data': '3'}, {'data': '4'}, {'data': '5'}, " - "{'data': '6'}, {'data': '7'} ... displaying 10 of " - "100 total bound parameter sets ... {'data': '98'}, {'data': '99'}\]", - lambda: self.eng.execute( - "INSERT INTO nonexistent (data) values (:data)", - [{"data":str(i)} for i in range(100)] - ) - ) - - def test_error_large_list(self): - assert_raises_message( - tsa.exc.DBAPIError, - r".*INSERT INTO nonexistent \(data\) values " - "\(\?\)' \[\('0',\), \('1',\), \('2',\), \('3',\), " - "\('4',\), \('5',\), \('6',\), \('7',\) ... displaying " - "10 of 100 total bound parameter sets ... " - "\('98',\), \('99',\)\]", - lambda: self.eng.execute( - "INSERT INTO nonexistent (data) values (?)", - [(str(i), ) for i in range(100)] - ) - ) - -class LoggingNameTest(fixtures.TestBase): - __requires__ = 'ad_hoc_engines', - - def _assert_names_in_execute(self, eng, eng_name, pool_name): - eng.execute(select([1])) - assert self.buf.buffer - for name in [b.name for b in self.buf.buffer]: - assert name in ( - 'sqlalchemy.engine.base.Engine.%s' % eng_name, - 'sqlalchemy.pool.%s.%s' % - (eng.pool.__class__.__name__, pool_name) - ) - - def _assert_no_name_in_execute(self, eng): - eng.execute(select([1])) - assert self.buf.buffer - for name in [b.name for b in self.buf.buffer]: - assert name in ( - 'sqlalchemy.engine.base.Engine', - 'sqlalchemy.pool.%s' % eng.pool.__class__.__name__ - ) - - def _named_engine(self, **kw): - options = { - 'logging_name':'myenginename', - 'pool_logging_name':'mypoolname', - 'echo':True - } - options.update(kw) - return engines.testing_engine(options=options) - - def _unnamed_engine(self, **kw): - kw.update({'echo':True}) - return engines.testing_engine(options=kw) - - def setup(self): - self.buf = logging.handlers.BufferingHandler(100) - for log in [ - logging.getLogger('sqlalchemy.engine'), - logging.getLogger('sqlalchemy.pool') - ]: - log.addHandler(self.buf) - - def teardown(self): - for log in [ - logging.getLogger('sqlalchemy.engine'), - logging.getLogger('sqlalchemy.pool') - ]: - log.removeHandler(self.buf) - - def test_named_logger_names(self): - eng = self._named_engine() - eq_(eng.logging_name, "myenginename") - eq_(eng.pool.logging_name, "mypoolname") - - def test_named_logger_names_after_dispose(self): - eng = self._named_engine() - eng.execute(select([1])) - eng.dispose() - eq_(eng.logging_name, "myenginename") - eq_(eng.pool.logging_name, "mypoolname") - - def test_unnamed_logger_names(self): - eng = self._unnamed_engine() - eq_(eng.logging_name, None) - eq_(eng.pool.logging_name, None) - - def test_named_logger_execute(self): - eng = self._named_engine() - self._assert_names_in_execute(eng, "myenginename", "mypoolname") - - def test_named_logger_echoflags_execute(self): - eng = self._named_engine(echo='debug', echo_pool='debug') - self._assert_names_in_execute(eng, "myenginename", "mypoolname") - - def test_named_logger_execute_after_dispose(self): - eng = self._named_engine() - eng.execute(select([1])) - eng.dispose() - self._assert_names_in_execute(eng, "myenginename", "mypoolname") - - def test_unnamed_logger_execute(self): - eng = self._unnamed_engine() - self._assert_no_name_in_execute(eng) - - def test_unnamed_logger_echoflags_execute(self): - eng = self._unnamed_engine(echo='debug', echo_pool='debug') - self._assert_no_name_in_execute(eng) - -class EchoTest(fixtures.TestBase): - __requires__ = 'ad_hoc_engines', - - def setup(self): - self.level = logging.getLogger('sqlalchemy.engine').level - logging.getLogger('sqlalchemy.engine').setLevel(logging.WARN) - self.buf = logging.handlers.BufferingHandler(100) - logging.getLogger('sqlalchemy.engine').addHandler(self.buf) - - def teardown(self): - logging.getLogger('sqlalchemy.engine').removeHandler(self.buf) - logging.getLogger('sqlalchemy.engine').setLevel(self.level) - - def testing_engine(self): - e = engines.testing_engine() - - # do an initial execute to clear out 'first connect' - # messages - e.execute(select([10])).close() - self.buf.flush() - - return e - - def test_levels(self): - e1 = engines.testing_engine() - - eq_(e1._should_log_info(), False) - eq_(e1._should_log_debug(), False) - eq_(e1.logger.isEnabledFor(logging.INFO), False) - eq_(e1.logger.getEffectiveLevel(), logging.WARN) - - e1.echo = True - eq_(e1._should_log_info(), True) - eq_(e1._should_log_debug(), False) - eq_(e1.logger.isEnabledFor(logging.INFO), True) - eq_(e1.logger.getEffectiveLevel(), logging.INFO) - - e1.echo = 'debug' - eq_(e1._should_log_info(), True) - eq_(e1._should_log_debug(), True) - eq_(e1.logger.isEnabledFor(logging.DEBUG), True) - eq_(e1.logger.getEffectiveLevel(), logging.DEBUG) - - e1.echo = False - eq_(e1._should_log_info(), False) - eq_(e1._should_log_debug(), False) - eq_(e1.logger.isEnabledFor(logging.INFO), False) - eq_(e1.logger.getEffectiveLevel(), logging.WARN) - - def test_echo_flag_independence(self): - """test the echo flag's independence to a specific engine.""" - - e1 = self.testing_engine() - e2 = self.testing_engine() - - e1.echo = True - e1.execute(select([1])).close() - e2.execute(select([2])).close() - - e1.echo = False - e1.execute(select([3])).close() - e2.execute(select([4])).close() - - e2.echo = True - e1.execute(select([5])).close() - e2.execute(select([6])).close() - - assert self.buf.buffer[0].getMessage().startswith("SELECT 1") - assert self.buf.buffer[2].getMessage().startswith("SELECT 6") - assert len(self.buf.buffer) == 4 class MockStrategyTest(fixtures.TestBase): def _engine_fixture(self): @@ -912,6 +684,7 @@ class MockStrategyTest(fixtures.TestBase): ) class ResultProxyTest(fixtures.TestBase): + __backend__ = True def test_nontuple_row(self): """ensure the C version of BaseRowProxy handles @@ -1171,6 +944,7 @@ class AlternateResultProxyTest(fixtures.TestBase): class EngineEventsTest(fixtures.TestBase): __requires__ = 'ad_hoc_engines', + __backend__ = True def tearDown(self): Engine.dispatch._clear() diff --git a/test/engine/test_logging.py b/test/engine/test_logging.py new file mode 100644 index 000000000..94ea22813 --- /dev/null +++ b/test/engine/test_logging.py @@ -0,0 +1,255 @@ +from sqlalchemy.testing import eq_, assert_raises, assert_raises_message, \ + config, is_ +import re +from sqlalchemy.testing.util import picklers +from sqlalchemy.interfaces import ConnectionProxy +from sqlalchemy import MetaData, Integer, String, INT, VARCHAR, func, \ + bindparam, select, event, TypeDecorator, create_engine, Sequence +from sqlalchemy.sql import column, literal +from sqlalchemy.testing.schema import Table, Column +import sqlalchemy as tsa +from sqlalchemy import testing +from sqlalchemy.testing import engines +from sqlalchemy import util +from sqlalchemy.testing.engines import testing_engine +import logging.handlers +from sqlalchemy.dialects.oracle.zxjdbc import ReturningParam +from sqlalchemy.engine import result as _result, default +from sqlalchemy.engine.base import Engine +from sqlalchemy.testing import fixtures +from sqlalchemy.testing.mock import Mock, call, patch + +class LogParamsTest(fixtures.TestBase): + __only_on__ = 'sqlite' + __requires__ = 'ad_hoc_engines', + + def setup(self): + self.eng = engines.testing_engine(options={'echo':True}) + self.eng.execute("create table foo (data string)") + self.buf = logging.handlers.BufferingHandler(100) + for log in [ + logging.getLogger('sqlalchemy.engine'), + logging.getLogger('sqlalchemy.pool') + ]: + log.addHandler(self.buf) + + def teardown(self): + self.eng.execute("drop table foo") + for log in [ + logging.getLogger('sqlalchemy.engine'), + logging.getLogger('sqlalchemy.pool') + ]: + log.removeHandler(self.buf) + + def test_log_large_dict(self): + self.eng.execute( + "INSERT INTO foo (data) values (:data)", + [{"data":str(i)} for i in range(100)] + ) + eq_( + self.buf.buffer[1].message, + "[{'data': '0'}, {'data': '1'}, {'data': '2'}, {'data': '3'}, " + "{'data': '4'}, {'data': '5'}, {'data': '6'}, {'data': '7'}" + " ... displaying 10 of 100 total bound " + "parameter sets ... {'data': '98'}, {'data': '99'}]" + ) + + def test_log_large_list(self): + self.eng.execute( + "INSERT INTO foo (data) values (?)", + [(str(i), ) for i in range(100)] + ) + eq_( + self.buf.buffer[1].message, + "[('0',), ('1',), ('2',), ('3',), ('4',), ('5',), " + "('6',), ('7',) ... displaying 10 of 100 total " + "bound parameter sets ... ('98',), ('99',)]" + ) + + def test_error_large_dict(self): + assert_raises_message( + tsa.exc.DBAPIError, + r".*'INSERT INTO nonexistent \(data\) values \(:data\)' " + "\[{'data': '0'}, {'data': '1'}, {'data': '2'}, " + "{'data': '3'}, {'data': '4'}, {'data': '5'}, " + "{'data': '6'}, {'data': '7'} ... displaying 10 of " + "100 total bound parameter sets ... {'data': '98'}, {'data': '99'}\]", + lambda: self.eng.execute( + "INSERT INTO nonexistent (data) values (:data)", + [{"data":str(i)} for i in range(100)] + ) + ) + + def test_error_large_list(self): + assert_raises_message( + tsa.exc.DBAPIError, + r".*INSERT INTO nonexistent \(data\) values " + "\(\?\)' \[\('0',\), \('1',\), \('2',\), \('3',\), " + "\('4',\), \('5',\), \('6',\), \('7',\) ... displaying " + "10 of 100 total bound parameter sets ... " + "\('98',\), \('99',\)\]", + lambda: self.eng.execute( + "INSERT INTO nonexistent (data) values (?)", + [(str(i), ) for i in range(100)] + ) + ) + +class LoggingNameTest(fixtures.TestBase): + __requires__ = 'ad_hoc_engines', + + def _assert_names_in_execute(self, eng, eng_name, pool_name): + eng.execute(select([1])) + assert self.buf.buffer + for name in [b.name for b in self.buf.buffer]: + assert name in ( + 'sqlalchemy.engine.base.Engine.%s' % eng_name, + 'sqlalchemy.pool.%s.%s' % + (eng.pool.__class__.__name__, pool_name) + ) + + def _assert_no_name_in_execute(self, eng): + eng.execute(select([1])) + assert self.buf.buffer + for name in [b.name for b in self.buf.buffer]: + assert name in ( + 'sqlalchemy.engine.base.Engine', + 'sqlalchemy.pool.%s' % eng.pool.__class__.__name__ + ) + + def _named_engine(self, **kw): + options = { + 'logging_name':'myenginename', + 'pool_logging_name':'mypoolname', + 'echo':True + } + options.update(kw) + return engines.testing_engine(options=options) + + def _unnamed_engine(self, **kw): + kw.update({'echo':True}) + return engines.testing_engine(options=kw) + + def setup(self): + self.buf = logging.handlers.BufferingHandler(100) + for log in [ + logging.getLogger('sqlalchemy.engine'), + logging.getLogger('sqlalchemy.pool') + ]: + log.addHandler(self.buf) + + def teardown(self): + for log in [ + logging.getLogger('sqlalchemy.engine'), + logging.getLogger('sqlalchemy.pool') + ]: + log.removeHandler(self.buf) + + def test_named_logger_names(self): + eng = self._named_engine() + eq_(eng.logging_name, "myenginename") + eq_(eng.pool.logging_name, "mypoolname") + + def test_named_logger_names_after_dispose(self): + eng = self._named_engine() + eng.execute(select([1])) + eng.dispose() + eq_(eng.logging_name, "myenginename") + eq_(eng.pool.logging_name, "mypoolname") + + def test_unnamed_logger_names(self): + eng = self._unnamed_engine() + eq_(eng.logging_name, None) + eq_(eng.pool.logging_name, None) + + def test_named_logger_execute(self): + eng = self._named_engine() + self._assert_names_in_execute(eng, "myenginename", "mypoolname") + + def test_named_logger_echoflags_execute(self): + eng = self._named_engine(echo='debug', echo_pool='debug') + self._assert_names_in_execute(eng, "myenginename", "mypoolname") + + def test_named_logger_execute_after_dispose(self): + eng = self._named_engine() + eng.execute(select([1])) + eng.dispose() + self._assert_names_in_execute(eng, "myenginename", "mypoolname") + + def test_unnamed_logger_execute(self): + eng = self._unnamed_engine() + self._assert_no_name_in_execute(eng) + + def test_unnamed_logger_echoflags_execute(self): + eng = self._unnamed_engine(echo='debug', echo_pool='debug') + self._assert_no_name_in_execute(eng) + +class EchoTest(fixtures.TestBase): + __requires__ = 'ad_hoc_engines', + + def setup(self): + self.level = logging.getLogger('sqlalchemy.engine').level + logging.getLogger('sqlalchemy.engine').setLevel(logging.WARN) + self.buf = logging.handlers.BufferingHandler(100) + logging.getLogger('sqlalchemy.engine').addHandler(self.buf) + + def teardown(self): + logging.getLogger('sqlalchemy.engine').removeHandler(self.buf) + logging.getLogger('sqlalchemy.engine').setLevel(self.level) + + def testing_engine(self): + e = engines.testing_engine() + + # do an initial execute to clear out 'first connect' + # messages + e.execute(select([10])).close() + self.buf.flush() + + return e + + def test_levels(self): + e1 = engines.testing_engine() + + eq_(e1._should_log_info(), False) + eq_(e1._should_log_debug(), False) + eq_(e1.logger.isEnabledFor(logging.INFO), False) + eq_(e1.logger.getEffectiveLevel(), logging.WARN) + + e1.echo = True + eq_(e1._should_log_info(), True) + eq_(e1._should_log_debug(), False) + eq_(e1.logger.isEnabledFor(logging.INFO), True) + eq_(e1.logger.getEffectiveLevel(), logging.INFO) + + e1.echo = 'debug' + eq_(e1._should_log_info(), True) + eq_(e1._should_log_debug(), True) + eq_(e1.logger.isEnabledFor(logging.DEBUG), True) + eq_(e1.logger.getEffectiveLevel(), logging.DEBUG) + + e1.echo = False + eq_(e1._should_log_info(), False) + eq_(e1._should_log_debug(), False) + eq_(e1.logger.isEnabledFor(logging.INFO), False) + eq_(e1.logger.getEffectiveLevel(), logging.WARN) + + def test_echo_flag_independence(self): + """test the echo flag's independence to a specific engine.""" + + e1 = self.testing_engine() + e2 = self.testing_engine() + + e1.echo = True + e1.execute(select([1])).close() + e2.execute(select([2])).close() + + e1.echo = False + e1.execute(select([3])).close() + e2.execute(select([4])).close() + + e2.echo = True + e1.execute(select([5])).close() + e2.execute(select([6])).close() + + assert self.buf.buffer[0].getMessage().startswith("SELECT 1") + assert self.buf.buffer[2].getMessage().startswith("SELECT 6") + assert len(self.buf.buffer) == 4 diff --git a/test/engine/test_reflection.py b/test/engine/test_reflection.py index a53893549..1db37851d 100644 --- a/test/engine/test_reflection.py +++ b/test/engine/test_reflection.py @@ -15,6 +15,7 @@ from sqlalchemy.util import ue metadata, users = None, None class ReflectionTest(fixtures.TestBase, ComparesTables): + __backend__ = True @testing.exclude('mssql', '<', (10, 0, 0), 'Date is only supported on MSSQL 2008+') @@ -1016,6 +1017,7 @@ class ReflectionTest(fixtures.TestBase, ComparesTables): _drop_views(metadata.bind) class CreateDropTest(fixtures.TestBase): + __backend__ = True @classmethod def setup_class(cls): @@ -1103,6 +1105,8 @@ class CreateDropTest(fixtures.TestBase): metadata.drop_all(bind=testing.db) class SchemaManipulationTest(fixtures.TestBase): + __backend__ = True + def test_append_constraint_unique(self): meta = MetaData() @@ -1119,6 +1123,8 @@ class SchemaManipulationTest(fixtures.TestBase): assert addresses.constraints == set([addresses.primary_key, fk]) class UnicodeReflectionTest(fixtures.TestBase): + __backend__ = True + @classmethod def setup_class(cls): cls.metadata = metadata = MetaData() @@ -1226,6 +1232,7 @@ class UnicodeReflectionTest(fixtures.TestBase): ) class SchemaTest(fixtures.TestBase): + __backend__ = True @testing.requires.schemas @testing.requires.cross_schema_fk_reflection @@ -1430,6 +1437,7 @@ def _drop_views(con, schema=None): class ReverseCasingReflectTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' + __backend__ = True @testing.requires.denormalized_names def setup(self): @@ -1456,6 +1464,7 @@ class ReverseCasingReflectTest(fixtures.TestBase, AssertsCompiledSQL): class CaseSensitiveTest(fixtures.TablesTest): """Nail down case sensitive behaviors, mostly on MySQL.""" + __backend__ = True @classmethod def define_tables(cls, metadata): @@ -1502,6 +1511,7 @@ class CaseSensitiveTest(fixtures.TablesTest): class ColumnEventsTest(fixtures.RemovesEvents, fixtures.TestBase): + __backend__ = True @classmethod def setup_class(cls): diff --git a/test/engine/test_transaction.py b/test/engine/test_transaction.py index c373133d1..ee626a50e 100644 --- a/test/engine/test_transaction.py +++ b/test/engine/test_transaction.py @@ -15,6 +15,8 @@ from sqlalchemy.testing import fixtures users, metadata = None, None class TransactionTest(fixtures.TestBase): + __backend__ = True + @classmethod def setup_class(cls): global users, metadata @@ -412,6 +414,8 @@ class TransactionTest(fixtures.TestBase): eq_(result.fetchall(), []) class ResetAgentTest(fixtures.TestBase): + __backend__ = True + def test_begin_close(self): with testing.db.connect() as connection: trans = connection.begin() @@ -513,6 +517,7 @@ class ResetAgentTest(fixtures.TestBase): assert connection.connection._reset_agent is None class AutoRollbackTest(fixtures.TestBase): + __backend__ = True @classmethod def setup_class(cls): @@ -678,6 +683,7 @@ tlengine = None class TLTransactionTest(fixtures.TestBase): __requires__ = ('ad_hoc_engines', ) + __backend__ = True @classmethod def setup_class(cls): @@ -1124,6 +1130,7 @@ counters = None class ForUpdateTest(fixtures.TestBase): __requires__ = 'ad_hoc_engines', + __backend__ = True @classmethod def setup_class(cls): @@ -1254,6 +1261,7 @@ class ForUpdateTest(fixtures.TestBase): class IsolationLevelTest(fixtures.TestBase): __requires__ = ('isolation_level', 'ad_hoc_engines') + __backend__ = True def _default_isolation_level(self): if testing.against('sqlite'): -- cgit v1.2.1