tests/testmocksignature.py

# Copyright (C) 2007-2012 Michael Foord & the mock team
# E-mail: fuzzyman AT voidspace DOT org DOT uk
# http://www.voidspace.org.uk/python/mock/

import inspect

from tests.support import unittest2

from mock import Mock, mocksignature, patch


class Something(object):
    def __init__(self, foo, bar=10):
        pass
    def __call__(self, foo, bar=5):
        pass

something = Something(1, 2)


def f(a, b, c):
    pass


class TestMockSignature(unittest2.TestCase):

    def test_function(self):
        def f(a):
            pass
        mock = Mock()

        f2  = mocksignature(f, mock)
        self.assertIs(f2.mock, mock)

        self.assertRaises(TypeError, f2)
        mock.return_value = 3
        self.assertEqual(f2('foo'), 3)
        mock.assert_called_with('foo')
        f2.mock.assert_called_with('foo')


    def test_function_without_explicit_mock(self):
        def f(a):
            pass

        f2  = mocksignature(f)
        self.assertIsInstance(f2.mock, Mock)

        self.assertRaises(TypeError, f2)
        f2.mock.return_value = 3
        self.assertEqual(f2('foo'), 3)
        f2.mock.assert_called_with('foo')


    def test_method(self):
        class Foo(object):
            def method(self, a, b):
                pass

        f = Foo()
        mock = Mock()
        mock.return_value = 3
        f.method = mocksignature(f.method, mock)
        self.assertEqual(f.method('foo', 'bar'), 3)
        mock.assert_called_with('foo', 'bar')


    def test_function_with_defaults(self):
        def f(a, b=None):
            pass
        mock = Mock()
        f2  = mocksignature(f, mock)
        f2(3)
        mock.assert_called_with(3, None)
        mock.reset_mock()

        f2(1, 7)
        mock.assert_called_with(1, 7)
        mock.reset_mock()

        f2(b=1, a=7)
        mock.assert_called_with(7, 1)
        mock.reset_mock()

        a = object()
        def f(a=a):
            pass
        f2 = mocksignature(f, mock)
        f2()
        mock.assert_called_with(a)


    def test_introspection(self):
        def f(a, *args, **kwargs):
            pass
        f2 = mocksignature(f, f)
        self.assertEqual(inspect.getargspec(f), inspect.getargspec(f2))

        def f(a, b=None, c=3, d=object()):
            pass
        f2 = mocksignature(f, f)
        self.assertEqual(inspect.getargspec(f), inspect.getargspec(f2))


    def test_function_with_varargs_and_kwargs(self):
        def f(a, b=None, *args, **kwargs):
            return (a, b, args, kwargs)
        f2 = mocksignature(f, f)
        self.assertEqual(f2(3, 4, 5, x=6, y=9), (3, 4, (5,), {'x': 6, 'y': 9}))
        self.assertEqual(f2(3, x=6, y=9, b='a'), (3, 'a', (), {'x': 6, 'y': 9}))

        def f(*args):
            pass
        g = mocksignature(f)
        g.mock.return_value = 3
        self.assertEqual(g(1, 2, 'many'), 3)
        self.assertEqual(g(), 3)
        self.assertRaises(TypeError, lambda: g(a=None))

        def f(**kwargs):
            pass
        g = mocksignature(f)
        g.mock.return_value = 3
        self.assertEqual(g(), 3)
        self.assertEqual(g(a=None, b=None), 3)
        self.assertRaises(TypeError, lambda: g(None))


    def test_mocksignature_with_patch(self):
        mock = Mock()

        def f(a, b, c):
            pass
        mock.f = f

        @patch.object(mock, 'f', mocksignature=True)
        def test(mock_f):
            self.assertRaises(TypeError, mock.f, 3, 4)
            self.assertRaises(TypeError, mock.f, 3, 4, 5, 6)
            mock.f(1, 2, 3)

            mock_f.assert_called_with(1, 2, 3)
            mock.f.mock.assert_called_with(1, 2, 3)

        test()

        @patch('tests.support.SomeClass.wibble', mocksignature=True)
        def test(mock_wibble):
            from tests.support import SomeClass

            instance = SomeClass()
            self.assertRaises(TypeError, instance.wibble, 1)
            instance.wibble()

            mock_wibble.assert_called_with(instance)
            instance.wibble.mock.assert_called_with(instance)

        test()


    @unittest2.skipUnless(__debug__, 'assert disabled when run with -O/OO')
    def test_mocksignature_with_reserved_arg(self):
        def f(_mock_):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

        def f(_mock_=None):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

        def f(*_mock_):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

        def f(**_mock_):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))


    def test_mocksignature_class(self):
        MockedSomething = mocksignature(Something)

        result = MockedSomething(5, 23)
        self.assertIs(result, MockedSomething.mock.return_value)

        MockedSomething(1)
        MockedSomething.mock.assert_caled_with(1, 10)

        self.assertRaises(TypeError, MockedSomething)


    def test_mocksignature_callable(self):
        mocked_something = mocksignature(something)

        result = mocked_something(5, 23)
        self.assertIs(result, mocked_something.mock.return_value)

        mocked_something(1)
        mocked_something.mock.assert_caled_with(1, 5)

        self.assertRaises(TypeError, mocked_something)


    def test_patch_mocksignature_class(self):
        original_something = Something
        something_name = '%s.Something' % __name__
        @patch(something_name, mocksignature=True)
        def test(MockSomething):
            Something(3, 5)
            MockSomething.assert_called_with(3, 5)

            Something(6)
            MockSomething.assert_called_with(6, 10)

            self.assertRaises(TypeError, Something)
        test()
        self.assertIs(Something, original_something)


    def test_patch_mocksignature_callable(self):
        original_something = something
        something_name = '%s.something' % __name__
        @patch(something_name, mocksignature=True)
        def test(MockSomething):
            something(3, 4)
            MockSomething.assert_called_with(3, 4)

            something(6)
            MockSomething.assert_called_with(6, 5)

            self.assertRaises(TypeError, something)
        test()
        self.assertIs(something, original_something)


    def test_patchobject_mocksignature(self):
        class something(object):
            def meth(self, a, b, c):
                pass

        original = something.__dict__['meth']

        @patch.object(something, 'meth', mocksignature=True)
        def test(_):
            self.assertIsNot(something.__dict__['meth'], original)
            thing = something()
            thing.meth(1, 2, 3)
            self.assertRaises(TypeError, thing.meth, 1)

        test()
        self.assertIs(something.__dict__['meth'], original)

        thing = something()

        original = thing.meth
        @patch.object(thing, 'meth', mocksignature=True)
        def test(_):
            thing.meth(1, 2, 3)
            self.assertRaises(TypeError, thing.meth, 1)

        test()
        self.assertEqual(thing.meth, original)

        # when patching instance methods using mocksignatures we used to
        # replace the bound method with an instance attribute on unpatching.
        self.assertNotIn('meth', thing.__dict__)


    def test_assert_called_with(self):
        func = mocksignature(f)

        self.assertRaises(AssertionError, func.assert_called_with)
        self.assertRaises(AssertionError, func.assert_called_once_with)

        func(1, 2, 3)
        func.assert_called_with(1, 2, 3)
        self.assertRaises(AssertionError, func.assert_called_with, 4, 5, 6)
        func.assert_called_once_with(1, 2, 3)
        self.assertRaises(AssertionError, func.assert_called_once_with,
                          4, 5, 6)


    def test_mock_attributes(self):
        func = mocksignature(f)

        return_value = func.return_value
        self.assertIsInstance(return_value, Mock)
        self.assertIsNone(func.side_effect)
        self.assertFalse(func.called)
        self.assertIsNone(func.call_args)
        self.assertEqual(func.call_count, 0)
        self.assertEqual(func.method_calls, [])
        self.assertEqual(func.call_args_list, [])
        self.assertIs(func._mock_children, func.mock._mock_children)

        self.assertIs(func(1, 2, 3), return_value)

        self.assertTrue(func.called)
        self.assertEqual(func.call_args, ((1, 2, 3), {}))
        self.assertEqual(func.call_count, 1)
        self.assertEqual(func.method_calls, [])
        self.assertEqual(func.call_args_list, [((1, 2, 3), {})])
        func.method_calls.append('foo')

        return_value()
        func.reset_mock()

        self.assertEqual(return_value.call_count, False)
        self.assertFalse(func.called)
        self.assertIsNone(func.call_args)
        self.assertEqual(func.call_count, 0)
        self.assertEqual(func.method_calls, [])
        self.assertEqual(func.call_args_list, [])
        self.assertIs(func._mock_children, func.mock._mock_children)

        func.side_effect = KeyError
        self.assertRaises(KeyError, func, 1, 2, 3)
        self.assertTrue(func.called)

        func.side_effect = None
        func.return_value = 'foo'
        self.assertEqual(func(1, 2, 3), 'foo')
        self.assertEqual(func.call_count, 2)


    def test_return_value_from_existing_mock(self):
        mock = Mock(return_value='foo')
        func = mocksignature(f, mock)
        self.assertEqual(func(1, 2, 3), 'foo')

        mock.return_value = 'bar'
        self.assertEqual(func(1, 2, 3), 'bar')


    def test_side_effect_from_existing_mock(self):
        mock = Mock(side_effect=KeyError)
        func = mocksignature(f, mock)
        self.assertRaises(KeyError, func, 1, 2, 3)

        mock.side_effect = NameError
        self.assertRaises(NameError, func, 1, 2, 3)


if __name__ == '__main__':
    unittest2.main()