| 1 | var parse = require('../'); |
| 2 | var test = require('tape'); |
| 3 | |
| 4 | test('parse args', function (t) { |
| 5 | t.deepEqual( |
| 6 | parse([ '--no-moo' ]), |
| 7 | { moo : false, _ : [] }, |
| 8 | 'no' |
| 9 | ); |
| 10 | t.deepEqual( |
| 11 | parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]), |
| 12 | { v : ['a','b','c'], _ : [] }, |
| 13 | 'multi' |
| 14 | ); |
| 15 | t.end(); |
| 16 | }); |
| 17 | |
| 18 | test('comprehensive', function (t) { |
| 19 | t.deepEqual( |
| 20 | parse([ |
| 21 | '--name=meowmers', 'bare', '-cats', 'woo', |
| 22 | '-h', 'awesome', '--multi=quux', |
| 23 | '--key', 'value', |
| 24 | '-b', '--bool', '--no-meep', '--multi=baz', |
| 25 | '--', '--not-a-flag', 'eek' |
| 26 | ]), |
| 27 | { |
| 28 | c : true, |
| 29 | a : true, |
| 30 | t : true, |
| 31 | s : 'woo', |
| 32 | h : 'awesome', |
| 33 | b : true, |
| 34 | bool : true, |
| 35 | key : 'value', |
| 36 | multi : [ 'quux', 'baz' ], |
| 37 | meep : false, |
| 38 | name : 'meowmers', |
| 39 | _ : [ 'bare', '--not-a-flag', 'eek' ] |
| 40 | } |
| 41 | ); |
| 42 | t.end(); |
| 43 | }); |
| 44 | |
| 45 | test('nums', function (t) { |
| 46 | var argv = parse([ |
| 47 | '-x', '1234', |
| 48 | '-y', '5.67', |
| 49 | '-z', '1e7', |
| 50 | '-w', '10f', |
| 51 | '--hex', '0xdeadbeef', |
| 52 | '789' |
| 53 | ]); |
| 54 | t.deepEqual(argv, { |
| 55 | x : 1234, |
| 56 | y : 5.67, |
| 57 | z : 1e7, |
| 58 | w : '10f', |
| 59 | hex : 0xdeadbeef, |
| 60 | _ : [ 789 ] |
| 61 | }); |
| 62 | t.deepEqual(typeof argv.x, 'number'); |
| 63 | t.deepEqual(typeof argv.y, 'number'); |
| 64 | t.deepEqual(typeof argv.z, 'number'); |
| 65 | t.deepEqual(typeof argv.w, 'string'); |
| 66 | t.deepEqual(typeof argv.hex, 'number'); |
| 67 | t.deepEqual(typeof argv._[0], 'number'); |
| 68 | t.end(); |
| 69 | }); |
| 70 | |
| 71 | test('flag boolean', function (t) { |
| 72 | var argv = parse([ '-t', 'moo' ], { boolean: 't' }); |
| 73 | t.deepEqual(argv, { t : true, _ : [ 'moo' ] }); |
| 74 | t.deepEqual(typeof argv.t, 'boolean'); |
| 75 | t.end(); |
| 76 | }); |
| 77 | |
| 78 | test('flag boolean value', function (t) { |
| 79 | var argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], { |
| 80 | boolean: [ 't', 'verbose' ], |
| 81 | default: { verbose: true } |
| 82 | }); |
| 83 | |
| 84 | t.deepEqual(argv, { |
| 85 | verbose: false, |
| 86 | t: true, |
| 87 | _: ['moo'] |
| 88 | }); |
| 89 | |
| 90 | t.deepEqual(typeof argv.verbose, 'boolean'); |
| 91 | t.deepEqual(typeof argv.t, 'boolean'); |
| 92 | t.end(); |
| 93 | }); |
| 94 | |
| 95 | test('flag boolean default false', function (t) { |
| 96 | var argv = parse(['moo'], { |
| 97 | boolean: ['t', 'verbose'], |
| 98 | default: { verbose: false, t: false } |
| 99 | }); |
| 100 | |
| 101 | t.deepEqual(argv, { |
| 102 | verbose: false, |
| 103 | t: false, |
| 104 | _: ['moo'] |
| 105 | }); |
| 106 | |
| 107 | t.deepEqual(typeof argv.verbose, 'boolean'); |
| 108 | t.deepEqual(typeof argv.t, 'boolean'); |
| 109 | t.end(); |
| 110 | |
| 111 | }); |
| 112 | |
| 113 | test('boolean groups', function (t) { |
| 114 | var argv = parse([ '-x', '-z', 'one', 'two', 'three' ], { |
| 115 | boolean: ['x','y','z'] |
| 116 | }); |
| 117 | |
| 118 | t.deepEqual(argv, { |
| 119 | x : true, |
| 120 | y : false, |
| 121 | z : true, |
| 122 | _ : [ 'one', 'two', 'three' ] |
| 123 | }); |
| 124 | |
| 125 | t.deepEqual(typeof argv.x, 'boolean'); |
| 126 | t.deepEqual(typeof argv.y, 'boolean'); |
| 127 | t.deepEqual(typeof argv.z, 'boolean'); |
| 128 | t.end(); |
| 129 | }); |
| 130 | |
| 131 | test('newlines in params' , function (t) { |
| 132 | var args = parse([ '-s', "X\nX" ]) |
| 133 | t.deepEqual(args, { _ : [], s : "X\nX" }); |
| 134 | |
| 135 | // reproduce in bash: |
| 136 | // VALUE="new |
| 137 | // line" |
| 138 | // node program.js --s="$VALUE" |
| 139 | args = parse([ "--s=X\nX" ]) |
| 140 | t.deepEqual(args, { _ : [], s : "X\nX" }); |
| 141 | t.end(); |
| 142 | }); |
| 143 | |
| 144 | test('strings' , function (t) { |
| 145 | var s = parse([ '-s', '0001234' ], { string: 's' }).s; |
| 146 | t.equal(s, '0001234'); |
| 147 | t.equal(typeof s, 'string'); |
| 148 | |
| 149 | var x = parse([ '-x', '56' ], { string: 'x' }).x; |
| 150 | t.equal(x, '56'); |
| 151 | t.equal(typeof x, 'string'); |
| 152 | t.end(); |
| 153 | }); |
| 154 | |
| 155 | test('stringArgs', function (t) { |
| 156 | var s = parse([ ' ', ' ' ], { string: '_' })._; |
| 157 | t.same(s.length, 2); |
| 158 | t.same(typeof s[0], 'string'); |
| 159 | t.same(s[0], ' '); |
| 160 | t.same(typeof s[1], 'string'); |
| 161 | t.same(s[1], ' '); |
| 162 | t.end(); |
| 163 | }); |
| 164 | |
| 165 | test('empty strings', function(t) { |
| 166 | var s = parse([ '-s' ], { string: 's' }).s; |
| 167 | t.equal(s, ''); |
| 168 | t.equal(typeof s, 'string'); |
| 169 | |
| 170 | var str = parse([ '--str' ], { string: 'str' }).str; |
| 171 | t.equal(str, ''); |
| 172 | t.equal(typeof str, 'string'); |
| 173 | |
| 174 | var letters = parse([ '-art' ], { |
| 175 | string: [ 'a', 't' ] |
| 176 | }); |
| 177 | |
| 178 | t.equal(letters.a, ''); |
| 179 | t.equal(letters.r, true); |
| 180 | t.equal(letters.t, ''); |
| 181 | |
| 182 | t.end(); |
| 183 | }); |
| 184 | |
| 185 | |
| 186 | test('slashBreak', function (t) { |
| 187 | t.same( |
| 188 | parse([ '-I/foo/bar/baz' ]), |
| 189 | { I : '/foo/bar/baz', _ : [] } |
| 190 | ); |
| 191 | t.same( |
| 192 | parse([ '-xyz/foo/bar/baz' ]), |
| 193 | { x : true, y : true, z : '/foo/bar/baz', _ : [] } |
| 194 | ); |
| 195 | t.end(); |
| 196 | }); |
| 197 | |
| 198 | test('alias', function (t) { |
| 199 | var argv = parse([ '-f', '11', '--zoom', '55' ], { |
| 200 | alias: { z: 'zoom' } |
| 201 | }); |
| 202 | t.equal(argv.zoom, 55); |
| 203 | t.equal(argv.z, argv.zoom); |
| 204 | t.equal(argv.f, 11); |
| 205 | t.end(); |
| 206 | }); |
| 207 | |
| 208 | test('multiAlias', function (t) { |
| 209 | var argv = parse([ '-f', '11', '--zoom', '55' ], { |
| 210 | alias: { z: [ 'zm', 'zoom' ] } |
| 211 | }); |
| 212 | t.equal(argv.zoom, 55); |
| 213 | t.equal(argv.z, argv.zoom); |
| 214 | t.equal(argv.z, argv.zm); |
| 215 | t.equal(argv.f, 11); |
| 216 | t.end(); |
| 217 | }); |
| 218 | |
| 219 | test('nested dotted objects', function (t) { |
| 220 | var argv = parse([ |
| 221 | '--foo.bar', '3', '--foo.baz', '4', |
| 222 | '--foo.quux.quibble', '5', '--foo.quux.o_O', |
| 223 | '--beep.boop' |
| 224 | ]); |
| 225 | |
| 226 | t.same(argv.foo, { |
| 227 | bar : 3, |
| 228 | baz : 4, |
| 229 | quux : { |
| 230 | quibble : 5, |
| 231 | o_O : true |
| 232 | } |
| 233 | }); |
| 234 | t.same(argv.beep, { boop : true }); |
| 235 | t.end(); |
| 236 | }); |
| 237 | |
| 238 | test('boolean and alias with chainable api', function (t) { |
| 239 | var aliased = [ '-h', 'derp' ]; |
| 240 | var regular = [ '--herp', 'derp' ]; |
| 241 | var opts = { |
| 242 | herp: { alias: 'h', boolean: true } |
| 243 | }; |
| 244 | var aliasedArgv = parse(aliased, { |
| 245 | boolean: 'herp', |
| 246 | alias: { h: 'herp' } |
| 247 | }); |
| 248 | var propertyArgv = parse(regular, { |
| 249 | boolean: 'herp', |
| 250 | alias: { h: 'herp' } |
| 251 | }); |
| 252 | var expected = { |
| 253 | herp: true, |
| 254 | h: true, |
| 255 | '_': [ 'derp' ] |
| 256 | }; |
| 257 | |
| 258 | t.same(aliasedArgv, expected); |
| 259 | t.same(propertyArgv, expected); |
| 260 | t.end(); |
| 261 | }); |
| 262 | |
| 263 | test('boolean and alias with options hash', function (t) { |
| 264 | var aliased = [ '-h', 'derp' ]; |
| 265 | var regular = [ '--herp', 'derp' ]; |
| 266 | var opts = { |
| 267 | alias: { 'h': 'herp' }, |
| 268 | boolean: 'herp' |
| 269 | }; |
| 270 | var aliasedArgv = parse(aliased, opts); |
| 271 | var propertyArgv = parse(regular, opts); |
| 272 | var expected = { |
| 273 | herp: true, |
| 274 | h: true, |
| 275 | '_': [ 'derp' ] |
| 276 | }; |
| 277 | t.same(aliasedArgv, expected); |
| 278 | t.same(propertyArgv, expected); |
| 279 | t.end(); |
| 280 | }); |
| 281 | |
| 282 | test('boolean and alias using explicit true', function (t) { |
| 283 | var aliased = [ '-h', 'true' ]; |
| 284 | var regular = [ '--herp', 'true' ]; |
| 285 | var opts = { |
| 286 | alias: { h: 'herp' }, |
| 287 | boolean: 'h' |
| 288 | }; |
| 289 | var aliasedArgv = parse(aliased, opts); |
| 290 | var propertyArgv = parse(regular, opts); |
| 291 | var expected = { |
| 292 | herp: true, |
| 293 | h: true, |
| 294 | '_': [ ] |
| 295 | }; |
| 296 | |
| 297 | t.same(aliasedArgv, expected); |
| 298 | t.same(propertyArgv, expected); |
| 299 | t.end(); |
| 300 | }); |
| 301 | |
| 302 | // regression, see https://github.com/substack/node-optimist/issues/71 |
| 303 | test('boolean and --x=true', function(t) { |
| 304 | var parsed = parse(['--boool', '--other=true'], { |
| 305 | boolean: 'boool' |
| 306 | }); |
| 307 | |
| 308 | t.same(parsed.boool, true); |
| 309 | t.same(parsed.other, 'true'); |
| 310 | |
| 311 | parsed = parse(['--boool', '--other=false'], { |
| 312 | boolean: 'boool' |
| 313 | }); |
| 314 | |
| 315 | t.same(parsed.boool, true); |
| 316 | t.same(parsed.other, 'false'); |
| 317 | t.end(); |
| 318 | }); |