Kaydet (Commit) de2800f8 authored tarafından Serhiy Storchaka's avatar Serhiy Storchaka

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

üst 64f7c4e4
...@@ -13,7 +13,6 @@ if sys.argv[0].endswith("__main__.py"): ...@@ -13,7 +13,6 @@ if sys.argv[0].endswith("__main__.py"):
__unittest = True __unittest = True
from .main import main, TestProgram, USAGE_AS_MAIN from .main import main, TestProgram
TestProgram.USAGE = USAGE_AS_MAIN
main(module=None) main(module=None)
"""Unittest main program""" """Unittest main program"""
import sys import sys
import optparse import argparse
import os import os
from . import loader, runner from . import loader, runner
...@@ -9,52 +9,19 @@ from .signals import installHandler ...@@ -9,52 +9,19 @@ from .signals import installHandler
__unittest = True __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: 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: 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
""" """
...@@ -82,10 +49,11 @@ class TestProgram(object): ...@@ -82,10 +49,11 @@ class TestProgram(object):
"""A command-line program that runs a set of tests; this is primarily """A command-line program that runs a set of tests; this is primarily
for making test modules conveniently executable. for making test modules conveniently executable.
""" """
USAGE = USAGE_FROM_MODULE
# defaults for testing # defaults for testing
module=None
verbosity = 1
failfast = catchbreak = buffer = progName = warnings = None failfast = catchbreak = buffer = progName = warnings = None
_discovery_parser = None
def __init__(self, module='__main__', defaultTest=None, argv=None, def __init__(self, module='__main__', defaultTest=None, argv=None,
testRunner=None, testLoader=loader.defaultTestLoader, testRunner=None, testLoader=loader.defaultTestLoader,
...@@ -127,44 +95,44 @@ class TestProgram(object): ...@@ -127,44 +95,44 @@ class TestProgram(object):
def usageExit(self, msg=None): def usageExit(self, msg=None):
if msg: if msg:
print(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) 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): 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:
if len(argv) > 1 and argv[1].lower() == 'discover':
self._do_discovery(argv[2:]) self._do_discovery(argv[2:])
return return
self._main_parser.parse_args(argv[1:], self)
parser = self._getOptParser() if not self.tests:
options, args = parser.parse_args(argv[1:])
self._setAttributesFromOptions(options)
if len(args) == 0 and self.module is None:
# this allows "python -m unittest -v" to still work for # this allows "python -m unittest -v" to still work for
# test discovery. This means -c / -b / -v / -f options will # test discovery.
# be handled twice, which is harmless but not ideal. self._do_discovery([])
self._do_discovery(argv[1:])
return return
else:
self._main_parser.parse_args(argv[1:], self)
if len(args) == 0 and self.defaultTest is None: if self.tests:
# createTests will load tests from self.module self.testNames = _convert_names(self.tests)
self.testNames = None
elif len(args) > 0:
self.testNames = _convert_names(args)
if __name__ == '__main__': if __name__ == '__main__':
# to support python -m unittest ... # to support python -m unittest ...
self.module = None self.module = None
else: elif self.defaultTest is None:
if isinstance(self.defaultTest, str): # createTests will load tests from self.module
self.testNames = None
elif isinstance(self.defaultTest, str):
self.testNames = (self.defaultTest,) self.testNames = (self.defaultTest,)
else: else:
self.testNames = list(self.defaultTest) self.testNames = list(self.defaultTest)
...@@ -177,76 +145,84 @@ class TestProgram(object): ...@@ -177,76 +145,84 @@ class TestProgram(object):
self.test = self.testLoader.loadTestsFromNames(self.testNames, self.test = self.testLoader.loadTestsFromNames(self.testNames,
self.module) 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')
parser.add_option('-q', '--quiet', dest='quiet', default=False,
help='Quiet output', action='store_true')
if self.failfast != False: def _getParentArgParser(self):
parser.add_option('-f', '--failfast', dest='failfast', default=False, parser = argparse.ArgumentParser(add_help=False)
help='Stop on first fail or error',
action='store_true') parser.add_argument('-v', '--verbose', dest='verbosity',
if self.catchbreak != False: action='store_const', const=2,
parser.add_option('-c', '--catch', dest='catchbreak', default=False, help='Verbose output')
help='Catch ctrl-C and display results so far', parser.add_argument('-q', '--quiet', dest='verbosity',
action='store_true') action='store_const', const=0,
if self.buffer != False: help='Quiet output')
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):
# only set options from the parsing here
# if they weren't set explicitly in the constructor
if self.failfast is None: if self.failfast is None:
self.failfast = options.failfast 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: if self.catchbreak is None:
self.catchbreak = options.catchbreak 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: if self.buffer is None:
self.buffer = options.buffer parser.add_argument('-b', '--buffer', dest='buffer',
action='store_true',
help='Buffer stdout and stderr during tests')
self.buffer = False
if options.verbose: return parser
self.verbosity = 2
elif options.quiet:
self.verbosity = 0
def _addDiscoveryOptions(self, parser): def _getMainArgParser(self, parent):
parser.add_option('-s', '--start-directory', dest='start', default='.', parser = argparse.ArgumentParser(parents=[parent])
help="Directory to start discovery ('.' default)") parser.prog = self.progName
parser.add_option('-p', '--pattern', dest='pattern', default='test*.py', parser.print_help = self._print_help
help="Pattern to match tests ('test*.py' default)")
parser.add_option('-t', '--top-level-directory', dest='top', default=None,
help='Top level directory of project (defaults to start directory)')
def _do_discovery(self, argv, Loader=None): parser.add_argument('tests', nargs='*',
if Loader is None: help='a list of any number of test modules, '
Loader = lambda: self.testLoader 'classes and test methods.')
# handle command line args for test discovery return parser
self.progName = '%s discover' % self.progName
parser = self._getOptParser()
self._addDiscoveryOptions(parser)
options, args = parser.parse_args(argv) def _getDiscoveryArgParser(self, parent):
if len(args) > 3: parser = argparse.ArgumentParser(parents=[parent])
self.usageExit() parser.prog = '%s discover' % self.progName
parser.epilog = ('For test discovery all test modules must be '
'importable from the top level directory of the '
'project.')
for name, value in zip(('start', 'pattern', 'top'), args): parser.add_argument('-s', '--start-directory', dest='start',
setattr(options, name, value) 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)
self._setAttributesFromOptions(options) return parser
start_dir = options.start def _do_discovery(self, argv, Loader=None):
pattern = options.pattern self.start = '.'
top_level_dir = options.top 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)
loader = Loader() loader = self.testLoader if Loader is None else Loader()
self.test = loader.discover(start_dir, pattern, top_level_dir) self.test = loader.discover(self.start, self.pattern, self.top)
def runTests(self): def runTests(self):
if self.catchbreak: if self.catchbreak:
......
import os import os
import re import re
import sys import sys
from test import support
import unittest import unittest
class TestableTestProgram(unittest.TestProgram): class TestableTestProgram(unittest.TestProgram):
module = '__main__' module = None
exit = True exit = True
defaultTest = failfast = catchbreak = buffer = None defaultTest = failfast = catchbreak = buffer = None
verbosity = 1 verbosity = 1
...@@ -232,58 +233,54 @@ class TestDiscovery(unittest.TestCase): ...@@ -232,58 +233,54 @@ class TestDiscovery(unittest.TestCase):
program = TestableTestProgram() program = TestableTestProgram()
args = [] args = []
def do_discovery(argv): program._do_discovery = args.append
args.extend(argv)
program._do_discovery = do_discovery
program.parseArgs(['something', 'discover']) program.parseArgs(['something', 'discover'])
self.assertEqual(args, []) self.assertEqual(args, [[]])
args[:] = []
program.parseArgs(['something', 'discover', 'foo', 'bar']) 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): def test_command_line_handling_discover_by_default(self):
program = TestableTestProgram() 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']) 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): def test_command_line_handling_discover_by_default_with_options(self):
program = TestableTestProgram() 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): def test_command_line_handling_do_discovery_too_many_arguments(self):
class Stop(Exception):
pass
def usageExit():
raise Stop
program = TestableTestProgram() program = TestableTestProgram()
program.usageExit = usageExit
program.testLoader = None program.testLoader = None
with self.assertRaises(Stop): with support.captured_stderr() as stderr, \
self.assertRaises(SystemExit) as cm:
# too many args # too many args
program._do_discovery(['one', 'two', 'three', 'four']) 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): def test_command_line_handling_do_discovery_uses_default_loader(self):
program = object.__new__(unittest.TestProgram) program = object.__new__(unittest.TestProgram)
program._initArgParsers()
class Loader(object): class Loader(object):
args = [] args = []
......
...@@ -2,6 +2,7 @@ import io ...@@ -2,6 +2,7 @@ import io
import os import os
import sys import sys
from test import support
import unittest import unittest
...@@ -186,20 +187,38 @@ class TestCommandLineArgs(unittest.TestCase): ...@@ -186,20 +187,38 @@ class TestCommandLineArgs(unittest.TestCase):
if attr == 'catch' and not hasInstallHandler: if attr == 'catch' and not hasInstallHandler:
continue 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] short_opt = '-%s' % arg[0]
long_opt = '--%s' % arg long_opt = '--%s' % arg
for opt in short_opt, long_opt: for opt in short_opt, long_opt:
setattr(program, attr, None) setattr(program, attr, None)
program.parseArgs([None, opt]) 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,))
setattr(program, attr, True)
with support.captured_stderr() as stderr, \
self.assertRaises(SystemExit) as cm:
program.parseArgs([None, opt]) program.parseArgs([None, opt])
self.assertEqual(getattr(program, attr), not_none) self.assertEqual(cm.exception.args, (2,))
def testWarning(self): def testWarning(self):
"""Test the warnings argument""" """Test the warnings argument"""
......
...@@ -51,6 +51,8 @@ Core and Builtins ...@@ -51,6 +51,8 @@ Core and Builtins
Library Library
------- -------
- Issue #17974: Switch unittest from using getopt to using argparse.
- Issue #11798: TestSuite now drops references to own tests after execution. - Issue #11798: TestSuite now drops references to own tests after execution.
- Issue #16611: http.cookie now correctly parses the 'secure' and 'httponly' - Issue #16611: http.cookie now correctly parses the 'secure' and 'httponly'
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment