示例#1
0
    def test_commit_raises_session_commit_exception(self):
        self.sqlite_db._session.commit = fudge.Fake().expects_call().raises(ValueError)

        with self.assertRaises(ValueError):
            self.sqlite_db.commit()

        fudge.verify()
示例#2
0
    def test_create_not_latin_chars(self):

        def inspect_request(r):
            # NOTE: due to URL fetching, you can only raise
            # AssertionError here
            self.assertEqual(r.get_full_url(), 'http://__dummylive365service__/cgi-bin/add_song.cgi')
            qs = dict(cgi.parse_qsl(r.data))
            self.assertEqual(qs['member_name'], "dummy_member")
            self.assertEqual(qs['password'], "dummy_password")
            self.assertEqual(qs['seconds'], '30')
            # c should be replaced because latin-1 can't encode that and Live365 likes latin-1
            self.assertEqual(qs['title'], 'Ivan Krsti song')
            self.assertEqual(qs['album'], 'Ivan Krsti album')
            self.assertEqual(qs['artist'], 'Ivan Krsti')
            return True

        fake_urlopen = (fudge.Fake('urlopen', expect_call=True)
                                .with_args(arg.passes_test(inspect_request)))

        fake_response = (fake_urlopen
                                .returns_fake()
                                .has_attr(code='200')
                                .provides('read')
                                .returns("<service response>"))

        with fudge.patched_context(playlists.tasks.urllib2, "urlopen", fake_urlopen):
            resp = self.client.post(reverse('playlists.send_track_to_live365'), {
                'id': self.track.key()
            })

        fudge.verify()
    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()
    def test_dispatches_to_authorize_to_create_transaction(self):
        donation, donation_form = self.random_donation_and_form

        api = fudge.Fake("api")
        api.expects("transaction").with_args(
                amount=donation.amount,
                card_num=donation_form.cleaned_data["card_number"],
                card_code=donation_form.cleaned_data["ccv_code"],
                exp_date=u"%02d-%04d" % (
                        int(donation_form.cleaned_data["expiration_month"]),
                        int(donation_form.cleaned_data["expiration_year"])),
                description=u"Donation: $%d" % donation.amount,
                first_name=unicode(donation.donor.name.split(" ")[0]),
                last_name=unicode(donation.donor.name.split(" ", 1)[-1]),
                address=donation.donor.address.address,
                city=donation.donor.address.city,
                state=donation.donor.address.state,
                zip=donation.donor.address.zipcode,
        ).returns({"reason_code": u"1", "reason_text": u"Some random Reason"})
        get_api = fudge.Fake().expects_call().returns(api)

        backend = backends.AuthorizeNetBackend()
        with fudge.patched_context(backend, "get_api", get_api):
            backend.purchase(donation, donation_form)
        fudge.verify()
    def test_dont_include_repeats_suffix_if_one_time(self):
        donation, donation_form = self.random_donation_and_form
        donation.donation_type = self.random_monthly_type
        donation.donation_type.repeat = 0

        api = fudge.Fake("api")
        api.expects("transaction").with_args(
                amount=donation.amount,
                card_num=donation_form.cleaned_data["card_number"],
                card_code=donation_form.cleaned_data["ccv_code"],
                exp_date=u"%02d-%04d" % (
                        int(donation_form.cleaned_data["expiration_month"]),
                        int(donation_form.cleaned_data["expiration_year"])),
                description=u"Membership: %s" % donation.donation_type.name,
                first_name=unicode(donation.donor.first_name),
                last_name=unicode(donation.donor.last_name),
                address=donation.donor.address.address,
                city=donation.donor.address.city,
                state=donation.donor.address.state,
                zip=donation.donor.address.zipcode,
        ).returns({"reason_code": u"1", "reason_text": u"Some random Reason"})
        get_api = fudge.Fake().expects_call().returns(api)

        backend = backends.AuthorizeNetBackend()
        with fudge.patched_context(backend, "get_api", get_api):
            backend.purchase(donation, donation_form)
        fudge.verify()
    def test_calls_to_recurring_donation_if_donation_is_recurring(self):
        donation, donation_form = self.random_donation_and_form
        donation.donation_type = self.random_monthly_type
        today = datetime.date.today()
        start_date = u"%s" % ((today + datetime.timedelta(days=30))
                .strftime("%Y-%m-%d"))

        recurring_api = fudge.Fake()
        expiration_date = u"%(expiration_year)s-%(expiration_month)s" % (
                donation_form.cleaned_data)
        recurring_api.expects("create_subscription").with_args(
                amount=donation.amount,
                interval_unit=arb.MONTHS_INTERVAL,
                interval_length=u"1",
                card_number=donation_form.cleaned_data["card_number"],
                card_code=donation_form.cleaned_data["ccv_code"],
                expiration_date=expiration_date,
                bill_first_name=u"%s" % donation.donor.name.split(" ")[0],
                bill_last_name=u"%s" % donation.donor.name.split(" ", 1)[-1],
                total_occurrences=donation.donation_type.repeat,
                start_date=start_date,
        ).returns({"messages": {"result_code": {"text_": u"Ok"}}})

        fake = fudge.Fake().expects_call().returns(recurring_api)
        backend = backends.AuthorizeNetBackend()
        with fudge.patched_context(backend, "get_api", self.get_api_stub()):
            with fudge.patched_context(backend, "get_recurring_api", fake):
                backend.purchase(donation, donation_form)
        fudge.verify()
示例#7
0
    def test_raises_exception_if_dir_does_not_exists_after_creation_attempt(self):
        # first assert signatures of the functions we are going to mock did not change.
        assert_spec(os.makedirs, ['name', 'mode'])
        assert_spec(os.path.exists, ['path'])

        # prepare state
        fake_makedirs = fudge.Fake('makedirs')\
            .expects_call()

        fake_exists = fudge.Fake('exists')\
            .expects_call()\
            .returns(False)\
            .next_call()\
            .returns(False)
        library_db_file = os.path.join(self.test_temp_dir, 'no-such-dir', 'test_database1.db')

        # test
        with fudge.patched_context(os, 'makedirs', fake_makedirs):
            with fudge.patched_context(os.path, 'exists', fake_exists):
                try:
                    db = LibraryDb(driver='sqlite', dbname=library_db_file)
                    db._create_path()
                except Exception as exc:
                    self.assertIn('Couldn\'t create directory', exc.message)
        fudge.verify()
示例#8
0
    def test_add_document_to_writer_for_each_given_identifier(self):
        # prepare state

        # TODO: It is so complicated. Find another way to mock indexer.
        fake_writer = fudge.Fake()\
            .expects('add_document')\
            .expects('commit')

        class FakeSearcher(object):
            pass

        FakeSearcher.documents = fudge.Fake()\
            .expects_call()\
            .returns([])

        search = Search(self.lib)

        search._identifier_index = fudge.Fake('Index')\
            .provides('writer')\
            .returns(fake_writer)\
            .provides('searcher')\
            .returns(FakeSearcher())

        # testing
        identifiers = [
            {'identifier': 'ident1', 'type': 'type1', 'name': 'name1'},
            {'identifier': 'ident2', 'type': 'type2', 'name': 'name2'}]

        search.index_identifiers(identifiers)
        fudge.verify()
        def registry(num):
            try:
                try:
                    fudge.clear_calls()
                    fudge.clear_expectations()

                    exp_order = ExpectedCallOrder(self.fake)
                    reg.remember_expected_call_order(exp_order)
                    eq_(len(reg.get_expected_call_order().keys()), 1)

                    # registered first time on __init__ :
                    exp = ExpectedCall(self.fake, "callMe", call_order=exp_order)
                    reg.expect_call(exp)
                    reg.expect_call(exp)
                    reg.expect_call(exp)
                    eq_(len(reg.get_expected_calls()), 4)

                    # actual calls:
                    exp()
                    exp()
                    exp()
                    exp()

                    fudge.verify()
                    fudge.clear_expectations()
                except Exception, er:
                    thread_run.errors.append(er)
                    raise
            finally:
                thread_run.waiting -= 1
示例#10
0
 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()
示例#11
0
 def test_closes_session_and_connection(self):
     db = LibraryDb(driver='sqlite')
     db.session.close = fudge.Fake('session.close').expects_call()
     db.connection.close = fudge.Fake('connection.close').expects_call()
     db.close()
     fudge.verify()
     self.assertIsNone(db._session)
     self.assertIsNone(db._connection)
示例#12
0
 def __exit__(self, exc_type, exc_val, exc_tb):
     try:
         if not exc_type:
             fudge.verify()
     finally:
         for p in self.patches:
             p.restore()
         fudge.clear_expectations()
    def test_is_test_is_false_for_api_class_api_by_default(self):
        api_class = fudge.Fake().expects_call().with_args(arg.any(), arg.any(),
                delimiter=arg.any(), is_test=False)

        backend = backends.AuthorizeNetBackend()
        with fudge.patched_context(backend, "api_class", api_class):
            backend.get_api()
        fudge.verify()
    def test_adds_is_test_to_api_class_api_if_in_testing_mode(self):
        api_class = fudge.Fake().expects_call().with_args(arg.any(), arg.any(),
                delimiter=arg.any(), is_test=True)

        backend = backends.AuthorizeNetBackend(testing=True)
        with fudge.patched_context(backend, "api_class", api_class):
            backend.get_api()
        fudge.verify()
示例#15
0
    def inner(self, *args, **kwargs):
        request = fudge.Fake(HttpRequest)
        request.has_attr(COOKIES={})
        result = func(self, request, *args, **kwargs)

        fudge.verify()
        fudge.clear_expectations()
        return result
示例#16
0
    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()
示例#17
0
    def test_returns_false_if_database_exists(self):
        # first assert signatures of the functions we are going to mock did not change.
        assert_spec(self.sqlite_db.exists, ['self'])

        # prepare state
        self.sqlite_db.exists = fudge.Fake('exists').expects_call().returns(True)
        ret = self.sqlite_db.create()
        self.assertFalse(ret)
        fudge.verify()
 def test_variable_resolution_for_list(self):
     random_list_name = "list_%d" % random.randint(100, 200)
     rln = RenderListNode(Variable(random_list_name), "'debug'")
     with stub_render_to_string():
         try:
             rln.render(Context({random_list_name: [generate_random_model()]}))
         except VariableDoesNotExist:
             self.fail("should have found variable in context")
     fudge.verify()
示例#19
0
 def test_contains_list(self):
     db = Fake("db").expects("execute_statements").with_args(
                                         arg.contains("select * from foo"))
     db.execute_statements([
         "update foo",
         "select * from foo",
         "drop table foo"
     ])
     fudge.verify()
示例#20
0
    def test_updates_config(self):
        # first assert signatures of the functions we are going to mock did not change.
        assert_spec(self.sqlite_db.set_config_value, ['self', 'group', 'key', 'value'])

        self.sqlite_db.set_config_value = fudge.Fake('set_config_value')\
            .expects_call()\
            .with_args('activity', 'change', arg.any())

        self.sqlite_db._mark_update()
        fudge.verify()
示例#21
0
def test_task_will_invoke_provided_class():
    def foo(): pass
    fake = Fake()
    fake.expects("__init__").with_args(foo)
    fudge.clear_calls()
    fudge.clear_expectations()

    foo = decorators.task(foo, task_class=fake)

    fudge.verify()
    def test_global_verify(self):
        exp = ExpectedCall(self.fake, "callMe")
        exp()
        eq_(exp.was_called, True)
        eq_(len(self.reg.get_expected_calls()), 1)

        fudge.verify()

        eq_(exp.was_called, False, "call was not reset by verify()")
        eq_(len(self.reg.get_expected_calls()), 1, "verify() should not reset expectations")
示例#23
0
    def test_extracts_view_out_of_templatetag_call(self):
        random_view_name = 'hello_world_%d' % random.randint(100, 200)
        token = fudge.Fake()
        token.expects('split_contents').returns(('esi', random_view_name))
        fudge.clear_calls()

        result = esi(Parser([]), token)
        self.assertEquals(str(result.view_name), random_view_name)

        fudge.verify()
 def test_finds_new_templates_for_each_model(self):
     rln = RenderListNode(Variable('list'), "'debug'")
     num_models = random.randint(5, 10)
     with stub_render_to_string():
         try:
             rln.render(Context({'list': [generate_random_model()
                 for i in range(num_models)]}))
         except VariableDoesNotExist:
             self.fail("should have found variable in context")
     fudge.verify()
示例#25
0
    def test_handle_Multiword(self):
        bridge = fudge.Fake("bridge").provides("get_group").calls(lambda: {"1":{"name":"Bedroom"}, "2":{"name":"LivingRoom"}})
        bridge.expects("set_group")
        light_action = hue._handle(bridge, "Turn the living room lights on")
        group_id = light_action.light_group
        action = light_action.action

        self.assertEqual(group_id, "2")
        self.assertEqual(action, "on")
        fudge.verify()
示例#26
0
 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()
    def test_embed_dispatches_kwargs_to_backend(self):
        kwargs = dict(
                [("key-%d" % a, a) for a in range(random.randint(1, 10))])
        backend = fudge.Fake()
        backend.provides("prepare")
        video = EmbeddedVideo("foo/bar", backend=backend)
        backend.expects("embed").with_args(video, **kwargs)
        fudge.clear_calls()

        video.embed(**kwargs)
        fudge.verify()
    def test_dispatches_to_configured_backend(self):
        m = Donation()
        random_card = "some-random-card-%d" % random.randint(1000, 2000)
        fake_backend = fudge.Fake()
        fake_backend.expects("purchase").with_args(m, random_card)
        fake_get_backend = fudge.Fake()
        fake_get_backend.is_callable().returns(fake_backend)
        with fudge.patched_context(backends, "get_backend", fake_get_backend):
            m.purchase(random_card)

        fudge.verify()
示例#29
0
def test_task_passes_args_to_the_task_class():
    random_vars = ("some text", random.randint(100, 200))
    def foo(): pass

    fake = Fake()
    fake.expects("__init__").with_args(foo, *random_vars)
    fudge.clear_calls()
    fudge.clear_expectations()

    foo = decorators.task(foo, task_class=fake, *random_vars)
    fudge.verify()
    def test_embed_dispatches_to_backend_and_returns_result(self):
        random_return = random.randint(1000, 2000)
        backend = fudge.Fake()
        backend.provides("prepare")
        video = EmbeddedVideo("foo/bar", backend=backend)
        backend.expects("embed").with_args(video).returns(random_return)
        fudge.clear_calls()

        result = video.embed()
        self.assertEqual(result, random_return)

        fudge.verify()
    def test_fires_donation_complete_on_successful_charge(self):
        donation, form = self.random_donation_and_form
        result = {
            "status": True,
            "random": random.randint(100, 200),
        }
        onetime_purchase = (fudge.Fake().is_callable().returns(result))

        backend = backends.AuthorizeNetBackend()
        signal = (fudge.Fake().expects_call().with_args(sender=backend,
                                                        donation=donation,
                                                        signal=arg.any(),
                                                        form=form,
                                                        result=result))
        signals.successful_purchase.connect(signal)
        with stub_onetime_purchase(backend, onetime_purchase):
            backend.purchase(donation, form)

        fudge.verify()
        signals.successful_purchase.disconnect(signal)
示例#32
0
    def test_post_passes_kwargs_to_form_is_valid(self):
        r = lambda: random.randint(100, 200)
        random_kwargs = {
            "slug%d" % r(): "foo-%d" % r(),
        }
        donation_form = fudge.Fake()
        donation_form.provides("is_valid").returns(True)
        get_donation_form = fudge.Fake()
        get_donation_form.is_callable().returns(donation_form)

        form_is_valid = fudge.Fake()
        form_is_valid.expects_call().with_args(donation_form=donation_form,
                                               **random_kwargs)
        view = self.post_view
        with fudge.patched_context(view, "get_donation_form",
                                   get_donation_form):
            with fudge.patched_context(view, "form_is_valid", form_is_valid):
                view.post({}, **random_kwargs)

        fudge.verify()
示例#33
0
    def test_create_ascii_chars(self):

        self.playlist = ChirpBroadcast()
        selector = self.get_selector()
        self.track = PlaylistTrack(
                    playlist=self.playlist,
                    selector=selector,
                    freeform_artist_name=u'artist',
                    freeform_album_title=u'album',
                    freeform_track_title=u'song')
        self.track.put()

        def inspect_request(r):
            # NOTE: due to URL fetching, you can only raise
            # AssertionError here
            self.assertEqual(r.get_full_url(), 'http://__dummylive365service__/cgi-bin/add_song.cgi')
            qs = dict(cgi.parse_qsl(r.data))
            self.assertEqual(qs['member_name'], "dummy_member")
            self.assertEqual(qs['password'], "dummy_password")
            self.assertEqual(qs['seconds'], '30')
            # c should be replaced because latin-1 can't encode that and Live365 likes latin-1
            self.assertEqual(qs['title'], 'song')
            self.assertEqual(qs['album'], 'album')
            self.assertEqual(qs['artist'], 'artist')
            return True

        fake_urlopen = (fudge.Fake('urlopen', expect_call=True)
                                .with_args(arg.passes_test(inspect_request)))

        fake_response = (fake_urlopen
                                .returns_fake()
                                .has_attr(code='200')
                                .provides('read')
                                .returns("<service response>"))

        with fudge.patched_context(playlists.tasks.urllib2, "urlopen", fake_urlopen):
            resp = self.client.post(reverse('playlists.send_track_to_live365'), {
                'id': self.track.key()
            })

        fudge.verify()
示例#34
0
def check_connection_calls(host_strings, num_calls):
    # Clear Fudge call stack
    clear_calls()
    # Patch connect() with Fake obj set to expect num_calls calls
    patched_connect = patch_object(
        'fabric.network', 'connect',
        Fake('connect', expect_call=True).times_called(num_calls))
    try:
        # Make new cache object
        cache = HostConnectionCache()
        # Connect to all connection strings
        for host_string in host_strings:
            # Obtain connection from cache, potentially calling connect()
            cache[host_string]
        # Verify expected calls matches up with actual calls
        verify()
    finally:
        # Restore connect()
        patched_connect.restore()
        # Clear expectation stack
        clear_expectations()
示例#35
0
    def test_form_is_valid_passes_kwargs_to_purchase_failed(self):
        donation, donation_form = self.random_donation_and_form
        r = lambda: random.randint(100, 200)
        random_kwargs = {
            "slug%d" % r(): "foo-%d" % r(),
        }

        view = self.post_view
        view.confirm = False
        backends = self.get_backend_stub(successful=False)
        backend_response = backends.get_backend().purchase()

        purchase_failed = fudge.Fake()
        purchase_failed.expects_call().with_args(backend_response,
                                                 **random_kwargs)

        with fudge.patched_context(views, "backends", backends):
            with fudge.patched_context(view, "purchase_failed",
                                       purchase_failed):
                view.form_is_valid(donation_form, **random_kwargs)

        fudge.verify()
    def test_api_instantiates_api_class_with_configured_settings(self):
        random_login = "******" % random.randint(100, 200)
        random_key = "some random key %d" % random.randint(100, 200)
        random_return = "some random return %d" % random.randint(100, 200)
        settings = fudge.Fake()
        settings.has_attr(AUTHORIZE={
            "LOGIN": random_login,
            "KEY": random_key,
        })
        api_class = fudge.Fake()

        # Note that delimiter is included here because authorize's code
        # can't even keep track of what deliminter it wants to use!
        (api_class.expects_call().with_args(
            random_login, random_key, delimiter=arg.any(),
            is_test=arg.any()).returns(random_return))
        fudge.clear_calls()

        backend = backends.AuthorizeNetBackend(api_class=api_class,
                                               settings=settings)
        result = backend.get_api()
        self.assertEqual(result, random_return)
        fudge.verify()
示例#37
0
 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()
示例#38
0
 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()
示例#39
0
 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()
示例#40
0
 def tearDown(self):
     fudge.verify()
     super(TestCase, self).tearDown()
示例#41
0
 def test_expects_call_shortcut_ok(self):
     remove = Fake("os.remove").expects_call()
     remove()
     fudge.verify()
     assert isinstance(remove, Fake)
示例#42
0
 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()
示例#43
0
 def test_contains_str(self):
     db = Fake("db").expects("execute").with_args(arg.contains("table foo"))
     db.execute("select into table foo;")
     db.execute("select * from table foo where bar = 1")
     fudge.verify()
示例#44
0
 def test_expected_callable(self):
     login = fudge.Fake('login', expect_call=True).times_called(2)
     login()
     fudge.verify()
示例#45
0
 def test_callable_expectation_with_args(self):
     fake_setup = (fudge.Fake('setup', expect_call=True).with_args('<db>'))
     fake_setup('<db>')
     # was called so verification should pass:
     fudge.verify()
示例#46
0
 def test_callable_expectation(self):
     fake_setup = fudge.Fake('setup', expect_call=True)
     fake_setup()
     # was called so verification should pass:
     fudge.verify()
示例#47
0
 def test_when_provided_ok(self):
     self.fake = fudge.Fake().provides("something").times_called(2)
     self.fake.something()
     self.fake.something()
     fudge.verify()
示例#48
0
 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()
示例#49
0
 def test_contains_fail(self):
     db = Fake("db").expects("execute").with_args(arg.contains("table foo"))
     db.execute("select into table notyourmama;")
     fudge.verify()
示例#50
0
 def decorated_function(*args, **kwargs):
     try:
         result = f(*args, **kwargs)
     finally:
         fudge.verify()
     return result
示例#51
0
 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()
示例#52
0
 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()
示例#53
0
 def test_out_of_order(self):
     fake = fudge.Fake().remember_order().expects("one").expects("two")
     fake.two()
     fake.one()
     fudge.verify()
示例#54
0
 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()
示例#55
0
 def test_contains_list(self):
     db = Fake("db").expects("execute_statements").with_args(
         arg.contains("select * from foo"))
     db.execute_statements(
         ["update foo", "select * from foo", "drop table foo"])
     fudge.verify()
示例#56
0
 def test_callable(self):
     fake = fudge.Fake().is_callable()
     fake()  # allow the call
     fudge.verify()  # no error
示例#57
0
 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()
示例#58
0
 def test_when_expected_ok(self):
     self.fake = fudge.Fake().expects("something").times_called(2)
     self.fake.something()
     self.fake.something()
     fudge.verify()
示例#59
0
 def test_callable_ok(self):
     self.fake = fudge.Fake(callable=True).times_called(2)
     self.fake()
     self.fake()
     fudge.verify()
示例#60
0
 def test_nocall(self):
     fake = fudge.Fake()
     exp = fake.expects('something')
     fudge.verify()