         ]
         assert.deepEqual(actual, expected)
 
-    it 'accepts multiple boolean arguments', ->
+    it 'calls .boolean(key)', ->
         spec = { boolean: [ 'foo', 'bar', 'baz' ] }
         actual = getMethodInvocation(spec)
         expected = [

        ]
        assert.deepEqual(actual, expected)

    it '.default(key, value)', ->
        spec = { default: { foo: 'bar' } }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'default', args: [ 'foo', 'bar' ] } ]
        assert.deepEqual(actual, expected)

    it '.default(key, value, [description])'

    it '.demand(key, [msg | boolean])'

    it '.demand(count, [max], [msg])'

    it '.describe(key, desc)', ->
        spec = { describe: { foo: 'foo is awesome' } }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'describe', args: [ 'foo', 'foo is awesome' ] } ]
        assert.deepEqual(actual, expected)

    it '.detectLocale(boolean)', ->
        spec = { detectLocale: true }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'detectLocale', args: [ true ] } ]
        assert.deepEqual(actual, expected)

    it '.epilogue(str)', ->
        spec = { epilogue: 'foo bar baz' }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'epilogue', args: [ 'foo bar baz' ] } ]
        assert.deepEqual(actual, expected)

    it '.epilog(str)', ->
        spec = { epilog: 'foo bar baz' }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'epilog', args: [ 'foo bar baz' ] } ]
        assert.deepEqual(actual, expected)

    it '.example(cmd, desc)'

    it '.exitProcess(enable)', ->
        spec = { exitProcess: true }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'exitProcess', args: [ true ] } ]
        assert.deepEqual(actual, expected)

    it '.fail(fn)', ->
        fn = -> console.log('fail')
        spec = { fail: fn }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'fail', args: [ fn ] } ]
        assert.deepEqual(actual, expected)

    it '.help([option, [description]])'

    it '.implies(x, y)', ->
        spec = { implies: { x: 'y' } }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'implies', args: [ 'x', 'y' ] } ]
        assert.deepEqual(actual, expected)


    it '.locale(locale)', ->
        spec = { locale: 'pirate' }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'locale', args: [ 'pirate' ] } ]
        assert.deepEqual(actual, expected)

    it '.nargs(key, count)'

    it '.options(key, opt)', ->
        spec = { options: { foo: { alias: 'f', type: 'boolean' } } }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'options', args: [ 'foo', { alias: 'f', type: 'boolean' } ] } ]
        assert.deepEqual(actual, expected)

    it '.require(key)', ->
        spec = { require: 'foo' }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'require', args: [ 'foo' ] } ]
        assert.deepEqual(actual, expected)

    it '.require(key, [msg | boolean])', ->
        spec = { require: { foo: false } }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'require', args: [ 'foo', false ] } ]
        assert.deepEqual(actual, expected)

    it '.required(key)', ->
        spec = { required: 'foo' }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'required', args: [ 'foo' ] } ]
        assert.deepEqual(actual, expected)

    it '.required(key, [msg | boolean])', ->
        spec = { required: { foo: false } }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'required', args: [ 'foo', false ] } ]
        assert.deepEqual(actual, expected)

    it '.showHelp(consoleLevel="error")', ->
        spec = { showHelp: 'log' }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'showHelp', args: [ 'log' ] } ]
        assert.deepEqual(actual, expected)

    it '.showHelpOnFail(enable)', ->
        spec = { showHelpOnFail: true }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'showHelpOnFail', args: [ true ] } ]

        ]
        assert.deepEqual(actual, expected)

    it 'calls .command(cmd, desc)'
    it 'calls .command(cmd, desc, fn)'
    it 'calls .completion(cmd, [description], [fn])'

    it 'calls .config(key)', ->
        spec = { config: 'foo' }
        actual = getMethodInvocation(spec)
        expected = [ { method: 'config', args: [ 'foo' ] } ]
        assert.deepEqual(actual, expected)

    it 'calls .config(key, description)', ->
        spec = { config: { foo: 'description' }}
        actual = getMethodInvocation(spec)
        expected = [ { method: 'config', args: [ 'foo', 'description' ] } ]
        assert.deepEqual(actual, expected)

    it 'calls .count(key)', ->
        spec = { count: [ 'foo', 'bar', 'baz' ] }
        actual = getMethodInvocation(spec)
        expected = [
