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 )