unittest.mock

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

19 Examples 7

Example 1

Project: brython Source File: testmock.py
Function: test_java_exception_side_effect
    @unittest.skipUnless('java' in sys.platform,
                          'This test only applies to Jython')
    def test_java_exception_side_effect(self):
        import java
        mock = Mock(side_effect=java.lang.RuntimeException("Boom!"))

        # can't use assertRaises with java exceptions
        try:
            mock(1, 2, fish=3)
        except java.lang.RuntimeException:
            pass
        else:
            self.fail('java exception not raised')
        mock.assert_called_with(1,2, fish=3)

Example 2

Project: brython Source File: testmock.py
    def test_call_args_comparison(self):
        mock = Mock()
        mock()
        mock(sentinel.Arg)
        mock(kw=sentinel.Kwarg)
        mock(sentinel.Arg, kw=sentinel.Kwarg)
        self.assertEqual(mock.call_args_list, [
            (),
            ((sentinel.Arg,),),
            ({"kw": sentinel.Kwarg},),
            ((sentinel.Arg,), {"kw": sentinel.Kwarg})
        ])
        self.assertEqual(mock.call_args,
                         ((sentinel.Arg,), {"kw": sentinel.Kwarg}))

Example 3

Project: brython Source File: testmock.py
    def test_assert_called_with(self):
        mock = Mock()
        mock()

        # Will raise an exception if it fails
        mock.assert_called_with()
        self.assertRaises(AssertionError, mock.assert_called_with, 1)

        mock.reset_mock()
        self.assertRaises(AssertionError, mock.assert_called_with)

        mock(1, 2, 3, a='fish', b='nothing')
        mock.assert_called_with(1, 2, 3, a='fish', b='nothing')

Example 4

Project: brython Source File: testmock.py
    def test_wraps_calls(self):
        real = Mock()

        mock = Mock(wraps=real)
        self.assertEqual(mock(), real())

        real.reset_mock()

        mock(1, 2, fish=3)
        real.assert_called_with(1, 2, fish=3)

Example 5

Project: brython Source File: testmock.py
    def test_setting_call(self):
        mock = Mock()
        def __call__(self, a):
            return self._mock_call(a)

        type(mock).__call__ = __call__
        mock('one')
        mock.assert_called_with('one')

        self.assertRaises(TypeError, mock, 'one', 'two')

Example 6

Project: brython Source File: testmock.py
    def test_call_args_two_tuple(self):
        mock = Mock()
        mock(1, a=3)
        mock(2, b=4)

        self.assertEqual(len(mock.call_args), 2)
        args, kwargs = mock.call_args
        self.assertEqual(args, (2,))
        self.assertEqual(kwargs, dict(b=4))

        expected_list = [((1,), dict(a=3)), ((2,), dict(b=4))]
        for expected, call_args in zip(expected_list, mock.call_args_list):
            self.assertEqual(len(call_args), 2)
            self.assertEqual(expected[0], call_args[0])
            self.assertEqual(expected[1], call_args[1])

Example 7

Project: papyrus Source File: test_protocol.py
Function: test_count
    def test_count(self):
        from papyrus.protocol import Protocol
        try:
            from unittest.mock import patch
        except:
            from mock import patch

        engine = self._get_engine()
        Session = self._get_session(engine)
        MappedClass = self._get_mapped_class()

        proto = Protocol(Session, MappedClass, "geom")

        # We make Query.count return the query and just check it includes
        # "SELECT". Yes, not so good!
        request = testing.DummyRequest()
        with patch('sqlalchemy.orm.query.Query.count', lambda q: q):
            query = proto.count(request)
        self.assertTrue(b"SELECT" in query_to_str(query, engine))

Example 8

Project: sparts Source File: base.py
Function: mock
    @property
    def mock(self):
        if sys.version < '3.3':
            try:
                import mock
                return mock
            except ImportError:
                raise Skip("the mock module is required to run this test")
        else:
            import unittest.mock
            return unittest.mock

Example 9

Project: brython Source File: testmock.py
    def test_reset_mock(self):
        parent = Mock()
        spec = ["something"]
        mock = Mock(name="child", parent=parent, spec=spec)
        mock(sentinel.Something, something=sentinel.SomethingElse)
        something = mock.something
        mock.something()
        mock.side_effect = sentinel.SideEffect
        return_value = mock.return_value
        return_value()

        mock.reset_mock()

        self.assertEqual(mock._mock_name, "child",
                         "name incorrectly reset")
        self.assertEqual(mock._mock_parent, parent,
                         "parent incorrectly reset")
        self.assertEqual(mock._mock_methods, spec,
                         "methods incorrectly reset")

        self.assertFalse(mock.called, "called not reset")
        self.assertEqual(mock.call_count, 0, "call_count not reset")
        self.assertEqual(mock.call_args, None, "call_args not reset")
        self.assertEqual(mock.call_args_list, [], "call_args_list not reset")
        self.assertEqual(mock.method_calls, [],
                        "method_calls not initialised correctly: %r != %r" %
                        (mock.method_calls, []))
        self.assertEqual(mock.mock_calls, [])

        self.assertEqual(mock.side_effect, sentinel.SideEffect,
                          "side_effect incorrectly reset")
        self.assertEqual(mock.return_value, return_value,
                          "return_value incorrectly reset")
        self.assertFalse(return_value.called, "return value mock not reset")
        self.assertEqual(mock._mock_children, {'something': something},
                          "children reset incorrectly")
        self.assertEqual(mock.something, something,
                          "children incorrectly cleared")
        self.assertFalse(mock.something.called, "child not reset")

Example 10

Project: brython Source File: testmock.py
    def test_assert_called_once_with(self):
        mock = Mock()
        mock()

        # Will raise an exception if it fails
        mock.assert_called_once_with()

        mock()
        self.assertRaises(AssertionError, mock.assert_called_once_with)

        mock.reset_mock()
        self.assertRaises(AssertionError, mock.assert_called_once_with)

        mock('foo', 'bar', baz=2)
        mock.assert_called_once_with('foo', 'bar', baz=2)

        mock.reset_mock()
        mock('foo', 'bar', baz=2)
        self.assertRaises(
            AssertionError,
            lambda: mock.assert_called_once_with('bob', 'bar', baz=2)
        )

Example 11

Project: brython Source File: testmock.py
    def test_arg_lists(self):
        mocks = [
            Mock(),
            MagicMock(),
            NonCallableMock(),
            NonCallableMagicMock()
        ]

        def assert_attrs(mock):
            names = 'call_args_list', 'method_calls', 'mock_calls'
            for name in names:
                attr = getattr(mock, name)
                self.assertIsInstance(attr, _CallList)
                self.assertIsInstance(attr, list)
                self.assertEqual(attr, [])

        for mock in mocks:
            assert_attrs(mock)

            if callable(mock):
                mock()
                mock(1, 2)
                mock(a=3)

                mock.reset_mock()
                assert_attrs(mock)

            mock.foo()
            mock.foo.bar(1, a=3)
            mock.foo(1).bar().baz(3)

            mock.reset_mock()
            assert_attrs(mock)

Example 12

Project: brython Source File: testmock.py
    def test_side_effect_iterator(self):
        mock = Mock(side_effect=iter([1, 2, 3]))
        self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
        self.assertRaises(StopIteration, mock)

        mock = MagicMock(side_effect=['a', 'b', 'c'])
        self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
        self.assertRaises(StopIteration, mock)

        mock = Mock(side_effect='ghi')
        self.assertEqual([mock(), mock(), mock()], ['g', 'h', 'i'])
        self.assertRaises(StopIteration, mock)

        class Foo(object):
            pass
        mock = MagicMock(side_effect=Foo)
        self.assertIsInstance(mock(), Foo)

        mock = Mock(side_effect=Iter())
        self.assertEqual([mock(), mock(), mock(), mock()],
                         ['this', 'is', 'an', 'iter'])
        self.assertRaises(StopIteration, mock)

Example 13

Project: brython Source File: testmock.py
    def test_assert_has_calls_any_order(self):
        mock = Mock()
        mock(1, 2)
        mock(a=3)
        mock(3, 4)
        mock(b=6)
        mock(b=6)

        kalls = [
            call(1, 2), ({'a': 3},),
            ((3, 4),), ((), {'a': 3}),
            ('', (1, 2)), ('', {'a': 3}),
            ('', (1, 2), {}), ('', (), {'a': 3})
        ]
        for kall in kalls:
            mock.assert_has_calls([kall], any_order=True)

        for kall in call(1, '2'), call(b=3), call(), 3, None, 'foo':
            self.assertRaises(
                AssertionError, mock.assert_has_calls,
                [kall], any_order=True
            )

        kall_lists = [
            [call(1, 2), call(b=6)],
            [call(3, 4), call(1, 2)],
            [call(b=6), call(b=6)],
        ]

        for kall_list in kall_lists:
            mock.assert_has_calls(kall_list, any_order=True)

        kall_lists = [
            [call(b=6), call(b=6), call(b=6)],
            [call(1, 2), call(1, 2)],
            [call(3, 4), call(1, 2), call(5, 7)],
            [call(b=6), call(3, 4), call(b=6), call(1, 2), call(b=6)],
        ]
        for kall_list in kall_lists:
            self.assertRaises(
                AssertionError, mock.assert_has_calls,
                kall_list, any_order=True
            )

Example 14

Project: brython Source File: testmock.py
    def test_assert_has_calls(self):
        kalls1 = [
                call(1, 2), ({'a': 3},),
                ((3, 4),), call(b=6),
                ('', (1,), {'b': 6}),
        ]
        kalls2 = [call.foo(), call.bar(1)]
        kalls2.extend(call.spam().baz(a=3).call_list())
        kalls2.extend(call.bam(set(), foo={}).fish([1]).call_list())

        mocks = []
        for mock in Mock(), MagicMock():
            mock(1, 2)
            mock(a=3)
            mock(3, 4)
            mock(b=6)
            mock(1, b=6)
            mocks.append((mock, kalls1))

        mock = Mock()
        mock.foo()
        mock.bar(1)
        mock.spam().baz(a=3)
        mock.bam(set(), foo={}).fish([1])
        mocks.append((mock, kalls2))

        for mock, kalls in mocks:
            for i in range(len(kalls)):
                for step in 1, 2, 3:
                    these = kalls[i:i+step]
                    mock.assert_has_calls(these)

                    if len(these) > 1:
                        self.assertRaises(
                            AssertionError,
                            mock.assert_has_calls,
                            list(reversed(these))
                        )

Example 15

Project: brython Source File: testmock.py
    def test_assert_any_call(self):
        mock = Mock()
        mock(1, 2)
        mock(a=3)
        mock(1, b=6)

        mock.assert_any_call(1, 2)
        mock.assert_any_call(a=3)
        mock.assert_any_call(1, b=6)

        self.assertRaises(
            AssertionError,
            mock.assert_any_call
        )
        self.assertRaises(
            AssertionError,
            mock.assert_any_call,
            1, 3
        )
        self.assertRaises(
            AssertionError,
            mock.assert_any_call,
            a=4
        )

Example 16

Project: TwitterSearch Source File: test_ts.py
    @httpretty.activate
    def test_TS_search_tweets_iterable_callback(self):
        """ Tests TwitterSearch.search_tweets_iterable(callback) by using TwitterSearchOrder class """

        import sys
        if sys.version_info[0] < 3:
            self.assertTrue(True) # Dummy test for py2 doesn't have Mock class
            return

        httpretty.register_uri(httpretty.GET, self.search_url,
                        responses=[
                            httpretty.Response(streaming=True, status=200, content_type='text/json', body=self.apiAnsweringMachine('tests/mock-data/search/0.log')),
                            httpretty.Response(streaming=True, status=200, content_type='text/json', body=self.apiAnsweringMachine('tests/mock-data/search/1.log')),
                            httpretty.Response(streaming=True, status=200, content_type='text/json', body=self.apiAnsweringMachine('tests/mock-data/search/2.log')),
                            httpretty.Response(streaming=True, status=200, content_type='text/json', body=self.apiAnsweringMachine('tests/mock-data/search/3.log'))
                            ]
                        )

        pages = 4
        tso = self.createTSO()
        tso.set_count(4)
        ts = self.createTS()

        from unittest.mock import Mock

        mock = Mock()
        for tweet in ts.search_tweets_iterable(tso, callback=mock):
            mock.assert_called_with(ts)

        times = len(mock.call_args_list)
        self.assertEqual(pages, times, "Callback function was NOT called 4 times but %i times" % times)

Example 17

Project: pyshould Source File: dsl.py
Function: test_mock
    def test_mock(self):
        try:
            from unittest.mock import Mock, patch  # Python 3.3
        except:
            try:
                from mock import Mock, patch
            except:
                raise unittest.SkipTest('Mock library not available, skipping test')

        mock = Mock()
        mock(10, 1)

        mock | should.be_called
        self.assertRaises(
            AssertionError,
            lambda: mock | should.not_be_called
        )

        # Check it supports matchers in params
        mock.assert_called_with(should.any, should.less_than(3))
        self.assertRaises(
            AssertionError,
            lambda: mock.assert_called_with(should.any, should.greater_than(3))
        )

        # Check we can wrap it even when implementing __or__
        with patch.object(self, 'test_mock') as mock:
            it(mock) | should.not_be_called

Example 18

Project: papyrus Source File: test_protocol.py
Function: test_query
    def test___query(self):
        from papyrus.protocol import Protocol, create_attr_filter
        try:
            from unittest.mock import patch
        except:
            from mock import patch

        engine = self._get_engine()
        Session = self._get_session(engine)
        MappedClass = self._get_mapped_class()

        proto = Protocol(Session, MappedClass, "geom")

        request = testing.DummyRequest()
        with patch('sqlalchemy.orm.query.Query.all', lambda q: q):
            query = proto._query(request)
        self.assertTrue(b"SELECT" in query_to_str(query, engine))

        request = testing.DummyRequest(params={"queryable": "id",
                                               "id__eq": "1"})
        with patch('sqlalchemy.orm.query.Query.all', lambda q: q):
            query = proto._query(request)
        self.assertTrue(b"WHERE" in query_to_str(query, engine))

        request = testing.DummyRequest(params={"queryable": "id",
                                               "id__eq": "1"})
        with patch('sqlalchemy.orm.query.Query.all', lambda q: q):
            filter = create_attr_filter(request, MappedClass)
            query = proto._query(testing.DummyRequest(), filter=filter)
        self.assertTrue(b"WHERE" in query_to_str(query, engine))

        request = testing.DummyRequest(params={"limit": "2"})
        with patch('sqlalchemy.orm.query.Query.all', lambda q: q):
            query = proto._query(request)
        self.assertTrue(b"LIMIT" in query_to_str(query, engine))

        request = testing.DummyRequest(params={"maxfeatures": "2"})
        with patch('sqlalchemy.orm.query.Query.all', lambda q: q):
            query = proto._query(request)
        self.assertTrue(b"LIMIT" in query_to_str(query, engine))

        request = testing.DummyRequest(params={"limit": "2", "offset": "10"})
        with patch('sqlalchemy.orm.query.Query.all', lambda q: q):
            query = proto._query(request)
        self.assertTrue(b"OFFSET" in query_to_str(query, engine))

        request = testing.DummyRequest(params={"order_by": "text"})
        with patch('sqlalchemy.orm.query.Query.all', lambda q: q):
            query = proto._query(request)
        self.assertTrue(b"ORDER BY" in query_to_str(query, engine))
        self.assertTrue(b"ASC" in query_to_str(query, engine))

        request = testing.DummyRequest(params={"sort": "text"})
        with patch('sqlalchemy.orm.query.Query.all', lambda q: q):
            query = proto._query(request)
        self.assertTrue(b"ORDER BY" in query_to_str(query, engine))
        self.assertTrue(b"ASC" in query_to_str(query, engine))

        request = testing.DummyRequest(params={"order_by": "text",
                                               "dir": "DESC"})
        with patch('sqlalchemy.orm.query.Query.all', lambda q: q):
            query = proto._query(request)
        self.assertTrue(b"ORDER BY" in query_to_str(query, engine))
        self.assertTrue(b"DESC" in query_to_str(query, engine))

Example 19

Project: aliyun-oss-python-sdk Source File: test_api_base.py
        def test_user_agent(self):
            app = 'fantastic-tool'

            assert_found = False
            def do_request(session_self, req, timeout):
                if assert_found:
                    self.assertTrue(req.headers['User-Agent'].find(app) >= 0)
                else:
                    self.assertTrue(req.headers['User-Agent'].find(app) < 0)

                raise oss2.exceptions.ClientError('intentional')

            from unittest.mock import patch
            with patch.object(oss2.Session, 'do_request', side_effect=do_request, autospec=True):
                # 不加 app_name
                assert_found = False
                self.assertRaises(oss2.exceptions.ClientError, self.bucket.get_bucket_acl)

                service = oss2.Service(oss2.Auth(OSS_ID, OSS_SECRET), OSS_ENDPOINT)
                self.assertRaises(oss2.exceptions.ClientError, service.list_buckets)

                # 加app_name
                assert_found = True
                bucket = oss2.Bucket(oss2.Auth(OSS_ID, OSS_SECRET), OSS_ENDPOINT, OSS_BUCKET,
                                     app_name=app)
                self.assertRaises(oss2.exceptions.ClientError, bucket.get_bucket_acl)

                service = oss2.Service(oss2.Auth(OSS_ID, OSS_SECRET), OSS_ENDPOINT,
                                       app_name=app)
                self.assertRaises(oss2.exceptions.ClientError, service.list_buckets)