import sys import unittest from nose.tools import eq_, raises from nose.exc import SkipTest import fudge from fudge.inspector import arg from fudge import ( Fake, Registry, ExpectedCall, ExpectedCallOrder, Call, CallStack, FakeDeclarationError) def test_decorator_on_def(): class holder: test_called = False bobby = fudge.Fake() bobby.expects("suzie_called") @raises(AssertionError) @fudge.with_fakes def some_test(): holder.test_called = True eq_(some_test.__name__, 'some_test') some_test() eq_(holder.test_called, True) # for a test below _some_fake = fudge.Fake() class TestFake(unittest.TestCase): def test_guess_name(self): if sys.platform.startswith('java'): raise SkipTest("not supported") my_obj = fudge.Fake() eq_(repr(my_obj), "fake:my_obj") def test_guess_name_globals(self): if sys.platform.startswith('java'): raise SkipTest("not supported") eq_(repr(_some_fake), "fake:_some_fake") def test_guess_name_deref(self): if sys.platform.startswith('java'): raise SkipTest("not supported") my_obj = 44 my_obj = fudge.Fake() eq_(repr(my_obj), "fake:my_obj") def test_has_attr(self): my_obj = fudge.Fake().has_attr(vice='versa', beach='playa') eq_(my_obj.vice, 'versa') eq_(my_obj.beach, 'playa') def test_has_property(self): fake_vise = fudge.Fake().is_callable().returns('versa') fake_stuff = fudge.Fake().is_callable().raises( Exception('broken stuff')) my_obj = fudge.Fake().has_property(vice=fake_vise, stuff=fake_stuff) eq_(my_obj.vice, 'versa') try: my_obj.stuff except Exception as exc: eq_(str(exc), 'broken stuff') else: raise RuntimeError('expected Exception') def test_attributes_are_settable(self): my_obj = fudge.Fake().has_attr(vice='versa') my_obj.vice = 'miami' eq_(my_obj.vice, 'miami') def test_none_type_attributes_are_settable(self): my_obj = fudge.Fake().has_attr(vice=None) eq_(my_obj.vice, None) my_obj.vice = 'miami' eq_(my_obj.vice, 'miami') def test_attributes_can_replace_internals(self): my_obj = fudge.Fake().has_attr(provides='hijacked') eq_(my_obj.provides, 'hijacked') def test_repr_shortens_long_values(self): fake = Fake("widget").provides("set_bits").with_args( "12345678910111213141516171819202122232425262728293031" ) try: fake.set_bits() except AssertionError as exc: eq_(str(exc), "fake:widget.set_bits('123456789101112131415161718192021222324252627...') " "was called unexpectedly with args ()") else: raise RuntimeError("expected AssertionError") class TestChainedNames(unittest.TestCase): def setUp(self): self.fake = fudge.Fake('db.Adapter') def tearDown(self): fudge.clear_expectations() def test_basic(self): eq_(repr(self.fake), 'fake:db.Adapter') def test_nesting(self): f = self.fake f = f.provides('query').returns_fake().provides('fetchall') eq_(repr(f), 'fake:db.Adapter.query()') f = f.provides('cursor').returns_fake() eq_(repr(f), 'fake:db.Adapter.query().cursor()') def test_more_nesting(self): class ctx: fake = None @fudge.patch('smtplib.SMTP') def test(fake_SMTP): (fake_SMTP.is_callable() .returns_fake() .provides('sendmail')) ctx.fake = fake_SMTP() test() eq_(str(ctx.fake), 'fake:smtplib.SMTP()') class TestIsAStub(unittest.TestCase): def tearDown(self): fudge.clear_expectations() def test_is_callable(self): f = fudge.Fake().is_a_stub() result = f() assert isinstance(result, fudge.Fake) def test_infinite_callables(self): f = fudge.Fake().is_a_stub() result = f()()() assert isinstance(result, fudge.Fake) def test_is_any_call(self): f = fudge.Fake().is_a_stub() assert isinstance(f.foobar(), fudge.Fake) assert isinstance(f.foozilated(), fudge.Fake) def test_is_any_call_with_any_args(self): f = fudge.Fake().is_a_stub() assert isinstance(f.foobar(blazz='Blaz', kudoz='Klazzed'), fudge.Fake) def test_stubs_are_infinite(self): f = fudge.Fake().is_a_stub() assert isinstance(f.one().two().three(), fudge.Fake) def test_stubs_have_any_attribute(self): f = fudge.Fake().is_a_stub() assert isinstance(f.foo, fudge.Fake) assert isinstance(f.bar, fudge.Fake) def test_attributes_are_infinite(self): f = fudge.Fake().is_a_stub() assert isinstance(f.foo.bar.barfoo, fudge.Fake) def test_infinite_path_expectation(self): f = fudge.Fake().is_a_stub() f.foo.bar().expects('barfoo') f.foo.bar().barfoo() @raises(AssertionError) def test_infinite_path_expectation_is_verified(self): f = fudge.Fake().is_a_stub() f.foo.bar().expects('barfoo').with_args(foo='bar') f.foo.bar().barfoo() fudge.verify() def test_infinite_path_naming(self): f = fudge.Fake(name='base').is_a_stub() eq_(str(f.foo.bar().baz), 'fake:base.foo.bar().baz') class TestLongArgValues(unittest.TestCase): def test_arg_diffs_are_not_shortened(self): fake = Fake("widget").provides("set_bits").with_args( "12345678910111213141516171819202122232425262728293031" ) try: # this should not be shortened but the above arg spec should: fake.set_bits("99999999999999999999999999999999999999999999999999999999") except AssertionError as exc: eq_(str(exc), "fake:widget.set_bits('123456789101112131415161718192021222324252627...') " "was called unexpectedly with args " "('99999999999999999999999999999999999999999999999999999999')") else: raise RuntimeError("expected AssertionError") def test_kwarg_diffs_are_not_shortened(self): fake = Fake("widget").provides("set_bits").with_args( newbits="12345678910111213141516171819202122232425262728293031" ) try: # this should not be shortened but the above arg spec should: fake.set_bits(newbits="99999999999999999999999999999999999999999999999999999999") except AssertionError as exc: eq_(str(exc), "fake:widget.set_bits(newbits='123456789101112131415161718192021222324252627...') " "was called unexpectedly with args " "(newbits='99999999999999999999999999999999999999999999999999999999')") else: raise RuntimeError("expected AssertionError") class TestArguments(unittest.TestCase): def setUp(self): self.fake = fudge.Fake() def tearDown(self): fudge.clear_expectations() @raises(AssertionError) def test_wrong_args(self): exp = self.fake.expects('theCall').with_args( 1, "ho ho ho ho ho ho ho, it's Santa", {'ditto':False}) exp.theCall() @raises(AssertionError) def test_wrong_kwargs(self): exp = self.fake.expects('other').with_args(one="twozy", items=[1,2,3,4]) exp.other(nice="NOT NICE") @raises(AssertionError) def test_arg_count(self): exp = self.fake.expects('one').with_arg_count(3) exp.one('no', 'maybe') @raises(AssertionError) def test_kwarg_count(self): exp = self.fake.expects('__init__').with_kwarg_count(2) exp(maybe="yes, maybe") @raises(FakeDeclarationError) def test_with_args_requires_a_method(self): self.fake.with_args('something') @raises(AssertionError) def test_with_args_can_operate_on_provision(self): self.fake.provides("not_expected").with_args('something') self.fake.not_expected() # should still raise arg error @raises(AssertionError) def test_with_args_checks_args(self): self.fake.expects('count').with_args('one', two='two') self.fake.count(two='two') @raises(AssertionError) def test_with_args_checks_kwargs(self): self.fake.expects('count').with_args('one', two='two') self.fake.count('one') @raises(AssertionError) def test_raises_does_not_obscure_with_kwargs(self): # previously, this test failed because the raises(exc) # was raised too early. Issue 6 self.fake.expects('count').with_args(two='two').raises(RuntimeError('bork')) self.fake.count('one') # wrong kwargs @raises(AssertionError) def test_raises_does_not_obscure_with_args(self): # Issue 6 self.fake.expects('count').with_args('one').raises(RuntimeError('bork')) self.fake.count(two='two') # wrong args @raises(AssertionError) def test_too_many_args(self): db = Fake("db").expects("execute").with_args(bind={'one':1}) db.execute("select foozilate()", bind={'one':1}) # unexpected statement arg def test_zero_keywords_ok(self): mail = fudge.Fake('mail').expects('send').with_arg_count(3) mail.send("you", "me", "hi") # no kw args should be ok def test_zero_args_ok(self): mail = fudge.Fake('mail').expects('send').with_kwarg_count(3) mail.send(to="you", from_="me", msg="hi") # no args should be ok def test_with_args_with_object_that_is_never_equal_to_anything(self): class NeverEqual(object): def __eq__(self, other): return False obj = NeverEqual() self.fake.expects('save').with_args(arg.any()) self.fake.save(obj) # this should pass but was failing prior to issue 9 def test_with_kwargs_with_object_that_is_never_equal_to_anything(self): class NeverEqual(object): def __eq__(self, other): return False obj = NeverEqual() self.fake.expects('save').with_args(foo=arg.any()) self.fake.save(foo=obj) # this should pass but was failing prior to issue 9 def test_with_matching_positional_args(self): db = self.fake db.expects('transaction').with_matching_args('insert') db.transaction("insert", isolation_level="lock") fudge.verify() def test_with_matching_keyword_args(self): db = self.fake db.expects('transaction').with_matching_args(isolation_level="lock") db.transaction("insert", isolation_level="lock") fudge.verify() @raises(AssertionError) def test_with_non_matching_positional_args(self): db = self.fake db.expects('transaction').with_matching_args('update') db.transaction("insert", isolation_level="lock") fudge.verify() @raises(AssertionError) def test_with_too_many_non_matching_positional_args(self): # this may be unintuitve but specifying too many # arguments constitutes as non-matching. Why? # Because how else is it possible to implement, by index? db = self.fake db.expects('transaction').with_matching_args('update') db.transaction("update", "delete", isolation_level="lock") fudge.verify() @raises(AssertionError) def test_with_non_matching_keyword_args(self): db = self.fake db.expects('transaction').with_matching_args(isolation_level="read") db.transaction("insert", isolation_level="lock") fudge.verify() @raises(AssertionError) def test_missing_matching_positional_args_is_not_ok(self): # this is awkward to implement so I think it should not be supported db = self.fake db.expects('transaction').with_matching_args("update") db.transaction() fudge.verify() def test_missing_matching_keyword_args_is_ok(self): db = self.fake db.expects('transaction').with_matching_args(isolation_level="read") db.transaction() fudge.verify() ## hmm, arg diffing needs more thought # class TestArgDiff(unittest.TestCase): # # def setUp(self): # self.fake = Fake("foo") # self.call = Call(self.fake) # # def test_empty(self): # eq_(self.call._arg_diff(tuple(), tuple()), "") # # def test_one_unexpected(self): # eq_(self.call._arg_diff(('one',), tuple()), "arg #1 was unexpected") # # def test_one_missing(self): # eq_(self.call._arg_diff(tuple(), ('one',)), "arg #1 never showed up") # # def test_four_unexpected(self): # eq_(self.call._arg_diff( # ('one','two','three','four'), # ('one','two','three')), "arg #4 was unexpected") # # def test_four_missing(self): # eq_(self.call._arg_diff( # ('one','two','three'), # ('one','two','three','four')), "arg #4 never showed up") # # def test_one_mismatch(self): # eq_(self.call._arg_diff(('won',), ('one',)), "arg #1 'won' != 'one'") # # def test_four_mismatch(self): # eq_(self.call._arg_diff( # ('one','two','three','not four'), # ('one','two','three','four')), "arg #4 'not four' != 'four'") # class TestKeywordArgDiff(unittest.TestCase): # # def setUp(self): # self.fake = Fake("foo") # self.call = Call(self.fake) # # def test_empty(self): # eq_(self.call._keyword_diff({}, {}), (True, "")) # # def test_one_empty(self): # eq_(self.call._keyword_diff({}, # {'something':'here','another':'there'}), # (False, "these keywords never showed up: ('something', 'another')")) # # def test_complex_match_yields_no_reason(self): # actual = {'num':1, 'two':2, 'three':3} # expected = {'num':1, 'two':2, 'three':3} # eq_(self.call._keyword_diff(actual, expected), (True, "")) # # def test_simple_mismatch_yields_no_reason(self): # actual = {'num':1} # expected = {'num':2} # eq_(self.call._keyword_diff(actual, expected), (False, "")) # # def test_simple_match_yields_no_reason(self): # actual = {'num':1} # expected = {'num':1} # eq_(self.call._keyword_diff(actual, expected), (True, "")) # # def test_actual_kw_extra_key(self): # actual = {'one':1, 'two':2} # expected = {'one':1} # eq_(self.call._keyword_diff(actual, expected), # (False, "keyword 'two' was not expected")) # # def test_actual_kw_value_inequal(self): # actual = {'one':1, 'two':2} # expected = {'one':1, 'two':3} # eq_(self.call._keyword_diff(actual, expected), # (False, "two=2 != two=3")) # # def test_expected_kw_extra_key(self): # actual = {'one':1} # expected = {'one':1, 'two':2} # eq_(self.call._keyword_diff(actual, expected), # (False, "this keyword never showed up: ('two',)")) # # def test_expected_kw_value_inequal(self): # actual = {'one':1, 'two':'not two'} # expected = {'one':1, 'two':2} # eq_(self.call._keyword_diff(actual, expected), # (False, "two='not two' != two=2")) class TestCall(unittest.TestCase): def setUp(self): self.fake = fudge.Fake('SMTP') def test_repr(self): s = Call(self.fake) eq_(repr(s), "fake:SMTP()") def test_repr_callable(self): s = Call(self.fake.is_callable()) eq_(repr(s), "fake:SMTP()") def test_repr_with_args(self): s = Call(self.fake) s.expected_args = [1,"bad"] eq_(repr(s), "fake:SMTP(1, 'bad')") def test_repr_with_kwargs(self): s = Call(self.fake) s.expected_args = [1,"bad"] s.expected_kwargs = {'baz':'borzo'} eq_(repr(s), "fake:SMTP(1, 'bad', baz='borzo')") def test_named_repr_with_args(self): s = Call(self.fake, call_name='connect') s.expected_args = [1,"bad"] eq_(repr(s), "fake:SMTP.connect(1, 'bad')") def test_nested_named_repr_with_args(self): f = self.fake.provides('get_conn').returns_fake() s = Call(f, call_name='connect') s.expected_args = [1,"bad"] eq_(repr(s), "fake:SMTP.get_conn().connect(1, 'bad')") def test_named_repr_with_index(self): s = Call(self.fake, call_name='connect') s.expected_args = [1,"bad"] s.index = 0 eq_(repr(s), "fake:SMTP.connect(1, 'bad')[0]") s.index = 1 eq_(repr(s), "fake:SMTP.connect(1, 'bad')[1]") class TestCallStack(unittest.TestCase): def setUp(self): self.fake = fudge.Fake('SMTP') def test_calls(self): call_stack = CallStack(self.fake) c = Call(self.fake) c.return_val = 1 call_stack.add_call(c) c = Call(self.fake) c.return_val = 2 call_stack.add_call(c) eq_(call_stack(), 1) eq_(call_stack(), 2) @raises(AssertionError) def test_no_calls(self): call_stack = CallStack(self.fake) call_stack() @raises(AssertionError) def test_end_of_calls(self): call_stack = CallStack(self.fake) c = Call(self.fake) c.return_val = 1 call_stack.add_call(c) eq_(call_stack(), 1) call_stack() def test_get_call_object(self): call_stack = CallStack(self.fake) c = Call(self.fake) call_stack.add_call(c) assert call_stack.get_call_object() is c d = Call(self.fake) call_stack.add_call(d) assert call_stack.get_call_object() is d def test_with_initial_calls(self): c = Call(self.fake) c.return_val = 1 call_stack = CallStack(self.fake, initial_calls=[c]) eq_(call_stack(), 1) def test_reset(self): call_stack = CallStack(self.fake) c = Call(self.fake) c.return_val = 1 call_stack.add_call(c) c = Call(self.fake) c.return_val = 2 call_stack.add_call(c) eq_(call_stack(), 1) eq_(call_stack(), 2) call_stack.reset() eq_(call_stack(), 1) eq_(call_stack(), 2) class TestFakeCallables(unittest.TestCase): def tearDown(self): fudge.clear_expectations() @raises(RuntimeError) def test_not_callable_by_default(self): self.fake = fudge.Fake() self.fake() def test_callable(self): fake = fudge.Fake().is_callable() fake() # allow the call fudge.verify() # no error @raises(AttributeError) def test_cannot_stub_any_call_by_default(self): self.fake.Anything() # must define this first @raises(AssertionError) def test_stub_with_args(self): self.fake = fudge.Fake().is_callable().with_args(1,2) self.fake(1) @raises(AssertionError) def test_stub_with_arg_count(self): self.fake = fudge.Fake().is_callable().with_arg_count(3) self.fake('bah') @raises(AssertionError) def test_stub_with_kwarg_count(self): self.fake = fudge.Fake().is_callable().with_kwarg_count(3) self.fake(two=1) def test_stub_with_provides(self): self.fake = fudge.Fake().provides("something") self.fake.something() def test_fake_can_sabotage_itself(self): # I'm not sure if there should be a warning # for this but it seems that it should be # possible for maximum flexibility: # replace Fake.with_args() self.fake = fudge.Fake().provides("with_args").returns(1) eq_(self.fake.with_args(), 1) @raises(AssertionError) def test_stub_with_provides_and_args(self): self.fake = fudge.Fake().provides("something").with_args(1,2) self.fake.something() def test_stub_is_not_registered(self): self.fake = fudge.Fake().provides("something") exp = self.fake._get_current_call() eq_(exp.call_name, "something") assert exp not in fudge.registry @raises(RuntimeError) def test_raises_class(self): self.fake = fudge.Fake().provides("fail").raises(RuntimeError) self.fake.fail() @raises(RuntimeError) def test_raises_instance(self): self.fake = fudge.Fake().provides("fail").raises(RuntimeError("batteries ran out")) self.fake.fail() class TestReplacementCalls(unittest.TestCase): def tearDown(self): fudge.clear_expectations() def test_replace_call(self): def something(): return "hijacked" fake = fudge.Fake().provides("something").calls(something) eq_(fake.something(), "hijacked") def test_calls_mixed_with_returns(self): called = [] def something(): called.append(True) return "hijacked" fake = fudge.Fake().provides("something").calls(something).returns("other") eq_(fake.something(), "other") eq_(called, [True]) @raises(AssertionError) def test_calls_mixed_with_expectations(self): def something(): return "hijacked" # with_args() expectation should not get lost: fake = fudge.Fake().provides("something").calls(something).with_args(1,2) eq_(fake.something(), "hijacked") def test_replace_init(self): class custom_object: def hello(self): return "hi" fake = fudge.Fake().provides("__init__").returns(custom_object()) eq_(fake().hello(), "hi") class TestFakeTimesCalled(unittest.TestCase): def tearDown(self): fudge.clear_expectations() def test_when_provided(self): self.fake = fudge.Fake().provides("something").times_called(2) # this should not raise an error because the call was provided not expected fudge.verify() @raises(AssertionError) def test_when_provided_raises_on_too_many_calls(self): self.fake = fudge.Fake().provides("something").times_called(2) self.fake.something() self.fake.something() self.fake.something() # too many @raises(AssertionError) def test_when_expected(self): self.fake = fudge.Fake().expects("something").times_called(2) self.fake.something() fudge.verify() @raises(AssertionError) def test_when_expected_raises_on_too_many_calls(self): self.fake = fudge.Fake().expects("something").times_called(2) self.fake.something() self.fake.something() self.fake.something() # too many fudge.verify() @raises(AssertionError) def test_expected_callable(self): login = fudge.Fake('login',expect_call=True).times_called(2) login() fudge.verify() def test_callable_ok(self): self.fake = fudge.Fake(callable=True).times_called(2) self.fake() self.fake() fudge.verify() def test_when_provided_ok(self): self.fake = fudge.Fake().provides("something").times_called(2) self.fake.something() self.fake.something() fudge.verify() def test_when_expected_ok(self): self.fake = fudge.Fake().expects("something").times_called(2) self.fake.something() self.fake.something() fudge.verify() class TestNextCall(unittest.TestCase): def tearDown(self): fudge.clear_expectations() @raises(FakeDeclarationError) def test_next_call_then_times_called_is_error(self): self.fake = fudge.Fake().expects("hi").returns("goodday").next_call().times_called(4) self.fake.hi() self.fake.hi() fudge.verify() @raises(FakeDeclarationError) def test_times_called_then_next_call_is_error(self): self.fake = fudge.Fake().expects("hi").times_called(4).next_call() self.fake.hi() self.fake.hi() fudge.verify() def test_stacked_returns(self): fake = fudge.Fake().provides("something") fake = fake.returns(1) fake = fake.next_call() fake = fake.returns(2) fake = fake.next_call() fake = fake.returns(3) eq_(fake.something(), 1) eq_(fake.something(), 2) eq_(fake.something(), 3) @raises(AssertionError) def test_stacked_calls_are_finite(self): self.fake = fudge.Fake().provides("something") self.fake = self.fake.returns(1) self.fake = self.fake.next_call() self.fake = self.fake.returns(2) eq_(self.fake.something(), 1) eq_(self.fake.something(), 2) self.fake.something() def test_stack_is_reset_when_name_changes(self): self.fake = fudge.Fake().provides("something") self.fake = self.fake.returns(1) self.fake = self.fake.next_call() self.fake = self.fake.returns(2) self.fake = self.fake.provides("other") self.fake = self.fake.returns(3) eq_(self.fake.something(), 1) eq_(self.fake.something(), 2) eq_(self.fake.other(), 3) eq_(self.fake.other(), 3) eq_(self.fake.other(), 3) eq_(self.fake.other(), 3) eq_(self.fake.other(), 3) def test_next_call_with_multiple_returns(self): self.fake = fudge.Fake().provides("something") self.fake = self.fake.returns(1) self.fake = self.fake.next_call() self.fake = self.fake.returns(2) self.fake = self.fake.provides("other") self.fake = self.fake.returns(3) self.fake = self.fake.next_call() self.fake = self.fake.returns(4) eq_(self.fake.something(), 1) eq_(self.fake.something(), 2) eq_(self.fake.other(), 3) eq_(self.fake.other(), 4) def test_stacked_calls_do_not_collide(self): self.fake = fudge.Fake().provides("something") self.fake = self.fake.returns(1) self.fake = self.fake.next_call() self.fake = self.fake.returns(2) self.fake = self.fake.provides("other") self.fake = self.fake.returns(3) self.fake = self.fake.next_call() self.fake = self.fake.returns(4) eq_(self.fake.something(), 1) eq_(self.fake.other(), 3) eq_(self.fake.something(), 2) eq_(self.fake.other(), 4) def test_returns_are_infinite(self): self.fake = fudge.Fake().provides("something").returns(1) eq_(self.fake.something(), 1) eq_(self.fake.something(), 1) eq_(self.fake.something(), 1) eq_(self.fake.something(), 1) eq_(self.fake.something(), 1) eq_(self.fake.something(), 1) eq_(self.fake.something(), 1) eq_(self.fake.something(), 1) def test_stacked_does_not_copy_expectations(self): fake = fudge.Fake().expects("add") fake = fake.with_args(1,2).returns(3) fake = fake.next_call() fake = fake.returns(-1) eq_(fake.add(1,2), 3) eq_(fake.add(), -1) def test_stacked_calls_are_in_registry(self): fake = fudge.Fake().expects("count").with_args(1) fake = fake.next_call().with_args(2) fake = fake.next_call().with_args(3) fake = fake.next_call().with_args(4) # hmm call_stack = fake._declared_calls[fake._last_declared_call_name] calls = [c for c in call_stack] assert calls[0] in fudge.registry assert calls[1] in fudge.registry assert calls[2] in fudge.registry assert calls[3] in fudge.registry def test_stacked_calls_are_indexed(self): fake = fudge.Fake().expects("count").with_args(1) fake = fake.next_call().with_args(2) fake = fake.next_call().with_args(3) fake = fake.next_call().with_args(4) # hmm call_stack = fake._declared_calls[fake._last_declared_call_name] calls = [c for c in call_stack] eq_(calls[0].index, 0) eq_(calls[1].index, 1) eq_(calls[2].index, 2) eq_(calls[3].index, 3) def test_start_stop_resets_stack(self): fudge.clear_expectations() fake = fudge.Fake().provides("something") fake = fake.returns(1) fake = fake.next_call() fake = fake.returns(2) eq_(fake.something(), 1) eq_(fake.something(), 2) fudge.clear_calls() eq_(fake.something(), 1) eq_(fake.something(), 2) fudge.verify() eq_(fake.something(), 1) eq_(fake.something(), 2) def test_next_call_with_callables(self): login = (fudge.Fake('login') .is_callable() .returns("yes") .next_call() .returns("maybe") .next_call() .returns("no")) eq_(login(), "yes") eq_(login(), "maybe") eq_(login(), "no") def test_returns(self): db = Fake("db")\ .provides("get_id").returns(1)\ .provides("set_id")\ .next_call(for_method="get_id").returns(2) # print [c.return_val for c in db._declared_calls["get_id"]._calls] eq_(db.get_id(), 1) eq_(db.set_id(), None) eq_(db.get_id(), 2) def test_expectations_with_multiple_return_values(self): db = Fake("db")\ .expects("get_id").returns(1)\ .expects("set_id")\ .next_call(for_method="get_id").returns(2) eq_(db.get_id(), 1) eq_(db.set_id(), None) eq_(db.get_id(), 2) fudge.verify() class TestExpectsAndProvides(unittest.TestCase): def tearDown(self): fudge.clear_expectations() @raises(AssertionError) def test_nocall(self): fake = fudge.Fake() exp = fake.expects('something') fudge.verify() def test_multiple_provides_on_chained_fakes_ok(self): db = Fake("db").provides("insert").returns_fake().provides("insert") def test_multiple_expects_on_chained_fakes_ok(self): db = Fake("db").expects("insert").returns_fake().expects("insert") def test_callable_expectation(self): fake_setup = fudge.Fake('setup', expect_call=True) fake_setup() # was called so verification should pass: fudge.verify() def test_callable_expectation_with_args(self): fake_setup = (fudge.Fake('setup', expect_call=True) .with_args('')) fake_setup('') # was called so verification should pass: fudge.verify() def test_multiple_expects_act_like_next_call(self): self.fake = fudge.Fake().expects("something") self.fake = self.fake.returns(1) self.fake = self.fake.expects("something") self.fake = self.fake.returns(2) eq_(self.fake.something(), 1) eq_(self.fake.something(), 2) def test_multiple_provides_act_like_next_call(self): self.fake = fudge.Fake().provides("something") self.fake = self.fake.returns(1) self.fake = self.fake.provides("something") self.fake = self.fake.returns(2) eq_(self.fake.something(), 1) eq_(self.fake.something(), 2) def test_multiple_expects_for_sep_methods(self): self.fake = (fudge.Fake() .expects("marco") .returns(1) .expects("polo") .returns('A') .expects("marco") .returns(2) .expects("polo") .returns('B') ) eq_(self.fake.marco(), 1) eq_(self.fake.marco(), 2) eq_(self.fake.polo(), 'A') eq_(self.fake.polo(), 'B') def test_multiple_provides_for_sep_methods(self): self.fake = (fudge.Fake() .provides("marco") .returns(1) .provides("polo") .returns('A') .provides("marco") .returns(2) .provides("polo") .returns('B') ) eq_(self.fake.marco(), 1) eq_(self.fake.marco(), 2) eq_(self.fake.polo(), 'A') eq_(self.fake.polo(), 'B') class TestOrderedCalls(unittest.TestCase): def tearDown(self): fudge.clear_expectations() @raises(AssertionError) def test_out_of_order(self): fake = fudge.Fake().remember_order().expects("one").expects("two") fake.two() fake.one() fudge.verify() @raises(FakeDeclarationError) def test_cannot_remember_order_when_callable_is_true(self): fake = fudge.Fake().is_callable().remember_order() @raises(FakeDeclarationError) def test_cannot_remember_order_when_expect_call_is_true(self): fake = fudge.Fake(expect_call=True).remember_order() @raises(AssertionError) def test_not_enough_calls(self): # need to drop down a level to bypass expected calls: r = Registry() fake = Fake() call_order = ExpectedCallOrder(fake) r.remember_expected_call_order(call_order) exp = ExpectedCall(fake, "callMe", call_order=call_order) call_order.add_expected_call(exp) r.verify() @raises(AssertionError) def test_only_one_call(self): # need to drop down a level to bypass expected calls: r = Registry() fake = Fake() call_order = ExpectedCallOrder(fake) r.remember_expected_call_order(call_order) exp = ExpectedCall(fake, "one", call_order=call_order) call_order.add_expected_call(exp) exp() # call this exp = ExpectedCall(fake, "two", call_order=call_order) call_order.add_expected_call(exp) r.verify() def test_incremental_order_assertion_ok(self): # need to drop down a level to bypass expected calls: fake = Fake() call_order = ExpectedCallOrder(fake) exp = ExpectedCall(fake, "one", call_order=call_order) call_order.add_expected_call(exp) exp() # call this exp = ExpectedCall(fake, "two", call_order=call_order) call_order.add_expected_call(exp) # two() not called but assertion is not finalized: call_order.assert_order_met(finalize=False) def test_multiple_returns_affect_order(self): db = Fake("db")\ .remember_order()\ .expects("get_id").returns(1)\ .expects("set_id")\ .next_call(for_method="get_id").returns(2) eq_(db.get_id(), 1) eq_(db.set_id(), None) eq_(db.get_id(), 2) fudge.verify() @raises(AssertionError) def test_chained_fakes_honor_order(self): Thing = Fake("thing").remember_order().expects("__init__") holder = Thing.expects("get_holder").returns_fake() holder = holder.expects("init") thing = Thing() holder = thing.get_holder() # missing thing.init() fudge.verify() @raises(AssertionError) def test_too_many_calls(self): db = Fake("db")\ .remember_order()\ .expects("get_id").returns(1)\ .expects("set_id") eq_(db.get_id(), 1) eq_(db.set_id(), None) # extra : eq_(db.get_id(), 1) @raises(AssertionError) def test_expects_call_shortcut(self): remove = Fake("os.remove").expects_call() fudge.verify() assert isinstance(remove, Fake) def test_expects_call_shortcut_ok(self): remove = Fake("os.remove").expects_call() remove() fudge.verify() assert isinstance(remove, Fake) def test_provides_call_shortcut(self): remove = Fake("os.remove").is_callable() remove() assert isinstance(remove, Fake) class TestPatchedFakes(unittest.TestCase): def tearDown(self): fudge.clear_expectations() def test_expectations_are_cleared(self): class holder: test_called = False # Set up decoy expectation: fake = fudge.Fake('db').expects('save') @fudge.patch('shutil.copy') def some_test(copy): holder.test_called = True some_test() fudge.verify() # should be no errors eq_(holder.test_called, True) def test_expectations_are_verified(self): class holder: test_called = False @raises(AssertionError) @fudge.patch('shutil.copy') def some_test(copy): copy.expects('__call__') holder.test_called = True some_test() eq_(holder.test_called, True) def test_expectations_are_always_cleared(self): class holder: test_called = False @raises(RuntimeError) @fudge.patch('shutil.copy') def some_test(copy): holder.test_called = True copy.expects_call() raise RuntimeError some_test() fudge.verify() # should be no errors eq_(holder.test_called, True) def test_calls_are_cleared(self): class holder: test_called = False sess = fudge.Fake('session').expects('save') # call should be cleared: sess.save() @fudge.patch('shutil.copy') def some_test(copy): holder.test_called = True copy.expects_call().times_called(1) copy() some_test() fudge.verify() # should be no errors eq_(holder.test_called, True) def test_with_statement(self): class holder: test_called = False @raises(AssertionError) def run_test(): with fudge.patch('shutil.copy') as copy: copy.expects('__call__') holder.test_called = True run_test() eq_(holder.test_called, True) def test_with_statement_exception(self): @raises(RuntimeError) def run_test(): with fudge.patch('shutil.copy') as copy: copy.expects('__call__') raise RuntimeError() run_test() class TestNonPatchedFakeTest(unittest.TestCase): def tearDown(self): fudge.clear_expectations() def test_preserve_method(self): @fudge.test def some_test(): holder.test_called = True eq_(some_test.__name__, 'some_test') def test_expectations_are_cleared(self): class holder: test_called = False # Set up decoy expectation: fake = fudge.Fake('db').expects('save') @fudge.test def some_test(): holder.test_called = True some_test() fudge.verify() # should be no errors eq_(holder.test_called, True) def test_expectations_are_always_cleared(self): class holder: test_called = False @raises(RuntimeError) @fudge.test def some_test(): holder.test_called = True fake = fudge.Fake('db').expects('save') raise RuntimeError some_test() fudge.verify() # should be no errors eq_(holder.test_called, True) def test_calls_are_cleared(self): class holder: test_called = False sess = fudge.Fake('session').expects('save') # call should be cleared: sess.save() @fudge.test def some_test(): holder.test_called = True db = fudge.Fake('db').expects('save').times_called(1) db.save() some_test() fudge.verify() # should be no errors eq_(holder.test_called, True) @raises(AssertionError) def test_verify(self): @fudge.test def some_test(): fake = fudge.Fake('db').expects('save') some_test()