         ]
         assert.deepEqual(actual, expected)
 
-    it '.default(key, value)', ->
+    it 'calls .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)', ->
+    it 'calls .default(key, value, description)'
+
+    it 'calls .demand(key)', ->
+        spec = { demand: [ 'foo', 'bar' ] }
+        actual = getMethodInvocation(spec)
+        expected = [
+            { method: 'demand', args: [ 'foo' ] }
+            { method: 'demand', args: [ 'bar' ] }
+        ]
+        assert.deepEqual(actual, expected)
+
+    it 'calls .demand(key, [msg | boolean])', ->
+        spec = { demand: { foo: 'bar' } }
+        actual = getMethodInvocation(spec)
+        expected = [ { method: 'demand', args: [ 'foo', 'bar' ] } ]
+        assert.deepEqual(actual, expected)
+
+    it 'calls .demand(count, [max], [msg])'
+
+    it 'calls .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)', ->
+    it 'calls .detectLocale(boolean)', ->
         spec = { detectLocale: true }
         actual = getMethodInvocation(spec)
         expected = [ { method: 'detectLocale', args: [ true ] } ]
         assert.deepEqual(actual, expected)
 
-    it '.epilogue(str)', ->
+    it 'calls .epilogue(str)', ->
         spec = { epilogue: 'foo bar baz' }
         actual = getMethodInvocation(spec)
         expected = [ { method: 'epilogue', args: [ 'foo bar baz' ] } ]
         assert.deepEqual(actual, expected)
 
-    it '.epilog(str)', ->
+    it 'calls .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)', ->
+    it 'calls .example(cmd, desc)', ->
+        spec = { example: { foo: 'This is a command that does things and stuff' } }
+        actual = getMethodInvocation(spec)
+        expected = [ { method: 'example', args: [ 'foo', 'This is a command that does things and stuff' ] } ]
+        assert.deepEqual(actual, expected)
+
+    it 'calls .exitProcess(enable)', ->
         spec = { exitProcess: true }
         actual = getMethodInvocation(spec)
         expected = [ { method: 'exitProcess', args: [ true ] } ]
         assert.deepEqual(actual, expected)
 
-    it '.fail(fn)', ->
+    it 'calls .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)', ->
+    it 'calls .help([option, [description]])'
+
+    it 'calls .implies(x, y)', ->
         spec = { implies: { x: 'y' } }
         actual = getMethodInvocation(spec)
         expected = [ { method: 'implies', args: [ 'x', 'y' ] } ]
         assert.deepEqual(actual, expected)
 
 
-    it '.locale(locale)', ->
+    it 'calls .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)', ->
+    it 'calls .nargs(key, count)', ->
+        spec = { nargs: { foo: 7 } }
+        actual = getMethodInvocation(spec)
+        expected = [ { method: 'nargs', args: [ 'foo', 7 ] } ]
+        assert.deepEqual(actual, expected)
+
+    it 'calls .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)', ->
+    it 'calls .require(key)', ->
         spec = { require: 'foo' }
         actual = getMethodInvocation(spec)
         expected = [ { method: 'require', args: [ 'foo' ] } ]
         assert.deepEqual(actual, expected)
 
-    it '.require(key, [msg | boolean])', ->
+    it 'calls .require(key, [msg | boolean])', ->
         spec = { require: { foo: false } }
         actual = getMethodInvocation(spec)
         expected = [ { method: 'require', args: [ 'foo', false ] } ]
         assert.deepEqual(actual, expected)
 
-    it '.required(key)', ->
+    it 'calls .required(key)', ->
         spec = { required: 'foo' }
         actual = getMethodInvocation(spec)
         expected = [ { method: 'required', args: [ 'foo' ] } ]
         assert.deepEqual(actual, expected)
 
-    it '.required(key, [msg | boolean])', ->
+    it 'calls .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")', ->
+    it 'calls .showHelp(consoleLevel="error")', ->
         spec = { showHelp: 'log' }
         actual = getMethodInvocation(spec)
         expected = [ { method: 'showHelp', args: [ 'log' ] } ]
         assert.deepEqual(actual, expected)
 
-    it '.showHelpOnFail(enable)', ->
+    it 'calls .showHelpOnFail(enable)', ->
         spec = { showHelpOnFail: true }
         actual = getMethodInvocation(spec)
         expected = [ { method: 'showHelpOnFail', args: [ true ] } ]

        ]
        assert.deepEqual(actual, expected)

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

        ]
        assert.deepEqual(actual, expected)

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

    it 'calls .choices(key, choices)', ->
        spec = { choices: { foo: [ 'apples', 'oranges' ], bar: [ 'peaches', 'pears' ], baz: [ 'plums', 'mangos', 'guava' ] } }
        actual = getMethodInvocation(spec)
        expected = [
