def test_flex_respects_at_least_when_called_less_than_requested(self):
class Foo:
def method_foo(self): pass
foo = Foo()
flex(foo).method_foo.returns('bar').times(2, None)
foo.method_foo()
assertRaises(MethodCallError, verify)
def test_flex_should_mock_generators(self):
class Gen:
def foo(self): pass
gen = Gen()
flex(gen).foo.yields(*range(1, 10))
output = [val for val in gen.foo()]
assertEqual([val for val in range(1, 10)], output)
def test_flex_should_create_partial_old_style_class_mock(self):
class User:
def __init__(self): pass
def get_name(self): pass
flex(User).get_name.returns('mike')
user = User()
assertEqual('mike', user.get_name())
def test_flex_calls_should_match_keyword_arguments(self):
class Foo:
def method1(self, arg1, arg2=None, arg3=None):
return '%s%s%s' % (arg1, arg2, arg3)
foo = Foo()
flex(foo).method1(1, arg3=3, arg2=2).runs().times(1)
assertEqual('123', foo.method1(1, arg2=2, arg3=3))
def test_arg_matching_works_with_regexp(self):
class Foo:
def foo(arg1, arg2): pass
foo = Foo()
flex(foo).foo(
re.compile('^arg1.*asdf$'), arg2=re.compile('f')).returns('mocked')
assertEqual('mocked', foo.foo('arg1somejunkasdf', arg2='aadsfdas'))
def test_should_give_reasonable_error_for_instances_of_builtins(self):
d = dict()
try:
flex(d).keys
raise Exception('MockBuiltinError not raised')
except MockBuiltinError:
pass
def test_should_not_blow_up_on_default_for_static_methods(self):
class User:
@staticmethod
def foo():
return 'static'
flex(User).foo.runs()
assertEqual('static', User.foo())
def test_should_not_blow_up_on_default_for_class_methods(self):
class User:
@classmethod
def foo(self):
return 'class'
flex(User).foo.runs()
assertEqual('class', User.foo())
def test_flex_respects_at_most_when_called_more_than_requested(self):
class Foo:
def method_foo(self): pass
foo = Foo()
flex(foo).method_foo.returns('value_bar').times(0, 1)
foo.method_foo()
assertRaises(MethodCallError, foo.method_foo)
def test_flex_respects_at_most_when_called_requested_number(self):
class Foo:
def method_foo(self): pass
foo = Foo()
flex(foo).method_foo.returns('value_bar').times(0, 1)
foo.method_foo()
verify()
def test_flex_respects_at_most_when_called_less_than_requested(self):
class Foo:
def method_foo(self): pass
foo = Foo()
flex(foo).method_foo.returns('bar').times(0, 2)
foo.method_foo()
verify()
def test_flex_spy_should_not_clobber_original_method(self):
class User:
def get_stuff(self): return 'real', 'stuff'
user = User()
flex(user).get_stuff.runs()
flex(user).get_stuff.runs()
assertEqual(('real', 'stuff'), user.get_stuff())
def test_should_mock_new_instances_with_multiple_params(self):
class User(object): pass
class Group(object):
def __init__(self, arg, arg2):
pass
user = User()
flex(Group).__new__.returns(user)
assert user is Group(1, 2)
def test_arg_matching_with_regex_fails_when_regex_doesnt_match_kwarg(self):
class Foo:
def foo(arg1, arg2): pass
foo = Foo()
flex(foo).foo(
re.compile('^arg1.*asdf$'), arg2=re.compile('a')).returns('mocked')
assertRaises(MethodSignatureError,
foo.foo, 'arg1somejunkasdf', arg2='b')
def test_flex_respects_at_least_when_called_more_than_requested(self):
class Foo:
def method_foo(self): pass
foo = Foo()
flex(foo).method_foo.returns('value_bar').times(1, None)
foo.method_foo()
foo.method_foo()
verify()
def test_flex_should_fail_mocking_nonexistent_methods(self):
class User: pass
user = User()
try:
flex(user).nonexistent()
raise Exception('failed to raise FlexError')
except FlexError:
pass
def test_flex_should_replace_method(self):
class Foo:
def method(self, arg):
return arg
foo = Foo()
flex(foo).method.runs(lambda x: x == 5)
assertEqual(foo.method(5), True)
assertEqual(foo.method(4), False)
def test_flex_should_revert_new_instances_on_teardown(self):
class User(object): pass
class Group(object): pass
user = User()
group = Group()
flex(Group).__new__.returns(user)
assert user is Group()
verify()
assertEqual(group.__class__, Group().__class__)
def test_should_accept_multiple_return_values_with_shortcut(self):
class Foo:
def method1(self): pass
foo = Foo()
flex(foo).method1.returns(1, 2)
assertEqual(1, foo.method1())
assertEqual(2, foo.method1())
assertEqual(1, foo.method1())
assertEqual(2, foo.method1())
def test_calls_fails_properly_for_same_method_with_different_args(self):
class Foo:
def method(self, arg):
pass
foo = Foo()
flex(foo).method('foo').runs().times(1)
flex(foo).method('bar').runs().times(1)
foo.method('foo')
assertRaises(MethodCallError, verify)
def test_flex_should_properly_restore_module_level_functions(self):
if 'flex_test' in sys.modules:
mod = sys.modules['flex_test']
else:
mod = sys.modules['__main__']
flex(mod).module_level_function
assertEqual(None, module_level_function(1, 2))
verify()
assertEqual('1, 2', module_level_function(1, 2))
def test_should_properly_restore_undecorated_static_methods(self):
class User:
def get_stuff(): return 'ok!'
get_stuff = staticmethod(get_stuff)
assertEqual('ok!', User.get_stuff())
flex(User).get_stuff
assert User.get_stuff() is None
verify()
assertEqual('ok!', User.get_stuff())
def test_flex_should_properly_restore_static_methods(self):
class User:
@staticmethod
def get_stuff(): return 'ok!'
assertEqual('ok!', User.get_stuff())
flex(User).get_stuff
assert User.get_stuff() is None
verify()
assertEqual('ok!', User.get_stuff())
def test_flex_should_mock_private_special_methods(self):
class Foo:
def __private_special_method__(self):
return 'foo'
def public_method(self):
return self.__private_special_method__()
foo = Foo()
flex(foo).__private_special_method__.returns('bar')
assertEqual('bar', foo.public_method())
def test_flex_preserves_stubbed_class_methods_between_tests(self):
class User:
def get_name(self):
return 'mike'
user = User()
flex(User).get_name.returns('john')
assertEqual('john', user.get_name())
verify()
assertEqual('mike', user.get_name())
def test_flex_should_mock_double_underscore_method(self):
class Foo:
def __(self):
return 'foo'
def public_method(self):
return self.__()
foo = Foo()
flex(foo).__.returns('bar')
assertEqual('bar', foo.public_method())
def test_mocking_down_the_inheritance_chain_class_to_class(self):
class Parent(object):
def foo(self): pass
class Child(Parent):
def bar(self): pass
flex(Parent).foo.returns('outer')
flex(Child).bar.returns('inner')
assert 'outer', Parent().foo()
assert 'inner', Child().bar()
def test_calls_works_for_same_method_with_different_args(self):
class Foo:
def method(self, arg):
pass
foo = Foo()
flex(foo).method('foo').runs().times(1)
flex(foo).method('bar').runs().times(1)
foo.method('foo')
foo.method('bar')
verify()
def test_pass_thru_calls_original_method_only_once(self):
class Nyan(object):
def __init__(self):
self.n = 0
def method(self):
self.n += 1
obj = Nyan()
flex(obj).method.runs()
obj.method()
assertEqual(obj.n, 1)
def test_flex_should_properly_restore_class_methods(self):
class User:
@classmethod
def get_stuff(cls):
return cls.__name__
assertEqual('User', User.get_stuff())
flex(User).get_stuff.returns('foo')
assertEqual('foo', User.get_stuff())
verify()
assertEqual('User', User.get_stuff())