1import inspect
2import time
3import types
4import unittest
5
6from unittest.mock import (
7    call, _Call, create_autospec, MagicMock,
8    Mock, ANY, _CallList, patch, PropertyMock, _callable
9)
10
11from datetime import datetime
12from functools import partial
13
14class SomeClass(object):
15    def one(self, a, b): pass
16    def two(self): pass
17    def three(self, a=None): pass
18
19
20
21class AnyTest(unittest.TestCase):
22
23    def test_any(self):
24        self.assertEqual(ANY, object())
25
26        mock = Mock()
27        mock(ANY)
28        mock.assert_called_with(ANY)
29
30        mock = Mock()
31        mock(foo=ANY)
32        mock.assert_called_with(foo=ANY)
33
34    def test_repr(self):
35        self.assertEqual(repr(ANY), '<ANY>')
36        self.assertEqual(str(ANY), '<ANY>')
37
38
39    def test_any_and_datetime(self):
40        mock = Mock()
41        mock(datetime.now(), foo=datetime.now())
42
43        mock.assert_called_with(ANY, foo=ANY)
44
45
46    def test_any_mock_calls_comparison_order(self):
47        mock = Mock()
48        class Foo(object):
49            def __eq__(self, other): pass
50            def __ne__(self, other): pass
51
52        for d in datetime.now(), Foo():
53            mock.reset_mock()
54
55            mock(d, foo=d, bar=d)
56            mock.method(d, zinga=d, alpha=d)
57            mock().method(a1=d, z99=d)
58
59            expected = [
60                call(ANY, foo=ANY, bar=ANY),
61                call.method(ANY, zinga=ANY, alpha=ANY),
62                call(), call().method(a1=ANY, z99=ANY)
63            ]
64            self.assertEqual(expected, mock.mock_calls)
65            self.assertEqual(mock.mock_calls, expected)
66
67    def test_any_no_spec(self):
68        # This is a regression test for bpo-37555
69        class Foo:
70            def __eq__(self, other): pass
71
72        mock = Mock()
73        mock(Foo(), 1)
74        mock.assert_has_calls([call(ANY, 1)])
75        mock.assert_called_with(ANY, 1)
76        mock.assert_any_call(ANY, 1)
77
78    def test_any_and_spec_set(self):
79        # This is a regression test for bpo-37555
80        class Foo:
81            def __eq__(self, other): pass
82
83        mock = Mock(spec=Foo)
84
85        mock(Foo(), 1)
86        mock.assert_has_calls([call(ANY, 1)])
87        mock.assert_called_with(ANY, 1)
88        mock.assert_any_call(ANY, 1)
89
90class CallTest(unittest.TestCase):
91
92    def test_call_with_call(self):
93        kall = _Call()
94        self.assertEqual(kall, _Call())
95        self.assertEqual(kall, _Call(('',)))
96        self.assertEqual(kall, _Call(((),)))
97        self.assertEqual(kall, _Call(({},)))
98        self.assertEqual(kall, _Call(('', ())))
99        self.assertEqual(kall, _Call(('', {})))
100        self.assertEqual(kall, _Call(('', (), {})))
101        self.assertEqual(kall, _Call(('foo',)))
102        self.assertEqual(kall, _Call(('bar', ())))
103        self.assertEqual(kall, _Call(('baz', {})))
104        self.assertEqual(kall, _Call(('spam', (), {})))
105
106        kall = _Call(((1, 2, 3),))
107        self.assertEqual(kall, _Call(((1, 2, 3),)))
108        self.assertEqual(kall, _Call(('', (1, 2, 3))))
109        self.assertEqual(kall, _Call(((1, 2, 3), {})))
110        self.assertEqual(kall, _Call(('', (1, 2, 3), {})))
111
112        kall = _Call(((1, 2, 4),))
113        self.assertNotEqual(kall, _Call(('', (1, 2, 3))))
114        self.assertNotEqual(kall, _Call(('', (1, 2, 3), {})))
115
116        kall = _Call(('foo', (1, 2, 4),))
117        self.assertNotEqual(kall, _Call(('', (1, 2, 4))))
118        self.assertNotEqual(kall, _Call(('', (1, 2, 4), {})))
119        self.assertNotEqual(kall, _Call(('bar', (1, 2, 4))))
120        self.assertNotEqual(kall, _Call(('bar', (1, 2, 4), {})))
121
122        kall = _Call(({'a': 3},))
123        self.assertEqual(kall, _Call(('', (), {'a': 3})))
124        self.assertEqual(kall, _Call(('', {'a': 3})))
125        self.assertEqual(kall, _Call(((), {'a': 3})))
126        self.assertEqual(kall, _Call(({'a': 3},)))
127
128
129    def test_empty__Call(self):
130        args = _Call()
131
132        self.assertEqual(args, ())
133        self.assertEqual(args, ('foo',))
134        self.assertEqual(args, ((),))
135        self.assertEqual(args, ('foo', ()))
136        self.assertEqual(args, ('foo',(), {}))
137        self.assertEqual(args, ('foo', {}))
138        self.assertEqual(args, ({},))
139
140
141    def test_named_empty_call(self):
142        args = _Call(('foo', (), {}))
143
144        self.assertEqual(args, ('foo',))
145        self.assertEqual(args, ('foo', ()))
146        self.assertEqual(args, ('foo',(), {}))
147        self.assertEqual(args, ('foo', {}))
148
149        self.assertNotEqual(args, ((),))
150        self.assertNotEqual(args, ())
151        self.assertNotEqual(args, ({},))
152        self.assertNotEqual(args, ('bar',))
153        self.assertNotEqual(args, ('bar', ()))
154        self.assertNotEqual(args, ('bar', {}))
155
156
157    def test_call_with_args(self):
158        args = _Call(((1, 2, 3), {}))
159
160        self.assertEqual(args, ((1, 2, 3),))
161        self.assertEqual(args, ('foo', (1, 2, 3)))
162        self.assertEqual(args, ('foo', (1, 2, 3), {}))
163        self.assertEqual(args, ((1, 2, 3), {}))
164        self.assertEqual(args.args, (1, 2, 3))
165        self.assertEqual(args.kwargs, {})
166
167
168    def test_named_call_with_args(self):
169        args = _Call(('foo', (1, 2, 3), {}))
170
171        self.assertEqual(args, ('foo', (1, 2, 3)))
172        self.assertEqual(args, ('foo', (1, 2, 3), {}))
173        self.assertEqual(args.args, (1, 2, 3))
174        self.assertEqual(args.kwargs, {})
175
176        self.assertNotEqual(args, ((1, 2, 3),))
177        self.assertNotEqual(args, ((1, 2, 3), {}))
178
179
180    def test_call_with_kwargs(self):
181        args = _Call(((), dict(a=3, b=4)))
182
183        self.assertEqual(args, (dict(a=3, b=4),))
184        self.assertEqual(args, ('foo', dict(a=3, b=4)))
185        self.assertEqual(args, ('foo', (), dict(a=3, b=4)))
186        self.assertEqual(args, ((), dict(a=3, b=4)))
187        self.assertEqual(args.args, ())
188        self.assertEqual(args.kwargs, dict(a=3, b=4))
189
190
191    def test_named_call_with_kwargs(self):
192        args = _Call(('foo', (), dict(a=3, b=4)))
193
194        self.assertEqual(args, ('foo', dict(a=3, b=4)))
195        self.assertEqual(args, ('foo', (), dict(a=3, b=4)))
196        self.assertEqual(args.args, ())
197        self.assertEqual(args.kwargs, dict(a=3, b=4))
198
199        self.assertNotEqual(args, (dict(a=3, b=4),))
200        self.assertNotEqual(args, ((), dict(a=3, b=4)))
201
202
203    def test_call_with_args_call_empty_name(self):
204        args = _Call(((1, 2, 3), {}))
205
206        self.assertEqual(args, call(1, 2, 3))
207        self.assertEqual(call(1, 2, 3), args)
208        self.assertIn(call(1, 2, 3), [args])
209
210
211    def test_call_ne(self):
212        self.assertNotEqual(_Call(((1, 2, 3),)), call(1, 2))
213        self.assertFalse(_Call(((1, 2, 3),)) != call(1, 2, 3))
214        self.assertTrue(_Call(((1, 2), {})) != call(1, 2, 3))
215
216
217    def test_call_non_tuples(self):
218        kall = _Call(((1, 2, 3),))
219        for value in 1, None, self, int:
220            self.assertNotEqual(kall, value)
221            self.assertFalse(kall == value)
222
223
224    def test_repr(self):
225        self.assertEqual(repr(_Call()), 'call()')
226        self.assertEqual(repr(_Call(('foo',))), 'call.foo()')
227
228        self.assertEqual(repr(_Call(((1, 2, 3), {'a': 'b'}))),
229                         "call(1, 2, 3, a='b')")
230        self.assertEqual(repr(_Call(('bar', (1, 2, 3), {'a': 'b'}))),
231                         "call.bar(1, 2, 3, a='b')")
232
233        self.assertEqual(repr(call), 'call')
234        self.assertEqual(str(call), 'call')
235
236        self.assertEqual(repr(call()), 'call()')
237        self.assertEqual(repr(call(1)), 'call(1)')
238        self.assertEqual(repr(call(zz='thing')), "call(zz='thing')")
239
240        self.assertEqual(repr(call().foo), 'call().foo')
241        self.assertEqual(repr(call(1).foo.bar(a=3).bing),
242                         'call().foo.bar().bing')
243        self.assertEqual(
244            repr(call().foo(1, 2, a=3)),
245            "call().foo(1, 2, a=3)"
246        )
247        self.assertEqual(repr(call()()), "call()()")
248        self.assertEqual(repr(call(1)(2)), "call()(2)")
249        self.assertEqual(
250            repr(call()().bar().baz.beep(1)),
251            "call()().bar().baz.beep(1)"
252        )
253
254
255    def test_call(self):
256        self.assertEqual(call(), ('', (), {}))
257        self.assertEqual(call('foo', 'bar', one=3, two=4),
258                         ('', ('foo', 'bar'), {'one': 3, 'two': 4}))
259
260        mock = Mock()
261        mock(1, 2, 3)
262        mock(a=3, b=6)
263        self.assertEqual(mock.call_args_list,
264                         [call(1, 2, 3), call(a=3, b=6)])
265
266    def test_attribute_call(self):
267        self.assertEqual(call.foo(1), ('foo', (1,), {}))
268        self.assertEqual(call.bar.baz(fish='eggs'),
269                         ('bar.baz', (), {'fish': 'eggs'}))
270
271        mock = Mock()
272        mock.foo(1, 2 ,3)
273        mock.bar.baz(a=3, b=6)
274        self.assertEqual(mock.method_calls,
275                         [call.foo(1, 2, 3), call.bar.baz(a=3, b=6)])
276
277
278    def test_extended_call(self):
279        result = call(1).foo(2).bar(3, a=4)
280        self.assertEqual(result, ('().foo().bar', (3,), dict(a=4)))
281
282        mock = MagicMock()
283        mock(1, 2, a=3, b=4)
284        self.assertEqual(mock.call_args, call(1, 2, a=3, b=4))
285        self.assertNotEqual(mock.call_args, call(1, 2, 3))
286
287        self.assertEqual(mock.call_args_list, [call(1, 2, a=3, b=4)])
288        self.assertEqual(mock.mock_calls, [call(1, 2, a=3, b=4)])
289
290        mock = MagicMock()
291        mock.foo(1).bar()().baz.beep(a=6)
292
293        last_call = call.foo(1).bar()().baz.beep(a=6)
294        self.assertEqual(mock.mock_calls[-1], last_call)
295        self.assertEqual(mock.mock_calls, last_call.call_list())
296
297
298    def test_extended_not_equal(self):
299        a = call(x=1).foo
300        b = call(x=2).foo
301        self.assertEqual(a, a)
302        self.assertEqual(b, b)
303        self.assertNotEqual(a, b)
304
305
306    def test_nested_calls_not_equal(self):
307        a = call(x=1).foo().bar
308        b = call(x=2).foo().bar
309        self.assertEqual(a, a)
310        self.assertEqual(b, b)
311        self.assertNotEqual(a, b)
312
313
314    def test_call_list(self):
315        mock = MagicMock()
316        mock(1)
317        self.assertEqual(call(1).call_list(), mock.mock_calls)
318
319        mock = MagicMock()
320        mock(1).method(2)
321        self.assertEqual(call(1).method(2).call_list(),
322                         mock.mock_calls)
323
324        mock = MagicMock()
325        mock(1).method(2)(3)
326        self.assertEqual(call(1).method(2)(3).call_list(),
327                         mock.mock_calls)
328
329        mock = MagicMock()
330        int(mock(1).method(2)(3).foo.bar.baz(4)(5))
331        kall = call(1).method(2)(3).foo.bar.baz(4)(5).__int__()
332        self.assertEqual(kall.call_list(), mock.mock_calls)
333
334
335    def test_call_any(self):
336        self.assertEqual(call, ANY)
337
338        m = MagicMock()
339        int(m)
340        self.assertEqual(m.mock_calls, [ANY])
341        self.assertEqual([ANY], m.mock_calls)
342
343
344    def test_two_args_call(self):
345        args = _Call(((1, 2), {'a': 3}), two=True)
346        self.assertEqual(len(args), 2)
347        self.assertEqual(args[0], (1, 2))
348        self.assertEqual(args[1], {'a': 3})
349
350        other_args = _Call(((1, 2), {'a': 3}))
351        self.assertEqual(args, other_args)
352
353    def test_call_with_name(self):
354        self.assertEqual(_Call((), 'foo')[0], 'foo')
355        self.assertEqual(_Call((('bar', 'barz'),),)[0], '')
356        self.assertEqual(_Call((('bar', 'barz'), {'hello': 'world'}),)[0], '')
357
358    def test_dunder_call(self):
359        m = MagicMock()
360        m().foo()['bar']()
361        self.assertEqual(
362            m.mock_calls,
363            [call(), call().foo(), call().foo().__getitem__('bar'), call().foo().__getitem__()()]
364        )
365        m = MagicMock()
366        m().foo()['bar'] = 1
367        self.assertEqual(
368            m.mock_calls,
369            [call(), call().foo(), call().foo().__setitem__('bar', 1)]
370        )
371        m = MagicMock()
372        iter(m().foo())
373        self.assertEqual(
374            m.mock_calls,
375            [call(), call().foo(), call().foo().__iter__()]
376        )
377
378
379class SpecSignatureTest(unittest.TestCase):
380
381    def _check_someclass_mock(self, mock):
382        self.assertRaises(AttributeError, getattr, mock, 'foo')
383        mock.one(1, 2)
384        mock.one.assert_called_with(1, 2)
385        self.assertRaises(AssertionError,
386                          mock.one.assert_called_with, 3, 4)
387        self.assertRaises(TypeError, mock.one, 1)
388
389        mock.two()
390        mock.two.assert_called_with()
391        self.assertRaises(AssertionError,
392                          mock.two.assert_called_with, 3)
393        self.assertRaises(TypeError, mock.two, 1)
394
395        mock.three()
396        mock.three.assert_called_with()
397        self.assertRaises(AssertionError,
398                          mock.three.assert_called_with, 3)
399        self.assertRaises(TypeError, mock.three, 3, 2)
400
401        mock.three(1)
402        mock.three.assert_called_with(1)
403
404        mock.three(a=1)
405        mock.three.assert_called_with(a=1)
406
407
408    def test_basic(self):
409        mock = create_autospec(SomeClass)
410        self._check_someclass_mock(mock)
411        mock = create_autospec(SomeClass())
412        self._check_someclass_mock(mock)
413
414
415    def test_create_autospec_return_value(self):
416        def f(): pass
417        mock = create_autospec(f, return_value='foo')
418        self.assertEqual(mock(), 'foo')
419
420        class Foo(object):
421            pass
422
423        mock = create_autospec(Foo, return_value='foo')
424        self.assertEqual(mock(), 'foo')
425
426
427    def test_autospec_reset_mock(self):
428        m = create_autospec(int)
429        int(m)
430        m.reset_mock()
431        self.assertEqual(m.__int__.call_count, 0)
432
433
434    def test_mocking_unbound_methods(self):
435        class Foo(object):
436            def foo(self, foo): pass
437        p = patch.object(Foo, 'foo')
438        mock_foo = p.start()
439        Foo().foo(1)
440
441        mock_foo.assert_called_with(1)
442
443
444    def test_create_autospec_keyword_arguments(self):
445        class Foo(object):
446            a = 3
447        m = create_autospec(Foo, a='3')
448        self.assertEqual(m.a, '3')
449
450
451    def test_create_autospec_keyword_only_arguments(self):
452        def foo(a, *, b=None): pass
453
454        m = create_autospec(foo)
455        m(1)
456        m.assert_called_with(1)
457        self.assertRaises(TypeError, m, 1, 2)
458
459        m(2, b=3)
460        m.assert_called_with(2, b=3)
461
462
463    def test_function_as_instance_attribute(self):
464        obj = SomeClass()
465        def f(a): pass
466        obj.f = f
467
468        mock = create_autospec(obj)
469        mock.f('bing')
470        mock.f.assert_called_with('bing')
471
472
473    def test_spec_as_list(self):
474        # because spec as a list of strings in the mock constructor means
475        # something very different we treat a list instance as the type.
476        mock = create_autospec([])
477        mock.append('foo')
478        mock.append.assert_called_with('foo')
479
480        self.assertRaises(AttributeError, getattr, mock, 'foo')
481
482        class Foo(object):
483            foo = []
484
485        mock = create_autospec(Foo)
486        mock.foo.append(3)
487        mock.foo.append.assert_called_with(3)
488        self.assertRaises(AttributeError, getattr, mock.foo, 'foo')
489
490
491    def test_attributes(self):
492        class Sub(SomeClass):
493            attr = SomeClass()
494
495        sub_mock = create_autospec(Sub)
496
497        for mock in (sub_mock, sub_mock.attr):
498            self._check_someclass_mock(mock)
499
500
501    def test_spec_has_descriptor_returning_function(self):
502
503        class CrazyDescriptor(object):
504
505            def __get__(self, obj, type_):
506                if obj is None:
507                    return lambda x: None
508
509        class MyClass(object):
510
511            some_attr = CrazyDescriptor()
512
513        mock = create_autospec(MyClass)
514        mock.some_attr(1)
515        with self.assertRaises(TypeError):
516            mock.some_attr()
517        with self.assertRaises(TypeError):
518            mock.some_attr(1, 2)
519
520
521    def test_spec_has_function_not_in_bases(self):
522
523        class CrazyClass(object):
524
525            def __dir__(self):
526                return super(CrazyClass, self).__dir__()+['crazy']
527
528            def __getattr__(self, item):
529                if item == 'crazy':
530                    return lambda x: x
531                raise AttributeError(item)
532
533        inst = CrazyClass()
534        with self.assertRaises(AttributeError):
535            inst.other
536        self.assertEqual(inst.crazy(42), 42)
537
538        mock = create_autospec(inst)
539        mock.crazy(42)
540        with self.assertRaises(TypeError):
541            mock.crazy()
542        with self.assertRaises(TypeError):
543            mock.crazy(1, 2)
544
545
546    def test_builtin_functions_types(self):
547        # we could replace builtin functions / methods with a function
548        # with *args / **kwargs signature. Using the builtin method type
549        # as a spec seems to work fairly well though.
550        class BuiltinSubclass(list):
551            def bar(self, arg): pass
552            sorted = sorted
553            attr = {}
554
555        mock = create_autospec(BuiltinSubclass)
556        mock.append(3)
557        mock.append.assert_called_with(3)
558        self.assertRaises(AttributeError, getattr, mock.append, 'foo')
559
560        mock.bar('foo')
561        mock.bar.assert_called_with('foo')
562        self.assertRaises(TypeError, mock.bar, 'foo', 'bar')
563        self.assertRaises(AttributeError, getattr, mock.bar, 'foo')
564
565        mock.sorted([1, 2])
566        mock.sorted.assert_called_with([1, 2])
567        self.assertRaises(AttributeError, getattr, mock.sorted, 'foo')
568
569        mock.attr.pop(3)
570        mock.attr.pop.assert_called_with(3)
571        self.assertRaises(AttributeError, getattr, mock.attr, 'foo')
572
573
574    def test_method_calls(self):
575        class Sub(SomeClass):
576            attr = SomeClass()
577
578        mock = create_autospec(Sub)
579        mock.one(1, 2)
580        mock.two()
581        mock.three(3)
582
583        expected = [call.one(1, 2), call.two(), call.three(3)]
584        self.assertEqual(mock.method_calls, expected)
585
586        mock.attr.one(1, 2)
587        mock.attr.two()
588        mock.attr.three(3)
589
590        expected.extend(
591            [call.attr.one(1, 2), call.attr.two(), call.attr.three(3)]
592        )
593        self.assertEqual(mock.method_calls, expected)
594
595
596    def test_magic_methods(self):
597        class BuiltinSubclass(list):
598            attr = {}
599
600        mock = create_autospec(BuiltinSubclass)
601        self.assertEqual(list(mock), [])
602        self.assertRaises(TypeError, int, mock)
603        self.assertRaises(TypeError, int, mock.attr)
604        self.assertEqual(list(mock), [])
605
606        self.assertIsInstance(mock['foo'], MagicMock)
607        self.assertIsInstance(mock.attr['foo'], MagicMock)
608
609
610    def test_spec_set(self):
611        class Sub(SomeClass):
612            attr = SomeClass()
613
614        for spec in (Sub, Sub()):
615            mock = create_autospec(spec, spec_set=True)
616            self._check_someclass_mock(mock)
617
618            self.assertRaises(AttributeError, setattr, mock, 'foo', 'bar')
619            self.assertRaises(AttributeError, setattr, mock.attr, 'foo', 'bar')
620
621
622    def test_descriptors(self):
623        class Foo(object):
624            @classmethod
625            def f(cls, a, b): pass
626            @staticmethod
627            def g(a, b): pass
628
629        class Bar(Foo): pass
630
631        class Baz(SomeClass, Bar): pass
632
633        for spec in (Foo, Foo(), Bar, Bar(), Baz, Baz()):
634            mock = create_autospec(spec)
635            mock.f(1, 2)
636            mock.f.assert_called_once_with(1, 2)
637
638            mock.g(3, 4)
639            mock.g.assert_called_once_with(3, 4)
640
641
642    def test_recursive(self):
643        class A(object):
644            def a(self): pass
645            foo = 'foo bar baz'
646            bar = foo
647
648        A.B = A
649        mock = create_autospec(A)
650
651        mock()
652        self.assertFalse(mock.B.called)
653
654        mock.a()
655        mock.B.a()
656        self.assertEqual(mock.method_calls, [call.a(), call.B.a()])
657
658        self.assertIs(A.foo, A.bar)
659        self.assertIsNot(mock.foo, mock.bar)
660        mock.foo.lower()
661        self.assertRaises(AssertionError, mock.bar.lower.assert_called_with)
662
663
664    def test_spec_inheritance_for_classes(self):
665        class Foo(object):
666            def a(self, x): pass
667            class Bar(object):
668                def f(self, y): pass
669
670        class_mock = create_autospec(Foo)
671
672        self.assertIsNot(class_mock, class_mock())
673
674        for this_mock in class_mock, class_mock():
675            this_mock.a(x=5)
676            this_mock.a.assert_called_with(x=5)
677            this_mock.a.assert_called_with(5)
678            self.assertRaises(TypeError, this_mock.a, 'foo', 'bar')
679            self.assertRaises(AttributeError, getattr, this_mock, 'b')
680
681        instance_mock = create_autospec(Foo())
682        instance_mock.a(5)
683        instance_mock.a.assert_called_with(5)
684        instance_mock.a.assert_called_with(x=5)
685        self.assertRaises(TypeError, instance_mock.a, 'foo', 'bar')
686        self.assertRaises(AttributeError, getattr, instance_mock, 'b')
687
688        # The return value isn't isn't callable
689        self.assertRaises(TypeError, instance_mock)
690
691        instance_mock.Bar.f(6)
692        instance_mock.Bar.f.assert_called_with(6)
693        instance_mock.Bar.f.assert_called_with(y=6)
694        self.assertRaises(AttributeError, getattr, instance_mock.Bar, 'g')
695
696        instance_mock.Bar().f(6)
697        instance_mock.Bar().f.assert_called_with(6)
698        instance_mock.Bar().f.assert_called_with(y=6)
699        self.assertRaises(AttributeError, getattr, instance_mock.Bar(), 'g')
700
701
702    def test_inherit(self):
703        class Foo(object):
704            a = 3
705
706        Foo.Foo = Foo
707
708        # class
709        mock = create_autospec(Foo)
710        instance = mock()
711        self.assertRaises(AttributeError, getattr, instance, 'b')
712
713        attr_instance = mock.Foo()
714        self.assertRaises(AttributeError, getattr, attr_instance, 'b')
715
716        # instance
717        mock = create_autospec(Foo())
718        self.assertRaises(AttributeError, getattr, mock, 'b')
719        self.assertRaises(TypeError, mock)
720
721        # attribute instance
722        call_result = mock.Foo()
723        self.assertRaises(AttributeError, getattr, call_result, 'b')
724
725
726    def test_builtins(self):
727        # used to fail with infinite recursion
728        create_autospec(1)
729
730        create_autospec(int)
731        create_autospec('foo')
732        create_autospec(str)
733        create_autospec({})
734        create_autospec(dict)
735        create_autospec([])
736        create_autospec(list)
737        create_autospec(set())
738        create_autospec(set)
739        create_autospec(1.0)
740        create_autospec(float)
741        create_autospec(1j)
742        create_autospec(complex)
743        create_autospec(False)
744        create_autospec(True)
745
746
747    def test_function(self):
748        def f(a, b): pass
749
750        mock = create_autospec(f)
751        self.assertRaises(TypeError, mock)
752        mock(1, 2)
753        mock.assert_called_with(1, 2)
754        mock.assert_called_with(1, b=2)
755        mock.assert_called_with(a=1, b=2)
756
757        f.f = f
758        mock = create_autospec(f)
759        self.assertRaises(TypeError, mock.f)
760        mock.f(3, 4)
761        mock.f.assert_called_with(3, 4)
762        mock.f.assert_called_with(a=3, b=4)
763
764
765    def test_skip_attributeerrors(self):
766        class Raiser(object):
767            def __get__(self, obj, type=None):
768                if obj is None:
769                    raise AttributeError('Can only be accessed via an instance')
770
771        class RaiserClass(object):
772            raiser = Raiser()
773
774            @staticmethod
775            def existing(a, b):
776                return a + b
777
778        self.assertEqual(RaiserClass.existing(1, 2), 3)
779        s = create_autospec(RaiserClass)
780        self.assertRaises(TypeError, lambda x: s.existing(1, 2, 3))
781        self.assertEqual(s.existing(1, 2), s.existing.return_value)
782        self.assertRaises(AttributeError, lambda: s.nonexisting)
783
784        # check we can fetch the raiser attribute and it has no spec
785        obj = s.raiser
786        obj.foo, obj.bar
787
788
789    def test_signature_class(self):
790        class Foo(object):
791            def __init__(self, a, b=3): pass
792
793        mock = create_autospec(Foo)
794
795        self.assertRaises(TypeError, mock)
796        mock(1)
797        mock.assert_called_once_with(1)
798        mock.assert_called_once_with(a=1)
799        self.assertRaises(AssertionError, mock.assert_called_once_with, 2)
800
801        mock(4, 5)
802        mock.assert_called_with(4, 5)
803        mock.assert_called_with(a=4, b=5)
804        self.assertRaises(AssertionError, mock.assert_called_with, a=5, b=4)
805
806
807    def test_class_with_no_init(self):
808        # this used to raise an exception
809        # due to trying to get a signature from object.__init__
810        class Foo(object):
811            pass
812        create_autospec(Foo)
813
814
815    def test_signature_callable(self):
816        class Callable(object):
817            def __init__(self, x, y): pass
818            def __call__(self, a): pass
819
820        mock = create_autospec(Callable)
821        mock(1, 2)
822        mock.assert_called_once_with(1, 2)
823        mock.assert_called_once_with(x=1, y=2)
824        self.assertRaises(TypeError, mock, 'a')
825
826        instance = mock(1, 2)
827        self.assertRaises(TypeError, instance)
828        instance(a='a')
829        instance.assert_called_once_with('a')
830        instance.assert_called_once_with(a='a')
831        instance('a')
832        instance.assert_called_with('a')
833        instance.assert_called_with(a='a')
834
835        mock = create_autospec(Callable(1, 2))
836        mock(a='a')
837        mock.assert_called_once_with(a='a')
838        self.assertRaises(TypeError, mock)
839        mock('a')
840        mock.assert_called_with('a')
841
842
843    def test_signature_noncallable(self):
844        class NonCallable(object):
845            def __init__(self):
846                pass
847
848        mock = create_autospec(NonCallable)
849        instance = mock()
850        mock.assert_called_once_with()
851        self.assertRaises(TypeError, mock, 'a')
852        self.assertRaises(TypeError, instance)
853        self.assertRaises(TypeError, instance, 'a')
854
855        mock = create_autospec(NonCallable())
856        self.assertRaises(TypeError, mock)
857        self.assertRaises(TypeError, mock, 'a')
858
859
860    def test_create_autospec_none(self):
861        class Foo(object):
862            bar = None
863
864        mock = create_autospec(Foo)
865        none = mock.bar
866        self.assertNotIsInstance(none, type(None))
867
868        none.foo()
869        none.foo.assert_called_once_with()
870
871
872    def test_autospec_functions_with_self_in_odd_place(self):
873        class Foo(object):
874            def f(a, self): pass
875
876        a = create_autospec(Foo)
877        a.f(10)
878        a.f.assert_called_with(10)
879        a.f.assert_called_with(self=10)
880        a.f(self=10)
881        a.f.assert_called_with(10)
882        a.f.assert_called_with(self=10)
883
884
885    def test_autospec_data_descriptor(self):
886        class Descriptor(object):
887            def __init__(self, value):
888                self.value = value
889
890            def __get__(self, obj, cls=None):
891                return self
892
893            def __set__(self, obj, value): pass
894
895        class MyProperty(property):
896            pass
897
898        class Foo(object):
899            __slots__ = ['slot']
900
901            @property
902            def prop(self): pass
903
904            @MyProperty
905            def subprop(self): pass
906
907            desc = Descriptor(42)
908
909        foo = create_autospec(Foo)
910
911        def check_data_descriptor(mock_attr):
912            # Data descriptors don't have a spec.
913            self.assertIsInstance(mock_attr, MagicMock)
914            mock_attr(1, 2, 3)
915            mock_attr.abc(4, 5, 6)
916            mock_attr.assert_called_once_with(1, 2, 3)
917            mock_attr.abc.assert_called_once_with(4, 5, 6)
918
919        # property
920        check_data_descriptor(foo.prop)
921        # property subclass
922        check_data_descriptor(foo.subprop)
923        # class __slot__
924        check_data_descriptor(foo.slot)
925        # plain data descriptor
926        check_data_descriptor(foo.desc)
927
928
929    def test_autospec_on_bound_builtin_function(self):
930        meth = types.MethodType(time.ctime, time.time())
931        self.assertIsInstance(meth(), str)
932        mocked = create_autospec(meth)
933
934        # no signature, so no spec to check against
935        mocked()
936        mocked.assert_called_once_with()
937        mocked.reset_mock()
938        mocked(4, 5, 6)
939        mocked.assert_called_once_with(4, 5, 6)
940
941
942    def test_autospec_getattr_partial_function(self):
943        # bpo-32153 : getattr returning partial functions without
944        # __name__ should not create AttributeError in create_autospec
945        class Foo:
946
947            def __getattr__(self, attribute):
948                return partial(lambda name: name, attribute)
949
950        proxy = Foo()
951        autospec = create_autospec(proxy)
952        self.assertFalse(hasattr(autospec, '__name__'))
953
954
955    def test_spec_inspect_signature(self):
956
957        def myfunc(x, y): pass
958
959        mock = create_autospec(myfunc)
960        mock(1, 2)
961        mock(x=1, y=2)
962
963        self.assertEqual(inspect.signature(mock), inspect.signature(myfunc))
964        self.assertEqual(mock.mock_calls, [call(1, 2), call(x=1, y=2)])
965        self.assertRaises(TypeError, mock, 1)
966
967
968    def test_spec_inspect_signature_annotations(self):
969
970        def foo(a: int, b: int=10, *, c:int) -> int:
971            return a + b + c
972
973        self.assertEqual(foo(1, 2 , c=3), 6)
974        mock = create_autospec(foo)
975        mock(1, 2, c=3)
976        mock(1, c=3)
977
978        self.assertEqual(inspect.signature(mock), inspect.signature(foo))
979        self.assertEqual(mock.mock_calls, [call(1, 2, c=3), call(1, c=3)])
980        self.assertRaises(TypeError, mock, 1)
981        self.assertRaises(TypeError, mock, 1, 2, 3, c=4)
982
983
984    def test_spec_function_no_name(self):
985        func = lambda: 'nope'
986        mock = create_autospec(func)
987        self.assertEqual(mock.__name__, 'funcopy')
988
989
990    def test_spec_function_assert_has_calls(self):
991        def f(a): pass
992        mock = create_autospec(f)
993        mock(1)
994        mock.assert_has_calls([call(1)])
995        with self.assertRaises(AssertionError):
996            mock.assert_has_calls([call(2)])
997
998
999    def test_spec_function_assert_any_call(self):
1000        def f(a): pass
1001        mock = create_autospec(f)
1002        mock(1)
1003        mock.assert_any_call(1)
1004        with self.assertRaises(AssertionError):
1005            mock.assert_any_call(2)
1006
1007
1008    def test_spec_function_reset_mock(self):
1009        def f(a): pass
1010        rv = Mock()
1011        mock = create_autospec(f, return_value=rv)
1012        mock(1)(2)
1013        self.assertEqual(mock.mock_calls, [call(1)])
1014        self.assertEqual(rv.mock_calls, [call(2)])
1015        mock.reset_mock()
1016        self.assertEqual(mock.mock_calls, [])
1017        self.assertEqual(rv.mock_calls, [])
1018
1019
1020class TestCallList(unittest.TestCase):
1021
1022    def test_args_list_contains_call_list(self):
1023        mock = Mock()
1024        self.assertIsInstance(mock.call_args_list, _CallList)
1025
1026        mock(1, 2)
1027        mock(a=3)
1028        mock(3, 4)
1029        mock(b=6)
1030
1031        for kall in call(1, 2), call(a=3), call(3, 4), call(b=6):
1032            self.assertIn(kall, mock.call_args_list)
1033
1034        calls = [call(a=3), call(3, 4)]
1035        self.assertIn(calls, mock.call_args_list)
1036        calls = [call(1, 2), call(a=3)]
1037        self.assertIn(calls, mock.call_args_list)
1038        calls = [call(3, 4), call(b=6)]
1039        self.assertIn(calls, mock.call_args_list)
1040        calls = [call(3, 4)]
1041        self.assertIn(calls, mock.call_args_list)
1042
1043        self.assertNotIn(call('fish'), mock.call_args_list)
1044        self.assertNotIn([call('fish')], mock.call_args_list)
1045
1046
1047    def test_call_list_str(self):
1048        mock = Mock()
1049        mock(1, 2)
1050        mock.foo(a=3)
1051        mock.foo.bar().baz('fish', cat='dog')
1052
1053        expected = (
1054            "[call(1, 2),\n"
1055            " call.foo(a=3),\n"
1056            " call.foo.bar(),\n"
1057            " call.foo.bar().baz('fish', cat='dog')]"
1058        )
1059        self.assertEqual(str(mock.mock_calls), expected)
1060
1061
1062    def test_propertymock(self):
1063        p = patch('%s.SomeClass.one' % __name__, new_callable=PropertyMock)
1064        mock = p.start()
1065        try:
1066            SomeClass.one
1067            mock.assert_called_once_with()
1068
1069            s = SomeClass()
1070            s.one
1071            mock.assert_called_with()
1072            self.assertEqual(mock.mock_calls, [call(), call()])
1073
1074            s.one = 3
1075            self.assertEqual(mock.mock_calls, [call(), call(), call(3)])
1076        finally:
1077            p.stop()
1078
1079
1080    def test_propertymock_returnvalue(self):
1081        m = MagicMock()
1082        p = PropertyMock()
1083        type(m).foo = p
1084
1085        returned = m.foo
1086        p.assert_called_once_with()
1087        self.assertIsInstance(returned, MagicMock)
1088        self.assertNotIsInstance(returned, PropertyMock)
1089
1090
1091class TestCallablePredicate(unittest.TestCase):
1092
1093    def test_type(self):
1094        for obj in [str, bytes, int, list, tuple, SomeClass]:
1095            self.assertTrue(_callable(obj))
1096
1097    def test_call_magic_method(self):
1098        class Callable:
1099            def __call__(self): pass
1100        instance = Callable()
1101        self.assertTrue(_callable(instance))
1102
1103    def test_staticmethod(self):
1104        class WithStaticMethod:
1105            @staticmethod
1106            def staticfunc(): pass
1107        self.assertTrue(_callable(WithStaticMethod.staticfunc))
1108
1109    def test_non_callable_staticmethod(self):
1110        class BadStaticMethod:
1111            not_callable = staticmethod(None)
1112        self.assertFalse(_callable(BadStaticMethod.not_callable))
1113
1114    def test_classmethod(self):
1115        class WithClassMethod:
1116            @classmethod
1117            def classfunc(cls): pass
1118        self.assertTrue(_callable(WithClassMethod.classfunc))
1119
1120    def test_non_callable_classmethod(self):
1121        class BadClassMethod:
1122            not_callable = classmethod(None)
1123        self.assertFalse(_callable(BadClassMethod.not_callable))
1124
1125
1126if __name__ == '__main__':
1127    unittest.main()
1128