it("negative number options present, so any neg number is an option", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-1'], {dest: 'one'});
parser.addArgument(['foo'], {nargs: '?'});
// negative number options present, so -1 is an option
args = parser.parseArgs(['-1', 'X']);
// Namespace(foo=None, one='X')
assert.equal(args.one, 'X');
// negative number options present, so -2 is an option
assert.throws(
function () {
parser.parseArgs(['-2']);
},
/Unrecognized arguments: -2/i
);
// negative number options present, so both -1s are options
assert.throws(
function () {
parser.parseArgs(['-1', '-1']);
},
/argument "-1": Expected one argument/i
);
args = parser.parseArgs(['--', '-f']);
// Namespace(foo='-f', one=None)
assert.equal(args.foo, '-f');
});
it('test specifying an args for an Optional, that accepts one or more', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ '-x' ], { nargs: '+' });
parser.addArgument([ '-y' ], { default: 'spam', nargs: '+', defaultValue: 'spam' });
args = parser.parseArgs([]);
assert.deepEqual(args, { y: 'spam', x: null });
args = parser.parseArgs([ '-x', 'a' ]);
assert.deepEqual(args, { y: 'spam', x: [ 'a' ] });
args = parser.parseArgs([ '-x', 'a', 'b' ]);
assert.deepEqual(args, { y: 'spam', x: [ 'a', 'b' ] });
args = parser.parseArgs([ '-y', 'a' ]);
assert.deepEqual(args, { y: [ 'a' ], x: null });
args = parser.parseArgs([ '-y', 'a', 'b' ]);
assert.deepEqual(args, { y: [ 'a', 'b' ], x: null });
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-x' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-y' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a', '-x' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a', '-y', 'b' ]);
});
});
it('test specifying the choices for an Optional', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ '-f' ], { choices: 'abc' });
parser.addArgument([ '-g' ], { type: 'int', choices: [ 0, 1, 2, 3, 4 ] });
args = parser.parseArgs([]);
assert.deepEqual(args, { g: null, f: null });
args = parser.parseArgs([ '-f', 'a' ]);
assert.deepEqual(args, { g: null, f: 'a' });
args = parser.parseArgs([ '-f', 'c' ]);
assert.deepEqual(args, { g: null, f: 'c' });
args = parser.parseArgs([ '-g', '0' ]);
assert.deepEqual(args, { g: 0, f: null });
args = parser.parseArgs([ '-g', '03' ]);
assert.deepEqual(args, { g: 3, f: null });
args = parser.parseArgs([ '-fb', '-g4' ]);
assert.deepEqual(args, { g: 4, f: 'b' });
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-f', 'd' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-fad' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-ga' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-g', '6' ]);
});
});
it('test specifying a positional with nargs=REMAINDER', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ 'x' ], {});
parser.addArgument([ 'y' ], { nargs: $$.REMAINDER });
parser.addArgument([ '-z' ], {});
args = parser.parseArgs([ 'X' ]);
assert.deepEqual(args, { y: [], x: 'X', z: null });
args = parser.parseArgs([ '-z', 'Z', 'X' ]);
assert.deepEqual(args, { y: [], x: 'X', z: 'Z' });
args = parser.parseArgs([ 'X', 'A', 'B', '-z', 'Z' ]);
assert.deepEqual(args, { y: [ 'A', 'B', '-z', 'Z' ], x: 'X', z: null });
args = parser.parseArgs([ 'X', 'Y', '--foo' ]);
assert.deepEqual(args, { y: [ 'Y', '--foo' ], x: 'X', z: null });
assert.throws(function () {
args = parser.parseArgs([]);
});
assert.throws(function () {
args = parser.parseArgs([ '-z' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-z', 'Z' ]);
});
});
it('test empty and space containing arguments', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ 'x' ], { nargs: '?' });
parser.addArgument([ '-y', '--yyy' ], { dest: 'y' });
args = parser.parseArgs([ '' ]);
assert.deepEqual(args, { y: null, x: '' });
args = parser.parseArgs([ 'a badger' ]);
assert.deepEqual(args, { y: null, x: 'a badger' });
args = parser.parseArgs([ '-a badger' ]);
assert.deepEqual(args, { y: null, x: '-a badger' });
args = parser.parseArgs([ '-y', '' ]);
assert.deepEqual(args, { y: '', x: null });
args = parser.parseArgs([ '-y', 'a badger' ]);
assert.deepEqual(args, { y: 'a badger', x: null });
args = parser.parseArgs([ '-y', '-a badger' ]);
assert.deepEqual(args, { y: '-a badger', x: null });
args = parser.parseArgs([ '--yyy=a badger' ]);
assert.deepEqual(args, { y: 'a badger', x: null });
args = parser.parseArgs([ '--yyy=-a badger' ]);
assert.deepEqual(args, { y: '-a badger', x: null });
assert.throws(function () {
args = parser.parseArgs([ '-y' ]);
});
});
it('test the append_const action for an Optional', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ '-b' ], { default: [ 'X' ],
action: 'appendConst',
const: 'Exception',
defaultValue: [ 'X' ],
constant: 'Exception' });
parser.addArgument([ '-c' ], { dest: 'b', action: 'append' });
args = parser.parseArgs([]);
assert.deepEqual(args, { b: [ 'X' ] });
args = parser.parseArgs([ '-b' ]);
assert.deepEqual(args, { b: [ 'X', 'Exception' ] });
args = parser.parseArgs([ '-b', '-cx', '-b', '-cyz' ]);
assert.deepEqual(args, { b: [ 'X', 'Exception', 'x', 'Exception', 'yz' ] });
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-c' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a', '-c' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-bx' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-b', 'x' ]);
});
});
it("getDefault() should get defaults", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']);
parser.addArgument(['-g', '--goo'], {defaultValue: 42});
assert.equal(parser.getDefault('goo'), 42);
assert.equal(parser.getDefault('help'), require('../lib/const').SUPPRESS);
});
it("should parse negative arguments", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']);
parser.addArgument([ 'bar' ], { type: 'int', });
args = parser.parseArgs(['-1']);
assert.equal(args.bar, -1);
});
it("should accept defaultValue for nargs:'*'", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']);
parser.addArgument(['bar'], { nargs: '*', defaultValue: 42});
args = parser.parseArgs([]);
assert.equal(args.bar, 42);
});
it("should parse multiple arguments", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']);
parser.addArgument(['--bar']);
args = parser.parseArgs('--foo 5 --bar 6'.split(' '));
assert.equal(args.foo, 5);
assert.equal(args.bar, 6);
});
it("should accept 0 defaultValue", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']);
parser.addArgument(['bar'], { nargs: '?', defaultValue: 0});
args = parser.parseArgs([]);
assert.equal(args.bar, 0);
// could also test for '', and false
});
it("should support pseudo-argument", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']);
parser.addArgument([ 'bar' ], { nargs: '+' });
args = parser.parseArgs([ '-f', 'foo', '--', '-f', 'bar' ]);
assert.equal(args.foo, 'foo');
assert.equal(args.bar.length, 2);
});
it("should drop down with empty args (positional arguments)", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']);
parser.addArgument([ 'baz']);
assert.throws(
function () {parser.parseArgs([]); },
// /too few arguments/
// change to more informative error message
/the following argument\(s\) are required: baz/i
);
});
it("should check argument type", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']);
parser.addArgument(['--bar' ], { type: 'int' });
assert.throws(function () {
parser.parseArgs('--bar bar'.split(' '));
});
assert.doesNotThrow(function () {
parser.parseArgs('--bar 1'.split(' '));
});
});
it("should handle user-defined type", function () {
function myType(arg) {
return arg;
}
parser = new ArgumentParser({debug: true});
parser.addArgument(['-x'], {type: myType});
parser.addArgument(['spam'], {type: myType});
args = parser.parseArgs(['a', '-x', 'b']);
assert.deepEqual(args, {x: myType('b'), spam: myType('a')});
args = parser.parseArgs(['-xf', 'g']);
assert.deepEqual(args, {x: myType('f'), spam: myType('g')});
});
it("should infer option destination from long and short options", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']); // from long option
parser.addArgument(['-g']); // from short option
parser.addArgument(['-x'], { dest: 'xxx' });// from dest keyword
args = parser.parseArgs(['-f', '1']);
assert.deepEqual(args, { foo: '1', g: null, xxx: null});
args = parser.parseArgs(['-g', '2']);
assert.deepEqual(args, { foo: null, g: '2', xxx: null});
args = parser.parseArgs(['-f', 1, '-g', 2, '-x', 3]);
assert.deepEqual(args, { foo: 1, g: 2, xxx: 3});
});
it('should handle positional metavar as an array', function () {
parser = new argparse.ArgumentParser({
prog: 'PROG'
});
parser.addArgument(['w'], {
help: 'w',
nargs: '+',
metavar: ['W1', 'W2']
});
parser.addArgument(['x'], {
help: 'x',
nargs: '*',
metavar: ['X1', 'X2']
});
parser.addArgument(['y'], {
help: 'y',
nargs: 3,
metavar: ['Y1', 'Y2', 'Y3']
});
parser.addArgument(['z'], {
help: 'z',
nargs: '?',
metavar: ['Z1']
});
helptext = parser.formatHelp();
console.log(helptext)
var ustring = 'PROG [-h] W1 [W2 ...] [X1 [X2 ...]] Y1 Y2 Y3 [Z1]';
ustring = ustring.replace(/\[/g, '\\[').replace(/\]/g, '\\]');
// have to escape all of those brackets
assert(helptext.match(new RegExp(ustring)));
assert(helptext.match(/Y1\|Y2\|Y3 y/g));
/*
usage: PROG [-h] W1 [W2 ...] [X1 [X2 ...]] Y1 Y2 Y3 [Z1]
positional arguments:
W1|W2 w
X1|X2 x
Y1|Y2|Y3 y
Z1 z
optional arguments:
-h, --help show this help message and exit
*/
});
it("should handle mixed positional and optional args", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-f', '--foo']);
parser.addArgument(['x']);
parser.addArgument(['y']);
args = parser.parseArgs(['X', 'Y']);
assert.deepEqual(args, {"foo": null, "x": "X", "y": "Y"});
args = parser.parseArgs(['-f', 'A', 'X', 'Y']);
assert.deepEqual(args, {"foo": "A", "x": "X", "y": "Y"});
args = parser.parseArgs(['X', '-f', 'A', 'Y']);
assert.deepEqual(args, {"foo": "A", "x": "X", "y": "Y"});
// was giving: Error: _mocha: error: Unrecognized arguments: X.
});
it("should handle builtin types", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['--eggs'], {type: 'int'});
parser.addArgument(['spam'], {type: 'float'});
args = parser.parseArgs(['--eggs=42', '42']);
assert.deepEqual(args, {eggs: 42, spam: 42.0});
args = parser.parseArgs(['1024.675']);
assert.deepEqual(args, {eggs: null, spam: 1024.675});
assert.throws(
function () { parser.parseArgs(['--eggs', 'a']); },
/Invalid int value: a/i
);
});
it("No negative number options; neg number is positional argument", function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(['-x'], {dest: 'x'});
parser.addArgument(['foo'], {nargs: '?'});
// no negative number options, so -1 is a positional argument
args = parser.parseArgs(['-x', '-1']);
// Namespace(foo=None, x='-1')
assert.equal(args.x, '-1');
// no negative number options, so -1 and -5 are positional arguments
args = parser.parseArgs(['-x', '-1', '-5']);
// Namespace(foo='-5', x='-1') order not determined
assert.equal(args.x, '-1');
assert.equal(args.foo, '-5');
});
it('test specifying the 3 args for an Optional', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ '-x' ], { nargs: 3 });
args = parser.parseArgs([]);
assert.deepEqual(args, { x: null });
args = parser.parseArgs([ '-x', 'a', 'b', 'c' ]);
assert.deepEqual(args, { x: [ 'a', 'b', 'c' ] });
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-x' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-x', 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-x', 'a', 'b' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a', '-x' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a', '-x', 'b' ]);
});
});
it('test a set of single-character choices', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ 'spam' ], { choices: [ 'a', 'c', 'b', 'e', 'd', 'g', 'f' ] });
args = parser.parseArgs([ 'a' ]);
assert.deepEqual(args, { spam: 'a' });
args = parser.parseArgs([ 'g' ]);
assert.deepEqual(args, { spam: 'g' });
assert.throws(function () {
args = parser.parseArgs([]);
});
assert.throws(function () {
args = parser.parseArgs([ '--foo' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'h' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '42' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'ef' ]);
});
});
it('test the append action for an Optional', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument(
[ '--baz' ],
{ default: [ 'X' ], action: 'append', defaultValue: [ 'X' ] }
);
args = parser.parseArgs([]);
assert.deepEqual(args, { baz: [ 'X' ] });
args = parser.parseArgs([ '--baz', 'a' ]);
assert.deepEqual(args, { baz: [ 'X', 'a' ] });
args = parser.parseArgs([ '--baz', 'a', '--baz', 'b' ]);
assert.deepEqual(args, { baz: [ 'X', 'a', 'b' ] });
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '--baz' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a', '--baz' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '--baz', 'a', 'b' ]);
});
});
it('test an Optional with a multi-character single-dash option string', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ '-foo' ], {});
args = parser.parseArgs([]);
assert.deepEqual(args, { foo: null });
args = parser.parseArgs([ '-foo', 'a' ]);
assert.deepEqual(args, { foo: 'a' });
args = parser.parseArgs([ '-foo', '-1' ]);
assert.deepEqual(args, { foo: '-1' });
args = parser.parseArgs([ '-fo', 'a' ]);
assert.deepEqual(args, { foo: 'a' });
args = parser.parseArgs([ '-f', 'a' ]);
assert.deepEqual(args, { foo: 'a' });
assert.throws(function () {
args = parser.parseArgs([ '-foo' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '--foo' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-foo', '--foo' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-foo', '-y' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-fooa' ]);
});
});
it('test a set of integer choices', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ 'spam' ], {
type: 'int',
choices: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 ]
});
args = parser.parseArgs([ '4' ]);
assert.deepEqual(args, { spam: 4 });
args = parser.parseArgs([ '15' ]);
assert.deepEqual(args, { spam: 15 });
assert.throws(function () {
args = parser.parseArgs([]);
});
assert.throws(function () {
args = parser.parseArgs([ '--foo' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'h' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '42' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'ef' ]);
});
});
it('test a combination of single- and double-dash option strings', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ '-v', '--verbose', '-n', '--noisy' ], { action: 'storeTrue' });
args = parser.parseArgs([]);
assert.deepEqual(args, { verbose: false });
args = parser.parseArgs([ '-v' ]);
assert.deepEqual(args, { verbose: true });
args = parser.parseArgs([ '--verbose' ]);
assert.deepEqual(args, { verbose: true });
args = parser.parseArgs([ '-n' ]);
assert.deepEqual(args, { verbose: true });
args = parser.parseArgs([ '--noisy' ]);
assert.deepEqual(args, { verbose: true });
assert.throws(function () {
args = parser.parseArgs([ '--x', '--verbose' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-N' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-v', 'x' ]);
});
});
it('test an Optional with a short opt string', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ '-1' ], { dest: 'one' });
args = parser.parseArgs([]);
assert.deepEqual(args, { one: null });
args = parser.parseArgs([ '-1', 'a' ]);
assert.deepEqual(args, { one: 'a' });
args = parser.parseArgs([ '-1a' ]);
assert.deepEqual(args, { one: 'a' });
args = parser.parseArgs([ '-1-2' ]);
assert.deepEqual(args, { one: '-2' });
assert.throws(function () {
args = parser.parseArgs([ '-1' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-1', '--foo' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-1', '-y' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-1', '-1' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-1', '-2' ]);
});
});
it('test an Optional with a double-dash option string', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ '--foo' ], {});
args = parser.parseArgs([]);
assert.deepEqual(args, { foo: null });
args = parser.parseArgs([ '--foo', 'a' ]);
assert.deepEqual(args, { foo: 'a' });
args = parser.parseArgs([ '--foo=a' ]);
assert.deepEqual(args, { foo: 'a' });
args = parser.parseArgs([ '--foo', '-2.5' ]);
assert.deepEqual(args, { foo: '-2.5' });
args = parser.parseArgs([ '--foo=-2.5' ]);
assert.deepEqual(args, { foo: '-2.5' });
assert.throws(function () {
args = parser.parseArgs([ '--foo' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-f' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '-f', 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '--foo', '-x' ]);
});
assert.throws(function () {
args = parser.parseArgs([ '--foo', '--bar' ]);
});
});
it('test specifying a default for an Optional', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ '-x' ], {});
parser.addArgument([ '-y' ], { default: 42, defaultValue: 42 });
args = parser.parseArgs([]);
assert.deepEqual(args, { y: 42, x: null });
args = parser.parseArgs([ '-xx' ]);
assert.deepEqual(args, { y: 42, x: 'x' });
args = parser.parseArgs([ '-yy' ]);
assert.deepEqual(args, { y: 'y', x: null });
assert.throws(function () {
args = parser.parseArgs([ 'a' ]);
});
});
it('test a `nargs` + `append` combination. Not obvious result - nested array', function () {
parser = new ArgumentParser({debug: true});
parser.addArgument([ 'foo' ], { action: 'append', nargs: '+' });
args = parser.parseArgs([ 'a', 'b' ]);
// YES, NESTED array, don't try to 'fix' it.
assert.deepEqual(args, { foo: [[ 'a', 'b' ]] });
});