Python mock.call_count方法代码示例

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
def test_limit_fn(fails):

    start = time.time()
    count = [0]

    def limit_1_sec(attempt_number):
        """Create a limiter that allows as many calls as possible in 0.1s"""
        count[0] += 1
        if time.time() - start > 0.1:
            raise retrace.LimitReached()

    wrapped = retrace.retry(limit=limit_1_sec)(fails)

    with pytest.raises(conftest.CustomException):
        wrapped()

    assert fails.call_count == count[0] 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
def test_limit_class(fails):
    class LimitSeconds(object):
        def __init__(self, seconds):
            self.seconds = seconds
            self.count = 0
            self.start = None

        def __call__(self, attempt_number):
            """Create a limiter that allows as many calls as possible in 0.1s"""

            if self.start is None:
                self.start = time.time()

            self.count += 1
            if time.time() - self.start > self.seconds:
                raise retrace.LimitReached()

    limiter = LimitSeconds(0.1)
    wrapped = retrace.retry(limit=limiter)(fails)

    with pytest.raises(conftest.CustomException):
        wrapped()

    assert fails.call_count == limiter.count 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
def test_dn_cached(self, mock):
        self._init_settings(
            USER_SEARCH=LDAPSearch(
                "ou=people,o=test", ldap.SCOPE_SUBTREE, "(uid=%(user)s)"
            ),
            CACHE_TIMEOUT=60,
        )
        for _ in range(2):
            user = authenticate(username="alice", password="password")
            self.assertIsNotNone(user)
        # Should have executed only once.
        self.assertEqual(mock.call_count, 1)
        # DN is cached.
        self.assertEqual(
            cache.get("django_auth_ldap.user_dn.alice"), "uid=alice,ou=people,o=test"
        ) 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
def test_fails_then_pass(fail_then_pass):
    mock, fail_then_pass = fail_then_pass
    wrapped = retrace.retry()(fail_then_pass)
    assert wrapped() == "PASS"
    assert mock.call_count == 5 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
def test_fails_4_times_and_hits_limit(fail_then_pass):
    mock, fail_then_pass = fail_then_pass
    wrapped = retrace.retry(limit=4)(fail_then_pass)
    with pytest.raises(KeyError):
        wrapped()
    assert mock.call_count == 4 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
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") 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
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") 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
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") 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
def test_group_cache(self, mock):
        self._init_settings(
            USER_DN_TEMPLATE="uid=%(user)s,ou=people,o=test",
            GROUP_SEARCH=LDAPSearch("ou=groups,o=test", ldap.SCOPE_SUBTREE),
            GROUP_TYPE=MemberDNGroupType(member_attr="member"),
            FIND_GROUP_PERMS=True,
            CACHE_TIMEOUT=3600,
        )
        self._init_groups()

        backend = get_backend()
        alice_id = User.objects.create(username="alice").pk
        bob_id = User.objects.create(username="bob").pk

        # Check permissions twice for each user
        for i in range(2):
            alice = backend.get_user(alice_id)
            self.assertEqual(
                backend.get_group_permissions(alice),
                {"auth.add_user", "auth.change_user"},
            )

            bob = backend.get_user(bob_id)
            self.assertEqual(backend.get_group_permissions(bob), set())

        # Should have executed one LDAP search per user
        self.assertEqual(mock.call_count, 2) 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
def test_dn_not_cached(self, mock):
        self._init_settings(
            USER_SEARCH=LDAPSearch(
                "ou=people,o=test", ldap.SCOPE_SUBTREE, "(uid=%(user)s)"
            )
        )
        for _ in range(2):
            user = authenticate(username="alice", password="password")
            self.assertIsNotNone(user)
        # Should have executed once per auth.
        self.assertEqual(mock.call_count, 2)
        # DN is not cached.
        self.assertIsNone(cache.get("django_auth_ldap.user_dn.alice")) 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
def assert_not_called(mock):
    assert mock.call_count == 0 

# 需要导入模块: import mock [as 别名]
# 或者: from mock import call_count [as 别名]
def assert_called_once(mock):
    assert mock.call_count == 1