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))