def test_owner_database_pairs(self, identifier, expected_schema, expected_owner, use_stmt): dialect = mssql.dialect() schema, owner = base._owner_plus_db(dialect, identifier) eq_(owner, expected_owner) eq_(schema, expected_schema) mock_connection = mock.Mock( dialect=dialect, scalar=mock.Mock(return_value="Some Database"), ) mock_lambda = mock.Mock() base._switch_db(schema, mock_connection, mock_lambda, "x", y="bar") if schema is None: eq_(mock_connection.mock_calls, []) else: eq_( mock_connection.mock_calls, [ mock.call.scalar("select db_name()"), mock.call.execute(use_stmt), mock.call.execute("use [Some Database]"), ], ) eq_(mock_lambda.mock_calls, [mock.call("x", y="bar")])
def test_standard_accept_has_legacies(self): canary = Mock() event.listen(self.TargetOne, "event_three", canary) self.TargetOne().dispatch.event_three(4, 5) eq_(canary.mock_calls, [call(4, 5)])
def test_cache_ok_for_event(self, modify_query_fixture): m1 = modify_query_fixture(True) User, Address = self._o2m_fixture() sess = Session() u1 = sess.query(User).filter(User.id == 7).first() u1.addresses eq_(m1.mock_calls, [mock.call(User), mock.call(Address)]) sess.expire(u1, ["addresses"]) u1.addresses eq_(m1.mock_calls, [mock.call(User), mock.call(Address)])
def test_parent_events_child_no_events(self): l1 = Mock() factory = self.TargetFactory() event.listen(self.TargetElement, "event_one", l1) element = factory.create() element.run_event(1) element.run_event(2) element.run_event(3) eq_( l1.mock_calls, [call(element, 1), call(element, 2), call(element, 3)], )
def test_complex_legacy_accept(self): canary = Mock() @event.listens_for(self.TargetOne, "event_six") def handler1(x, y, z, q): canary(x, y, z, q) self.TargetOne().dispatch.event_six(4, 5) eq_(canary.mock_calls, [call(4, 5, 9, 20)])
def test_cursor_shutdown_in_initialize(self): db = self._fixture(True, True) assert_raises_message_context_ok(exc.SAWarning, "Exception attempting to detect", db.connect) eq_( db.pool.logger.error.mock_calls, [call("Error closing cursor", exc_info=True)], )
def test_double_event_nonwrapped(self): Target = self._fixture() listen_one = Mock() t1 = Target() event.listen(t1, "event_one", listen_one) event.listen(t1, "event_one", listen_one) t1.dispatch.event_one("t1") # doubles are eliminated eq_(listen_one.mock_calls, [call("t1")]) # only one remove needed event.remove(t1, "event_one", listen_one) t1.dispatch.event_one("t2") eq_(listen_one.mock_calls, [call("t1")])
def test_legacy_accept(self): canary = Mock() @event.listens_for(self.TargetOne, "event_three") def handler1(x, y): canary(x, y) self.TargetOne().dispatch.event_three(4, 5, 6, 7) eq_(canary.mock_calls, [call(4, 5)])
def test_cursor_explode(self): db = self._fixture(False, False) conn = db.connect() result = conn.execute("select foo") result.close() conn.close() eq_( db.pool.logger.error.mock_calls, [call("Error closing cursor", exc_info=True)], )
def test_kw_accept_has_legacies(self): canary = Mock() @event.listens_for(self.TargetOne, "event_three", named=True) def handler1(**kw): canary(kw) self.TargetOne().dispatch.event_three(4, 5, 6, 7) eq_(canary.mock_calls, [call({"x": 4, "y": 5, "z": 6, "q": 7})])
def test_kw_accept_plus_kw(self): TargetOne = self._fixture() canary = Mock() @event.listens_for(TargetOne, "event_two", named=True) def handler1(**kw): canary(kw) TargetOne().dispatch.event_two(4, 5, z=8, q=5) eq_(canary.mock_calls, [call({"x": 4, "y": 5, "z": 8, "q": 5})])
def test_legacy_accept_from_method(self): canary = Mock() class MyClass(object): def handler1(self, x, y): canary(x, y) event.listen(self.TargetOne, "event_three", MyClass().handler1) self.TargetOne().dispatch.event_three(4, 5, 6, 7) eq_(canary.mock_calls, [call(4, 5)])
def test_parent_class_child_instance_apply_after(self): l1 = Mock() l2 = Mock() event.listen(self.TargetFactory, "event_one", l1) element = self.TargetFactory().create() element.run_event(1) event.listen(element, "event_one", l2) element.run_event(2) element.run_event(3) eq_( l1.mock_calls, [call(element, 1), call(element, 2), call(element, 3)], ) eq_(l2.mock_calls, [call(element, 2), call(element, 3)])
def test_owner_database_pairs_dont_use_for_same_db(self): dialect = mssql.dialect() identifier = "my_db.some_schema" schema, owner = base._owner_plus_db(dialect, identifier) mock_connection = mock.Mock(dialect=dialect, scalar=mock.Mock(return_value="my_db")) mock_lambda = mock.Mock() base._switch_db(schema, mock_connection, mock_lambda, "x", y="bar") eq_(mock_connection.mock_calls, [mock.call.scalar("select db_name()")]) eq_(mock_lambda.mock_calls, [mock.call("x", y="bar")])
def test_partial_kw_accept(self): TargetOne = self._fixture() canary = Mock() @event.listens_for(TargetOne, "event_five", named=True) def handler1(z, y, **kw): canary(z, y, kw) TargetOne().dispatch.event_five(4, 5, 6, 7) eq_(canary.mock_calls, [call(6, 5, {"x": 4, "q": 7})])
def test_kw_accept_wrapped(self): TargetOne = self._wrapped_fixture() canary = Mock() @event.listens_for(TargetOne, "event_one", named=True) def handler1(**kw): canary(kw) TargetOne().dispatch.event_one(4, 5) eq_(canary.mock_calls, [call({"y": "adapted 5", "x": "adapted 4"})])
def test_kw_accept(self): TargetOne = self._fixture() canary = Mock() @event.listens_for(TargetOne, "event_one", named=True) def handler1(**kw): canary(kw) TargetOne().dispatch.event_one(4, 5) eq_(canary.mock_calls, [call({"x": 4, "y": 5})])
def test_custom_bind(self): Address, addresses, users, User = ( self.classes.Address, self.tables.addresses, self.tables.users, self.classes.User, ) mapper( User, users, properties=dict(addresses=relationship( mapper(Address, addresses), lazy="select", primaryjoin=and_( users.c.id == addresses.c.user_id, users.c.name == bindparam("name"), ), )), ) canary = mock.Mock() class MyOption(MapperOption): propagate_to_loaders = True def __init__(self, crit): self.crit = crit def process_query_conditionally(self, query): """process query during a lazyload""" canary() query._params = query._params.union(dict(name=self.crit)) s = Session() ed = s.query(User).options(MyOption("ed")).filter_by(name="ed").one() eq_( ed.addresses, [ Address(id=2, user_id=8), Address(id=3, user_id=8), Address(id=4, user_id=8), ], ) eq_(canary.mock_calls, [mock.call()]) fred = (s.query(User).options( MyOption("ed")).filter_by(name="fred").one()) eq_(fred.addresses, []) # fred is missing eq_(canary.mock_calls, [mock.call(), mock.call()]) # the lazy query was not cached; the option is re-applied to the # Fred object due to populate_existing() fred = (s.query(User).populate_existing().options( MyOption("fred")).filter_by(name="fred").one()) eq_(fred.addresses, [Address(id=5, user_id=9)]) # fred is there eq_(canary.mock_calls, [mock.call(), mock.call(), mock.call()])
def test_kw_ok(self): l1 = Mock() def listen(**kw): l1(kw) event.listen(self.TargetFactory, "event_one", listen, named=True) element = self.TargetFactory().create() element.run_event(1) element.run_event(2) eq_( l1.mock_calls, [ call({ "target": element, "arg": 1 }), call({ "target": element, "arg": 2 }), ], )
def test_max_identifier_length_onconnect(self): eng = engines.testing_engine() def _check_max_identifer_length(conn): return 47 with mock.patch.object( eng.dialect, "_check_max_identifier_length", side_effect=_check_max_identifer_length, ) as mock_: with eng.connect(): eq_(eng.dialect.max_identifier_length, 47) eq_(mock_.mock_calls, [mock.call(mock.ANY)])
def test_modified_event(self): canary = mock.Mock() event.listen(Foo.data, "modified", canary) f1 = Foo(data={"a": "b"}) f1.data["a"] = "c" eq_( canary.mock_calls, [ mock.call( f1, attributes.Event(Foo.data.impl, attributes.OP_MODIFIED)) ], )
def setup(self): self.dbapi = MockDBAPI() self.db = testing_engine( "postgresql://*****:*****@localhost/test", options=dict(module=self.dbapi, _initialize=False), ) self.mock_connect = call(host="localhost", password="******", user="******", database="test") # monkeypatch disconnect checker self.db.dialect.is_disconnect = lambda e, conn, cursor: isinstance( e, MockDisconnect)
def test_conn_reusable(self): conn = self.db.connect() conn.execute(select([1])) eq_(self.dbapi.connect.mock_calls, [self.mock_connect]) self.dbapi.shutdown() assert_raises(tsa.exc.DBAPIError, conn.execute, select([1])) assert not conn.closed assert conn.invalidated eq_([c.close.mock_calls for c in self.dbapi.connections], [[call()]]) # test reconnects conn.execute(select([1])) assert not conn.invalidated eq_( [c.close.mock_calls for c in self.dbapi.connections], [[call()], []], )
def test_clslevel(self): Target = self._fixture() m1 = Mock() event.listen(Target, "event_two", m1) t1 = Target() t1.dispatch.event_two("x") event.remove(Target, "event_two", m1) t1.dispatch.event_two("y") eq_(m1.mock_calls, [call("x")])
def test_insert(self): from psycopg2 import extras if self.engine.dialect.executemany_mode is EXECUTEMANY_BATCH: meth = extras.execute_batch stmt = "INSERT INTO data (x, y) VALUES (%(x)s, %(y)s)" expected_kwargs = {} else: meth = extras.execute_values stmt = "INSERT INTO data (x, y) VALUES %s" expected_kwargs = {"template": "(%(x)s, %(y)s)"} with mock.patch.object( extras, meth.__name__, side_effect=meth ) as mock_exec: with self.engine.connect() as conn: conn.execute( self.tables.data.insert(), [ {"x": "x1", "y": "y1"}, {"x": "x2", "y": "y2"}, {"x": "x3", "y": "y3"}, ], ) eq_( conn.execute(select([self.tables.data])).fetchall(), [ (1, "x1", "y1", 5), (2, "x2", "y2", 5), (3, "x3", "y3", 5), ], ) eq_( mock_exec.mock_calls, [ mock.call( mock.ANY, stmt, ( {"x": "x1", "y": "y1"}, {"x": "x2", "y": "y2"}, {"x": "x3", "y": "y3"}, ), **expected_kwargs ) ], )
def test_insert_page_size(self): from psycopg2 import extras opts = self.options.copy() opts["executemany_batch_page_size"] = 500 opts["executemany_values_page_size"] = 1000 with self.expect_deprecated_opts(): eng = engines.testing_engine(options=opts) if eng.dialect.executemany_mode is EXECUTEMANY_BATCH: meth = extras.execute_batch stmt = "INSERT INTO data (x, y) VALUES (%(x)s, %(y)s)" expected_kwargs = {"page_size": 500} else: meth = extras.execute_values stmt = "INSERT INTO data (x, y) VALUES %s" expected_kwargs = {"page_size": 1000, "template": "(%(x)s, %(y)s)"} with mock.patch.object( extras, meth.__name__, side_effect=meth ) as mock_exec: with eng.connect() as conn: conn.execute( self.tables.data.insert(), [ {"x": "x1", "y": "y1"}, {"x": "x2", "y": "y2"}, {"x": "x3", "y": "y3"}, ], ) eq_( mock_exec.mock_calls, [ mock.call( mock.ANY, stmt, ( {"x": "x1", "y": "y1"}, {"x": "x2", "y": "y2"}, {"x": "x3", "y": "y3"}, ), **expected_kwargs ) ], )
def test_insert_w_newlines(self): from psycopg2 import extras t = self.tables.data ins = t.insert(inline=True).values( id=bindparam("id"), x=select([literal_column("5")]).select_from(self.tables.data), y=bindparam("y"), z=bindparam("z"), ) # compiled SQL has a newline in it eq_( str(ins.compile(testing.db)), "INSERT INTO data (id, x, y, z) VALUES (%(id)s, " "(SELECT 5 \nFROM data), %(y)s, %(z)s)", ) meth = extras.execute_values with mock.patch.object( extras, "execute_values", side_effect=meth ) as mock_exec: with self.engine.connect() as conn: conn.execute( ins, [ {"id": 1, "y": "y1", "z": 1}, {"id": 2, "y": "y2", "z": 2}, {"id": 3, "y": "y3", "z": 3}, ], ) eq_( mock_exec.mock_calls, [ mock.call( mock.ANY, "INSERT INTO data (id, x, y, z) VALUES %s", ( {"id": 1, "y": "y1", "z": 1}, {"id": 2, "y": "y2", "z": 2}, {"id": 3, "y": "y3", "z": 3}, ), template="(%(id)s, (SELECT 5 \nFROM data), %(y)s, %(z)s)", ) ], )
def test_plugin_url_registration(self): from sqlalchemy_1_3.dialects import sqlite global MyEnginePlugin def side_effect(url, kw): eq_( url.query, { "plugin": "engineplugin", "myplugin_arg": "bat", "foo": "bar", }, ) eq_(kw, {"logging_name": "foob"}) kw["logging_name"] = "bar" url.query.pop("myplugin_arg", None) return MyEnginePlugin MyEnginePlugin = Mock(side_effect=side_effect) plugins.register("engineplugin", __name__, "MyEnginePlugin") e = create_engine( "sqlite:///?plugin=engineplugin&foo=bar&myplugin_arg=bat", logging_name="foob", ) eq_(e.dialect.name, "sqlite") eq_(e.logging_name, "bar") # plugin args are removed from URL. eq_(e.url.query, {"foo": "bar"}) assert isinstance(e.dialect, sqlite.dialect) eq_( MyEnginePlugin.mock_calls, [ call(url.make_url("sqlite:///?foo=bar"), {}), call.handle_dialect_kwargs(sqlite.dialect, mock.ANY), call.handle_pool_kwargs(mock.ANY, {"dialect": e.dialect}), call.engine_created(e), ], ) # url was modified in place by MyEnginePlugin eq_(str(MyEnginePlugin.mock_calls[0][1][0]), "sqlite:///?foo=bar")
def test_propagate(self): listen_one = Mock() listen_two = Mock() t1 = self.Target() event.listen(t1, "event_one", listen_one, propagate=True) event.listen(t1, "event_two", listen_two) t2 = self.Target() t2.dispatch._update(t1.dispatch) t2.dispatch.event_one(t2, 1) t2.dispatch.event_two(t2, 2) eq_(listen_one.mock_calls, [call(t2, 1)]) eq_(listen_two.mock_calls, [])
def test_exec_once_exception(self): m1 = Mock() m1.side_effect = ValueError event.listen(self.Target, "event_one", m1) t1 = self.Target() assert_raises( ValueError, t1.dispatch.event_one.for_modify(t1.dispatch).exec_once, 5, 6, ) t1.dispatch.event_one.for_modify(t1.dispatch).exec_once(7, 8) eq_(m1.mock_calls, [call(5, 6)])