'use strict';const assert = require('assert');const yargs = require('../index.cjs');const expect = require('chai').expect;const checkOutput = require('./helpers/utils.cjs').checkOutput;
require('chai').should();const noop = () => {};async function wait() { return new Promise(resolve => { setTimeout(resolve, 10); });}
describe('Command', () => { beforeEach(() => { yargs.getInternalMethods().reset(); });
describe('positional arguments', () => { it('parses command string and populates optional and required positional arguments', () => { const y = yargs([]).command( 'foo <bar> [awesome]', 'my awesome command', yargs => yargs ); const command = y.getInternalMethods().getCommandInstance(); const handlers = command.getCommandHandlers(); handlers.foo.demanded.should.deep.include({ cmd: ['bar'], variadic: false, }); handlers.foo.optional.should.deep.include({ cmd: ['awesome'], variadic: false, }); });
it('populates inner argv with positional arguments', done => { yargs('foo hello world') .command('foo <bar> [awesome]', 'my awesome command', noop, argv => { argv._.should.include('foo'); argv.bar.should.equal('hello'); argv.awesome.should.equal('world'); return done(); }) .parse(); });
it('populates outer argv with positional arguments when unknown-options-as-args is not set', () => { const argv = yargs('foo hello world') .command('foo <bar> [awesome]') .parse();
argv._.should.include('foo'); argv.should.have.property('bar', 'hello'); argv.should.have.property('awesome', 'world'); });
it('populates outer argv with positional arguments when unknown-options-as-args is set', () => { const argv = yargs('foo hello world') .command('foo <bar> [awesome]') .parserConfiguration({'unknown-options-as-args': true}) .parse();
argv._.should.include('foo'); argv.should.have.property('bar', 'hello'); argv.should.have.property('awesome', 'world'); });
it('populates argv with camel-case variants of arguments when possible', () => { const argv = yargs('foo hello world') .command('foo <foo-bar> [baz-qux]') .parse();
argv._.should.include('foo'); argv['foo-bar'].should.equal('hello'); argv.fooBar.should.equal('hello'); argv.bazQux.should.equal('world'); argv['baz-qux'].should.equal('world'); });
it('populates argv with camel-case variants of variadic args when possible', () => { const argv = yargs('foo hello world !') .command('foo <foo-bar> [baz-qux..]') .parse();
argv._.should.include('foo'); argv['foo-bar'].should.equal('hello'); argv.fooBar.should.equal('hello'); argv.bazQux.should.deep.equal(['world', '!']); argv['baz-qux'].should.deep.equal(['world', '!']); });
it("populates subcommand's inner argv with positional arguments", () => { yargs('foo bar hello world') .command('foo', 'my awesome command', yargs => yargs.command( 'bar <greeting> [recipient]', 'subcommands are cool', noop, argv => { argv._.should.deep.equal(['foo', 'bar']); argv.greeting.should.equal('hello'); argv.recipient.should.equal('world'); } ) ) .parse(); });
it('ignores positional args for aliases', () => { const y = yargs([]).command( ['foo [awesome]', 'wat <yo>'], 'my awesome command' ); const command = y.getInternalMethods().getCommandInstance(); const handlers = command.getCommandHandlers(); handlers.foo.optional.should.deep.include({ cmd: ['awesome'], variadic: false, }); handlers.foo.demanded.should.deep.equal([]); expect(handlers.wat).to.equal(undefined); command.getCommands().should.deep.equal(['foo', 'wat']); });
it('does not overwrite existing values in argv for keys that are not positional', () => { const argv = yargs('foo foo.js --reporter=html') .command('foo <file>') .default('reporter', 'text') .parse(); argv.file.should.equal('foo.js'); argv.reporter.should.equal('html'); });
it('does not load config twice when command executed', () => { let parseCount = 0; yargs('cmd --config=.foo.json') .command( '$0 [foo..]', 'does a thing', yargs => yargs .option('config', { default: '.foo.json', }) .positional('foo', { description: 'bar', }) .config('config', filepath => { parseCount++; return {}; }), argv => {} ) .parse(); parseCount.should.equal(1); });
it('handles -- in conjunction with positional arguments', () => { let called = false; const argv = yargs('foo hello world series -- apple banana') .command( 'foo <bar> [awesome...]', 'my awesome command', noop, argv2 => { argv2.bar.should.eql('hello'); argv2.awesome.should.eql(['world', 'series']); argv2._.should.eql(['foo', 'apple', 'banana']); called = true; } ) .parse(); argv.bar.should.eql('hello'); argv.awesome.should.eql(['world', 'series']); argv._.should.eql(['foo', 'apple', 'banana']); called.should.equal(true); });
it('continues to support populate-- for commands, post #1457', () => { let called = false; const argv = yargs('foo hello world series -- apple banana') .command( 'foo <bar> [awesome...]', 'my awesome command', noop, argv2 => { argv2.bar.should.eql('hello'); argv2.awesome.should.eql(['world', 'series']); argv2._.should.eql(['foo']); argv2['--'].should.eql(['apple', 'banana']); called = true; } ) .parserConfiguration({ 'populate--': true, }) .parse(); argv.bar.should.eql('hello'); argv.awesome.should.eql(['world', 'series']); argv._.should.eql(['foo']); argv['--'].should.eql(['apple', 'banana']); called.should.equal(true); });
it('does not overwrite options in argv if variadic', () => { yargs .command({ command: 'cmd [foods..]', desc: 'cmd desc', builder: yargs => yargs.positional('foods', { desc: 'foods desc', type: 'string', }), handler: argv => { argv.foods.should.deep.equal(['apples', 'cherries', 'grapes']); }, }) .parse('cmd --foods apples cherries grapes'); });
it('does not overwrite options in argv if variadic and when using default command', () => { yargs .command({ command: '$0 [foods..]', desc: 'default desc', builder: yargs => yargs.positional('foods', { desc: 'foods desc', type: 'string', }), handler: argv => { argv.foods.should.deep.equal(['apples', 'cherries', 'grapes']); }, }) .parse('--foods apples cherries grapes'); });
it('does not combine positional default and provided values', () => { yargs() .command({ command: 'cmd [foods..]', desc: 'cmd desc', builder: yargs => yargs.positional('foods', { desc: 'foods desc', type: 'string', default: ['pizza', 'wings'], }), handler: argv => { argv.foods.should.deep.equal(['apples', 'cherries', 'grapes']); argv.foods.should.not.include('pizza'); }, }) .parse('cmd apples cherries grapes'); });
it('does not combine config values and provided values', () => { yargs('foo bar baz qux') .command({ command: '$0 <arg-1> [arg-2] [arg-3..]', desc: 'default description', builder: yargs => yargs .option('arg-1', {type: 'string'}) .option('arg-2', {type: 'string'}) .option('arg-3', {type: 'string'}) .config({ arg2: 'bar', arg3: ['baz', 'qux'], }), handler: argv => { argv.arg1.should.equal('foo'); argv.arg2.should.equal('bar'); argv.arg3.should.deep.equal(['baz', 'qux']); argv['arg-3'].should.deep.equal(['baz', 'qux']); }, }) .strict() .parse(); });
it('does not overwrite options in argv if variadic and preserves falsy values', () => { yargs .command({ command: '$0 [numbers..]', desc: 'default desc', builder: yargs => yargs.positional('numbers', { desc: 'numbers desc', type: 'number', }), handler: argv => { argv.numbers.should.deep.equal([0, 1, 2]); }, }) .parse('--numbers 0 1 2'); }); });
describe('variadic', () => { it('allows required arguments to be variadic', () => { const argv = yargs('foo /root file1 file2 file3') .command('foo <root> <files..>') .parse();
argv.root.should.equal('/root'); argv.files.should.deep.equal(['file1', 'file2', 'file3']); });
it('allows optional arguments to be variadic', () => { const argv = yargs('foo /root file1 file2 file3') .command('foo <root> [files..]') .parse();
argv.root.should.equal('/root'); argv.files.should.deep.equal(['file1', 'file2', 'file3']); });
it('fails if required arguments are missing', done => { yargs('foo /root') .command('foo <root> <files..>') .fail(err => { err.should.match(/Not enough non-option arguments/); return done(); }) .parse(); });
it('does not fail if zero optional arguments are provided', () => { const argv = yargs('foo /root').command('foo <root> [files...]').parse();
argv.root.should.equal('/root'); argv.files.should.deep.equal([]); });
it('only allows the last argument to be variadic', () => { const argv = yargs('foo /root file1 file2') .command('foo <root..> <file>') .parse();
argv.root.should.equal('/root'); argv.file.should.equal('file1'); argv._.should.include('file2'); });
it('allows camel-case, variadic arguments, and strict mode to be combined', () => { const argv = yargs('ls one two three') .command('ls [expandMe...]') .strict() .parse();
argv.expandMe.should.deep.equal(['one', 'two', 'three']); argv['expand-me'].should.deep.equal(['one', 'two', 'three']); }); });
describe('missing positional arguments', () => { it('fails if a required argument is missing', done => { const argv = yargs('foo hello') .command('foo <bar> <awesome>') .fail(err => { err.should.match(/got 1, need at least 2/); return done(); }) .parse();
argv.bar.should.equal('hello'); });
it('does not fail if optional argument is missing', () => { const argv = yargs('foo hello').command('foo <bar> [awesome]').parse();
expect(argv.awesome).to.equal(undefined); argv.bar.should.equal('hello'); }); });
describe('API', () => { it('accepts string, string as first 2 arguments', () => { const cmd = 'foo'; const desc = "i'm not feeling very creative at the moment"; const isDefault = false; const aliases = []; const deprecated = false;
const y = yargs([]).command(cmd, desc); const commands = y.getInternalMethods().getUsageInstance().getCommands(); commands[0].should.deep.equal([ cmd, desc, isDefault, aliases, deprecated, ]); });
it('accepts array, string as first 2 arguments', () => { const aliases = ['bar', 'baz']; const cmd = 'foo <qux>'; const desc = "i'm not feeling very creative at the moment"; const isDefault = false; const deprecated = false;
const y = yargs([]).command([cmd].concat(aliases), desc); const usageCommands = y .getInternalMethods() .getUsageInstance() .getCommands(); usageCommands[0].should.deep.equal([ cmd, desc, isDefault, aliases, deprecated, ]); const cmdCommands = y .getInternalMethods() .getCommandInstance() .getCommands(); cmdCommands.should.deep.equal(['foo', 'bar', 'baz']); });
it('accepts string, boolean as first 2 arguments', () => { const cmd = 'foo'; const desc = false;
const y = yargs([]).command(cmd, desc); const commands = y.getInternalMethods().getUsageInstance().getCommands(); commands.should.deep.equal([]); });
it('accepts array, boolean as first 2 arguments', () => { const aliases = ['bar', 'baz']; const cmd = 'foo <qux>'; const desc = false;
const y = yargs([]).command([cmd].concat(aliases), desc); const usageCommands = y .getInternalMethods() .getUsageInstance() .getCommands(); usageCommands.should.deep.equal([]); const cmdCommands = y .getInternalMethods() .getCommandInstance() .getCommands(); cmdCommands.should.deep.equal(['foo', 'bar', 'baz']); });
it('accepts function as 3rd argument', () => { const cmd = 'foo'; const desc = "i'm not feeling very creative at the moment"; const builder = yargs => yargs;
const y = yargs([]).command(cmd, desc, builder); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(cmd); handlers.foo.builder.should.equal(builder); });
it('accepts options object as 3rd argument', () => { const cmd = 'foo'; const desc = "i'm not feeling very creative at the moment"; const builder = { hello: {default: 'world'}, };
const y = yargs([]).command(cmd, desc, builder); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(cmd); handlers.foo.builder.should.equal(builder); });
it('accepts module (with builder function and handler function) as 3rd argument', () => { const cmd = 'foo'; const desc = "i'm not feeling very creative at the moment"; const module = { builder(yargs) { return yargs; }, handler(argv) {}, };
const y = yargs([]).command(cmd, desc, module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(cmd); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); });
it('accepts module (with builder object and handler function) as 3rd argument', () => { const cmd = 'foo'; const desc = "i'm not feeling very creative at the moment"; const module = { builder: { hello: {default: 'world'}, }, handler(argv) {}, };
const y = yargs([]).command(cmd, desc, module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(cmd); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); });
it('accepts module (describe key, builder function) as 1st argument', () => { const module = { command: 'foo', describe: "i'm not feeling very creative at the moment", builder(yargs) { return yargs; }, handler(argv) {}, }; const isDefault = false; const aliases = []; const deprecated = false;
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const commands = y.getInternalMethods().getUsageInstance().getCommands(); commands[0].should.deep.equal([ module.command, module.describe, isDefault, aliases, deprecated, ]); });
it('accepts module (description key, builder function) as 1st argument', () => { const module = { command: 'foo', description: "i'm not feeling very creative at the moment", builder(yargs) { return yargs; }, handler(argv) {}, }; const isDefault = false; const aliases = []; const deprecated = false;
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const commands = y.getInternalMethods().getUsageInstance().getCommands(); commands[0].should.deep.equal([ module.command, module.description, isDefault, aliases, deprecated, ]); });
it('accepts module (desc key, builder function) as 1st argument', () => { const module = { command: 'foo', desc: "i'm not feeling very creative at the moment", builder(yargs) { return yargs; }, handler(argv) {}, }; const isDefault = false; const aliases = []; const deprecated = false;
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const commands = y.getInternalMethods().getUsageInstance().getCommands(); commands[0].should.deep.equal([ module.command, module.desc, isDefault, aliases, deprecated, ]); });
it('accepts module (false describe, builder function) as 1st argument', () => { const module = { command: 'foo', describe: false, builder(yargs) { return yargs; }, handler(argv) {}, };
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const commands = y.getInternalMethods().getUsageInstance().getCommands(); commands.should.deep.equal([]); });
it('accepts module (missing describe, builder function) as 1st argument', () => { const module = { command: 'foo', builder(yargs) { return yargs; }, handler(argv) {}, };
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const commands = y.getInternalMethods().getUsageInstance().getCommands(); commands.should.deep.equal([]); });
it('accepts module (describe key, builder object) as 1st argument', () => { const module = { command: 'foo', describe: "i'm not feeling very creative at the moment", builder: { hello: { default: 'world', }, }, handler(argv) {}, }; const isDefault = false; const aliases = []; const deprecated = false;
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const commands = y.getInternalMethods().getUsageInstance().getCommands(); commands[0].should.deep.equal([ module.command, module.describe, isDefault, aliases, deprecated, ]); });
it('accepts module (missing handler function) as 1st argument', () => { const module = { command: 'foo', describe: "i'm not feeling very creative at the moment", builder: { hello: { default: 'world', }, }, }; const isDefault = false; const aliases = []; const deprecated = false;
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command); handlers.foo.builder.should.equal(module.builder); expect(typeof handlers.foo.handler).to.equal('function'); const commands = y.getInternalMethods().getUsageInstance().getCommands(); commands[0].should.deep.equal([ module.command, module.describe, isDefault, aliases, deprecated, ]); });
it('accepts module (with command array) as 1st argument', () => { const module = { command: ['foo <qux>', 'bar', 'baz'], describe: "i'm not feeling very creative at the moment", builder(yargs) { return yargs; }, handler(argv) {}, }; const isDefault = false; const deprecated = false;
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command[0]); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const usageCommands = y .getInternalMethods() .getUsageInstance() .getCommands(); usageCommands[0].should.deep.equal([ module.command[0], module.describe, isDefault, ['bar', 'baz'], deprecated, ]); const cmdCommands = y .getInternalMethods() .getCommandInstance() .getCommands(); cmdCommands.should.deep.equal(['foo', 'bar', 'baz']); });
it('accepts module (with command string and aliases array) as 1st argument', () => { const module = { command: 'foo <qux>', aliases: ['bar', 'baz'], describe: "i'm not feeling very creative at the moment", builder(yargs) { return yargs; }, handler(argv) {}, }; const isDefault = false; const deprecated = false;
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const usageCommands = y .getInternalMethods() .getUsageInstance() .getCommands(); usageCommands[0].should.deep.equal([ module.command, module.describe, isDefault, module.aliases, deprecated, ]); const cmdCommands = y .getInternalMethods() .getCommandInstance() .getCommands(); cmdCommands.should.deep.equal(['foo', 'bar', 'baz']); });
it('accepts module (with command array and aliases array) as 1st argument', () => { const module = { command: ['foo <qux>', 'bar'], aliases: ['baz', 'nat'], describe: "i'm not feeling very creative at the moment", builder(yargs) { return yargs; }, handler(argv) {}, }; const isDefault = false; const deprecated = false;
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command[0]); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const usageCommands = y .getInternalMethods() .getUsageInstance() .getCommands(); usageCommands[0].should.deep.equal([ module.command[0], module.describe, isDefault, ['bar', 'baz', 'nat'], deprecated, ]); const cmdCommands = y .getInternalMethods() .getCommandInstance() .getCommands(); cmdCommands.should.deep.equal(['foo', 'bar', 'baz', 'nat']); });
it('accepts module (with command string and aliases string) as 1st argument', () => { const module = { command: 'foo <qux>', aliases: 'bar', describe: "i'm not feeling very creative at the moment", builder(yargs) { return yargs; }, handler(argv) {}, }; const isDefault = false; const deprecated = false;
const y = yargs([]).command(module); const handlers = y .getInternalMethods() .getCommandInstance() .getCommandHandlers(); handlers.foo.original.should.equal(module.command); handlers.foo.builder.should.equal(module.builder); handlers.foo.handler.should.equal(module.handler); const usageCommands = y .getInternalMethods() .getUsageInstance() .getCommands(); usageCommands[0].should.deep.equal([ module.command, module.describe, isDefault, ['bar'], deprecated, ]); const cmdCommands = y .getInternalMethods() .getCommandInstance() .getCommands(); cmdCommands.should.deep.equal(['foo', 'bar']); });
it('accepts deprecated as 5th argument', () => { const command = 'command'; const description = 'description'; const isDefault = false; const aliases = []; const deprecated = false; const y = yargs([]).command( command, description, {}, () => {}, [], deprecated ); const usageCommands = y .getInternalMethods() .getUsageInstance() .getCommands(); usageCommands[0].should.deep.equal([ command, description, isDefault, aliases, deprecated, ]); }); });
describe('commandDir', () => { it('supports relative dirs', () => { const r = checkOutput(() => yargs('--help').wrap(null).commandDir('fixtures/cmddir').parse() ); r.exit.should.equal(true); r.exitCode.should.equal(0); r.errors.length.should.equal(0); r.should.have.property('logs'); r.logs .join('\n') .split(/\n+/) .should.deep.equal([ 'usage [command]', 'Commands:', ' usage dream [command] [opts] Go to sleep and dream', 'Options:', ' --help Show help [boolean]', ' --version Show version number [boolean]', ]); });
it('supports nested subcommands', () => { const r = checkOutput( () => yargs('dream --help') .wrap(null) .commandDir('fixtures/cmddir') .parse(), ['./command'] ); r.exit.should.equal(true); r.errors.length.should.equal(0); r.logs[0] .split(/\n+/) .should.deep.equal([ 'command dream [command] [opts]', 'Go to sleep and dream', 'Commands:', ' command dream of-memory <memory> Dream about a specific memory', ' command dream within-a-dream [command] [opts] Dream within a dream', 'Options:', ' --help Show help [boolean]', ' --version Show version number [boolean]', ' --shared Is the dream shared with others? [boolean]', ' --extract Attempt extraction? [boolean]', ]); });
it('supports a "recurse" boolean option', () => { const r = checkOutput(() => yargs('--help') .wrap(null) .commandDir('fixtures/cmddir', {recurse: true}) .parse() ); r.exit.should.equal(true); r.errors.length.should.equal(0); r.logs .join('\n') .split(/\n+/) .should.deep.equal([ 'usage [command]', 'Commands:', ' usage limbo [opts] Get lost in pure subconscious', ' usage inception [command] [opts] Enter another dream, where inception is possible', ' usage within-a-dream [command] [opts] Dream within a dream', ' usage dream [command] [opts] Go to sleep and dream', 'Options:', ' --help Show help [boolean]', ' --version Show version number [boolean]', ]); });
it('supports a "visit" function option', () => { let commandObject; let pathToFile; let filename; const r = checkOutput(() => yargs('--help') .wrap(null) .commandDir('fixtures/cmddir', { visit(_commandObject, _pathToFile, _filename) { commandObject = _commandObject; pathToFile = _pathToFile; filename = _filename; return false; }, }) .parse() ); commandObject.should.have .property('command') .and.equal('dream [command] [opts]'); commandObject.should.have .property('desc') .and.equal('Go to sleep and dream'); commandObject.should.have.property('builder'); commandObject.should.have.property('handler'); pathToFile.should.contain( require('path').join('test', 'fixtures', 'cmddir', 'dream.js') ); filename.should.equal('dream.js'); r.exit.should.equal(true); r.errors.length.should.equal(0); r.logs .join('\n') .split(/\n+/) .should.deep.equal([ 'Options:', ' --help Show help [boolean]', ' --version Show version number [boolean]', ]); });
it('detects and ignores cyclic dir references', () => { const r = checkOutput( () => yargs('cyclic --help') .wrap(null) .commandDir('fixtures/cmddir_cyclic') .parse(), ['./command'] ); r.exit.should.equal(true); r.errors.length.should.equal(0); r.should.have.property('logs'); r.logs .join('\n') .split(/\n+/) .should.deep.equal([ 'command cyclic', 'Attempts to (re)apply its own dir', 'Options:', ' --help Show help [boolean]', ' --version Show version number [boolean]', ]); });
it("derives 'command' string from filename when not exported", () => { const r = checkOutput(() => yargs('--help').wrap(null).commandDir('fixtures/cmddir_noname').parse() ); r.exit.should.equal(true); r.errors.length.should.equal(0); r.should.have.property('logs'); r.logs .join('\n') .split(/\n+/) .should.deep.equal([ 'usage [command]', 'Commands:', ' usage nameless Command name derived from module filename', 'Options:', ' --help Show help [boolean]', ' --version Show version number [boolean]', ]); }); });
describe('help command', () => { it('displays command help appropriately', () => { const sub = { command: 'sub', desc: 'Run the subcommand', builder: {}, handler(argv) {}, };
const cmd = { command: 'cmd <sub>', desc: 'Try a command', builder(yargs) { return yargs.command(sub); }, handler(argv) {}, };
const helpCmd = checkOutput( () => yargs('help cmd').wrap(null).command(cmd).parse(), ['./command'] );
const cmdHelp = checkOutput( () => yargs('cmd help').wrap(null).command(cmd).parse(), ['./command'] );
const helpCmdSub = checkOutput( () => yargs('help cmd sub').wrap(null).command(cmd).parse(), ['./command'] );
const cmdHelpSub = checkOutput( () => yargs('cmd help sub').wrap(null).command(cmd).parse(), ['./command'] );
const cmdSubHelp = checkOutput( () => yargs('cmd sub help').wrap(null).command(cmd).parse(), ['./command'] );
const expectedCmd = [ 'command cmd <sub>', 'Try a command', 'Commands:', ' command cmd sub Run the subcommand', 'Options:', ' --help Show help [boolean]', ' --version Show version number [boolean]', ];
const expectedSub = [ 'command cmd sub', 'Run the subcommand', 'Options:', ' --help Show help [boolean]', ' --version Show version number [boolean]', ];
helpCmd.logs.should.eql([]); helpCmdSub.logs.should.eql([]); cmdHelpSub.logs.should.eql([]);
cmdHelp.logs.join('\n').split(/\n+/).should.deep.equal(expectedCmd); cmdSubHelp.logs.join('\n').split(/\n+/).should.deep.equal(expectedSub); }); });
it('preserves top-level envPrefix', () => { process.env.FUN_DIP_STICK = 'yummy'; process.env.FUN_DIP_POWDER = 'true'; yargs('eat') .env('FUN_DIP') .global('stick') .command( 'eat', 'Adult supervision recommended', yargs => yargs.boolean('powder').exitProcess(false), argv => { argv.powder.should.equal(true); argv.stick.should.equal('yummy'); } ) .exitProcess(false) .parse(); });
it('respects order of positional arguments when matching commands', () => { const output = []; yargs('bar foo') .command('foo', 'foo command', yargs => { output.push('foo'); }) .command('bar', 'bar command', yargs => { output.push('bar'); }) .parse();
output.should.include('bar'); output.should.not.include('foo'); });
it('handles positional arguments if command is invoked using .parse()', () => { const y = yargs([]).command('foo <second>', 'the foo command', {}); const argv = y.parse(['foo', 'bar']); argv.second.should.equal('bar'); });
it('invokes command handler repeatedly if parse() is called multiple times', () => { let counter = 0; const y = yargs([]).command('foo', 'the foo command', {}, argv => { counter++; }); y.parse(['foo']); y.parse(['foo']); counter.should.equal(2); });
it('allows command handler to be invoked repeatedly when help is enabled', done => { let counter = 0; const y = yargs([]).command('foo', 'the foo command', {}, argv => { counter++; }); y.parse(['foo'], noop); y.parse(['foo'], () => { counter.should.equal(2); return done(); }); });
it('does not require builder function to return', () => { const argv = yargs('yo') .command( 'yo [someone]', 'Send someone a yo', yargs => { yargs.default('someone', 'Pat'); }, argv => { argv.should.have.property('someone').and.equal('Pat'); } ) .parse(); argv.should.have.property('someone').and.equal('Pat'); });
it('allows builder function to parse argv without returning', () => { const argv = yargs('yo Jude') .command( 'yo <someone>', 'Send someone a yo', yargs => { yargs.parse(); }, argv => { argv.should.have.property('someone').and.equal('Jude'); } ) .parse(); argv.should.have.property('someone').and.equal('Jude'); });
it('allows builder function to return parsed argv', () => { const argv = yargs('yo Leslie') .command( 'yo <someone>', 'Send someone a yo', yargs => yargs.parse(), argv => { argv.should.have.property('someone').and.equal('Leslie'); } ) .parse(); argv.should.have.property('someone').and.equal('Leslie'); });
it('ignores extra spaces in command string', () => { const y = yargs([]).command( 'foo [awesome]', 'my awesome command', yargs => yargs ); const command = y.getInternalMethods().getCommandInstance(); const handlers = command.getCommandHandlers(); handlers.foo.demanded.should.not.include({ cmd: '', variadic: false, }); handlers.foo.demanded.should.have.lengthOf(0); });
it('executes a command via alias', () => { let commandCalled = false; const argv = yargs('hi world') .command(['hello <someone>', 'hi'], 'Say hello', {}, argv => { commandCalled = true; argv.should.have.property('someone').and.equal('world'); }) .parse(); argv.should.have.property('someone').and.equal('world'); commandCalled.should.equal(true); });
describe('positional aliases', () => { it('allows an alias to be defined for a required positional argument', () => { const argv = yargs('yo bcoe 113993') .command('yo <user | email> [ssn]', 'Send someone a yo') .parse(); argv.user.should.equal('bcoe'); argv.email.should.equal('bcoe'); argv.ssn.should.equal(113993); });
it('allows an alias to be defined for an optional positional argument', () => { let argv; yargs('yo 113993') .command('yo [ssn|sin]', 'Send someone a yo', {}, _argv => { argv = _argv; }) .parse(); argv.ssn.should.equal(113993); argv.sin.should.equal(113993); });
it('allows several aliases to be defined for a required positional argument', () => { const argv = yargs('yo bcoe 113993') .command('yo <user | email | id> [ssn]', 'Send someone a yo', yargs => yargs.alias('user', 'somethingElse') ) .parse(); argv.user.should.equal('bcoe'); argv.email.should.equal('bcoe'); argv.id.should.equal('bcoe'); argv.somethingElse.should.equal('bcoe'); argv.ssn.should.equal(113993); });
it('allows several aliases to be defined for an optional positional argument', () => { let argv; yargs('yo 113993') .command( 'yo [ssn|sin|id]', 'Send someone a yo', yargs => yargs.alias('ssn', 'somethingElse'), _argv => { argv = _argv; } ) .parse(); argv.ssn.should.equal(113993); argv.sin.should.equal(113993); argv.id.should.equal(113993); argv.somethingElse.should.equal(113993); });
it('allows variadic and positional arguments to be combined', () => { const parser = yargs.command( 'yo <user|email> [ ssns | sins... ]', 'Send someone a yo' ); const argv = parser.parse('yo bcoe 113993 112888'); argv.user.should.equal('bcoe'); argv.email.should.equal('bcoe'); argv.ssns.should.deep.equal([113993, 112888]); argv.sins.should.deep.equal([113993, 112888]); }); });
describe('global parsing hints', () => { describe('config', () => { it('does not load config for command if global is false', done => { yargs('command --foo ./package.json') .command('command', 'a command', {}, argv => { expect(argv.license).to.equal(undefined); return done(); }) .config('foo') .global('foo', false) .parse(); });
it('loads config for command by default', done => { yargs('command --foo ./package.json') .command('command', 'a command', {}, argv => { argv.license.should.equal('MIT'); return done(); }) .config('foo') .parse(); }); });
describe('validation', () => { it('resets implies logic for command if global is false', done => { yargs('command --foo 99') .command('command', 'a command', {}, argv => { argv.foo.should.equal(99); return done(); }) .implies('foo', 'bar') .global('foo', false) .parse(); });
it('applies conflicts logic for command by default', done => { yargs('command --foo --bar') .command('command', 'a command', {}, argv => {}) .fail(msg => { msg.should.match(/mutually exclusive/); return done(); }) .conflicts('foo', 'bar') .parse(); });
it('resets conflicts logic for command if global is false', done => { yargs('command --foo --bar') .command('command', 'a command', {}, argv => { argv.foo.should.equal(true); argv.bar.should.equal(true); return done(); }) .conflicts('foo', 'bar') .global('foo', false) .parse(); });
it('applies custom checks globally by default', done => { yargs('command blerg --foo') .command('command <snuh>', 'a command') .check(argv => { argv.snuh.should.equal('blerg'); argv.foo.should.equal(true); argv._.should.include('command'); done(); return true; }) .parse(); });
it('resets custom check if global is false', () => { let checkCalled = false; yargs('command blerg --foo') .command('command <snuh>', 'a command') .check(argv => { checkCalled = true; return true; }, false) .parse(); checkCalled.should.equal(false); });
it('allows each builder to specify own middleware', () => { let checkCalled1 = 0; let checkCalled2 = 0; const y = yargs() .command('command <snuh>', 'a command', () => { yargs.check(argv => { checkCalled1++; return true; }); }) .command('command2 <snuh>', 'a second command', yargs => { yargs.check(argv => { checkCalled2++; return true; }); }); y.parse('command blerg --foo'); y.parse('command2 blerg --foo'); y.parse('command blerg --foo'); checkCalled1.should.equal(2); checkCalled2.should.equal(1); });
it('applies demandOption globally', done => { yargs('command blerg --foo') .command('command <snuh>', 'a command') .fail(msg => { msg.should.match(/Missing required argument: bar/); return done(); }) .demandOption('bar') .parse(); }); });
describe('strict', () => { it('defaults to false when not called', () => { let commandCalled = false; yargs('hi').command('hi', 'The hi command', innerYargs => { commandCalled = true; innerYargs.getStrict().should.equal(false); }); yargs.getStrict().should.equal(false); yargs.parse(); commandCalled.should.equal(true); });
it('can be enabled just for a command', () => { let commandCalled = false; yargs('hi').command('hi', 'The hi command', innerYargs => { commandCalled = true; innerYargs.strict().getStrict().should.equal(true); }); yargs.getStrict().should.equal(false); yargs.parse(); commandCalled.should.equal(true); });
it('applies strict globally by default', () => { let commandCalled = false; yargs('hi') .strict() .command('hi', 'The hi command', innerYargs => { commandCalled = true; innerYargs.getStrict().should.equal(true); }); yargs.getStrict().should.equal(true); yargs.parse(); commandCalled.should.equal(true); });
it('does not fail strict check due to postional command arguments', done => { yargs() .strict() .command('hi <name>', 'The hi command') .parse('hi ben', (err, argv, output) => { expect(err).to.equal(null); return done(); }); });
it('does not fail strict check due to postional command arguments in nested commands', done => { yargs() .strict() .command('hi', 'The hi command', yargs => { yargs.command('ben <age>', 'ben command', noop, noop); }) .parse('hi ben 99', (err, argv, output) => { expect(err).to.equal(null); return done(); }); });
it('allows a command to override global`', () => { let commandCalled = false; yargs('hi') .strict() .command('hi', 'The hi command', innerYargs => { commandCalled = true; innerYargs.strict(false).getStrict().should.equal(false); }); yargs.getStrict().should.equal(true); yargs.parse(); commandCalled.should.equal(true); });
it('does not fire command if validation fails', done => { let commandRun = false; yargs() .strict() .command('hi <name>', 'The hi command', noop, argv => { commandRun = true; }) .parse('hi ben --hello=world', (err, argv, output) => { commandRun.should.equal(false); err.message.should.equal('Unknown argument: hello'); return done(); }); }); });
describe('types', () => { it('applies array type globally', () => { const argv = yargs('command --foo 1 2') .command('command', 'a command') .array('foo') .parse(); argv.foo.should.eql([1, 2]); });
it('allows global setting to be disabled for array type', () => { const argv = yargs('command --foo 1 2') .command('command', 'a command') .array('foo') .global('foo', false) .parse(); argv.foo.should.eql(1); });
it('applies choices type globally', done => { yargs('command --foo 99') .command('command', 'a command') .choices('foo', [33, 88]) .fail(msg => { msg.should.match(/Choices: 33, 88/); return done(); }) .parse(); }); });
describe('aliases', () => { it('defaults to applying aliases globally', done => { yargs('command blerg --foo 22') .command('command <snuh>', 'a command', {}, argv => { argv.foo.should.equal(22); argv.bar.should.equal(22); argv.snuh.should.equal('blerg'); return done(); }) .alias('foo', 'bar') .parse(); });
it('allows global application of alias to be disabled', done => { yargs('command blerg --foo 22') .command('command <snuh>', 'a command', {}, argv => { argv.foo.should.equal(22); expect(argv.bar).to.equal(undefined); argv.snuh.should.equal('blerg'); return done(); }) .option('foo', { alias: 'bar', global: false, }) .parse(); }); });
describe('coerce', () => { it('defaults to applying coerce rules globally', done => { yargs('command blerg --foo 22') .command('command <snuh>', 'a command', {}, argv => { argv.foo.should.equal(44); argv.snuh.should.equal('blerg'); return done(); }) .coerce('foo', arg => arg * 2) .parse(); });
it('should bubble errors thrown by coerce function inside commands', done => { yargs .command('foo', 'the foo command', yargs => { yargs.coerce('x', arg => { throw Error('yikes an error'); }); }) .parse('foo -x 99', err => { err.message.should.match(/yikes an error/); return done(); }); });
it('should not be applied multiple times for nested commands', () => { let coerceExecutionCount = 0;
const argv = yargs('cmd1 cmd2 foo bar baz') .command('cmd1', 'cmd1 desc', yargs => yargs.command('cmd2 <positional1> <rest...>', 'cmd2 desc', yargs => yargs .positional('rest', { type: 'string', coerce: arg => { if (coerceExecutionCount) { throw Error('coerce applied multiple times'); } coerceExecutionCount++; return arg.join(' '); }, }) .fail(() => { expect.fail(); }) ) ) .parse();
argv.rest.should.equal('bar baz'); coerceExecutionCount.should.equal(1); });
it('should not run or set new properties on argv when related argument is not passed', () => { yargs('cmd1') .command( 'cmd1', 'cmd1 desc', yargs => yargs .option('foo', {alias: 'f', type: 'string'}) .option('bar', { alias: 'b', type: 'string', implies: 'f', coerce: () => expect.fail(), }) .fail(() => { expect.fail(); }), argv => { if (Object.prototype.hasOwnProperty(argv, 'b')) { expect.fail(); } } ) .strict() .parse(); });
it('should not add aliases to argv if strip-aliased config is true', () => { yargs('cmd1 -f hello -b world') .parserConfiguration({'strip-aliased': true}) .command( 'cmd1', 'cmd1 desc', yargs => yargs.option('foo', {alias: 'f', type: 'string'}).option('bar', { type: 'string', alias: 'b', coerce: val => val, }), argv => { if (Object.prototype.hasOwnProperty(argv, 'b')) { expect.fail(); } } ) .strict() .parse(); }); });
describe('defaults', () => { it('applies defaults globally', done => { yargs('command --foo 22') .command('command [snuh]', 'a command', {}, argv => { argv.foo.should.equal(22); argv.snuh.should.equal(55); return done(); }) .default('snuh', 55) .parse(); }); });
describe('describe', () => { it('flags an option as global if a description is set', done => { yargs() .command('command [snuh]', 'a command') .describe('foo', 'an awesome argument') .parse('command --help', (err, argv, output) => { if (err) return done(err); output.should.not.match(/Commands:/); output.should.match(/an awesome argument/); return done(); }); }); });
describe('help', () => { it('applies help globally', done => { yargs() .command('command [snuh]', 'a command') .describe('foo', 'an awesome argument') .help('hellllllp') .parse('command --hellllllp', (err, argv, output) => { if (err) return done(err); output.should.match(/--hellllllp {2}Show help/); return done(); }); }); });
describe('version', () => { it('applies version globally', done => { yargs() .command('command [snuh]', 'a command') .describe('foo', 'an awesome argument') .version('ver', 'show version', '9.9.9') .parse('command --ver', (err, argv, output) => { if (err) return done(err); output.should.equal('9.9.9'); return done(); }); }); });
describe('groups', () => { it('should apply custom option groups globally', done => { yargs() .command('command [snuh]', 'a command') .group('foo', 'Bad Variable Names:') .group('snuh', 'Bad Variable Names:') .describe('foo', 'foo option') .describe('snuh', 'snuh positional') .parse('command --help', (err, argv, output) => { if (err) return done(err); output.should.match(/Bad Variable Names:\W*--foo/); return done(); }); }); }); });
describe('default commands', () => { it('executes default command if no positional arguments given', done => { yargs('--foo bar') .command('*', 'default command', noop, argv => { argv.foo.should.equal('bar'); return done(); }) .parse(); });
it('executes default command if undefined positional arguments and only command', done => { yargs('baz --foo bar') .command('*', 'default command', noop, argv => { argv.foo.should.equal('bar'); argv._.should.contain('baz'); return done(); }) .parse(); });
it('executes default command if defined positional arguments and only command', done => { yargs('baz --foo bar') .command('* <target>', 'default command', noop, argv => { argv.foo.should.equal('bar'); argv.target.should.equal('baz'); return done(); }) .parse(); });
it('allows $0 as an alias for a default command', done => { yargs('9999') .command('$0 [port]', 'default command', noop, argv => { argv.port.should.equal(9999); return done(); }) .parse(); });
it('does not execute default command if another command is provided', done => { yargs('run bcoe --foo bar') .command('*', 'default command', noop, argv => {}) .command('run <name>', 'run command', noop, argv => { argv.name.should.equal('bcoe'); argv.foo.should.equal('bar'); return done(); }) .parse(); });
it('allows default command to be set as alias', done => { yargs('bcoe --foo bar') .command(['start <name>', '*'], 'start command', noop, argv => { argv._.should.eql([]); argv.name.should.equal('bcoe'); argv.foo.should.equal('bar'); return done(); }) .parse(); });
it('allows command to be run when alias is default command', done => { yargs('start bcoe --foo bar') .command(['start <name>', '*'], 'start command', noop, argv => { argv._.should.eql(['start']); argv.name.should.equal('bcoe'); argv.foo.should.equal('bar'); return done(); }) .parse(); });
it('the last default command set should take precedence', done => { yargs('bcoe --foo bar') .command(['first', '*'], 'override me', noop, noop) .command(['second <name>', '*'], 'start command', noop, argv => { argv._.should.eql([]); argv.name.should.equal('bcoe'); argv.foo.should.equal('bar'); return done(); }) .parse(); });
describe('strict', () => { it('executes default command when strict mode is enabled', done => { yargs('--foo bar') .command('*', 'default command', noop, argv => { argv.foo.should.equal('bar'); return done(); }) .option('foo', { describe: 'a foo command', }) .strict() .parse(); });
it('allows default command aliases, when strict mode is enabled', done => { yargs('bcoe --foo bar') .command(['start <name>', '*'], 'start command', noop, argv => { argv._.should.eql([]); argv.name.should.equal('bcoe'); argv.foo.should.equal('bar'); return done(); }) .strict() .option('foo', { describe: 'a foo command', }) .parse(); }); }); });
describe('deprecated command', () => { describe('using arg', () => { it('shows deprecated notice with boolean', () => { const command = 'command'; const description = 'description'; const deprecated = true; const r = checkOutput(() => { yargs('--help') .command(command, description, {}, () => {}, [], deprecated) .parse(); }); r.logs.should.match(/\[deprecated\]/); }); it('shows deprecated notice with string', () => { const command = 'command'; const description = 'description'; const deprecated = 'deprecated'; const r = checkOutput(() => { yargs('--help') .command(command, description, {}, () => {}, [], deprecated) .parse(); }); r.logs.should.match(/\[deprecated: deprecated\]/); }); }); describe('using module', () => { it('shows deprecated notice with boolean', () => { const command = 'command'; const description = 'description'; const deprecated = true; const r = checkOutput(() => { yargs('--help').command({command, description, deprecated}).parse(); }); r.logs.should.match(/\[deprecated\]/); }); it('shows deprecated notice with string', () => { const command = 'command'; const description = 'description'; const deprecated = 'deprecated'; const r = checkOutput(() => { yargs('--help').command({command, description, deprecated}).parse(); }); r.logs.should.match(/\[deprecated: deprecated\]/); }); }); });
it('should kick along [demand] configuration to commands', () => { let called = false; const r = checkOutput(() => { yargs('foo') .command('foo', 'foo command', noop, argv => { called = true; }) .option('bar', { describe: 'a foo command', demand: true, }) .parse(); }); called.should.equal(false); r.exitCode.should.equal(1); r.errors.should.match(/Missing required argument/); });
it('should support numeric commands', () => { const output = []; yargs('1') .command('1', 'numeric command', yargs => { output.push('1'); }) .parse(); output.should.include('1'); });
it('should not execute command if it is preceded by another positional argument', () => { let commandCalled = false; yargs() .command('foo', 'foo command', noop, () => { commandCalled = true; }) .parse('bar foo', (err, argv) => { expect(err).to.equal(null); commandCalled.should.equal(false); argv._.should.eql(['bar', 'foo']); }); });
it('should allow positional arguments for inner commands in strict mode, when no handler is provided', () => { yargs() .command('foo', 'outer command', yargs => { yargs.command('bar [optional]', 'inner command'); }) .strict() .parse('foo bar 33', (err, argv) => { expect(err).to.equal(null); argv.optional.should.equal(33); argv._.should.eql(['foo', 'bar']); }); });
describe('usage', () => { it('allows you to configure a default command', () => { yargs() .usage('$0 <port>', 'default command', yargs => { yargs.positional('port', { type: 'string', }); }) .parse('33', (err, argv) => { expect(err).to.equal(null); argv.port.should.equal('33'); }); });
it('throws exception if default command does not have leading $0', () => { expect(() => { yargs().usage('<port>', 'default command', yargs => { yargs.positional('port', { type: 'string', }); }); }).to.throw(/.*\.usage\(\) description must start with \$0.*/); }); });
describe('async', () => { it('fails when the promise returned by the command handler rejects', done => { const error = new Error(); yargs('foo') .command('foo', 'foo command', noop, yargs => Promise.reject(error)) .fail((msg, err) => { expect(msg).to.equal(null); expect(err).to.equal(error); done(); }) .parse(); });
it('returns promise that resolves arguments once handler succeeds', async () => { let complete = false; const handler = new Promise((resolve, reject) => { setTimeout(() => { complete = true; return resolve(); }, 10); }); const parsedPromise = yargs('foo hello') .command( 'foo <pos>', 'foo command', () => {}, () => handler ) .parse(); complete.should.equal(false); const parsed = await parsedPromise; complete.should.equal(true); parsed.pos.should.equal('hello'); });
it('returns promise that can be caught, when fail(false)', async () => { let complete = false; const handler = new Promise((resolve, reject) => { setTimeout(() => { complete = true; return reject(Error('error from handler')); }, 10); }); const parsedPromise = yargs('foo hello') .command( 'foo <pos>', 'foo command', () => {}, () => handler ) .fail(false) .parse(); try { complete.should.equal(false); await parsedPromise; throw Error('unreachable'); } catch (err) { err.message.should.match(/error from handler/); complete.should.equal(true); } });
it('displays error and appropriate help message when handler fails', async () => { const r = await checkOutput(async () => { return yargs('foo') .command( 'foo', 'foo command', yargs => { yargs.option('bar', { describe: 'bar option', }); }, argv => { return Promise.reject(Error('foo error')); } ) .exitProcess(false) .parse(); }); const errorLog = r.errors.join('\n'); errorLog.should.include('bar option'); errorLog.should.include('foo error'); }); });
it('does not coerce number from positional with leading "+"', () => { const argv = yargs.command('$0 <phone>', '', yargs => {}).parse('+5550100'); argv.phone.should.equal('+5550100'); });
it('allows an array of commands to be provided', () => { const innerCommands = [ { command: 'c <x> <y>', describe: 'add x to y', builder: () => {}, handler: argv => { argv.output.value = argv.x + argv.y; }, }, ]; const cmds = [ { command: 'a', describe: 'numeric comamand', builder: yargs => { yargs.command(innerCommands); }, handler: () => {}, }, ]; const context = { output: {}, }; yargs().command(cmds).parse('a c 10 5', context); context.output.value.should.equal(15); });
it('allows async exception in handler to be caught', async () => { await assert.rejects( yargs(['mw']) .fail(false) .command( 'mw', 'adds func to middleware', () => {}, async () => { throw Error('not cool'); } ) .parse(), /not cool/ ); });
it('reports error if error occurs parsing positional', () => { try { yargs(['cmd', 'neat']) .fail(false) .command('cmd <foo>', 'run a foo command', yargs => { yargs.option('foo', { nargs: 3, }); }) .parse(); throw Error('unreachable'); } catch (err) { err.message.should.match(/Not enough arguments/); } });
describe('async builder', async () => { it('allows positionals to be configured asynchronously', async () => { const argvPromise = yargs(['cmd', '999']) .command('cmd <foo>', 'a test command', async yargs => { await wait(); yargs.positional('foo', { type: 'string', }); }) .parse(); (typeof argvPromise.then).should.equal('function'); const argv = await argvPromise; (typeof argv.foo).should.equal('string'); }); describe('helpOrVersionSet', () => { it('--help', async () => { let set = false; await yargs() .command('cmd <foo>', 'a test command', (yargs, helpOrVersionSet) => { set = helpOrVersionSet; if (!helpOrVersionSet) { return wait(); } }) .parse('cmd --help', () => {}); assert.strictEqual(set, true); }); }); it('does not print to stdout when parse callback is provided', async () => { await yargs() .command('cmd <foo>', 'a test command', async () => { await wait(); }) .parse('cmd --help', (_err, argv, output) => { output.should.include('a test command'); argv.help.should.equal(true); }); }); it('allows command to be defined in async builder', async () => { let invoked = false; await yargs('alpha beta') .strict() .command({ command: 'alpha', describe: 'A', builder: async yargs => { await wait(); yargs .command({ command: 'beta', describe: 'B', handler: () => { invoked = true; }, }) .demandCommand(1); }, }) .demandCommand(1) .parse(); assert.strictEqual(invoked, true); }); it('allows deeply nested command to be defined in async builder', async () => { let invoked = false; await yargs('alpha beta gamma') .strict() .command('alpha', 'A', async yargs => { await wait(); yargs .command({ command: 'beta', describe: 'B', builder: async yargs => { await wait(); return yargs.command( 'gamma', 'C', async () => { await wait(); }, async () => { await wait(); invoked = true; } ); }, }) .demandCommand(1); }) .demandCommand(1) .parse(); assert.strictEqual(invoked, true); }); });
describe('builder', () => { describe('helpOrVersionSet', () => { it('--version', () => { let set = false; yargs() .command('cmd <foo>', 'a test command', (yargs, helpOrVersionSet) => { set = helpOrVersionSet; }) .parse('cmd --version', () => {}); assert.strictEqual(set, true); }); it('--help', () => { let set = false; yargs() .command('cmd <foo>', 'a test command', (yargs, helpOrVersionSet) => { set = helpOrVersionSet; }) .parse('cmd --help', () => {}); assert.strictEqual(set, true); }); it('help', () => { let set = false; yargs() .command('cmd <foo>', 'a test command', (yargs, helpOrVersionSet) => { set = helpOrVersionSet; }) .parse('cmd help', () => {}); assert.strictEqual(set, true); }); it('cmd', () => { let set = false; const argv = yargs() .command('cmd <foo>', 'a test command', (yargs, helpOrVersionSet) => { set = helpOrVersionSet; }) .parse('cmd bar', () => {}); assert.strictEqual(set, false); assert.strictEqual(argv.foo, 'bar'); }); }); });});