Example #1
0
def test_proxy_manual_start_stop(container_factory, rabbit_config):

    container = container_factory(FooService, rabbit_config)
    container.start()

    foobar_proxy = RpcProxy('foobar', rabbit_config)
    foo = foobar_proxy.start()
    assert foo.spam(ham='eggs') == 'eggs'
    assert foo.spam(ham='eggs') == 'eggs'  # test re-use
    foobar_proxy.stop()
Example #2
0
 def make_proxy(service_name, **kwargs):
     proxy = RpcProxy(service_name, rabbit_config, **kwargs)
     all_proxies.append(proxy)
     return proxy.start()
Example #3
0
 def wait_for_result():
     with RpcProxy("exampleservice", rabbit_config) as proxy:
         return proxy.task_a()
Example #4
0
def test_rpc_incorrect_signature(container_factory, rabbit_config):
    class Service(object):
        @rpc
        def no_args(self):
            pass

        @rpc
        def args_only(self, a):
            pass

        @rpc
        def kwargs_only(self, a=None):
            pass

        @rpc
        def star_args(self, *args):
            pass

        @rpc
        def star_kwargs(self, **kwargs):
            pass

        @rpc
        def args_star_args(self, a, *args):
            pass

        @rpc
        def args_star_kwargs(self, a, **kwargs):
            pass

    container = container_factory(Service, rabbit_config)
    container.start()

    method_calls = [
        (('no_args', (), {}), True),
        (('no_args', ('bad arg', ), {}), False),
        (('args_only', ('arg', ), {}), True),
        (('args_only', (), {
            'a': 'arg'
        }), True),
        (('args_only', (), {
            'arg': 'arg'
        }), False),
        (('kwargs_only', ('a', ), {}), True),
        (('kwargs_only', (), {
            'a': 'arg'
        }), True),
        (('kwargs_only', (), {
            'arg': 'arg'
        }), False),
        (('star_args', ('a', 'b'), {}), True),
        (('star_args', (), {
            'c': 'c'
        }), False),
        (('args_star_args', ('a', ), {}), True),
        (('args_star_args', ('a', 'b'), {}), True),
        (('args_star_args', (), {}), False),
        (('args_star_args', (), {
            'c': 'c'
        }), False),
        (('args_star_kwargs', ('a', ), {}), True),
        (('args_star_kwargs', ('a', 'b'), {}), False),
        (('args_star_kwargs', ('a', 'b'), {
            'c': 'c'
        }), False),
        (('args_star_kwargs', (), {}), False),
    ]

    for signature, is_valid_call in method_calls:

        method_name, args, kwargs = signature

        with RpcProxy("service", rabbit_config) as proxy:
            method = getattr(proxy, method_name)

            if not is_valid_call:
                with pytest.raises(IncorrectSignature):
                    method(*args, **kwargs)
            else:
                method(*args, **kwargs)  # no raise