node_modules/node-static/node_modules/optimist/test/parse.js

   1 var optimist = require('../index');
   2 var path = require('path');
   3 var test = require('tap').test;
   4
   5 var $0 = 'node ./' + path.relative(process.cwd(), __filename);
   6
   7 test('short boolean', function (t) {
   8     var parse = optimist.parse([ '-b' ]);
   9     t.same(parse, { b : true, _ : [], $0 : $0 });
  10     t.same(typeof parse.b, 'boolean');
  11     t.end();
  12 });
  13
  14 test('long boolean', function (t) {
  15     t.same(
  16         optimist.parse([ '--bool' ]),
  17         { bool : true, _ : [], $0 : $0 }
  18     );
  19     t.end();
  20 });
  21
  22 test('bare', function (t) {
  23     t.same(
  24         optimist.parse([ 'foo', 'bar', 'baz' ]),
  25         { _ : [ 'foo', 'bar', 'baz' ], $0 : $0 }
  26     );
  27     t.end();
  28 });
  29
  30 test('short group', function (t) {
  31     t.same(
  32         optimist.parse([ '-cats' ]),
  33         { c : true, a : true, t : true, s : true, _ : [], $0 : $0 }
  34     );
  35     t.end();
  36 });
  37
  38 test('short group next', function (t) {
  39     t.same(
  40         optimist.parse([ '-cats', 'meow' ]),
  41         { c : true, a : true, t : true, s : 'meow', _ : [], $0 : $0 }
  42     );
  43     t.end();
  44 });
  45
  46 test('short capture', function (t) {
  47     t.same(
  48         optimist.parse([ '-h', 'localhost' ]),
  49         { h : 'localhost', _ : [], $0 : $0 }
  50     );
  51     t.end();
  52 });
  53
  54 test('short captures', function (t) {
  55     t.same(
  56         optimist.parse([ '-h', 'localhost', '-p', '555' ]),
  57         { h : 'localhost', p : 555, _ : [], $0 : $0 }
  58     );
  59     t.end();
  60 });
  61
  62 test('long capture sp', function (t) {
  63     t.same(
  64         optimist.parse([ '--pow', 'xixxle' ]),
  65         { pow : 'xixxle', _ : [], $0 : $0 }
  66     );
  67     t.end();
  68 });
  69
  70 test('long capture eq', function (t) {
  71     t.same(
  72         optimist.parse([ '--pow=xixxle' ]),
  73         { pow : 'xixxle', _ : [], $0 : $0 }
  74     );
  75     t.end()
  76 });
  77
  78 test('long captures sp', function (t) {
  79     t.same(
  80         optimist.parse([ '--host', 'localhost', '--port', '555' ]),
  81         { host : 'localhost', port : 555, _ : [], $0 : $0 }
  82     );
  83     t.end();
  84 });
  85
  86 test('long captures eq', function (t) {
  87     t.same(
  88         optimist.parse([ '--host=localhost', '--port=555' ]),
  89         { host : 'localhost', port : 555, _ : [], $0 : $0 }
  90     );
  91     t.end();
  92 });
  93
  94 test('mixed short bool and capture', function (t) {
  95     t.same(
  96         optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
  97         {
  98             f : true, p : 555, h : 'localhost',
  99             _ : [ 'script.js' ], $0 : $0,
 100         }
 101     );
 102     t.end();
 103 });
 104
 105 test('short and long', function (t) {
 106     t.same(
 107         optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
 108         {
 109             f : true, p : 555, h : 'localhost',
 110             _ : [ 'script.js' ], $0 : $0,
 111         }
 112     );
 113     t.end();
 114 });
 115
 116 test('no', function (t) {
 117     t.same(
 118         optimist.parse([ '--no-moo' ]),
 119         { moo : false, _ : [], $0 : $0 }
 120     );
 121     t.end();
 122 });
 123
 124 test('multi', function (t) {
 125     t.same(
 126         optimist.parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]),
 127         { v : ['a','b','c'], _ : [], $0 : $0 }
 128     );
 129     t.end();
 130 });
 131
 132 test('comprehensive', function (t) {
 133     t.same(
 134         optimist.parse([
 135             '--name=meowmers', 'bare', '-cats', 'woo',
 136             '-h', 'awesome', '--multi=quux',
 137             '--key', 'value',
 138             '-b', '--bool', '--no-meep', '--multi=baz',
 139             '--', '--not-a-flag', 'eek'
 140         ]),
 141         {
 142             c : true,
 143             a : true,
 144             t : true,
 145             s : 'woo',
 146             h : 'awesome',
 147             b : true,
 148             bool : true,
 149             key : 'value',
 150             multi : [ 'quux', 'baz' ],
 151             meep : false,
 152             name : 'meowmers',
 153             _ : [ 'bare', '--not-a-flag', 'eek' ],
 154             $0 : $0
 155         }
 156     );
 157     t.end();
 158 });
 159
 160 test('nums', function (t) {
 161     var argv = optimist.parse([
 162         '-x', '1234',
 163         '-y', '5.67',
 164         '-z', '1e7',
 165         '-w', '10f',
 166         '--hex', '0xdeadbeef',
 167         '789',
 168     ]);
 169     t.same(argv, {
 170         x : 1234,
 171         y : 5.67,
 172         z : 1e7,
 173         w : '10f',
 174         hex : 0xdeadbeef,
 175         _ : [ 789 ],
 176         $0 : $0
 177     });
 178     t.same(typeof argv.x, 'number');
 179     t.same(typeof argv.y, 'number');
 180     t.same(typeof argv.z, 'number');
 181     t.same(typeof argv.w, 'string');
 182     t.same(typeof argv.hex, 'number');
 183     t.same(typeof argv._[0], 'number');
 184     t.end();
 185 });
 186
 187 test('flag boolean', function (t) {
 188     var parse = optimist([ '-t', 'moo' ]).boolean(['t']).argv;
 189     t.same(parse, { t : true, _ : [ 'moo' ], $0 : $0 });
 190     t.same(typeof parse.t, 'boolean');
 191     t.end();
 192 });
 193
 194 test('flag boolean value', function (t) {
 195     var parse = optimist(['--verbose', 'false', 'moo', '-t', 'true'])
 196         .boolean(['t', 'verbose']).default('verbose', true).argv;
 197
 198     t.same(parse, {
 199         verbose: false,
 200         t: true,
 201         _: ['moo'],
 202         $0 : $0
 203     });
 204
 205     t.same(typeof parse.verbose, 'boolean');
 206     t.same(typeof parse.t, 'boolean');
 207     t.end();
 208 });
 209
 210 test('flag boolean default false', function (t) {
 211     var parse = optimist(['moo'])
 212         .boolean(['t', 'verbose'])
 213         .default('verbose', false)
 214         .default('t', false).argv;
 215
 216     t.same(parse, {
 217         verbose: false,
 218         t: false,
 219         _: ['moo'],
 220         $0 : $0
 221     });
 222
 223     t.same(typeof parse.verbose, 'boolean');
 224     t.same(typeof parse.t, 'boolean');
 225     t.end();
 226
 227 });
 228
 229 test('boolean groups', function (t) {
 230     var parse = optimist([ '-x', '-z', 'one', 'two', 'three' ])
 231         .boolean(['x','y','z']).argv;
 232
 233     t.same(parse, {
 234         x : true,
 235         y : false,
 236         z : true,
 237         _ : [ 'one', 'two', 'three' ],
 238         $0 : $0
 239     });
 240
 241     t.same(typeof parse.x, 'boolean');
 242     t.same(typeof parse.y, 'boolean');
 243     t.same(typeof parse.z, 'boolean');
 244     t.end();
 245 });
 246
 247 test('newlines in params' , function (t) {
 248     var args = optimist.parse([ '-s', "X\nX" ])
 249     t.same(args, { _ : [], s : "X\nX", $0 : $0 });
 250
 251     // reproduce in bash:
 252     // VALUE="new
 253     // line"
 254     // node program.js --s="$VALUE"
 255     args = optimist.parse([ "--s=X\nX" ])
 256     t.same(args, { _ : [], s : "X\nX", $0 : $0 });
 257     t.end();
 258 });
 259
 260 test('strings' , function (t) {
 261     var s = optimist([ '-s', '0001234' ]).string('s').argv.s;
 262     t.same(s, '0001234');
 263     t.same(typeof s, 'string');
 264
 265     var x = optimist([ '-x', '56' ]).string('x').argv.x;
 266     t.same(x, '56');
 267     t.same(typeof x, 'string');
 268     t.end();
 269 });
 270
 271 test('stringArgs', function (t) {
 272     var s = optimist([ '  ', '  ' ]).string('_').argv._;
 273     t.same(s.length, 2);
 274     t.same(typeof s[0], 'string');
 275     t.same(s[0], '  ');
 276     t.same(typeof s[1], 'string');
 277     t.same(s[1], '  ');
 278     t.end();
 279 });
 280
 281 test('slashBreak', function (t) {
 282     t.same(
 283         optimist.parse([ '-I/foo/bar/baz' ]),
 284         { I : '/foo/bar/baz', _ : [], $0 : $0 }
 285     );
 286     t.same(
 287         optimist.parse([ '-xyz/foo/bar/baz' ]),
 288         { x : true, y : true, z : '/foo/bar/baz', _ : [], $0 : $0 }
 289     );
 290     t.end();
 291 });
 292
 293 test('alias', function (t) {
 294     var argv = optimist([ '-f', '11', '--zoom', '55' ])
 295         .alias('z', 'zoom')
 296         .argv
 297     ;
 298     t.equal(argv.zoom, 55);
 299     t.equal(argv.z, argv.zoom);
 300     t.equal(argv.f, 11);
 301     t.end();
 302 });
 303
 304 test('multiAlias', function (t) {
 305     var argv = optimist([ '-f', '11', '--zoom', '55' ])
 306         .alias('z', [ 'zm', 'zoom' ])
 307         .argv
 308     ;
 309     t.equal(argv.zoom, 55);
 310     t.equal(argv.z, argv.zoom);
 311     t.equal(argv.z, argv.zm);
 312     t.equal(argv.f, 11);
 313     t.end();
 314 });
 315
 316 test('boolean default true', function (t) {
 317     var argv = optimist.options({
 318         sometrue: {
 319             boolean: true,
 320             default: true
 321         }
 322     }).argv;
 323
 324     t.equal(argv.sometrue, true);
 325     t.end();
 326 });
 327
 328 test('boolean default false', function (t) {
 329     var argv = optimist.options({
 330         somefalse: {
 331             boolean: true,
 332             default: false
 333         }
 334     }).argv;
 335
 336     t.equal(argv.somefalse, false);
 337     t.end();
 338 });
 339
 340 test('nested dotted objects', function (t) {
 341     var argv = optimist([
 342         '--foo.bar', '3', '--foo.baz', '4',
 343         '--foo.quux.quibble', '5', '--foo.quux.o_O',
 344         '--beep.boop'
 345     ]).argv;
 346
 347     t.same(argv.foo, {
 348         bar : 3,
 349         baz : 4,
 350         quux : {
 351             quibble : 5,
 352             o_O : true
 353         },
 354     });
 355     t.same(argv.beep, { boop : true });
 356     t.end();
 357 });
 358
 359 test('boolean and alias with chainable api', function (t) {
 360     var aliased = [ '-h', 'derp' ];
 361     var regular = [ '--herp',  'derp' ];
 362     var opts = {
 363         herp: { alias: 'h', boolean: true }
 364     };
 365     var aliasedArgv = optimist(aliased)
 366         .boolean('herp')
 367         .alias('h', 'herp')
 368         .argv;
 369     var propertyArgv = optimist(regular)
 370         .boolean('herp')
 371         .alias('h', 'herp')
 372         .argv;
 373     var expected = {
 374         herp: true,
 375         h: true,
 376         '_': [ 'derp' ],
 377         '$0': $0,
 378     };
 379
 380     t.same(aliasedArgv, expected);
 381     t.same(propertyArgv, expected);
 382     t.end();
 383 });
 384
 385 test('boolean and alias with options hash', function (t) {
 386     var aliased = [ '-h', 'derp' ];
 387     var regular = [ '--herp', 'derp' ];
 388     var opts = {
 389         herp: { alias: 'h', boolean: true }
 390     };
 391     var aliasedArgv = optimist(aliased)
 392       .options(opts)
 393       .argv;
 394     var propertyArgv = optimist(regular).options(opts).argv;
 395     var expected = {
 396         herp: true,
 397         h: true,
 398         '_': [ 'derp' ],
 399         '$0': $0,
 400     };
 401
 402     t.same(aliasedArgv, expected);
 403     t.same(propertyArgv, expected);
 404
 405     t.end();
 406 });
 407
 408 test('boolean and alias using explicit true', function (t) {
 409     var aliased = [ '-h', 'true' ];
 410     var regular = [ '--herp',  'true' ];
 411     var opts = {
 412         herp: { alias: 'h', boolean: true }
 413     };
 414     var aliasedArgv = optimist(aliased)
 415         .boolean('h')
 416         .alias('h', 'herp')
 417         .argv;
 418     var propertyArgv = optimist(regular)
 419         .boolean('h')
 420         .alias('h', 'herp')
 421         .argv;
 422     var expected = {
 423         herp: true,
 424         h: true,
 425         '_': [ ],
 426         '$0': $0,
 427     };
 428
 429     t.same(aliasedArgv, expected);
 430     t.same(propertyArgv, expected);
 431     t.end();
 432 });
 433
 434 // regression, see https://github.com/substack/node-optimist/issues/71
 435 test('boolean and --x=true', function(t) {
 436     var parsed = optimist(['--boool', '--other=true']).boolean('boool').argv;
 437
 438     t.same(parsed.boool, true);
 439     t.same(parsed.other, 'true');
 440
 441     parsed = optimist(['--boool', '--other=false']).boolean('boool').argv;
 442
 443     t.same(parsed.boool, true);
 444     t.same(parsed.other, 'false');
 445     t.end();
 446 });