def to_call_original(context):
if has_original_callable:
context.memoize("times", lambda _: 3)
@context.before
def setup_mock(self):
self.mock_callable_dsl.to_call_original()
context.nest_context("mock call arguments")
context.nest_context("assertions")
@context.example
def it_calls_original_implementation(self):
self.assertEqual(
self.callable_target(*self.call_args, **self.call_kwargs),
self.original_callable(*self.call_args, **self.call_kwargs),
)
else:
@context.example
def it_fails_to_mock(self):
with self.assertRaisesWithMessage(
ValueError,
"Can not call original callable that does not exist.",
):
self.mock_callable_dsl.to_call_original()
def to_yield_values_values_list(context):
context.memoize("values_list", lambda _: ["first", "second", "third"])
context.memoize("times", lambda self: len(self.values_list) - 1)
@context.before
def setup_mock(self):
self.mock_callable_dsl.to_yield_values(self.values_list)
if has_original_callable:
context.nest_context("mock call arguments")
context.nest_context("assertions")
@context.memoize
def iterable(self):
return iter(
self.callable_target(*self.call_args, **self.call_kwargs)
)
@context.example
def yield_values_from_list_in_order(self):
for value in self.values_list:
self.assertEqual(next(self.iterable), value)
@context.sub_context
def when_list_is_empty(context):
@context.before
def before(self):
for _ in self.values_list:
next(self.iterable)
@context.example
def it_raises_StopIteration(self):
with self.assertRaises(StopIteration):
next(self.iterable)
def with_implementation_func(context):
context.memoize("times", lambda _: 3)
context.memoize("func_return", lambda _: "mocked response")
@context.memoize
def func(self):
def _func(*args, **kwargs):
return self.func_return
return _func
@context.before
def setup_mock(self):
self.mock_callable_dsl.with_implementation(self.func)
if has_original_callable:
context.nest_context("mock call arguments")
context.nest_context("assertions")
@context.example
def it_calls_new_implementation(self):
self.assertEqual(
self.callable_target(*self.call_args, **self.call_kwargs),
self.func_return,
)
def to_return_values_values_list(context):
context.memoize("values_list", lambda _: ["first", "second", "third"])
context.memoize("times", lambda self: len(self.values_list) - 1)
@context.before
def setup_mock(self):
self.mock_callable_dsl.to_return_values(self.values_list)
if has_original_callable:
context.nest_context("mock call arguments")
context.nest_context("assertions")
@context.example
def return_values_from_list_in_order(self):
for value in self.values_list:
self.assertEqual(
self.callable_target(*self.call_args, **self.call_kwargs), value
)
@context.sub_context
def when_list_is_exhausted(context):
@context.before
def before(self):
for _ in self.values_list:
self.callable_target(*self.call_args, **self.call_kwargs)
@context.example
def it_raises(self):
with self.assertRaisesWithMessage(
UndefinedBehaviorForCall, "No more values to return!"
):
self.callable_target(*self.call_args, **self.call_kwargs)
def when_given_an_exception_class(context):
@context.before
def setup_mock(self):
self.mock_callable_dsl.to_raise(self.exception_class)
@context.example
def it_raises_an_instance_of_the_class(self):
with self.assertRaises(self.exception_class):
self.callable_target(*self.call_args, **self.call_kwargs)
context.nest_context("integration")
def integration(context):
@context.before
def catch_callable_target_exceptions(self):
original_callable_target = self.callable_target
def _callable_target(*args, **kwargs):
with self.assertRaises(self.exception_class):
return original_callable_target(*args, **kwargs)
self.callable_target = _callable_target
if has_original_callable:
context.nest_context("mock call arguments")
context.nest_context("assertions")
def when_given_an_exception_instance(context):
context.memoize("exception_message", lambda _: "test exception")
context.memoize(
"exception",
lambda self: self.exception_class(self.exception_message),
)
@context.before
def setup_mock(self):
self.mock_callable_dsl.to_raise(self.exception)
@context.example
def it_raises_the_exception_instance(self):
with self.assertRaises(self.exception_class) as cm:
self.callable_target(*self.call_args, **self.call_kwargs)
self.assertEqual(self.exception, cm.exception)
context.nest_context("integration")
def common(context, fails_if_class_attribute):
context.nest_context("patching works")
@context.example
def it_fails_if_attribute_is_callable(self):
with self.assertRaisesRegex(ValueError,
"^Attribute can not be callable*"):
self.patch_attribute(self.target, self.callable_attribute,
self.new_value)
if fails_if_class_attribute:
@context.example
def it_fails_if_attribute_is_a_class(self):
with self.assertRaisesRegex(ValueError,
"^Attribute can not be a class*"):
self.patch_attribute(self.target, self.class_attribute,
self.new_value)
else:
@context.sub_context
def with_class_attributes(context):
context.merge_context("patching works")
@context.sub_context
def type_validation(context):
@context.example
def it_fails_if_new_value_is_of_incompatible_type(self):
with self.assertRaises(TypeCheckError):
self.patch_attribute(self.target, "typedattr", 123)
@context.example
def it_passes_if_new_value_is_of_incompatible_type_with_type_validation_false(
self, ):
self.patch_attribute(self.target,
"typedattr",
123,
type_validation=False)
@context.example
def it_passes_if_new_value_is_of_matching_type(self, ):
self.patch_attribute(self.target, "typedattr", "mocked")
def with_wrapper_wrappr_func(context):
context.memoize("func_return", lambda _: "mocked response")
@context.memoize
def wrapper_func(self):
def _wrapper_func(original_function, *args, **kwargs):
self.assertEqual(original_function, self.original_callable)
return self.func_return
return _wrapper_func
if has_original_callable:
context.memoize("times", lambda _: 3)
@context.before
def setup_mock(self):
self.mock_callable_dsl.with_wrapper(self.wrapper_func)
context.nest_context("mock call arguments")
context.nest_context("assertions")
@context.example
def it_calls_wrapper_function(self):
self.assertEqual(
self.callable_target(*self.call_args,
**self.call_kwargs),
self.func_return,
)
else:
@context.example
def it_fails_to_mock(self):
with self.assertRaisesWithMessage(
ValueError,
"Can not wrap original callable that does not exist.",
):
self.mock_callable_dsl.with_wrapper(self.wrapper_func)
def to_return_value(context):
context.memoize("value", lambda _: "mocked value")
context.memoize("times", lambda _: 3)
@context.before
def setup_mock(self):
self.mock_callable_dsl.to_return_value(self.value)
if has_original_callable:
context.nest_context("mock call arguments")
context.nest_context("assertions")
@context.example
def mock_call_returns_given_value(self):
self.assertEqual(
self.callable_target(*self.call_args, **self.call_kwargs),
self.value,
)
other_args = ["other_arg" for arg in self.call_args]
other_kwargs = {k: "other_value" for k in self.call_kwargs}
self.assertEqual(
self.callable_target(*other_args, **other_kwargs), self.value
)
