Python support.is_instance函数代码示例

    def test_call(self):
        mock = Mock()
        self.assertTrue(is_instance(mock.return_value, Mock),
                        "Default return_value should be a Mock")

        result = mock()
        self.assertEqual(mock(), result,
                         "different result from consecutive calls")
        mock.reset_mock()

        ret_val = mock(sentinel.Arg)
        self.assertTrue(mock.called, "called not set")
        self.assertEqual(mock.call_count, 1, "call_count incoreect")
        self.assertEqual(mock.call_args, ((sentinel.Arg,), {}),
                         "call_args not set")
        self.assertEqual(mock.call_args_list, [((sentinel.Arg,), {})],
                         "call_args_list not initialised correctly")

        mock.return_value = sentinel.ReturnValue
        ret_val = mock(sentinel.Arg, key=sentinel.KeyArg)
        self.assertEqual(ret_val, sentinel.ReturnValue,
                         "incorrect return value")

        self.assertEqual(mock.call_count, 2, "call_count incorrect")
        self.assertEqual(mock.call_args,
                         ((sentinel.Arg,), {'key': sentinel.KeyArg}),
                         "call_args not set")
        self.assertEqual(mock.call_args_list, [
            ((sentinel.Arg,), {}),
            ((sentinel.Arg,), {'key': sentinel.KeyArg})
        ],
            "call_args_list not set")

    def test_constructor(self):
        mock = Mock()

        self.assertFalse(mock.called, "called not initialised correctly")
        self.assertEqual(mock.call_count, 0,
                         "call_count not initialised correctly")
        self.assertTrue(is_instance(mock.return_value, Mock),
                        "return_value not initialised correctly")

        self.assertEqual(mock.call_args, None,
                         "call_args not initialised correctly")
        self.assertEqual(mock.call_args_list, [],
                         "call_args_list not initialised correctly")
        self.assertEqual(mock.method_calls, [],
                          "method_calls not initialised correctly")

        # Can't use hasattr for this test as it always returns True on a mock
        self.assertNotIn('_items', mock.__dict__,
                         "default mock should not have '_items' attribute")

        self.assertIsNone(mock._mock_parent,
                          "parent not initialised correctly")
        self.assertIsNone(mock._mock_methods,
                          "methods not initialised correctly")
        self.assertEqual(mock._mock_children, {},
                         "children not initialised incorrectly")

    def test_patch_spec_callable_class(self):
        class CallableX(X):
            def __call__(self):
                pass

        class Sub(CallableX):
            pass

        class Multi(SomeClass, Sub):
            pass

        for arg in 'spec', 'spec_set':
            for Klass in CallableX, Sub, Multi:
                with patch('%s.X' % __name__, **{arg: Klass}) as mock:
                    instance = mock()
                    mock.assert_called_once_with()

                    self.assertTrue(is_instance(instance, MagicMock))
                    # inherited spec
                    self.assertRaises(AttributeError, getattr, instance,
                                      'foobarbaz')

                    result = instance()
                    # instance is callable, result has no spec
                    instance.assert_called_once_with()

                    result(3, 2, 1)
                    result.assert_called_once_with(3, 2, 1)
                    result.foo(3, 2, 1)
                    result.foo.assert_called_once_with(3, 2, 1)

 def test_attribute_access_returns_mocks(self):
     mock = Mock()
     something = mock.something
     self.assertTrue(is_instance(something, Mock), "attribute isn't a mock")
     self.assertEqual(mock.something, something, 'different attributes returned for same name')
     mock = Mock()
     mock.something.return_value = 3
     self.assertEqual(mock.something(), 3, 'method returned wrong value')
     self.assertTrue(mock.something.called, "method didn't record being called")

 def test_constructor(self):
     mock = Mock()
     self.assertFalse(mock.called, 'called not initialised correctly')
     self.assertEqual(mock.call_count, 0, 'call_count not initialised correctly')
     self.assertTrue(is_instance(mock.return_value, Mock), 'return_value not initialised correctly')
     self.assertEqual(mock.call_args, None, 'call_args not initialised correctly')
     self.assertEqual(mock.call_args_list, [], 'call_args_list not initialised correctly')
     self.assertEqual(mock.method_calls, [], 'method_calls not initialised correctly')
     self.assertNotIn('_items', mock.__dict__, "default mock should not have '_items' attribute")
     self.assertIsNone(mock._mock_parent, 'parent not initialised correctly')
     self.assertIsNone(mock._mock_methods, 'methods not initialised correctly')
     self.assertEqual(mock._mock_children, {}, 'children not initialised incorrectly')

 def test_with_statement_as(self):
     with patch("%s.something" % __name__) as mock_something:
         self.assertEqual(something, mock_something, "unpatched")
         self.assertTrue(is_instance(mock_something, MagicMock), "patching wrong type")
     self.assertEqual(something, sentinel.Something)

 def assertNotCallable(self, mock):
     self.assertTrue(is_instance(mock, NonCallableMagicMock))
     self.assertFalse(is_instance(mock, CallableMixin))