def test_command_equivalence(self, basic_param):
@parameters([basic_param])
def func1(foo):
return foo
@command(parameters=[basic_param])
def func2(foo):
return foo
cmd1 = _parse_method(func1)
cmd2 = _parse_method(func2)
assert_parameter_equal(cmd1.parameters[0], cmd2.parameters[0])
def test_kwargs(self):
@command
def cmd(foo, **_):
return foo
bg_cmd = _parse_method(cmd)
assert len(bg_cmd.parameters) == 1
assert bg_cmd.parameters[0].key == "foo"
def test_parameter_equivalence(self, basic_param, param):
@parameter(**basic_param)
def expected_method(foo):
return foo
@command(parameters=[basic_param])
def dict_method(foo):
return foo
@command(parameters=[param])
def param_method(foo):
return foo
expected = _parse_method(expected_method)
dict_cmd = _parse_method(dict_method)
param_cmd = _parse_method(param_method)
assert_parameter_equal(dict_cmd.parameters[0], expected.parameters[0])
assert_parameter_equal(param_cmd.parameters[0], expected.parameters[0])
def test_self(self):
class Container(object):
@command
def cmd(self, foo):
return foo
bg_cmd = _parse_method(Container.cmd)
assert len(bg_cmd.parameters) == 1
assert bg_cmd.parameters[0].key == "foo"
def test_order(self):
@parameter(key="a")
@parameter(key="b")
@parameter(key="c")
def cmd(a, b, c, d, e):
return a + b + c + d + e
bg_cmd = _parse_method(cmd)
assert [p.key for p in bg_cmd.parameters] == ["a", "b", "c", "d", "e"]
def test_no_parameter_decorator(self):
@command
def cmd(foo="hi"):
return foo
bg_cmd = _parse_method(cmd)
assert len(bg_cmd.parameters) == 1
assert bg_cmd.parameters[0].key == "foo"
assert bg_cmd.parameters[0].default == "hi"
assert bg_cmd.parameters[0].optional is True
def test_decorator_consistent(self):
"""Decorator values are what would have been determined"""
@command
@parameter(key="foo", default="hi", optional=True)
def cmd(foo="hi"):
return foo
bg_cmd = _parse_method(cmd)
assert len(bg_cmd.parameters) == 1
assert bg_cmd.parameters[0].key == "foo"
assert bg_cmd.parameters[0].default == "hi"
assert bg_cmd.parameters[0].optional is True
def test_decorator_inconsistent(self):
"""Decorator values take precedence"""
@command
@parameter(key="foo", default="hi", optional=False)
def cmd(foo=None):
return foo
bg_cmd = _parse_method(cmd)
assert len(bg_cmd.parameters) == 1
assert bg_cmd.parameters[0].key == "foo"
assert bg_cmd.parameters[0].default == "hi"
assert bg_cmd.parameters[0].optional is False
def test_decorator_inconsistent(self):
"""Decorator values kind of take precedence
THIS ONE IS DIFFERENT!!!
Specifically, the default value of this will actually be the signature
default "hi" instead of the decorator default None.
This is because there's no way to distinguish this:
@parameter(key="foo", default=None, optional=False)
from this:
@parameter(key="foo", optional=False)
And in the latter case the "correct" behavior is to use the default
value from the signature.
This test is the cornerest of the cases, and if anyone actually wrote a
command this way they should expect it to be a toss-up which default is
actually used. Therefore I'm decreeing this to be The Correct Behavior.
"""
@command
@parameter(key="foo", default=None, optional=False)
def cmd(foo="hi"):
return foo
bg_cmd = _parse_method(cmd)
assert len(bg_cmd.parameters) == 1
assert bg_cmd.parameters[0].key == "foo"
assert bg_cmd.parameters[0].optional is False
# AGAIN, THIS ONE IS DIFFERENT!!!!
assert bg_cmd.parameters[0].default == "hi"
def test_no_key(self, cmd):
with pytest.raises(PluginParamError):
_parse_method(parameter(cmd))
def test_cmd_parameter(self, cmd):
cmd = command(cmd)
cmd = parameter(cmd, key="foo")
assert _parse_method(cmd) is not None
def test_parameters(self, cmd):
with warnings.catch_warnings(record=True):
partial = parameters([{"key": "foo"}])
cmd = partial(cmd)
assert _parse_method(cmd) is not None
def test_multiple_parameter(self, cmd_kwargs):
cmd_kwargs = parameter(cmd_kwargs, key="foo", is_kwarg=True)
cmd_kwargs = parameter(cmd_kwargs, key="bar", is_kwarg=True)
assert _parse_method(cmd_kwargs) is not None
def test_one_parameter(self, cmd):
cmd = parameter(cmd, key="foo")
assert _parse_method(cmd) is not None
def test_only_command(self, cmd):
cmd = command(cmd)
assert _parse_method(cmd) is not None
def test_non_command(self, cmd):
assert _parse_method(cmd) is None