def setup_mocks(self):
mock_callable(
self.target_arg, self.callable_arg
).to_return_value("any args").and_assert_called_once()
mock_callable(self.target_arg, self.callable_arg).for_call(
*self.specific_call_args, **self.specific_call_kwargs
).to_return_value("specific").and_assert_called_twice()
def class_is_not_mocked(self):
mock_callable(self.target_arg, self.callable_arg).to_return_value(
"mocked value"
)
self.assertEqual(
self.callable_target(*self.call_args, **self.call_kwargs),
"mocked value",
)
self.assertEqual(
getattr(Target, self.callable_arg)(*self.call_args, **self.call_kwargs),
"original response",
)
def before(self):
target = Target()
self.original_callable = target.instance_method
self.real_target = target
self.target_arg = target
self.mock_callable_dsl = mock_callable(self.target_arg, self.callable_arg)
self.callable_target = target.instance_method
def before(self):
self.original_callable = Target.static_method
self.real_target = Target
self.target_arg = Target
self.callable_arg = "static_method"
self.mock_callable_dsl = mock_callable(self.target_arg, self.callable_arg)
self.callable_target = Target.static_method
def before(self):
self.original_callable = time.sleep
self.real_target = time
self.target_arg = "time"
self.callable_arg = "sleep"
self.mock_callable_dsl = mock_callable(self.target_arg, self.callable_arg)
self.callable_target = time.sleep
def before(self):
self.original_callable = testslide._test_function
self.real_target = testslide
self.target_arg = "testslide"
self.callable_arg = "_test_function"
self.mock_callable_dsl = mock_callable(self.target_arg, self.callable_arg)
self.callable_target = testslide._test_function
def before(self):
target = StrictMock(template=Target)
self.original_callable = None
self.target_arg = target
self.mock_callable_dsl = mock_callable(self.target_arg,
self.callable_arg)
self.callable_target = target.instance_method
def before(self):
self.original_callable = self.target.__str__
self.target_arg = self.target
self.callable_arg = "__str__"
self.mock_callable_dsl = mock_callable(self.target_arg,
self.callable_arg)
self.callable_target = lambda: str(self.target)
def before(self):
self.original_callable = Target.class_method
self.target_arg = Target
self.callable_arg = "class_method"
self.mock_callable_dsl = mock_callable(self.target_arg,
self.callable_arg)
self.callable_target = Target.class_method
def before(self):
target = StrictMock(template=Target,
runtime_attrs=["dynamic_instance_method"])
self.original_callable = None
self.target_arg = target
self.mock_callable_dsl = mock_callable(self.target_arg,
self.callable_arg)
self.callable_target = target.dynamic_instance_method
def before(self):
target = StrictMock(template=Target)
self.original_callable = None
self.target_arg = target
self.callable_arg = "__str__"
self.mock_callable_dsl = mock_callable(self.target_arg,
self.callable_arg)
self.callable_target = lambda: str(target)
def other_instances_are_not_mocked(self):
mock_callable(
self.target_arg,
self.callable_arg).to_return_value("mocked value")
self.assertEqual(
self.callable_target(*self.call_args, **self.call_kwargs),
"mocked value",
)
other_strict_mock = StrictMock(template=Target,
runtime_attrs=runtime_attrs)
mock_callable(
other_strict_mock,
self.callable_arg).to_return_value("other mocked value")
self.assertEqual(
getattr(other_strict_mock,
self.callable_arg)(*self.call_args,
**self.call_kwargs),
"other mocked value",
)
def newest_mock_has_precedence_over_older_mocks(self):
"""
Mocks are designed to be composable, allowing us to declare
multiple behaviors for different calls. Those definitions stack up,
and when a call is made to the mock, they are searched from newest
to oldest, to find one that is able to be caled.
"""
# First, mock all calls
mock_callable(self.target_arg, self.callable_arg).to_return_value(
"any args"
)
# Then we add some specific call behavior
mock_callable(self.target_arg, self.callable_arg).for_call(
*self.specific_call_args, **self.specific_call_kwargs
).to_return_value("specific")
# The first behavior should still be there
self.assertEqual(
self.callable_target(*self.call_args, **self.call_kwargs),
"any args",
)
# as well as the specific case
self.assertEqual(
self.callable_target(
*self.specific_call_args, **self.specific_call_kwargs
),
"specific",
)
# but if we add another "catch all" case
mock_callable(self.target_arg, self.callable_arg).to_return_value(
"new any args"
)
# it should take over any previous mock
self.assertEqual(
self.callable_target(*self.call_args, **self.call_kwargs),
"new any args",
)
self.assertEqual(
self.callable_target(
*self.specific_call_args, **self.specific_call_kwargs
),
"new any args",
)
def other_instances_are_not_mocked(self):
mock_callable(self.target_arg, self.callable_arg).to_return_value(
"mocked value"
)
self.assertEqual(self.callable_target(), "mocked value")
self.assertEqual(str(Target()), "original response")
def it_is_not_allowed(self):
with self.assertRaises(ValueError):
mock_callable(Target, "instance_method")
