def test_run(self): """ Test the `ipalib.frontend.Command.run` method. """ class my_cmd(self.cls): def execute(self, *args, **kw): return ('execute', args, kw) def forward(self, *args, **kw): return ('forward', args, kw) args = ('Hello,', 'world,') kw = dict(how_are='you', on_this='fine day?', version=API_VERSION) # Test in server context: api, _home = create_test_api(in_server=True) api.finalize() o = my_cmd(api) if six.PY2: assert o.run.__func__ is self.cls.run.__func__ else: assert o.run.__func__ is self.cls.run out = o.run(*args, **kw) assert ('execute', args, kw) == out # Test in non-server context api, _home = create_test_api(in_server=False) api.finalize() o = my_cmd(api) if six.PY2: assert o.run.__func__ is self.cls.run.__func__ else: assert o.run.__func__ is self.cls.run assert ('forward', args, kw) == o.run(*args, **kw)
def test_run(self): """ Test the `ipalib.frontend.Command.run` method. """ class my_cmd(self.cls): def execute(self, *args, **kw): return ('execute', args, kw) def forward(self, *args, **kw): return ('forward', args, kw) args = ('Hello,', 'world,') kw = dict(how_are='you', on_this='fine day?', version=API_VERSION) # Test in server context: (api, home) = create_test_api(in_server=True) api.finalize() o = my_cmd(api) assert o.run.__func__ is self.cls.run.__func__ out = o.run(*args, **kw) assert ('execute', args, kw) == out # Test in non-server context (api, home) = create_test_api(in_server=False) api.finalize() o = my_cmd(api) assert o.run.__func__ is self.cls.run.__func__ assert ('forward', args, kw) == o.run(*args, **kw)
def test_run(self): """ Test the `ipalib.frontend.LocalOrRemote.run` method. """ class example(self.cls): takes_args = 'key?' def forward(self, *args, **options): return dict(result=('forward', args, options)) def execute(self, *args, **options): return dict(result=('execute', args, options)) # Test when in_server=False: (api, home) = create_test_api(in_server=False) api.add_plugin(example) api.finalize() cmd = api.Command.example assert cmd(version=u'2.47') == dict( result=('execute', (None,), dict(version=u'2.47', server=False)) ) assert cmd(u'var', version=u'2.47') == dict( result=('execute', (u'var',), dict(version=u'2.47', server=False)) ) assert cmd(server=True, version=u'2.47') == dict( result=('forward', (None,), dict(version=u'2.47', server=True)) ) assert cmd(u'var', server=True, version=u'2.47') == dict( result=('forward', (u'var',), dict(version=u'2.47', server=True)) ) # Test when in_server=True (should always call execute): (api, home) = create_test_api(in_server=True) api.add_plugin(example) api.finalize() cmd = api.Command.example assert cmd(version=u'2.47') == dict( result=('execute', (None,), dict(version=u'2.47', server=False)) ) assert cmd(u'var', version=u'2.47') == dict( result=('execute', (u'var',), dict(version=u'2.47', server=False)) ) assert cmd(server=True, version=u'2.47') == dict( result=('execute', (None,), dict(version=u'2.47', server=True)) ) assert cmd(u'var', server=True, version=u'2.47') == dict( result=('execute', (u'var',), dict(version=u'2.47', server=True)) )
def test_default_from_chaining(self): """ Test chaining of parameters through default_from. """ class my_cmd(self.cls): takes_options = ( Str('option0'), Str('option1', default_from=lambda option0: option0), Str('option2', default_from=lambda option1: option1), ) def run(self, *args, **options): return dict(result=options) kw = dict(option0=u'some value') (api, home) = create_test_api() api.finalize() o = my_cmd() o.set_api(api) o.finalize() e = o(**kw) # pylint: disable=not-callable assert type(e) is dict assert 'result' in e assert 'option2' in e['result'] assert e['result']['option2'] == u'some value'
def test_args_options_2_entry(self): """ Test `ipalib.frontend.Command.args_options_2_entry` method. """ class my_cmd(self.cls): takes_args = ( parameters.Str('one', attribute=True), parameters.Str('two', attribute=False), ) takes_options = ( parameters.Str('three', attribute=True, multivalue=True), parameters.Str('four', attribute=True, multivalue=False), ) def run(self, *args, **kw): return self.args_options_2_entry(*args, **kw) args = ('one', 'two') kw = dict(three=('three1', 'three2'), four='four') api, _home = create_test_api() api.finalize() o = my_cmd(api) o.finalize() e = o.run(*args, **kw) assert type(e) is dict assert 'one' in e assert 'two' not in e assert 'three' in e assert 'four' in e assert e['one'] == 'one' assert e['three'] == ['three1', 'three2'] assert e['four'] == 'four'
def test_default_from_chaining(self): """ Test chaining of parameters through default_from. """ class my_cmd(self.cls): takes_options = ( Str('option0'), Str('option1', default_from=lambda option0: option0), Str('option2', default_from=lambda option1: option1), ) def run(self, *args, **options): return dict(result=options) kw = dict(option0=u'some value') (api, home) = create_test_api() api.finalize() o = my_cmd(api) o.finalize() e = o(**kw) # pylint: disable=not-callable assert type(e) is dict assert 'result' in e assert 'option2' in e['result'] assert e['result']['option2'] == u'some value'
def test_args_options_2_entry(self): """ Test `ipalib.frontend.Command.args_options_2_entry` method. """ class my_cmd(self.cls): takes_args = ( parameters.Str('one', attribute=True), parameters.Str('two', attribute=False), ) takes_options = ( parameters.Str('three', attribute=True, multivalue=True), parameters.Str('four', attribute=True, multivalue=False), ) def run(self, *args, **kw): return self.args_options_2_entry(*args, **kw) args = ('one', 'two') kw = dict(three=('three1', 'three2'), four='four') (api, home) = create_test_api() api.finalize() o = my_cmd(api) o.finalize() e = o.run(*args, **kw) assert type(e) is dict assert 'one' in e assert 'two' not in e assert 'three' in e assert 'four' in e assert e['one'] == 'one' assert e['three'] == ['three1', 'three2'] assert e['four'] == 'four'
def test_messages(self): """ Test correct handling of messages """ class TestMessage(messages.PublicMessage): type = 'info' format = 'This is a message.' errno = 1234 class my_cmd(self.cls): def execute(self, *args, **kw): result = {'name': 'execute'} messages.add_message(kw['version'], result, TestMessage()) return result def forward(self, *args, **kw): result = {'name': 'forward'} messages.add_message(kw['version'], result, TestMessage()) return result args = ('Hello,', 'world,') kw = dict(how_are='you', on_this='fine day?', version=API_VERSION) expected = [TestMessage().to_dict()] # Test in server context: api, _home = create_test_api(in_server=True) api.finalize() o = my_cmd(api) if six.PY2: assert o.run.__func__ is self.cls.run.__func__ else: assert o.run.__func__ is self.cls.run assert {'name': 'execute', 'messages': expected} == o.run(*args, **kw) # Test in non-server context api, _home = create_test_api(in_server=False) api.finalize() o = my_cmd(api) if six.PY2: assert o.run.__func__ is self.cls.run.__func__ else: assert o.run.__func__ is self.cls.run assert {'name': 'forward', 'messages': expected} == o.run(*args, **kw)
def test_messages(self): """ Test correct handling of messages """ class TestMessage(messages.PublicMessage): type = 'info' format = 'This is a message.' errno = 1234 class my_cmd(self.cls): def execute(self, *args, **kw): result = {'name': 'execute'} messages.add_message(kw['version'], result, TestMessage()) return result def forward(self, *args, **kw): result = {'name': 'forward'} messages.add_message(kw['version'], result, TestMessage()) return result args = ('Hello,', 'world,') kw = dict(how_are='you', on_this='fine day?', version=API_VERSION) expected = [TestMessage().to_dict()] # Test in server context: (api, home) = create_test_api(in_server=True) api.finalize() o = my_cmd(api) if six.PY2: assert o.run.__func__ is self.cls.run.__func__ else: assert o.run.__func__ is self.cls.run assert {'name': 'execute', 'messages': expected} == o.run(*args, **kw) # Test in non-server context (api, home) = create_test_api(in_server=False) api.finalize() o = my_cmd(api) if six.PY2: assert o.run.__func__ is self.cls.run.__func__ else: assert o.run.__func__ is self.cls.run assert {'name': 'forward', 'messages': expected} == o.run(*args, **kw)
def test_run(self): """ Test the `ipalib.frontend.LocalOrRemote.run` method. """ class example(self.cls): takes_args = 'key?' def forward(self, *args, **options): return dict(result=('forward', args, options)) def execute(self, *args, **options): return dict(result=('execute', args, options)) # Test when in_server=False: api, _home = create_test_api(in_server=False) api.add_plugin(example) api.finalize() cmd = api.Command.example assert cmd(version=u'2.47') == dict(result=('execute', (), dict(version=u'2.47'))) assert cmd(u'var', version=u'2.47') == dict(result=('execute', (u'var', ), dict(version=u'2.47'))) assert cmd(server=True, version=u'2.47') == dict( result=('forward', (), dict(version=u'2.47', server=True))) assert cmd(u'var', server=True, version=u'2.47') == dict( result=('forward', (u'var', ), dict(version=u'2.47', server=True))) # Test when in_server=True (should always call execute): api, _home = create_test_api(in_server=True) api.add_plugin(example) api.finalize() cmd = api.Command.example assert cmd(version=u'2.47') == dict( result=('execute', (), dict(version=u'2.47', server=False))) assert cmd(u'var', version=u'2.47') == dict( result=('execute', (u'var', ), dict(version=u'2.47', server=False))) assert cmd(server=True, version=u'2.47') == dict( result=('execute', (), dict(version=u'2.47', server=True))) assert cmd(u'var', server=True, version=u'2.47') == dict( result=('execute', (u'var', ), dict(version=u'2.47', server=True)))
def test_load_plugins(self): """ Test the `ipalib.plugable.API.load_plugins` method. """ (o, home) = create_test_api() assert o.isdone('bootstrap') is False assert o.isdone('load_plugins') is False o.load_plugins() assert o.isdone('bootstrap') is True assert o.isdone('load_plugins') is True e = raises(StandardError, o.load_plugins) assert str(e) == 'API.load_plugins() already called'
def test_load_plugins(self): """ Test the `ipalib.plugable.API.load_plugins` method. """ (o, home) = create_test_api() assert o.isdone('bootstrap') is False assert o.isdone('load_plugins') is False o.load_plugins() assert o.isdone('bootstrap') is True assert o.isdone('load_plugins') is True e = raises(Exception, o.load_plugins) assert str(e) == 'API.load_plugins() already called'
def test_load_plugins(self): """ Test the `ipalib.plugable.API.load_plugins` method. """ (o, home) = create_test_api() assert o.isdone("bootstrap") is False assert o.isdone("load_plugins") is False o.load_plugins() assert o.isdone("bootstrap") is True assert o.isdone("load_plugins") is True e = raises(StandardError, o.load_plugins) assert str(e) == "API.load_plugins() already called"
def test_primary_key(self): """ Test the `ipalib.frontend.Object.primary_key` attribute. """ (api, home) = create_test_api() api.finalize() # Test with no primary keys: class example1(self.cls): takes_params = ( 'one', 'two', ) o = example1() o.set_api(api) assert o.primary_key is None # Test with 1 primary key: class example2(self.cls): takes_params = ( 'one', 'two', parameters.Str('three', primary_key=True), 'four', ) o = example2() o.set_api(api) pk = o.primary_key assert type(pk) is parameters.Str assert pk.name == 'three' assert pk.primary_key is True assert o.params[2] is o.primary_key assert isinstance(o.params_minus_pk, plugable.NameSpace) assert list(o.params_minus_pk) == ['one', 'two', 'four'] # Test with multiple primary_key: class example3(self.cls): takes_params = ( parameters.Str('one', primary_key=True), parameters.Str('two', primary_key=True), 'three', parameters.Str('four', primary_key=True), ) o = example3() o.set_api(api) e = raises(ValueError, o.finalize) assert str(e) == \ 'example3 (Object) has multiple primary keys: one, two, four'
def test_bootstrap(self): """ Test the `ipalib.plugable.API.bootstrap` method. """ (o, home) = create_test_api() assert o.env._isdone('_bootstrap') is False assert o.env._isdone('_finalize_core') is False assert o.isdone('bootstrap') is False o.bootstrap(my_test_override='Hello, world!') assert o.isdone('bootstrap') is True assert o.env._isdone('_bootstrap') is True assert o.env._isdone('_finalize_core') is True assert o.env.my_test_override == 'Hello, world!' e = raises(StandardError, o.bootstrap) assert str(e) == 'API.bootstrap() already called'
def test_bootstrap(self): """ Test the `ipalib.plugable.API.bootstrap` method. """ (o, home) = create_test_api() assert o.env._isdone("_bootstrap") is False assert o.env._isdone("_finalize_core") is False assert o.isdone("bootstrap") is False o.bootstrap(my_test_override="Hello, world!") assert o.isdone("bootstrap") is True assert o.env._isdone("_bootstrap") is True assert o.env._isdone("_finalize_core") is True assert o.env.my_test_override == "Hello, world!" e = raises(StandardError, o.bootstrap) assert str(e) == "API.bootstrap() already called"
def test_bootstrap(self): """ Test the `ipalib.plugable.API.bootstrap` method. """ (o, home) = create_test_api() assert o.env._isdone('_bootstrap') is False assert o.env._isdone('_finalize_core') is False assert o.isdone('bootstrap') is False o.bootstrap(my_test_override='Hello, world!') assert o.isdone('bootstrap') is True assert o.env._isdone('_bootstrap') is True assert o.env._isdone('_finalize_core') is True assert o.env.my_test_override == 'Hello, world!' e = raises(Exception, o.bootstrap) assert str(e) == 'API.bootstrap() already called'
def test_backend(self): """ Test the `ipalib.frontend.Object.backend` attribute. """ (api, home) = create_test_api() class ldap(backend.Backend): whatever = 'It worked!' api.add_plugin(ldap) class user(frontend.Object): backend_name = 'ldap' api.add_plugin(user) api.finalize() b = api.Object.user.backend assert isinstance(b, ldap) assert b.whatever == 'It worked!'
def test_params_minus(self): """ Test the `ipalib.frontend.Object.params_minus` method. """ class example(self.cls): takes_params = ('one', 'two', 'three', 'four') (api, home) = create_test_api() api.finalize() o = example(api) p = o.params assert tuple(o.params_minus()) == tuple(p()) assert tuple(o.params_minus([])) == tuple(p()) assert tuple(o.params_minus('two', 'three')) == (p.one, p.four) assert tuple(o.params_minus(['two', 'three'])) == (p.one, p.four) assert tuple(o.params_minus(p.two, p.three)) == (p.one, p.four) assert tuple(o.params_minus([p.two, p.three])) == (p.one, p.four) ns = NameSpace([p.two, p.three]) assert tuple(o.params_minus(ns)) == (p.one, p.four)
def test_backend(self): """ Test the `ipalib.frontend.Object.backend` attribute. """ api, _home = create_test_api() class ldap(backend.Backend): whatever = 'It worked!' api.add_plugin(ldap) class user(frontend.Object): backend_name = 'ldap' api.add_plugin(user) api.finalize() b = api.Object.user.backend assert isinstance(b, ldap) assert b.whatever == 'It worked!'
def get_api(self, args=tuple(), options=tuple()): """ Return a finalized `ipalib.plugable.API` instance. """ (api, home) = create_test_api() class user(frontend.Object): takes_params = ( 'givenname', 'sn', frontend.Param('uid', primary_key=True), 'initials', ) class user_verb(self.cls): takes_args = args takes_options = options api.add_plugin(user) api.add_plugin(user_verb) api.finalize() return api
def test_params_minus(self): """ Test the `ipalib.frontend.Object.params_minus` method. """ class example(self.cls): takes_params = ('one', 'two', 'three', 'four') api, _home = create_test_api() api.finalize() o = example(api) p = o.params assert tuple(o.params_minus()) == tuple(p()) assert tuple(o.params_minus([])) == tuple(p()) assert tuple(o.params_minus('two', 'three')) == (p.one, p.four) assert tuple(o.params_minus(['two', 'three'])) == (p.one, p.four) assert tuple(o.params_minus(p.two, p.three)) == (p.one, p.four) assert tuple(o.params_minus([p.two, p.three])) == (p.one, p.four) ns = NameSpace([p.two, p.three]) assert tuple(o.params_minus(ns)) == (p.one, p.four)
def get_api(self, args=tuple(), options=tuple()): """ Return a finalized `ipalib.plugable.API` instance. """ api, _home = create_test_api() class user(frontend.Object): takes_params = ( 'givenname', 'sn', frontend.Param('uid', primary_key=True), 'initials', ) class user_verb(self.cls): takes_args = args takes_options = options api.add_plugin(user) api.add_plugin(user_verb) api.finalize() return api
def test_execute(self): """ Test the `ipalib.backend.Executioner.execute` method. """ (api, home) = create_test_api(in_server=True) class echo(Command): takes_args = ("arg1", "arg2+") takes_options = ("option1?", "option2?") def execute(self, *args, **options): assert type(args[1]) is tuple return dict(result=args + (options,)) api.add_plugin(echo) class good(Command): def execute(self, **options): raise errors.ValidationError(name="nurse", error=u"Not naughty!") api.add_plugin(good) class bad(Command): def execute(self, **options): raise ValueError("This is private.") api.add_plugin(bad) class with_name(Command): """ Test that a kwarg named 'name' can be used. """ takes_options = "name" def execute(self, **options): return dict(result=options["name"].upper()) api.add_plugin(with_name) api.finalize() o = self.cls(api) o.finalize() # Test that CommandError is raised: conn = Connection("The connection.", Disconnect("someconn")) context.someconn = conn print(str(list(context.__dict__))) e = raises(errors.CommandError, o.execute, "nope") assert e.name == "nope" assert conn.disconnect.called is True # Make sure destroy_context() was called print(str(list(context.__dict__))) assert list(context.__dict__) == [] # Test with echo command: arg1 = unicode_str arg2 = (u"Hello", unicode_str, u"world!") args = (arg1,) + arg2 options = dict(option1=u"How are you?", option2=unicode_str, version=API_VERSION) conn = Connection("The connection.", Disconnect("someconn")) context.someconn = conn print(o.execute("echo", arg1, arg2, **options)) print(dict(result=(arg1, arg2, options))) assert o.execute("echo", arg1, arg2, **options) == dict(result=(arg1, arg2, options)) assert conn.disconnect.called is True # Make sure destroy_context() was called assert list(context.__dict__) == [] conn = Connection("The connection.", Disconnect("someconn")) context.someconn = conn assert o.execute("echo", *args, **options) == dict(result=(arg1, arg2, options)) assert conn.disconnect.called is True # Make sure destroy_context() was called assert list(context.__dict__) == [] # Test with good command: conn = Connection("The connection.", Disconnect("someconn")) context.someconn = conn e = raises(errors.ValidationError, o.execute, "good") assert e.name == "nurse" assert e.error == u"Not naughty!" assert conn.disconnect.called is True # Make sure destroy_context() was called assert list(context.__dict__) == [] # Test with bad command: conn = Connection("The connection.", Disconnect("someconn")) context.someconn = conn e = raises(errors.InternalError, o.execute, "bad") assert conn.disconnect.called is True # Make sure destroy_context() was called assert list(context.__dict__) == [] # Test with option 'name': conn = Connection("The connection.", Disconnect("someconn")) context.someconn = conn expected = dict(result=u"TEST") assert expected == o.execute("with_name", name=u"test", version=API_VERSION)
def test_execute(self): """ Test the `ipalib.backend.Executioner.execute` method. """ (api, home) = create_test_api(in_server=True) class echo(Command): takes_args = ('arg1', 'arg2+') takes_options = ('option1?', 'option2?') def execute(self, *args, **options): assert type(args[1]) is tuple return dict(result=args + (options, )) api.register(echo) class good(Command): def execute(self, **options): raise errors.ValidationError( name='nurse', error=u'Not naughty!', ) api.register(good) class bad(Command): def execute(self, **options): raise ValueError('This is private.') api.register(bad) class with_name(Command): """ Test that a kwarg named 'name' can be used. """ takes_options = 'name' def execute(self, **options): return dict(result=options['name'].upper()) api.register(with_name) api.finalize() o = self.cls() o.set_api(api) o.finalize() # Test that CommandError is raised: conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn print str(context.__dict__.keys()) e = raises(errors.CommandError, o.execute, 'nope') assert e.name == 'nope' assert conn.disconnect.called is True # Make sure destroy_context() was called print str(context.__dict__.keys()) assert context.__dict__.keys() == [] # Test with echo command: arg1 = unicode_str arg2 = (u'Hello', unicode_str, u'world!') args = (arg1, ) + arg2 options = dict(option1=u'How are you?', option2=unicode_str, version=API_VERSION) conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn print o.execute('echo', arg1, arg2, **options) print dict(result=(arg1, arg2, options)) assert o.execute('echo', arg1, arg2, **options) == dict(result=(arg1, arg2, options)) assert conn.disconnect.called is True # Make sure destroy_context() was called assert context.__dict__.keys() == [] conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn assert o.execute('echo', *args, **options) == dict(result=(arg1, arg2, options)) assert conn.disconnect.called is True # Make sure destroy_context() was called assert context.__dict__.keys() == [] # Test with good command: conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn e = raises(errors.ValidationError, o.execute, 'good') assert e.name == 'nurse' assert e.error == u'Not naughty!' assert conn.disconnect.called is True # Make sure destroy_context() was called assert context.__dict__.keys() == [] # Test with bad command: conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn e = raises(errors.InternalError, o.execute, 'bad') assert conn.disconnect.called is True # Make sure destroy_context() was called assert context.__dict__.keys() == [] # Test with option 'name': conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn expected = dict(result=u'TEST') assert expected == o.execute('with_name', name=u'test', version=API_VERSION)
def test_execute(self): """ Test the `ipalib.backend.Executioner.execute` method. """ api, _home = create_test_api(in_server=True) class echo(Command): takes_args = ('arg1', 'arg2+') takes_options = ('option1?', 'option2?') def execute(self, *args, **options): assert type(args[1]) is tuple return dict(result=args + (options,)) api.add_plugin(echo) class good(Command): def execute(self, **options): raise errors.ValidationError( name='nurse', error=u'Not naughty!', ) api.add_plugin(good) class bad(Command): def execute(self, **options): raise ValueError('This is private.') api.add_plugin(bad) class with_name(Command): """ Test that a kwarg named 'name' can be used. """ takes_options = 'name' def execute(self, **options): return dict(result=options['name'].upper()) api.add_plugin(with_name) api.finalize() o = self.cls(api) o.finalize() # Test that CommandError is raised: conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn print(str(list(context.__dict__))) e = raises(errors.CommandError, o.execute, 'nope') assert e.name == 'nope' assert conn.disconnect.called is True # Make sure destroy_context() was called print(str(list(context.__dict__))) assert list(context.__dict__) == [] # Test with echo command: arg1 = unicode_str arg2 = (u'Hello', unicode_str, u'world!') args = (arg1,) + arg2 options = dict(option1=u'How are you?', option2=unicode_str, version=API_VERSION) conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn print(o.execute('echo', arg1, arg2, **options)) print(dict( result=(arg1, arg2, options) )) assert o.execute('echo', arg1, arg2, **options) == dict( result=(arg1, arg2, options) ) assert conn.disconnect.called is True # Make sure destroy_context() was called assert list(context.__dict__) == [] conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn assert o.execute('echo', *args, **options) == dict( result=(arg1, arg2, options) ) assert conn.disconnect.called is True # Make sure destroy_context() was called assert list(context.__dict__) == [] # Test with good command: conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn e = raises(errors.ValidationError, o.execute, 'good') assert e.name == 'nurse' assert e.error == u'Not naughty!' assert conn.disconnect.called is True # Make sure destroy_context() was called assert list(context.__dict__) == [] # Test with bad command: conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn e = raises(errors.InternalError, o.execute, 'bad') assert conn.disconnect.called is True # Make sure destroy_context() was called assert list(context.__dict__) == [] # Test with option 'name': conn = Connection('The connection.', Disconnect('someconn')) context.someconn = conn expected = dict(result=u'TEST') assert expected == o.execute('with_name', name=u'test', version=API_VERSION)