def call_sub(self, name, args="", silent=False):
"""call() equivalent which supports subcommands"""
names = name.split(" ")
command = self.application.get_command(names[0])
for name in names[1:]:
command = command.get_sub_command(name)
args = StringArgs(args)
return command.run(args, silent and NullIO() or self.io)
def test_parse_fail_if_too_many_arguments_with_missing_command_name(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_argument(Argument("argument1"))
fmt = builder.format
with pytest.raises(CannotParseArgsException):
parser.parse(StringArgs("server foo bar"), fmt)
def test_parse_fails_if_missing_required_argument(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_argument(Argument("argument1", Argument.REQUIRED))
builder.add_argument(Argument("argument2", Argument.REQUIRED))
fmt = builder.format
with pytest.raises(CannotParseArgsException):
parser.parse(StringArgs("server add foo"), fmt)
def call(self, name, args=None): # type: (str, Optional[str]) -> int
"""
Call another command.
"""
if args is None:
args = ""
args = StringArgs(args)
command = self.application.get_command(name)
return command.run(args, self.io)
def test_parse_option_stops_parsing_if_invalid_option_and_lenient(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
fmt = builder.format
args = parser.parse(StringArgs("server add --foo bar"), fmt, True)
assert {} == args.arguments(False)
assert {} == args.options(False)
def test_option_fails_if_invalid_option(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
fmt = builder.format
with pytest.raises(NoSuchOptionException) as e:
parser.parse(StringArgs("server add --foo"), fmt)
assert 'The "--foo" option does not exist.' == str(e.value)
def test_parse_multi_valued_arguments_ignores_missing_command_names(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_argument(Argument("multi", Argument.MULTI_VALUED))
fmt = builder.format
args = parser.parse(StringArgs("server one two three"), fmt)
assert {"multi": ["one", "two", "three"]} == args.arguments(False)
assert {} == args.options(False)
def test_parse_does_not_fail_if_too_many_arguments_and_lenient(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_argument(Argument("argument1"))
fmt = builder.format
args = parser.parse(StringArgs("server add foo bar"), fmt, True)
assert {"argument1": "foo"} == args.arguments(False)
assert {} == args.options(False)
def test_parse_short_option_without_value(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_option(Option("option", "o"))
fmt = builder.format
args = parser.parse(StringArgs("server add -o"), fmt)
assert {} == args.arguments(False)
assert {"option": True} == args.options(False)
def test_parse_short_option_with_value2(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_option(Option("option", "o", flags=Option.OPTIONAL_VALUE))
fmt = builder.format
args = parser.parse(StringArgs("server add -ofoo"), fmt)
assert {} == args.arguments(False)
assert {"option": "foo"} == args.options(False)
def test_parse_ignores_missing_command_names(parser):
builder = ArgsFormatBuilder()
server = CommandName("server", ["server-alias"])
add = CommandName("add", ["add-alias"])
builder.add_command_names(server, add)
fmt = builder.format
args = parser.parse(StringArgs(""), fmt)
assert [server, add] == args.command_names
assert {} == args.arguments(False)
assert {} == args.options(False)
def test_parse_option_up_to_invalid_option_if_lenient(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_argument(Argument("argument"))
fmt = builder.format
args = parser.parse(StringArgs("server add bar --foo"), fmt, True)
assert {"argument": "bar"} == args.arguments(False)
assert {} == args.options(False)
def test_parse_command_names(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
fmt = builder.format
args = parser.parse(StringArgs("server add"), fmt)
assert [server, add] == args.command_names
assert {} == args.arguments(False)
assert {} == args.options(False)
def test_parse_short_option_fails_if_missing_value(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_option(Option("option", "o", flags=Option.REQUIRED_VALUE))
fmt = builder.format
with pytest.raises(CannotParseArgsException) as e:
parser.parse(StringArgs("server add -o"), fmt)
assert 'The "--option" option requires a value.' == str(e.value)
def test_parse_does_not_fail_if_missing_required_argument_and_lenient(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_argument(Argument("argument1", Argument.REQUIRED))
builder.add_argument(Argument("argument2", Argument.REQUIRED))
fmt = builder.format
args = parser.parse(StringArgs("server add foo"), fmt, True)
assert {"argument1": "foo"} == args.arguments(False)
assert {} == args.options(False)
def test_parse_arguments_ignores_missing_command_name_aliases(parser):
builder = ArgsFormatBuilder()
server = CommandName("server", ["server-alias"])
add = CommandName("add", ["add-alias"])
builder.add_command_names(server, add)
builder.add_argument(Argument("argument1"))
builder.add_argument(Argument("argument2"))
fmt = builder.format
args = parser.parse(StringArgs("server-alias foo bar"), fmt)
assert {"argument1": "foo", "argument2": "bar"} == args.arguments(False)
assert {} == args.options(False)
def test_parse_arguments(parser):
builder = ArgsFormatBuilder()
server = CommandName("server")
add = CommandName("add")
builder.add_command_names(server, add)
builder.add_argument(Argument("argument1"))
builder.add_argument(Argument("argument2"))
fmt = builder.format
args = parser.parse(StringArgs("server add foo bar"), fmt)
assert {"argument1": "foo", "argument2": "bar"} == args.arguments(False)
assert {} == args.options(False)
def test_run_with_keyboard_interrupt(
config): # type: (ApplicationConfig) -> None
def callback(_, io):
raise KeyboardInterrupt()
config.create_command("interrupted").set_handler(CallbackHandler(callback))
app = ConsoleApplication(config)
output = BufferedOutputStream()
error_output = BufferedOutputStream()
assert 1 == app.run(StringArgs("interrupted"), StringInputStream(""),
output, error_output)
assert "" == output.fetch()
assert "" == error_output.fetch()
def handle(self): # type: () -> int
poetry_python_version = ".".join(str(s) for s in sys.version_info[:3])
self.line("")
self.line("<b>Poetry</b>")
self.line(
"\n".join(
[
"<info>Version</info>: <comment>{}</>".format(self.poetry.VERSION),
"<info>Python</info>: <comment>{}</>".format(
poetry_python_version
),
]
)
)
args = StringArgs("")
command = self.application.get_command("env").get_sub_command("info")
return command.run(args, self._io)
def test_run_command(config, arg_string, config_callback):
def callback(_, io):
io.write(io.read_line())
io.error(io.read_line())
return 123
config_callback(config, callback)
args = StringArgs(arg_string)
input = StringInputStream("line1\nline2")
output = BufferedOutputStream()
error_output = BufferedOutputStream()
app = ConsoleApplication(config)
assert 123 == app.run(args, input, output, error_output)
assert "line1\n" == output.fetch()
assert "line2" == error_output.fetch()
def test_create(string, tokens):
args = StringArgs(string)
assert tokens == args.tokens
