sqlalchemy.testing.mock.Mock

Here are the examples of the python api sqlalchemy.testing.mock.Mock taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

98 Examples 7

Page 1 Selected Page 2

Example 1

Project: sqlalchemy Source File: test_ddlevents.py
    def test_metadata_create_after(self):
        metadata, bind = self.metadata, self.bind
        canary = mock.Mock()
        event.listen(metadata, 'after_create', canary.after_create)

        metadata.create_all(bind)
        metadata.drop_all(bind)
        eq_(
            canary.mock_calls,
            [
                mock.call.after_create(
                    metadata, self.bind, checkfirst=False,
                    tables=list(metadata.tables.values()),
                    _ddl_runner=mock.ANY),
            ]
        )

Example 2

Project: sqlalchemy Source File: test_bind.py
    def test_bind_base_table_joined_sub_class(self):
        base_class_bind = Mock()
        session = self._fixture({
            self.tables.base_table: base_class_bind
        })

        is_(
            session.get_bind(self.classes.BaseClass),
            base_class_bind
        )
        is_(
            session.get_bind(self.classes.JoinedSubClass),
            base_class_bind
        )

Example 3

Project: sqlalchemy Source File: test_events.py
    def test_clslevel_subclass(self):
        Target = self._fixture()

        class SubTarget(Target):
            pass

        m1 = Mock()

        event.listen(Target, "event_two", m1)

        t1 = SubTarget()
        t1.dispatch.event_two("x")

        event.remove(Target, "event_two", m1)

        t1.dispatch.event_two("y")

        eq_(m1.mock_calls, [call("x")])

Example 4

Project: sqlalchemy Source File: test_ddlevents.py
    def test_table_create_both(self):
        table, bind = self.table, self.bind
        canary = mock.Mock()
        event.listen(table, 'before_create', canary.before_create)
        event.listen(table, 'after_create', canary.after_create)

        table.create(bind)
        table.drop(bind)
        eq_(
            canary.mock_calls,
            [
                mock.call.before_create(
                    table, self.bind, checkfirst=False,
                    _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY),
                mock.call.after_create(
                    table, self.bind, checkfirst=False,
                    _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY)
            ]
        )

Example 5

Project: sqlalchemy Source File: test_events.py
    def test_remove_wrapped_named(self):
        Target = self._wrapped_fixture()

        listen_one = Mock()
        t1 = Target()
        event.listen(t1, "event_one", listen_one, named=True)
        t1.dispatch.event_one("t1")

        eq_(listen_one.mock_calls, [call(x="adapted t1")])
        event.remove(t1, "event_one", listen_one)
        t1.dispatch.event_one("t2")

        eq_(listen_one.mock_calls, [call(x="adapted t1")])

Example 6

Project: sqlalchemy Source File: test_events.py
    def test_parent_class_only(self):
        l1 = Mock()

        event.listen(self.TargetFactory, "event_one", l1)

        element = self.TargetFactory().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)]
        )

Example 7

Project: sqlalchemy Source File: test_reconnect.py
    def test_invalidate_dont_call_finalizer(self):
        conn = self.db.connect()
        finalizer = mock.Mock()
        conn.connection._connection_record.\
            finalize_callback.append(finalizer)
        conn.invalidate()
        assert conn.invalidated
        eq_(finalizer.call_count, 0)

Example 8

Project: sqlalchemy Source File: test_events.py
    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)]
        )

Example 9

Project: sqlalchemy Source File: test_bind.py
    def test_bind_sub_table_concrete_sub_class(self):
        base_class_bind = Mock(name='base')
        concrete_sub_bind = Mock(name='concrete')

        session = self._fixture({
            self.tables.base_table: base_class_bind,
            self.tables.concrete_sub_table: concrete_sub_bind
        })

        is_(
            session.get_bind(self.classes.BaseClass),
            base_class_bind
        )
        is_(
            session.get_bind(self.classes.ConcreteSubClass),
            concrete_sub_bind
        )

Example 10

Project: sqlalchemy Source File: test_events.py
    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})]
        )

Example 11

Project: sqlalchemy Source File: test_ddlevents.py
    def test_table_create_before(self):
        table, bind = self.table, self.bind
        canary = mock.Mock()
        event.listen(table, 'before_create', canary.before_create)

        table.create(bind)
        table.drop(bind)
        eq_(
            canary.mock_calls,
            [
                mock.call.before_create(
                    table, self.bind, checkfirst=False,
                    _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY)
            ]
        )

Example 12

Project: sqlalchemy Source File: test_engine.py
    def test_legacy_schema_flag(self):
        cfg = {
            "sqlalchemy.url": "mssql://foodsn",
            "sqlalchemy.legacy_schema_aliasing": "false"
        }
        e = engine_from_config(
            cfg, module=Mock(version="MS SQL Server 11.0.92"))
        eq_(e.dialect.legacy_schema_aliasing, False)

Example 13

Project: sqlalchemy Source File: test_events.py
    def test_remove_instancelevel(self):
        listen_one = Mock()
        t1 = self.Target()
        event.listen(t1, "event_one", listen_one, add=True)
        t1.dispatch.event_one(5, 7)
        eq_(
            listen_one.mock_calls,
            [call(12)]
        )
        event.remove(t1, "event_one", listen_one)
        t1.dispatch.event_one(10, 5)
        eq_(
            listen_one.mock_calls,
            [call(12)]
        )

Example 14

Project: sqlalchemy Source File: test_ddlevents.py
    def test_table_drop_after(self):
        table, bind = self.table, self.bind
        canary = mock.Mock()
        event.listen(table, 'after_drop', canary.after_drop)

        table.create(bind)
        canary.state = 'skipped'
        table.drop(bind)
        eq_(
            canary.mock_calls,
            [
                mock.call.after_drop(
                    table, self.bind, checkfirst=False,
                    _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY),
            ]
        )

Example 15

Project: sqlalchemy Source File: test_events.py
    def test_legacy_accept_partial(self):
        canary = Mock()

        def evt(a, x, y, **kw):
            canary(a, x, y, **kw)
        from functools import partial
        evt_partial = partial(evt, 5)
        target = self.TargetOne()
        event.listen(target, "event_four", evt_partial)
        # can't do legacy accept on a partial; we can't inspect it
        assert_raises(
            TypeError,
            target.dispatch.event_four, 4, 5, 6, 7, foo="bar"
        )
        target.dispatch.event_four(4, 5, foo="bar")
        eq_(
            canary.mock_calls,
            [call(5, 4, 5, foo="bar")]
        )

Example 16

Project: sqlalchemy Source File: test_ddlevents.py
    def test_metadata_drop_after(self):
        metadata, bind = self.metadata, self.bind
        canary = mock.Mock()
        event.listen(metadata, 'after_drop', canary.after_drop)

        metadata.create_all(bind)
        metadata.drop_all(bind)
        eq_(
            canary.mock_calls,
            [
                mock.call.after_drop(
                    metadata, self.bind, checkfirst=False,
                    tables=list(metadata.tables.values()),
                    _ddl_runner=mock.ANY),
            ]
        )

Example 17

Project: sqlalchemy Source File: test_events.py
    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)]
        )

Example 18

Project: sqlalchemy Source File: test_automap.py
    def test_prepare_defaults_to_no_schema(self):
        """
        The underlying reflect call accepts an optional schema argument.
        This is for determining which database schema to load.
        This test verifies that prepare passes a default None if no schema is provided.
        """
        Base = automap_base(metadata=self.metadata)
        engine_mock = Mock()
        with patch.object(Base.metadata, "reflect") as reflect_mock:
            Base.prepare(engine_mock, reflect=True)
            reflect_mock.assert_called_once_with(
                engine_mock,
                schema=None,
                extend_existing=True,
                autoload_replace=False,
            )

Example 19

Project: sqlalchemy Source File: test_events.py
    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})]
        )

Example 20

Project: sqlalchemy Source File: test_bind.py
    def test_bind_base_table_concrete_sub_class(self):
        base_class_bind = Mock()
        session = self._fixture({
            self.tables.base_table: base_class_bind
        })

        is_(
            session.get_bind(self.classes.ConcreteSubClass),
            testing.db
        )

Example 21

Project: sqlalchemy Source File: test_events.py
    def test_no_add_in_event(self):
        Target = self._fixture()

        t1 = Target()

        m1 = Mock()

        def evt():
            event.listen(t1, "event_one", m1)

        event.listen(t1, "event_one", evt)

        assert_raises_message(
            Exception,
            "deque mutated during iteration",
            t1.dispatch.event_one
        )

Example 22

Project: sqlalchemy Source File: test_events.py
    def test_remove_plain_named(self):
        Target = self._fixture()

        listen_one = Mock()
        t1 = Target()
        event.listen(t1, "event_one", listen_one, named=True)
        t1.dispatch.event_one("t1")

        eq_(listen_one.mock_calls, [call(x="t1")])
        event.remove(t1, "event_one", listen_one)
        t1.dispatch.event_one("t2")

        eq_(listen_one.mock_calls, [call(x="t1")])

Example 23

Project: sqlalchemy Source File: test_events.py
    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)]
        )

Example 24

Project: sqlalchemy Source File: test_events.py
    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")])

Example 25

Project: sqlalchemy Source File: test_events.py
    def test_kw_accept_plus_kw_has_legacies(self):
        canary = Mock()

        @event.listens_for(self.TargetOne, "event_four", named=True)
        def handler1(**kw):
            canary(kw)

        self.TargetOne().dispatch.event_four(4, 5, 6, 7, foo="bar")

        eq_(
            canary.mock_calls,
            [call({"x": 4, "y": 5, "z": 6, "q": 7, "foo": "bar"})]
        )

Example 26

Project: sqlalchemy Source File: test_mxodbc.py
Function: mock_dbapi
def mock_dbapi():
    return Mock(paramstyle='qmark',
                connect=Mock(
                        return_value=Mock(
                            cursor=Mock(
                                return_value=Mock(
                                                description=None,
                                                rowcount=None)
                                )
                        )
                )
            )

Example 27

Project: sqlalchemy Source File: test_engine.py
    def test_pymssql_version(self):
        dialect = pymssql.MSDialect_pymssql()

        for vers in [
            "Microsoft SQL Server Blah - 11.0.9216.62",
            "Microsoft SQL Server (XYZ) - 11.0.9216.62 \n"
            "Jul 18 2014 22:00:21 \nCopyright (c) Microsoft Corporation",
            "Microsoft SQL Azure (RTM) - 11.0.9216.62 \n"
            "Jul 18 2014 22:00:21 \nCopyright (c) Microsoft Corporation"
        ]:
            conn = Mock(scalar=Mock(return_value=vers))
            eq_(
                dialect._get_server_version_info(conn),
                (11, 0, 9216, 62)
            )

Example 28

Project: sqlalchemy Source File: test_events.py
    def test_remove_clslevel(self):
        listen_one = Mock()
        event.listen(self.Target, "event_one", listen_one, add=True)
        t1 = self.Target()
        t1.dispatch.event_one(5, 7)
        eq_(
            listen_one.mock_calls,
            [call(12)]
        )
        event.remove(self.Target, "event_one", listen_one)
        t1.dispatch.event_one(10, 5)
        eq_(
            listen_one.mock_calls,
            [call(12)]
        )

Example 29

Project: sqlalchemy Source File: test_ddlevents.py
    def test_table_create_after(self):
        table, bind = self.table, self.bind
        canary = mock.Mock()
        event.listen(table, 'after_create', canary.after_create)

        table.create(bind)
        table.drop(bind)
        eq_(
            canary.mock_calls,
            [
                mock.call.after_create(
                    table, self.bind, checkfirst=False,
                    _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY)
            ]
        )

Example 30

Project: sqlalchemy Source File: test_events.py
    def test_legacy_accept_kw_instance(self):
        canary = Mock()

        inst = self.TargetOne()

        @event.listens_for(inst, "event_four")
        def handler1(x, y, **kw):
            canary(x, y, kw)
        self._test_legacy_accept_kw(inst, canary)

Example 31

Project: sqlalchemy Source File: test_ddlevents.py
    def test_table_drop_before(self):
        table, bind = self.table, self.bind
        canary = mock.Mock()
        event.listen(table, 'before_drop', canary.before_drop)

        table.create(bind)
        table.drop(bind)
        eq_(
            canary.mock_calls,
            [
                mock.call.before_drop(
                    table, self.bind, checkfirst=False,
                    _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY),
            ]
        )

Example 32

Project: sqlalchemy Source File: test_events.py
    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}),
            ]
        )

Example 33

Project: sqlalchemy Source File: test_ddlevents.py
    def test_metadata_create_before(self):
        metadata, bind = self.metadata, self.bind
        canary = mock.Mock()
        event.listen(metadata, 'before_create', canary.before_create)

        metadata.create_all(bind)
        metadata.drop_all(bind)
        eq_(
            canary.mock_calls,
            [
                mock.call.before_create(
                    # checkfirst is False because of the MockConnection
                    # used in the current testing strategy.
                    metadata, self.bind, checkfirst=False,
                    tables=list(metadata.tables.values()),
                    _ddl_runner=mock.ANY),
            ]
        )

Example 34

Project: sqlalchemy Source File: test_events.py
    def test_partial_kw_accept_wrapped(self):
        TargetOne = self._wrapped_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('adapted 6', 'adapted 5',
             {'q': 'adapted 7', 'x': 'adapted 4'})]
        )

Example 35

Project: sqlalchemy Source File: test_ddlevents.py
    def test_metadata_drop_before(self):
        metadata, bind = self.metadata, self.bind
        canary = mock.Mock()
        event.listen(metadata, 'before_drop', canary.before_drop)

        metadata.create_all(bind)
        metadata.drop_all(bind)
        eq_(
            canary.mock_calls,
            [
                mock.call.before_drop(
                    metadata, self.bind, checkfirst=False,
                    tables=list(metadata.tables.values()),
                    _ddl_runner=mock.ANY),
            ]
        )

Example 36

Project: sqlalchemy Source File: test_events.py
    def test_parent_class_child_class(self):
        l1 = Mock()
        l2 = Mock()

        event.listen(self.TargetFactory, "event_one", l1)
        event.listen(self.TargetElement, "event_one", l2)

        element = self.TargetFactory().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)]
        )
        eq_(
            l2.mock_calls,
            [call(element, 1), call(element, 2), call(element, 3)]
        )

Example 37

Project: sqlalchemy Source File: test_parseconnect.py
Function: mock_dbapi
def MockDBAPI(**assert_kwargs):
    connection = Mock(get_server_version_info=Mock(return_value='5.0'))

    def connect(*args, **kwargs):
        for k in assert_kwargs:
            assert k in kwargs, 'key %s not present in dictionary' % k
            eq_(
                kwargs[k], assert_kwargs[k]
            )
        return connection

    return MagicMock(
        sqlite_version_info=(99, 9, 9,),
        version_info=(99, 9, 9,),
        sqlite_version='99.9.9',
        paramstyle='named',
        connect=Mock(side_effect=connect)
    )

Example 38

Project: sqlalchemy Source File: test_events.py
    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)]
        )

Example 39

Project: sqlalchemy Source File: test_automap.py
    def test_prepare_accepts_optional_schema_arg(self):
        """
        The underlying reflect call accepts an optional schema argument.
        This is for determining which database schema to load.
        This test verifies that prepare can accept an optiona schema argument
        and pass it to reflect.
        """
        Base = automap_base(metadata=self.metadata)
        engine_mock = Mock()
        with patch.object(Base.metadata, "reflect") as reflect_mock:
            Base.prepare(engine_mock, reflect=True, schema="some_schema")
            reflect_mock.assert_called_once_with(
                engine_mock,
                schema="some_schema",
                extend_existing=True,
                autoload_replace=False,
            )

Example 40

Project: sqlalchemy Source File: test_events.py
Function: test_clslevel
    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")])

Example 41

Project: sqlalchemy Source File: test_bind.py
    def test_bind_base_table_base_class(self):
        base_class_bind = Mock()
        session = self._fixture({
            self.tables.base_table: base_class_bind
        })

        is_(
            session.get_bind(self.classes.BaseClass),
            base_class_bind
        )

Example 42

Project: sqlalchemy Source File: test_events.py
    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'})]
        )

Example 43

Project: sqlalchemy Source File: test_bind.py
    def test_bind_joined_sub_table_joined_sub_class(self):
        base_class_bind = Mock(name='base')
        joined_class_bind = Mock(name='joined')
        session = self._fixture({
            self.tables.base_table: base_class_bind,
            self.tables.joined_sub_table: joined_class_bind
        })

        is_(
            session.get_bind(self.classes.BaseClass),
            base_class_bind
        )
        # joined table inheritance has to query based on the base
        # table, so this is what we expect
        is_(
            session.get_bind(self.classes.JoinedSubClass),
            base_class_bind
        )

Example 44

Project: sqlalchemy Source File: test_events.py
    def test_remove_not_listened(self):
        Target = self._fixture()

        m1 = Mock()

        t1 = Target()

        event.listen(t1, "event_one", m1, propagate=True)
        event.listen(t1, "event_three", m1)

        event.remove(t1, "event_one", m1)
        assert_raises_message(
            exc.InvalidRequestError,
            r"No listeners found for event <.*Target.*> / "
            r"'event_two' / <Mock.*> ",
            event.remove, t1, "event_two", m1
        )

        event.remove(t1, "event_three", m1)

Example 45

Project: sqlalchemy Source File: test_events.py
    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)]
        )

Example 46

Project: sqlalchemy Source File: test_events.py
    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})]
        )

Example 47

Project: sqlalchemy Source File: test_events.py
    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})]
        )

Example 48

Project: sqlalchemy Source File: test_events.py
    def test_legacy_accept_kw_cls(self):
        canary = Mock()

        @event.listens_for(self.TargetOne, "event_four")
        def handler1(x, y, **kw):
            canary(x, y, kw)
        self._test_legacy_accept_kw(self.TargetOne(), canary)

Example 49

Project: sqlalchemy Source File: test_events.py
    def test_listen_override(self):
        listen_one = Mock()
        listen_two = Mock()

        event.listen(self.Target, "event_one", listen_one, add=True)
        event.listen(self.Target, "event_one", listen_two)

        t1 = self.Target()
        t1.dispatch.event_one(5, 7)
        t1.dispatch.event_one(10, 5)

        eq_(
            listen_one.mock_calls,
            [call(12), call(15)]
        )
        eq_(
            listen_two.mock_calls,
            [call(5, 7), call(10, 5)]
        )

Example 50

Project: sqlalchemy Source File: test_firebird.py
Function: db_api
    def _dbapi(self):
        return Mock(
                    paramstyle='qmark',
                    connect=Mock(
                            return_value=Mock(
                                server_version="UI-V6.3.2.18118 Firebird 2.1",
                                cursor=Mock(return_value=Mock())
                            )
                    )
                )
See More Examples - Go to Next Page
Page 1 Selected Page 2