1# Author: Steven J. Bethard <steven.bethard@gmail.com>. 2 3import codecs 4import inspect 5import os 6import shutil 7import stat 8import sys 9import textwrap 10import tempfile 11import unittest 12import argparse 13 14from StringIO import StringIO 15 16class StdIOBuffer(StringIO): 17 pass 18 19from test import test_support 20 21class TestCase(unittest.TestCase): 22 23 def assertEqual(self, obj1, obj2): 24 if obj1 != obj2: 25 print('') 26 print(repr(obj1)) 27 print(repr(obj2)) 28 print(obj1) 29 print(obj2) 30 super(TestCase, self).assertEqual(obj1, obj2) 31 32 def setUp(self): 33 # The tests assume that line wrapping occurs at 80 columns, but this 34 # behaviour can be overridden by setting the COLUMNS environment 35 # variable. To ensure that this assumption is true, unset COLUMNS. 36 env = test_support.EnvironmentVarGuard() 37 env.unset("COLUMNS") 38 self.addCleanup(env.__exit__) 39 40 41class TempDirMixin(object): 42 43 def setUp(self): 44 self.temp_dir = tempfile.mkdtemp() 45 self.old_dir = os.getcwd() 46 os.chdir(self.temp_dir) 47 48 def tearDown(self): 49 os.chdir(self.old_dir) 50 shutil.rmtree(self.temp_dir, True) 51 52 def create_readonly_file(self, filename): 53 file_path = os.path.join(self.temp_dir, filename) 54 with open(file_path, 'w') as file: 55 file.write(filename) 56 os.chmod(file_path, stat.S_IREAD) 57 58class Sig(object): 59 60 def __init__(self, *args, **kwargs): 61 self.args = args 62 self.kwargs = kwargs 63 64 65class NS(object): 66 67 def __init__(self, **kwargs): 68 self.__dict__.update(kwargs) 69 70 def __repr__(self): 71 sorted_items = sorted(self.__dict__.items()) 72 kwarg_str = ', '.join(['%s=%r' % tup for tup in sorted_items]) 73 return '%s(%s)' % (type(self).__name__, kwarg_str) 74 75 __hash__ = None 76 77 def __eq__(self, other): 78 return vars(self) == vars(other) 79 80 def __ne__(self, other): 81 return not (self == other) 82 83 84class ArgumentParserError(Exception): 85 86 def __init__(self, message, stdout=None, stderr=None, error_code=None): 87 Exception.__init__(self, message, stdout, stderr) 88 self.message = message 89 self.stdout = stdout 90 self.stderr = stderr 91 self.error_code = error_code 92 93 94def stderr_to_parser_error(parse_args, *args, **kwargs): 95 # if this is being called recursively and stderr or stdout is already being 96 # redirected, simply call the function and let the enclosing function 97 # catch the exception 98 if isinstance(sys.stderr, StdIOBuffer) or isinstance(sys.stdout, StdIOBuffer): 99 return parse_args(*args, **kwargs) 100 101 # if this is not being called recursively, redirect stderr and 102 # use it as the ArgumentParserError message 103 old_stdout = sys.stdout 104 old_stderr = sys.stderr 105 sys.stdout = StdIOBuffer() 106 sys.stderr = StdIOBuffer() 107 try: 108 try: 109 result = parse_args(*args, **kwargs) 110 for key in list(vars(result)): 111 if getattr(result, key) is sys.stdout: 112 setattr(result, key, old_stdout) 113 if getattr(result, key) is sys.stderr: 114 setattr(result, key, old_stderr) 115 return result 116 except SystemExit: 117 code = sys.exc_info()[1].code 118 stdout = sys.stdout.getvalue() 119 stderr = sys.stderr.getvalue() 120 raise ArgumentParserError("SystemExit", stdout, stderr, code) 121 finally: 122 sys.stdout = old_stdout 123 sys.stderr = old_stderr 124 125 126class ErrorRaisingArgumentParser(argparse.ArgumentParser): 127 128 def parse_args(self, *args, **kwargs): 129 parse_args = super(ErrorRaisingArgumentParser, self).parse_args 130 return stderr_to_parser_error(parse_args, *args, **kwargs) 131 132 def exit(self, *args, **kwargs): 133 exit = super(ErrorRaisingArgumentParser, self).exit 134 return stderr_to_parser_error(exit, *args, **kwargs) 135 136 def error(self, *args, **kwargs): 137 error = super(ErrorRaisingArgumentParser, self).error 138 return stderr_to_parser_error(error, *args, **kwargs) 139 140 141class ParserTesterMetaclass(type): 142 """Adds parser tests using the class attributes. 143 144 Classes of this type should specify the following attributes: 145 146 argument_signatures -- a list of Sig objects which specify 147 the signatures of Argument objects to be created 148 failures -- a list of args lists that should cause the parser 149 to fail 150 successes -- a list of (initial_args, options, remaining_args) tuples 151 where initial_args specifies the string args to be parsed, 152 options is a dict that should match the vars() of the options 153 parsed out of initial_args, and remaining_args should be any 154 remaining unparsed arguments 155 """ 156 157 def __init__(cls, name, bases, bodydict): 158 if name == 'ParserTestCase': 159 return 160 161 # default parser signature is empty 162 if not hasattr(cls, 'parser_signature'): 163 cls.parser_signature = Sig() 164 if not hasattr(cls, 'parser_class'): 165 cls.parser_class = ErrorRaisingArgumentParser 166 167 # --------------------------------------- 168 # functions for adding optional arguments 169 # --------------------------------------- 170 def no_groups(parser, argument_signatures): 171 """Add all arguments directly to the parser""" 172 for sig in argument_signatures: 173 parser.add_argument(*sig.args, **sig.kwargs) 174 175 def one_group(parser, argument_signatures): 176 """Add all arguments under a single group in the parser""" 177 group = parser.add_argument_group('foo') 178 for sig in argument_signatures: 179 group.add_argument(*sig.args, **sig.kwargs) 180 181 def many_groups(parser, argument_signatures): 182 """Add each argument in its own group to the parser""" 183 for i, sig in enumerate(argument_signatures): 184 group = parser.add_argument_group('foo:%i' % i) 185 group.add_argument(*sig.args, **sig.kwargs) 186 187 # -------------------------- 188 # functions for parsing args 189 # -------------------------- 190 def listargs(parser, args): 191 """Parse the args by passing in a list""" 192 return parser.parse_args(args) 193 194 def sysargs(parser, args): 195 """Parse the args by defaulting to sys.argv""" 196 old_sys_argv = sys.argv 197 sys.argv = [old_sys_argv[0]] + args 198 try: 199 return parser.parse_args() 200 finally: 201 sys.argv = old_sys_argv 202 203 # class that holds the combination of one optional argument 204 # addition method and one arg parsing method 205 class AddTests(object): 206 207 def __init__(self, tester_cls, add_arguments, parse_args): 208 self._add_arguments = add_arguments 209 self._parse_args = parse_args 210 211 add_arguments_name = self._add_arguments.__name__ 212 parse_args_name = self._parse_args.__name__ 213 for test_func in [self.test_failures, self.test_successes]: 214 func_name = test_func.__name__ 215 names = func_name, add_arguments_name, parse_args_name 216 test_name = '_'.join(names) 217 218 def wrapper(self, test_func=test_func): 219 test_func(self) 220 try: 221 wrapper.__name__ = test_name 222 except TypeError: 223 pass 224 setattr(tester_cls, test_name, wrapper) 225 226 def _get_parser(self, tester): 227 args = tester.parser_signature.args 228 kwargs = tester.parser_signature.kwargs 229 parser = tester.parser_class(*args, **kwargs) 230 self._add_arguments(parser, tester.argument_signatures) 231 return parser 232 233 def test_failures(self, tester): 234 parser = self._get_parser(tester) 235 for args_str in tester.failures: 236 args = args_str.split() 237 raises = tester.assertRaises 238 raises(ArgumentParserError, parser.parse_args, args) 239 240 def test_successes(self, tester): 241 parser = self._get_parser(tester) 242 for args, expected_ns in tester.successes: 243 if isinstance(args, str): 244 args = args.split() 245 result_ns = self._parse_args(parser, args) 246 tester.assertEqual(expected_ns, result_ns) 247 248 # add tests for each combination of an optionals adding method 249 # and an arg parsing method 250 for add_arguments in [no_groups, one_group, many_groups]: 251 for parse_args in [listargs, sysargs]: 252 AddTests(cls, add_arguments, parse_args) 253 254bases = TestCase, 255ParserTestCase = ParserTesterMetaclass('ParserTestCase', bases, {}) 256 257# =============== 258# Optionals tests 259# =============== 260 261class TestOptionalsSingleDash(ParserTestCase): 262 """Test an Optional with a single-dash option string""" 263 264 argument_signatures = [Sig('-x')] 265 failures = ['-x', 'a', '--foo', '-x --foo', '-x -y'] 266 successes = [ 267 ('', NS(x=None)), 268 ('-x a', NS(x='a')), 269 ('-xa', NS(x='a')), 270 ('-x -1', NS(x='-1')), 271 ('-x-1', NS(x='-1')), 272 ] 273 274 275class TestOptionalsSingleDashCombined(ParserTestCase): 276 """Test an Optional with a single-dash option string""" 277 278 argument_signatures = [ 279 Sig('-x', action='store_true'), 280 Sig('-yyy', action='store_const', const=42), 281 Sig('-z'), 282 ] 283 failures = ['a', '--foo', '-xa', '-x --foo', '-x -z', '-z -x', 284 '-yx', '-yz a', '-yyyx', '-yyyza', '-xyza'] 285 successes = [ 286 ('', NS(x=False, yyy=None, z=None)), 287 ('-x', NS(x=True, yyy=None, z=None)), 288 ('-za', NS(x=False, yyy=None, z='a')), 289 ('-z a', NS(x=False, yyy=None, z='a')), 290 ('-xza', NS(x=True, yyy=None, z='a')), 291 ('-xz a', NS(x=True, yyy=None, z='a')), 292 ('-x -za', NS(x=True, yyy=None, z='a')), 293 ('-x -z a', NS(x=True, yyy=None, z='a')), 294 ('-y', NS(x=False, yyy=42, z=None)), 295 ('-yyy', NS(x=False, yyy=42, z=None)), 296 ('-x -yyy -za', NS(x=True, yyy=42, z='a')), 297 ('-x -yyy -z a', NS(x=True, yyy=42, z='a')), 298 ] 299 300 301class TestOptionalsSingleDashLong(ParserTestCase): 302 """Test an Optional with a multi-character single-dash option string""" 303 304 argument_signatures = [Sig('-foo')] 305 failures = ['-foo', 'a', '--foo', '-foo --foo', '-foo -y', '-fooa'] 306 successes = [ 307 ('', NS(foo=None)), 308 ('-foo a', NS(foo='a')), 309 ('-foo -1', NS(foo='-1')), 310 ('-fo a', NS(foo='a')), 311 ('-f a', NS(foo='a')), 312 ] 313 314 315class TestOptionalsSingleDashSubsetAmbiguous(ParserTestCase): 316 """Test Optionals where option strings are subsets of each other""" 317 318 argument_signatures = [Sig('-f'), Sig('-foobar'), Sig('-foorab')] 319 failures = ['-f', '-foo', '-fo', '-foo b', '-foob', '-fooba', '-foora'] 320 successes = [ 321 ('', NS(f=None, foobar=None, foorab=None)), 322 ('-f a', NS(f='a', foobar=None, foorab=None)), 323 ('-fa', NS(f='a', foobar=None, foorab=None)), 324 ('-foa', NS(f='oa', foobar=None, foorab=None)), 325 ('-fooa', NS(f='ooa', foobar=None, foorab=None)), 326 ('-foobar a', NS(f=None, foobar='a', foorab=None)), 327 ('-foorab a', NS(f=None, foobar=None, foorab='a')), 328 ] 329 330 331class TestOptionalsSingleDashAmbiguous(ParserTestCase): 332 """Test Optionals that partially match but are not subsets""" 333 334 argument_signatures = [Sig('-foobar'), Sig('-foorab')] 335 failures = ['-f', '-f a', '-fa', '-foa', '-foo', '-fo', '-foo b'] 336 successes = [ 337 ('', NS(foobar=None, foorab=None)), 338 ('-foob a', NS(foobar='a', foorab=None)), 339 ('-foor a', NS(foobar=None, foorab='a')), 340 ('-fooba a', NS(foobar='a', foorab=None)), 341 ('-foora a', NS(foobar=None, foorab='a')), 342 ('-foobar a', NS(foobar='a', foorab=None)), 343 ('-foorab a', NS(foobar=None, foorab='a')), 344 ] 345 346 347class TestOptionalsNumeric(ParserTestCase): 348 """Test an Optional with a short opt string""" 349 350 argument_signatures = [Sig('-1', dest='one')] 351 failures = ['-1', 'a', '-1 --foo', '-1 -y', '-1 -1', '-1 -2'] 352 successes = [ 353 ('', NS(one=None)), 354 ('-1 a', NS(one='a')), 355 ('-1a', NS(one='a')), 356 ('-1-2', NS(one='-2')), 357 ] 358 359 360class TestOptionalsDoubleDash(ParserTestCase): 361 """Test an Optional with a double-dash option string""" 362 363 argument_signatures = [Sig('--foo')] 364 failures = ['--foo', '-f', '-f a', 'a', '--foo -x', '--foo --bar'] 365 successes = [ 366 ('', NS(foo=None)), 367 ('--foo a', NS(foo='a')), 368 ('--foo=a', NS(foo='a')), 369 ('--foo -2.5', NS(foo='-2.5')), 370 ('--foo=-2.5', NS(foo='-2.5')), 371 ] 372 373 374class TestOptionalsDoubleDashPartialMatch(ParserTestCase): 375 """Tests partial matching with a double-dash option string""" 376 377 argument_signatures = [ 378 Sig('--badger', action='store_true'), 379 Sig('--bat'), 380 ] 381 failures = ['--bar', '--b', '--ba', '--b=2', '--ba=4', '--badge 5'] 382 successes = [ 383 ('', NS(badger=False, bat=None)), 384 ('--bat X', NS(badger=False, bat='X')), 385 ('--bad', NS(badger=True, bat=None)), 386 ('--badg', NS(badger=True, bat=None)), 387 ('--badge', NS(badger=True, bat=None)), 388 ('--badger', NS(badger=True, bat=None)), 389 ] 390 391 392class TestOptionalsDoubleDashPrefixMatch(ParserTestCase): 393 """Tests when one double-dash option string is a prefix of another""" 394 395 argument_signatures = [ 396 Sig('--badger', action='store_true'), 397 Sig('--ba'), 398 ] 399 failures = ['--bar', '--b', '--ba', '--b=2', '--badge 5'] 400 successes = [ 401 ('', NS(badger=False, ba=None)), 402 ('--ba X', NS(badger=False, ba='X')), 403 ('--ba=X', NS(badger=False, ba='X')), 404 ('--bad', NS(badger=True, ba=None)), 405 ('--badg', NS(badger=True, ba=None)), 406 ('--badge', NS(badger=True, ba=None)), 407 ('--badger', NS(badger=True, ba=None)), 408 ] 409 410 411class TestOptionalsSingleDoubleDash(ParserTestCase): 412 """Test an Optional with single- and double-dash option strings""" 413 414 argument_signatures = [ 415 Sig('-f', action='store_true'), 416 Sig('--bar'), 417 Sig('-baz', action='store_const', const=42), 418 ] 419 failures = ['--bar', '-fbar', '-fbaz', '-bazf', '-b B', 'B'] 420 successes = [ 421 ('', NS(f=False, bar=None, baz=None)), 422 ('-f', NS(f=True, bar=None, baz=None)), 423 ('--ba B', NS(f=False, bar='B', baz=None)), 424 ('-f --bar B', NS(f=True, bar='B', baz=None)), 425 ('-f -b', NS(f=True, bar=None, baz=42)), 426 ('-ba -f', NS(f=True, bar=None, baz=42)), 427 ] 428 429 430class TestOptionalsAlternatePrefixChars(ParserTestCase): 431 """Test an Optional with option strings with custom prefixes""" 432 433 parser_signature = Sig(prefix_chars='+:/', add_help=False) 434 argument_signatures = [ 435 Sig('+f', action='store_true'), 436 Sig('::bar'), 437 Sig('/baz', action='store_const', const=42), 438 ] 439 failures = ['--bar', '-fbar', '-b B', 'B', '-f', '--bar B', '-baz', '-h', '--help', '+h', '::help', '/help'] 440 successes = [ 441 ('', NS(f=False, bar=None, baz=None)), 442 ('+f', NS(f=True, bar=None, baz=None)), 443 ('::ba B', NS(f=False, bar='B', baz=None)), 444 ('+f ::bar B', NS(f=True, bar='B', baz=None)), 445 ('+f /b', NS(f=True, bar=None, baz=42)), 446 ('/ba +f', NS(f=True, bar=None, baz=42)), 447 ] 448 449 450class TestOptionalsAlternatePrefixCharsAddedHelp(ParserTestCase): 451 """When ``-`` not in prefix_chars, default operators created for help 452 should use the prefix_chars in use rather than - or -- 453 http://bugs.python.org/issue9444""" 454 455 parser_signature = Sig(prefix_chars='+:/', add_help=True) 456 argument_signatures = [ 457 Sig('+f', action='store_true'), 458 Sig('::bar'), 459 Sig('/baz', action='store_const', const=42), 460 ] 461 failures = ['--bar', '-fbar', '-b B', 'B', '-f', '--bar B', '-baz'] 462 successes = [ 463 ('', NS(f=False, bar=None, baz=None)), 464 ('+f', NS(f=True, bar=None, baz=None)), 465 ('::ba B', NS(f=False, bar='B', baz=None)), 466 ('+f ::bar B', NS(f=True, bar='B', baz=None)), 467 ('+f /b', NS(f=True, bar=None, baz=42)), 468 ('/ba +f', NS(f=True, bar=None, baz=42)) 469 ] 470 471 472class TestOptionalsAlternatePrefixCharsMultipleShortArgs(ParserTestCase): 473 """Verify that Optionals must be called with their defined prefixes""" 474 475 parser_signature = Sig(prefix_chars='+-', add_help=False) 476 argument_signatures = [ 477 Sig('-x', action='store_true'), 478 Sig('+y', action='store_true'), 479 Sig('+z', action='store_true'), 480 ] 481 failures = ['-w', 482 '-xyz', 483 '+x', 484 '-y', 485 '+xyz', 486 ] 487 successes = [ 488 ('', NS(x=False, y=False, z=False)), 489 ('-x', NS(x=True, y=False, z=False)), 490 ('+y -x', NS(x=True, y=True, z=False)), 491 ('+yz -x', NS(x=True, y=True, z=True)), 492 ] 493 494 495class TestOptionalsShortLong(ParserTestCase): 496 """Test a combination of single- and double-dash option strings""" 497 498 argument_signatures = [ 499 Sig('-v', '--verbose', '-n', '--noisy', action='store_true'), 500 ] 501 failures = ['--x --verbose', '-N', 'a', '-v x'] 502 successes = [ 503 ('', NS(verbose=False)), 504 ('-v', NS(verbose=True)), 505 ('--verbose', NS(verbose=True)), 506 ('-n', NS(verbose=True)), 507 ('--noisy', NS(verbose=True)), 508 ] 509 510 511class TestOptionalsDest(ParserTestCase): 512 """Tests various means of setting destination""" 513 514 argument_signatures = [Sig('--foo-bar'), Sig('--baz', dest='zabbaz')] 515 failures = ['a'] 516 successes = [ 517 ('--foo-bar f', NS(foo_bar='f', zabbaz=None)), 518 ('--baz g', NS(foo_bar=None, zabbaz='g')), 519 ('--foo-bar h --baz i', NS(foo_bar='h', zabbaz='i')), 520 ('--baz j --foo-bar k', NS(foo_bar='k', zabbaz='j')), 521 ] 522 523 524class TestOptionalsDefault(ParserTestCase): 525 """Tests specifying a default for an Optional""" 526 527 argument_signatures = [Sig('-x'), Sig('-y', default=42)] 528 failures = ['a'] 529 successes = [ 530 ('', NS(x=None, y=42)), 531 ('-xx', NS(x='x', y=42)), 532 ('-yy', NS(x=None, y='y')), 533 ] 534 535 536class TestOptionalsNargsDefault(ParserTestCase): 537 """Tests not specifying the number of args for an Optional""" 538 539 argument_signatures = [Sig('-x')] 540 failures = ['a', '-x'] 541 successes = [ 542 ('', NS(x=None)), 543 ('-x a', NS(x='a')), 544 ] 545 546 547class TestOptionalsNargs1(ParserTestCase): 548 """Tests specifying the 1 arg for an Optional""" 549 550 argument_signatures = [Sig('-x', nargs=1)] 551 failures = ['a', '-x'] 552 successes = [ 553 ('', NS(x=None)), 554 ('-x a', NS(x=['a'])), 555 ] 556 557 558class TestOptionalsNargs3(ParserTestCase): 559 """Tests specifying the 3 args for an Optional""" 560 561 argument_signatures = [Sig('-x', nargs=3)] 562 failures = ['a', '-x', '-x a', '-x a b', 'a -x', 'a -x b'] 563 successes = [ 564 ('', NS(x=None)), 565 ('-x a b c', NS(x=['a', 'b', 'c'])), 566 ] 567 568 569class TestOptionalsNargsOptional(ParserTestCase): 570 """Tests specifying an Optional arg for an Optional""" 571 572 argument_signatures = [ 573 Sig('-w', nargs='?'), 574 Sig('-x', nargs='?', const=42), 575 Sig('-y', nargs='?', default='spam'), 576 Sig('-z', nargs='?', type=int, const='42', default='84'), 577 ] 578 failures = ['2'] 579 successes = [ 580 ('', NS(w=None, x=None, y='spam', z=84)), 581 ('-w', NS(w=None, x=None, y='spam', z=84)), 582 ('-w 2', NS(w='2', x=None, y='spam', z=84)), 583 ('-x', NS(w=None, x=42, y='spam', z=84)), 584 ('-x 2', NS(w=None, x='2', y='spam', z=84)), 585 ('-y', NS(w=None, x=None, y=None, z=84)), 586 ('-y 2', NS(w=None, x=None, y='2', z=84)), 587 ('-z', NS(w=None, x=None, y='spam', z=42)), 588 ('-z 2', NS(w=None, x=None, y='spam', z=2)), 589 ] 590 591 592class TestOptionalsNargsZeroOrMore(ParserTestCase): 593 """Tests specifying an args for an Optional that accepts zero or more""" 594 595 argument_signatures = [ 596 Sig('-x', nargs='*'), 597 Sig('-y', nargs='*', default='spam'), 598 ] 599 failures = ['a'] 600 successes = [ 601 ('', NS(x=None, y='spam')), 602 ('-x', NS(x=[], y='spam')), 603 ('-x a', NS(x=['a'], y='spam')), 604 ('-x a b', NS(x=['a', 'b'], y='spam')), 605 ('-y', NS(x=None, y=[])), 606 ('-y a', NS(x=None, y=['a'])), 607 ('-y a b', NS(x=None, y=['a', 'b'])), 608 ] 609 610 611class TestOptionalsNargsOneOrMore(ParserTestCase): 612 """Tests specifying an args for an Optional that accepts one or more""" 613 614 argument_signatures = [ 615 Sig('-x', nargs='+'), 616 Sig('-y', nargs='+', default='spam'), 617 ] 618 failures = ['a', '-x', '-y', 'a -x', 'a -y b'] 619 successes = [ 620 ('', NS(x=None, y='spam')), 621 ('-x a', NS(x=['a'], y='spam')), 622 ('-x a b', NS(x=['a', 'b'], y='spam')), 623 ('-y a', NS(x=None, y=['a'])), 624 ('-y a b', NS(x=None, y=['a', 'b'])), 625 ] 626 627 628class TestOptionalsChoices(ParserTestCase): 629 """Tests specifying the choices for an Optional""" 630 631 argument_signatures = [ 632 Sig('-f', choices='abc'), 633 Sig('-g', type=int, choices=range(5))] 634 failures = ['a', '-f d', '-fad', '-ga', '-g 6'] 635 successes = [ 636 ('', NS(f=None, g=None)), 637 ('-f a', NS(f='a', g=None)), 638 ('-f c', NS(f='c', g=None)), 639 ('-g 0', NS(f=None, g=0)), 640 ('-g 03', NS(f=None, g=3)), 641 ('-fb -g4', NS(f='b', g=4)), 642 ] 643 644 645class TestOptionalsRequired(ParserTestCase): 646 """Tests the an optional action that is required""" 647 648 argument_signatures = [ 649 Sig('-x', type=int, required=True), 650 ] 651 failures = ['a', ''] 652 successes = [ 653 ('-x 1', NS(x=1)), 654 ('-x42', NS(x=42)), 655 ] 656 657 658class TestOptionalsActionStore(ParserTestCase): 659 """Tests the store action for an Optional""" 660 661 argument_signatures = [Sig('-x', action='store')] 662 failures = ['a', 'a -x'] 663 successes = [ 664 ('', NS(x=None)), 665 ('-xfoo', NS(x='foo')), 666 ] 667 668 669class TestOptionalsActionStoreConst(ParserTestCase): 670 """Tests the store_const action for an Optional""" 671 672 argument_signatures = [Sig('-y', action='store_const', const=object)] 673 failures = ['a'] 674 successes = [ 675 ('', NS(y=None)), 676 ('-y', NS(y=object)), 677 ] 678 679 680class TestOptionalsActionStoreFalse(ParserTestCase): 681 """Tests the store_false action for an Optional""" 682 683 argument_signatures = [Sig('-z', action='store_false')] 684 failures = ['a', '-za', '-z a'] 685 successes = [ 686 ('', NS(z=True)), 687 ('-z', NS(z=False)), 688 ] 689 690 691class TestOptionalsActionStoreTrue(ParserTestCase): 692 """Tests the store_true action for an Optional""" 693 694 argument_signatures = [Sig('--apple', action='store_true')] 695 failures = ['a', '--apple=b', '--apple b'] 696 successes = [ 697 ('', NS(apple=False)), 698 ('--apple', NS(apple=True)), 699 ] 700 701 702class TestOptionalsActionAppend(ParserTestCase): 703 """Tests the append action for an Optional""" 704 705 argument_signatures = [Sig('--baz', action='append')] 706 failures = ['a', '--baz', 'a --baz', '--baz a b'] 707 successes = [ 708 ('', NS(baz=None)), 709 ('--baz a', NS(baz=['a'])), 710 ('--baz a --baz b', NS(baz=['a', 'b'])), 711 ] 712 713 714class TestOptionalsActionAppendWithDefault(ParserTestCase): 715 """Tests the append action for an Optional""" 716 717 argument_signatures = [Sig('--baz', action='append', default=['X'])] 718 failures = ['a', '--baz', 'a --baz', '--baz a b'] 719 successes = [ 720 ('', NS(baz=['X'])), 721 ('--baz a', NS(baz=['X', 'a'])), 722 ('--baz a --baz b', NS(baz=['X', 'a', 'b'])), 723 ] 724 725 726class TestOptionalsActionAppendConst(ParserTestCase): 727 """Tests the append_const action for an Optional""" 728 729 argument_signatures = [ 730 Sig('-b', action='append_const', const=Exception), 731 Sig('-c', action='append', dest='b'), 732 ] 733 failures = ['a', '-c', 'a -c', '-bx', '-b x'] 734 successes = [ 735 ('', NS(b=None)), 736 ('-b', NS(b=[Exception])), 737 ('-b -cx -b -cyz', NS(b=[Exception, 'x', Exception, 'yz'])), 738 ] 739 740 741class TestOptionalsActionAppendConstWithDefault(ParserTestCase): 742 """Tests the append_const action for an Optional""" 743 744 argument_signatures = [ 745 Sig('-b', action='append_const', const=Exception, default=['X']), 746 Sig('-c', action='append', dest='b'), 747 ] 748 failures = ['a', '-c', 'a -c', '-bx', '-b x'] 749 successes = [ 750 ('', NS(b=['X'])), 751 ('-b', NS(b=['X', Exception])), 752 ('-b -cx -b -cyz', NS(b=['X', Exception, 'x', Exception, 'yz'])), 753 ] 754 755 756class TestOptionalsActionCount(ParserTestCase): 757 """Tests the count action for an Optional""" 758 759 argument_signatures = [Sig('-x', action='count')] 760 failures = ['a', '-x a', '-x b', '-x a -x b'] 761 successes = [ 762 ('', NS(x=None)), 763 ('-x', NS(x=1)), 764 ] 765 766 767# ================ 768# Positional tests 769# ================ 770 771class TestPositionalsNargsNone(ParserTestCase): 772 """Test a Positional that doesn't specify nargs""" 773 774 argument_signatures = [Sig('foo')] 775 failures = ['', '-x', 'a b'] 776 successes = [ 777 ('a', NS(foo='a')), 778 ] 779 780 781class TestPositionalsNargs1(ParserTestCase): 782 """Test a Positional that specifies an nargs of 1""" 783 784 argument_signatures = [Sig('foo', nargs=1)] 785 failures = ['', '-x', 'a b'] 786 successes = [ 787 ('a', NS(foo=['a'])), 788 ] 789 790 791class TestPositionalsNargs2(ParserTestCase): 792 """Test a Positional that specifies an nargs of 2""" 793 794 argument_signatures = [Sig('foo', nargs=2)] 795 failures = ['', 'a', '-x', 'a b c'] 796 successes = [ 797 ('a b', NS(foo=['a', 'b'])), 798 ] 799 800 801class TestPositionalsNargsZeroOrMore(ParserTestCase): 802 """Test a Positional that specifies unlimited nargs""" 803 804 argument_signatures = [Sig('foo', nargs='*')] 805 failures = ['-x'] 806 successes = [ 807 ('', NS(foo=[])), 808 ('a', NS(foo=['a'])), 809 ('a b', NS(foo=['a', 'b'])), 810 ] 811 812 813class TestPositionalsNargsZeroOrMoreDefault(ParserTestCase): 814 """Test a Positional that specifies unlimited nargs and a default""" 815 816 argument_signatures = [Sig('foo', nargs='*', default='bar')] 817 failures = ['-x'] 818 successes = [ 819 ('', NS(foo='bar')), 820 ('a', NS(foo=['a'])), 821 ('a b', NS(foo=['a', 'b'])), 822 ] 823 824 825class TestPositionalsNargsOneOrMore(ParserTestCase): 826 """Test a Positional that specifies one or more nargs""" 827 828 argument_signatures = [Sig('foo', nargs='+')] 829 failures = ['', '-x'] 830 successes = [ 831 ('a', NS(foo=['a'])), 832 ('a b', NS(foo=['a', 'b'])), 833 ] 834 835 836class TestPositionalsNargsOptional(ParserTestCase): 837 """Tests an Optional Positional""" 838 839 argument_signatures = [Sig('foo', nargs='?')] 840 failures = ['-x', 'a b'] 841 successes = [ 842 ('', NS(foo=None)), 843 ('a', NS(foo='a')), 844 ] 845 846 847class TestPositionalsNargsOptionalDefault(ParserTestCase): 848 """Tests an Optional Positional with a default value""" 849 850 argument_signatures = [Sig('foo', nargs='?', default=42)] 851 failures = ['-x', 'a b'] 852 successes = [ 853 ('', NS(foo=42)), 854 ('a', NS(foo='a')), 855 ] 856 857 858class TestPositionalsNargsOptionalConvertedDefault(ParserTestCase): 859 """Tests an Optional Positional with a default value 860 that needs to be converted to the appropriate type. 861 """ 862 863 argument_signatures = [ 864 Sig('foo', nargs='?', type=int, default='42'), 865 ] 866 failures = ['-x', 'a b', '1 2'] 867 successes = [ 868 ('', NS(foo=42)), 869 ('1', NS(foo=1)), 870 ] 871 872 873class TestPositionalsNargsNoneNone(ParserTestCase): 874 """Test two Positionals that don't specify nargs""" 875 876 argument_signatures = [Sig('foo'), Sig('bar')] 877 failures = ['', '-x', 'a', 'a b c'] 878 successes = [ 879 ('a b', NS(foo='a', bar='b')), 880 ] 881 882 883class TestPositionalsNargsNone1(ParserTestCase): 884 """Test a Positional with no nargs followed by one with 1""" 885 886 argument_signatures = [Sig('foo'), Sig('bar', nargs=1)] 887 failures = ['', '--foo', 'a', 'a b c'] 888 successes = [ 889 ('a b', NS(foo='a', bar=['b'])), 890 ] 891 892 893class TestPositionalsNargs2None(ParserTestCase): 894 """Test a Positional with 2 nargs followed by one with none""" 895 896 argument_signatures = [Sig('foo', nargs=2), Sig('bar')] 897 failures = ['', '--foo', 'a', 'a b', 'a b c d'] 898 successes = [ 899 ('a b c', NS(foo=['a', 'b'], bar='c')), 900 ] 901 902 903class TestPositionalsNargsNoneZeroOrMore(ParserTestCase): 904 """Test a Positional with no nargs followed by one with unlimited""" 905 906 argument_signatures = [Sig('foo'), Sig('bar', nargs='*')] 907 failures = ['', '--foo'] 908 successes = [ 909 ('a', NS(foo='a', bar=[])), 910 ('a b', NS(foo='a', bar=['b'])), 911 ('a b c', NS(foo='a', bar=['b', 'c'])), 912 ] 913 914 915class TestPositionalsNargsNoneOneOrMore(ParserTestCase): 916 """Test a Positional with no nargs followed by one with one or more""" 917 918 argument_signatures = [Sig('foo'), Sig('bar', nargs='+')] 919 failures = ['', '--foo', 'a'] 920 successes = [ 921 ('a b', NS(foo='a', bar=['b'])), 922 ('a b c', NS(foo='a', bar=['b', 'c'])), 923 ] 924 925 926class TestPositionalsNargsNoneOptional(ParserTestCase): 927 """Test a Positional with no nargs followed by one with an Optional""" 928 929 argument_signatures = [Sig('foo'), Sig('bar', nargs='?')] 930 failures = ['', '--foo', 'a b c'] 931 successes = [ 932 ('a', NS(foo='a', bar=None)), 933 ('a b', NS(foo='a', bar='b')), 934 ] 935 936 937class TestPositionalsNargsZeroOrMoreNone(ParserTestCase): 938 """Test a Positional with unlimited nargs followed by one with none""" 939 940 argument_signatures = [Sig('foo', nargs='*'), Sig('bar')] 941 failures = ['', '--foo'] 942 successes = [ 943 ('a', NS(foo=[], bar='a')), 944 ('a b', NS(foo=['a'], bar='b')), 945 ('a b c', NS(foo=['a', 'b'], bar='c')), 946 ] 947 948 949class TestPositionalsNargsOneOrMoreNone(ParserTestCase): 950 """Test a Positional with one or more nargs followed by one with none""" 951 952 argument_signatures = [Sig('foo', nargs='+'), Sig('bar')] 953 failures = ['', '--foo', 'a'] 954 successes = [ 955 ('a b', NS(foo=['a'], bar='b')), 956 ('a b c', NS(foo=['a', 'b'], bar='c')), 957 ] 958 959 960class TestPositionalsNargsOptionalNone(ParserTestCase): 961 """Test a Positional with an Optional nargs followed by one with none""" 962 963 argument_signatures = [Sig('foo', nargs='?', default=42), Sig('bar')] 964 failures = ['', '--foo', 'a b c'] 965 successes = [ 966 ('a', NS(foo=42, bar='a')), 967 ('a b', NS(foo='a', bar='b')), 968 ] 969 970 971class TestPositionalsNargs2ZeroOrMore(ParserTestCase): 972 """Test a Positional with 2 nargs followed by one with unlimited""" 973 974 argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='*')] 975 failures = ['', '--foo', 'a'] 976 successes = [ 977 ('a b', NS(foo=['a', 'b'], bar=[])), 978 ('a b c', NS(foo=['a', 'b'], bar=['c'])), 979 ] 980 981 982class TestPositionalsNargs2OneOrMore(ParserTestCase): 983 """Test a Positional with 2 nargs followed by one with one or more""" 984 985 argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='+')] 986 failures = ['', '--foo', 'a', 'a b'] 987 successes = [ 988 ('a b c', NS(foo=['a', 'b'], bar=['c'])), 989 ] 990 991 992class TestPositionalsNargs2Optional(ParserTestCase): 993 """Test a Positional with 2 nargs followed by one optional""" 994 995 argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='?')] 996 failures = ['', '--foo', 'a', 'a b c d'] 997 successes = [ 998 ('a b', NS(foo=['a', 'b'], bar=None)), 999 ('a b c', NS(foo=['a', 'b'], bar='c')), 1000 ] 1001 1002 1003class TestPositionalsNargsZeroOrMore1(ParserTestCase): 1004 """Test a Positional with unlimited nargs followed by one with 1""" 1005 1006 argument_signatures = [Sig('foo', nargs='*'), Sig('bar', nargs=1)] 1007 failures = ['', '--foo', ] 1008 successes = [ 1009 ('a', NS(foo=[], bar=['a'])), 1010 ('a b', NS(foo=['a'], bar=['b'])), 1011 ('a b c', NS(foo=['a', 'b'], bar=['c'])), 1012 ] 1013 1014 1015class TestPositionalsNargsOneOrMore1(ParserTestCase): 1016 """Test a Positional with one or more nargs followed by one with 1""" 1017 1018 argument_signatures = [Sig('foo', nargs='+'), Sig('bar', nargs=1)] 1019 failures = ['', '--foo', 'a'] 1020 successes = [ 1021 ('a b', NS(foo=['a'], bar=['b'])), 1022 ('a b c', NS(foo=['a', 'b'], bar=['c'])), 1023 ] 1024 1025 1026class TestPositionalsNargsOptional1(ParserTestCase): 1027 """Test a Positional with an Optional nargs followed by one with 1""" 1028 1029 argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs=1)] 1030 failures = ['', '--foo', 'a b c'] 1031 successes = [ 1032 ('a', NS(foo=None, bar=['a'])), 1033 ('a b', NS(foo='a', bar=['b'])), 1034 ] 1035 1036 1037class TestPositionalsNargsNoneZeroOrMore1(ParserTestCase): 1038 """Test three Positionals: no nargs, unlimited nargs and 1 nargs""" 1039 1040 argument_signatures = [ 1041 Sig('foo'), 1042 Sig('bar', nargs='*'), 1043 Sig('baz', nargs=1), 1044 ] 1045 failures = ['', '--foo', 'a'] 1046 successes = [ 1047 ('a b', NS(foo='a', bar=[], baz=['b'])), 1048 ('a b c', NS(foo='a', bar=['b'], baz=['c'])), 1049 ] 1050 1051 1052class TestPositionalsNargsNoneOneOrMore1(ParserTestCase): 1053 """Test three Positionals: no nargs, one or more nargs and 1 nargs""" 1054 1055 argument_signatures = [ 1056 Sig('foo'), 1057 Sig('bar', nargs='+'), 1058 Sig('baz', nargs=1), 1059 ] 1060 failures = ['', '--foo', 'a', 'b'] 1061 successes = [ 1062 ('a b c', NS(foo='a', bar=['b'], baz=['c'])), 1063 ('a b c d', NS(foo='a', bar=['b', 'c'], baz=['d'])), 1064 ] 1065 1066 1067class TestPositionalsNargsNoneOptional1(ParserTestCase): 1068 """Test three Positionals: no nargs, optional narg and 1 nargs""" 1069 1070 argument_signatures = [ 1071 Sig('foo'), 1072 Sig('bar', nargs='?', default=0.625), 1073 Sig('baz', nargs=1), 1074 ] 1075 failures = ['', '--foo', 'a'] 1076 successes = [ 1077 ('a b', NS(foo='a', bar=0.625, baz=['b'])), 1078 ('a b c', NS(foo='a', bar='b', baz=['c'])), 1079 ] 1080 1081 1082class TestPositionalsNargsOptionalOptional(ParserTestCase): 1083 """Test two optional nargs""" 1084 1085 argument_signatures = [ 1086 Sig('foo', nargs='?'), 1087 Sig('bar', nargs='?', default=42), 1088 ] 1089 failures = ['--foo', 'a b c'] 1090 successes = [ 1091 ('', NS(foo=None, bar=42)), 1092 ('a', NS(foo='a', bar=42)), 1093 ('a b', NS(foo='a', bar='b')), 1094 ] 1095 1096 1097class TestPositionalsNargsOptionalZeroOrMore(ParserTestCase): 1098 """Test an Optional narg followed by unlimited nargs""" 1099 1100 argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='*')] 1101 failures = ['--foo'] 1102 successes = [ 1103 ('', NS(foo=None, bar=[])), 1104 ('a', NS(foo='a', bar=[])), 1105 ('a b', NS(foo='a', bar=['b'])), 1106 ('a b c', NS(foo='a', bar=['b', 'c'])), 1107 ] 1108 1109 1110class TestPositionalsNargsOptionalOneOrMore(ParserTestCase): 1111 """Test an Optional narg followed by one or more nargs""" 1112 1113 argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='+')] 1114 failures = ['', '--foo'] 1115 successes = [ 1116 ('a', NS(foo=None, bar=['a'])), 1117 ('a b', NS(foo='a', bar=['b'])), 1118 ('a b c', NS(foo='a', bar=['b', 'c'])), 1119 ] 1120 1121 1122class TestPositionalsChoicesString(ParserTestCase): 1123 """Test a set of single-character choices""" 1124 1125 argument_signatures = [Sig('spam', choices=set('abcdefg'))] 1126 failures = ['', '--foo', 'h', '42', 'ef'] 1127 successes = [ 1128 ('a', NS(spam='a')), 1129 ('g', NS(spam='g')), 1130 ] 1131 1132 1133class TestPositionalsChoicesInt(ParserTestCase): 1134 """Test a set of integer choices""" 1135 1136 argument_signatures = [Sig('spam', type=int, choices=range(20))] 1137 failures = ['', '--foo', 'h', '42', 'ef'] 1138 successes = [ 1139 ('4', NS(spam=4)), 1140 ('15', NS(spam=15)), 1141 ] 1142 1143 1144class TestPositionalsActionAppend(ParserTestCase): 1145 """Test the 'append' action""" 1146 1147 argument_signatures = [ 1148 Sig('spam', action='append'), 1149 Sig('spam', action='append', nargs=2), 1150 ] 1151 failures = ['', '--foo', 'a', 'a b', 'a b c d'] 1152 successes = [ 1153 ('a b c', NS(spam=['a', ['b', 'c']])), 1154 ] 1155 1156# ======================================== 1157# Combined optionals and positionals tests 1158# ======================================== 1159 1160class TestOptionalsNumericAndPositionals(ParserTestCase): 1161 """Tests negative number args when numeric options are present""" 1162 1163 argument_signatures = [ 1164 Sig('x', nargs='?'), 1165 Sig('-4', dest='y', action='store_true'), 1166 ] 1167 failures = ['-2', '-315'] 1168 successes = [ 1169 ('', NS(x=None, y=False)), 1170 ('a', NS(x='a', y=False)), 1171 ('-4', NS(x=None, y=True)), 1172 ('-4 a', NS(x='a', y=True)), 1173 ] 1174 1175 1176class TestOptionalsAlmostNumericAndPositionals(ParserTestCase): 1177 """Tests negative number args when almost numeric options are present""" 1178 1179 argument_signatures = [ 1180 Sig('x', nargs='?'), 1181 Sig('-k4', dest='y', action='store_true'), 1182 ] 1183 failures = ['-k3'] 1184 successes = [ 1185 ('', NS(x=None, y=False)), 1186 ('-2', NS(x='-2', y=False)), 1187 ('a', NS(x='a', y=False)), 1188 ('-k4', NS(x=None, y=True)), 1189 ('-k4 a', NS(x='a', y=True)), 1190 ] 1191 1192 1193class TestEmptyAndSpaceContainingArguments(ParserTestCase): 1194 1195 argument_signatures = [ 1196 Sig('x', nargs='?'), 1197 Sig('-y', '--yyy', dest='y'), 1198 ] 1199 failures = ['-y'] 1200 successes = [ 1201 ([''], NS(x='', y=None)), 1202 (['a badger'], NS(x='a badger', y=None)), 1203 (['-a badger'], NS(x='-a badger', y=None)), 1204 (['-y', ''], NS(x=None, y='')), 1205 (['-y', 'a badger'], NS(x=None, y='a badger')), 1206 (['-y', '-a badger'], NS(x=None, y='-a badger')), 1207 (['--yyy=a badger'], NS(x=None, y='a badger')), 1208 (['--yyy=-a badger'], NS(x=None, y='-a badger')), 1209 ] 1210 1211 1212class TestPrefixCharacterOnlyArguments(ParserTestCase): 1213 1214 parser_signature = Sig(prefix_chars='-+') 1215 argument_signatures = [ 1216 Sig('-', dest='x', nargs='?', const='badger'), 1217 Sig('+', dest='y', type=int, default=42), 1218 Sig('-+-', dest='z', action='store_true'), 1219 ] 1220 failures = ['-y', '+ -'] 1221 successes = [ 1222 ('', NS(x=None, y=42, z=False)), 1223 ('-', NS(x='badger', y=42, z=False)), 1224 ('- X', NS(x='X', y=42, z=False)), 1225 ('+ -3', NS(x=None, y=-3, z=False)), 1226 ('-+-', NS(x=None, y=42, z=True)), 1227 ('- ===', NS(x='===', y=42, z=False)), 1228 ] 1229 1230 1231class TestNargsZeroOrMore(ParserTestCase): 1232 """Tests specifying an args for an Optional that accepts zero or more""" 1233 1234 argument_signatures = [Sig('-x', nargs='*'), Sig('y', nargs='*')] 1235 failures = [] 1236 successes = [ 1237 ('', NS(x=None, y=[])), 1238 ('-x', NS(x=[], y=[])), 1239 ('-x a', NS(x=['a'], y=[])), 1240 ('-x a -- b', NS(x=['a'], y=['b'])), 1241 ('a', NS(x=None, y=['a'])), 1242 ('a -x', NS(x=[], y=['a'])), 1243 ('a -x b', NS(x=['b'], y=['a'])), 1244 ] 1245 1246 1247class TestNargsRemainder(ParserTestCase): 1248 """Tests specifying a positional with nargs=REMAINDER""" 1249 1250 argument_signatures = [Sig('x'), Sig('y', nargs='...'), Sig('-z')] 1251 failures = ['', '-z', '-z Z'] 1252 successes = [ 1253 ('X', NS(x='X', y=[], z=None)), 1254 ('-z Z X', NS(x='X', y=[], z='Z')), 1255 ('X A B -z Z', NS(x='X', y=['A', 'B', '-z', 'Z'], z=None)), 1256 ('X Y --foo', NS(x='X', y=['Y', '--foo'], z=None)), 1257 ] 1258 1259 1260class TestOptionLike(ParserTestCase): 1261 """Tests options that may or may not be arguments""" 1262 1263 argument_signatures = [ 1264 Sig('-x', type=float), 1265 Sig('-3', type=float, dest='y'), 1266 Sig('z', nargs='*'), 1267 ] 1268 failures = ['-x', '-y2.5', '-xa', '-x -a', 1269 '-x -3', '-x -3.5', '-3 -3.5', 1270 '-x -2.5', '-x -2.5 a', '-3 -.5', 1271 'a x -1', '-x -1 a', '-3 -1 a'] 1272 successes = [ 1273 ('', NS(x=None, y=None, z=[])), 1274 ('-x 2.5', NS(x=2.5, y=None, z=[])), 1275 ('-x 2.5 a', NS(x=2.5, y=None, z=['a'])), 1276 ('-3.5', NS(x=None, y=0.5, z=[])), 1277 ('-3-.5', NS(x=None, y=-0.5, z=[])), 1278 ('-3 .5', NS(x=None, y=0.5, z=[])), 1279 ('a -3.5', NS(x=None, y=0.5, z=['a'])), 1280 ('a', NS(x=None, y=None, z=['a'])), 1281 ('a -x 1', NS(x=1.0, y=None, z=['a'])), 1282 ('-x 1 a', NS(x=1.0, y=None, z=['a'])), 1283 ('-3 1 a', NS(x=None, y=1.0, z=['a'])), 1284 ] 1285 1286 1287class TestDefaultSuppress(ParserTestCase): 1288 """Test actions with suppressed defaults""" 1289 1290 argument_signatures = [ 1291 Sig('foo', nargs='?', default=argparse.SUPPRESS), 1292 Sig('bar', nargs='*', default=argparse.SUPPRESS), 1293 Sig('--baz', action='store_true', default=argparse.SUPPRESS), 1294 ] 1295 failures = ['-x'] 1296 successes = [ 1297 ('', NS()), 1298 ('a', NS(foo='a')), 1299 ('a b', NS(foo='a', bar=['b'])), 1300 ('--baz', NS(baz=True)), 1301 ('a --baz', NS(foo='a', baz=True)), 1302 ('--baz a b', NS(foo='a', bar=['b'], baz=True)), 1303 ] 1304 1305 1306class TestParserDefaultSuppress(ParserTestCase): 1307 """Test actions with a parser-level default of SUPPRESS""" 1308 1309 parser_signature = Sig(argument_default=argparse.SUPPRESS) 1310 argument_signatures = [ 1311 Sig('foo', nargs='?'), 1312 Sig('bar', nargs='*'), 1313 Sig('--baz', action='store_true'), 1314 ] 1315 failures = ['-x'] 1316 successes = [ 1317 ('', NS()), 1318 ('a', NS(foo='a')), 1319 ('a b', NS(foo='a', bar=['b'])), 1320 ('--baz', NS(baz=True)), 1321 ('a --baz', NS(foo='a', baz=True)), 1322 ('--baz a b', NS(foo='a', bar=['b'], baz=True)), 1323 ] 1324 1325 1326class TestParserDefault42(ParserTestCase): 1327 """Test actions with a parser-level default of 42""" 1328 1329 parser_signature = Sig(argument_default=42, version='1.0') 1330 argument_signatures = [ 1331 Sig('foo', nargs='?'), 1332 Sig('bar', nargs='*'), 1333 Sig('--baz', action='store_true'), 1334 ] 1335 failures = ['-x'] 1336 successes = [ 1337 ('', NS(foo=42, bar=42, baz=42)), 1338 ('a', NS(foo='a', bar=42, baz=42)), 1339 ('a b', NS(foo='a', bar=['b'], baz=42)), 1340 ('--baz', NS(foo=42, bar=42, baz=True)), 1341 ('a --baz', NS(foo='a', bar=42, baz=True)), 1342 ('--baz a b', NS(foo='a', bar=['b'], baz=True)), 1343 ] 1344 1345 1346class TestArgumentsFromFile(TempDirMixin, ParserTestCase): 1347 """Test reading arguments from a file""" 1348 1349 def setUp(self): 1350 super(TestArgumentsFromFile, self).setUp() 1351 file_texts = [ 1352 ('hello', 'hello world!\n'), 1353 ('recursive', '-a\n' 1354 'A\n' 1355 '@hello'), 1356 ('invalid', '@no-such-path\n'), 1357 ] 1358 for path, text in file_texts: 1359 file = open(path, 'w') 1360 file.write(text) 1361 file.close() 1362 1363 parser_signature = Sig(fromfile_prefix_chars='@') 1364 argument_signatures = [ 1365 Sig('-a'), 1366 Sig('x'), 1367 Sig('y', nargs='+'), 1368 ] 1369 failures = ['', '-b', 'X', '@invalid', '@missing'] 1370 successes = [ 1371 ('X Y', NS(a=None, x='X', y=['Y'])), 1372 ('X -a A Y Z', NS(a='A', x='X', y=['Y', 'Z'])), 1373 ('@hello X', NS(a=None, x='hello world!', y=['X'])), 1374 ('X @hello', NS(a=None, x='X', y=['hello world!'])), 1375 ('-a B @recursive Y Z', NS(a='A', x='hello world!', y=['Y', 'Z'])), 1376 ('X @recursive Z -a B', NS(a='B', x='X', y=['hello world!', 'Z'])), 1377 (["-a", "", "X", "Y"], NS(a='', x='X', y=['Y'])), 1378 ] 1379 1380 1381class TestArgumentsFromFileConverter(TempDirMixin, ParserTestCase): 1382 """Test reading arguments from a file""" 1383 1384 def setUp(self): 1385 super(TestArgumentsFromFileConverter, self).setUp() 1386 file_texts = [ 1387 ('hello', 'hello world!\n'), 1388 ] 1389 for path, text in file_texts: 1390 file = open(path, 'w') 1391 file.write(text) 1392 file.close() 1393 1394 class FromFileConverterArgumentParser(ErrorRaisingArgumentParser): 1395 1396 def convert_arg_line_to_args(self, arg_line): 1397 for arg in arg_line.split(): 1398 if not arg.strip(): 1399 continue 1400 yield arg 1401 parser_class = FromFileConverterArgumentParser 1402 parser_signature = Sig(fromfile_prefix_chars='@') 1403 argument_signatures = [ 1404 Sig('y', nargs='+'), 1405 ] 1406 failures = [] 1407 successes = [ 1408 ('@hello X', NS(y=['hello', 'world!', 'X'])), 1409 ] 1410 1411 1412# ===================== 1413# Type conversion tests 1414# ===================== 1415 1416class TestFileTypeRepr(TestCase): 1417 1418 def test_r(self): 1419 type = argparse.FileType('r') 1420 self.assertEqual("FileType('r')", repr(type)) 1421 1422 def test_wb_1(self): 1423 type = argparse.FileType('wb', 1) 1424 self.assertEqual("FileType('wb', 1)", repr(type)) 1425 1426 1427class RFile(object): 1428 seen = {} 1429 1430 def __init__(self, name): 1431 self.name = name 1432 1433 __hash__ = None 1434 1435 def __eq__(self, other): 1436 if other in self.seen: 1437 text = self.seen[other] 1438 else: 1439 text = self.seen[other] = other.read() 1440 other.close() 1441 if not isinstance(text, str): 1442 text = text.decode('ascii') 1443 return self.name == other.name == text 1444 1445 1446class TestFileTypeR(TempDirMixin, ParserTestCase): 1447 """Test the FileType option/argument type for reading files""" 1448 1449 def setUp(self): 1450 super(TestFileTypeR, self).setUp() 1451 for file_name in ['foo', 'bar']: 1452 file = open(os.path.join(self.temp_dir, file_name), 'w') 1453 file.write(file_name) 1454 file.close() 1455 self.create_readonly_file('readonly') 1456 1457 argument_signatures = [ 1458 Sig('-x', type=argparse.FileType()), 1459 Sig('spam', type=argparse.FileType('r')), 1460 ] 1461 failures = ['-x', '-x bar', 'non-existent-file.txt'] 1462 successes = [ 1463 ('foo', NS(x=None, spam=RFile('foo'))), 1464 ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))), 1465 ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))), 1466 ('-x - -', NS(x=sys.stdin, spam=sys.stdin)), 1467 ('readonly', NS(x=None, spam=RFile('readonly'))), 1468 ] 1469 1470class TestFileTypeDefaults(TempDirMixin, ParserTestCase): 1471 """Test that a file is not created unless the default is needed""" 1472 def setUp(self): 1473 super(TestFileTypeDefaults, self).setUp() 1474 file = open(os.path.join(self.temp_dir, 'good'), 'w') 1475 file.write('good') 1476 file.close() 1477 1478 argument_signatures = [ 1479 Sig('-c', type=argparse.FileType('r'), default='no-file.txt'), 1480 ] 1481 # should provoke no such file error 1482 failures = [''] 1483 # should not provoke error because default file is created 1484 successes = [('-c good', NS(c=RFile('good')))] 1485 1486 1487class TestFileTypeRB(TempDirMixin, ParserTestCase): 1488 """Test the FileType option/argument type for reading files""" 1489 1490 def setUp(self): 1491 super(TestFileTypeRB, self).setUp() 1492 for file_name in ['foo', 'bar']: 1493 file = open(os.path.join(self.temp_dir, file_name), 'w') 1494 file.write(file_name) 1495 file.close() 1496 1497 argument_signatures = [ 1498 Sig('-x', type=argparse.FileType('rb')), 1499 Sig('spam', type=argparse.FileType('rb')), 1500 ] 1501 failures = ['-x', '-x bar'] 1502 successes = [ 1503 ('foo', NS(x=None, spam=RFile('foo'))), 1504 ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))), 1505 ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))), 1506 ('-x - -', NS(x=sys.stdin, spam=sys.stdin)), 1507 ] 1508 1509 1510class WFile(object): 1511 seen = set() 1512 1513 def __init__(self, name): 1514 self.name = name 1515 1516 __hash__ = None 1517 1518 def __eq__(self, other): 1519 if other not in self.seen: 1520 text = 'Check that file is writable.' 1521 if 'b' in other.mode: 1522 text = text.encode('ascii') 1523 other.write(text) 1524 other.close() 1525 self.seen.add(other) 1526 return self.name == other.name 1527 1528 1529@unittest.skipIf(hasattr(os, 'geteuid') and os.geteuid() == 0, 1530 "non-root user required") 1531class TestFileTypeW(TempDirMixin, ParserTestCase): 1532 """Test the FileType option/argument type for writing files""" 1533 1534 def setUp(self): 1535 super(TestFileTypeW, self).setUp() 1536 self.create_readonly_file('readonly') 1537 1538 argument_signatures = [ 1539 Sig('-x', type=argparse.FileType('w')), 1540 Sig('spam', type=argparse.FileType('w')), 1541 ] 1542 failures = ['-x', '-x bar'] 1543 failures = ['-x', '-x bar', 'readonly'] 1544 successes = [ 1545 ('foo', NS(x=None, spam=WFile('foo'))), 1546 ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))), 1547 ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))), 1548 ('-x - -', NS(x=sys.stdout, spam=sys.stdout)), 1549 ] 1550 1551 1552class TestFileTypeWB(TempDirMixin, ParserTestCase): 1553 1554 argument_signatures = [ 1555 Sig('-x', type=argparse.FileType('wb')), 1556 Sig('spam', type=argparse.FileType('wb')), 1557 ] 1558 failures = ['-x', '-x bar'] 1559 successes = [ 1560 ('foo', NS(x=None, spam=WFile('foo'))), 1561 ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))), 1562 ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))), 1563 ('-x - -', NS(x=sys.stdout, spam=sys.stdout)), 1564 ] 1565 1566 1567class TestTypeCallable(ParserTestCase): 1568 """Test some callables as option/argument types""" 1569 1570 argument_signatures = [ 1571 Sig('--eggs', type=complex), 1572 Sig('spam', type=float), 1573 ] 1574 failures = ['a', '42j', '--eggs a', '--eggs 2i'] 1575 successes = [ 1576 ('--eggs=42 42', NS(eggs=42, spam=42.0)), 1577 ('--eggs 2j -- -1.5', NS(eggs=2j, spam=-1.5)), 1578 ('1024.675', NS(eggs=None, spam=1024.675)), 1579 ] 1580 1581 1582class TestTypeUserDefined(ParserTestCase): 1583 """Test a user-defined option/argument type""" 1584 1585 class MyType(TestCase): 1586 1587 def __init__(self, value): 1588 self.value = value 1589 1590 __hash__ = None 1591 1592 def __eq__(self, other): 1593 return (type(self), self.value) == (type(other), other.value) 1594 1595 argument_signatures = [ 1596 Sig('-x', type=MyType), 1597 Sig('spam', type=MyType), 1598 ] 1599 failures = [] 1600 successes = [ 1601 ('a -x b', NS(x=MyType('b'), spam=MyType('a'))), 1602 ('-xf g', NS(x=MyType('f'), spam=MyType('g'))), 1603 ] 1604 1605 1606class TestTypeClassicClass(ParserTestCase): 1607 """Test a classic class type""" 1608 1609 class C: 1610 1611 def __init__(self, value): 1612 self.value = value 1613 1614 __hash__ = None 1615 1616 def __eq__(self, other): 1617 return (type(self), self.value) == (type(other), other.value) 1618 1619 argument_signatures = [ 1620 Sig('-x', type=C), 1621 Sig('spam', type=C), 1622 ] 1623 failures = [] 1624 successes = [ 1625 ('a -x b', NS(x=C('b'), spam=C('a'))), 1626 ('-xf g', NS(x=C('f'), spam=C('g'))), 1627 ] 1628 1629 1630class TestTypeRegistration(TestCase): 1631 """Test a user-defined type by registering it""" 1632 1633 def test(self): 1634 1635 def get_my_type(string): 1636 return 'my_type{%s}' % string 1637 1638 parser = argparse.ArgumentParser() 1639 parser.register('type', 'my_type', get_my_type) 1640 parser.add_argument('-x', type='my_type') 1641 parser.add_argument('y', type='my_type') 1642 1643 self.assertEqual(parser.parse_args('1'.split()), 1644 NS(x=None, y='my_type{1}')) 1645 self.assertEqual(parser.parse_args('-x 1 42'.split()), 1646 NS(x='my_type{1}', y='my_type{42}')) 1647 1648 1649# ============ 1650# Action tests 1651# ============ 1652 1653class TestActionUserDefined(ParserTestCase): 1654 """Test a user-defined option/argument action""" 1655 1656 class OptionalAction(argparse.Action): 1657 1658 def __call__(self, parser, namespace, value, option_string=None): 1659 try: 1660 # check destination and option string 1661 assert self.dest == 'spam', 'dest: %s' % self.dest 1662 assert option_string == '-s', 'flag: %s' % option_string 1663 # when option is before argument, badger=2, and when 1664 # option is after argument, badger=<whatever was set> 1665 expected_ns = NS(spam=0.25) 1666 if value in [0.125, 0.625]: 1667 expected_ns.badger = 2 1668 elif value in [2.0]: 1669 expected_ns.badger = 84 1670 else: 1671 raise AssertionError('value: %s' % value) 1672 assert expected_ns == namespace, ('expected %s, got %s' % 1673 (expected_ns, namespace)) 1674 except AssertionError: 1675 e = sys.exc_info()[1] 1676 raise ArgumentParserError('opt_action failed: %s' % e) 1677 setattr(namespace, 'spam', value) 1678 1679 class PositionalAction(argparse.Action): 1680 1681 def __call__(self, parser, namespace, value, option_string=None): 1682 try: 1683 assert option_string is None, ('option_string: %s' % 1684 option_string) 1685 # check destination 1686 assert self.dest == 'badger', 'dest: %s' % self.dest 1687 # when argument is before option, spam=0.25, and when 1688 # option is after argument, spam=<whatever was set> 1689 expected_ns = NS(badger=2) 1690 if value in [42, 84]: 1691 expected_ns.spam = 0.25 1692 elif value in [1]: 1693 expected_ns.spam = 0.625 1694 elif value in [2]: 1695 expected_ns.spam = 0.125 1696 else: 1697 raise AssertionError('value: %s' % value) 1698 assert expected_ns == namespace, ('expected %s, got %s' % 1699 (expected_ns, namespace)) 1700 except AssertionError: 1701 e = sys.exc_info()[1] 1702 raise ArgumentParserError('arg_action failed: %s' % e) 1703 setattr(namespace, 'badger', value) 1704 1705 argument_signatures = [ 1706 Sig('-s', dest='spam', action=OptionalAction, 1707 type=float, default=0.25), 1708 Sig('badger', action=PositionalAction, 1709 type=int, nargs='?', default=2), 1710 ] 1711 failures = [] 1712 successes = [ 1713 ('-s0.125', NS(spam=0.125, badger=2)), 1714 ('42', NS(spam=0.25, badger=42)), 1715 ('-s 0.625 1', NS(spam=0.625, badger=1)), 1716 ('84 -s2', NS(spam=2.0, badger=84)), 1717 ] 1718 1719 1720class TestActionRegistration(TestCase): 1721 """Test a user-defined action supplied by registering it""" 1722 1723 class MyAction(argparse.Action): 1724 1725 def __call__(self, parser, namespace, values, option_string=None): 1726 setattr(namespace, self.dest, 'foo[%s]' % values) 1727 1728 def test(self): 1729 1730 parser = argparse.ArgumentParser() 1731 parser.register('action', 'my_action', self.MyAction) 1732 parser.add_argument('badger', action='my_action') 1733 1734 self.assertEqual(parser.parse_args(['1']), NS(badger='foo[1]')) 1735 self.assertEqual(parser.parse_args(['42']), NS(badger='foo[42]')) 1736 1737 1738# ================ 1739# Subparsers tests 1740# ================ 1741 1742class TestAddSubparsers(TestCase): 1743 """Test the add_subparsers method""" 1744 1745 def assertArgumentParserError(self, *args, **kwargs): 1746 self.assertRaises(ArgumentParserError, *args, **kwargs) 1747 1748 def _get_parser(self, subparser_help=False, prefix_chars=None): 1749 # create a parser with a subparsers argument 1750 if prefix_chars: 1751 parser = ErrorRaisingArgumentParser( 1752 prog='PROG', description='main description', prefix_chars=prefix_chars) 1753 parser.add_argument( 1754 prefix_chars[0] * 2 + 'foo', action='store_true', help='foo help') 1755 else: 1756 parser = ErrorRaisingArgumentParser( 1757 prog='PROG', description='main description') 1758 parser.add_argument( 1759 '--foo', action='store_true', help='foo help') 1760 parser.add_argument( 1761 'bar', type=float, help='bar help') 1762 1763 # check that only one subparsers argument can be added 1764 subparsers = parser.add_subparsers(help='command help') 1765 self.assertArgumentParserError(parser.add_subparsers) 1766 1767 # add first sub-parser 1768 parser1_kwargs = dict(description='1 description') 1769 if subparser_help: 1770 parser1_kwargs['help'] = '1 help' 1771 parser1 = subparsers.add_parser('1', **parser1_kwargs) 1772 parser1.add_argument('-w', type=int, help='w help') 1773 parser1.add_argument('x', choices='abc', help='x help') 1774 1775 # add second sub-parser 1776 parser2_kwargs = dict(description='2 description') 1777 if subparser_help: 1778 parser2_kwargs['help'] = '2 help' 1779 parser2 = subparsers.add_parser('2', **parser2_kwargs) 1780 parser2.add_argument('-y', choices='123', help='y help') 1781 parser2.add_argument('z', type=complex, nargs='*', help='z help') 1782 1783 # add third sub-parser 1784 parser3_kwargs = dict(description='3 description') 1785 if subparser_help: 1786 parser3_kwargs['help'] = '3 help' 1787 parser3 = subparsers.add_parser('3', **parser3_kwargs) 1788 parser3.add_argument('t', type=int, help='t help') 1789 parser3.add_argument('u', nargs='...', help='u help') 1790 1791 # return the main parser 1792 return parser 1793 1794 def setUp(self): 1795 super(TestAddSubparsers, self).setUp() 1796 self.parser = self._get_parser() 1797 self.command_help_parser = self._get_parser(subparser_help=True) 1798 1799 def test_parse_args_failures(self): 1800 # check some failure cases: 1801 for args_str in ['', 'a', 'a a', '0.5 a', '0.5 1', 1802 '0.5 1 -y', '0.5 2 -w']: 1803 args = args_str.split() 1804 self.assertArgumentParserError(self.parser.parse_args, args) 1805 1806 def test_parse_args(self): 1807 # check some non-failure cases: 1808 self.assertEqual( 1809 self.parser.parse_args('0.5 1 b -w 7'.split()), 1810 NS(foo=False, bar=0.5, w=7, x='b'), 1811 ) 1812 self.assertEqual( 1813 self.parser.parse_args('0.25 --foo 2 -y 2 3j -- -1j'.split()), 1814 NS(foo=True, bar=0.25, y='2', z=[3j, -1j]), 1815 ) 1816 self.assertEqual( 1817 self.parser.parse_args('--foo 0.125 1 c'.split()), 1818 NS(foo=True, bar=0.125, w=None, x='c'), 1819 ) 1820 self.assertEqual( 1821 self.parser.parse_args('-1.5 3 11 -- a --foo 7 -- b'.split()), 1822 NS(foo=False, bar=-1.5, t=11, u=['a', '--foo', '7', '--', 'b']), 1823 ) 1824 1825 def test_parse_known_args(self): 1826 self.assertEqual( 1827 self.parser.parse_known_args('0.5 1 b -w 7'.split()), 1828 (NS(foo=False, bar=0.5, w=7, x='b'), []), 1829 ) 1830 self.assertEqual( 1831 self.parser.parse_known_args('0.5 -p 1 b -w 7'.split()), 1832 (NS(foo=False, bar=0.5, w=7, x='b'), ['-p']), 1833 ) 1834 self.assertEqual( 1835 self.parser.parse_known_args('0.5 1 b -w 7 -p'.split()), 1836 (NS(foo=False, bar=0.5, w=7, x='b'), ['-p']), 1837 ) 1838 self.assertEqual( 1839 self.parser.parse_known_args('0.5 1 b -q -rs -w 7'.split()), 1840 (NS(foo=False, bar=0.5, w=7, x='b'), ['-q', '-rs']), 1841 ) 1842 self.assertEqual( 1843 self.parser.parse_known_args('0.5 -W 1 b -X Y -w 7 Z'.split()), 1844 (NS(foo=False, bar=0.5, w=7, x='b'), ['-W', '-X', 'Y', 'Z']), 1845 ) 1846 1847 def test_dest(self): 1848 parser = ErrorRaisingArgumentParser() 1849 parser.add_argument('--foo', action='store_true') 1850 subparsers = parser.add_subparsers(dest='bar') 1851 parser1 = subparsers.add_parser('1') 1852 parser1.add_argument('baz') 1853 self.assertEqual(NS(foo=False, bar='1', baz='2'), 1854 parser.parse_args('1 2'.split())) 1855 1856 def test_help(self): 1857 self.assertEqual(self.parser.format_usage(), 1858 'usage: PROG [-h] [--foo] bar {1,2,3} ...\n') 1859 self.assertEqual(self.parser.format_help(), textwrap.dedent('''\ 1860 usage: PROG [-h] [--foo] bar {1,2,3} ... 1861 1862 main description 1863 1864 positional arguments: 1865 bar bar help 1866 {1,2,3} command help 1867 1868 optional arguments: 1869 -h, --help show this help message and exit 1870 --foo foo help 1871 ''')) 1872 1873 def test_help_extra_prefix_chars(self): 1874 # Make sure - is still used for help if it is a non-first prefix char 1875 parser = self._get_parser(prefix_chars='+:-') 1876 self.assertEqual(parser.format_usage(), 1877 'usage: PROG [-h] [++foo] bar {1,2,3} ...\n') 1878 self.assertEqual(parser.format_help(), textwrap.dedent('''\ 1879 usage: PROG [-h] [++foo] bar {1,2,3} ... 1880 1881 main description 1882 1883 positional arguments: 1884 bar bar help 1885 {1,2,3} command help 1886 1887 optional arguments: 1888 -h, --help show this help message and exit 1889 ++foo foo help 1890 ''')) 1891 1892 1893 def test_help_alternate_prefix_chars(self): 1894 parser = self._get_parser(prefix_chars='+:/') 1895 self.assertEqual(parser.format_usage(), 1896 'usage: PROG [+h] [++foo] bar {1,2,3} ...\n') 1897 self.assertEqual(parser.format_help(), textwrap.dedent('''\ 1898 usage: PROG [+h] [++foo] bar {1,2,3} ... 1899 1900 main description 1901 1902 positional arguments: 1903 bar bar help 1904 {1,2,3} command help 1905 1906 optional arguments: 1907 +h, ++help show this help message and exit 1908 ++foo foo help 1909 ''')) 1910 1911 def test_parser_command_help(self): 1912 self.assertEqual(self.command_help_parser.format_usage(), 1913 'usage: PROG [-h] [--foo] bar {1,2,3} ...\n') 1914 self.assertEqual(self.command_help_parser.format_help(), 1915 textwrap.dedent('''\ 1916 usage: PROG [-h] [--foo] bar {1,2,3} ... 1917 1918 main description 1919 1920 positional arguments: 1921 bar bar help 1922 {1,2,3} command help 1923 1 1 help 1924 2 2 help 1925 3 3 help 1926 1927 optional arguments: 1928 -h, --help show this help message and exit 1929 --foo foo help 1930 ''')) 1931 1932 def test_subparser_title_help(self): 1933 parser = ErrorRaisingArgumentParser(prog='PROG', 1934 description='main description') 1935 parser.add_argument('--foo', action='store_true', help='foo help') 1936 parser.add_argument('bar', help='bar help') 1937 subparsers = parser.add_subparsers(title='subcommands', 1938 description='command help', 1939 help='additional text') 1940 parser1 = subparsers.add_parser('1') 1941 parser2 = subparsers.add_parser('2') 1942 self.assertEqual(parser.format_usage(), 1943 'usage: PROG [-h] [--foo] bar {1,2} ...\n') 1944 self.assertEqual(parser.format_help(), textwrap.dedent('''\ 1945 usage: PROG [-h] [--foo] bar {1,2} ... 1946 1947 main description 1948 1949 positional arguments: 1950 bar bar help 1951 1952 optional arguments: 1953 -h, --help show this help message and exit 1954 --foo foo help 1955 1956 subcommands: 1957 command help 1958 1959 {1,2} additional text 1960 ''')) 1961 1962 def _test_subparser_help(self, args_str, expected_help): 1963 try: 1964 self.parser.parse_args(args_str.split()) 1965 except ArgumentParserError: 1966 err = sys.exc_info()[1] 1967 if err.stdout != expected_help: 1968 print(repr(expected_help)) 1969 print(repr(err.stdout)) 1970 self.assertEqual(err.stdout, expected_help) 1971 1972 def test_subparser1_help(self): 1973 self._test_subparser_help('5.0 1 -h', textwrap.dedent('''\ 1974 usage: PROG bar 1 [-h] [-w W] {a,b,c} 1975 1976 1 description 1977 1978 positional arguments: 1979 {a,b,c} x help 1980 1981 optional arguments: 1982 -h, --help show this help message and exit 1983 -w W w help 1984 ''')) 1985 1986 def test_subparser2_help(self): 1987 self._test_subparser_help('5.0 2 -h', textwrap.dedent('''\ 1988 usage: PROG bar 2 [-h] [-y {1,2,3}] [z [z ...]] 1989 1990 2 description 1991 1992 positional arguments: 1993 z z help 1994 1995 optional arguments: 1996 -h, --help show this help message and exit 1997 -y {1,2,3} y help 1998 ''')) 1999 2000# ============ 2001# Groups tests 2002# ============ 2003 2004class TestPositionalsGroups(TestCase): 2005 """Tests that order of group positionals matches construction order""" 2006 2007 def test_nongroup_first(self): 2008 parser = ErrorRaisingArgumentParser() 2009 parser.add_argument('foo') 2010 group = parser.add_argument_group('g') 2011 group.add_argument('bar') 2012 parser.add_argument('baz') 2013 expected = NS(foo='1', bar='2', baz='3') 2014 result = parser.parse_args('1 2 3'.split()) 2015 self.assertEqual(expected, result) 2016 2017 def test_group_first(self): 2018 parser = ErrorRaisingArgumentParser() 2019 group = parser.add_argument_group('xxx') 2020 group.add_argument('foo') 2021 parser.add_argument('bar') 2022 parser.add_argument('baz') 2023 expected = NS(foo='1', bar='2', baz='3') 2024 result = parser.parse_args('1 2 3'.split()) 2025 self.assertEqual(expected, result) 2026 2027 def test_interleaved_groups(self): 2028 parser = ErrorRaisingArgumentParser() 2029 group = parser.add_argument_group('xxx') 2030 parser.add_argument('foo') 2031 group.add_argument('bar') 2032 parser.add_argument('baz') 2033 group = parser.add_argument_group('yyy') 2034 group.add_argument('frell') 2035 expected = NS(foo='1', bar='2', baz='3', frell='4') 2036 result = parser.parse_args('1 2 3 4'.split()) 2037 self.assertEqual(expected, result) 2038 2039# =================== 2040# Parent parser tests 2041# =================== 2042 2043class TestParentParsers(TestCase): 2044 """Tests that parsers can be created with parent parsers""" 2045 2046 def assertArgumentParserError(self, *args, **kwargs): 2047 self.assertRaises(ArgumentParserError, *args, **kwargs) 2048 2049 def setUp(self): 2050 super(TestParentParsers, self).setUp() 2051 self.wxyz_parent = ErrorRaisingArgumentParser(add_help=False) 2052 self.wxyz_parent.add_argument('--w') 2053 x_group = self.wxyz_parent.add_argument_group('x') 2054 x_group.add_argument('-y') 2055 self.wxyz_parent.add_argument('z') 2056 2057 self.abcd_parent = ErrorRaisingArgumentParser(add_help=False) 2058 self.abcd_parent.add_argument('a') 2059 self.abcd_parent.add_argument('-b') 2060 c_group = self.abcd_parent.add_argument_group('c') 2061 c_group.add_argument('--d') 2062 2063 self.w_parent = ErrorRaisingArgumentParser(add_help=False) 2064 self.w_parent.add_argument('--w') 2065 2066 self.z_parent = ErrorRaisingArgumentParser(add_help=False) 2067 self.z_parent.add_argument('z') 2068 2069 # parents with mutually exclusive groups 2070 self.ab_mutex_parent = ErrorRaisingArgumentParser(add_help=False) 2071 group = self.ab_mutex_parent.add_mutually_exclusive_group() 2072 group.add_argument('-a', action='store_true') 2073 group.add_argument('-b', action='store_true') 2074 2075 self.main_program = os.path.basename(sys.argv[0]) 2076 2077 def test_single_parent(self): 2078 parser = ErrorRaisingArgumentParser(parents=[self.wxyz_parent]) 2079 self.assertEqual(parser.parse_args('-y 1 2 --w 3'.split()), 2080 NS(w='3', y='1', z='2')) 2081 2082 def test_single_parent_mutex(self): 2083 self._test_mutex_ab(self.ab_mutex_parent.parse_args) 2084 parser = ErrorRaisingArgumentParser(parents=[self.ab_mutex_parent]) 2085 self._test_mutex_ab(parser.parse_args) 2086 2087 def test_single_granparent_mutex(self): 2088 parents = [self.ab_mutex_parent] 2089 parser = ErrorRaisingArgumentParser(add_help=False, parents=parents) 2090 parser = ErrorRaisingArgumentParser(parents=[parser]) 2091 self._test_mutex_ab(parser.parse_args) 2092 2093 def _test_mutex_ab(self, parse_args): 2094 self.assertEqual(parse_args([]), NS(a=False, b=False)) 2095 self.assertEqual(parse_args(['-a']), NS(a=True, b=False)) 2096 self.assertEqual(parse_args(['-b']), NS(a=False, b=True)) 2097 self.assertArgumentParserError(parse_args, ['-a', '-b']) 2098 self.assertArgumentParserError(parse_args, ['-b', '-a']) 2099 self.assertArgumentParserError(parse_args, ['-c']) 2100 self.assertArgumentParserError(parse_args, ['-a', '-c']) 2101 self.assertArgumentParserError(parse_args, ['-b', '-c']) 2102 2103 def test_multiple_parents(self): 2104 parents = [self.abcd_parent, self.wxyz_parent] 2105 parser = ErrorRaisingArgumentParser(parents=parents) 2106 self.assertEqual(parser.parse_args('--d 1 --w 2 3 4'.split()), 2107 NS(a='3', b=None, d='1', w='2', y=None, z='4')) 2108 2109 def test_multiple_parents_mutex(self): 2110 parents = [self.ab_mutex_parent, self.wxyz_parent] 2111 parser = ErrorRaisingArgumentParser(parents=parents) 2112 self.assertEqual(parser.parse_args('-a --w 2 3'.split()), 2113 NS(a=True, b=False, w='2', y=None, z='3')) 2114 self.assertArgumentParserError( 2115 parser.parse_args, '-a --w 2 3 -b'.split()) 2116 self.assertArgumentParserError( 2117 parser.parse_args, '-a -b --w 2 3'.split()) 2118 2119 def test_conflicting_parents(self): 2120 self.assertRaises( 2121 argparse.ArgumentError, 2122 argparse.ArgumentParser, 2123 parents=[self.w_parent, self.wxyz_parent]) 2124 2125 def test_conflicting_parents_mutex(self): 2126 self.assertRaises( 2127 argparse.ArgumentError, 2128 argparse.ArgumentParser, 2129 parents=[self.abcd_parent, self.ab_mutex_parent]) 2130 2131 def test_same_argument_name_parents(self): 2132 parents = [self.wxyz_parent, self.z_parent] 2133 parser = ErrorRaisingArgumentParser(parents=parents) 2134 self.assertEqual(parser.parse_args('1 2'.split()), 2135 NS(w=None, y=None, z='2')) 2136 2137 def test_subparser_parents(self): 2138 parser = ErrorRaisingArgumentParser() 2139 subparsers = parser.add_subparsers() 2140 abcde_parser = subparsers.add_parser('bar', parents=[self.abcd_parent]) 2141 abcde_parser.add_argument('e') 2142 self.assertEqual(parser.parse_args('bar -b 1 --d 2 3 4'.split()), 2143 NS(a='3', b='1', d='2', e='4')) 2144 2145 def test_subparser_parents_mutex(self): 2146 parser = ErrorRaisingArgumentParser() 2147 subparsers = parser.add_subparsers() 2148 parents = [self.ab_mutex_parent] 2149 abc_parser = subparsers.add_parser('foo', parents=parents) 2150 c_group = abc_parser.add_argument_group('c_group') 2151 c_group.add_argument('c') 2152 parents = [self.wxyz_parent, self.ab_mutex_parent] 2153 wxyzabe_parser = subparsers.add_parser('bar', parents=parents) 2154 wxyzabe_parser.add_argument('e') 2155 self.assertEqual(parser.parse_args('foo -a 4'.split()), 2156 NS(a=True, b=False, c='4')) 2157 self.assertEqual(parser.parse_args('bar -b --w 2 3 4'.split()), 2158 NS(a=False, b=True, w='2', y=None, z='3', e='4')) 2159 self.assertArgumentParserError( 2160 parser.parse_args, 'foo -a -b 4'.split()) 2161 self.assertArgumentParserError( 2162 parser.parse_args, 'bar -b -a 4'.split()) 2163 2164 def test_parent_help(self): 2165 parents = [self.abcd_parent, self.wxyz_parent] 2166 parser = ErrorRaisingArgumentParser(parents=parents) 2167 parser_help = parser.format_help() 2168 progname = self.main_program 2169 self.assertEqual(parser_help, textwrap.dedent('''\ 2170 usage: {}{}[-h] [-b B] [--d D] [--w W] [-y Y] a z 2171 2172 positional arguments: 2173 a 2174 z 2175 2176 optional arguments: 2177 -h, --help show this help message and exit 2178 -b B 2179 --w W 2180 2181 c: 2182 --d D 2183 2184 x: 2185 -y Y 2186 '''.format(progname, ' ' if progname else '' ))) 2187 2188 def test_groups_parents(self): 2189 parent = ErrorRaisingArgumentParser(add_help=False) 2190 g = parent.add_argument_group(title='g', description='gd') 2191 g.add_argument('-w') 2192 g.add_argument('-x') 2193 m = parent.add_mutually_exclusive_group() 2194 m.add_argument('-y') 2195 m.add_argument('-z') 2196 parser = ErrorRaisingArgumentParser(parents=[parent]) 2197 2198 self.assertRaises(ArgumentParserError, parser.parse_args, 2199 ['-y', 'Y', '-z', 'Z']) 2200 2201 parser_help = parser.format_help() 2202 progname = self.main_program 2203 self.assertEqual(parser_help, textwrap.dedent('''\ 2204 usage: {}{}[-h] [-w W] [-x X] [-y Y | -z Z] 2205 2206 optional arguments: 2207 -h, --help show this help message and exit 2208 -y Y 2209 -z Z 2210 2211 g: 2212 gd 2213 2214 -w W 2215 -x X 2216 '''.format(progname, ' ' if progname else '' ))) 2217 2218# ============================== 2219# Mutually exclusive group tests 2220# ============================== 2221 2222class TestMutuallyExclusiveGroupErrors(TestCase): 2223 2224 def test_invalid_add_argument_group(self): 2225 parser = ErrorRaisingArgumentParser() 2226 raises = self.assertRaises 2227 raises(TypeError, parser.add_mutually_exclusive_group, title='foo') 2228 2229 def test_invalid_add_argument(self): 2230 parser = ErrorRaisingArgumentParser() 2231 group = parser.add_mutually_exclusive_group() 2232 add_argument = group.add_argument 2233 raises = self.assertRaises 2234 raises(ValueError, add_argument, '--foo', required=True) 2235 raises(ValueError, add_argument, 'bar') 2236 raises(ValueError, add_argument, 'bar', nargs='+') 2237 raises(ValueError, add_argument, 'bar', nargs=1) 2238 raises(ValueError, add_argument, 'bar', nargs=argparse.PARSER) 2239 2240 def test_help(self): 2241 parser = ErrorRaisingArgumentParser(prog='PROG') 2242 group1 = parser.add_mutually_exclusive_group() 2243 group1.add_argument('--foo', action='store_true') 2244 group1.add_argument('--bar', action='store_false') 2245 group2 = parser.add_mutually_exclusive_group() 2246 group2.add_argument('--soup', action='store_true') 2247 group2.add_argument('--nuts', action='store_false') 2248 expected = '''\ 2249 usage: PROG [-h] [--foo | --bar] [--soup | --nuts] 2250 2251 optional arguments: 2252 -h, --help show this help message and exit 2253 --foo 2254 --bar 2255 --soup 2256 --nuts 2257 ''' 2258 self.assertEqual(parser.format_help(), textwrap.dedent(expected)) 2259 2260class MEMixin(object): 2261 2262 def test_failures_when_not_required(self): 2263 parse_args = self.get_parser(required=False).parse_args 2264 error = ArgumentParserError 2265 for args_string in self.failures: 2266 self.assertRaises(error, parse_args, args_string.split()) 2267 2268 def test_failures_when_required(self): 2269 parse_args = self.get_parser(required=True).parse_args 2270 error = ArgumentParserError 2271 for args_string in self.failures + ['']: 2272 self.assertRaises(error, parse_args, args_string.split()) 2273 2274 def test_successes_when_not_required(self): 2275 parse_args = self.get_parser(required=False).parse_args 2276 successes = self.successes + self.successes_when_not_required 2277 for args_string, expected_ns in successes: 2278 actual_ns = parse_args(args_string.split()) 2279 self.assertEqual(actual_ns, expected_ns) 2280 2281 def test_successes_when_required(self): 2282 parse_args = self.get_parser(required=True).parse_args 2283 for args_string, expected_ns in self.successes: 2284 actual_ns = parse_args(args_string.split()) 2285 self.assertEqual(actual_ns, expected_ns) 2286 2287 def test_usage_when_not_required(self): 2288 format_usage = self.get_parser(required=False).format_usage 2289 expected_usage = self.usage_when_not_required 2290 self.assertEqual(format_usage(), textwrap.dedent(expected_usage)) 2291 2292 def test_usage_when_required(self): 2293 format_usage = self.get_parser(required=True).format_usage 2294 expected_usage = self.usage_when_required 2295 self.assertEqual(format_usage(), textwrap.dedent(expected_usage)) 2296 2297 def test_help_when_not_required(self): 2298 format_help = self.get_parser(required=False).format_help 2299 help = self.usage_when_not_required + self.help 2300 self.assertEqual(format_help(), textwrap.dedent(help)) 2301 2302 def test_help_when_required(self): 2303 format_help = self.get_parser(required=True).format_help 2304 help = self.usage_when_required + self.help 2305 self.assertEqual(format_help(), textwrap.dedent(help)) 2306 2307 2308class TestMutuallyExclusiveSimple(MEMixin, TestCase): 2309 2310 def get_parser(self, required=None): 2311 parser = ErrorRaisingArgumentParser(prog='PROG') 2312 group = parser.add_mutually_exclusive_group(required=required) 2313 group.add_argument('--bar', help='bar help') 2314 group.add_argument('--baz', nargs='?', const='Z', help='baz help') 2315 return parser 2316 2317 failures = ['--bar X --baz Y', '--bar X --baz'] 2318 successes = [ 2319 ('--bar X', NS(bar='X', baz=None)), 2320 ('--bar X --bar Z', NS(bar='Z', baz=None)), 2321 ('--baz Y', NS(bar=None, baz='Y')), 2322 ('--baz', NS(bar=None, baz='Z')), 2323 ] 2324 successes_when_not_required = [ 2325 ('', NS(bar=None, baz=None)), 2326 ] 2327 2328 usage_when_not_required = '''\ 2329 usage: PROG [-h] [--bar BAR | --baz [BAZ]] 2330 ''' 2331 usage_when_required = '''\ 2332 usage: PROG [-h] (--bar BAR | --baz [BAZ]) 2333 ''' 2334 help = '''\ 2335 2336 optional arguments: 2337 -h, --help show this help message and exit 2338 --bar BAR bar help 2339 --baz [BAZ] baz help 2340 ''' 2341 2342 2343class TestMutuallyExclusiveLong(MEMixin, TestCase): 2344 2345 def get_parser(self, required=None): 2346 parser = ErrorRaisingArgumentParser(prog='PROG') 2347 parser.add_argument('--abcde', help='abcde help') 2348 parser.add_argument('--fghij', help='fghij help') 2349 group = parser.add_mutually_exclusive_group(required=required) 2350 group.add_argument('--klmno', help='klmno help') 2351 group.add_argument('--pqrst', help='pqrst help') 2352 return parser 2353 2354 failures = ['--klmno X --pqrst Y'] 2355 successes = [ 2356 ('--klmno X', NS(abcde=None, fghij=None, klmno='X', pqrst=None)), 2357 ('--abcde Y --klmno X', 2358 NS(abcde='Y', fghij=None, klmno='X', pqrst=None)), 2359 ('--pqrst X', NS(abcde=None, fghij=None, klmno=None, pqrst='X')), 2360 ('--pqrst X --fghij Y', 2361 NS(abcde=None, fghij='Y', klmno=None, pqrst='X')), 2362 ] 2363 successes_when_not_required = [ 2364 ('', NS(abcde=None, fghij=None, klmno=None, pqrst=None)), 2365 ] 2366 2367 usage_when_not_required = '''\ 2368 usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ] 2369 [--klmno KLMNO | --pqrst PQRST] 2370 ''' 2371 usage_when_required = '''\ 2372 usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ] 2373 (--klmno KLMNO | --pqrst PQRST) 2374 ''' 2375 help = '''\ 2376 2377 optional arguments: 2378 -h, --help show this help message and exit 2379 --abcde ABCDE abcde help 2380 --fghij FGHIJ fghij help 2381 --klmno KLMNO klmno help 2382 --pqrst PQRST pqrst help 2383 ''' 2384 2385 2386class TestMutuallyExclusiveFirstSuppressed(MEMixin, TestCase): 2387 2388 def get_parser(self, required): 2389 parser = ErrorRaisingArgumentParser(prog='PROG') 2390 group = parser.add_mutually_exclusive_group(required=required) 2391 group.add_argument('-x', help=argparse.SUPPRESS) 2392 group.add_argument('-y', action='store_false', help='y help') 2393 return parser 2394 2395 failures = ['-x X -y'] 2396 successes = [ 2397 ('-x X', NS(x='X', y=True)), 2398 ('-x X -x Y', NS(x='Y', y=True)), 2399 ('-y', NS(x=None, y=False)), 2400 ] 2401 successes_when_not_required = [ 2402 ('', NS(x=None, y=True)), 2403 ] 2404 2405 usage_when_not_required = '''\ 2406 usage: PROG [-h] [-y] 2407 ''' 2408 usage_when_required = '''\ 2409 usage: PROG [-h] -y 2410 ''' 2411 help = '''\ 2412 2413 optional arguments: 2414 -h, --help show this help message and exit 2415 -y y help 2416 ''' 2417 2418 2419class TestMutuallyExclusiveManySuppressed(MEMixin, TestCase): 2420 2421 def get_parser(self, required): 2422 parser = ErrorRaisingArgumentParser(prog='PROG') 2423 group = parser.add_mutually_exclusive_group(required=required) 2424 add = group.add_argument 2425 add('--spam', action='store_true', help=argparse.SUPPRESS) 2426 add('--badger', action='store_false', help=argparse.SUPPRESS) 2427 add('--bladder', help=argparse.SUPPRESS) 2428 return parser 2429 2430 failures = [ 2431 '--spam --badger', 2432 '--badger --bladder B', 2433 '--bladder B --spam', 2434 ] 2435 successes = [ 2436 ('--spam', NS(spam=True, badger=True, bladder=None)), 2437 ('--badger', NS(spam=False, badger=False, bladder=None)), 2438 ('--bladder B', NS(spam=False, badger=True, bladder='B')), 2439 ('--spam --spam', NS(spam=True, badger=True, bladder=None)), 2440 ] 2441 successes_when_not_required = [ 2442 ('', NS(spam=False, badger=True, bladder=None)), 2443 ] 2444 2445 usage_when_required = usage_when_not_required = '''\ 2446 usage: PROG [-h] 2447 ''' 2448 help = '''\ 2449 2450 optional arguments: 2451 -h, --help show this help message and exit 2452 ''' 2453 2454 2455class TestMutuallyExclusiveOptionalAndPositional(MEMixin, TestCase): 2456 2457 def get_parser(self, required): 2458 parser = ErrorRaisingArgumentParser(prog='PROG') 2459 group = parser.add_mutually_exclusive_group(required=required) 2460 group.add_argument('--foo', action='store_true', help='FOO') 2461 group.add_argument('--spam', help='SPAM') 2462 group.add_argument('badger', nargs='*', default='X', help='BADGER') 2463 return parser 2464 2465 failures = [ 2466 '--foo --spam S', 2467 '--spam S X', 2468 'X --foo', 2469 'X Y Z --spam S', 2470 '--foo X Y', 2471 ] 2472 successes = [ 2473 ('--foo', NS(foo=True, spam=None, badger='X')), 2474 ('--spam S', NS(foo=False, spam='S', badger='X')), 2475 ('X', NS(foo=False, spam=None, badger=['X'])), 2476 ('X Y Z', NS(foo=False, spam=None, badger=['X', 'Y', 'Z'])), 2477 ] 2478 successes_when_not_required = [ 2479 ('', NS(foo=False, spam=None, badger='X')), 2480 ] 2481 2482 usage_when_not_required = '''\ 2483 usage: PROG [-h] [--foo | --spam SPAM | badger [badger ...]] 2484 ''' 2485 usage_when_required = '''\ 2486 usage: PROG [-h] (--foo | --spam SPAM | badger [badger ...]) 2487 ''' 2488 help = '''\ 2489 2490 positional arguments: 2491 badger BADGER 2492 2493 optional arguments: 2494 -h, --help show this help message and exit 2495 --foo FOO 2496 --spam SPAM SPAM 2497 ''' 2498 2499 2500class TestMutuallyExclusiveOptionalsMixed(MEMixin, TestCase): 2501 2502 def get_parser(self, required): 2503 parser = ErrorRaisingArgumentParser(prog='PROG') 2504 parser.add_argument('-x', action='store_true', help='x help') 2505 group = parser.add_mutually_exclusive_group(required=required) 2506 group.add_argument('-a', action='store_true', help='a help') 2507 group.add_argument('-b', action='store_true', help='b help') 2508 parser.add_argument('-y', action='store_true', help='y help') 2509 group.add_argument('-c', action='store_true', help='c help') 2510 return parser 2511 2512 failures = ['-a -b', '-b -c', '-a -c', '-a -b -c'] 2513 successes = [ 2514 ('-a', NS(a=True, b=False, c=False, x=False, y=False)), 2515 ('-b', NS(a=False, b=True, c=False, x=False, y=False)), 2516 ('-c', NS(a=False, b=False, c=True, x=False, y=False)), 2517 ('-a -x', NS(a=True, b=False, c=False, x=True, y=False)), 2518 ('-y -b', NS(a=False, b=True, c=False, x=False, y=True)), 2519 ('-x -y -c', NS(a=False, b=False, c=True, x=True, y=True)), 2520 ] 2521 successes_when_not_required = [ 2522 ('', NS(a=False, b=False, c=False, x=False, y=False)), 2523 ('-x', NS(a=False, b=False, c=False, x=True, y=False)), 2524 ('-y', NS(a=False, b=False, c=False, x=False, y=True)), 2525 ] 2526 2527 usage_when_required = usage_when_not_required = '''\ 2528 usage: PROG [-h] [-x] [-a] [-b] [-y] [-c] 2529 ''' 2530 help = '''\ 2531 2532 optional arguments: 2533 -h, --help show this help message and exit 2534 -x x help 2535 -a a help 2536 -b b help 2537 -y y help 2538 -c c help 2539 ''' 2540 2541 2542class TestMutuallyExclusiveInGroup(MEMixin, TestCase): 2543 2544 def get_parser(self, required=None): 2545 parser = ErrorRaisingArgumentParser(prog='PROG') 2546 titled_group = parser.add_argument_group( 2547 title='Titled group', description='Group description') 2548 mutex_group = \ 2549 titled_group.add_mutually_exclusive_group(required=required) 2550 mutex_group.add_argument('--bar', help='bar help') 2551 mutex_group.add_argument('--baz', help='baz help') 2552 return parser 2553 2554 failures = ['--bar X --baz Y', '--baz X --bar Y'] 2555 successes = [ 2556 ('--bar X', NS(bar='X', baz=None)), 2557 ('--baz Y', NS(bar=None, baz='Y')), 2558 ] 2559 successes_when_not_required = [ 2560 ('', NS(bar=None, baz=None)), 2561 ] 2562 2563 usage_when_not_required = '''\ 2564 usage: PROG [-h] [--bar BAR | --baz BAZ] 2565 ''' 2566 usage_when_required = '''\ 2567 usage: PROG [-h] (--bar BAR | --baz BAZ) 2568 ''' 2569 help = '''\ 2570 2571 optional arguments: 2572 -h, --help show this help message and exit 2573 2574 Titled group: 2575 Group description 2576 2577 --bar BAR bar help 2578 --baz BAZ baz help 2579 ''' 2580 2581 2582class TestMutuallyExclusiveOptionalsAndPositionalsMixed(MEMixin, TestCase): 2583 2584 def get_parser(self, required): 2585 parser = ErrorRaisingArgumentParser(prog='PROG') 2586 parser.add_argument('x', help='x help') 2587 parser.add_argument('-y', action='store_true', help='y help') 2588 group = parser.add_mutually_exclusive_group(required=required) 2589 group.add_argument('a', nargs='?', help='a help') 2590 group.add_argument('-b', action='store_true', help='b help') 2591 group.add_argument('-c', action='store_true', help='c help') 2592 return parser 2593 2594 failures = ['X A -b', '-b -c', '-c X A'] 2595 successes = [ 2596 ('X A', NS(a='A', b=False, c=False, x='X', y=False)), 2597 ('X -b', NS(a=None, b=True, c=False, x='X', y=False)), 2598 ('X -c', NS(a=None, b=False, c=True, x='X', y=False)), 2599 ('X A -y', NS(a='A', b=False, c=False, x='X', y=True)), 2600 ('X -y -b', NS(a=None, b=True, c=False, x='X', y=True)), 2601 ] 2602 successes_when_not_required = [ 2603 ('X', NS(a=None, b=False, c=False, x='X', y=False)), 2604 ('X -y', NS(a=None, b=False, c=False, x='X', y=True)), 2605 ] 2606 2607 usage_when_required = usage_when_not_required = '''\ 2608 usage: PROG [-h] [-y] [-b] [-c] x [a] 2609 ''' 2610 help = '''\ 2611 2612 positional arguments: 2613 x x help 2614 a a help 2615 2616 optional arguments: 2617 -h, --help show this help message and exit 2618 -y y help 2619 -b b help 2620 -c c help 2621 ''' 2622 2623# ================================================= 2624# Mutually exclusive group in parent parser tests 2625# ================================================= 2626 2627class MEPBase(object): 2628 2629 def get_parser(self, required=None): 2630 parent = super(MEPBase, self).get_parser(required=required) 2631 parser = ErrorRaisingArgumentParser( 2632 prog=parent.prog, add_help=False, parents=[parent]) 2633 return parser 2634 2635 2636class TestMutuallyExclusiveGroupErrorsParent( 2637 MEPBase, TestMutuallyExclusiveGroupErrors): 2638 pass 2639 2640 2641class TestMutuallyExclusiveSimpleParent( 2642 MEPBase, TestMutuallyExclusiveSimple): 2643 pass 2644 2645 2646class TestMutuallyExclusiveLongParent( 2647 MEPBase, TestMutuallyExclusiveLong): 2648 pass 2649 2650 2651class TestMutuallyExclusiveFirstSuppressedParent( 2652 MEPBase, TestMutuallyExclusiveFirstSuppressed): 2653 pass 2654 2655 2656class TestMutuallyExclusiveManySuppressedParent( 2657 MEPBase, TestMutuallyExclusiveManySuppressed): 2658 pass 2659 2660 2661class TestMutuallyExclusiveOptionalAndPositionalParent( 2662 MEPBase, TestMutuallyExclusiveOptionalAndPositional): 2663 pass 2664 2665 2666class TestMutuallyExclusiveOptionalsMixedParent( 2667 MEPBase, TestMutuallyExclusiveOptionalsMixed): 2668 pass 2669 2670 2671class TestMutuallyExclusiveOptionalsAndPositionalsMixedParent( 2672 MEPBase, TestMutuallyExclusiveOptionalsAndPositionalsMixed): 2673 pass 2674 2675# ================= 2676# Set default tests 2677# ================= 2678 2679class TestSetDefaults(TestCase): 2680 2681 def test_set_defaults_no_args(self): 2682 parser = ErrorRaisingArgumentParser() 2683 parser.set_defaults(x='foo') 2684 parser.set_defaults(y='bar', z=1) 2685 self.assertEqual(NS(x='foo', y='bar', z=1), 2686 parser.parse_args([])) 2687 self.assertEqual(NS(x='foo', y='bar', z=1), 2688 parser.parse_args([], NS())) 2689 self.assertEqual(NS(x='baz', y='bar', z=1), 2690 parser.parse_args([], NS(x='baz'))) 2691 self.assertEqual(NS(x='baz', y='bar', z=2), 2692 parser.parse_args([], NS(x='baz', z=2))) 2693 2694 def test_set_defaults_with_args(self): 2695 parser = ErrorRaisingArgumentParser() 2696 parser.set_defaults(x='foo', y='bar') 2697 parser.add_argument('-x', default='xfoox') 2698 self.assertEqual(NS(x='xfoox', y='bar'), 2699 parser.parse_args([])) 2700 self.assertEqual(NS(x='xfoox', y='bar'), 2701 parser.parse_args([], NS())) 2702 self.assertEqual(NS(x='baz', y='bar'), 2703 parser.parse_args([], NS(x='baz'))) 2704 self.assertEqual(NS(x='1', y='bar'), 2705 parser.parse_args('-x 1'.split())) 2706 self.assertEqual(NS(x='1', y='bar'), 2707 parser.parse_args('-x 1'.split(), NS())) 2708 self.assertEqual(NS(x='1', y='bar'), 2709 parser.parse_args('-x 1'.split(), NS(x='baz'))) 2710 2711 def test_set_defaults_subparsers(self): 2712 parser = ErrorRaisingArgumentParser() 2713 parser.set_defaults(x='foo') 2714 subparsers = parser.add_subparsers() 2715 parser_a = subparsers.add_parser('a') 2716 parser_a.set_defaults(y='bar') 2717 self.assertEqual(NS(x='foo', y='bar'), 2718 parser.parse_args('a'.split())) 2719 2720 def test_set_defaults_parents(self): 2721 parent = ErrorRaisingArgumentParser(add_help=False) 2722 parent.set_defaults(x='foo') 2723 parser = ErrorRaisingArgumentParser(parents=[parent]) 2724 self.assertEqual(NS(x='foo'), parser.parse_args([])) 2725 2726 def test_set_defaults_same_as_add_argument(self): 2727 parser = ErrorRaisingArgumentParser() 2728 parser.set_defaults(w='W', x='X', y='Y', z='Z') 2729 parser.add_argument('-w') 2730 parser.add_argument('-x', default='XX') 2731 parser.add_argument('y', nargs='?') 2732 parser.add_argument('z', nargs='?', default='ZZ') 2733 2734 # defaults set previously 2735 self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'), 2736 parser.parse_args([])) 2737 2738 # reset defaults 2739 parser.set_defaults(w='WW', x='X', y='YY', z='Z') 2740 self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'), 2741 parser.parse_args([])) 2742 2743 def test_set_defaults_same_as_add_argument_group(self): 2744 parser = ErrorRaisingArgumentParser() 2745 parser.set_defaults(w='W', x='X', y='Y', z='Z') 2746 group = parser.add_argument_group('foo') 2747 group.add_argument('-w') 2748 group.add_argument('-x', default='XX') 2749 group.add_argument('y', nargs='?') 2750 group.add_argument('z', nargs='?', default='ZZ') 2751 2752 2753 # defaults set previously 2754 self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'), 2755 parser.parse_args([])) 2756 2757 # reset defaults 2758 parser.set_defaults(w='WW', x='X', y='YY', z='Z') 2759 self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'), 2760 parser.parse_args([])) 2761 2762# ================= 2763# Get default tests 2764# ================= 2765 2766class TestGetDefault(TestCase): 2767 2768 def test_get_default(self): 2769 parser = ErrorRaisingArgumentParser() 2770 self.assertEqual(None, parser.get_default("foo")) 2771 self.assertEqual(None, parser.get_default("bar")) 2772 2773 parser.add_argument("--foo") 2774 self.assertEqual(None, parser.get_default("foo")) 2775 self.assertEqual(None, parser.get_default("bar")) 2776 2777 parser.add_argument("--bar", type=int, default=42) 2778 self.assertEqual(None, parser.get_default("foo")) 2779 self.assertEqual(42, parser.get_default("bar")) 2780 2781 parser.set_defaults(foo="badger") 2782 self.assertEqual("badger", parser.get_default("foo")) 2783 self.assertEqual(42, parser.get_default("bar")) 2784 2785# ========================== 2786# Namespace 'contains' tests 2787# ========================== 2788 2789class TestNamespaceContainsSimple(TestCase): 2790 2791 def test_empty(self): 2792 ns = argparse.Namespace() 2793 self.assertEqual('' in ns, False) 2794 self.assertEqual('' not in ns, True) 2795 self.assertEqual('x' in ns, False) 2796 2797 def test_non_empty(self): 2798 ns = argparse.Namespace(x=1, y=2) 2799 self.assertEqual('x' in ns, True) 2800 self.assertEqual('x' not in ns, False) 2801 self.assertEqual('y' in ns, True) 2802 self.assertEqual('' in ns, False) 2803 self.assertEqual('xx' in ns, False) 2804 self.assertEqual('z' in ns, False) 2805 2806# ===================== 2807# Help formatting tests 2808# ===================== 2809 2810class TestHelpFormattingMetaclass(type): 2811 2812 def __init__(cls, name, bases, bodydict): 2813 if name == 'HelpTestCase': 2814 return 2815 2816 class AddTests(object): 2817 2818 def __init__(self, test_class, func_suffix, std_name): 2819 self.func_suffix = func_suffix 2820 self.std_name = std_name 2821 2822 for test_func in [self.test_format, 2823 self.test_print, 2824 self.test_print_file]: 2825 test_name = '%s_%s' % (test_func.__name__, func_suffix) 2826 2827 def test_wrapper(self, test_func=test_func): 2828 test_func(self) 2829 try: 2830 test_wrapper.__name__ = test_name 2831 except TypeError: 2832 pass 2833 setattr(test_class, test_name, test_wrapper) 2834 2835 def _get_parser(self, tester): 2836 parser = argparse.ArgumentParser( 2837 *tester.parser_signature.args, 2838 **tester.parser_signature.kwargs) 2839 for argument_sig in getattr(tester, 'argument_signatures', []): 2840 parser.add_argument(*argument_sig.args, 2841 **argument_sig.kwargs) 2842 group_sigs = getattr(tester, 'argument_group_signatures', []) 2843 for group_sig, argument_sigs in group_sigs: 2844 group = parser.add_argument_group(*group_sig.args, 2845 **group_sig.kwargs) 2846 for argument_sig in argument_sigs: 2847 group.add_argument(*argument_sig.args, 2848 **argument_sig.kwargs) 2849 subparsers_sigs = getattr(tester, 'subparsers_signatures', []) 2850 if subparsers_sigs: 2851 subparsers = parser.add_subparsers() 2852 for subparser_sig in subparsers_sigs: 2853 subparsers.add_parser(*subparser_sig.args, 2854 **subparser_sig.kwargs) 2855 return parser 2856 2857 def _test(self, tester, parser_text): 2858 expected_text = getattr(tester, self.func_suffix) 2859 expected_text = textwrap.dedent(expected_text) 2860 if expected_text != parser_text: 2861 print(repr(expected_text)) 2862 print(repr(parser_text)) 2863 for char1, char2 in zip(expected_text, parser_text): 2864 if char1 != char2: 2865 print('first diff: %r %r' % (char1, char2)) 2866 break 2867 tester.assertEqual(expected_text, parser_text) 2868 2869 def test_format(self, tester): 2870 parser = self._get_parser(tester) 2871 format = getattr(parser, 'format_%s' % self.func_suffix) 2872 self._test(tester, format()) 2873 2874 def test_print(self, tester): 2875 parser = self._get_parser(tester) 2876 print_ = getattr(parser, 'print_%s' % self.func_suffix) 2877 old_stream = getattr(sys, self.std_name) 2878 setattr(sys, self.std_name, StdIOBuffer()) 2879 try: 2880 print_() 2881 parser_text = getattr(sys, self.std_name).getvalue() 2882 finally: 2883 setattr(sys, self.std_name, old_stream) 2884 self._test(tester, parser_text) 2885 2886 def test_print_file(self, tester): 2887 parser = self._get_parser(tester) 2888 print_ = getattr(parser, 'print_%s' % self.func_suffix) 2889 sfile = StdIOBuffer() 2890 print_(sfile) 2891 parser_text = sfile.getvalue() 2892 self._test(tester, parser_text) 2893 2894 # add tests for {format,print}_{usage,help,version} 2895 for func_suffix, std_name in [('usage', 'stdout'), 2896 ('help', 'stdout'), 2897 ('version', 'stderr')]: 2898 AddTests(cls, func_suffix, std_name) 2899 2900bases = TestCase, 2901HelpTestCase = TestHelpFormattingMetaclass('HelpTestCase', bases, {}) 2902 2903 2904class TestHelpBiggerOptionals(HelpTestCase): 2905 """Make sure that argument help aligns when options are longer""" 2906 2907 parser_signature = Sig(prog='PROG', description='DESCRIPTION', 2908 epilog='EPILOG', version='0.1') 2909 argument_signatures = [ 2910 Sig('-x', action='store_true', help='X HELP'), 2911 Sig('--y', help='Y HELP'), 2912 Sig('foo', help='FOO HELP'), 2913 Sig('bar', help='BAR HELP'), 2914 ] 2915 argument_group_signatures = [] 2916 usage = '''\ 2917 usage: PROG [-h] [-v] [-x] [--y Y] foo bar 2918 ''' 2919 help = usage + '''\ 2920 2921 DESCRIPTION 2922 2923 positional arguments: 2924 foo FOO HELP 2925 bar BAR HELP 2926 2927 optional arguments: 2928 -h, --help show this help message and exit 2929 -v, --version show program's version number and exit 2930 -x X HELP 2931 --y Y Y HELP 2932 2933 EPILOG 2934 ''' 2935 version = '''\ 2936 0.1 2937 ''' 2938 2939 2940class TestHelpBiggerOptionalGroups(HelpTestCase): 2941 """Make sure that argument help aligns when options are longer""" 2942 2943 parser_signature = Sig(prog='PROG', description='DESCRIPTION', 2944 epilog='EPILOG', version='0.1') 2945 argument_signatures = [ 2946 Sig('-x', action='store_true', help='X HELP'), 2947 Sig('--y', help='Y HELP'), 2948 Sig('foo', help='FOO HELP'), 2949 Sig('bar', help='BAR HELP'), 2950 ] 2951 argument_group_signatures = [ 2952 (Sig('GROUP TITLE', description='GROUP DESCRIPTION'), [ 2953 Sig('baz', help='BAZ HELP'), 2954 Sig('-z', nargs='+', help='Z HELP')]), 2955 ] 2956 usage = '''\ 2957 usage: PROG [-h] [-v] [-x] [--y Y] [-z Z [Z ...]] foo bar baz 2958 ''' 2959 help = usage + '''\ 2960 2961 DESCRIPTION 2962 2963 positional arguments: 2964 foo FOO HELP 2965 bar BAR HELP 2966 2967 optional arguments: 2968 -h, --help show this help message and exit 2969 -v, --version show program's version number and exit 2970 -x X HELP 2971 --y Y Y HELP 2972 2973 GROUP TITLE: 2974 GROUP DESCRIPTION 2975 2976 baz BAZ HELP 2977 -z Z [Z ...] Z HELP 2978 2979 EPILOG 2980 ''' 2981 version = '''\ 2982 0.1 2983 ''' 2984 2985 2986class TestHelpBiggerPositionals(HelpTestCase): 2987 """Make sure that help aligns when arguments are longer""" 2988 2989 parser_signature = Sig(usage='USAGE', description='DESCRIPTION') 2990 argument_signatures = [ 2991 Sig('-x', action='store_true', help='X HELP'), 2992 Sig('--y', help='Y HELP'), 2993 Sig('ekiekiekifekang', help='EKI HELP'), 2994 Sig('bar', help='BAR HELP'), 2995 ] 2996 argument_group_signatures = [] 2997 usage = '''\ 2998 usage: USAGE 2999 ''' 3000 help = usage + '''\ 3001 3002 DESCRIPTION 3003 3004 positional arguments: 3005 ekiekiekifekang EKI HELP 3006 bar BAR HELP 3007 3008 optional arguments: 3009 -h, --help show this help message and exit 3010 -x X HELP 3011 --y Y Y HELP 3012 ''' 3013 3014 version = '' 3015 3016 3017class TestHelpReformatting(HelpTestCase): 3018 """Make sure that text after short names starts on the first line""" 3019 3020 parser_signature = Sig( 3021 prog='PROG', 3022 description=' oddly formatted\n' 3023 'description\n' 3024 '\n' 3025 'that is so long that it should go onto multiple ' 3026 'lines when wrapped') 3027 argument_signatures = [ 3028 Sig('-x', metavar='XX', help='oddly\n' 3029 ' formatted -x help'), 3030 Sig('y', metavar='yyy', help='normal y help'), 3031 ] 3032 argument_group_signatures = [ 3033 (Sig('title', description='\n' 3034 ' oddly formatted group\n' 3035 '\n' 3036 'description'), 3037 [Sig('-a', action='store_true', 3038 help=' oddly \n' 3039 'formatted -a help \n' 3040 ' again, so long that it should be wrapped over ' 3041 'multiple lines')]), 3042 ] 3043 usage = '''\ 3044 usage: PROG [-h] [-x XX] [-a] yyy 3045 ''' 3046 help = usage + '''\ 3047 3048 oddly formatted description that is so long that it should go onto \ 3049multiple 3050 lines when wrapped 3051 3052 positional arguments: 3053 yyy normal y help 3054 3055 optional arguments: 3056 -h, --help show this help message and exit 3057 -x XX oddly formatted -x help 3058 3059 title: 3060 oddly formatted group description 3061 3062 -a oddly formatted -a help again, so long that it should \ 3063be wrapped 3064 over multiple lines 3065 ''' 3066 version = '' 3067 3068 3069class TestHelpWrappingShortNames(HelpTestCase): 3070 """Make sure that text after short names starts on the first line""" 3071 3072 parser_signature = Sig(prog='PROG', description= 'D\nD' * 30) 3073 argument_signatures = [ 3074 Sig('-x', metavar='XX', help='XHH HX' * 20), 3075 Sig('y', metavar='yyy', help='YH YH' * 20), 3076 ] 3077 argument_group_signatures = [ 3078 (Sig('ALPHAS'), [ 3079 Sig('-a', action='store_true', help='AHHH HHA' * 10)]), 3080 ] 3081 usage = '''\ 3082 usage: PROG [-h] [-x XX] [-a] yyy 3083 ''' 3084 help = usage + '''\ 3085 3086 D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \ 3087DD DD DD 3088 DD DD DD DD D 3089 3090 positional arguments: 3091 yyy YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \ 3092YHYH YHYH 3093 YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH 3094 3095 optional arguments: 3096 -h, --help show this help message and exit 3097 -x XX XHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH \ 3098HXXHH HXXHH 3099 HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HX 3100 3101 ALPHAS: 3102 -a AHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH \ 3103HHAAHHH 3104 HHAAHHH HHAAHHH HHA 3105 ''' 3106 version = '' 3107 3108 3109class TestHelpWrappingLongNames(HelpTestCase): 3110 """Make sure that text after long names starts on the next line""" 3111 3112 parser_signature = Sig(usage='USAGE', description= 'D D' * 30, 3113 version='V V'*30) 3114 argument_signatures = [ 3115 Sig('-x', metavar='X' * 25, help='XH XH' * 20), 3116 Sig('y', metavar='y' * 25, help='YH YH' * 20), 3117 ] 3118 argument_group_signatures = [ 3119 (Sig('ALPHAS'), [ 3120 Sig('-a', metavar='A' * 25, help='AH AH' * 20), 3121 Sig('z', metavar='z' * 25, help='ZH ZH' * 20)]), 3122 ] 3123 usage = '''\ 3124 usage: USAGE 3125 ''' 3126 help = usage + '''\ 3127 3128 D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \ 3129DD DD DD 3130 DD DD DD DD D 3131 3132 positional arguments: 3133 yyyyyyyyyyyyyyyyyyyyyyyyy 3134 YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \ 3135YHYH YHYH 3136 YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH 3137 3138 optional arguments: 3139 -h, --help show this help message and exit 3140 -v, --version show program's version number and exit 3141 -x XXXXXXXXXXXXXXXXXXXXXXXXX 3142 XH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH \ 3143XHXH XHXH 3144 XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XH 3145 3146 ALPHAS: 3147 -a AAAAAAAAAAAAAAAAAAAAAAAAA 3148 AH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH \ 3149AHAH AHAH 3150 AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AH 3151 zzzzzzzzzzzzzzzzzzzzzzzzz 3152 ZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH \ 3153ZHZH ZHZH 3154 ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZH 3155 ''' 3156 version = '''\ 3157 V VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV \ 3158VV VV VV 3159 VV VV VV VV V 3160 ''' 3161 3162 3163class TestHelpUsage(HelpTestCase): 3164 """Test basic usage messages""" 3165 3166 parser_signature = Sig(prog='PROG') 3167 argument_signatures = [ 3168 Sig('-w', nargs='+', help='w'), 3169 Sig('-x', nargs='*', help='x'), 3170 Sig('a', help='a'), 3171 Sig('b', help='b', nargs=2), 3172 Sig('c', help='c', nargs='?'), 3173 ] 3174 argument_group_signatures = [ 3175 (Sig('group'), [ 3176 Sig('-y', nargs='?', help='y'), 3177 Sig('-z', nargs=3, help='z'), 3178 Sig('d', help='d', nargs='*'), 3179 Sig('e', help='e', nargs='+'), 3180 ]) 3181 ] 3182 usage = '''\ 3183 usage: PROG [-h] [-w W [W ...]] [-x [X [X ...]]] [-y [Y]] [-z Z Z Z] 3184 a b b [c] [d [d ...]] e [e ...] 3185 ''' 3186 help = usage + '''\ 3187 3188 positional arguments: 3189 a a 3190 b b 3191 c c 3192 3193 optional arguments: 3194 -h, --help show this help message and exit 3195 -w W [W ...] w 3196 -x [X [X ...]] x 3197 3198 group: 3199 -y [Y] y 3200 -z Z Z Z z 3201 d d 3202 e e 3203 ''' 3204 version = '' 3205 3206 3207class TestHelpOnlyUserGroups(HelpTestCase): 3208 """Test basic usage messages""" 3209 3210 parser_signature = Sig(prog='PROG', add_help=False) 3211 argument_signatures = [] 3212 argument_group_signatures = [ 3213 (Sig('xxxx'), [ 3214 Sig('-x', help='x'), 3215 Sig('a', help='a'), 3216 ]), 3217 (Sig('yyyy'), [ 3218 Sig('b', help='b'), 3219 Sig('-y', help='y'), 3220 ]), 3221 ] 3222 usage = '''\ 3223 usage: PROG [-x X] [-y Y] a b 3224 ''' 3225 help = usage + '''\ 3226 3227 xxxx: 3228 -x X x 3229 a a 3230 3231 yyyy: 3232 b b 3233 -y Y y 3234 ''' 3235 version = '' 3236 3237 3238class TestHelpUsageLongProg(HelpTestCase): 3239 """Test usage messages where the prog is long""" 3240 3241 parser_signature = Sig(prog='P' * 60) 3242 argument_signatures = [ 3243 Sig('-w', metavar='W'), 3244 Sig('-x', metavar='X'), 3245 Sig('a'), 3246 Sig('b'), 3247 ] 3248 argument_group_signatures = [] 3249 usage = '''\ 3250 usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP 3251 [-h] [-w W] [-x X] a b 3252 ''' 3253 help = usage + '''\ 3254 3255 positional arguments: 3256 a 3257 b 3258 3259 optional arguments: 3260 -h, --help show this help message and exit 3261 -w W 3262 -x X 3263 ''' 3264 version = '' 3265 3266 3267class TestHelpUsageLongProgOptionsWrap(HelpTestCase): 3268 """Test usage messages where the prog is long and the optionals wrap""" 3269 3270 parser_signature = Sig(prog='P' * 60) 3271 argument_signatures = [ 3272 Sig('-w', metavar='W' * 25), 3273 Sig('-x', metavar='X' * 25), 3274 Sig('-y', metavar='Y' * 25), 3275 Sig('-z', metavar='Z' * 25), 3276 Sig('a'), 3277 Sig('b'), 3278 ] 3279 argument_group_signatures = [] 3280 usage = '''\ 3281 usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP 3282 [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \ 3283[-x XXXXXXXXXXXXXXXXXXXXXXXXX] 3284 [-y YYYYYYYYYYYYYYYYYYYYYYYYY] [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ] 3285 a b 3286 ''' 3287 help = usage + '''\ 3288 3289 positional arguments: 3290 a 3291 b 3292 3293 optional arguments: 3294 -h, --help show this help message and exit 3295 -w WWWWWWWWWWWWWWWWWWWWWWWWW 3296 -x XXXXXXXXXXXXXXXXXXXXXXXXX 3297 -y YYYYYYYYYYYYYYYYYYYYYYYYY 3298 -z ZZZZZZZZZZZZZZZZZZZZZZZZZ 3299 ''' 3300 version = '' 3301 3302 3303class TestHelpUsageLongProgPositionalsWrap(HelpTestCase): 3304 """Test usage messages where the prog is long and the positionals wrap""" 3305 3306 parser_signature = Sig(prog='P' * 60, add_help=False) 3307 argument_signatures = [ 3308 Sig('a' * 25), 3309 Sig('b' * 25), 3310 Sig('c' * 25), 3311 ] 3312 argument_group_signatures = [] 3313 usage = '''\ 3314 usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP 3315 aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb 3316 ccccccccccccccccccccccccc 3317 ''' 3318 help = usage + '''\ 3319 3320 positional arguments: 3321 aaaaaaaaaaaaaaaaaaaaaaaaa 3322 bbbbbbbbbbbbbbbbbbbbbbbbb 3323 ccccccccccccccccccccccccc 3324 ''' 3325 version = '' 3326 3327 3328class TestHelpUsageOptionalsWrap(HelpTestCase): 3329 """Test usage messages where the optionals wrap""" 3330 3331 parser_signature = Sig(prog='PROG') 3332 argument_signatures = [ 3333 Sig('-w', metavar='W' * 25), 3334 Sig('-x', metavar='X' * 25), 3335 Sig('-y', metavar='Y' * 25), 3336 Sig('-z', metavar='Z' * 25), 3337 Sig('a'), 3338 Sig('b'), 3339 Sig('c'), 3340 ] 3341 argument_group_signatures = [] 3342 usage = '''\ 3343 usage: PROG [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \ 3344[-x XXXXXXXXXXXXXXXXXXXXXXXXX] 3345 [-y YYYYYYYYYYYYYYYYYYYYYYYYY] \ 3346[-z ZZZZZZZZZZZZZZZZZZZZZZZZZ] 3347 a b c 3348 ''' 3349 help = usage + '''\ 3350 3351 positional arguments: 3352 a 3353 b 3354 c 3355 3356 optional arguments: 3357 -h, --help show this help message and exit 3358 -w WWWWWWWWWWWWWWWWWWWWWWWWW 3359 -x XXXXXXXXXXXXXXXXXXXXXXXXX 3360 -y YYYYYYYYYYYYYYYYYYYYYYYYY 3361 -z ZZZZZZZZZZZZZZZZZZZZZZZZZ 3362 ''' 3363 version = '' 3364 3365 3366class TestHelpUsagePositionalsWrap(HelpTestCase): 3367 """Test usage messages where the positionals wrap""" 3368 3369 parser_signature = Sig(prog='PROG') 3370 argument_signatures = [ 3371 Sig('-x'), 3372 Sig('-y'), 3373 Sig('-z'), 3374 Sig('a' * 25), 3375 Sig('b' * 25), 3376 Sig('c' * 25), 3377 ] 3378 argument_group_signatures = [] 3379 usage = '''\ 3380 usage: PROG [-h] [-x X] [-y Y] [-z Z] 3381 aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb 3382 ccccccccccccccccccccccccc 3383 ''' 3384 help = usage + '''\ 3385 3386 positional arguments: 3387 aaaaaaaaaaaaaaaaaaaaaaaaa 3388 bbbbbbbbbbbbbbbbbbbbbbbbb 3389 ccccccccccccccccccccccccc 3390 3391 optional arguments: 3392 -h, --help show this help message and exit 3393 -x X 3394 -y Y 3395 -z Z 3396 ''' 3397 version = '' 3398 3399 3400class TestHelpUsageOptionalsPositionalsWrap(HelpTestCase): 3401 """Test usage messages where the optionals and positionals wrap""" 3402 3403 parser_signature = Sig(prog='PROG') 3404 argument_signatures = [ 3405 Sig('-x', metavar='X' * 25), 3406 Sig('-y', metavar='Y' * 25), 3407 Sig('-z', metavar='Z' * 25), 3408 Sig('a' * 25), 3409 Sig('b' * 25), 3410 Sig('c' * 25), 3411 ] 3412 argument_group_signatures = [] 3413 usage = '''\ 3414 usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \ 3415[-y YYYYYYYYYYYYYYYYYYYYYYYYY] 3416 [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ] 3417 aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb 3418 ccccccccccccccccccccccccc 3419 ''' 3420 help = usage + '''\ 3421 3422 positional arguments: 3423 aaaaaaaaaaaaaaaaaaaaaaaaa 3424 bbbbbbbbbbbbbbbbbbbbbbbbb 3425 ccccccccccccccccccccccccc 3426 3427 optional arguments: 3428 -h, --help show this help message and exit 3429 -x XXXXXXXXXXXXXXXXXXXXXXXXX 3430 -y YYYYYYYYYYYYYYYYYYYYYYYYY 3431 -z ZZZZZZZZZZZZZZZZZZZZZZZZZ 3432 ''' 3433 version = '' 3434 3435 3436class TestHelpUsageOptionalsOnlyWrap(HelpTestCase): 3437 """Test usage messages where there are only optionals and they wrap""" 3438 3439 parser_signature = Sig(prog='PROG') 3440 argument_signatures = [ 3441 Sig('-x', metavar='X' * 25), 3442 Sig('-y', metavar='Y' * 25), 3443 Sig('-z', metavar='Z' * 25), 3444 ] 3445 argument_group_signatures = [] 3446 usage = '''\ 3447 usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \ 3448[-y YYYYYYYYYYYYYYYYYYYYYYYYY] 3449 [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ] 3450 ''' 3451 help = usage + '''\ 3452 3453 optional arguments: 3454 -h, --help show this help message and exit 3455 -x XXXXXXXXXXXXXXXXXXXXXXXXX 3456 -y YYYYYYYYYYYYYYYYYYYYYYYYY 3457 -z ZZZZZZZZZZZZZZZZZZZZZZZZZ 3458 ''' 3459 version = '' 3460 3461 3462class TestHelpUsagePositionalsOnlyWrap(HelpTestCase): 3463 """Test usage messages where there are only positionals and they wrap""" 3464 3465 parser_signature = Sig(prog='PROG', add_help=False) 3466 argument_signatures = [ 3467 Sig('a' * 25), 3468 Sig('b' * 25), 3469 Sig('c' * 25), 3470 ] 3471 argument_group_signatures = [] 3472 usage = '''\ 3473 usage: PROG aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb 3474 ccccccccccccccccccccccccc 3475 ''' 3476 help = usage + '''\ 3477 3478 positional arguments: 3479 aaaaaaaaaaaaaaaaaaaaaaaaa 3480 bbbbbbbbbbbbbbbbbbbbbbbbb 3481 ccccccccccccccccccccccccc 3482 ''' 3483 version = '' 3484 3485 3486class TestHelpVariableExpansion(HelpTestCase): 3487 """Test that variables are expanded properly in help messages""" 3488 3489 parser_signature = Sig(prog='PROG') 3490 argument_signatures = [ 3491 Sig('-x', type=int, 3492 help='x %(prog)s %(default)s %(type)s %%'), 3493 Sig('-y', action='store_const', default=42, const='XXX', 3494 help='y %(prog)s %(default)s %(const)s'), 3495 Sig('--foo', choices='abc', 3496 help='foo %(prog)s %(default)s %(choices)s'), 3497 Sig('--bar', default='baz', choices=[1, 2], metavar='BBB', 3498 help='bar %(prog)s %(default)s %(dest)s'), 3499 Sig('spam', help='spam %(prog)s %(default)s'), 3500 Sig('badger', default=0.5, help='badger %(prog)s %(default)s'), 3501 ] 3502 argument_group_signatures = [ 3503 (Sig('group'), [ 3504 Sig('-a', help='a %(prog)s %(default)s'), 3505 Sig('-b', default=-1, help='b %(prog)s %(default)s'), 3506 ]) 3507 ] 3508 usage = ('''\ 3509 usage: PROG [-h] [-x X] [-y] [--foo {a,b,c}] [--bar BBB] [-a A] [-b B] 3510 spam badger 3511 ''') 3512 help = usage + '''\ 3513 3514 positional arguments: 3515 spam spam PROG None 3516 badger badger PROG 0.5 3517 3518 optional arguments: 3519 -h, --help show this help message and exit 3520 -x X x PROG None int % 3521 -y y PROG 42 XXX 3522 --foo {a,b,c} foo PROG None a, b, c 3523 --bar BBB bar PROG baz bar 3524 3525 group: 3526 -a A a PROG None 3527 -b B b PROG -1 3528 ''' 3529 version = '' 3530 3531 3532class TestHelpVariableExpansionUsageSupplied(HelpTestCase): 3533 """Test that variables are expanded properly when usage= is present""" 3534 3535 parser_signature = Sig(prog='PROG', usage='%(prog)s FOO') 3536 argument_signatures = [] 3537 argument_group_signatures = [] 3538 usage = ('''\ 3539 usage: PROG FOO 3540 ''') 3541 help = usage + '''\ 3542 3543 optional arguments: 3544 -h, --help show this help message and exit 3545 ''' 3546 version = '' 3547 3548 3549class TestHelpVariableExpansionNoArguments(HelpTestCase): 3550 """Test that variables are expanded properly with no arguments""" 3551 3552 parser_signature = Sig(prog='PROG', add_help=False) 3553 argument_signatures = [] 3554 argument_group_signatures = [] 3555 usage = ('''\ 3556 usage: PROG 3557 ''') 3558 help = usage 3559 version = '' 3560 3561 3562class TestHelpSuppressUsage(HelpTestCase): 3563 """Test that items can be suppressed in usage messages""" 3564 3565 parser_signature = Sig(prog='PROG', usage=argparse.SUPPRESS) 3566 argument_signatures = [ 3567 Sig('--foo', help='foo help'), 3568 Sig('spam', help='spam help'), 3569 ] 3570 argument_group_signatures = [] 3571 help = '''\ 3572 positional arguments: 3573 spam spam help 3574 3575 optional arguments: 3576 -h, --help show this help message and exit 3577 --foo FOO foo help 3578 ''' 3579 usage = '' 3580 version = '' 3581 3582 3583class TestHelpSuppressOptional(HelpTestCase): 3584 """Test that optional arguments can be suppressed in help messages""" 3585 3586 parser_signature = Sig(prog='PROG', add_help=False) 3587 argument_signatures = [ 3588 Sig('--foo', help=argparse.SUPPRESS), 3589 Sig('spam', help='spam help'), 3590 ] 3591 argument_group_signatures = [] 3592 usage = '''\ 3593 usage: PROG spam 3594 ''' 3595 help = usage + '''\ 3596 3597 positional arguments: 3598 spam spam help 3599 ''' 3600 version = '' 3601 3602 3603class TestHelpSuppressOptionalGroup(HelpTestCase): 3604 """Test that optional groups can be suppressed in help messages""" 3605 3606 parser_signature = Sig(prog='PROG') 3607 argument_signatures = [ 3608 Sig('--foo', help='foo help'), 3609 Sig('spam', help='spam help'), 3610 ] 3611 argument_group_signatures = [ 3612 (Sig('group'), [Sig('--bar', help=argparse.SUPPRESS)]), 3613 ] 3614 usage = '''\ 3615 usage: PROG [-h] [--foo FOO] spam 3616 ''' 3617 help = usage + '''\ 3618 3619 positional arguments: 3620 spam spam help 3621 3622 optional arguments: 3623 -h, --help show this help message and exit 3624 --foo FOO foo help 3625 ''' 3626 version = '' 3627 3628 3629class TestHelpSuppressPositional(HelpTestCase): 3630 """Test that positional arguments can be suppressed in help messages""" 3631 3632 parser_signature = Sig(prog='PROG') 3633 argument_signatures = [ 3634 Sig('--foo', help='foo help'), 3635 Sig('spam', help=argparse.SUPPRESS), 3636 ] 3637 argument_group_signatures = [] 3638 usage = '''\ 3639 usage: PROG [-h] [--foo FOO] 3640 ''' 3641 help = usage + '''\ 3642 3643 optional arguments: 3644 -h, --help show this help message and exit 3645 --foo FOO foo help 3646 ''' 3647 version = '' 3648 3649 3650class TestHelpRequiredOptional(HelpTestCase): 3651 """Test that required options don't look optional""" 3652 3653 parser_signature = Sig(prog='PROG') 3654 argument_signatures = [ 3655 Sig('--foo', required=True, help='foo help'), 3656 ] 3657 argument_group_signatures = [] 3658 usage = '''\ 3659 usage: PROG [-h] --foo FOO 3660 ''' 3661 help = usage + '''\ 3662 3663 optional arguments: 3664 -h, --help show this help message and exit 3665 --foo FOO foo help 3666 ''' 3667 version = '' 3668 3669 3670class TestHelpAlternatePrefixChars(HelpTestCase): 3671 """Test that options display with different prefix characters""" 3672 3673 parser_signature = Sig(prog='PROG', prefix_chars='^;', add_help=False) 3674 argument_signatures = [ 3675 Sig('^^foo', action='store_true', help='foo help'), 3676 Sig(';b', ';;bar', help='bar help'), 3677 ] 3678 argument_group_signatures = [] 3679 usage = '''\ 3680 usage: PROG [^^foo] [;b BAR] 3681 ''' 3682 help = usage + '''\ 3683 3684 optional arguments: 3685 ^^foo foo help 3686 ;b BAR, ;;bar BAR bar help 3687 ''' 3688 version = '' 3689 3690 3691class TestHelpNoHelpOptional(HelpTestCase): 3692 """Test that the --help argument can be suppressed help messages""" 3693 3694 parser_signature = Sig(prog='PROG', add_help=False) 3695 argument_signatures = [ 3696 Sig('--foo', help='foo help'), 3697 Sig('spam', help='spam help'), 3698 ] 3699 argument_group_signatures = [] 3700 usage = '''\ 3701 usage: PROG [--foo FOO] spam 3702 ''' 3703 help = usage + '''\ 3704 3705 positional arguments: 3706 spam spam help 3707 3708 optional arguments: 3709 --foo FOO foo help 3710 ''' 3711 version = '' 3712 3713 3714class TestHelpVersionOptional(HelpTestCase): 3715 """Test that the --version argument can be suppressed help messages""" 3716 3717 parser_signature = Sig(prog='PROG', version='1.0') 3718 argument_signatures = [ 3719 Sig('--foo', help='foo help'), 3720 Sig('spam', help='spam help'), 3721 ] 3722 argument_group_signatures = [] 3723 usage = '''\ 3724 usage: PROG [-h] [-v] [--foo FOO] spam 3725 ''' 3726 help = usage + '''\ 3727 3728 positional arguments: 3729 spam spam help 3730 3731 optional arguments: 3732 -h, --help show this help message and exit 3733 -v, --version show program's version number and exit 3734 --foo FOO foo help 3735 ''' 3736 version = '''\ 3737 1.0 3738 ''' 3739 3740 3741class TestHelpNone(HelpTestCase): 3742 """Test that no errors occur if no help is specified""" 3743 3744 parser_signature = Sig(prog='PROG') 3745 argument_signatures = [ 3746 Sig('--foo'), 3747 Sig('spam'), 3748 ] 3749 argument_group_signatures = [] 3750 usage = '''\ 3751 usage: PROG [-h] [--foo FOO] spam 3752 ''' 3753 help = usage + '''\ 3754 3755 positional arguments: 3756 spam 3757 3758 optional arguments: 3759 -h, --help show this help message and exit 3760 --foo FOO 3761 ''' 3762 version = '' 3763 3764 3765class TestHelpTupleMetavar(HelpTestCase): 3766 """Test specifying metavar as a tuple""" 3767 3768 parser_signature = Sig(prog='PROG') 3769 argument_signatures = [ 3770 Sig('-w', help='w', nargs='+', metavar=('W1', 'W2')), 3771 Sig('-x', help='x', nargs='*', metavar=('X1', 'X2')), 3772 Sig('-y', help='y', nargs=3, metavar=('Y1', 'Y2', 'Y3')), 3773 Sig('-z', help='z', nargs='?', metavar=('Z1', )), 3774 ] 3775 argument_group_signatures = [] 3776 usage = '''\ 3777 usage: PROG [-h] [-w W1 [W2 ...]] [-x [X1 [X2 ...]]] [-y Y1 Y2 Y3] \ 3778[-z [Z1]] 3779 ''' 3780 help = usage + '''\ 3781 3782 optional arguments: 3783 -h, --help show this help message and exit 3784 -w W1 [W2 ...] w 3785 -x [X1 [X2 ...]] x 3786 -y Y1 Y2 Y3 y 3787 -z [Z1] z 3788 ''' 3789 version = '' 3790 3791 3792class TestHelpRawText(HelpTestCase): 3793 """Test the RawTextHelpFormatter""" 3794 3795 parser_signature = Sig( 3796 prog='PROG', formatter_class=argparse.RawTextHelpFormatter, 3797 description='Keep the formatting\n' 3798 ' exactly as it is written\n' 3799 '\n' 3800 'here\n') 3801 3802 argument_signatures = [ 3803 Sig('--foo', help=' foo help should also\n' 3804 'appear as given here'), 3805 Sig('spam', help='spam help'), 3806 ] 3807 argument_group_signatures = [ 3808 (Sig('title', description=' This text\n' 3809 ' should be indented\n' 3810 ' exactly like it is here\n'), 3811 [Sig('--bar', help='bar help')]), 3812 ] 3813 usage = '''\ 3814 usage: PROG [-h] [--foo FOO] [--bar BAR] spam 3815 ''' 3816 help = usage + '''\ 3817 3818 Keep the formatting 3819 exactly as it is written 3820 3821 here 3822 3823 positional arguments: 3824 spam spam help 3825 3826 optional arguments: 3827 -h, --help show this help message and exit 3828 --foo FOO foo help should also 3829 appear as given here 3830 3831 title: 3832 This text 3833 should be indented 3834 exactly like it is here 3835 3836 --bar BAR bar help 3837 ''' 3838 version = '' 3839 3840 3841class TestHelpRawDescription(HelpTestCase): 3842 """Test the RawTextHelpFormatter""" 3843 3844 parser_signature = Sig( 3845 prog='PROG', formatter_class=argparse.RawDescriptionHelpFormatter, 3846 description='Keep the formatting\n' 3847 ' exactly as it is written\n' 3848 '\n' 3849 'here\n') 3850 3851 argument_signatures = [ 3852 Sig('--foo', help=' foo help should not\n' 3853 ' retain this odd formatting'), 3854 Sig('spam', help='spam help'), 3855 ] 3856 argument_group_signatures = [ 3857 (Sig('title', description=' This text\n' 3858 ' should be indented\n' 3859 ' exactly like it is here\n'), 3860 [Sig('--bar', help='bar help')]), 3861 ] 3862 usage = '''\ 3863 usage: PROG [-h] [--foo FOO] [--bar BAR] spam 3864 ''' 3865 help = usage + '''\ 3866 3867 Keep the formatting 3868 exactly as it is written 3869 3870 here 3871 3872 positional arguments: 3873 spam spam help 3874 3875 optional arguments: 3876 -h, --help show this help message and exit 3877 --foo FOO foo help should not retain this odd formatting 3878 3879 title: 3880 This text 3881 should be indented 3882 exactly like it is here 3883 3884 --bar BAR bar help 3885 ''' 3886 version = '' 3887 3888 3889class TestHelpArgumentDefaults(HelpTestCase): 3890 """Test the ArgumentDefaultsHelpFormatter""" 3891 3892 parser_signature = Sig( 3893 prog='PROG', formatter_class=argparse.ArgumentDefaultsHelpFormatter, 3894 description='description') 3895 3896 argument_signatures = [ 3897 Sig('--foo', help='foo help - oh and by the way, %(default)s'), 3898 Sig('--bar', action='store_true', help='bar help'), 3899 Sig('spam', help='spam help'), 3900 Sig('badger', nargs='?', default='wooden', help='badger help'), 3901 ] 3902 argument_group_signatures = [ 3903 (Sig('title', description='description'), 3904 [Sig('--baz', type=int, default=42, help='baz help')]), 3905 ] 3906 usage = '''\ 3907 usage: PROG [-h] [--foo FOO] [--bar] [--baz BAZ] spam [badger] 3908 ''' 3909 help = usage + '''\ 3910 3911 description 3912 3913 positional arguments: 3914 spam spam help 3915 badger badger help (default: wooden) 3916 3917 optional arguments: 3918 -h, --help show this help message and exit 3919 --foo FOO foo help - oh and by the way, None 3920 --bar bar help (default: False) 3921 3922 title: 3923 description 3924 3925 --baz BAZ baz help (default: 42) 3926 ''' 3927 version = '' 3928 3929class TestHelpVersionAction(HelpTestCase): 3930 """Test the default help for the version action""" 3931 3932 parser_signature = Sig(prog='PROG', description='description') 3933 argument_signatures = [Sig('-V', '--version', action='version', version='3.6')] 3934 argument_group_signatures = [] 3935 usage = '''\ 3936 usage: PROG [-h] [-V] 3937 ''' 3938 help = usage + '''\ 3939 3940 description 3941 3942 optional arguments: 3943 -h, --help show this help message and exit 3944 -V, --version show program's version number and exit 3945 ''' 3946 version = '' 3947 3948class TestHelpSubparsersOrdering(HelpTestCase): 3949 """Test ordering of subcommands in help matches the code""" 3950 parser_signature = Sig(prog='PROG', 3951 description='display some subcommands', 3952 version='0.1') 3953 3954 subparsers_signatures = [Sig(name=name) 3955 for name in ('a', 'b', 'c', 'd', 'e')] 3956 3957 usage = '''\ 3958 usage: PROG [-h] [-v] {a,b,c,d,e} ... 3959 ''' 3960 3961 help = usage + '''\ 3962 3963 display some subcommands 3964 3965 positional arguments: 3966 {a,b,c,d,e} 3967 3968 optional arguments: 3969 -h, --help show this help message and exit 3970 -v, --version show program's version number and exit 3971 ''' 3972 3973 version = '''\ 3974 0.1 3975 ''' 3976 3977class TestHelpSubparsersWithHelpOrdering(HelpTestCase): 3978 """Test ordering of subcommands in help matches the code""" 3979 parser_signature = Sig(prog='PROG', 3980 description='display some subcommands', 3981 version='0.1') 3982 3983 subcommand_data = (('a', 'a subcommand help'), 3984 ('b', 'b subcommand help'), 3985 ('c', 'c subcommand help'), 3986 ('d', 'd subcommand help'), 3987 ('e', 'e subcommand help'), 3988 ) 3989 3990 subparsers_signatures = [Sig(name=name, help=help) 3991 for name, help in subcommand_data] 3992 3993 usage = '''\ 3994 usage: PROG [-h] [-v] {a,b,c,d,e} ... 3995 ''' 3996 3997 help = usage + '''\ 3998 3999 display some subcommands 4000 4001 positional arguments: 4002 {a,b,c,d,e} 4003 a a subcommand help 4004 b b subcommand help 4005 c c subcommand help 4006 d d subcommand help 4007 e e subcommand help 4008 4009 optional arguments: 4010 -h, --help show this help message and exit 4011 -v, --version show program's version number and exit 4012 ''' 4013 4014 version = '''\ 4015 0.1 4016 ''' 4017 4018 4019# ===================================== 4020# Optional/Positional constructor tests 4021# ===================================== 4022 4023class TestInvalidArgumentConstructors(TestCase): 4024 """Test a bunch of invalid Argument constructors""" 4025 4026 def assertTypeError(self, *args, **kwargs): 4027 parser = argparse.ArgumentParser() 4028 self.assertRaises(TypeError, parser.add_argument, 4029 *args, **kwargs) 4030 4031 def assertValueError(self, *args, **kwargs): 4032 parser = argparse.ArgumentParser() 4033 self.assertRaises(ValueError, parser.add_argument, 4034 *args, **kwargs) 4035 4036 def test_invalid_keyword_arguments(self): 4037 self.assertTypeError('-x', bar=None) 4038 self.assertTypeError('-y', callback='foo') 4039 self.assertTypeError('-y', callback_args=()) 4040 self.assertTypeError('-y', callback_kwargs={}) 4041 4042 def test_missing_destination(self): 4043 self.assertTypeError() 4044 for action in ['append', 'store']: 4045 self.assertTypeError(action=action) 4046 4047 def test_invalid_option_strings(self): 4048 self.assertValueError('--') 4049 self.assertValueError('---') 4050 4051 def test_invalid_type(self): 4052 self.assertValueError('--foo', type='int') 4053 self.assertValueError('--foo', type=(int, float)) 4054 4055 def test_invalid_action(self): 4056 self.assertValueError('-x', action='foo') 4057 self.assertValueError('foo', action='baz') 4058 self.assertValueError('--foo', action=('store', 'append')) 4059 parser = argparse.ArgumentParser() 4060 try: 4061 parser.add_argument("--foo", action="store-true") 4062 except ValueError: 4063 e = sys.exc_info()[1] 4064 expected = 'unknown action' 4065 msg = 'expected %r, found %r' % (expected, e) 4066 self.assertTrue(expected in str(e), msg) 4067 4068 def test_multiple_dest(self): 4069 parser = argparse.ArgumentParser() 4070 parser.add_argument(dest='foo') 4071 try: 4072 parser.add_argument('bar', dest='baz') 4073 except ValueError: 4074 e = sys.exc_info()[1] 4075 expected = 'dest supplied twice for positional argument' 4076 msg = 'expected %r, found %r' % (expected, e) 4077 self.assertTrue(expected in str(e), msg) 4078 4079 def test_no_argument_actions(self): 4080 for action in ['store_const', 'store_true', 'store_false', 4081 'append_const', 'count']: 4082 for attrs in [dict(type=int), dict(nargs='+'), 4083 dict(choices='ab')]: 4084 self.assertTypeError('-x', action=action, **attrs) 4085 4086 def test_no_argument_no_const_actions(self): 4087 # options with zero arguments 4088 for action in ['store_true', 'store_false', 'count']: 4089 4090 # const is always disallowed 4091 self.assertTypeError('-x', const='foo', action=action) 4092 4093 # nargs is always disallowed 4094 self.assertTypeError('-x', nargs='*', action=action) 4095 4096 def test_more_than_one_argument_actions(self): 4097 for action in ['store', 'append']: 4098 4099 # nargs=0 is disallowed 4100 self.assertValueError('-x', nargs=0, action=action) 4101 self.assertValueError('spam', nargs=0, action=action) 4102 4103 # const is disallowed with non-optional arguments 4104 for nargs in [1, '*', '+']: 4105 self.assertValueError('-x', const='foo', 4106 nargs=nargs, action=action) 4107 self.assertValueError('spam', const='foo', 4108 nargs=nargs, action=action) 4109 4110 def test_required_const_actions(self): 4111 for action in ['store_const', 'append_const']: 4112 4113 # nargs is always disallowed 4114 self.assertTypeError('-x', nargs='+', action=action) 4115 4116 def test_parsers_action_missing_params(self): 4117 self.assertTypeError('command', action='parsers') 4118 self.assertTypeError('command', action='parsers', prog='PROG') 4119 self.assertTypeError('command', action='parsers', 4120 parser_class=argparse.ArgumentParser) 4121 4122 def test_required_positional(self): 4123 self.assertTypeError('foo', required=True) 4124 4125 def test_user_defined_action(self): 4126 4127 class Success(Exception): 4128 pass 4129 4130 class Action(object): 4131 4132 def __init__(self, 4133 option_strings, 4134 dest, 4135 const, 4136 default, 4137 required=False): 4138 if dest == 'spam': 4139 if const is Success: 4140 if default is Success: 4141 raise Success() 4142 4143 def __call__(self, *args, **kwargs): 4144 pass 4145 4146 parser = argparse.ArgumentParser() 4147 self.assertRaises(Success, parser.add_argument, '--spam', 4148 action=Action, default=Success, const=Success) 4149 self.assertRaises(Success, parser.add_argument, 'spam', 4150 action=Action, default=Success, const=Success) 4151 4152# ================================ 4153# Actions returned by add_argument 4154# ================================ 4155 4156class TestActionsReturned(TestCase): 4157 4158 def test_dest(self): 4159 parser = argparse.ArgumentParser() 4160 action = parser.add_argument('--foo') 4161 self.assertEqual(action.dest, 'foo') 4162 action = parser.add_argument('-b', '--bar') 4163 self.assertEqual(action.dest, 'bar') 4164 action = parser.add_argument('-x', '-y') 4165 self.assertEqual(action.dest, 'x') 4166 4167 def test_misc(self): 4168 parser = argparse.ArgumentParser() 4169 action = parser.add_argument('--foo', nargs='?', const=42, 4170 default=84, type=int, choices=[1, 2], 4171 help='FOO', metavar='BAR', dest='baz') 4172 self.assertEqual(action.nargs, '?') 4173 self.assertEqual(action.const, 42) 4174 self.assertEqual(action.default, 84) 4175 self.assertEqual(action.type, int) 4176 self.assertEqual(action.choices, [1, 2]) 4177 self.assertEqual(action.help, 'FOO') 4178 self.assertEqual(action.metavar, 'BAR') 4179 self.assertEqual(action.dest, 'baz') 4180 4181 4182# ================================ 4183# Argument conflict handling tests 4184# ================================ 4185 4186class TestConflictHandling(TestCase): 4187 4188 def test_bad_type(self): 4189 self.assertRaises(ValueError, argparse.ArgumentParser, 4190 conflict_handler='foo') 4191 4192 def test_conflict_error(self): 4193 parser = argparse.ArgumentParser() 4194 parser.add_argument('-x') 4195 self.assertRaises(argparse.ArgumentError, 4196 parser.add_argument, '-x') 4197 parser.add_argument('--spam') 4198 self.assertRaises(argparse.ArgumentError, 4199 parser.add_argument, '--spam') 4200 4201 def test_resolve_error(self): 4202 get_parser = argparse.ArgumentParser 4203 parser = get_parser(prog='PROG', conflict_handler='resolve') 4204 4205 parser.add_argument('-x', help='OLD X') 4206 parser.add_argument('-x', help='NEW X') 4207 self.assertEqual(parser.format_help(), textwrap.dedent('''\ 4208 usage: PROG [-h] [-x X] 4209 4210 optional arguments: 4211 -h, --help show this help message and exit 4212 -x X NEW X 4213 ''')) 4214 4215 parser.add_argument('--spam', metavar='OLD_SPAM') 4216 parser.add_argument('--spam', metavar='NEW_SPAM') 4217 self.assertEqual(parser.format_help(), textwrap.dedent('''\ 4218 usage: PROG [-h] [-x X] [--spam NEW_SPAM] 4219 4220 optional arguments: 4221 -h, --help show this help message and exit 4222 -x X NEW X 4223 --spam NEW_SPAM 4224 ''')) 4225 4226 4227# ============================= 4228# Help and Version option tests 4229# ============================= 4230 4231class TestOptionalsHelpVersionActions(TestCase): 4232 """Test the help and version actions""" 4233 4234 def _get_error(self, func, *args, **kwargs): 4235 try: 4236 func(*args, **kwargs) 4237 except ArgumentParserError: 4238 return sys.exc_info()[1] 4239 else: 4240 self.assertRaises(ArgumentParserError, func, *args, **kwargs) 4241 4242 def assertPrintHelpExit(self, parser, args_str): 4243 self.assertEqual( 4244 parser.format_help(), 4245 self._get_error(parser.parse_args, args_str.split()).stdout) 4246 4247 def assertPrintVersionExit(self, parser, args_str): 4248 self.assertEqual( 4249 parser.format_version(), 4250 self._get_error(parser.parse_args, args_str.split()).stderr) 4251 4252 def assertArgumentParserError(self, parser, *args): 4253 self.assertRaises(ArgumentParserError, parser.parse_args, args) 4254 4255 def test_version(self): 4256 parser = ErrorRaisingArgumentParser(version='1.0') 4257 self.assertPrintHelpExit(parser, '-h') 4258 self.assertPrintHelpExit(parser, '--help') 4259 self.assertPrintVersionExit(parser, '-v') 4260 self.assertPrintVersionExit(parser, '--version') 4261 4262 def test_version_format(self): 4263 parser = ErrorRaisingArgumentParser(prog='PPP', version='%(prog)s 3.5') 4264 msg = self._get_error(parser.parse_args, ['-v']).stderr 4265 self.assertEqual('PPP 3.5\n', msg) 4266 4267 def test_version_no_help(self): 4268 parser = ErrorRaisingArgumentParser(add_help=False, version='1.0') 4269 self.assertArgumentParserError(parser, '-h') 4270 self.assertArgumentParserError(parser, '--help') 4271 self.assertPrintVersionExit(parser, '-v') 4272 self.assertPrintVersionExit(parser, '--version') 4273 4274 def test_version_action(self): 4275 parser = ErrorRaisingArgumentParser(prog='XXX') 4276 parser.add_argument('-V', action='version', version='%(prog)s 3.7') 4277 msg = self._get_error(parser.parse_args, ['-V']).stderr 4278 self.assertEqual('XXX 3.7\n', msg) 4279 4280 def test_no_help(self): 4281 parser = ErrorRaisingArgumentParser(add_help=False) 4282 self.assertArgumentParserError(parser, '-h') 4283 self.assertArgumentParserError(parser, '--help') 4284 self.assertArgumentParserError(parser, '-v') 4285 self.assertArgumentParserError(parser, '--version') 4286 4287 def test_alternate_help_version(self): 4288 parser = ErrorRaisingArgumentParser() 4289 parser.add_argument('-x', action='help') 4290 parser.add_argument('-y', action='version') 4291 self.assertPrintHelpExit(parser, '-x') 4292 self.assertPrintVersionExit(parser, '-y') 4293 self.assertArgumentParserError(parser, '-v') 4294 self.assertArgumentParserError(parser, '--version') 4295 4296 def test_help_version_extra_arguments(self): 4297 parser = ErrorRaisingArgumentParser(version='1.0') 4298 parser.add_argument('-x', action='store_true') 4299 parser.add_argument('y') 4300 4301 # try all combinations of valid prefixes and suffixes 4302 valid_prefixes = ['', '-x', 'foo', '-x bar', 'baz -x'] 4303 valid_suffixes = valid_prefixes + ['--bad-option', 'foo bar baz'] 4304 for prefix in valid_prefixes: 4305 for suffix in valid_suffixes: 4306 format = '%s %%s %s' % (prefix, suffix) 4307 self.assertPrintHelpExit(parser, format % '-h') 4308 self.assertPrintHelpExit(parser, format % '--help') 4309 self.assertPrintVersionExit(parser, format % '-v') 4310 self.assertPrintVersionExit(parser, format % '--version') 4311 4312 4313# ====================== 4314# str() and repr() tests 4315# ====================== 4316 4317class TestStrings(TestCase): 4318 """Test str() and repr() on Optionals and Positionals""" 4319 4320 def assertStringEqual(self, obj, result_string): 4321 for func in [str, repr]: 4322 self.assertEqual(func(obj), result_string) 4323 4324 def test_optional(self): 4325 option = argparse.Action( 4326 option_strings=['--foo', '-a', '-b'], 4327 dest='b', 4328 type='int', 4329 nargs='+', 4330 default=42, 4331 choices=[1, 2, 3], 4332 help='HELP', 4333 metavar='METAVAR') 4334 string = ( 4335 "Action(option_strings=['--foo', '-a', '-b'], dest='b', " 4336 "nargs='+', const=None, default=42, type='int', " 4337 "choices=[1, 2, 3], help='HELP', metavar='METAVAR')") 4338 self.assertStringEqual(option, string) 4339 4340 def test_argument(self): 4341 argument = argparse.Action( 4342 option_strings=[], 4343 dest='x', 4344 type=float, 4345 nargs='?', 4346 default=2.5, 4347 choices=[0.5, 1.5, 2.5], 4348 help='H HH H', 4349 metavar='MV MV MV') 4350 string = ( 4351 "Action(option_strings=[], dest='x', nargs='?', " 4352 "const=None, default=2.5, type=%r, choices=[0.5, 1.5, 2.5], " 4353 "help='H HH H', metavar='MV MV MV')" % float) 4354 self.assertStringEqual(argument, string) 4355 4356 def test_namespace(self): 4357 ns = argparse.Namespace(foo=42, bar='spam') 4358 string = "Namespace(bar='spam', foo=42)" 4359 self.assertStringEqual(ns, string) 4360 4361 def test_parser(self): 4362 parser = argparse.ArgumentParser(prog='PROG') 4363 string = ( 4364 "ArgumentParser(prog='PROG', usage=None, description=None, " 4365 "version=None, formatter_class=%r, conflict_handler='error', " 4366 "add_help=True)" % argparse.HelpFormatter) 4367 self.assertStringEqual(parser, string) 4368 4369# =============== 4370# Namespace tests 4371# =============== 4372 4373class TestNamespace(TestCase): 4374 4375 def test_constructor(self): 4376 ns = argparse.Namespace() 4377 self.assertRaises(AttributeError, getattr, ns, 'x') 4378 4379 ns = argparse.Namespace(a=42, b='spam') 4380 self.assertEqual(ns.a, 42) 4381 self.assertEqual(ns.b, 'spam') 4382 4383 def test_equality(self): 4384 ns1 = argparse.Namespace(a=1, b=2) 4385 ns2 = argparse.Namespace(b=2, a=1) 4386 ns3 = argparse.Namespace(a=1) 4387 ns4 = argparse.Namespace(b=2) 4388 4389 self.assertEqual(ns1, ns2) 4390 self.assertNotEqual(ns1, ns3) 4391 self.assertNotEqual(ns1, ns4) 4392 self.assertNotEqual(ns2, ns3) 4393 self.assertNotEqual(ns2, ns4) 4394 self.assertTrue(ns1 != ns3) 4395 self.assertTrue(ns1 != ns4) 4396 self.assertTrue(ns2 != ns3) 4397 self.assertTrue(ns2 != ns4) 4398 4399 4400# =================== 4401# File encoding tests 4402# =================== 4403 4404class TestEncoding(TestCase): 4405 4406 def _test_module_encoding(self, path): 4407 path, _ = os.path.splitext(path) 4408 path += ".py" 4409 with codecs.open(path, 'r', 'utf8') as f: 4410 f.read() 4411 4412 def test_argparse_module_encoding(self): 4413 self._test_module_encoding(argparse.__file__) 4414 4415 def test_test_argparse_module_encoding(self): 4416 self._test_module_encoding(__file__) 4417 4418# =================== 4419# ArgumentError tests 4420# =================== 4421 4422class TestArgumentError(TestCase): 4423 4424 def test_argument_error(self): 4425 msg = "my error here" 4426 error = argparse.ArgumentError(None, msg) 4427 self.assertEqual(str(error), msg) 4428 4429# ======================= 4430# ArgumentTypeError tests 4431# ======================= 4432 4433class TestArgumentTypeError(TestCase): 4434 4435 def test_argument_type_error(self): 4436 4437 def spam(string): 4438 raise argparse.ArgumentTypeError('spam!') 4439 4440 parser = ErrorRaisingArgumentParser(prog='PROG', add_help=False) 4441 parser.add_argument('x', type=spam) 4442 try: 4443 parser.parse_args(['XXX']) 4444 except ArgumentParserError: 4445 expected = 'usage: PROG x\nPROG: error: argument x: spam!\n' 4446 msg = sys.exc_info()[1].stderr 4447 self.assertEqual(expected, msg) 4448 else: 4449 self.fail() 4450 4451# ================================================ 4452# Check that the type function is called only once 4453# ================================================ 4454 4455class TestTypeFunctionCallOnlyOnce(TestCase): 4456 4457 def test_type_function_call_only_once(self): 4458 def spam(string_to_convert): 4459 self.assertEqual(string_to_convert, 'spam!') 4460 return 'foo_converted' 4461 4462 parser = argparse.ArgumentParser() 4463 parser.add_argument('--foo', type=spam, default='bar') 4464 args = parser.parse_args('--foo spam!'.split()) 4465 self.assertEqual(NS(foo='foo_converted'), args) 4466 4467# ================================================================== 4468# Check semantics regarding the default argument and type conversion 4469# ================================================================== 4470 4471class TestTypeFunctionCalledOnDefault(TestCase): 4472 4473 def test_type_function_call_with_non_string_default(self): 4474 def spam(int_to_convert): 4475 self.assertEqual(int_to_convert, 0) 4476 return 'foo_converted' 4477 4478 parser = argparse.ArgumentParser() 4479 parser.add_argument('--foo', type=spam, default=0) 4480 args = parser.parse_args([]) 4481 # foo should *not* be converted because its default is not a string. 4482 self.assertEqual(NS(foo=0), args) 4483 4484 def test_type_function_call_with_string_default(self): 4485 def spam(int_to_convert): 4486 return 'foo_converted' 4487 4488 parser = argparse.ArgumentParser() 4489 parser.add_argument('--foo', type=spam, default='0') 4490 args = parser.parse_args([]) 4491 # foo is converted because its default is a string. 4492 self.assertEqual(NS(foo='foo_converted'), args) 4493 4494 def test_no_double_type_conversion_of_default(self): 4495 def extend(str_to_convert): 4496 return str_to_convert + '*' 4497 4498 parser = argparse.ArgumentParser() 4499 parser.add_argument('--test', type=extend, default='*') 4500 args = parser.parse_args([]) 4501 # The test argument will be two stars, one coming from the default 4502 # value and one coming from the type conversion being called exactly 4503 # once. 4504 self.assertEqual(NS(test='**'), args) 4505 4506 def test_issue_15906(self): 4507 # Issue #15906: When action='append', type=str, default=[] are 4508 # providing, the dest value was the string representation "[]" when it 4509 # should have been an empty list. 4510 parser = argparse.ArgumentParser() 4511 parser.add_argument('--test', dest='test', type=str, 4512 default=[], action='append') 4513 args = parser.parse_args([]) 4514 self.assertEqual(args.test, []) 4515 4516# ====================== 4517# parse_known_args tests 4518# ====================== 4519 4520class TestParseKnownArgs(TestCase): 4521 4522 def test_arguments_tuple(self): 4523 parser = argparse.ArgumentParser() 4524 parser.parse_args(()) 4525 4526 def test_arguments_list(self): 4527 parser = argparse.ArgumentParser() 4528 parser.parse_args([]) 4529 4530 def test_arguments_tuple_positional(self): 4531 parser = argparse.ArgumentParser() 4532 parser.add_argument('x') 4533 parser.parse_args(('x',)) 4534 4535 def test_arguments_list_positional(self): 4536 parser = argparse.ArgumentParser() 4537 parser.add_argument('x') 4538 parser.parse_args(['x']) 4539 4540 def test_optionals(self): 4541 parser = argparse.ArgumentParser() 4542 parser.add_argument('--foo') 4543 args, extras = parser.parse_known_args('--foo F --bar --baz'.split()) 4544 self.assertEqual(NS(foo='F'), args) 4545 self.assertEqual(['--bar', '--baz'], extras) 4546 4547 def test_mixed(self): 4548 parser = argparse.ArgumentParser() 4549 parser.add_argument('-v', nargs='?', const=1, type=int) 4550 parser.add_argument('--spam', action='store_false') 4551 parser.add_argument('badger') 4552 4553 argv = ["B", "C", "--foo", "-v", "3", "4"] 4554 args, extras = parser.parse_known_args(argv) 4555 self.assertEqual(NS(v=3, spam=True, badger="B"), args) 4556 self.assertEqual(["C", "--foo", "4"], extras) 4557 4558# ========================== 4559# add_argument metavar tests 4560# ========================== 4561 4562class TestAddArgumentMetavar(TestCase): 4563 4564 EXPECTED_MESSAGE = "length of metavar tuple does not match nargs" 4565 4566 def do_test_no_exception(self, nargs, metavar): 4567 parser = argparse.ArgumentParser() 4568 parser.add_argument("--foo", nargs=nargs, metavar=metavar) 4569 4570 def do_test_exception(self, nargs, metavar): 4571 parser = argparse.ArgumentParser() 4572 with self.assertRaises(ValueError) as cm: 4573 parser.add_argument("--foo", nargs=nargs, metavar=metavar) 4574 self.assertEqual(cm.exception.args[0], self.EXPECTED_MESSAGE) 4575 4576 # Unit tests for different values of metavar when nargs=None 4577 4578 def test_nargs_None_metavar_string(self): 4579 self.do_test_no_exception(nargs=None, metavar="1") 4580 4581 def test_nargs_None_metavar_length0(self): 4582 self.do_test_exception(nargs=None, metavar=tuple()) 4583 4584 def test_nargs_None_metavar_length1(self): 4585 self.do_test_no_exception(nargs=None, metavar=("1")) 4586 4587 def test_nargs_None_metavar_length2(self): 4588 self.do_test_exception(nargs=None, metavar=("1", "2")) 4589 4590 def test_nargs_None_metavar_length3(self): 4591 self.do_test_exception(nargs=None, metavar=("1", "2", "3")) 4592 4593 # Unit tests for different values of metavar when nargs=? 4594 4595 def test_nargs_optional_metavar_string(self): 4596 self.do_test_no_exception(nargs="?", metavar="1") 4597 4598 def test_nargs_optional_metavar_length0(self): 4599 self.do_test_exception(nargs="?", metavar=tuple()) 4600 4601 def test_nargs_optional_metavar_length1(self): 4602 self.do_test_no_exception(nargs="?", metavar=("1")) 4603 4604 def test_nargs_optional_metavar_length2(self): 4605 self.do_test_exception(nargs="?", metavar=("1", "2")) 4606 4607 def test_nargs_optional_metavar_length3(self): 4608 self.do_test_exception(nargs="?", metavar=("1", "2", "3")) 4609 4610 # Unit tests for different values of metavar when nargs=* 4611 4612 def test_nargs_zeroormore_metavar_string(self): 4613 self.do_test_no_exception(nargs="*", metavar="1") 4614 4615 def test_nargs_zeroormore_metavar_length0(self): 4616 self.do_test_exception(nargs="*", metavar=tuple()) 4617 4618 def test_nargs_zeroormore_metavar_length1(self): 4619 self.do_test_no_exception(nargs="*", metavar=("1")) 4620 4621 def test_nargs_zeroormore_metavar_length2(self): 4622 self.do_test_no_exception(nargs="*", metavar=("1", "2")) 4623 4624 def test_nargs_zeroormore_metavar_length3(self): 4625 self.do_test_exception(nargs="*", metavar=("1", "2", "3")) 4626 4627 # Unit tests for different values of metavar when nargs=+ 4628 4629 def test_nargs_oneormore_metavar_string(self): 4630 self.do_test_no_exception(nargs="+", metavar="1") 4631 4632 def test_nargs_oneormore_metavar_length0(self): 4633 self.do_test_exception(nargs="+", metavar=tuple()) 4634 4635 def test_nargs_oneormore_metavar_length1(self): 4636 self.do_test_no_exception(nargs="+", metavar=("1")) 4637 4638 def test_nargs_oneormore_metavar_length2(self): 4639 self.do_test_no_exception(nargs="+", metavar=("1", "2")) 4640 4641 def test_nargs_oneormore_metavar_length3(self): 4642 self.do_test_exception(nargs="+", metavar=("1", "2", "3")) 4643 4644 # Unit tests for different values of metavar when nargs=... 4645 4646 def test_nargs_remainder_metavar_string(self): 4647 self.do_test_no_exception(nargs="...", metavar="1") 4648 4649 def test_nargs_remainder_metavar_length0(self): 4650 self.do_test_no_exception(nargs="...", metavar=tuple()) 4651 4652 def test_nargs_remainder_metavar_length1(self): 4653 self.do_test_no_exception(nargs="...", metavar=("1")) 4654 4655 def test_nargs_remainder_metavar_length2(self): 4656 self.do_test_no_exception(nargs="...", metavar=("1", "2")) 4657 4658 def test_nargs_remainder_metavar_length3(self): 4659 self.do_test_no_exception(nargs="...", metavar=("1", "2", "3")) 4660 4661 # Unit tests for different values of metavar when nargs=A... 4662 4663 def test_nargs_parser_metavar_string(self): 4664 self.do_test_no_exception(nargs="A...", metavar="1") 4665 4666 def test_nargs_parser_metavar_length0(self): 4667 self.do_test_exception(nargs="A...", metavar=tuple()) 4668 4669 def test_nargs_parser_metavar_length1(self): 4670 self.do_test_no_exception(nargs="A...", metavar=("1")) 4671 4672 def test_nargs_parser_metavar_length2(self): 4673 self.do_test_exception(nargs="A...", metavar=("1", "2")) 4674 4675 def test_nargs_parser_metavar_length3(self): 4676 self.do_test_exception(nargs="A...", metavar=("1", "2", "3")) 4677 4678 # Unit tests for different values of metavar when nargs=1 4679 4680 def test_nargs_1_metavar_string(self): 4681 self.do_test_no_exception(nargs=1, metavar="1") 4682 4683 def test_nargs_1_metavar_length0(self): 4684 self.do_test_exception(nargs=1, metavar=tuple()) 4685 4686 def test_nargs_1_metavar_length1(self): 4687 self.do_test_no_exception(nargs=1, metavar=("1")) 4688 4689 def test_nargs_1_metavar_length2(self): 4690 self.do_test_exception(nargs=1, metavar=("1", "2")) 4691 4692 def test_nargs_1_metavar_length3(self): 4693 self.do_test_exception(nargs=1, metavar=("1", "2", "3")) 4694 4695 # Unit tests for different values of metavar when nargs=2 4696 4697 def test_nargs_2_metavar_string(self): 4698 self.do_test_no_exception(nargs=2, metavar="1") 4699 4700 def test_nargs_2_metavar_length0(self): 4701 self.do_test_exception(nargs=2, metavar=tuple()) 4702 4703 def test_nargs_2_metavar_length1(self): 4704 self.do_test_no_exception(nargs=2, metavar=("1")) 4705 4706 def test_nargs_2_metavar_length2(self): 4707 self.do_test_no_exception(nargs=2, metavar=("1", "2")) 4708 4709 def test_nargs_2_metavar_length3(self): 4710 self.do_test_exception(nargs=2, metavar=("1", "2", "3")) 4711 4712 # Unit tests for different values of metavar when nargs=3 4713 4714 def test_nargs_3_metavar_string(self): 4715 self.do_test_no_exception(nargs=3, metavar="1") 4716 4717 def test_nargs_3_metavar_length0(self): 4718 self.do_test_exception(nargs=3, metavar=tuple()) 4719 4720 def test_nargs_3_metavar_length1(self): 4721 self.do_test_no_exception(nargs=3, metavar=("1")) 4722 4723 def test_nargs_3_metavar_length2(self): 4724 self.do_test_exception(nargs=3, metavar=("1", "2")) 4725 4726 def test_nargs_3_metavar_length3(self): 4727 self.do_test_no_exception(nargs=3, metavar=("1", "2", "3")) 4728 4729# ============================ 4730# from argparse import * tests 4731# ============================ 4732 4733class TestImportStar(TestCase): 4734 4735 def test(self): 4736 for name in argparse.__all__: 4737 self.assertTrue(hasattr(argparse, name)) 4738 4739 def test_all_exports_everything_but_modules(self): 4740 items = [ 4741 name 4742 for name, value in vars(argparse).items() 4743 if not name.startswith("_") 4744 if not inspect.ismodule(value) 4745 ] 4746 self.assertEqual(sorted(items), sorted(argparse.__all__)) 4747 4748def test_main(): 4749 # silence warnings about version argument - these are expected 4750 with test_support.check_warnings( 4751 ('The "version" argument to ArgumentParser is deprecated.', 4752 DeprecationWarning), 4753 ('The (format|print)_version method is deprecated', 4754 DeprecationWarning)): 4755 test_support.run_unittest(__name__) 4756 # Remove global references to avoid looking like we have refleaks. 4757 RFile.seen = {} 4758 WFile.seen = set() 4759 4760 4761 4762if __name__ == '__main__': 4763 test_main() 4764