def test_equivalence(self, param_definition):
# We need two separate copies of _cmd here so just invoke cwd() directly
func1 = parameter(cmd(), **param_definition)
func2 = parameters([param_definition], cmd())
assert_parameter_equal(func1._command.parameters[0],
func2._command.parameters[0])
def test_is_kwarg(self, param_definition):
@parameter(is_kwarg=True, **param_definition)
def cmd(_, **kwargs):
return kwargs
param = cmd._command.get_parameter_by_key("foo")
assert_parameter_equal(param, Parameter(**param_definition))
def test_basic(self, basic_param, param):
@parameter(**basic_param)
def cmd(foo):
return foo
assert hasattr(cmd, "parameters")
assert len(cmd.parameters) == 1
assert_parameter_equal(cmd.parameters[0], param)
def test_parameter_equivalence(self, basic_param):
@parameters([basic_param])
def func1(foo):
return foo
@parameter(**basic_param)
def func2(foo):
return foo
assert_parameter_equal(func1.parameters[0], func2.parameters[0])
def test_decorator_equivalence(self, param_definition):
@parameter(**param_definition)
def func1(_, foo):
return foo
@parameters([param_definition])
def func2(_, foo):
return foo
assert_parameter_equal(func1._command.parameters[0],
func2._command.parameters[0])
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_equivalence(self, param_definition):
# We need two separate copies of _cmd here, but pytest doesn't like you calling
# fixtures directly. So just re-define the function here:
def cmd(_, foo):
"""Docstring"""
return foo
func1 = parameter(cmd, **param_definition)
func2 = parameters([param_definition], cmd)
assert_parameter_equal(
func1._command.parameters[0], func2._command.parameters[0]
)
def test_parameter_then_command(self, cmd, param_definition):
@command(command_type="INFO", output_type="JSON")
@parameter(**param_definition)
def _cmd(_, foo):
return foo
assert hasattr(_cmd, "_command")
assert _cmd._command.name == "_cmd"
assert _cmd._command.command_type == "INFO"
assert _cmd._command.output_type == "JSON"
assert len(_cmd._command.parameters) == 1
assert_parameter_equal(_cmd._command.parameters[0],
Parameter(**param_definition))
def test_model(self, my_model, param_1, param_2, default, expected):
@parameter(key="foo", model=my_model, default=default)
def cmd(_, foo):
return foo
model_param = cmd._command.get_parameter_by_key("foo")
assert model_param.key == "foo"
assert model_param.type == "Dictionary"
assert len(model_param.parameters) == 2
assert model_param.default == expected
assert_parameter_equal(model_param.parameters[0], param_1)
assert_parameter_equal(model_param.parameters[1], param_2)
def test_parameter_then_command(self, basic_param):
class Unused(object):
@command(command_type="INFO", output_type="JSON")
@parameter(**basic_param)
def cmd(self, foo):
return foo
cmds = _parse_client(Unused)
c = cmds[0]
assert c.name == "cmd"
assert c.command_type == "INFO"
assert c.output_type == "JSON"
assert len(c.parameters) == 1
assert_parameter_equal(c.parameters[0], Parameter(**basic_param))
def test_plugin_param(self, cmd, parameter_dict):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
plugin_param(cmd, **parameter_dict)
assert issubclass(w[0].category, DeprecationWarning)
assert "plugin_param" in str(w[0].message)
assert hasattr(cmd, "parameters")
assert len(cmd.parameters) == 1
assert_parameter_equal(
_initialize_parameter(cmd.parameters[0]),
_initialize_parameter(**parameter_dict),
)
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_reinitialize(self, parameter_dict):
"""Parameter objects can be initialized twice, so make sure that works"""
p1 = _initialize_parameter(**parameter_dict)
p2 = _initialize_parameter(p1)
assert_parameter_equal(p1, p2)
def test_values(self, cmd, param_definition):
wrapped = parameter(cmd, **param_definition)
param = wrapped._command.get_parameter_by_key("foo")
assert_parameter_equal(param, Parameter(**param_definition))