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_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(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_render_exception(self): """ Application.render_exception() displays formatted exception. """ application = Application() application.set_auto_exit(False) application.get_terminal_width = self.mock().MagicMock(return_value=120) tester = ApplicationTester(application) tester.run([("command", "foo")], {"decorated": False}) self.assertEqual(self.open_fixture("application_renderexception1.txt"), tester.get_display()) tester.run([("command", "foo")], {"decorated": False, "verbosity": Output.VERBOSITY_VERBOSE}) self.assertRegex(tester.get_display(), "Exception trace") tester.run([("command", "list"), ("--foo", True)], {"decorated": False}) self.assertEqual(self.open_fixture("application_renderexception2.txt"), tester.get_display()) application.add(Foo3Command()) tester = ApplicationTester(application) tester.run([("command", "foo3:bar")], {"decorated": False}) self.assertEqual(self.open_fixture("application_renderexception3.txt"), tester.get_display()) tester = ApplicationTester(application) tester.run([("command", "foo3:bar")], {"decorated": True}) self.assertEqual(self.open_fixture("application_renderexception3decorated.txt"), tester.get_display()) application = Application() application.set_auto_exit(False) application.get_terminal_width = self.mock().MagicMock(return_value=31) tester = ApplicationTester(application) tester.run([("command", "foo")], {"decorated": False}) self.assertEqual(self.open_fixture("application_renderexception4.txt"), tester.get_display())
def test_find_namespace(self): """ Application.find_namespace() should return a namespace """ application = Application() application.add(FooCommand()) self.assertEqual( 'foo', application.find_namespace('foo'), msg='.find_namespace() returns the given namespace if it exists' ) self.assertEqual( 'foo', application.find_namespace('f'), msg='.find_namespace() finds a namespace given an abbreviation' ) application.add(Foo2Command()) self.assertEqual( 'foo', application.find_namespace('foo'), msg='.find_namespace() returns the given namespace if it exists' )
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_has_get(self): """ Application.has() and Application.get() should determine and get commands """ application = Application() self.assertTrue(application.has('list'), msg='.has() returns true if a command is registered') self.assertFalse( application.has('afoobar'), msg='.has() returns false if a command is not registered') foo = FooCommand() application.add(foo) self.assertTrue(application.has('afoobar'), msg='.has() returns true if an alias is registered') self.assertEqual(foo, application.get('foo:bar'), msg='.get() returns a command by name') self.assertEqual(foo, application.get('afoobar'), msg='.get() returns a command by alias') application = Application() application.add(foo) # Simulate help application._want_helps = True self.assertTrue( isinstance(application.get('foo:bar'), HelpCommand), msg= '.get() returns the help command if --help is provided as the input' )
def test_set_run_custom_default_command(self): """ Application calls the default command. """ application = Application() application.set_auto_exit(False) command = FooCommand() application.add(command) application.set_default_command(command.get_name()) tester = ApplicationTester(application) tester.run([]) self.assertEqual( 'interact called\ncalled\n', tester.get_display() ) application = CustomDefaultCommandApplication() application.set_auto_exit(False) tester = ApplicationTester(application) tester.run([]) self.assertEqual( 'interact called\ncalled\n', tester.get_display() )
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_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_all(app: Application): commands = app.all() assert isinstance(commands["help"], Command) app.add(FooCommand()) assert len(app.all("foo")) == 1
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_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_ambiguous_namespace(app: Application): app.add(FooCommand()) app.add(Foo2Command()) with pytest.raises( NamespaceNotFoundException, match=r'There are no commands in the "f" namespace\.\n\nDid you mean one of these\?\n foo\n foo1', ): app.find_namespace("f")
def test_find_invalid_namespace(app: Application): app.add(FooCommand()) app.add(Foo2Command()) with pytest.raises( NamespaceNotFoundException, match=r'There are no commands in the "bar" namespace\.', ): app.find_namespace("bar")
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 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_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_unique_name_but_namespace_name(self): """ Application.find() should raise an error when command is missing """ application = Application() application.add(FooCommand()) application.add(Foo1Command()) application.add(Foo2Command()) self.assertRaisesRegexp(Exception, 'Command "foo1" is not defined', application.find, "foo1")
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 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_render_exception(self): """ Application.render_exception() displays formatted exception. """ application = Application() application.set_auto_exit(False) application.get_terminal_width = self.mock().MagicMock(return_value=120) tester = ApplicationTester(application) tester.run([('command', 'foo')], {'decorated': False}) self.assertEqual( self.open_fixture('application_renderexception1.txt'), tester.get_display() ) tester.run([('command', 'foo')], {'decorated': False, 'verbosity': Output.VERBOSITY_VERBOSE}) self.assertRegex( tester.get_display(), 'Exception trace' ) tester.run([('command', 'list'), ('--foo', True)], {'decorated': False}) self.assertEqual( self.open_fixture('application_renderexception2.txt'), tester.get_display() ) application.add(Foo3Command()) tester = ApplicationTester(application) tester.run([('command', 'foo3:bar')], {'decorated': False}) self.assertEqual( self.open_fixture('application_renderexception3.txt'), tester.get_display() ) tester = ApplicationTester(application) tester.run([('command', 'foo3:bar')], {'decorated': True}) self.assertEqual( self.open_fixture('application_renderexception3decorated.txt'), tester.get_display() ) application = Application() application.set_auto_exit(False) application.get_terminal_width = self.mock().MagicMock(return_value=31) tester = ApplicationTester(application) tester.run([('command', 'foo')], {'decorated': False}) self.assertEqual( self.open_fixture('application_renderexception4.txt'), tester.get_display() )
def test_find_unique_name_but_namespace_name(self): """ Application.find() should raise an error when command is missing """ application = Application() application.add(FooCommand()) application.add(Foo1Command()) application.add(Foo2Command()) self.assertRaisesRegexp(Exception, 'Command "foo1" is not defined', application.find, 'foo1')
def test_get_namespaces(self): """ Application.get_namespaces() should return registered namespaces """ application = Application() application.add(FooCommand()) application.add(Foo1Command()) self.assertEqual( ["foo"], application.get_namespaces(), msg=".get_namespaces() returns an array of unique used namespaces" )
def test_has_get(app: Application): assert app.has("list") assert not app.has("afoobar") foo = FooCommand() app.add(foo) assert app.has("foo bar") assert app.has("afoobar") assert app.get("foo bar") == foo assert app.get("afoobar") == foo
def test_find_alternative_exception_message_single(self): """ Application.find() raises an exception when an alternative has been found """ data = ["foo3:baR", "foO3:bar"] application = Application() application.add(Foo3Command()) for d in data: self.assertRaisesRegexp(Exception, "Did you mean this", application.find, d)
def test_as_text(self): """ Application.as_text() returns a text representation of the application. """ application = Application() application.add(FooCommand()) self.ensure_static_command_help(application) self.assertEqual(self.open_fixture("application_astext1.txt"), application.as_text()) self.assertEqual(self.open_fixture("application_astext2.txt"), application.as_text("foo"))
def test_find_alternative_exception_message_single(self): """ Application.find() raises an exception when an alternative has been found """ data = ['foo3:baR', 'foO3:bar'] application = Application() application.add(Foo3Command()) for d in data: self.assertRaisesRegexp(Exception, 'Did you mean this', application.find, d)
def test_get_namespaces(self): """ Application.get_namespaces() should return registered namespaces """ application = Application() application.add(FooCommand()) application.add(Foo1Command()) self.assertEqual( ['foo'], application.get_namespaces(), msg='.get_namespaces() returns an array of unique used namespaces')
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_add(app: Application): foo = FooCommand() app.add(foo) commands = app.all() assert [commands["foo bar"]] == [foo] foo1 = Foo1Command() app.add(foo1) commands = app.all() assert [commands["foo bar"], commands["foo bar1"]] == [foo, foo1]
def test_run(app: Application, argv): app.catch_exceptions(False) app.auto_exits(False) command = Foo1Command() app.add(command) sys.argv = ["console", "foo bar1"] app.run() assert isinstance(command.io, IO) assert isinstance(command.io.output, StreamOutput) assert isinstance(command.io.error_output, StreamOutput) assert command.io.output.stream == sys.stdout assert command.io.error_output.stream == sys.stderr
def test_all(self): """ Application.get_all() returns all comands of the application """ application = Application() commands = application.all() self.assertEqual( "HelpCommand", commands["help"].__class__.__name__, msg=".all() returns the registered commands" ) application.add(FooCommand()) self.assertEqual(1, len(application.all("foo")), msg=".all() take a namespace as first argument")
def test_set_run_custom_single_command(self): command = FooCommand() application = Application() application.set_auto_exit(False) application.add(command) application.set_default_command(command.get_name(), True) tester = ApplicationTester(application) tester.run([]) self.assertIn('called', tester.get_display()) tester.run([('--help', True)]) self.assertIn('The foo:bar command', tester.get_display())
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_find_alternative_commands_with_question(self): application = Application() application.set_auto_exit(False) os.environ['COLUMNS'] = '120' os.environ['SHELL_INTERACTIVE'] = '1' application.add(FooCommand()) application.add(Foo1Command()) application.add(Foo2Command()) tester = ApplicationTester(application) tester.set_inputs(['1\n']) tester.run([('command', 'f:b')], {'interactive': True}) self.assertEqual( self.open_fixture('application_unknown_command_question.txt'), tester.get_display(True))
def test_all(self): """ Application.get_all() returns all comands of the application """ application = Application() commands = application.all() self.assertEqual('HelpCommand', commands['help'].__class__.__name__, msg='.all() returns the registered commands') application.add(FooCommand()) self.assertEqual(1, len(application.all('foo')), msg='.all() take a namespace as first argument')
def test_find_with_ambiguous_abbreviations(self): """ Application.find() should raise an error when there is ambiguosity """ data = [ ["f", 'Command "f" is not defined\.'], ["a", 'Command "a" is ambiguous \(afoobar, afoobar1 and 1 more\)\.'], ["foo:b", 'Command "foo:b" is ambiguous \(foo1:bar, foo:bar and 1 more\)\.'], ] application = Application() application.add(FooCommand()) application.add(Foo1Command()) application.add(Foo2Command()) for d in data: self.assertRaisesRegexp(Exception, d[1], application.find, d[0])
def test_as_text(self): """ Application.as_text() returns a text representation of the application. """ application = Application() application.add(FooCommand()) self.ensure_static_command_help(application) self.assertEqual( self.open_fixture('application_astext1.txt'), application.as_text() ) self.assertEqual( self.open_fixture('application_astext2.txt'), application.as_text('foo') )
def test_render_exception(self): """ Application.render_exception() displays formatted exception. """ application = Application() application.set_auto_exit(False) os.environ['COLUMNS'] = '120' tester = ApplicationTester(application) tester.run([('command', 'foo')], {'decorated': False}) self.assertEqual(self.open_fixture('application_renderexception1.txt'), tester.get_display()) tester.run([('command', 'foo')], { 'decorated': False, 'verbosity': Output.VERBOSITY_VERBOSE }) self.assertRegex(tester.get_display(), 'Exception trace') tester.run([('command', 'list'), ('--foo', True)], {'decorated': False}) self.assertEqual(self.open_fixture('application_renderexception2.txt'), tester.get_display()) application.add(Foo3Command()) tester = ApplicationTester(application) tester.run([('command', 'foo3:bar')], {'decorated': False}) self.assertEqual(self.open_fixture('application_renderexception3.txt'), tester.get_display()) tester = ApplicationTester(application) tester.run([('command', 'foo3:bar')], {'decorated': True}) self.assertEqual( self.open_fixture('application_renderexception3decorated.txt'), tester.get_display()) application = Application() application.set_auto_exit(False) os.environ['COLUMNS'] = '31' tester = ApplicationTester(application) tester.run([('command', 'foo')], {'decorated': False}) self.assertEqual(self.open_fixture('application_renderexception4.txt'), tester.get_display())
def test_add(self): """ Application.add() and .addCommands() register commands """ application = Application() foo = FooCommand() application.add(foo) self.assertEqual(foo, application.all()["foo:bar"], msg=".add() registers a command") application = Application() foo, foo1 = FooCommand(), Foo1Command() application.add_commands([foo, foo1]) commands = application.all() self.assertEqual( [foo, foo1], [commands["foo:bar"], commands["foo:bar1"]], msg=".add_commands() registers a list of commands" )
def test_add_with_dictionary(self): """ Application.add() accepts a dictionary as argument. """ application = Application() foo = application.add(foo_commmand) self.assertTrue(isinstance(foo, Command)) self.assertEqual("foo:bar1", foo.get_name())
def test_find_namespace(self): """ Application.find_namespace() should return a namespace """ application = Application() application.add(FooCommand()) self.assertEqual( "foo", application.find_namespace("foo"), msg=".find_namespace() returns the given namespace if it exists" ) self.assertEqual( "foo", application.find_namespace("f"), msg=".find_namespace() finds a namespace given an abbreviation" ) application.add(Foo2Command()) self.assertEqual( "foo", application.find_namespace("foo"), msg=".find_namespace() returns the given namespace if it exists" )
def test_set_run_custom_default_command(self): """ Application calls the default command. """ application = Application() application.set_auto_exit(False) command = FooCommand() application.add(command) application.set_default_command(command.get_name()) tester = ApplicationTester(application) tester.run([]) self.assertEqual("interact called\ncalled\n", tester.get_display()) application = CustomDefaultCommandApplication() application.set_auto_exit(False) tester = ApplicationTester(application) tester.run([]) self.assertEqual("interact called\ncalled\n", tester.get_display())
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_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_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_has_get(self): """ Application.has() and Application.get() should determine and get commands """ application = Application() self.assertTrue(application.has("list"), msg=".has() returns true if a command is registered") self.assertFalse(application.has("afoobar"), msg=".has() returns false if a command is not registered") foo = FooCommand() application.add(foo) self.assertTrue(application.has("afoobar"), msg=".has() returns true if an alias is registered") self.assertEqual(foo, application.get("foo:bar"), msg=".get() returns a command by name") self.assertEqual(foo, application.get("afoobar"), msg=".get() returns a command by alias") application = Application() application.add(foo) # Simulate help application._want_helps = True self.assertTrue( isinstance(application.get("foo:bar"), HelpCommand), msg=".get() returns the help command if --help is provided as the input", )
def test_find_ambiguous_namespace(self): """ Application.find_namespace() should raise an error when namespace is ambiguous """ application = Application() application.add(BarBucCommand()) application.add(FooCommand()) application.add(Foo2Command()) self.assertRaisesRegexp( Exception, 'The namespace "f" is ambiguous \(foo, foo1\)\.', application.find_namespace, "f" )
def app(): app = Application() app.config.set_terminate_after_run(False) app.add(FooCommand()) return app
def test_run(self): application = Application() application.set_auto_exit(False) application.set_catch_exceptions(False) command = Foo1Command() application.add(command) sys.argv = ["cli.py", "foo:bar1"] application.run() self.assertEqual("ArgvInput", command.input.__class__.__name__) self.assertEqual("ConsoleOutput", command.output.__class__.__name__) application = Application() application.set_auto_exit(False) application.set_catch_exceptions(False) self.ensure_static_command_help(application) tester = ApplicationTester(application) tester.run([], {"decorated": False}) self.assertEqual(self.open_fixture("application_run1.txt"), tester.get_display()) tester.run([("--help", True)], {"decorated": False}) self.assertEqual(self.open_fixture("application_run2.txt"), tester.get_display()) tester.run([("-h", True)], {"decorated": False}) self.assertEqual(self.open_fixture("application_run2.txt"), tester.get_display()) tester.run([("command", "list"), ("--help", True)], {"decorated": False}) self.assertEqual(self.open_fixture("application_run3.txt"), tester.get_display()) tester.run([("command", "list"), ("-h", True)], {"decorated": False}) self.assertEqual(self.open_fixture("application_run3.txt"), tester.get_display()) tester.run([("--ansi", True)]) self.assertTrue(tester.get_output().is_decorated()) tester.run([("--no-ansi", True)]) self.assertFalse(tester.get_output().is_decorated()) tester.run([("--version", True)], {"decorated": False}) self.assertEqual(self.open_fixture("application_run4.txt"), tester.get_display()) tester.run([("-V", True)], {"decorated": False}) self.assertEqual(self.open_fixture("application_run4.txt"), tester.get_display()) tester.run([("command", "list"), ("--quiet", True)]) self.assertEqual("", tester.get_display()) tester.run([("command", "list"), ("-q", True)]) self.assertEqual("", tester.get_display()) tester.run([("command", "list"), ("--verbose", True)]) self.assertEqual(Output.VERBOSITY_VERBOSE, tester.get_output().get_verbosity()) tester.run([("command", "list"), ("-v", True)]) self.assertEqual(Output.VERBOSITY_VERBOSE, tester.get_output().get_verbosity()) application = Application() application.set_auto_exit(False) application.set_catch_exceptions(False) application.add(FooCommand()) tester = ApplicationTester(application) tester.run([("command", "foo:bar"), ("--no-interaction", True)], {"decorated": False}) self.assertEqual("called\n", tester.get_display()) tester.run([("command", "foo:bar"), ("-n", True)], {"decorated": False}) self.assertEqual("called\n", tester.get_display())