Python Application.find方法代碼示例

# 需要導入模塊: from cleo.application import Application [as 別名]
# 或者: from cleo.application.Application import find [as 別名]
    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"'
            )

# 需要導入模塊: from cleo.application import Application [as 別名]
# 或者: from cleo.application.Application import find [as 別名]
    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",
        )

# 需要導入模塊: from cleo.application import Application [as 別名]
# 或者: from cleo.application.Application import find [as 別名]
    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",
        )

# 需要導入模塊: from cleo.application import Application [as 別名]
# 或者: from cleo.application.Application import find [as 別名]
    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))

# 需要導入模塊: from cleo.application import Application [as 別名]
# 或者: from cleo.application.Application import find [as 別名]
    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))

# 需要導入模塊: from cleo.application import Application [as 別名]
# 或者: from cleo.application.Application import find [as 別名]
    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)

# 需要導入模塊: from cleo.application import Application [as 別名]
# 或者: from cleo.application.Application import find [as 別名]
    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")

# 需要導入模塊: from cleo.application import Application [as 別名]
# 或者: from cleo.application.Application import find [as 別名]
    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$")