def test_find(self):
"""
Application.find() should return a command
"""
application = Application()
application.add(FooCommand())
self.assertTrue(
isinstance(application.find('foo:bar'), FooCommand),
msg='.find() returns a command if its name exists'
)
self.assertTrue(
isinstance(application.find('h'), HelpCommand),
msg='.find() returns a command if its name exists'
)
self.assertTrue(
isinstance(application.find('f:bar'), FooCommand),
msg='.find() returns a command if the abbreviation for the namespace exists'
)
self.assertTrue(
isinstance(application.find('f:b'), FooCommand),
msg='.find() returns a command if the abbreviation for the namespace and the command name exist'
)
self.assertTrue(
isinstance(application.find('a'), FooCommand),
msg='.find() returns a command if the abbreviation exists for an alias'
)
def test_find(self):
"""
Application.find() should return a command
"""
application = Application()
application.add(FooCommand())
self.assertTrue(
isinstance(application.find("foo:bar"), FooCommand), msg=".find() returns a command if its name exists"
)
self.assertTrue(
isinstance(application.find("h"), HelpCommand), msg=".find() returns a command if its name exists"
)
self.assertTrue(
isinstance(application.find("f:bar"), FooCommand),
msg=".find() returns a command if the abbreviation for the namespace exists",
)
self.assertTrue(
isinstance(application.find("f:b"), FooCommand),
msg=".find() returns a command if the abbreviation for the namespace and the command name exist",
)
self.assertTrue(
isinstance(application.find("a"), FooCommand),
msg=".find() returns a command if the abbreviation exists for an alias",
)
def test_find_alternative_commands(self):
application = Application()
application.add(FooCommand())
application.add(Foo1Command())
application.add(Foo2Command())
command_name = 'Unknown command'
try:
application.find(command_name)
self.fail('.find() raises an Exception if command does not exist')
except Exception as e:
self.assertEqual('Command "%s" is not defined.' % command_name,
str(e))
command_name = 'bar1'
try:
application.find(command_name)
self.fail('.find() raises an Exception if command does not exist')
except Exception as e:
self.assertRegexpMatches(
str(e), 'Command "%s" is not defined.' % command_name)
self.assertRegexpMatches(
str(e),
'afoobar1',
)
self.assertRegexpMatches(
str(e),
'foo:bar1',
)
self.assertNotRegex(str(e), 'foo:bar$')
def test_find_alternative_namespace(self):
application = Application()
application.add(FooCommand())
application.add(Foo1Command())
application.add(Foo2Command())
application.add(Foo3Command())
try:
application.find("Unknown-namespace:Unknown-command")
self.fail(".find() raises an Exception if namespace does not exist")
except Exception as e:
self.assertRegex(str(e), 'There are no commands defined in the "Unknown-namespace" namespace.')
try:
application.find("foo2:command")
self.fail(".find() raises an tException if namespace does not exist")
except Exception as e:
self.assertRegex(str(e), 'There are no commands defined in the "foo2" namespace.')
self.assertRegex(
str(e), "foo", msg='.find() raises an tException if namespace does not exist, with alternative "foo"'
)
self.assertRegex(
str(e), "foo1", msg='.find() raises an tException if namespace does not exist, with alternative "foo1"'
)
self.assertRegex(
str(e), "foo3", msg='.find() raises an Exception if namespace does not exist, with alternative "foo2"'
)
def test_find_ambiguous_command(app: Application):
app.add(FooCommand())
with pytest.raises(
CommandNotFoundException,
match=r'The command "foo b" does not exist\.\n\nDid you mean this\?\n foo bar',
):
app.find("foo b")
def test_find_unique_name_but_namespace_name(app: Application):
app.add(FooCommand())
app.add(Foo1Command())
app.add(Foo2Command())
with pytest.raises(
CommandNotFoundException,
match=r'The command "foo1" does not exist\.',
):
app.find("foo1")
def test_find_ambiguous_command_hidden(app: Application):
foo = FooCommand()
foo.hidden = True
app.add(foo)
with pytest.raises(
CommandNotFoundException,
match=r'The command "foo b" does not exist\.$',
):
app.find("foo b")
def test_find_command_equal_namesapce(self):
"""
Application.find() returns a command if it has a namespace with the same name
"""
application = Application()
application.add(Foo3Command())
application.add(Foo4Command())
self.assertTrue(
isinstance(application.find('foo3:bar'), Foo3Command),
msg='.find() returns the good command even if a namespace has same name'
)
self.assertTrue(
isinstance(application.find('foo3:bar:toh'), Foo4Command),
msg='.find() returns a command even if its namespace equals another command name'
)
def test_find_command_equal_namesapce(self):
"""
Application.find() returns a command if it has a namespace with the same name
"""
application = Application()
application.add(Foo3Command())
application.add(Foo4Command())
self.assertTrue(
isinstance(application.find("foo3:bar"), Foo3Command),
msg=".find() returns the good command even if a namespace has same name",
)
self.assertTrue(
isinstance(application.find("foo3:bar:toh"), Foo4Command),
msg=".find() returns a command even if its namespace equals another command name",
)
def test_execute_hello_world_command_no_params():
application = Application()
application.add(HelloWorldCommand())
command = application.find('greet')
command_tester = CommandTester(command)
command_tester.execute()
assert "Hello" == command_tester.io.fetch_output().rstrip()
def test_find_command_with_missing_namespace(self):
"""
Application.find() returns a command with missing namespace
"""
application = Application()
application.add(Foo4Command())
self.assertTrue(isinstance(application.find("f::t"), Foo4Command))
def test_find_command_with_missing_namespace(self):
"""
Application.find() returns a command with missing namespace
"""
application = Application()
application.add(Foo4Command())
self.assertTrue(isinstance(application.find('f::t'), Foo4Command))
def test_execute_namespace_command():
app = Application()
app.add(FooBarCommand())
tester = CommandTester(app.find("foo bar"))
assert 0 == tester.execute()
assert 0 == tester.status_code
assert "foo bar called\n" == tester.io.fetch_output()
def test_find_command_with_ambiguous_namespace_but_unique_name(self):
"""
Application.find() returns a command with ambiguous namespace
"""
application = Application()
application.add(FooCommand())
application.add(FoobarCommand())
self.assertTrue(isinstance(application.find("f:f"), FoobarCommand))
def test_find_command_with_ambiguous_namespace_but_unique_name(self):
"""
Application.find() returns a command with ambiguous namespace
"""
application = Application()
application.add(FooCommand())
application.add(FoobarCommand())
self.assertTrue(isinstance(application.find('f:f'), FoobarCommand))
def test_find_alternative_namespace(self):
application = Application()
application.add(FooCommand())
application.add(Foo1Command())
application.add(Foo2Command())
application.add(Foo3Command())
try:
application.find('Unknown-namespace:Unknown-command')
self.fail(
'.find() raises an Exception if namespace does not exist')
except Exception as e:
self.assertRegex(
str(e),
'There are no commands defined in the "Unknown-namespace" namespace.'
)
try:
application.find('foo2:command')
self.fail(
'.find() raises an tException if namespace does not exist')
except Exception as e:
self.assertRegex(
str(e),
'There are no commands defined in the "foo2" namespace.')
self.assertRegex(
str(e),
'foo',
msg=
'.find() raises an tException if namespace does not exist, with alternative "foo"'
)
self.assertRegex(
str(e),
'foo1',
msg=
'.find() raises an tException if namespace does not exist, with alternative "foo1"'
)
self.assertRegex(
str(e),
'foo3',
msg=
'.find() raises an Exception if namespace does not exist, with alternative "foo2"'
)
def find_alternative_commands_with_an_alias(self):
foo_command = FooCommand()
foo_command.set_aliases(['foo2'])
application = Application()
application.add(foo_command)
result = application.find('foo')
self.assertEqual(foo_command, result)
def find_alternative_commands_with_an_alias(self):
foo_command = FooCommand()
foo_command.set_aliases(["foo2"])
application = Application()
application.add(foo_command)
result = application.find("foo")
self.assertEqual(foo_command, result)
def test_execute():
config = {
"scripts": {
"e": ["python", "-c", "print(1)"],
}
}
application = Application()
application.add(CustomCommand(config))
command = application.find("do")
command_tester = CommandTester(command)
command_tester.execute("e")
def test_find_alternative_exception_message_multiple(self):
"""
Application.find() raises an exception when alternatives have been found
"""
application = Application()
application.add(FooCommand())
application.add(Foo1Command())
application.add(Foo2Command())
try:
application.find("foo:baR")
self.fail(".find() raises an Exception if command does not exist, with alternatives")
except Exception as e:
self.assertRegexpMatches(str(e), "Did you mean one of these")
self.assertRegexpMatches(str(e), "foo1:bar")
self.assertRegexpMatches(str(e), "foo:bar")
try:
application.find("foo2:baR")
self.fail(".find() raises an Exception if command does not exist, with alternatives")
except Exception as e:
self.assertRegexpMatches(str(e), "Did you mean one of these")
self.assertRegexpMatches(str(e), "foo1")
application.add(Foo3Command())
application.add(Foo4Command())
try:
application.find("foo3:")
self.fail(".find() raises an Exception if command does not exist, with alternatives")
except Exception as e:
self.assertRegexpMatches(str(e), "foo3:bar")
self.assertRegexpMatches(str(e), "foo3:bar:toh")
def test_find_alternative_commands(self):
application = Application()
application.add(FooCommand())
application.add(Foo1Command())
application.add(Foo2Command())
command_name = "Unknown command"
try:
application.find(command_name)
self.fail(".find() raises an Exception if command does not exist")
except Exception as e:
self.assertEqual('Command "%s" is not defined.' % command_name, str(e))
command_name = "bar1"
try:
application.find(command_name)
self.fail(".find() raises an Exception if command does not exist")
except Exception as e:
self.assertRegexpMatches(str(e), 'Command "%s" is not defined.' % command_name)
self.assertRegexpMatches(str(e), "afoobar1")
self.assertRegexpMatches(str(e), "foo:bar1")
self.assertNotRegex(str(e), "foo:bar$")
def test_find_alternative_exception_message_multiple(self):
"""
Application.find() raises an exception when alternatives have been found
"""
application = Application()
application.add(FooCommand())
application.add(Foo1Command())
application.add(Foo2Command())
try:
application.find('foo:baR')
self.fail('.find() raises an Exception if command does not exist, with alternatives')
except Exception as e:
self.assertRegexpMatches(
str(e),
'Did you mean one of these'
)
self.assertRegexpMatches(
str(e),
'foo1:bar'
)
self.assertRegexpMatches(
str(e),
'foo:bar'
)
try:
application.find('foo2:baR')
self.fail('.find() raises an Exception if command does not exist, with alternatives')
except Exception as e:
self.assertRegexpMatches(
str(e),
'Did you mean one of these'
)
self.assertRegexpMatches(
str(e),
'foo1'
)
application.add(Foo3Command())
application.add(Foo4Command())
try:
application.find('foo3:')
self.fail('.find() raises an Exception if command does not exist, with alternatives')
except Exception as e:
self.assertRegexpMatches(
str(e),
'foo3:bar'
)
self.assertRegexpMatches(
str(e),
'foo3:bar:toh'
)
def test_find(app: Application):
app.add(FooCommand())
assert isinstance(app.find("foo bar"), FooCommand)
assert isinstance(app.find("afoobar"), FooCommand)
