Issue #17974: Switch unittest from using getopt to using argparse.

Lib/unittest/__main__.py

@@ -13,7 +13,6 @@ if sys.argv[0].endswith("__main__.py"):
 
 __unittest = True
 
-from .main import main, TestProgram, USAGE_AS_MAIN
+from .main import main, TestProgram
-TestProgram.USAGE = USAGE_AS_MAIN
 
 main(module=None)

Lib/unittest/main.py

@@ -1,7 +1,7 @@
 """Unittest main program"""
 
 import sys
-import optparse
+import argparse
 import os
 
 from . import loader, runner
@@ -9,53 +9,20 @@ from .signals import installHandler
 
 __unittest = True
 
-FAILFAST     = "  -f, --failfast   Stop on first failure\n"
+MAIN_EXAMPLES = """\
-CATCHBREAK   = "  -c, --catch      Catch control-C and display results\n"
-BUFFEROUTPUT = "  -b, --buffer     Buffer stdout and stderr during test runs\n"
-
-USAGE_AS_MAIN = """\
-Usage: %(progName)s [options] [tests]
-
-Options:
-  -h, --help       Show this message
-  -v, --verbose    Verbose output
-  -q, --quiet      Minimal output
-%(failfast)s%(catchbreak)s%(buffer)s
 Examples:
-  %(progName)s test_module               - run tests from test_module
+  %(prog)s test_module               - run tests from test_module
-  %(progName)s module.TestClass          - run tests from module.TestClass
+  %(prog)s module.TestClass          - run tests from module.TestClass
-  %(progName)s module.Class.test_method  - run specified test method
+  %(prog)s module.Class.test_method  - run specified test method
-
-[tests] can be a list of any number of test modules, classes and test
-methods.
-
-Alternative Usage: %(progName)s discover [options]
-
-Options:
-  -v, --verbose    Verbose output
-%(failfast)s%(catchbreak)s%(buffer)s  -s directory     Directory to start discovery ('.' default)
-  -p pattern       Pattern to match test files ('test*.py' default)
-  -t directory     Top level directory of project (default to
-                   start directory)
-
-For test discovery all test modules must be importable from the top
-level directory of the project.
 """
 
-USAGE_FROM_MODULE = """\
+MODULE_EXAMPLES = """\
-Usage: %(progName)s [options] [test] [...]
-
-Options:
-  -h, --help       Show this message
-  -v, --verbose    Verbose output
-  -q, --quiet      Minimal output
-%(failfast)s%(catchbreak)s%(buffer)s
 Examples:
-  %(progName)s                               - run default set of tests
+  %(prog)s                           - run default set of tests
-  %(progName)s MyTestSuite                   - run suite 'MyTestSuite'
+  %(prog)s MyTestSuite               - run suite 'MyTestSuite'
-  %(progName)s MyTestCase.testSomething      - run MyTestCase.testSomething
+  %(prog)s MyTestCase.testSomething  - run MyTestCase.testSomething
-  %(progName)s MyTestCase                    - run all 'test*' test methods
+  %(prog)s MyTestCase                - run all 'test*' test methods
-                                               in MyTestCase
+                                       in MyTestCase
 """
 
 def _convert_name(name):
@@ -82,10 +49,11 @@ class TestProgram(object):
     """A command-line program that runs a set of tests; this is primarily
        for making test modules conveniently executable.
     """
-    USAGE = USAGE_FROM_MODULE
-
     # defaults for testing
+    module=None
+    verbosity = 1
     failfast = catchbreak = buffer = progName = warnings = None
+    _discovery_parser = None
 
     def __init__(self, module='__main__', defaultTest=None, argv=None,
                     testRunner=None, testLoader=loader.defaultTestLoader,
@@ -127,47 +95,47 @@ class TestProgram(object):
     def usageExit(self, msg=None):
         if msg:
             print(msg)
-        usage = {'progName': self.progName, 'catchbreak': '', 'failfast': '',
+        if self._discovery_parser is None:
-                 'buffer': ''}
+            self._initArgParsers()
-        if self.failfast != False:
+        self._print_help()
-            usage['failfast'] = FAILFAST
-        if self.catchbreak != False:
-            usage['catchbreak'] = CATCHBREAK
-        if self.buffer != False:
-            usage['buffer'] = BUFFEROUTPUT
-        print(self.USAGE % usage)
         sys.exit(2)
 
+    def _print_help(self, *args, **kwargs):
+        if self.module is None:
+            print(self._main_parser.format_help())
+            print(MAIN_EXAMPLES % {'prog': self.progName})
+            self._discovery_parser.print_help()
+        else:
+            print(self._main_parser.format_help())
+            print(MODULE_EXAMPLES % {'prog': self.progName})
+
     def parseArgs(self, argv):
-        if ((len(argv) > 1 and argv[1].lower() == 'discover') or
+        self._initArgParsers()
-            (len(argv) == 1 and self.module is None)):
+        if self.module is None:
-            self._do_discovery(argv[2:])
+            if len(argv) > 1 and argv[1].lower() == 'discover':
-            return
+                self._do_discovery(argv[2:])
+                return
+            self._main_parser.parse_args(argv[1:], self)
+            if not self.tests:
+                # this allows "python -m unittest -v" to still work for
+                # test discovery.
+                self._do_discovery([])
+                return
+        else:
+            self._main_parser.parse_args(argv[1:], self)
 
-        parser = self._getOptParser()
+        if self.tests:
-        options, args = parser.parse_args(argv[1:])
+            self.testNames = _convert_names(self.tests)
-        self._setAttributesFromOptions(options)
-
-        if len(args) == 0 and self.module is None:
-            # this allows "python -m unittest -v" to still work for
-            # test discovery. This means -c / -b / -v / -f options will
-            # be handled twice, which is harmless but not ideal.
-            self._do_discovery(argv[1:])
-            return
-
-        if len(args) == 0 and self.defaultTest is None:
-            # createTests will load tests from self.module
-            self.testNames = None
-        elif len(args) > 0:
-            self.testNames = _convert_names(args)
             if __name__ == '__main__':
                 # to support python -m unittest ...
                 self.module = None
+        elif self.defaultTest is None:
+            # createTests will load tests from self.module
+            self.testNames = None
+        elif isinstance(self.defaultTest, str):
+            self.testNames = (self.defaultTest,)
         else:
-            if isinstance(self.defaultTest, str):
+            self.testNames = list(self.defaultTest)
-                self.testNames = (self.defaultTest,)
-            else:
-                self.testNames = list(self.defaultTest)
         self.createTests()
 
     def createTests(self):
@@ -177,76 +145,84 @@ class TestProgram(object):
             self.test = self.testLoader.loadTestsFromNames(self.testNames,
                                                            self.module)
 
-    def _getOptParser(self):
+    def _initArgParsers(self):
-        import optparse
+        parent_parser = self._getParentArgParser()
-        parser = optparse.OptionParser()
+        self._main_parser = self._getMainArgParser(parent_parser)
-        parser.prog = self.progName
+        self._discovery_parser = self._getDiscoveryArgParser(parent_parser)
-        parser.add_option('-v', '--verbose', dest='verbose', default=False,
+
-                          help='Verbose output', action='store_true')
+    def _getParentArgParser(self):
-        parser.add_option('-q', '--quiet', dest='quiet', default=False,
+        parser = argparse.ArgumentParser(add_help=False)
-                          help='Quiet output', action='store_true')
+
+        parser.add_argument('-v', '--verbose', dest='verbosity',
+                            action='store_const', const=2,
+                            help='Verbose output')
+        parser.add_argument('-q', '--quiet', dest='verbosity',
+                            action='store_const', const=0,
+                            help='Quiet output')
+
+        if self.failfast is None:
+            parser.add_argument('-f', '--failfast', dest='failfast',
+                                action='store_true',
+                                help='Stop on first fail or error')
+            self.failfast = False
+        if self.catchbreak is None:
+            parser.add_argument('-c', '--catch', dest='catchbreak',
+                                action='store_true',
+                                help='Catch ctrl-C and display results so far')
+            self.catchbreak = False
+        if self.buffer is None:
+            parser.add_argument('-b', '--buffer', dest='buffer',
+                                action='store_true',
+                                help='Buffer stdout and stderr during tests')
+            self.buffer = False
 
-        if self.failfast != False:
-            parser.add_option('-f', '--failfast', dest='failfast', default=False,
-                              help='Stop on first fail or error',
-                              action='store_true')
-        if self.catchbreak != False:
-            parser.add_option('-c', '--catch', dest='catchbreak', default=False,
-                              help='Catch ctrl-C and display results so far',
-                              action='store_true')
-        if self.buffer != False:
-            parser.add_option('-b', '--buffer', dest='buffer', default=False,
-                              help='Buffer stdout and stderr during tests',
-                              action='store_true')
         return parser
 
-    def _setAttributesFromOptions(self, options):
+    def _getMainArgParser(self, parent):
-        # only set options from the parsing here
+        parser = argparse.ArgumentParser(parents=[parent])
-        # if they weren't set explicitly in the constructor
+        parser.prog = self.progName
-        if self.failfast is None:
+        parser.print_help = self._print_help
-            self.failfast = options.failfast
-        if self.catchbreak is None:
-            self.catchbreak = options.catchbreak
-        if self.buffer is None:
-            self.buffer = options.buffer
 
-        if options.verbose:
+        parser.add_argument('tests', nargs='*',
-            self.verbosity = 2
+                            help='a list of any number of test modules, '
-        elif options.quiet:
+                            'classes and test methods.')
-            self.verbosity = 0
 
-    def _addDiscoveryOptions(self, parser):
+        return parser
-        parser.add_option('-s', '--start-directory', dest='start', default='.',
+
-                          help="Directory to start discovery ('.' default)")
+    def _getDiscoveryArgParser(self, parent):
-        parser.add_option('-p', '--pattern', dest='pattern', default='test*.py',
+        parser = argparse.ArgumentParser(parents=[parent])
-                          help="Pattern to match tests ('test*.py' default)")
+        parser.prog = '%s discover' % self.progName
-        parser.add_option('-t', '--top-level-directory', dest='top', default=None,
+        parser.epilog = ('For test discovery all test modules must be '
-                          help='Top level directory of project (defaults to start directory)')
+                         'importable from the top level directory of the '
+                         'project.')
+
+        parser.add_argument('-s', '--start-directory', dest='start',
+                            help="Directory to start discovery ('.' default)")
+        parser.add_argument('-p', '--pattern', dest='pattern',
+                            help="Pattern to match tests ('test*.py' default)")
+        parser.add_argument('-t', '--top-level-directory', dest='top',
+                            help='Top level directory of project (defaults to '
+                                 'start directory)')
+        for arg in ('start', 'pattern', 'top'):
+            parser.add_argument(arg, nargs='?',
+                                default=argparse.SUPPRESS,
+                                help=argparse.SUPPRESS)
+
+        return parser
 
     def _do_discovery(self, argv, Loader=None):
-        if Loader is None:
+        self.start = '.'
-            Loader = lambda: self.testLoader
+        self.pattern = 'test*.py'
+        self.top = None
+        if argv is not None:
+            # handle command line args for test discovery
+            if self._discovery_parser is None:
+                # for testing
+                self._initArgParsers()
+            self._discovery_parser.parse_args(argv, self)
 
-        # handle command line args for test discovery
+        loader = self.testLoader if Loader is None else Loader()
-        self.progName = '%s discover' % self.progName
+        self.test = loader.discover(self.start, self.pattern, self.top)
-        parser = self._getOptParser()
-        self._addDiscoveryOptions(parser)
-
-        options, args = parser.parse_args(argv)
-        if len(args) > 3:
-            self.usageExit()
-
-        for name, value in zip(('start', 'pattern', 'top'), args):
-            setattr(options, name, value)
-
-        self._setAttributesFromOptions(options)
-
-        start_dir = options.start
-        pattern = options.pattern
-        top_level_dir = options.top
-
-        loader = Loader()
-        self.test = loader.discover(start_dir, pattern, top_level_dir)
 
     def runTests(self):
         if self.catchbreak:

Lib/unittest/test/test_discovery.py

@@ -1,12 +1,13 @@
 import os
 import re
 import sys
+from test import support
 
 import unittest
 
 
 class TestableTestProgram(unittest.TestProgram):
-    module = '__main__'
+    module = None
     exit = True
     defaultTest = failfast = catchbreak = buffer = None
     verbosity = 1
@@ -232,58 +233,54 @@ class TestDiscovery(unittest.TestCase):
         program = TestableTestProgram()
 
         args = []
-        def do_discovery(argv):
+        program._do_discovery = args.append
-            args.extend(argv)
-        program._do_discovery = do_discovery
         program.parseArgs(['something', 'discover'])
-        self.assertEqual(args, [])
+        self.assertEqual(args, [[]])
 
+        args[:] = []
         program.parseArgs(['something', 'discover', 'foo', 'bar'])
-        self.assertEqual(args, ['foo', 'bar'])
+        self.assertEqual(args, [['foo', 'bar']])
 
     def test_command_line_handling_discover_by_default(self):
         program = TestableTestProgram()
-        program.module = None
 
-        self.called = False
+        args = []
-        def do_discovery(argv):
+        program._do_discovery = args.append
-            self.called = True
-            self.assertEqual(argv, [])
-        program._do_discovery = do_discovery
         program.parseArgs(['something'])
-        self.assertTrue(self.called)
+        self.assertEqual(args, [[]])
+        self.assertEqual(program.verbosity, 1)
+        self.assertIs(program.buffer, False)
+        self.assertIs(program.catchbreak, False)
+        self.assertIs(program.failfast, False)
 
     def test_command_line_handling_discover_by_default_with_options(self):
         program = TestableTestProgram()
-        program.module = None
 
-        args = ['something', '-v', '-b', '-v', '-c', '-f']
+        args = []
-        self.called = False
+        program._do_discovery = args.append
-        def do_discovery(argv):
+        program.parseArgs(['something', '-v', '-b', '-v', '-c', '-f'])
-            self.called = True
+        self.assertEqual(args, [[]])
-            self.assertEqual(argv, args[1:])
+        self.assertEqual(program.verbosity, 2)
-        program._do_discovery = do_discovery
+        self.assertIs(program.buffer, True)
-        program.parseArgs(args)
+        self.assertIs(program.catchbreak, True)
-        self.assertTrue(self.called)
+        self.assertIs(program.failfast, True)
 
 
     def test_command_line_handling_do_discovery_too_many_arguments(self):
-        class Stop(Exception):
-            pass
-        def usageExit():
-            raise Stop
-
         program = TestableTestProgram()
-        program.usageExit = usageExit
         program.testLoader = None
 
-        with self.assertRaises(Stop):
+        with support.captured_stderr() as stderr, \
+             self.assertRaises(SystemExit) as cm:
             # too many args
             program._do_discovery(['one', 'two', 'three', 'four'])
+        self.assertEqual(cm.exception.args, (2,))
+        self.assertIn('usage:', stderr.getvalue())
 
 
     def test_command_line_handling_do_discovery_uses_default_loader(self):
         program = object.__new__(unittest.TestProgram)
+        program._initArgParsers()
 
         class Loader(object):
             args = []

Lib/unittest/test/test_program.py

@@ -2,6 +2,7 @@ import io
 
 import os
 import sys
+from test import support
 import unittest
 
 
@@ -186,20 +187,38 @@ class TestCommandLineArgs(unittest.TestCase):
             if attr == 'catch' and not hasInstallHandler:
                 continue
 
+            setattr(program, attr, None)
+            program.parseArgs([None])
+            self.assertIs(getattr(program, attr), False)
+
+            false = []
+            setattr(program, attr, false)
+            program.parseArgs([None])
+            self.assertIs(getattr(program, attr), false)
+
+            true = [42]
+            setattr(program, attr, true)
+            program.parseArgs([None])
+            self.assertIs(getattr(program, attr), true)
+
             short_opt = '-%s' % arg[0]
             long_opt = '--%s' % arg
             for opt in short_opt, long_opt:
                 setattr(program, attr, None)
-
                 program.parseArgs([None, opt])
-                self.assertTrue(getattr(program, attr))
+                self.assertIs(getattr(program, attr), True)
 
-            for opt in short_opt, long_opt:
+                setattr(program, attr, False)
-                not_none = object()
+                with support.captured_stderr() as stderr, \
-                setattr(program, attr, not_none)
+                    self.assertRaises(SystemExit) as cm:
+                    program.parseArgs([None, opt])
+                self.assertEqual(cm.exception.args, (2,))
 
-                program.parseArgs([None, opt])
+                setattr(program, attr, True)
-                self.assertEqual(getattr(program, attr), not_none)
+                with support.captured_stderr() as stderr, \
+                    self.assertRaises(SystemExit) as cm:
+                    program.parseArgs([None, opt])
+                self.assertEqual(cm.exception.args, (2,))
 
     def testWarning(self):
         """Test the warnings argument"""

Misc/NEWS

@@ -51,6 +51,8 @@ Core and Builtins
 Library
 -------
 
+- Issue #17974: Switch unittest from using getopt to using argparse.
+
 - Issue #11798: TestSuite now drops references to own tests after execution.
 
 - Issue #16611: http.cookie now correctly parses the 'secure' and 'httponly'