text: # 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 unittest2 as unittest
  from mock.tests.support import inPy3k
  
  from mock import (
      call, create_autospec, MagicMock,
      Mock, ANY, patch, PropertyMock
  )
  from mock.mock import _Call, _CallList
  
  from datetime import datetime
  
  class SomeClass(object):
      def one(self, a, b):
          pass
      def two(self):
          pass
      def three(self, a=None):
          pass
  
  
  
  class AnyTest(unittest.TestCase):
  
      def test_any(self):
          self.assertEqual(ANY, object())
  
          mock = Mock()
          mock(ANY)
          mock.assert_called_with(ANY)
  
          mock = Mock()
          mock(foo=ANY)
          mock.assert_called_with(foo=ANY)
  
      def test_repr(self):
          self.assertEqual(repr(ANY), '<ANY>')
          self.assertEqual(str(ANY), '<ANY>')
  
  
      def test_any_and_datetime(self):
          mock = Mock()
          mock(datetime.now(), foo=datetime.now())
  
          mock.assert_called_with(ANY, foo=ANY)
  
  
      def test_any_mock_calls_comparison_order(self):
          mock = Mock()
          d = datetime.now()
          class Foo(object):
              def __eq__(self, other):
                  return False
              def __ne__(self, other):
                  return True
  
          for d in datetime.now(), Foo():
              mock.reset_mock()
  
              mock(d, foo=d, bar=d)
              mock.method(d, zinga=d, alpha=d)
              mock().method(a1=d, z99=d)
  
              expected = [
                  call(ANY, foo=ANY, bar=ANY),
                  call.method(ANY, zinga=ANY, alpha=ANY),
                  call(), call().method(a1=ANY, z99=ANY)
              ]
              self.assertEqual(expected, mock.mock_calls)
              self.assertEqual(mock.mock_calls, expected)
  
  
  
  class CallTest(unittest.TestCase):
  
      def test_call_with_call(self):
          kall = _Call()
          self.assertEqual(kall, _Call())
          self.assertEqual(kall, _Call(('',)))
          self.assertEqual(kall, _Call(((),)))
          self.assertEqual(kall, _Call(({},)))
          self.assertEqual(kall, _Call(('', ())))
          self.assertEqual(kall, _Call(('', {})))
          self.assertEqual(kall, _Call(('', (), {})))
          self.assertEqual(kall, _Call(('foo',)))
          self.assertEqual(kall, _Call(('bar', ())))
          self.assertEqual(kall, _Call(('baz', {})))
          self.assertEqual(kall, _Call(('spam', (), {})))
  
          kall = _Call(((1, 2, 3),))
          self.assertEqual(kall, _Call(((1, 2, 3),)))
          self.assertEqual(kall, _Call(('', (1, 2, 3))))
          self.assertEqual(kall, _Call(((1, 2, 3), {})))
          self.assertEqual(kall, _Call(('', (1, 2, 3), {})))
  
          kall = _Call(((1, 2, 4),))
          self.assertNotEqual(kall, _Call(('', (1, 2, 3))))
          self.assertNotEqual(kall, _Call(('', (1, 2, 3), {})))
  
          kall = _Call(('foo', (1, 2, 4),))
          self.assertNotEqual(kall, _Call(('', (1, 2, 4))))
          self.assertNotEqual(kall, _Call(('', (1, 2, 4), {})))
          self.assertNotEqual(kall, _Call(('bar', (1, 2, 4))))
          self.assertNotEqual(kall, _Call(('bar', (1, 2, 4), {})))
  
          kall = _Call(({'a': 3},))
          self.assertEqual(kall, _Call(('', (), {'a': 3})))
          self.assertEqual(kall, _Call(('', {'a': 3})))
          self.assertEqual(kall, _Call(((), {'a': 3})))
          self.assertEqual(kall, _Call(({'a': 3},)))
  
  
      def test_empty__Call(self):
          args = _Call()
  
          self.assertEqual(args, ())
          self.assertEqual(args, ('foo',))
          self.assertEqual(args, ((),))
          self.assertEqual(args, ('foo', ()))
          self.assertEqual(args, ('foo',(), {}))
          self.assertEqual(args, ('foo', {}))
          self.assertEqual(args, ({},))
  
  
      def test_named_empty_call(self):
          args = _Call(('foo', (), {}))
  
          self.assertEqual(args, ('foo',))
          self.assertEqual(args, ('foo', ()))
          self.assertEqual(args, ('foo',(), {}))
          self.assertEqual(args, ('foo', {}))
  
          self.assertNotEqual(args, ((),))
          self.assertNotEqual(args, ())
          self.assertNotEqual(args, ({},))
          self.assertNotEqual(args, ('bar',))
          self.assertNotEqual(args, ('bar', ()))
          self.assertNotEqual(args, ('bar', {}))
  
  
      def test_call_with_args(self):
          args = _Call(((1, 2, 3), {}))
  
          self.assertEqual(args, ((1, 2, 3),))
          self.assertEqual(args, ('foo', (1, 2, 3)))
          self.assertEqual(args, ('foo', (1, 2, 3), {}))
          self.assertEqual(args, ((1, 2, 3), {}))
  
  
      def test_named_call_with_args(self):
          args = _Call(('foo', (1, 2, 3), {}))
  
          self.assertEqual(args, ('foo', (1, 2, 3)))
          self.assertEqual(args, ('foo', (1, 2, 3), {}))
  
          self.assertNotEqual(args, ((1, 2, 3),))
          self.assertNotEqual(args, ((1, 2, 3), {}))
  
  
      def test_call_with_kwargs(self):
          args = _Call(((), dict(a=3, b=4)))
  
          self.assertEqual(args, (dict(a=3, b=4),))
          self.assertEqual(args, ('foo', dict(a=3, b=4)))
          self.assertEqual(args, ('foo', (), dict(a=3, b=4)))
          self.assertEqual(args, ((), dict(a=3, b=4)))
  
  
      def test_named_call_with_kwargs(self):
          args = _Call(('foo', (), dict(a=3, b=4)))
  
          self.assertEqual(args, ('foo', dict(a=3, b=4)))
          self.assertEqual(args, ('foo', (), dict(a=3, b=4)))
  
          self.assertNotEqual(args, (dict(a=3, b=4),))
          self.assertNotEqual(args, ((), dict(a=3, b=4)))
  
  
      def test_call_with_args_call_empty_name(self):
          args = _Call(((1, 2, 3), {}))
          self.assertEqual(args, call(1, 2, 3))
          self.assertEqual(call(1, 2, 3), args)
          self.assertIn(call(1, 2, 3), [args])
  
  
      def test_call_ne(self):
          self.assertNotEqual(_Call(((1, 2, 3),)), call(1, 2))
          self.assertFalse(_Call(((1, 2, 3),)) != call(1, 2, 3))
          self.assertTrue(_Call(((1, 2), {})) != call(1, 2, 3))
  
  
      def test_call_non_tuples(self):
          kall = _Call(((1, 2, 3),))
          for value in 1, None, self, int:
              self.assertNotEqual(kall, value)
              self.assertFalse(kall == value)
  
  
      def test_repr(self):
          self.assertEqual(repr(_Call()), 'call()')
          self.assertEqual(repr(_Call(('foo',))), 'call.foo()')
  
          self.assertEqual(repr(_Call(((1, 2, 3), {'a': 'b'}))),
                           "call(1, 2, 3, a='b')")
          self.assertEqual(repr(_Call(('bar', (1, 2, 3), {'a': 'b'}))),
                           "call.bar(1, 2, 3, a='b')")
  
          self.assertEqual(repr(call), 'call')
          self.assertEqual(str(call), 'call')
  
          self.assertEqual(repr(call()), 'call()')
          self.assertEqual(repr(call(1)), 'call(1)')
          self.assertEqual(repr(call(zz='thing')), "call(zz='thing')")
  
          self.assertEqual(repr(call().foo), 'call().foo')
          self.assertEqual(repr(call(1).foo.bar(a=3).bing),
                           'call().foo.bar().bing')
          self.assertEqual(
              repr(call().foo(1, 2, a=3)),
              "call().foo(1, 2, a=3)"
          )
          self.assertEqual(repr(call()()), "call()()")
          self.assertEqual(repr(call(1)(2)), "call()(2)")
          self.assertEqual(
              repr(call()().bar().baz.beep(1)),
              "call()().bar().baz.beep(1)"
          )
  
  
      def test_call(self):
          self.assertEqual(call(), ('', (), {}))
          self.assertEqual(call('foo', 'bar', one=3, two=4),
                           ('', ('foo', 'bar'), {'one': 3, 'two': 4}))
  
          mock = Mock()
          mock(1, 2, 3)
          mock(a=3, b=6)
          self.assertEqual(mock.call_args_list,
                           [call(1, 2, 3), call(a=3, b=6)])
  
      def test_attribute_call(self):
          self.assertEqual(call.foo(1), ('foo', (1,), {}))
          self.assertEqual(call.bar.baz(fish='eggs'),
                           ('bar.baz', (), {'fish': 'eggs'}))
  
          mock = Mock()
          mock.foo(1, 2 ,3)
          mock.bar.baz(a=3, b=6)
          self.assertEqual(mock.method_calls,
                           [call.foo(1, 2, 3), call.bar.baz(a=3, b=6)])
  
  
      def test_extended_call(self):
          result = call(1).foo(2).bar(3, a=4)
          self.assertEqual(result, ('().foo().bar', (3,), dict(a=4)))
  
          mock = MagicMock()
          mock(1, 2, a=3, b=4)
          self.assertEqual(mock.call_args, call(1, 2, a=3, b=4))
          self.assertNotEqual(mock.call_args, call(1, 2, 3))
  
          self.assertEqual(mock.call_args_list, [call(1, 2, a=3, b=4)])
          self.assertEqual(mock.mock_calls, [call(1, 2, a=3, b=4)])
  
          mock = MagicMock()
          mock.foo(1).bar()().baz.beep(a=6)
  
          last_call = call.foo(1).bar()().baz.beep(a=6)
          self.assertEqual(mock.mock_calls[-1], last_call)
          self.assertEqual(mock.mock_calls, last_call.call_list())
  
  
      def test_call_list(self):
          mock = MagicMock()
          mock(1)
          self.assertEqual(call(1).call_list(), mock.mock_calls)
  
          mock = MagicMock()
          mock(1).method(2)
          self.assertEqual(call(1).method(2).call_list(),
                           mock.mock_calls)
  
          mock = MagicMock()
          mock(1).method(2)(3)
          self.assertEqual(call(1).method(2)(3).call_list(),
                           mock.mock_calls)
  
          mock = MagicMock()
          int(mock(1).method(2)(3).foo.bar.baz(4)(5))
          kall = call(1).method(2)(3).foo.bar.baz(4)(5).__int__()
          self.assertEqual(kall.call_list(), mock.mock_calls)
  
  
      def test_call_any(self):
          self.assertEqual(call, ANY)
  
          m = MagicMock()
          int(m)
          self.assertEqual(m.mock_calls, [ANY])
          self.assertEqual([ANY], m.mock_calls)
  
  
      def test_two_args_call(self):
          args = _Call(((1, 2), {'a': 3}), two=True)
          self.assertEqual(len(args), 2)
          self.assertEqual(args[0], (1, 2))
          self.assertEqual(args[1], {'a': 3})
  
          other_args = _Call(((1, 2), {'a': 3}))
          self.assertEqual(args, other_args)
  
  
  class SpecSignatureTest(unittest.TestCase):
  
      def _check_someclass_mock(self, mock):
          self.assertRaises(AttributeError, getattr, mock, 'foo')
          mock.one(1, 2)
          mock.one.assert_called_with(1, 2)
          self.assertRaises(AssertionError,
                            mock.one.assert_called_with, 3, 4)
          self.assertRaises(TypeError, mock.one, 1)
  
          mock.two()
          mock.two.assert_called_with()
          self.assertRaises(AssertionError,
                            mock.two.assert_called_with, 3)
          self.assertRaises(TypeError, mock.two, 1)
  
          mock.three()
          mock.three.assert_called_with()
          self.assertRaises(AssertionError,
                            mock.three.assert_called_with, 3)
          self.assertRaises(TypeError, mock.three, 3, 2)
  
          mock.three(1)
          mock.three.assert_called_with(1)
  
          mock.three(a=1)
          mock.three.assert_called_with(a=1)
  
  
      def test_basic(self):
          mock = create_autospec(SomeClass)
          self._check_someclass_mock(mock)
          mock = create_autospec(SomeClass())
          self._check_someclass_mock(mock)
  
  
      def test_create_autospec_return_value(self):
          def f():
              pass
          mock = create_autospec(f, return_value='foo')
          self.assertEqual(mock(), 'foo')
  
          class Foo(object):
              pass
  
          mock = create_autospec(Foo, return_value='foo')
          self.assertEqual(mock(), 'foo')
  
  
      def test_autospec_reset_mock(self):
          m = create_autospec(int)
          int(m)
          m.reset_mock()
          self.assertEqual(m.__int__.call_count, 0)
  
  
      def test_mocking_unbound_methods(self):
          class Foo(object):
              def foo(self, foo):
                  pass
          p = patch.object(Foo, 'foo')
          mock_foo = p.start()
          Foo().foo(1)
  
          mock_foo.assert_called_with(1)
  
  
      @unittest.expectedFailure
      def test_create_autospec_unbound_methods(self):
          # see mock issue 128
          class Foo(object):
              def foo(self):
                  pass
  
          klass = create_autospec(Foo)
          instance = klass()
          self.assertRaises(TypeError, instance.foo, 1)
  
          # Note: no type checking on the "self" parameter
          klass.foo(1)
          klass.foo.assert_called_with(1)
          self.assertRaises(TypeError, klass.foo)
  
  
      def test_create_autospec_keyword_arguments(self):
          class Foo(object):
              a = 3
          m = create_autospec(Foo, a='3')
          self.assertEqual(m.a, '3')
  
      @unittest.skipUnless(inPy3k, "Keyword only arguments Python 3 specific")
      def test_create_autospec_keyword_only_arguments(self):
          func_def = "def foo(a, *, b=None):\n    pass\n"
          namespace = {}
          exec (func_def, namespace)
          foo = namespace['foo']
  
          m = create_autospec(foo)
          m(1)
          m.assert_called_with(1)
          self.assertRaises(TypeError, m, 1, 2)
  
          m(2, b=3)
          m.assert_called_with(2, b=3)
  
      def test_function_as_instance_attribute(self):
          obj = SomeClass()
          def f(a):
              pass
          obj.f = f
  
          mock = create_autospec(obj)
          mock.f('bing')
          mock.f.assert_called_with('bing')
  
  
      def test_spec_as_list(self):
          # because spec as a list of strings in the mock constructor means
          # something very different we treat a list instance as the type.
          mock = create_autospec([])
          mock.append('foo')
          mock.append.assert_called_with('foo')
  
          self.assertRaises(AttributeError, getattr, mock, 'foo')
  
          class Foo(object):
              foo = []
  
          mock = create_autospec(Foo)
          mock.foo.append(3)
          mock.foo.append.assert_called_with(3)
          self.assertRaises(AttributeError, getattr, mock.foo, 'foo')
  
  
      def test_attributes(self):
          class Sub(SomeClass):
              attr = SomeClass()
  
          sub_mock = create_autospec(Sub)
  
          for mock in (sub_mock, sub_mock.attr):
              self._check_someclass_mock(mock)
  
  
      def test_builtin_functions_types(self):
          # we could replace builtin functions / methods with a function
          # with *args / **kwargs signature. Using the builtin method type
          # as a spec seems to work fairly well though.
          class BuiltinSubclass(list):
              def bar(self, arg):
                  pass
              sorted = sorted
              attr = {}
  
          mock = create_autospec(BuiltinSubclass)
          mock.append(3)
          mock.append.assert_called_with(3)
          self.assertRaises(AttributeError, getattr, mock.append, 'foo')
  
          mock.bar('foo')
          mock.bar.assert_called_with('foo')
          self.assertRaises(TypeError, mock.bar, 'foo', 'bar')
          self.assertRaises(AttributeError, getattr, mock.bar, 'foo')
  
          mock.sorted([1, 2])
          mock.sorted.assert_called_with([1, 2])
          self.assertRaises(AttributeError, getattr, mock.sorted, 'foo')
  
          mock.attr.pop(3)
          mock.attr.pop.assert_called_with(3)
          self.assertRaises(AttributeError, getattr, mock.attr, 'foo')
  
  
      def test_method_calls(self):
          class Sub(SomeClass):
              attr = SomeClass()
  
          mock = create_autospec(Sub)
          mock.one(1, 2)
          mock.two()
          mock.three(3)
  
          expected = [call.one(1, 2), call.two(), call.three(3)]
          self.assertEqual(mock.method_calls, expected)
  
          mock.attr.one(1, 2)
          mock.attr.two()
          mock.attr.three(3)
  
          expected.extend(
              [call.attr.one(1, 2), call.attr.two(), call.attr.three(3)]
          )
          self.assertEqual(mock.method_calls, expected)
  
  
      def test_magic_methods(self):
          class BuiltinSubclass(list):
              attr = {}
  
          mock = create_autospec(BuiltinSubclass)
          self.assertEqual(list(mock), [])
          self.assertRaises(TypeError, int, mock)
          self.assertRaises(TypeError, int, mock.attr)
          self.assertEqual(list(mock), [])
  
          self.assertIsInstance(mock['foo'], MagicMock)
          self.assertIsInstance(mock.attr['foo'], MagicMock)
  
  
      def test_spec_set(self):
          class Sub(SomeClass):
              attr = SomeClass()
  
          for spec in (Sub, Sub()):
              mock = create_autospec(spec, spec_set=True)
              self._check_someclass_mock(mock)
  
              self.assertRaises(AttributeError, setattr, mock, 'foo', 'bar')
              self.assertRaises(AttributeError, setattr, mock.attr, 'foo', 'bar')
  
  
      def test_descriptors(self):
          class Foo(object):
              @classmethod
              def f(cls, a, b):
                  pass
              @staticmethod
              def g(a, b):
                  pass
  
          class Bar(Foo):
              pass
  
          class Baz(SomeClass, Bar):
              pass
  
          for spec in (Foo, Foo(), Bar, Bar(), Baz, Baz()):
              mock = create_autospec(spec)
              mock.f(1, 2)
              mock.f.assert_called_once_with(1, 2)
  
              mock.g(3, 4)
              mock.g.assert_called_once_with(3, 4)
  
  
      @unittest.skipIf(inPy3k, "No old style classes in Python 3")
      def test_old_style_classes(self):
          class Foo:
              def f(self, a, b):
                  pass
  
          class Bar(Foo):
              g = Foo()
  
          for spec in (Foo, Foo(), Bar, Bar()):
              mock = create_autospec(spec)
              mock.f(1, 2)
              mock.f.assert_called_once_with(1, 2)
  
              self.assertRaises(AttributeError, getattr, mock, 'foo')
              self.assertRaises(AttributeError, getattr, mock.f, 'foo')
  
          mock.g.f(1, 2)
          mock.g.f.assert_called_once_with(1, 2)
          self.assertRaises(AttributeError, getattr, mock.g, 'foo')
  
  
      def test_recursive(self):
          class A(object):
              def a(self):
                  pass
              foo = 'foo bar baz'
              bar = foo
  
          A.B = A
          mock = create_autospec(A)
  
          mock()
          self.assertFalse(mock.B.called)
  
          mock.a()
          mock.B.a()
          self.assertEqual(mock.method_calls, [call.a(), call.B.a()])
  
          self.assertIs(A.foo, A.bar)
          self.assertIsNot(mock.foo, mock.bar)
          mock.foo.lower()
          self.assertRaises(AssertionError, mock.bar.lower.assert_called_with)
  
  
      def test_spec_inheritance_for_classes(self):
          class Foo(object):
              def a(self, x):
                  pass
              class Bar(object):
                  def f(self, y):
                      pass
  
          class_mock = create_autospec(Foo)
  
          self.assertIsNot(class_mock, class_mock())
  
          for this_mock in class_mock, class_mock():
              this_mock.a(x=5)
              this_mock.a.assert_called_with(x=5)
              this_mock.a.assert_called_with(5)
              self.assertRaises(TypeError, this_mock.a, 'foo', 'bar')
              self.assertRaises(AttributeError, getattr, this_mock, 'b')
  
          instance_mock = create_autospec(Foo())
          instance_mock.a(5)
          instance_mock.a.assert_called_with(5)
          instance_mock.a.assert_called_with(x=5)
          self.assertRaises(TypeError, instance_mock.a, 'foo', 'bar')
          self.assertRaises(AttributeError, getattr, instance_mock, 'b')
  
          # The return value isn't isn't callable
          self.assertRaises(TypeError, instance_mock)
  
          instance_mock.Bar.f(6)
          instance_mock.Bar.f.assert_called_with(6)
          instance_mock.Bar.f.assert_called_with(y=6)
          self.assertRaises(AttributeError, getattr, instance_mock.Bar, 'g')
  
          instance_mock.Bar().f(6)
          instance_mock.Bar().f.assert_called_with(6)
          instance_mock.Bar().f.assert_called_with(y=6)
          self.assertRaises(AttributeError, getattr, instance_mock.Bar(), 'g')
  
  
      def test_inherit(self):
          class Foo(object):
              a = 3
  
          Foo.Foo = Foo
  
          # class
          mock = create_autospec(Foo)
          instance = mock()
          self.assertRaises(AttributeError, getattr, instance, 'b')
  
          attr_instance = mock.Foo()
          self.assertRaises(AttributeError, getattr, attr_instance, 'b')
  
          # instance
          mock = create_autospec(Foo())
          self.assertRaises(AttributeError, getattr, mock, 'b')
          self.assertRaises(TypeError, mock)
  
          # attribute instance
          call_result = mock.Foo()
          self.assertRaises(AttributeError, getattr, call_result, 'b')
  
  
      def test_builtins(self):
          # used to fail with infinite recursion
          create_autospec(1)
  
          create_autospec(int)
          create_autospec('foo')
          create_autospec(str)
          create_autospec({})
          create_autospec(dict)
          create_autospec([])
          create_autospec(list)
          create_autospec(set())
          create_autospec(set)
          create_autospec(1.0)
          create_autospec(float)
          create_autospec(1j)
          create_autospec(complex)
          create_autospec(False)
          create_autospec(True)
  
  
      def test_function(self):
          def f(a, b):
              pass
  
          mock = create_autospec(f)
          self.assertRaises(TypeError, mock)
          mock(1, 2)
          mock.assert_called_with(1, 2)
          mock.assert_called_with(1, b=2)
          mock.assert_called_with(a=1, b=2)
  
          f.f = f
          mock = create_autospec(f)
          self.assertRaises(TypeError, mock.f)
          mock.f(3, 4)
          mock.f.assert_called_with(3, 4)
          mock.f.assert_called_with(a=3, b=4)
  
  
      def test_skip_attributeerrors(self):
          class Raiser(object):
              def __get__(self, obj, type=None):
                  if obj is None:
                      raise AttributeError('Can only be accessed via an instance')
  
          class RaiserClass(object):
              raiser = Raiser()
  
              @staticmethod
              def existing(a, b):
                  return a + b
  
          s = create_autospec(RaiserClass)
          self.assertRaises(TypeError, lambda x: s.existing(1, 2, 3))
          s.existing(1, 2)
          self.assertRaises(AttributeError, lambda: s.nonexisting)
  
          # check we can fetch the raiser attribute and it has no spec
          obj = s.raiser
          obj.foo, obj.bar
  
  
      def test_signature_class(self):
          class Foo(object):
              def __init__(self, a, b=3):
                  pass
  
          mock = create_autospec(Foo)
  
          self.assertRaises(TypeError, mock)
          mock(1)
          mock.assert_called_once_with(1)
  
          mock(4, 5)
          mock.assert_called_with(4, 5)
  
  
      @unittest.skipIf(inPy3k, 'no old style classes in Python 3')
      def test_signature_old_style_class(self):
          class Foo:
              def __init__(self, a, b=3):
                  pass
  
          mock = create_autospec(Foo)
  
          self.assertRaises(TypeError, mock)
          mock(1)
          mock.assert_called_once_with(1)
          mock.assert_called_once_with(a=1)
          self.assertRaises(AssertionError, mock.assert_called_once_with, 2)
  
          mock(4, 5)
          mock.assert_called_with(4, 5)
          mock.assert_called_with(a=4, b=5)
          self.assertRaises(AssertionError, mock.assert_called_with, a=5, b=4)
  
  
      def test_class_with_no_init(self):
          # this used to raise an exception
          # due to trying to get a signature from object.__init__
          class Foo(object):
              pass
          create_autospec(Foo)
  
  
      @unittest.skipIf(inPy3k, 'no old style classes in Python 3')
      def test_old_style_class_with_no_init(self):
          # this used to raise an exception
          # due to Foo.__init__ raising an AttributeError
          class Foo:
              pass
          create_autospec(Foo)
  
  
      def test_signature_callable(self):
          class Callable(object):
              def __init__(self, x, y):
                  pass
              def __call__(self, a):
                  pass
  
          mock = create_autospec(Callable)
          mock(1, 2)
          mock.assert_called_once_with(1, 2)
          mock.assert_called_once_with(x=1, y=2)
          self.assertRaises(TypeError, mock, 'a')
  
          instance = mock(1, 2)
          self.assertRaises(TypeError, instance)
          instance(a='a')
          instance.assert_called_once_with('a')
          instance.assert_called_once_with(a='a')
          instance('a')
          instance.assert_called_with('a')
          instance.assert_called_with(a='a')
  
          mock = create_autospec(Callable(1, 2))
          mock(a='a')
          mock.assert_called_once_with(a='a')
          self.assertRaises(TypeError, mock)
          mock('a')
          mock.assert_called_with('a')
  
  
      def test_signature_noncallable(self):
          class NonCallable(object):
              def __init__(self):
                  pass
  
          mock = create_autospec(NonCallable)
          instance = mock()
          mock.assert_called_once_with()
          self.assertRaises(TypeError, mock, 'a')
          self.assertRaises(TypeError, instance)
          self.assertRaises(TypeError, instance, 'a')
  
          mock = create_autospec(NonCallable())
          self.assertRaises(TypeError, mock)
          self.assertRaises(TypeError, mock, 'a')
  
  
      def test_create_autospec_none(self):
          class Foo(object):
              bar = None
  
          mock = create_autospec(Foo)
          none = mock.bar
          self.assertNotIsInstance(none, type(None))
  
          none.foo()
          none.foo.assert_called_once_with()
  
  
      def test_autospec_functions_with_self_in_odd_place(self):
          class Foo(object):
              def f(a, self):
                  pass
  
          a = create_autospec(Foo)
          a.f(10)
          a.f.assert_called_with(10)
          a.f.assert_called_with(self=10)
          a.f(self=10)
          a.f.assert_called_with(10)
          a.f.assert_called_with(self=10)
  
  
      def test_autospec_property(self):
          class Foo(object):
              @property
              def foo(self):
                  return 3
  
          foo = create_autospec(Foo)
          mock_property = foo.foo
  
          # no spec on properties
          self.assertIsInstance(mock_property, MagicMock)
          mock_property(1, 2, 3)
          mock_property.abc(4, 5, 6)
          mock_property.assert_called_once_with(1, 2, 3)
          mock_property.abc.assert_called_once_with(4, 5, 6)
  
  
      def test_autospec_slots(self):
          class Foo(object):
              __slots__ = ['a']
  
          foo = create_autospec(Foo)
          mock_slot = foo.a
  
          # no spec on slots
          mock_slot(1, 2, 3)
          mock_slot.abc(4, 5, 6)
          mock_slot.assert_called_once_with(1, 2, 3)
          mock_slot.abc.assert_called_once_with(4, 5, 6)
  
  
  class TestCallList(unittest.TestCase):
  
      def test_args_list_contains_call_list(self):
          mock = Mock()
          self.assertIsInstance(mock.call_args_list, _CallList)
  
          mock(1, 2)
          mock(a=3)
          mock(3, 4)
          mock(b=6)
  
          for kall in call(1, 2), call(a=3), call(3, 4), call(b=6):
              self.assertIn(kall, mock.call_args_list)
  
          calls = [call(a=3), call(3, 4)]
          self.assertIn(calls, mock.call_args_list)
          calls = [call(1, 2), call(a=3)]
          self.assertIn(calls, mock.call_args_list)
          calls = [call(3, 4), call(b=6)]
          self.assertIn(calls, mock.call_args_list)
          calls = [call(3, 4)]
          self.assertIn(calls, mock.call_args_list)
  
          self.assertNotIn(call('fish'), mock.call_args_list)
          self.assertNotIn([call('fish')], mock.call_args_list)
  
  
      def test_call_list_str(self):
          mock = Mock()
          mock(1, 2)
          mock.foo(a=3)
          mock.foo.bar().baz('fish', cat='dog')
  
          expected = (
              "[call(1, 2),\n"
              " call.foo(a=3),\n"
              " call.foo.bar(),\n"
              " call.foo.bar().baz('fish', cat='dog')]"
          )
          self.assertEqual(str(mock.mock_calls), expected)
  
  
      def test_propertymock(self):
          p = patch('%s.SomeClass.one' % __name__, new_callable=PropertyMock)
          mock = p.start()
          try:
              SomeClass.one
              mock.assert_called_once_with()
  
              s = SomeClass()
              s.one
              mock.assert_called_with()
              self.assertEqual(mock.mock_calls, [call(), call()])
  
              s.one = 3
              self.assertEqual(mock.mock_calls, [call(), call(), call(3)])
          finally:
              p.stop()
  
  
      def test_propertymock_returnvalue(self):
          m = MagicMock()
          p = PropertyMock()
          type(m).foo = p
  
          returned = m.foo
          p.assert_called_once_with()
          self.assertIsInstance(returned, MagicMock)
          self.assertNotIsInstance(returned, PropertyMock)
  
  
  if __name__ == '__main__':
      unittest.main()
  