From ffe24763d8c66bf045f1f7930ee909799c4c353e Mon Sep 17 00:00:00 2001
From: Jason Dobry <jmdobry@users.noreply.github.com>
Date: Thu, 18 Aug 2016 20:05:27 -0700
Subject: [PATCH] All Storage samples are now up to standard. (#182)

* All Storage samples are now up to standard.

* Address comments

* Address comments

* Remove .only

* Fixed links
---
 CONTRIBUTING.md                        |  61 ++-
 storage/README.md                      | 185 ++++---
 storage/acl.js                         |  19 +-
 storage/buckets.js                     |  92 ++--
 storage/encryption.js                  | 138 ++---
 storage/files.js                       | 364 ++++++-------
 storage/iam.js                         |   0
 storage/system-test/buckets.test.js    |  12 +-
 storage/system-test/encryption.test.js |  22 +-
 storage/system-test/files.test.js      | 106 +++-
 storage/system-test/transfer.test.js   |  18 +-
 storage/test/acl.test.js               |  28 +-
 storage/test/buckets.test.js           | 190 +++----
 storage/test/encryption.test.js        | 227 ++++----
 storage/test/files.test.js             | 703 +++++++++++++------------
 storage/test/transfer.test.js          | 260 +++------
 storage/transfer.js                    | 208 +++-----
 17 files changed, 1324 insertions(+), 1309 deletions(-)
 delete mode 100644 storage/iam.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index b5fb73c807..0e7713f4ee 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -27,6 +27,65 @@ accept your pull requests.
 1. Fork the desired repo, develop and test your code changes.
 1. Ensure that your code adheres to the existing style in the sample to which you are contributing. Refer to the
    [Google Cloud Platform Samples Style Guide](https://github.com/GoogleCloudPlatform/Template/wiki/style.html) for the
-   recommended coding standards for this organization.  You can run `npm run jshint` to match our JavaScript coding standards. 
+   recommended coding standards for this organization.  You can run `npm run jshint` to match our JavaScript coding standards.
 1. Ensure that your code has an appropriate set of unit tests which all pass.
 1. Submit a pull request!
+
+## Sample template
+
+```
+<LICENSE_HEADER>
+
+// [START all]
+// [START setup]
+// By default, the client will authenticate using the service account file
+// specified by the GOOGLE_APPLICATION_CREDENTIALS environment variable and use
+// the project specified by the GCLOUD_PROJECT environment variable. See
+// https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/guides/authentication
+var <API_CLIENT> = require('@google-cloud/<API>');
+
+// Instantiate a <API> client
+var <CLIENT> = <API_CLIENT>();
+// [END setup]
+
+// [START <REGION_TAG_NAME>]
+/**
+ * <DESCRIPTION>
+ *
+ * @param {<TYPE>} <NAME> <DESCRIPTION>.
+ * @param {function} cb The callback function.
+ */
+function <METHOD_NAME> (<ARGUMENTS>, callback) {
+  // <SETUP>
+
+  // <RUN SAMPLE CODE>
+
+  // Inside callback: console.log(<MESSAGE>)
+}
+// [END <REGION_TAG_NAME>]
+
+// The command-line program
+var cli = require('yargs');
+
+var program = module.exports = {
+  <METHOD_NAME>: <METHOD_NAME>,
+  main: function (args) {
+    // Run the command-line program
+    cli.help().strict().parse(args).argv;
+  }
+};
+
+cli
+  .demand(1)
+  .command('<COMMAND> <ARGS>', '<DESCRIPTION>.', {}, function (options) {
+    program.<METHOD_NAME>(options, console.log);
+  })
+  .example('node $0 <COMMAND> <ARGS>', '<DESCRIPTION>.')
+  .wrap(100)
+  .recommendCommands()
+  .epilogue('For more information, see <DOCS_LINK>');
+
+if (module === require.main) {
+  program.main(process.argv.slice(2));
+}
+```
\ No newline at end of file
diff --git a/storage/README.md b/storage/README.md
index a5a54eb01b..3af203b46b 100644
--- a/storage/README.md
+++ b/storage/README.md
@@ -42,11 +42,12 @@ Commands:
   delete <entity>      Delete access controls from a bucket or file.
 
 Options:
-  --bucket, -b   The target storage bucket.                                      [string] [required]
-  --default, -d  Whether to set default access controls. Only valid when setting access controls on
-                 a bucket.                                                                 [boolean]
-  --file, -f     The target file.                                                           [string]
-  --help         Show help                                                                 [boolean]
+  --bucket, -b   The target storage bucket.           [string] [required]
+  --default, -d  Whether to set default access
+                 controls. Only valid when setting
+                 access controls on a bucket.         [boolean]
+  --file, -f     The target file.                     [string]
+  --help         Show help                            [boolean]
 
 Examples:
   node acl add user-bob@domain.com OWNER -b mybucket  Add OWNER access controls for
@@ -71,19 +72,20 @@ View the [documentation][buckets_docs] or the [source code][buckets_code].
 __Usage:__ `node buckets --help`
 
 ```
-Usage: node buckets COMMAND [ARGS...]
-
 Commands:
+  create <bucket>  Create a new bucket with the given name.
+  list             List all buckets in the authenticated project.
+  delete <bucket>  Delete the specified bucket.
 
-  create BUCKET_NAME
-  list
-  delete BUCKET_NAME
+Options:
+  --help  Show help              [boolean]
 
 Examples:
+  node buckets create my-bucket  Create a new bucket named "my-bucket".
+  node buckets list              List all buckets in the authenticated project.
+  node buckets delete my-bucket  Delete "my-bucket".
 
-  node buckets create my-bucket
-  node buckets list
-  node buckets delete my-bucket
+For more information, see https://cloud.google.com/storage/docs
 ```
 
 [buckets_docs]: https://cloud.google.com/storage/docs
@@ -96,21 +98,25 @@ View the [documentation][encryption_docs] or the [source code][encryption_code].
 __Usage:__ `node encryption --help`
 
 ```
-Usage: node encryption COMMAND [ARGS...]
-
 Commands:
+  generate-encryption-key                       Generate a sample encryption key.
+  upload <bucket> <srcFile> <destFile> <key>    Upload an encrypted file to a bucket.
+  download <bucket> <srcFile> <destFile> <key>  Download an encrypted file from a bucket.
+  rotate <bucket> <file> <oldkey> <newKey>      Rotate encryption keys for a file.
 
-  generate-encryption-key
-  upload BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME KEY
-  download BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME KEY
-  rotate BUCKET_NAME FILE_NAME OLD_KEY NEW_KEY
+Options:
+  --help  Show help                                             [boolean]
 
 Examples:
-
-  node encryption generate-encryption-key
-  node encryption upload my-bucket resources/test.txt file_encrypted.txt QxhqaZEqBGVTW55HhQw9Q=
-  node encryption download my-bucket file_encrypted.txt ./file.txt QxhqaZEqBGVTW55HhQw9Q=
-  node encryption rotate my-bucket file_encrypted.txt QxhqaZEqBGVTW55HhQw9Q= SxafpsdfSDFS89sds9Q=
+  node encryption generate-encryption-key                       Generate a sample encryption key.
+  node encryption upload my-bucket resources/test.txt           Upload "resources/test.txt" to
+  file_encrypted.txt QxhqaZEqBGVTW55HhQw9Q=                     "gs://my-bucket/file_encrypted.txt".
+  node encryption download my-bucket file_encrypted.txt         Download "gs://my-bucket/file_encrypted.txt" to
+  ./file.txt QxhqaZEqBGVTW55HhQw9Q=                             "./file.txt".
+  node encryption rotate my-bucket file_encrypted.txt           Rotate encryptiong keys for
+  QxhqaZEqBGVTW55HhQw9Q= SxafpsdfSDFS89sds9Q=                   "gs://my-bucket/file_encrypted.txt".
+
+For more information, see https://cloud.google.com/storage/docs
 ```
 
 [encryption_docs]: https://cloud.google.com/storage/docs
@@ -123,32 +129,36 @@ View the [documentation][files_docs] or the [source code][files_code].
 __Usage:__ `node files --help`
 
 ```
-Usage: node files COMMAND [ARGS...]
-
 Commands:
+  list <bucket> [options]                             List files in a bucket, optionally filtering
+                                                      by a prefix.
+  upload <bucket> <srcFile>                           Upload a local file to a bucket.
+  download <bucket> <srcFile> <destFile>              Download a file from a bucket.
+  delete <bucket> <file>                              Delete a file from a bucket.
+  getMetadata <bucket> <file>                         Get metadata for a file in a bucket.
+  makePublic <bucket> <file>                          Make a file public in a bucket.
+  move <bucket> <srcFile> <destFile>                  Rename a file in a bucket.
+  copy <srcBucket> <srcFile> <destBucket> <destFile>  Copy a file in a bucket to another bucket.
 
-  list BUCKET_NAME
-  listByPrefix BUCKET_NAME PREFIX [DELIMITER]
-  upload BUCKET_NAME FILE_NAME
-  download BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME
-  delete BUCKET_NAME FILE_NAME
-  getMetadata BUCKET_NAME FILE_NAME
-  makePublic BUCKET_NAME FILE_NAME
-  move BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME
-  copy BUCKET_NAME SRC_FILE_NAME DEST_BUCKET_NAME DEST_FILE_NAME
+Options:
+  --help  Show help                                                                        [boolean]
 
 Examples:
-
-  list my-bucket
-  listByPrefix my-bucket /some-folder
-  listByPrefix my-bucket /some-folder -
-  upload my-bucket ./file.txt
-  download my-bucket file.txt ./file.txt
-  delete my-bucket file.txt
-  getMetadata my-bucket file.txt
-  makePublic my-bucket file.txt
-  move my-bucket file.txt file2.txt
-  copy my-bucket file.txt my-other-bucket file.txt
+  node files list my-bucket                           List files in "my-bucket".
+  node files list my-bucket -p public/                List files in "my-bucket" filtered by prefix
+                                                      "public/".
+  node files upload my-bucket ./file.txt              Upload "./file.txt" to "my-bucket".
+  node files download my-bucket file.txt ./file.txt   Download "gs://my-bucket/file.txt" to
+                                                      "./file.txt".
+  node files delete my-bucket file.txt                Delete "gs://my-bucket/file.txt".
+  node files getMetadata my-bucket file.txt           Get metadata for "gs://my-bucket/file.txt".
+  node files makePublic my-bucket file.txt            Make "gs://my-bucket/file.txt" public.
+  node files move my-bucket file.txt file2.txt        Rename "gs://my-bucket/file.txt" to
+                                                      "gs://my-bucket/file2.txt".
+  node files copy my-bucket file.txt my-other-bucket  Copy "gs://my-bucket/file.txt" to
+  file.txt                                            "gs://my-other-bucket/file.txt".
+
+For more information, see https://cloud.google.com/storage/docs
 ```
 
 [files_docs]: https://cloud.google.com/storage/docs
@@ -161,41 +171,74 @@ View the [documentation][storagetransfer_docs] or the [source code][storagetrans
 __Usage:__ `node transfer --help`
 
 ```
-Usage: node encryption RESOURCE COMMAND [ARGS...]
+Commands:
+  jobs <cmd> [args]        Run a job command.
+  operations <cmd> [args]  Run an operation command.
 
-Resources:
+Options:
+  --help  Show help                                                                        [boolean]
 
-  jobs
+Examples:
+  node transfer jobs --help        Show job commands.
+  node transfer operations --help  Show operations commands.
 
-      Commands:
+For more information, see https://cloud.google.com/storage/transfer
+```
 
-        create SRC_BUCKET_NAME DEST_BUCKET_NAME DATE TIME [DESCRIPTION]
-        get JOB_NAME
-        list
-        set JOB_NAME FIELD VALUE
+__Usage:__ `node transfer jobs --help`
 
-  operations
+```
+transfer jobs <cmd> [args]
 
-      Commands:
+Commands:
+  create <srcBucket> <destBucket> <time> <date>       Create a transfer job.
+  [description]
+  get <job>                                           Get a transfer job.
+  list                                                List transfer jobs.
+  set <job> <field> <value>                           Change the status, description or transferSpec
+                                                      of a transfer job.
 
-        list [JOB_NAME]
-        get TRANSFER_NAME
-        pause TRANSFER_NAME
-        resume TRANSFER_NAME
+Options:
+  --help  Show help                                                                        [boolean]
 
 Examples:
+  node transfer jobs create my-bucket                 Create a transfer job.
+  my-other-bucket 2016/08/12 16:30 "Move my files"
+  node transfer jobs get                              Get a transfer job.
+  transferJobs/123456789012345678
+  node transfer jobs list                             List transfer jobs.
+  node transfer jobs set                              Update the description for a transfer job.
+  transferJobs/123456789012345678 description "My
+  new description"
+  node transfer jobs set                              Disable a transfer job.
+  transferJobs/123456789012345678 status DISABLED
+```
+
+__Usage:__ `node transfer operations --help`
+
+```
+transfer operations <cmd> [args]
+
+Commands:
+  list [job]          List transfer operations, optionally filtering by a job name.
+  get <operation>     Get a transfer operation.
+  pause <operation>   Pause a transfer operation.
+  resume <operation>  Resume a transfer operation.
 
-  node transfer jobs create my-bucket my-other-bucket 2016/08/12 16:30 "Move my files"
-  node transfer jobs get transferJobs/123456789012345678
-  node transfer jobs list
-  node transfer jobs set transferJobs/123456789012345678 description "My new description"
-  node transfer jobs set transferJobs/123456789012345678 status DISABLED
-  node transfer operations list
-  node transfer operations list transferJobs/123456789012345678
-  node transfer operations get transferOperations/123456789012345678
-  node transfer operations pause transferOperations/123456789012345678
-  node transfer operations resume transferOperations/123456789012345678
+Options:
+  --help  Show help                                                                        [boolean]
+
+Examples:
+  node transfer operations list                       List all transfer operations.
+  node transfer operations list                       List all transfer operations for a specific
+  transferJobs/123456789012345678                     job.
+  node transfer operations get                        Get a transfer operation.
+  transferOperations/123456789012345678
+  node transfer operations pause                      Pause a transfer operation.
+  transferOperations/123456789012345678
+  node transfer operations resume                     Resume a transfer operation.
+  transferOperations/123456789012345678
 ```
 
-[storagetransfer_docs]: https://cloud.google.com/storage/docs
+[storagetransfer_docs]: https://cloud.google.com/storage/transfer
 [storagetransfer_code]: transfer.js
diff --git a/storage/acl.js b/storage/acl.js
index 20fbf2e88e..6ce0c15541 100644
--- a/storage/acl.js
+++ b/storage/acl.js
@@ -41,16 +41,16 @@ function addAccessControl (options, callback) {
   // Reference the specified storage bucket
   var bucket = storage.bucket(options.bucket);
   // Reference the bucket's acl resource
-  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/storage/bucket?method=acl.add
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
   var acl = bucket.acl;
 
   if (options.file) {
     // Optionally target a file's acl resource
-    // See https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/storage/file?method=acl.add
+    // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
     acl = bucket.file(options.file).acl;
   } else if (options.default) {
     // Optionally add "default" access controls to the bucket
-    // See https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/storage/bucket?method=acl.default.add
+    // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
     acl = acl.default;
   }
 
@@ -86,16 +86,16 @@ function getAccessControl (options, callback) {
   // Reference the specified storage bucket
   var bucket = storage.bucket(options.bucket);
   // Reference the bucket's acl resource
-  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/storage/bucket?method=acl.get
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
   var acl = bucket.acl;
 
   if (options.file) {
     // Optionally target a file's acl resource
-    // See https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/storage/file?method=acl.get
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
     acl = bucket.file(options.file).acl;
   } else if (options.default) {
     // Optionally get "default" access controls for the bucket
-    // See https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/storage/bucket?method=acl.default.get
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
     acl = acl.default;
   }
 
@@ -133,16 +133,16 @@ function deleteAccessControl (options, callback) {
   // Reference the specified storage bucket
   var bucket = storage.bucket(options.bucket);
   // Reference the bucket's acl resource
-  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/storage/bucket?method=acl.delete
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
   var acl = bucket.acl;
 
   if (options.file) {
     // Optionally target a file's acl resource
-    // See https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/storage/file?method=acl.delete
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
     acl = bucket.file(options.file).acl;
   } else if (options.default) {
     // Optionally delete "default" access controls from the bucket
-    // See https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/storage/bucket?method=acl.default.delete
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
     acl = acl.default;
   }
 
@@ -173,6 +173,7 @@ var program = module.exports = {
 };
 
 cli
+  .demand(1)
   .command('add <entity> <role>', 'Add access controls on a bucket or file.', {}, function (options) {
     program.addAccessControl(options, console.log);
   })
diff --git a/storage/buckets.js b/storage/buckets.js
index 6f6be5dc19..d78a48c300 100644
--- a/storage/buckets.js
+++ b/storage/buckets.js
@@ -25,7 +25,7 @@ var Storage = require('@google-cloud/storage');
 var storage = Storage();
 // [END setup]
 
-// [START create]
+// [START create_bucket]
 /**
  * Creates a new bucket with the given name.
  *
@@ -33,11 +33,10 @@ var storage = Storage();
  * @param {function} cb The callback function.
  */
 function createBucket (name, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  }
+  var bucket = storage.bucket(name);
 
-  storage.createBucket(name, function (err, bucket) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
+  bucket.create(function (err, bucket) {
     if (err) {
       return callback(err);
     }
@@ -46,27 +45,28 @@ function createBucket (name, callback) {
     return callback(null, bucket);
   });
 }
-// [END create]
+// [END create_bucket]
 
-// [START list]
+// [START list_buckets]
 /**
- * Fetches all of the current project's buckets.
+ * List all of the authenticated project's buckets.
  *
  * @param {function} cb The callback function.
  */
 function listBuckets (callback) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage
   storage.getBuckets(function (err, buckets) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Found %d buckets!', buckets.length);
+    console.log('Found %d bucket(s)!', buckets.length);
     return callback(null, buckets);
   });
 }
-// [END list]
+// [END list_buckets]
 
-// [START delete]
+// [START delete_bucket]
 /**
  * Deletes the specified bucket.
  *
@@ -74,62 +74,52 @@ function listBuckets (callback) {
  * @param {function} cb The callback function.
  */
 function deleteBucket (name, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  }
-
   var bucket = storage.bucket(name);
 
-  bucket.delete(function (err, apiResponse) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
+  bucket.delete(function (err) {
     if (err) {
       return callback(err);
     }
 
     console.log('Deleted bucket: %s', name);
-    return callback(null, apiResponse);
+    return callback(null);
   });
 }
-// [END delete]
-
-// [START usage]
-function printUsage () {
-  console.log('Usage: node buckets COMMAND [ARGS...]');
-  console.log('\nCommands:\n');
-  console.log('\tcreate BUCKET_NAME');
-  console.log('\tlist');
-  console.log('\tdelete BUCKET_NAME');
-  console.log('\nExamples:\n');
-  console.log('\tnode buckets create my-bucket');
-  console.log('\tnode buckets list');
-  console.log('\tnode buckets delete my-bucket');
-}
-// [END usage]
+// [END delete_bucket]
+// [END all]
 
 // The command-line program
-var program = {
+var cli = require('yargs');
+
+var program = module.exports = {
   createBucket: createBucket,
   listBuckets: listBuckets,
   deleteBucket: deleteBucket,
-  printUsage: printUsage,
-
-  // Executed when this program is run from the command-line
-  main: function (args, cb) {
-    var command = args.shift();
-    if (command === 'create') {
-      this.createBucket(args[0], cb);
-    } else if (command === 'list') {
-      this.listBuckets(cb);
-    } else if (command === 'delete') {
-      this.deleteBucket(args[0], cb);
-    } else {
-      this.printUsage();
-    }
+  main: function (args) {
+    // Run the command-line program
+    cli.help().strict().parse(args).argv;
   }
 };
 
+cli
+  .demand(1)
+  .command('create <bucket>', 'Create a new bucket with the given name.', {}, function (options) {
+    program.createBucket(options.bucket, console.log);
+  })
+  .command('list', 'List all buckets in the authenticated project.', {}, function () {
+    program.listBuckets(console.log);
+  })
+  .command('delete <bucket>', 'Delete the specified bucket.', {}, function (options) {
+    program.deleteBucket(options.bucket, console.log);
+  })
+  .example('node $0 create my-bucket', 'Create a new bucket named "my-bucket".')
+  .example('node $0 list', 'List all buckets in the authenticated project.')
+  .example('node $0 delete my-bucket', 'Delete "my-bucket".')
+  .wrap(80)
+  .recommendCommands()
+  .epilogue('For more information, see https://cloud.google.com/storage/docs');
+
 if (module === require.main) {
-  program.main(process.argv.slice(2), console.log);
+  program.main(process.argv.slice(2));
 }
-// [END all]
-
-module.exports = program;
diff --git a/storage/encryption.js b/storage/encryption.js
index 5250a0aafe..7335981814 100644
--- a/storage/encryption.js
+++ b/storage/encryption.js
@@ -55,35 +55,27 @@ function generateEncryptionKey () {
  * The file will be encrypted by Google Cloud Storage and only retrievable using
  * the provided encryption key.
  *
- * @param {string} bucketName The bucket where the file will be uploaded.
- * @param {string} srcFileName The local file to be uploaded.
- * @param {string} destFileName The name of the destination file.
- * @param {string} key The encryption key.
+ * @param {object} options Configuration options.
+ * @param {string} options.bucket The bucket where the file will be uploaded.
+ * @param {string} options.srcFile The local file to be uploaded.
+ * @param {string} options.destFile The name of the destination file.
+ * @param {string} options.key The encryption key.
  * @param {function} callback The callback function.
  */
-function uploadEncryptedFile (bucketName, srcFileName, destFileName, key, callback) {
-  if (!bucketName) {
-    return callback(new Error('"bucketName" is required!'));
-  } else if (!srcFileName) {
-    return callback(new Error('"srcFileName" is required!'));
-  } else if (!destFileName) {
-    return callback(new Error('"destFileName" is required!'));
-  } else if (!key) {
-    return callback(new Error('"key" is required!'));
-  }
-
-  var bucket = storage.bucket(bucketName);
-  var options = {
-    destination: destFileName,
-    encryptionKey: new Buffer(key, 'base64')
+function uploadEncryptedFile (options, callback) {
+  var bucket = storage.bucket(options.bucket);
+  var config = {
+    destination: options.destFile,
+    encryptionKey: new Buffer(options.key, 'base64')
   };
 
-  bucket.upload(srcFileName, options, function (err, file) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
+  bucket.upload(options.srcFile, config, function (err, file) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Uploaded encrypted file: %s', destFileName);
+    console.log('Uploaded gs://%s/%s', options.bucket, options.destFile);
     return callback(null, file);
   });
 }
@@ -96,37 +88,28 @@ function uploadEncryptedFile (bucketName, srcFileName, destFileName, key, callba
  * The encryption key provided must be the same key provided when uploading the
  * file.
  *
- * @param {string} bucketName The bucket from which the file will be downloaded.
- * @param {string} srcFileName The name of the file to be downloaded.
- * @param {string} destFileName The local path to which to save the file.
- * @param {string} key The encryption key.
+ * @param {object} options Configuration options.
+ * @param {string} options.bucket The bucket from which the file will be downloaded.
+ * @param {string} options.srcFile The name of the file to be downloaded.
+ * @param {string} options.destFile The local path to which to save the file.
+ * @param {string} options.key The encryption key.
  * @param {function} key The callback function.
  */
-function downloadEncryptedFile (bucketName, srcFileName, destFileName, key, callback) {
-  if (!bucketName) {
-    return callback(new Error('"bucketName" is required!'));
-  } else if (!srcFileName) {
-    return callback(new Error('"srcFileName" is required!'));
-  } else if (!destFileName) {
-    return callback(new Error('"destFileName" is required!'));
-  } else if (!key) {
-    return callback(new Error('"key" is required!'));
-  }
-
-  var bucket = storage.bucket(bucketName);
-  var file = bucket.file(srcFileName);
-  var options = {
-    destination: destFileName
+function downloadEncryptedFile (options, callback) {
+  var file = storage.bucket(options.bucket).file(options.srcFile);
+  var config = {
+    destination: options.destFile
   };
 
-  file.setEncryptionKey(new Buffer(key, 'base64'));
+  file.setEncryptionKey(new Buffer(options.key, 'base64'));
 
-  file.download(options, function (err) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
+  file.download(config, function (err) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Downloaded encrypted file: %s', destFileName);
+    console.log('Downloaded gs://%s/%s to %s', options.bucket, options.srcFile, options.destFile);
     return callback(null);
   });
 }
@@ -137,57 +120,50 @@ function downloadEncryptedFile (bucketName, srcFileName, destFileName, key, call
  * Performs a key rotation by re-writing an encrypted blob with a new encryption
  * key.
  *
- * @param {function} key The callback function.
+ * @param {function} callback The callback function.
  */
 function rotateEncryptionKey (callback) {
   callback(new Error('This is currently not available using the Cloud Client Library.'));
 }
 // [END rotate_encryption_key]
-
-// [START usage]
-function printUsage () {
-  console.log('Usage: node encryption COMMAND [ARGS...]');
-  console.log('\nCommands:\n');
-  console.log('\tgenerate-encryption-key');
-  console.log('\tupload BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME KEY');
-  console.log('\tdownload BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME KEY');
-  console.log('\trotate BUCKET_NAME FILE_NAME OLD_KEY NEW_KEY');
-  console.log('\nExamples:\n');
-  console.log('\tnode encryption generate-encryption-key');
-  console.log('\tnode encryption upload my-bucket resources/test.txt file_encrypted.txt QxhqaZEqBGVTW55HhQw9Q=');
-  console.log('\tnode encryption download my-bucket file_encrypted.txt ./file.txt QxhqaZEqBGVTW55HhQw9Q=');
-  console.log('\tnode encryption rotate my-bucket file_encrypted.txt QxhqaZEqBGVTW55HhQw9Q= SxafpsdfSDFS89sds9Q=');
-}
-// [END usage]
+// [END all]
 
 // The command-line program
-var program = {
+var cli = require('yargs');
+
+var program = module.exports = {
   generateEncryptionKey: generateEncryptionKey,
   uploadEncryptedFile: uploadEncryptedFile,
   downloadEncryptedFile: downloadEncryptedFile,
   rotateEncryptionKey: rotateEncryptionKey,
-  printUsage: printUsage,
-
-  // Executed when this program is run from the command-line
-  main: function (args, cb) {
-    var command = args.shift();
-    if (command === 'generate-encryption-key') {
-      this.generateEncryptionKey();
-    } else if (command === 'upload') {
-      this.uploadEncryptedFile(args[0], args[1], args[2], args[3], cb);
-    } else if (command === 'download') {
-      this.downloadEncryptedFile(args[0], args[1], args[2], args[3], cb);
-    } else if (command === 'rotate') {
-      this.rotateEncryptionKey(cb);
-    } else {
-      this.printUsage();
-    }
+  main: function (args) {
+    // Run the command-line program
+    cli.help().strict().parse(args).argv;
   }
 };
 
+cli
+  .demand(1)
+  .command('generate-encryption-key', 'Generate a sample encryption key.', {}, function () {
+    program.generateEncryptionKey();
+  })
+  .command('upload <bucket> <srcFile> <destFile> <key>', 'Upload an encrypted file to a bucket.', {}, function (options) {
+    program.uploadEncryptedFile(options, console.log);
+  })
+  .command('download <bucket> <srcFile> <destFile> <key>', 'Download an encrypted file from a bucket.', {}, function (options) {
+    program.downloadEncryptedFile(options, console.log);
+  })
+  .command('rotate <bucket> <file> <oldkey> <newKey>', 'Rotate encryption keys for a file.', {}, function () {
+    program.rotateEncryptionKey(console.log);
+  })
+  .example('node $0 generate-encryption-key', 'Generate a sample encryption key.')
+  .example('node $0 upload my-bucket resources/test.txt file_encrypted.txt QxhqaZEqBGVTW55HhQw9Q=', 'Upload "resources/test.txt" to "gs://my-bucket/file_encrypted.txt".')
+  .example('node $0 download my-bucket file_encrypted.txt ./file.txt QxhqaZEqBGVTW55HhQw9Q=', 'Download "gs://my-bucket/file_encrypted.txt" to "./file.txt".')
+  .example('node $0 rotate my-bucket file_encrypted.txt QxhqaZEqBGVTW55HhQw9Q= SxafpsdfSDFS89sds9Q=', 'Rotate encryptiong keys for "gs://my-bucket/file_encrypted.txt".')
+  .wrap(120)
+  .recommendCommands()
+  .epilogue('For more information, see https://cloud.google.com/storage/docs');
+
 if (module === require.main) {
-  program.main(process.argv.slice(2), console.log);
+  program.main(process.argv.slice(2));
 }
-// [END all]
-
-module.exports = program;
diff --git a/storage/files.js b/storage/files.js
index 55f9834503..b045666890 100644
--- a/storage/files.js
+++ b/storage/files.js
@@ -25,7 +25,7 @@ var Storage = require('@google-cloud/storage');
 var storage = Storage();
 // [END setup]
 
-// [START list]
+// [START list_files]
 /**
  * Lists files in a bucket.
  *
@@ -33,24 +33,21 @@ var storage = Storage();
  * @param {function} cb The callback function.
  */
 function listFiles (name, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  }
-
   var bucket = storage.bucket(name);
 
-  bucket.getFiles(function (err, files, apiResponse) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
+  bucket.getFiles(function (err, files) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Found %d files!', files.length);
+    console.log('Found %d file(s)!', files.length);
     return callback(null, files);
   });
 }
-// [END list]
+// [END list_files]
 
-// [START listPrefix]
+// [START list_files_with_prefix]
 /**
  * Lists files in a bucket that match a certain prefix.
  *
@@ -72,287 +69,220 @@ function listFiles (name, callback) {
  *
  *   /a/1.txt
  *
- * @param {string} name The name of the bucket.
- * @param {string} prefix Filter results to objects whose names begin with this prefix.
- * @param {string} [delimiter] Results will contain only objects whose names, aside from the prefix, do not contain delimiter.
+ * @param {object} options Configuration options.
+ * @param {string} options.bucket The name of the bucket.
+ * @param {string} options.prefix Filter results to objects whose names begin
+ *     with this prefix.
+ * @param {string} [options.delimiter] Optional. Results will contain only
+ *     objects whose names, aside from the prefix, do not contain delimiter.
  * @param {function} cb The callback function.
  */
-function listFilesWithPrefix (name, prefix, delimiter, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  } else if (!prefix) {
-    return callback(new Error('"prefix" is required!'));
-  }
+function listFilesByPrefix (options, callback) {
+  var bucket = storage.bucket(options.bucket);
 
-  var bucket = storage.bucket(name);
-  var options = {
-    prefix: prefix
+  var config = {
+    prefix: options.prefix
   };
-  if (delimiter && typeof delimiter === 'string') {
-    options.delimiter = delimiter;
+  if (options.delimiter) {
+    config.delimiter = options.delimiter;
   }
 
-  bucket.getFiles(options, function (err, files, apiResponse) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
+  bucket.getFiles(config, function (err, files) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Found %d files!', files.length);
+    console.log('Found %d file(s)!', files.length);
     return callback(null, files);
   });
 }
-// [END listPrefix]
+// [END list_files_with_prefix]
 
-// [START upload]
+// [START upload_file]
 /**
  * Upload a file to a bucket.
  *
- * @param {string} name The name of the bucket.
- * @param {string} fileName The name of the file.
+ * @param {object} options Configuration options.
+ * @param {string} options.bucket The name of the bucket.
+ * @param {string} options.srcFile The name of the file.
  * @param {function} cb The callback function.
  */
-function uploadFile (name, fileName, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  } else if (!fileName) {
-    return callback(new Error('"fileName" is required!'));
-  }
-
-  var bucket = storage.bucket(name);
+function uploadFile (options, callback) {
+  var bucket = storage.bucket(options.bucket);
 
-  bucket.upload(fileName, function (err, file) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/bucket
+  bucket.upload(options.srcFile, function (err, file) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Uploaded file: %s', fileName);
+    console.log('Uploaded gs://%s/%s', options.bucket, options.srcFile);
     return callback(null, file);
   });
 }
-// [END upload]
+// [END upload_file]
 
-// [START download]
+// [START download_file]
 /**
  * Download a file from a bucket.
  *
- * @param {string} name The name of the bucket.
- * @param {string} srcFileName The source file name.
- * @param {string} destFileName The destination file name.
+ * @param {object} options Configuration options.
+ * @param {string} options.bucket The name of the bucket.
+ * @param {string} options.srcFile The source file name.
+ * @param {string} options.destFile The destination file name.
  * @param {function} cb The callback function.
  */
-function downloadFile (name, srcFileName, destFileName, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  } else if (!srcFileName) {
-    return callback(new Error('"srcFileName" is required!'));
-  } else if (!destFileName) {
-    return callback(new Error('"destFileName" is required!'));
-  }
+function downloadFile (options, callback) {
+  var file = storage.bucket(options.bucket).file(options.srcFile);
 
-  var bucket = storage.bucket(name);
-  var file = bucket.file(srcFileName);
-  var options = {
-    destination: destFileName
+  var config = {
+    destination: options.destFile
   };
 
-  file.download(options, function (err) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
+  file.download(config, function (err) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Downloaded %s to %s', srcFileName, destFileName);
+    console.log('Downloaded gs://%s/%s to %s', options.bucket, options.srcFile, options.destFile);
     return callback(null);
   });
 }
-// [END download]
+// [END download_file]
 
-// [START delete]
+// [START delete_file]
 /**
  * Delete a file from a bucket.
  *
- * @param {string} name The name of the bucket.
- * @param {string} fileName The file to delete.
+ * @param {object} options Configuration options.
+ * @param {string} options.bucket The name of the bucket.
+ * @param {string} options.file The name of the file to delete.
  * @param {function} cb The callback function.
  */
-function deleteFile (name, fileName, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  } else if (!fileName) {
-    return callback(new Error('"fileName" is required!'));
-  }
-
-  var bucket = storage.bucket(name);
-  var file = bucket.file(fileName);
+function deleteFile (options, callback) {
+  var file = storage.bucket(options.bucket).file(options.file);
 
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
   file.delete(function (err) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Deleted file: %s', fileName);
+    console.log('Deleted gs://%s/%s', options.bucket, options.file);
     return callback(null);
   });
 }
-// [END delete]
+// [END delete_file]
 
-// [START metadata]
+// [START get_metadata]
 /**
  * Get a file's metadata.
  *
- * @param {string} name The name of the bucket.
- * @param {string} fileName The name of the file.
+ * @param {object} options Configuration options.
+ * @param {string} options.bucket The name of the bucket.
+ * @param {string} options.file The name of the file.
  * @param {function} cb The callback function.
  */
-function getMetadata (name, fileName, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  } else if (!fileName) {
-    return callback(new Error('"fileName" is required!'));
-  }
-
-  var bucket = storage.bucket(name);
-  var file = bucket.file(fileName);
+function getMetadata (options, callback) {
+  var file = storage.bucket(options.bucket).file(options.file);
 
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
   file.getMetadata(function (err, metadata) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Got metadata for file: %s', fileName);
+    console.log('Got metadata for gs://%s/%s', options.bucket, options.file);
     return callback(null, metadata);
   });
 }
-// [END metadata]
+// [END get_metadata]
 
 // [START public]
 /**
  * Make a file public.
  *
- * @param {string} name The name of the bucket.
- * @param {string} fileName The name of the file to make public.
+ * @param {object} options Configuration options.
+ * @param {string} options.bucket The name of the bucket.
+ * @param {string} options.file The name of the file to make public.
  * @param {function} cb The callback function.
  */
-function makePublic (name, fileName, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  } else if (!fileName) {
-    return callback(new Error('"fileName" is required!'));
-  }
+function makePublic (options, callback) {
+  var file = storage.bucket(options.bucket).file(options.file);
 
-  var bucket = storage.bucket(name);
-  var file = bucket.file(fileName);
-
-  file.makePublic(function (err, apiResponse) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
+  file.makePublic(function (err) {
     if (err) {
       return callback(err);
     }
 
-    console.log('Made %s public!', fileName);
-    return callback(null, apiResponse);
+    console.log('Made gs://%s/%s public!', options.bucket, options.file);
+    return callback(null);
   });
 }
 // [END public]
 
-// [START move]
+// [START move_file]
 /**
- * Move a file to a new location within the same bucket.
+ * Move a file to a new location within the same bucket, i.e. rename the file.
  *
- * @param {string} name The name of the bucket.
- * @param {string} srcFileName The source file name.
- * @param {string} destFileName The destination file name.
+ * @param {object} options Configuration options.
+ * @param {string} options.bucket The name of the bucket.
+ * @param {string} options.srcFile The source file name.
+ * @param {string} options.destFile The destination file name.
  * @param {function} cb The callback function.
  */
-function moveFile (name, srcFileName, destFileName, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  } else if (!srcFileName) {
-    return callback(new Error('"srcFileName" is required!'));
-  } else if (!destFileName) {
-    return callback(new Error('"destFileName" is required!'));
-  }
+function moveFile (options, callback) {
+  var file = storage.bucket(options.bucket).file(options.srcFile);
 
-  var bucket = storage.bucket(name);
-  var file = bucket.file(srcFileName);
-
-  file.move(destFileName, function (err, file) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
+  file.move(options.destFile, function (err, file) {
     if (err) {
       return callback(err);
     }
 
-    console.log('%s moved to %s', srcFileName, destFileName);
+    console.log('Renamed gs://%s/%s to gs://%s/%s', options.bucket, options.srcFile, options.bucket, options.destFile);
     return callback(null, file);
   });
 }
-// [END move]
+// [END move_file]
 
-// [START copy]
+// [START copy_file]
 /**
  * Copy a file to a new bucket with a new name.
  *
- * @param {string} name The name of the bucket.
- * @param {string} srcFileName The source file name.
- * @param {string} destBucketName The destination bucket name.
- * @param {string} destFileName The destination file name.
+ * @param {object} options Configuration options.
+ * @param {string} options.srcBucket The name of the bucket.
+ * @param {string} options.srcFile The source file name.
+ * @param {string} options.destBucket The destination bucket name.
+ * @param {string} options.destFile The destination file name.
  * @param {function} cb The callback function.
  */
-function copyFile (name, srcFileName, destBucketName, destFileName, callback) {
-  if (!name) {
-    return callback(new Error('"name" is required!'));
-  } else if (!srcFileName) {
-    return callback(new Error('"srcFileName" is required!'));
-  } else if (!destBucketName) {
-    return callback(new Error('"destBucketName" is required!'));
-  } else if (!destFileName) {
-    return callback(new Error('"destFileName" is required!'));
-  }
-
-  var bucket = storage.bucket(name);
-  var file = bucket.file(srcFileName);
-  var newBucket = storage.bucket(destBucketName);
-  var newFile = newBucket.file(destFileName);
+function copyFile (options, callback) {
+  var file = storage.bucket(options.srcBucket).file(options.srcFile);
+  var copy = storage.bucket(options.destBucket).file(options.destFile);
 
-  file.move(newFile, function (err, file) {
+  // See https://googlecloudplatform.github.io/gcloud-node/#/docs/storage/latest/storage/file
+  file.copy(copy, function (err, file) {
     if (err) {
       return callback(err);
     }
 
-    console.log('%s moved to %s in %s', srcFileName, destFileName, destBucketName);
+    console.log('Copied gs://%s/%s to gs://%s/%s', options.srcBucket, options.srcFile, options.destBucket, options.destFile);
     return callback(null, file);
   });
 }
-// [END copy]
-
-// [START usage]
-function printUsage () {
-  console.log('Usage: node files COMMAND [ARGS...]');
-  console.log('\nCommands:\n');
-  console.log('\tlist BUCKET_NAME');
-  console.log('\tlistByPrefix BUCKET_NAME PREFIX [DELIMITER]');
-  console.log('\tupload BUCKET_NAME FILE_NAME');
-  console.log('\tdownload BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME');
-  console.log('\tdelete BUCKET_NAME FILE_NAME');
-  console.log('\tgetMetadata BUCKET_NAME FILE_NAME');
-  console.log('\tmakePublic BUCKET_NAME FILE_NAME');
-  console.log('\tmove BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME');
-  console.log('\tcopy BUCKET_NAME SRC_FILE_NAME DEST_BUCKET_NAME DEST_FILE_NAME');
-  console.log('\nExamples:\n');
-  console.log('\tlist my-bucket');
-  console.log('\tlistByPrefix my-bucket /some-folder');
-  console.log('\tlistByPrefix my-bucket /some-folder -');
-  console.log('\tupload my-bucket ./file.txt');
-  console.log('\tdownload my-bucket file.txt ./file.txt');
-  console.log('\tdelete my-bucket file.txt');
-  console.log('\tgetMetadata my-bucket file.txt');
-  console.log('\tmakePublic my-bucket file.txt');
-  console.log('\tmove my-bucket file.txt file2.txt');
-  console.log('\tcopy my-bucket file.txt my-other-bucket file.txt');
-}
-// [END usage]
+// [END copy_file]
+// [END all]
 
 // The command-line program
-var program = {
+var cli = require('yargs');
+
+var program = module.exports = {
   listFiles: listFiles,
-  listFilesWithPrefix: listFilesWithPrefix,
+  listFilesByPrefix: listFilesByPrefix,
   uploadFile: uploadFile,
   downloadFile: downloadFile,
   deleteFile: deleteFile,
@@ -360,38 +290,68 @@ var program = {
   makePublic: makePublic,
   moveFile: moveFile,
   copyFile: copyFile,
-  printUsage: printUsage,
-
-  // Executed when this program is run from the command-line
-  main: function (args, cb) {
-    var command = args.shift();
-    if (command === 'list') {
-      this.listFiles(args[0], cb);
-    } else if (command === 'listByPrefix') {
-      this.listFilesWithPrefix(args[0], args[1], args[2], cb);
-    } else if (command === 'upload') {
-      this.uploadFile(args[0], args[1], cb);
-    } else if (command === 'download') {
-      this.downloadFile(args[0], args[1], args[2], cb);
-    } else if (command === 'delete') {
-      this.deleteFile(args[0], args[1], cb);
-    } else if (command === 'getMetadata') {
-      this.getMetadata(args[0], args[1], cb);
-    } else if (command === 'makePublic') {
-      this.makePublic(args[0], args[1], cb);
-    } else if (command === 'move') {
-      this.moveFile(args[0], args[1], args[2], cb);
-    } else if (command === 'copy') {
-      this.copyFile(args[0], args[1], args[2], args[3], cb);
-    } else {
-      this.printUsage();
-    }
+  main: function (args) {
+    // Run the command-line program
+    cli.help().strict().parse(args).argv;
   }
 };
 
+cli
+  .demand(1)
+  .command('list <bucket> [options]', 'List files in a bucket, optionally filtering by a prefix.', {
+    prefix: {
+      alias: 'p',
+      requiresArg: true,
+      type: 'string',
+      description: 'Filter files by a prefix.'
+    },
+    delimiter: {
+      alias: 'd',
+      requiresArg: true,
+      type: 'string',
+      description: 'Specify a delimiter.'
+    }
+  }, function (options) {
+    if (options.prefix) {
+      program.listFilesByPrefix(options, console.log);
+    } else {
+      program.listFiles(options.bucket, console.log);
+    }
+  })
+  .command('upload <bucket> <srcFile>', 'Upload a local file to a bucket.', {}, function (options) {
+    program.uploadFile(options, console.log);
+  })
+  .command('download <bucket> <srcFile> <destFile>', 'Download a file from a bucket.', {}, function (options) {
+    program.downloadFile(options, console.log);
+  })
+  .command('delete <bucket> <file>', 'Delete a file from a bucket.', {}, function (options) {
+    program.deleteFile(options, console.log);
+  })
+  .command('getMetadata <bucket> <file>', 'Get metadata for a file in a bucket.', {}, function (options) {
+    program.getMetadata(options, console.log);
+  })
+  .command('makePublic <bucket> <file>', 'Make a file public in a bucket.', {}, function (options) {
+    program.makePublic(options, console.log);
+  })
+  .command('move <bucket> <srcFile> <destFile>', 'Move a file to a new location within the same bucket, i.e. rename the file.', {}, function (options) {
+    program.moveFile(options, console.log);
+  })
+  .command('copy <srcBucket> <srcFile> <destBucket> <destFile>', 'Copy a file in a bucket to another bucket.', {}, function (options) {
+    program.copyFile(options, console.log);
+  })
+  .example('node $0 list my-bucket', 'List files in "my-bucket".')
+  .example('node $0 list my-bucket -p public/', 'List files in "my-bucket" filtered by prefix "public/".')
+  .example('node $0 upload my-bucket ./file.txt', 'Upload "./file.txt" to "my-bucket".')
+  .example('node $0 download my-bucket file.txt ./file.txt', 'Download "gs://my-bucket/file.txt" to "./file.txt".')
+  .example('node $0 delete my-bucket file.txt', 'Delete "gs://my-bucket/file.txt".')
+  .example('node $0 getMetadata my-bucket file.txt', 'Get metadata for "gs://my-bucket/file.txt".')
+  .example('node $0 makePublic my-bucket file.txt', 'Make "gs://my-bucket/file.txt" public.')
+  .example('node $0 move my-bucket file.txt file2.txt', 'Rename "gs://my-bucket/file.txt" to "gs://my-bucket/file2.txt".')
+  .example('node $0 copy my-bucket file.txt my-other-bucket file.txt', 'Copy "gs://my-bucket/file.txt" to "gs://my-other-bucket/file.txt".')
+  .wrap(100)
+  .recommendCommands()
+  .epilogue('For more information, see https://cloud.google.com/storage/docs');
+
 if (module === require.main) {
-  program.main(process.argv.slice(2), console.log);
+  program.main(process.argv.slice(2));
 }
-// [END all]
-
-module.exports = program;
diff --git a/storage/iam.js b/storage/iam.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/storage/system-test/buckets.test.js b/storage/system-test/buckets.test.js
index c548634294..d89312b08c 100644
--- a/storage/system-test/buckets.test.js
+++ b/storage/system-test/buckets.test.js
@@ -14,13 +14,13 @@
 'use strict';
 
 var uuid = require('node-uuid');
-var bucketsExample = require('../buckets');
+var program = require('../buckets');
 var bucketName = 'nodejs-docs-samples-test-' + uuid.v4();
 
 describe('storage:buckets', function () {
   describe('create', function () {
     it('should create a bucket', function (done) {
-      bucketsExample.createBucket(bucketName, function (err, bucket) {
+      program.createBucket(bucketName, function (err, bucket) {
         assert.ifError(err);
         assert.equal(bucket.name, bucketName);
         assert(console.log.calledWith('Created bucket: %s', bucketName));
@@ -28,20 +28,22 @@ describe('storage:buckets', function () {
       });
     });
   });
+
   describe('list', function () {
     it('should list buckets', function (done) {
-      bucketsExample.listBuckets(function (err, buckets) {
+      program.listBuckets(function (err, buckets) {
         assert.ifError(err);
         assert(Array.isArray(buckets));
         assert(buckets.length > 0);
-        assert(console.log.calledWith('Found %d buckets!', buckets.length));
+        assert(console.log.calledWith('Found %d bucket(s)!', buckets.length));
         setTimeout(done, 2000);
       });
     });
   });
+
   describe('delete', function () {
     it('should delete a bucket', function (done) {
-      bucketsExample.deleteBucket(bucketName, function (err, apiResponse) {
+      program.deleteBucket(bucketName, function (err, apiResponse) {
         assert.ifError(err);
         assert(console.log.calledWith('Deleted bucket: %s', bucketName));
         done();
diff --git a/storage/system-test/encryption.test.js b/storage/system-test/encryption.test.js
index 21a405ae83..5d8d3de41c 100644
--- a/storage/system-test/encryption.test.js
+++ b/storage/system-test/encryption.test.js
@@ -54,11 +54,18 @@ describe('storage:encryption', function () {
 
   describe('uploadEncryptedFile', function () {
     it('should upload a file', function (done) {
-      program.uploadEncryptedFile(bucketName, filePath, fileName, key, function (err, file) {
+      var options = {
+        bucket: bucketName,
+        srcFile: filePath,
+        destFile: fileName,
+        key: key
+      };
+
+      program.uploadEncryptedFile(options, function (err, file) {
         assert.ifError(err);
         assert(file);
         assert.equal(file.name, fileName);
-        assert(console.log.calledWith('Uploaded encrypted file: %s', fileName));
+        assert(console.log.calledWith('Uploaded gs://%s/%s', options.bucket, options.destFile));
         done();
       });
     });
@@ -66,12 +73,19 @@ describe('storage:encryption', function () {
 
   describe('downloadEncryptedFile', function () {
     it('should download a file', function (done) {
-      program.downloadEncryptedFile(bucketName, fileName, downloadFilePath, key, function (err) {
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: downloadFilePath,
+        key: key
+      };
+
+      program.downloadEncryptedFile(options, function (err) {
         assert.ifError(err);
         assert.doesNotThrow(function () {
           fs.statSync(downloadFilePath);
         });
-        assert(console.log.calledWith('Downloaded encrypted file: %s', downloadFilePath));
+        assert(console.log.calledWith('Downloaded gs://%s/%s to %s', options.bucket, options.srcFile, options.destFile));
         done();
       });
     });
diff --git a/storage/system-test/files.test.js b/storage/system-test/files.test.js
index 34930ae135..7d9298ae0e 100644
--- a/storage/system-test/files.test.js
+++ b/storage/system-test/files.test.js
@@ -31,6 +31,7 @@ describe('storage:files', function () {
   before(function (done) {
     storage.createBucket(bucketName, done);
   });
+
   after(function (done) {
     try {
       fs.unlinkSync(downloadFilePath);
@@ -44,39 +45,60 @@ describe('storage:files', function () {
       storage.bucket(bucketName).delete(done);
     });
   });
+
   describe('uploadFile', function () {
     it('should upload a file', function (done) {
-      filesExample.uploadFile(bucketName, filePath, function (err, file) {
+      var options = {
+        bucket: bucketName,
+        srcFile: filePath
+      };
+
+      filesExample.uploadFile(options, function (err, file) {
         assert.ifError(err);
         assert(file);
         assert.equal(file.name, fileName);
-        assert(console.log.calledWith('Uploaded file: %s', filePath));
+        assert(console.log.calledWith('Uploaded gs://%s/%s', options.bucket, options.srcFile));
         done();
       });
     });
   });
+
   describe('downloadFile', function () {
     it('should download a file', function (done) {
-      filesExample.downloadFile(bucketName, fileName, downloadFilePath, function (err) {
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: downloadFilePath
+      };
+
+      filesExample.downloadFile(options, function (err) {
         assert.ifError(err);
         assert.doesNotThrow(function () {
           fs.statSync(downloadFilePath);
         });
-        assert(console.log.calledWith('Downloaded %s to %s', fileName, downloadFilePath));
+        assert(console.log.calledWith('Downloaded gs://%s/%s to %s', options.bucket, options.srcFile, options.destFile));
         done();
       });
     });
   });
+
   describe('moveFile', function () {
     it('should move a file', function (done) {
-      filesExample.moveFile(bucketName, fileName, movedFileName, function (err, file) {
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: movedFileName
+      };
+
+      filesExample.moveFile(options, function (err, file) {
         assert.ifError(err);
         assert.equal(file.name, movedFileName);
-        assert(console.log.calledWith('%s moved to %s', fileName, movedFileName));
+        assert(console.log.calledWith('Renamed gs://%s/%s to gs://%s/%s', options.bucket, options.srcFile, options.bucket, options.destFile));
         done();
       });
     });
   });
+
   describe('listFiles', function () {
     it('should list files', function (done) {
       filesExample.listFiles(bucketName, function (err, files) {
@@ -84,65 +106,103 @@ describe('storage:files', function () {
         assert(Array.isArray(files));
         assert.equal(files.length, 1);
         assert.equal(files[0].name, movedFileName);
-        assert(console.log.calledWith('Found %d files!', files.length));
+        assert(console.log.calledWith('Found %d file(s)!', files.length));
         done();
       });
     });
   });
+
   describe('copyFile', function () {
     it('should copy a file', function (done) {
-      filesExample.copyFile(bucketName, movedFileName, bucketName, copiedFileName, function (err, file) {
+      var options = {
+        srcBucket: bucketName,
+        srcFile: movedFileName,
+        destBucket: bucketName,
+        destFile: copiedFileName
+      };
+
+      filesExample.copyFile(options, function (err, file) {
         assert.ifError(err);
         assert.equal(file.name, copiedFileName);
-        assert(console.log.calledWith('%s moved to %s in %s', movedFileName, copiedFileName, bucketName));
+        assert(console.log.calledWith('Copied gs://%s/%s to gs://%s/%s', options.srcBucket, options.srcFile, options.destBucket, options.destFile));
         done();
       });
     });
   });
-  describe('listFilesWithPrefix', function () {
+
+  describe('listFilesByPrefix', function () {
     it('should list files by a prefix', function (done) {
-      filesExample.listFilesWithPrefix(bucketName, 'test', undefined, function (err, files) {
+      var options = {
+        bucket: bucketName,
+        prefix: 'test'
+      };
+
+      filesExample.listFilesByPrefix(options, function (err, files) {
         assert.ifError(err);
         assert(Array.isArray(files));
-        assert.equal(files.length, 1);
-        assert.equal(files[0].name, copiedFileName);
-        assert(console.log.calledWith('Found %d files!', files.length));
-        filesExample.listFilesWithPrefix(bucketName, 'foo', undefined, function (err, files) {
+        assert.equal(files.length, 2);
+        assert.equal(files[0].name, movedFileName);
+        assert.equal(files[1].name, copiedFileName);
+        assert(console.log.calledWith('Found %d file(s)!', files.length));
+
+        options = {
+          bucket: bucketName,
+          prefix: 'foo'
+        };
+
+        filesExample.listFilesByPrefix(options, function (err, files) {
           assert.ifError(err);
           assert(Array.isArray(files));
           assert.equal(files.length, 0);
-          assert(console.log.calledWith('Found %d files!', files.length));
+          assert(console.log.calledWith('Found %d file(s)!', files.length));
           done();
         });
       });
     });
   });
+
   describe('makePublic', function () {
     it('should make a file public', function (done) {
-      filesExample.makePublic(bucketName, copiedFileName, function (err, apiResponse) {
+      var options = {
+        bucket: bucketName,
+        file: copiedFileName
+      };
+
+      filesExample.makePublic(options, function (err) {
         assert.ifError(err);
-        assert(apiResponse);
-        assert(console.log.calledWith('Made %s public!', copiedFileName));
+        assert(console.log.calledWith('Made gs://%s/%s public!', options.bucket, options.file));
         done();
       });
     });
   });
+
   describe('getMetadata', function () {
     it('should get metadata for a file', function (done) {
-      filesExample.getMetadata(bucketName, copiedFileName, function (err, metadata) {
+      var options = {
+        bucket: bucketName,
+        file: copiedFileName
+      };
+
+      filesExample.getMetadata(options, function (err, metadata) {
         assert.ifError(err);
         assert(metadata);
         assert.equal(metadata.name, copiedFileName);
-        assert(console.log.calledWith('Got metadata for file: %s', copiedFileName));
+        assert(console.log.calledWith('Got metadata for gs://%s/%s', options.bucket, options.file));
         done();
       });
     });
   });
+
   describe('deleteFile', function () {
     it('should delete a file', function (done) {
-      filesExample.deleteFile(bucketName, copiedFileName, function (err) {
+      var options = {
+        bucket: bucketName,
+        file: copiedFileName
+      };
+
+      filesExample.deleteFile(options, function (err) {
         assert.ifError(err);
-        assert(console.log.calledWith('Deleted file: %s', copiedFileName));
+        assert(console.log.calledWith('Deleted gs://%s/%s', options.bucket, options.file));
         done();
       });
     });
diff --git a/storage/system-test/transfer.test.js b/storage/system-test/transfer.test.js
index 15687f3ca3..aabfd1eec2 100644
--- a/storage/system-test/transfer.test.js
+++ b/storage/system-test/transfer.test.js
@@ -58,7 +58,15 @@ describe('storage:transfer', function () {
 
   describe('createTransferJob', function () {
     it('should create a storage transfer job', function (done) {
-      program.createTransferJob(firstBucketName, secondBucketName, date, time, description, function (err, transferJob) {
+      var options = {
+        srcBucket: firstBucketName,
+        destBucket: secondBucketName,
+        date: date,
+        time: time,
+        description: description
+      };
+
+      program.createTransferJob(options, function (err, transferJob) {
         assert.ifError(err);
         jobName = transferJob.name;
         assert.equal(transferJob.name.indexOf('transferJobs/'), 0);
@@ -85,7 +93,13 @@ describe('storage:transfer', function () {
 
   describe('updateTransferJob', function () {
     it('should update a transferJob', function (done) {
-      program.updateTransferJob(jobName, 'status', status, function (err, transferJob) {
+      var options = {
+        job: jobName,
+        field: 'status',
+        value: status
+      };
+
+      program.updateTransferJob(options, function (err, transferJob) {
         assert.ifError(err);
         assert.equal(transferJob.name, jobName);
         assert.equal(transferJob.description, description);
diff --git a/storage/test/acl.test.js b/storage/test/acl.test.js
index 5f1aedad9e..b4aad8b18c 100644
--- a/storage/test/acl.test.js
+++ b/storage/test/acl.test.js
@@ -50,7 +50,8 @@ function getSample () {
 
   return {
     program: proxyquire('../acl', {
-      '@google-cloud/storage': StorageMock
+      '@google-cloud/storage': StorageMock,
+      yargs: proxyquire('yargs', {})
     }),
     mocks: {
       Storage: StorageMock,
@@ -63,7 +64,7 @@ function getSample () {
 }
 
 describe('storage:acl', function () {
-  describe('add', function () {
+  describe('addAccessControl', function () {
     it('should add access controls to bucket', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -87,6 +88,7 @@ describe('storage:acl', function () {
       assert.strictEqual(callback.firstCall.args[1], sample.mocks.aclObject, 'callback received acl object');
       assert(console.log.calledWith('Added access controls to: gs://%s', bucketName, ''));
     });
+
     it('should add "default" access controls to bucket', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -111,6 +113,7 @@ describe('storage:acl', function () {
       assert.strictEqual(callback.firstCall.args[1], sample.mocks.aclObject, 'callback received acl object');
       assert(console.log.calledWith('Added access controls to: gs://%s', bucketName, ''));
     });
+
     it('should add access controls to a file', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -135,6 +138,7 @@ describe('storage:acl', function () {
       assert.strictEqual(callback.firstCall.args[1], sample.mocks.aclObject, 'callback received acl object');
       assert(console.log.calledWith('Added access controls to: gs://%s/%s', bucketName, fileName));
     });
+
     it('should handle error', function () {
       var error = 'error';
       var sample = getSample();
@@ -154,7 +158,7 @@ describe('storage:acl', function () {
     });
   });
 
-  describe('get', function () {
+  describe('getAccessControl', function () {
     it('should get all access controls for a bucket', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -172,6 +176,7 @@ describe('storage:acl', function () {
       assert.strictEqual(callback.firstCall.args[1], sample.mocks.aclObject, 'callback received acl object');
       assert(console.log.calledWith('Got access controls for: gs://%s', bucketName, ''));
     });
+
     it('should get all "default" access controls for a bucket', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -190,6 +195,7 @@ describe('storage:acl', function () {
       assert.strictEqual(callback.firstCall.args[1], sample.mocks.aclObject, 'callback received acl object');
       assert(console.log.calledWith('Got access controls for: gs://%s', bucketName, ''));
     });
+
     it('should get an entity\'s access controls for a bucket', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -212,6 +218,7 @@ describe('storage:acl', function () {
       assert.strictEqual(callback.firstCall.args[1], sample.mocks.aclObject, 'callback received acl object');
       assert(console.log.calledWith('Got access controls for: gs://%s', bucketName, ''));
     });
+
     it('should get an entity\'s "default" access controls for a bucket', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -235,6 +242,7 @@ describe('storage:acl', function () {
       assert.strictEqual(callback.firstCall.args[1], sample.mocks.aclObject, 'callback received acl object');
       assert(console.log.calledWith('Got access controls for: gs://%s', bucketName, ''));
     });
+
     it('should get access controls for a file', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -253,6 +261,7 @@ describe('storage:acl', function () {
       assert.strictEqual(callback.firstCall.args[1], sample.mocks.aclObject, 'callback received acl object');
       assert(console.log.calledWith('Got access controls for: gs://%s/%s', bucketName, fileName));
     });
+
     it('should handle error', function () {
       var error = 'error';
       var sample = getSample();
@@ -271,7 +280,7 @@ describe('storage:acl', function () {
     });
   });
 
-  describe('delete', function () {
+  describe('deleteAccessControl', function () {
     it('should delete an entity\'s access controls from a bucket', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -293,6 +302,7 @@ describe('storage:acl', function () {
       assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
       assert(console.log.calledWith('Deleted access controls from: gs://%s', bucketName, ''));
     });
+
     it('should delete an entity\'s "default" access controls from a bucket', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -315,6 +325,7 @@ describe('storage:acl', function () {
       assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
       assert(console.log.calledWith('Deleted access controls from: gs://%s', bucketName, ''));
     });
+
     it('should delete access controls from a file', function () {
       var sample = getSample();
       var callback = sinon.stub();
@@ -333,6 +344,7 @@ describe('storage:acl', function () {
       assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
       assert(console.log.calledWith('Deleted access controls from: gs://%s/%s', bucketName, fileName));
     });
+
     it('should handle error', function () {
       var error = 'error';
       var sample = getSample();
@@ -356,7 +368,7 @@ describe('storage:acl', function () {
       var program = getSample().program;
 
       sinon.stub(program, 'addAccessControl');
-      program.main(['add', 'owners-1234', 'OWNER', '-b', 'nodejs-docs-samples']);
+      program.main(['add', entity, role, '-b', bucketName]);
       assert(program.addAccessControl.calledOnce);
     });
 
@@ -364,15 +376,15 @@ describe('storage:acl', function () {
       var program = getSample().program;
 
       sinon.stub(program, 'getAccessControl');
-      program.main(['get', 'owners-1234', '-b', 'nodejs-docs-samples']);
+      program.main(['get', entity, '-b', bucketName]);
       assert(program.getAccessControl.calledOnce);
     });
 
-    it('should call getAccessControl', function () {
+    it('should call deleteAccessControl', function () {
       var program = getSample().program;
 
       sinon.stub(program, 'deleteAccessControl');
-      program.main(['delete', 'owners-1234', '-b', 'nodejs-docs-samples']);
+      program.main(['delete', entity, '-b', bucketName]);
       assert(program.deleteAccessControl.calledOnce);
     });
   });
diff --git a/storage/test/buckets.test.js b/storage/test/buckets.test.js
index ebc70edde2..c3ee06839a 100644
--- a/storage/test/buckets.test.js
+++ b/storage/test/buckets.test.js
@@ -24,17 +24,19 @@ function getSample () {
     }
   ];
   var bucketMock = {
+    create: sinon.stub().callsArgWith(0, null, bucketsMock[0]),
     delete: sinon.stub().callsArgWith(0, null)
   };
   var storageMock = {
-    createBucket: sinon.stub().callsArgWith(1, null, bucketsMock[0]),
     getBuckets: sinon.stub().callsArgWith(0, null, bucketsMock, null, bucketsMock),
     bucket: sinon.stub().returns(bucketMock)
   };
   var StorageMock = sinon.stub().returns(storageMock);
+
   return {
-    sample: proxyquire('../buckets', {
-      '@google-cloud/storage': StorageMock
+    program: proxyquire('../buckets', {
+      '@google-cloud/storage': StorageMock,
+      yargs: proxyquire('yargs', {})
     }),
     mocks: {
       Storage: StorageMock,
@@ -46,123 +48,123 @@ function getSample () {
 }
 
 describe('storage:buckets', function () {
-  describe('create', function () {
+  describe('createBucket', function () {
     it('should create a bucket', function () {
-      var bucketsSample = getSample();
-
-      bucketsSample.sample.createBucket(bucketName, function (err, bucket) {
-        assert.ifError(err);
-        assert.strictEqual(bucket, bucketsSample.mocks.buckets[0]);
-        assert(console.log.calledWith('Created bucket: %s', bucketName));
-      });
-    });
-    it('should require name', function () {
-      var bucketsSample = getSample();
-
-      bucketsSample.sample.createBucket(undefined, function (err, bucket) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-        assert.equal(bucket, undefined);
-      });
+      var sample = getSample();
+      var callback = sinon.stub();
+
+      sample.program.createBucket(bucketName, callback);
+
+      assert(sample.mocks.bucket.create.calledOnce, 'create called once');
+      assert.equal(sample.mocks.bucket.create.firstCall.args.length, 1, 'create received 1 argument');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.buckets[0], 'callback received bucket');
+      assert(console.log.calledWith('Created bucket: %s', bucketName));
     });
+
     it('should handle error', function () {
-      var error = 'createError';
-      var bucketsSample = getSample();
-      bucketsSample.mocks.storage.createBucket = sinon.stub().callsArgWith(1, error);
-
-      bucketsSample.sample.createBucket(bucketName, function (err, bucket) {
-        assert.equal(err, error);
-        assert.equal(bucket, undefined);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      sample.mocks.bucket.create = sinon.stub().callsArgWith(0, error);
+
+      sample.program.createBucket(bucketName, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
-  describe('list', function () {
-    it('should list buckets', function () {
-      var bucketsSample = getSample();
 
-      bucketsSample.sample.listBuckets(function (err, buckets) {
-        assert.ifError(err);
-        assert.strictEqual(buckets, bucketsSample.mocks.buckets);
-        assert(console.log.calledWith('Found %d buckets!', bucketsSample.mocks.buckets.length));
-      });
+  describe('listBuckets', function () {
+    it('should list buckets', function () {
+      var sample = getSample();
+      var callback = sinon.stub();
+
+      sample.program.listBuckets(callback);
+
+      assert(sample.mocks.storage.getBuckets.calledOnce, 'getBuckets called once');
+      assert.equal(sample.mocks.storage.getBuckets.firstCall.args.length, 1, 'getBuckets received 1 argument');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.buckets, 'callback received buckets');
+      assert(console.log.calledWith('Found %d bucket(s)!', sample.mocks.buckets.length));
     });
+
     it('should handle error', function () {
-      var error = 'listError';
-      var bucketsSample = getSample();
-      bucketsSample.mocks.storage.getBuckets = sinon.stub().callsArgWith(0, error);
-
-      bucketsSample.sample.listBuckets(function (err, buckets) {
-        assert.equal(err, error);
-        assert.equal(buckets, undefined);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      sample.mocks.storage.getBuckets = sinon.stub().callsArgWith(0, error);
+
+      sample.program.listBuckets(callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
-  describe('delete', function () {
-    it('should delete a bucket', function () {
-      var bucketsSample = getSample();
 
-      bucketsSample.sample.deleteBucket(bucketName, function (err, apiResponse) {
-        assert.ifError(err);
-        assert.equal(bucketsSample.mocks.storage.bucket.firstCall.args[0], bucketName);
-        assert(console.log.calledWith('Deleted bucket: %s', bucketName));
-      });
-    });
-    it('should require name', function () {
-      var bucketsSample = getSample();
-
-      bucketsSample.sample.deleteBucket(undefined, function (err, apiResponse) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-        assert.equal(apiResponse, undefined);
-      });
+  describe('deleteBuckets', function () {
+    it('should delete a bucket', function () {
+      var sample = getSample();
+      var callback = sinon.stub();
+
+      sample.program.deleteBucket(bucketName, callback);
+
+      assert(sample.mocks.bucket.delete.calledOnce, 'delete called once');
+      assert.equal(sample.mocks.bucket.delete.firstCall.args.length, 1, 'delete received 1 argument');
+      assert.equal(sample.mocks.storage.bucket.firstCall.args[0], bucketName);
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.aclObject, 'callback received acl object');
+      assert(console.log.calledWith('Deleted bucket: %s', bucketName));
     });
+
     it('should handle error', function () {
-      var error = 'deleteError';
-      var bucketsSample = getSample();
-      bucketsSample.mocks.bucket.delete = sinon.stub().callsArgWith(0, error);
-
-      bucketsSample.sample.deleteBucket(bucketName, function (err, apiResponse) {
-        assert.equal(err, error);
-        assert.equal(apiResponse, undefined);
-      });
-    });
-  });
-  describe('printUsage', function () {
-    it('should print usage', function () {
-      var bucketsSample = getSample();
-
-      bucketsSample.sample.printUsage();
-
-      assert(console.log.calledWith('Usage: node buckets COMMAND [ARGS...]'));
-      assert(console.log.calledWith('\nCommands:\n'));
-      assert(console.log.calledWith('\tcreate BUCKET_NAME'));
-      assert(console.log.calledWith('\tlist'));
-      assert(console.log.calledWith('\tdelete BUCKET_NAME'));
-      assert(console.log.calledWith('\nExamples:\n'));
-      assert(console.log.calledWith('\tnode buckets create my-bucket'));
-      assert(console.log.calledWith('\tnode buckets list'));
-      assert(console.log.calledWith('\tnode buckets delete my-bucket'));
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      sample.mocks.bucket.delete = sinon.stub().callsArgWith(0, error);
+
+      sample.program.deleteBucket(bucketName, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
+
   describe('main', function () {
-    it('should call the right commands', function () {
-      var program = getSample().sample;
+    it('should call createBucket', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'createBucket');
-      program.main(['create']);
+      program.main(['create', 'my-bucket']);
       assert(program.createBucket.calledOnce);
+    });
+
+    it('should call listBuckets', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'listBuckets');
       program.main(['list']);
       assert(program.listBuckets.calledOnce);
+    });
+
+    it('should call deleteBucket', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'deleteBucket');
-      program.main(['delete']);
+      program.main(['delete', 'my-bucket']);
       assert(program.deleteBucket.calledOnce);
-
-      sinon.stub(program, 'printUsage');
-      program.main(['--help']);
-      assert(program.printUsage.calledOnce);
     });
   });
 });
diff --git a/storage/test/encryption.test.js b/storage/test/encryption.test.js
index b094fae394..59ca5c2d9b 100644
--- a/storage/test/encryption.test.js
+++ b/storage/test/encryption.test.js
@@ -15,6 +15,8 @@
 
 var proxyquire = require('proxyquire').noCallThru();
 var bucketName = 'foo';
+var fileName = 'file.txt';
+var key = 'keyboard-cat';
 
 function getSample () {
   var filesMock = [
@@ -37,7 +39,8 @@ function getSample () {
   var StorageMock = sinon.stub().returns(storageMock);
   return {
     program: proxyquire('../encryption', {
-      '@google-cloud/storage': StorageMock
+      '@google-cloud/storage': StorageMock,
+      yargs: proxyquire('yargs', {})
     }),
     mocks: {
       Storage: StorageMock,
@@ -60,121 +63,95 @@ describe('storage:encryption', function () {
   });
 
   describe('uploadEncryptedFile', function () {
-    var fileName = 'test.txt';
     it('should upload a file', function () {
       var sample = getSample();
-
-      sample.program.uploadEncryptedFile(bucketName, fileName, fileName, 'key', function (err, file) {
-        assert.ifError(err);
-        assert.strictEqual(file, sample.mocks.files[0]);
-        assert(console.log.calledWith('Uploaded encrypted file: %s', fileName));
-      });
-    });
-    it('should require bucket', function () {
-      var sample = getSample();
-
-      sample.program.uploadEncryptedFile(undefined, undefined, undefined, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"bucket" is required!');
-        assert.equal(file, undefined);
-      });
-    });
-    it('should require srcFileName', function () {
-      var sample = getSample();
-
-      sample.program.uploadEncryptedFile(bucketName, undefined, undefined, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"srcFileName" is required!');
-        assert.equal(file, undefined);
-      });
-    });
-    it('should require destFileName', function () {
-      var sample = getSample();
-
-      sample.program.uploadEncryptedFile(bucketName, fileName, undefined, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"destFileName" is required!');
-        assert.equal(file, undefined);
-      });
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName,
+        key: key
+      };
+
+      sample.program.uploadEncryptedFile(options, callback);
+
+      assert(sample.mocks.bucket.upload.calledOnce, 'upload called once');
+      assert.equal(sample.mocks.bucket.upload.firstCall.args.length, 3, 'upload received 3 arguments');
+      assert.deepEqual(sample.mocks.bucket.upload.firstCall.args[0], fileName, 'upload received file name');
+      assert.deepEqual(sample.mocks.bucket.upload.firstCall.args[1], {
+        destination: options.destFile,
+        encryptionKey: new Buffer(options.key, 'base64')
+      }, 'upload received config');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.files[0], 'callback received file');
+      assert(console.log.calledWith('Uploaded gs://%s/%s', options.bucket, options.destFile));
     });
-    it('should require key', function () {
-      var sample = getSample();
 
-      sample.program.uploadEncryptedFile(bucketName, fileName, fileName, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"key" is required!');
-        assert.equal(file, undefined);
-      });
-    });
     it('should handle error', function () {
       var error = 'error';
       var sample = getSample();
-      sample.mocks.bucket.upload = sinon.stub().callsArgWith(2, new Error(error));
-
-      sample.program.uploadEncryptedFile(bucketName, fileName, fileName, 'key', function (err, file) {
-        assert(err);
-        assert.equal(err.message, error);
-        assert.equal(file, undefined);
-      });
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName,
+        key: key
+      };
+      sample.mocks.bucket.upload = sinon.stub().callsArgWith(2, error);
+
+      sample.program.uploadEncryptedFile(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
 
   describe('downloadEncryptedFile', function () {
-    var fileName = 'test.txt';
     it('should download a file', function () {
       var sample = getSample();
-
-      sample.program.downloadEncryptedFile(bucketName, fileName, fileName, 'key', function (err) {
-        assert.ifError(err);
-        assert(console.log.calledWith('Downloaded encrypted file: %s', fileName));
-      });
-    });
-    it('should require bucket', function () {
-      var sample = getSample();
-
-      sample.program.downloadEncryptedFile(undefined, undefined, undefined, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"bucket" is required!');
-        assert.equal(file, undefined);
-      });
-    });
-    it('should require srcFileName', function () {
-      var sample = getSample();
-
-      sample.program.downloadEncryptedFile(bucketName, undefined, undefined, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"srcFileName" is required!');
-        assert.equal(file, undefined);
-      });
-    });
-    it('should require destFileName', function () {
-      var sample = getSample();
-
-      sample.program.downloadEncryptedFile(bucketName, fileName, undefined, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"destFileName" is required!');
-        assert.equal(file, undefined);
-      });
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName,
+        key: key
+      };
+
+      sample.program.downloadEncryptedFile(options, callback);
+
+      assert(sample.mocks.file.download.calledOnce, 'download called once');
+      assert.equal(sample.mocks.file.download.firstCall.args.length, 2, 'download received 2 arguments');
+      assert.deepEqual(sample.mocks.file.download.firstCall.args[0], {
+        destination: options.destFile
+      }, 'download received config');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert(console.log.calledWith('Downloaded gs://%s/%s to %s', options.bucket, options.srcFile, options.destFile));
     });
-    it('should require key', function () {
-      var sample = getSample();
 
-      sample.program.downloadEncryptedFile(bucketName, fileName, fileName, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"key" is required!');
-        assert.equal(file, undefined);
-      });
-    });
     it('should handle error', function () {
       var error = 'error';
       var sample = getSample();
-      sample.mocks.file.download = sinon.stub().callsArgWith(1, new Error(error));
-
-      sample.program.downloadEncryptedFile(bucketName, fileName, fileName, 'key', function (err, file) {
-        assert(err);
-        assert.equal(err.message, error);
-        assert.equal(file, undefined);
-      });
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName,
+        key: key
+      };
+      sample.mocks.file.download = sinon.stub().callsArgWith(1, error);
+
+      sample.program.downloadEncryptedFile(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
 
@@ -182,57 +159,49 @@ describe('storage:encryption', function () {
     it('should be implemented');
     it('should rotate an encryption key', function () {
       var sample = getSample();
+      var callback = sinon.stub();
+      var expected = 'This is currently not available using the Cloud Client Library.';
 
-      sample.program.rotateEncryptionKey(function (err) {
-        assert(err);
-        assert.equal(err.message, 'This is currently not available using the Cloud Client Library.');
-      });
-    });
-  });
-
-  describe('printUsage', function () {
-    it('should print usage', function () {
-      var program = getSample().program;
+      sample.program.rotateEncryptionKey(callback);
 
-      program.printUsage();
-
-      assert(console.log.calledWith('Usage: node encryption COMMAND [ARGS...]'));
-      assert(console.log.calledWith('\nCommands:\n'));
-      assert(console.log.calledWith('\tgenerate-encryption-key'));
-      assert(console.log.calledWith('\tupload BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME KEY'));
-      assert(console.log.calledWith('\tdownload BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME KEY'));
-      assert(console.log.calledWith('\trotate BUCKET_NAME FILE_NAME OLD_KEY NEW_KEY'));
-      assert(console.log.calledWith('\nExamples:\n'));
-      assert(console.log.calledWith('\tnode encryption generate-encryption-key'));
-      assert(console.log.calledWith('\tnode encryption upload my-bucket resources/test.txt file_encrypted.txt QxhqaZEqBGVTW55HhQw9Q='));
-      assert(console.log.calledWith('\tnode encryption download my-bucket file_encrypted.txt ./file.txt QxhqaZEqBGVTW55HhQw9Q='));
-      assert(console.log.calledWith('\tnode encryption rotate my-bucket file_encrypted.txt QxhqaZEqBGVTW55HhQw9Q= SxafpsdfSDFS89sds9Q='));
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, expected, 'error has correct message');
     });
   });
 
   describe('main', function () {
-    it('should call the right commands', function () {
+    it('should call generateEncryptionKey', function () {
       var program = getSample().program;
 
       sinon.stub(program, 'generateEncryptionKey');
       program.main(['generate-encryption-key']);
       assert(program.generateEncryptionKey.calledOnce);
+    });
+
+    it('should call uploadEncryptedFile', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'uploadEncryptedFile');
-      program.main(['upload']);
+      program.main(['upload', bucketName, fileName, fileName, key]);
       assert(program.uploadEncryptedFile.calledOnce);
+    });
+
+    it('should call downloadEncryptedFile', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'downloadEncryptedFile');
-      program.main(['download']);
+      program.main(['download', bucketName, fileName, fileName, key]);
       assert(program.downloadEncryptedFile.calledOnce);
+    });
+
+    it('should call rotateEncryptionKey', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'rotateEncryptionKey');
-      program.main(['rotate']);
+      program.main(['rotate', bucketName, fileName, key, key]);
       assert(program.rotateEncryptionKey.calledOnce);
-
-      sinon.stub(program, 'printUsage');
-      program.main(['--help']);
-      assert(program.printUsage.calledOnce);
     });
   });
 });
diff --git a/storage/test/files.test.js b/storage/test/files.test.js
index 8c32a21446..b5495b55b5 100644
--- a/storage/test/files.test.js
+++ b/storage/test/files.test.js
@@ -15,6 +15,7 @@
 
 var proxyquire = require('proxyquire').noCallThru();
 var bucketName = 'foo';
+var fileName = 'test.txt';
 
 function getSample () {
   var filesMock = [
@@ -28,7 +29,8 @@ function getSample () {
     getMetadata: sinon.stub().callsArgWith(0, null, { foo: 'bar' }),
     makePublic: sinon.stub().callsArgWith(0, null),
     delete: sinon.stub().callsArgWith(0, null),
-    move: sinon.stub().callsArgWith(1, null, filesMock[0])
+    move: sinon.stub().callsArgWith(1, null, filesMock[0]),
+    copy: sinon.stub().callsArgWith(1, null, filesMock[0])
   };
   var bucketMock = {
     getFiles: sinon.stub().callsArgWith(0, null, filesMock, null, filesMock),
@@ -40,8 +42,9 @@ function getSample () {
   };
   var StorageMock = sinon.stub().returns(storageMock);
   return {
-    sample: proxyquire('../files', {
-      '@google-cloud/storage': StorageMock
+    program: proxyquire('../files', {
+      '@google-cloud/storage': StorageMock,
+      yargs: proxyquire('yargs', {})
     }),
     mocks: {
       Storage: StorageMock,
@@ -56,425 +59,461 @@ function getSample () {
 describe('storage:files', function () {
   describe('list', function () {
     it('should list files', function () {
-      var filesSample = getSample();
+      var sample = getSample();
+      var callback = sinon.stub();
 
-      filesSample.sample.listFiles(bucketName, function (err, files) {
-        assert.ifError(err);
-        assert.strictEqual(files, filesSample.mocks.files);
-        assert(console.log.calledWith('Found %d files!', filesSample.mocks.files.length));
-      });
-    });
-    it('should require name', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.listFiles(undefined, function (err, files) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-        assert.equal(files, undefined);
-      });
+      sample.program.listFiles(bucketName, callback);
+
+      assert(sample.mocks.bucket.getFiles.calledOnce, 'getFiles called once');
+      assert.equal(sample.mocks.bucket.getFiles.firstCall.args.length, 1, 'getFiles received 1 argument');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.files, 'callback received files');
+      assert(console.log.calledWith('Found %d file(s)!', sample.mocks.files.length));
     });
+
     it('should handle error', function () {
-      var error = 'listError';
-      var filesSample = getSample();
-      filesSample.mocks.bucket.getFiles = sinon.stub().callsArgWith(0, error);
-
-      filesSample.sample.listFiles(bucketName, function (err, files) {
-        assert.equal(err, error);
-        assert.equal(files, undefined);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      sample.mocks.bucket.getFiles = sinon.stub().callsArgWith(0, error);
+
+      sample.program.listFiles(bucketName, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
-  describe('listWithPrefix', function () {
+
+  describe('listFilesByPrefix', function () {
     it('should list files with prefix', function () {
-      var filesSample = getSample();
-      filesSample.mocks.bucket.getFiles = sinon.stub().callsArgWith(1, null, filesSample.mocks.files);
-
-      filesSample.sample.listFilesWithPrefix(bucketName, '/a', undefined, function (err, files) {
-        assert.ifError(err);
-        assert.strictEqual(files, filesSample.mocks.files);
-        assert(console.log.calledWith('Found %d files!', filesSample.mocks.files.length));
-      });
-    });
-    it('should require name', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.listFilesWithPrefix(undefined, undefined, undefined, function (err, files) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-        assert.equal(files, undefined);
-      });
-    });
-    it('should require prefix', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.listFilesWithPrefix(bucketName, undefined, undefined, function (err, files) {
-        assert(err);
-        assert(err.message = '"prefix" is required!');
-        assert.equal(files, undefined);
-      });
+      var sample = getSample();
+      var callback = sinon.stub();
+      var prefix = '/a';
+      var options = {
+        bucket: bucketName,
+        prefix: prefix
+      };
+      sample.mocks.bucket.getFiles = sinon.stub().callsArgWith(1, null, sample.mocks.files);
+
+      sample.program.listFilesByPrefix(options, callback);
+
+      assert(sample.mocks.bucket.getFiles.calledOnce, 'getFiles called once');
+      assert.equal(sample.mocks.bucket.getFiles.firstCall.args.length, 2, 'getFiles received 2 arguments');
+      assert.deepEqual(sample.mocks.bucket.getFiles.firstCall.args[0], {
+        prefix: prefix
+      }, 'getFiles received options');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.files, 'callback received files');
+      assert(console.log.calledWith('Found %d file(s)!', sample.mocks.files.length));
+    });
+
+    it('should list files with prefix and delimiter', function () {
+      var sample = getSample();
+      var callback = sinon.stub();
+      var prefix = '/a';
+      var delimiter = '-';
+      var options = {
+        bucket: bucketName,
+        prefix: prefix,
+        delimiter: delimiter
+      };
+      sample.mocks.bucket.getFiles = sinon.stub().callsArgWith(1, null, sample.mocks.files);
+
+      sample.program.listFilesByPrefix(options, callback);
+
+      assert(sample.mocks.bucket.getFiles.calledOnce, 'getFiles called once');
+      assert.equal(sample.mocks.bucket.getFiles.firstCall.args.length, 2, 'getFiles received 2 arguments');
+      assert.deepEqual(sample.mocks.bucket.getFiles.firstCall.args[0], {
+        prefix: prefix,
+        delimiter: delimiter
+      }, 'getFiles received options');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.files, 'callback received files');
+      assert(console.log.calledWith('Found %d file(s)!', sample.mocks.files.length));
     });
+
     it('should handle error', function () {
-      var error = 'listError';
-      var filesSample = getSample();
-      filesSample.mocks.bucket.getFiles = sinon.stub().callsArgWith(1, error);
-
-      filesSample.sample.listFilesWithPrefix(bucketName, '/a', undefined, function (err, files) {
-        assert.equal(err, error);
-        assert.equal(files, undefined);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      var prefix = '/a';
+      var options = {
+        bucket: bucketName,
+        prefix: prefix
+      };
+      sample.mocks.bucket.getFiles = sinon.stub().callsArgWith(1, error);
+
+      sample.program.listFilesByPrefix(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
+
   describe('uploadFile', function () {
-    var fileName = 'test.txt';
     it('should upload a file', function () {
-      var filesSample = getSample();
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName
+      };
 
-      filesSample.sample.uploadFile(bucketName, fileName, function (err, file) {
-        assert.ifError(err);
-        assert.strictEqual(file, filesSample.mocks.files[0]);
-        assert(console.log.calledWith('Uploaded file: %s', fileName));
-      });
-    });
-    it('should require name', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.uploadFile(undefined, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-        assert.equal(file, undefined);
-      });
-    });
-    it('should require fileName', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.uploadFile(bucketName, undefined, function (err, file) {
-        assert(err);
-        assert(err.message = '"fileName" is required!');
-        assert.equal(file, undefined);
-      });
+      sample.program.uploadFile(options, callback);
+
+      assert(sample.mocks.bucket.upload.calledOnce, 'upload called once');
+      assert.equal(sample.mocks.bucket.upload.firstCall.args.length, 2, 'upload received 2 arguments');
+      assert.deepEqual(sample.mocks.bucket.upload.firstCall.args[0], fileName, 'upload received file name');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.files[0], 'callback received file');
+      assert(console.log.calledWith('Uploaded gs://%s/%s', options.bucket, options.srcFile));
     });
+
     it('should handle error', function () {
-      var error = 'uploadError';
-      var filesSample = getSample();
-      filesSample.mocks.bucket.upload = sinon.stub().callsArgWith(1, error);
-
-      filesSample.sample.uploadFile(bucketName, fileName, function (err, file) {
-        assert.equal(err, error);
-        assert.equal(file, undefined);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName
+      };
+      sample.mocks.bucket.upload = sinon.stub().callsArgWith(1, error);
+
+      sample.program.uploadFile(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
+
   describe('downloadFile', function () {
-    var fileName = 'test.txt';
     it('should download a file', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.downloadFile(bucketName, fileName, fileName, function (err) {
-        assert.ifError(err);
-        assert(console.log.calledWith('Downloaded %s to %s', fileName, fileName));
-      });
-    });
-    it('should require name', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.downloadFile(undefined, undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-      });
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName
+      };
+
+      sample.program.downloadFile(options, callback);
+
+      assert(sample.mocks.file.download.calledOnce, 'download called once');
+      assert.equal(sample.mocks.file.download.firstCall.args.length, 2, 'download received 2 arguments');
+      assert.deepEqual(sample.mocks.file.download.firstCall.args[0], {
+        destination: options.destFile
+      }, 'download received file name');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert(console.log.calledWith('Downloaded gs://%s/%s to %s', options.bucket, options.srcFile, options.destFile));
     });
-    it('should require srcFileName', function () {
-      var filesSample = getSample();
 
-      filesSample.sample.downloadFile(bucketName, undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"srcFileName" is required!');
-      });
-    });
-    it('should require destFileName', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.downloadFile(bucketName, fileName, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"destFileName" is required!');
-      });
-    });
     it('should handle error', function () {
-      var error = 'downloadError';
-      var filesSample = getSample();
-      filesSample.mocks.file.download = sinon.stub().callsArgWith(1, error);
-
-      filesSample.sample.downloadFile(bucketName, fileName, fileName, function (err) {
-        assert.equal(err, error);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName
+      };
+      sample.mocks.file.download = sinon.stub().callsArgWith(1, error);
+
+      sample.program.downloadFile(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
+
   describe('deleteFile', function () {
-    var fileName = 'test.txt';
     it('should delete a file', function () {
-      var filesSample = getSample();
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        file: fileName
+      };
 
-      filesSample.sample.deleteFile(bucketName, fileName, function (err) {
-        assert.ifError(err);
-        assert(console.log.calledWith('Deleted file: %s', fileName));
-      });
-    });
-    it('should require name', function () {
-      var filesSample = getSample();
+      sample.program.deleteFile(options, callback);
 
-      filesSample.sample.deleteFile(undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-      });
+      assert(sample.mocks.file.delete.calledOnce, 'delete called once');
+      assert.equal(sample.mocks.file.delete.firstCall.args.length, 1, 'delete received 1 argument');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert(console.log.calledWith('Deleted gs://%s/%s', options.bucket, options.file));
     });
-    it('should require fileName', function () {
-      var filesSample = getSample();
 
-      filesSample.sample.deleteFile(bucketName, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"fileName" is required!');
-      });
-    });
     it('should handle error', function () {
-      var error = 'deleteError';
-      var filesSample = getSample();
-      filesSample.mocks.file.delete = sinon.stub().callsArgWith(0, error);
-
-      filesSample.sample.deleteFile(bucketName, fileName, function (err) {
-        assert.equal(err, error);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        file: fileName
+      };
+      sample.mocks.file.delete = sinon.stub().callsArgWith(0, error);
+
+      sample.program.deleteFile(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
+
   describe('getMetadata', function () {
-    var fileName = 'test.txt';
     it('should get metadata for a file', function () {
-      var filesSample = getSample();
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        file: fileName
+      };
 
-      filesSample.sample.getMetadata(bucketName, fileName, function (err, metadata) {
-        assert.ifError(err);
-        assert.deepEqual(metadata, { foo: 'bar' });
-        assert(console.log.calledWith('Got metadata for file: %s', fileName));
-      });
-    });
-    it('should require name', function () {
-      var filesSample = getSample();
+      sample.program.getMetadata(options, callback);
 
-      filesSample.sample.getMetadata(undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-      });
+      assert(sample.mocks.file.getMetadata.calledOnce, 'getMetadata called once');
+      assert.equal(sample.mocks.file.getMetadata.firstCall.args.length, 1, 'getMetadata received 1 argument');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.deepEqual(callback.firstCall.args[1], { foo: 'bar' }, 'callback received metadata');
+      assert(console.log.calledWith('Got metadata for gs://%s/%s', options.bucket, options.file));
     });
-    it('should require fileName', function () {
-      var filesSample = getSample();
 
-      filesSample.sample.getMetadata(bucketName, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"fileName" is required!');
-      });
-    });
     it('should handle error', function () {
-      var error = 'getMetadataError';
-      var filesSample = getSample();
-      filesSample.mocks.file.getMetadata = sinon.stub().callsArgWith(0, error);
-
-      filesSample.sample.getMetadata(bucketName, fileName, function (err) {
-        assert.equal(err, error);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        file: fileName
+      };
+      sample.mocks.file.getMetadata = sinon.stub().callsArgWith(0, error);
+
+      sample.program.getMetadata(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
+
   describe('makePublic', function () {
-    var fileName = 'test.txt';
     it('should make a file public', function () {
-      var filesSample = getSample();
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        file: fileName
+      };
 
-      filesSample.sample.makePublic(bucketName, fileName, function (err) {
-        assert.ifError(err);
-        assert(console.log.calledWith('Made %s public!', fileName));
-      });
-    });
-    it('should require name', function () {
-      var filesSample = getSample();
+      sample.program.makePublic(options, callback);
 
-      filesSample.sample.makePublic(undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-      });
+      assert(sample.mocks.file.makePublic.calledOnce, 'makePublic called once');
+      assert.equal(sample.mocks.file.makePublic.firstCall.args.length, 1, 'makePublic received 1 argument');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert(console.log.calledWith('Made gs://%s/%s public!', options.bucket, options.file));
     });
-    it('should require fileName', function () {
-      var filesSample = getSample();
 
-      filesSample.sample.makePublic(bucketName, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"fileName" is required!');
-      });
-    });
     it('should handle error', function () {
-      var error = 'makePublicError';
-      var filesSample = getSample();
-      filesSample.mocks.file.makePublic = sinon.stub().callsArgWith(0, error);
-
-      filesSample.sample.makePublic(bucketName, fileName, function (err) {
-        assert.equal(err, error);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        file: fileName
+      };
+      sample.mocks.file.makePublic = sinon.stub().callsArgWith(0, error);
+
+      sample.program.makePublic(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
-  describe('moveFile', function () {
-    var fileName = 'test.txt';
-    it('should move a file', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.moveFile(bucketName, fileName, fileName, function (err) {
-        assert.ifError(err);
-        assert(console.log.calledWith('%s moved to %s', fileName, fileName));
-      });
-    });
-    it('should require name', function () {
-      var filesSample = getSample();
 
-      filesSample.sample.moveFile(undefined, undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-      });
-    });
-    it('should require srcFileName', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.moveFile(bucketName, undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"srcFileName" is required!');
-      });
+  describe('moveFile', function () {
+    it('should rename a file', function () {
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName
+      };
+
+      sample.program.moveFile(options, callback);
+
+      assert(sample.mocks.file.move.calledOnce, 'move called once');
+      assert.equal(sample.mocks.file.move.firstCall.args.length, 2, 'move received 2 arguments');
+      assert.deepEqual(sample.mocks.file.move.firstCall.args[0], options.destFile, 'move received options');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.files[0], 'callback received file');
+      assert(console.log.calledWith('Renamed gs://%s/%s to gs://%s/%s', options.bucket, options.srcFile, options.bucket, options.destFile));
     });
-    it('should require destFileName', function () {
-      var filesSample = getSample();
 
-      filesSample.sample.moveFile(bucketName, fileName, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"destFileName" is required!');
-      });
-    });
     it('should handle error', function () {
-      var error = 'moveFileError';
-      var filesSample = getSample();
-      filesSample.mocks.file.move = sinon.stub().callsArgWith(1, error);
-
-      filesSample.sample.moveFile(bucketName, fileName, fileName, function (err) {
-        assert.equal(err, error);
-      });
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        bucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName
+      };
+      sample.mocks.file.move = sinon.stub().callsArgWith(1, error);
+
+      sample.program.moveFile(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
+
   describe('copyFile', function () {
-    var fileName = 'test.txt';
     it('should copy a file', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.copyFile(bucketName, fileName, bucketName, fileName, function (err) {
-        assert.ifError(err);
-        assert(console.log.calledWith('%s moved to %s in %s', fileName, fileName, bucketName));
-      });
-    });
-    it('should require name', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.copyFile(undefined, undefined, undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"name" is required!');
-      });
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        srcBucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName,
+        destBucket: bucketName
+      };
+
+      sample.program.copyFile(options, callback);
+
+      assert(sample.mocks.file.copy.calledOnce, 'copy called once');
+      assert.equal(sample.mocks.file.copy.firstCall.args.length, 2, 'copy received 2 arguments');
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
+      assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
+      assert.strictEqual(callback.firstCall.args[1], sample.mocks.files[0], 'callback received file');
+      assert(console.log.calledWith('Copied gs://%s/%s to gs://%s/%s', options.srcBucket, options.srcFile, options.destBucket, options.destFile));
     });
-    it('should require srcFileName', function () {
-      var filesSample = getSample();
 
-      filesSample.sample.copyFile(bucketName, undefined, undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"srcFileName" is required!');
-      });
-    });
-    it('should require destBucketName', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.copyFile(bucketName, fileName, undefined, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"destBucketName" is required!');
-      });
-    });
-    it('should require destFileName', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.copyFile(bucketName, fileName, bucketName, undefined, function (err) {
-        assert(err);
-        assert(err.message = '"destFileName" is required!');
-      });
-    });
     it('should handle error', function () {
-      var error = 'copyFileError';
-      var filesSample = getSample();
-      filesSample.mocks.file.move = sinon.stub().callsArgWith(1, error);
-
-      filesSample.sample.copyFile(bucketName, fileName, bucketName, fileName, function (err) {
-        assert.equal(err, error);
-      });
-    });
-  });
-  describe('printUsage', function () {
-    it('should print usage', function () {
-      var filesSample = getSample();
-
-      filesSample.sample.printUsage();
-
-      assert(console.log.calledWith('Usage: node files COMMAND [ARGS...]'));
-      assert(console.log.calledWith('\nCommands:\n'));
-      assert(console.log.calledWith('\tlist BUCKET_NAME'));
-      assert(console.log.calledWith('\tlistByPrefix BUCKET_NAME PREFIX [DELIMITER]'));
-      assert(console.log.calledWith('\tupload BUCKET_NAME FILE_NAME'));
-      assert(console.log.calledWith('\tdownload BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME'));
-      assert(console.log.calledWith('\tdelete BUCKET_NAME FILE_NAME'));
-      assert(console.log.calledWith('\tgetMetadata BUCKET_NAME FILE_NAME'));
-      assert(console.log.calledWith('\tmakePublic BUCKET_NAME FILE_NAME'));
-      assert(console.log.calledWith('\tmove BUCKET_NAME SRC_FILE_NAME DEST_FILE_NAME'));
-      assert(console.log.calledWith('\tcopy BUCKET_NAME SRC_FILE_NAME DEST_BUCKET_NAME DEST_FILE_NAME'));
+      var error = 'error';
+      var sample = getSample();
+      var callback = sinon.stub();
+      var options = {
+        srcBucket: bucketName,
+        srcFile: fileName,
+        destFile: fileName,
+        destBucket: bucketName
+      };
+      sample.mocks.file.copy = sinon.stub().callsArgWith(1, error);
+
+      sample.program.copyFile(options, callback);
+
+      assert(callback.calledOnce, 'callback called once');
+      assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
+      assert(callback.firstCall.args[0], 'callback received error');
+      assert.equal(callback.firstCall.args[0].message, error.message, 'error has correct message');
     });
   });
+
   describe('main', function () {
-    it('should call the right commands', function () {
-      var program = getSample().sample;
+    it('should call listFiles', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'listFiles');
-      program.main(['list']);
+      program.main(['list', bucketName]);
       assert(program.listFiles.calledOnce);
+    });
+
+    it('should call listFilesByPrefix', function () {
+      var program = getSample().program;
 
-      sinon.stub(program, 'listFilesWithPrefix');
-      program.main(['listByPrefix']);
-      assert(program.listFilesWithPrefix.calledOnce);
+      sinon.stub(program, 'listFilesByPrefix');
+      program.main(['list', bucketName, '-p', 'public/']);
+      assert(program.listFilesByPrefix.calledOnce);
+    });
+
+    it('should call uploadFile', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'uploadFile');
-      program.main(['upload']);
+      program.main(['upload', bucketName, fileName]);
       assert(program.uploadFile.calledOnce);
+    });
+
+    it('should call downloadFile', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'downloadFile');
-      program.main(['download']);
+      program.main(['download', bucketName, fileName, fileName]);
       assert(program.downloadFile.calledOnce);
+    });
+
+    it('should call deleteFile', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'deleteFile');
-      program.main(['delete']);
+      program.main(['delete', bucketName, fileName]);
       assert(program.deleteFile.calledOnce);
+    });
+
+    it('should call getMetadata', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'getMetadata');
-      program.main(['getMetadata']);
+      program.main(['getMetadata', bucketName, fileName]);
       assert(program.getMetadata.calledOnce);
+    });
+
+    it('should call makePublic', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'makePublic');
-      program.main(['makePublic']);
+      program.main(['makePublic', bucketName, fileName]);
       assert(program.makePublic.calledOnce);
+    });
+
+    it('should call moveFile', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'moveFile');
-      program.main(['move']);
+      program.main(['move', bucketName, fileName, fileName]);
       assert(program.moveFile.calledOnce);
+    });
+
+    it('should call copyFile', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'copyFile');
-      program.main(['copy']);
+      program.main(['copy', bucketName, fileName, bucketName, fileName]);
       assert(program.copyFile.calledOnce);
-
-      sinon.stub(program, 'printUsage');
-      program.main(['--help']);
-      assert(program.printUsage.calledOnce);
     });
   });
 });
diff --git a/storage/test/transfer.test.js b/storage/test/transfer.test.js
index 55f0e2d467..63f61e00eb 100644
--- a/storage/test/transfer.test.js
+++ b/storage/test/transfer.test.js
@@ -19,7 +19,9 @@ var jobName = 'transferJobs/123456789012345678';
 var transferOperationName = 'transferOperations/123456789012345678';
 
 function getSample () {
-  var transferJobMock = {};
+  var transferJobMock = {
+    name: jobName
+  };
   var transferOperationMock = {};
   var storagetransferMock = {
     transferJobs: {
@@ -41,9 +43,11 @@ function getSample () {
       getApplicationDefault: sinon.stub().callsArgWith(0, null, {})
     }
   };
+
   return {
     program: proxyquire('../transfer', {
-      googleapis: googleapisMock
+      googleapis: googleapisMock,
+      yargs: proxyquire('yargs', {})
     }),
     mocks: {
       googleapis: googleapisMock,
@@ -61,45 +65,33 @@ describe('storage:transfer', function () {
         var description = 'description';
         var sample = getSample();
         var callback = sinon.stub();
+        var date = '2016/08/11';
+        var time = '15:30';
+        var options = {
+          srcBucket: bucketName,
+          destBucket: bucketName,
+          date: date,
+          time: time
+        };
 
-        sample.program.createTransferJob(bucketName, bucketName, '2016/08/11', '15:30', null, callback);
+        sample.program.createTransferJob(options, callback);
 
         assert(callback.calledOnce, 'callback called once');
         assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
         assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
         assert.strictEqual(callback.firstCall.args[1], sample.mocks.transferJob, 'callback received transfer job');
+        assert.equal(sample.mocks.storagetransfer.transferJobs.create.firstCall.args[0].resource.description, undefined, 'description was not set');
+        assert(console.log.calledWith('Created transfer job: %s', sample.mocks.transferJob.name));
 
-        sample.program.createTransferJob(bucketName, bucketName, '2016/08/11', '15:30', description, callback);
+        options.description = description;
+        sample.program.createTransferJob(options, callback);
 
         assert(callback.calledTwice, 'callback called twice');
         assert.equal(callback.secondCall.args.length, 2, 'callback received 2 arguments');
         assert.ifError(callback.secondCall.args[0], 'callback did not receive error');
         assert.strictEqual(callback.secondCall.args[1], sample.mocks.transferJob, 'callback received transfer job');
         assert.equal(sample.mocks.storagetransfer.transferJobs.create.secondCall.args[0].resource.description, description, 'description was set');
-      });
-
-      it('should require "srcBucketName"', function () {
-        var sample = getSample();
-        var callback = sinon.stub();
-
-        sample.program.createTransferJob(null, null, null, null, null, callback);
-
-        assert(callback.calledOnce, 'callback called once');
-        assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
-        assert(callback.firstCall.args[0], 'callback received error');
-        assert.equal(callback.firstCall.args[0].message, '"srcBucketName" is required!', 'error has correct message');
-      });
-
-      it('should require "destBucketName"', function () {
-        var sample = getSample();
-        var callback = sinon.stub();
-
-        sample.program.createTransferJob(bucketName, null, null, null, null, callback);
-
-        assert(callback.calledOnce, 'callback called once');
-        assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
-        assert(callback.firstCall.args[0], 'callback received error');
-        assert.equal(callback.firstCall.args[0].message, '"destBucketName" is required!', 'error has correct message');
+        assert(console.log.calledWith('Created transfer job: %s', sample.mocks.transferJob.name));
       });
 
       it('should handle auth error', function () {
@@ -108,7 +100,7 @@ describe('storage:transfer', function () {
         var callback = sinon.stub();
         sample.mocks.googleapis.auth.getApplicationDefault.callsArgWith(0, error);
 
-        sample.program.createTransferJob(bucketName, bucketName, 'time', 'date', null, callback);
+        sample.program.createTransferJob({}, callback);
 
         assert(callback.calledOnce, 'callback called once');
         assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
@@ -122,7 +114,7 @@ describe('storage:transfer', function () {
         var callback = sinon.stub();
         sample.mocks.storagetransfer.transferJobs.create.callsArgWith(1, error);
 
-        sample.program.createTransferJob(bucketName, bucketName, 'time', 'date', null, callback);
+        sample.program.createTransferJob({}, callback);
 
         assert(callback.calledOnce, 'callback called once');
         assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
@@ -142,18 +134,7 @@ describe('storage:transfer', function () {
         assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
         assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
         assert.strictEqual(callback.firstCall.args[1], sample.mocks.transferJob, 'callback received transfer job');
-      });
-
-      it('should require "jobName"', function () {
-        var sample = getSample();
-        var callback = sinon.stub();
-
-        sample.program.getTransferJob(null, callback);
-
-        assert(callback.calledOnce, 'callback called once');
-        assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
-        assert(callback.firstCall.args[0], 'callback received error');
-        assert.equal(callback.firstCall.args[0].message, '"jobName" is required!', 'error has correct message');
+        assert(console.log.calledWith('Found transfer job: %s', sample.mocks.transferJob.name));
       });
 
       it('should handle auth error', function () {
@@ -187,82 +168,55 @@ describe('storage:transfer', function () {
 
     describe('set', function () {
       it('should update a transfer job', function () {
-        var field = 'status';
-        var value = 'DISABLED';
         var sample = getSample();
         var callback = sinon.stub();
+        var options = {
+          job: jobName,
+          field: 'status',
+          value: 'DISABLED'
+        };
 
-        sample.program.updateTransferJob(jobName, field, value, callback);
+        sample.program.updateTransferJob(options, callback);
 
         assert(callback.calledOnce, 'callback called once');
         assert.equal(callback.firstCall.args.length, 2, 'callback received 2 arguments');
         assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
         assert.strictEqual(callback.firstCall.args[1], sample.mocks.transferJob, 'callback received transfer job');
 
-        field = 'description';
-        value = 'description';
+        options.field = 'description';
+        options.value = 'description';
 
-        sample.program.updateTransferJob(jobName, field, value, callback);
+        sample.program.updateTransferJob(options, callback);
 
         assert(callback.calledTwice, 'callback called twice');
         assert.equal(callback.secondCall.args.length, 2, 'callback received 2 arguments');
         assert.ifError(callback.secondCall.args[0], 'callback did not receive error');
         assert.strictEqual(callback.secondCall.args[1], sample.mocks.transferJob, 'callback received transfer job');
 
-        field = 'transferSpec';
-        value = '{"foo":"bar"}';
+        options.field = 'transferSpec';
+        options.value = '{"foo":"bar"}';
 
-        sample.program.updateTransferJob(jobName, field, value, callback);
+        sample.program.updateTransferJob(options, callback);
 
         assert(callback.calledThrice, 'callback called thrice');
         assert.equal(callback.thirdCall.args.length, 2, 'callback received 2 arguments');
         assert.ifError(callback.thirdCall.args[0], 'callback did not receive error');
         assert.strictEqual(callback.thirdCall.args[1], sample.mocks.transferJob, 'callback received transfer job');
-      });
-
-      it('should require "jobName"', function () {
-        var sample = getSample();
-        var callback = sinon.stub();
-
-        sample.program.updateTransferJob(null, null, null, callback);
-
-        assert(callback.calledOnce, 'callback called once');
-        assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
-        assert(callback.firstCall.args[0], 'callback received error');
-        assert.equal(callback.firstCall.args[0].message, '"jobName" is required!', 'error has correct message');
-      });
-
-      it('should require "field"', function () {
-        var sample = getSample();
-        var callback = sinon.stub();
-
-        sample.program.updateTransferJob(jobName, null, null, callback);
-
-        assert(callback.calledOnce, 'callback called once');
-        assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
-        assert(callback.firstCall.args[0], 'callback received error');
-        assert.equal(callback.firstCall.args[0].message, '"field" is required!', 'error has correct message');
-      });
-
-      it('should require "value"', function () {
-        var sample = getSample();
-        var callback = sinon.stub();
-
-        sample.program.updateTransferJob(jobName, 'field', null, callback);
-
-        assert(callback.calledOnce, 'callback called once');
-        assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
-        assert(callback.firstCall.args[0], 'callback received error');
-        assert.equal(callback.firstCall.args[0].message, '"value" is required!', 'error has correct message');
+        assert(console.log.calledWith('Updated transfer job: %s', sample.mocks.transferJob.name));
       });
 
       it('should handle auth error', function () {
         var error = new Error('error');
         var sample = getSample();
         var callback = sinon.stub();
+        var options = {
+          job: jobName,
+          field: 'status',
+          value: 'DISABLED'
+        };
         sample.mocks.googleapis.auth.getApplicationDefault.callsArgWith(0, error);
 
-        sample.program.updateTransferJob(jobName, 'field', 'value', callback);
+        sample.program.updateTransferJob(options, callback);
 
         assert(callback.calledOnce, 'callback called once');
         assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
@@ -274,9 +228,14 @@ describe('storage:transfer', function () {
         var error = new Error('error');
         var sample = getSample();
         var callback = sinon.stub();
+        var options = {
+          job: jobName,
+          field: 'status',
+          value: 'DISABLED'
+        };
         sample.mocks.storagetransfer.transferJobs.patch.callsArgWith(1, error);
 
-        sample.program.updateTransferJob(jobName, 'field', 'value', callback);
+        sample.program.updateTransferJob(options, callback);
 
         assert(callback.calledOnce, 'callback called once');
         assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
@@ -304,6 +263,7 @@ describe('storage:transfer', function () {
         assert.equal(callback.secondCall.args.length, 2, 'callback received 2 arguments');
         assert.ifError(callback.secondCall.args[0], 'callback did not receive error');
         assert.deepEqual(callback.secondCall.args[1], [], 'callback received no transfer jobs');
+        assert(console.log.calledWith('Found %d jobs!', 1));
       });
 
       it('should handle auth error', function () {
@@ -407,18 +367,6 @@ describe('storage:transfer', function () {
         assert.strictEqual(callback.firstCall.args[1], sample.mocks.transferOperation, 'callback received transfer operation');
       });
 
-      it('should require "transferOperationName"', function () {
-        var sample = getSample();
-        var callback = sinon.stub();
-
-        sample.program.getTransferOperation(null, callback);
-
-        assert(callback.calledOnce, 'callback called once');
-        assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
-        assert(callback.firstCall.args[0], 'callback received error');
-        assert.equal(callback.firstCall.args[0].message, '"transferOperationName" is required!', 'error has correct message');
-      });
-
       it('should handle auth error', function () {
         var error = new Error('error');
         var sample = getSample();
@@ -460,18 +408,6 @@ describe('storage:transfer', function () {
         assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
       });
 
-      it('should require "transferOperationName"', function () {
-        var sample = getSample();
-        var callback = sinon.stub();
-
-        sample.program.pauseTransferOperation(null, callback);
-
-        assert(callback.calledOnce, 'callback called once');
-        assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
-        assert(callback.firstCall.args[0], 'callback received error');
-        assert.equal(callback.firstCall.args[0].message, '"transferOperationName" is required!', 'error has correct message');
-      });
-
       it('should handle auth error', function () {
         var error = new Error('error');
         var sample = getSample();
@@ -513,18 +449,6 @@ describe('storage:transfer', function () {
         assert.ifError(callback.firstCall.args[0], 'callback did not receive error');
       });
 
-      it('should require "transferOperationName"', function () {
-        var sample = getSample();
-        var callback = sinon.stub();
-
-        sample.program.resumeTransferOperation(null, callback);
-
-        assert(callback.calledOnce, 'callback called once');
-        assert.equal(callback.firstCall.args.length, 1, 'callback received 1 argument');
-        assert(callback.firstCall.args[0], 'callback received error');
-        assert.equal(callback.firstCall.args[0].message, '"transferOperationName" is required!', 'error has correct message');
-      });
-
       it('should handle auth error', function () {
         var error = new Error('error');
         var sample = getSample();
@@ -555,85 +479,69 @@ describe('storage:transfer', function () {
     });
   });
 
-  describe('printUsage', function () {
-    it('should print usage', function () {
-      var program = getSample().program;
-
-      program.printUsage();
-
-      assert(console.log.calledWith('Usage: node encryption RESOURCE COMMAND [ARGS...]'));
-      assert(console.log.calledWith('\nResources:\n'));
-      assert(console.log.calledWith('    jobs'));
-      assert(console.log.calledWith('\n\tCommands:\n'));
-      assert(console.log.calledWith('\t\tcreate SRC_BUCKET_NAME DEST_BUCKET_NAME DATE TIME [DESCRIPTION]'));
-      assert(console.log.calledWith('\t\tget JOB_NAME'));
-      assert(console.log.calledWith('\t\tlist'));
-      assert(console.log.calledWith('\t\tset JOB_NAME FIELD VALUE'));
-      assert(console.log.calledWith('\n    operations'));
-      assert(console.log.calledWith('\n\tCommands:\n'));
-      assert(console.log.calledWith('\t\tlist [JOB_NAME]'));
-      assert(console.log.calledWith('\t\tget TRANSFER_NAME'));
-      assert(console.log.calledWith('\t\tpause TRANSFER_NAME'));
-      assert(console.log.calledWith('\t\tresume TRANSFER_NAME'));
-      assert(console.log.calledWith('\nExamples:\n'));
-      assert(console.log.calledWith('\tnode transfer jobs create my-bucket my-other-bucket 2016/08/12 16:30 "Move my files"'));
-      assert(console.log.calledWith('\tnode transfer jobs get transferJobs/123456789012345678'));
-      assert(console.log.calledWith('\tnode transfer jobs list'));
-      assert(console.log.calledWith('\tnode transfer jobs set transferJobs/123456789012345678 description "My new description"'));
-      assert(console.log.calledWith('\tnode transfer jobs set transferJobs/123456789012345678 status DISABLED'));
-      assert(console.log.calledWith('\tnode transfer operations list'));
-      assert(console.log.calledWith('\tnode transfer operations list transferJobs/123456789012345678'));
-      assert(console.log.calledWith('\tnode transfer operations get transferOperations/123456789012345678'));
-      assert(console.log.calledWith('\tnode transfer operations pause transferOperations/123456789012345678'));
-      assert(console.log.calledWith('\tnode transfer operations resume transferOperations/123456789012345678'));
-    });
-  });
-
   describe('main', function () {
-    it('should call the right commands', function () {
+    it('should call createTransferJob', function () {
       var program = getSample().program;
 
       sinon.stub(program, 'createTransferJob');
-      program.main(['jobs', 'create']);
+      program.main(['jobs', 'create', bucketName, bucketName, 'time', 'date']);
       assert(program.createTransferJob.calledOnce);
+    });
+
+    it('should call getTransferJob', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'getTransferJob');
-      program.main(['jobs', 'get']);
+      program.main(['jobs', 'get', jobName]);
       assert(program.getTransferJob.calledOnce);
+    });
+
+    it('should call listTransferJobs', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'listTransferJobs');
       program.main(['jobs', 'list']);
       assert(program.listTransferJobs.calledOnce);
+    });
+
+    it('should call updateTransferJob', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'updateTransferJob');
-      program.main(['jobs', 'set']);
+      program.main(['jobs', 'set', jobName, 'status', 'DISABLED']);
       assert(program.updateTransferJob.calledOnce);
+    });
+
+    it('should call listTransferOperations', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'listTransferOperations');
       program.main(['operations', 'list']);
       assert(program.listTransferOperations.calledOnce);
+    });
+
+    it('should call getTransferOperation', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'getTransferOperation');
-      program.main(['operations', 'get']);
+      program.main(['operations', 'get', transferOperationName]);
       assert(program.getTransferOperation.calledOnce);
+    });
+
+    it('should call pauseTransferOperation', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'pauseTransferOperation');
-      program.main(['operations', 'pause']);
+      program.main(['operations', 'pause', transferOperationName]);
       assert(program.pauseTransferOperation.calledOnce);
+    });
+
+    it('should call resumeTransferOperation', function () {
+      var program = getSample().program;
 
       sinon.stub(program, 'resumeTransferOperation');
-      program.main(['operations', 'resume']);
+      program.main(['operations', 'resume', transferOperationName]);
       assert(program.resumeTransferOperation.calledOnce);
-
-      sinon.stub(program, 'printUsage');
-      program.main(['--help']);
-      assert(program.printUsage.calledOnce);
-
-      program.main(['jobs']);
-      assert(program.printUsage.calledTwice);
-
-      program.main(['operations']);
-      assert(program.printUsage.calledThrice);
     });
   });
 });
diff --git a/storage/transfer.js b/storage/transfer.js
index dd1a1246b1..1958eff15b 100644
--- a/storage/transfer.js
+++ b/storage/transfer.js
@@ -51,20 +51,17 @@ function auth (callback) {
 /**
  * Review the transfer operations associated with a transfer job.
  *
- * @param {string} srcBucketName The name of the source bucket.
- * @param {string} destBucketName The name of the destination bucket.
- * @param {string} [description] Optional description for the new transfer job.
+ * @param {object} options Configuration options.
+ * @param {string} options.srcBucket The name of the source bucket.
+ * @param {string} options.destBucket The name of the destination bucket.
+ * @param {string} options.date The date of the first transfer in the format YYYY/MM/DD.
+ * @param {string} options.time The time of the first transfer in the format HH:MM.
+ * @param {string} [options.description] Optional. Description for the new transfer job.
  * @param {function} callback The callback function.
  */
-function createTransferJob (srcBucketName, destBucketName, date, time, description, callback) {
-  if (!srcBucketName) {
-    return callback(new Error('"srcBucketName" is required!'));
-  } else if (!destBucketName) {
-    return callback(new Error('"destBucketName" is required!'));
-  }
-
-  var startDate = moment(date, 'YYYY/MM/DD');
-  var transferTime = moment(time, 'HH:mm');
+function createTransferJob (options, callback) {
+  var startDate = moment(options.date, 'YYYY/MM/DD');
+  var transferTime = moment(options.time, 'HH:mm');
 
   auth(function (err, authClient) {
     if (err) {
@@ -76,10 +73,10 @@ function createTransferJob (srcBucketName, destBucketName, date, time, descripti
       status: 'ENABLED',
       transferSpec: {
         gcsDataSource: {
-          bucketName: srcBucketName
+          bucketName: options.srcBucket
         },
         gcsDataSink: {
-          bucketName: destBucketName
+          bucketName: options.destBucket
         },
         transferOptions: {
           deleteObjectsFromSourceAfterTransfer: false
@@ -98,8 +95,8 @@ function createTransferJob (srcBucketName, destBucketName, date, time, descripti
       }
     };
 
-    if (description) {
-      transferJob.description = description;
+    if (options.description) {
+      transferJob.description = options.description;
     }
 
     storagetransfer.transferJobs.create({
@@ -125,10 +122,6 @@ function createTransferJob (srcBucketName, destBucketName, date, time, descripti
  * @param {function} callback The callback function.
  */
 function getTransferJob (jobName, callback) {
-  if (!jobName) {
-    return callback(new Error('"jobName" is required!'));
-  }
-
   auth(function (err, authClient) {
     if (err) {
       return callback(err);
@@ -154,20 +147,13 @@ function getTransferJob (jobName, callback) {
 /**
  * Get a transfer job.
  *
- * @param {string} jobName The name of the transfer job to get.
- * @param {string} field The field to update. Can be description, status, or transferSpec.
- * @param {string} value The new value for the field.
+ * @param {object} options Configuration options.
+ * @param {string} options.job The name of the transfer job to get.
+ * @param {string} options.field The field to update. Can be description, status, or transferSpec.
+ * @param {string} options.value The new value for the field.
  * @param {function} callback The callback function.
  */
-function updateTransferJob (jobName, field, value, callback) {
-  if (!jobName) {
-    return callback(new Error('"jobName" is required!'));
-  } else if (!field) {
-    return callback(new Error('"field" is required!'));
-  } else if (!value) {
-    return callback(new Error('"value" is required!'));
-  }
-
+function updateTransferJob (options, callback) {
   auth(function (err, authClient) {
     if (err) {
       return callback(err);
@@ -176,22 +162,22 @@ function updateTransferJob (jobName, field, value, callback) {
     var patchRequest = {
       projectId: process.env.GCLOUD_PROJECT,
       transferJob: {
-        name: jobName
+        name: options.job
       },
-      updateTransferJobFieldMask: field
+      updateTransferJobFieldMask: options.field
     };
 
-    if (field === 'description') {
-      patchRequest.transferJob.description = value;
-    } else if (field === 'status') {
-      patchRequest.transferJob.status = value;
-    } else if (field === 'transferSpec') {
-      patchRequest.transferJob.transferSpec = JSON.parse(value);
+    if (options.field === 'description') {
+      patchRequest.transferJob.description = options.value;
+    } else if (options.field === 'status') {
+      patchRequest.transferJob.status = options.value;
+    } else if (options.field === 'transferSpec') {
+      patchRequest.transferJob.transferSpec = JSON.parse(options.value);
     }
 
     storagetransfer.transferJobs.patch({
       auth: authClient,
-      jobName: jobName,
+      jobName: options.job,
       resource: patchRequest
     }, function (err, transferJob) {
       if (err) {
@@ -281,10 +267,6 @@ function listTransferOperations (jobName, callback) {
  * @param {function} callback The callback function.
  */
 function getTransferOperation (transferOperationName, callback) {
-  if (!transferOperationName) {
-    return callback(new Error('"transferOperationName" is required!'));
-  }
-
   auth(function (err, authClient) {
     if (err) {
       return callback(err);
@@ -313,10 +295,6 @@ function getTransferOperation (transferOperationName, callback) {
  * @param {function} callback The callback function.
  */
 function pauseTransferOperation (transferOperationName, callback) {
-  if (!transferOperationName) {
-    return callback(new Error('"transferOperationName" is required!'));
-  }
-
   auth(function (err, authClient) {
     if (err) {
       return callback(err);
@@ -345,10 +323,6 @@ function pauseTransferOperation (transferOperationName, callback) {
  * @param {function} callback The callback function.
  */
 function resumeTransferOperation (transferOperationName, callback) {
-  if (!transferOperationName) {
-    return callback(new Error('"transferOperationName" is required!'));
-  }
-
   auth(function (err, authClient) {
     if (err) {
       return callback(err);
@@ -368,39 +342,12 @@ function resumeTransferOperation (transferOperationName, callback) {
   });
 }
 // [END resume_transfer_operation]
-
-// [START usage]
-function printUsage () {
-  console.log('Usage: node encryption RESOURCE COMMAND [ARGS...]');
-  console.log('\nResources:\n');
-  console.log('    jobs');
-  console.log('\n\tCommands:\n');
-  console.log('\t\tcreate SRC_BUCKET_NAME DEST_BUCKET_NAME DATE TIME [DESCRIPTION]');
-  console.log('\t\tget JOB_NAME');
-  console.log('\t\tlist');
-  console.log('\t\tset JOB_NAME FIELD VALUE');
-  console.log('\n    operations');
-  console.log('\n\tCommands:\n');
-  console.log('\t\tlist [JOB_NAME]');
-  console.log('\t\tget TRANSFER_NAME');
-  console.log('\t\tpause TRANSFER_NAME');
-  console.log('\t\tresume TRANSFER_NAME');
-  console.log('\nExamples:\n');
-  console.log('\tnode transfer jobs create my-bucket my-other-bucket 2016/08/12 16:30 "Move my files"');
-  console.log('\tnode transfer jobs get transferJobs/123456789012345678');
-  console.log('\tnode transfer jobs list');
-  console.log('\tnode transfer jobs set transferJobs/123456789012345678 description "My new description"');
-  console.log('\tnode transfer jobs set transferJobs/123456789012345678 status DISABLED');
-  console.log('\tnode transfer operations list');
-  console.log('\tnode transfer operations list transferJobs/123456789012345678');
-  console.log('\tnode transfer operations get transferOperations/123456789012345678');
-  console.log('\tnode transfer operations pause transferOperations/123456789012345678');
-  console.log('\tnode transfer operations resume transferOperations/123456789012345678');
-}
-// [END usage]
+// [END all]
 
 // The command-line program
-var program = {
+var cli = require('yargs');
+
+var program = module.exports = {
   createTransferJob: createTransferJob,
   getTransferJob: getTransferJob,
   listTransferJobs: listTransferJobs,
@@ -409,45 +356,64 @@ var program = {
   getTransferOperation: getTransferOperation,
   pauseTransferOperation: pauseTransferOperation,
   resumeTransferOperation: resumeTransferOperation,
-  printUsage: printUsage,
-
-  // Executed when this program is run from the command-line
-  main: function (args, cb) {
-    var resource = args.shift();
-    var command = args.shift();
-    if (resource === 'jobs') {
-      if (command === 'create') {
-        this.createTransferJob(args[0], args[1], args[2], args[3], args[4], cb);
-      } else if (command === 'get') {
-        this.getTransferJob(args[0], cb);
-      } else if (command === 'list') {
-        this.listTransferJobs(cb);
-      } else if (command === 'set') {
-        this.updateTransferJob(args[0], args[1], args[2], cb);
-      } else {
-        this.printUsage();
-      }
-    } else if (resource === 'operations') {
-      if (command === 'list') {
-        this.listTransferOperations(args[0], cb);
-      } else if (command === 'get') {
-        this.getTransferOperation(args[0], cb);
-      } else if (command === 'pause') {
-        this.pauseTransferOperation(args[0], cb);
-      } else if (command === 'resume') {
-        this.resumeTransferOperation(args[0], cb);
-      } else {
-        this.printUsage();
-      }
-    } else {
-      this.printUsage();
-    }
+  main: function (args) {
+    // Run the command-line program
+    cli.help().strict().parse(args).argv;
   }
 };
 
+cli
+  .demand(1)
+  .command('jobs <cmd> [args]', 'Run a job command.', function (yargs) {
+    yargs
+      .demand(2)
+      .command('create <srcBucket> <destBucket> <time> <date> [description]', 'Create a transfer job.', {}, function (options) {
+        program.createTransferJob(options, console.log);
+      })
+      .command('get <job>', 'Get a transfer job.', function (options) {
+        program.getTransferJob(options.job, console.log);
+      })
+      .command('list', 'List transfer jobs.', function (options) {
+        program.listTransferJobs(options, console.log);
+      })
+      .command('set <job> <field> <value>', 'Change the status, description or transferSpec of a transfer job.', function (options) {
+        program.updateTransferJob(options, console.log);
+      })
+      .example('node $0 jobs create my-bucket my-other-bucket 2016/08/12 16:30 "Move my files"', 'Create a transfer job.')
+      .example('node $0 jobs get transferJobs/123456789012345678', 'Get a transfer job.')
+      .example('node $0 jobs list', 'List transfer jobs.')
+      .example('node $0 jobs set transferJobs/123456789012345678 description "My new description"', 'Update the description for a transfer job.')
+      .example('node $0 jobs set transferJobs/123456789012345678 status DISABLED', 'Disable a transfer job.')
+      .wrap(100);
+  }, function () {})
+  .command('operations <cmd> [args]', 'Run an operation command.', function (yargs) {
+    yargs
+      .demand(2)
+      .command('list [job]', 'List transfer operations, optionally filtering by a job name.', function (options) {
+        program.listTransferOperations(options.job, console.log);
+      })
+      .command('get <operation>', 'Get a transfer operation.', function (options) {
+        program.getTransferOperation(options.operation, console.log);
+      })
+      .command('pause <operation>', 'Pause a transfer operation.', function (options) {
+        program.pauseTransferOperation(options.operation, console.log);
+      })
+      .command('resume <operation>', 'Resume a transfer operation.', function (options) {
+        program.resumeTransferOperation(options.operation, console.log);
+      })
+      .example('node $0 operations list', 'List all transfer operations.')
+      .example('node $0 operations list transferJobs/123456789012345678', 'List all transfer operations for a specific job.')
+      .example('node $0 operations get transferOperations/123456789012345678', 'Get a transfer operation.')
+      .example('node $0 operations pause transferOperations/123456789012345678', 'Pause a transfer operation.')
+      .example('node $0 operations resume transferOperations/123456789012345678', 'Resume a transfer operation.')
+      .wrap(100);
+  }, function () {})
+  .example('node $0 jobs --help', 'Show job commands.')
+  .example('node $0 operations --help', 'Show operations commands.')
+  .wrap(100)
+  .recommendCommands()
+  .epilogue('For more information, see https://cloud.google.com/storage/transfer');
+
 if (module === require.main) {
-  program.main(process.argv.slice(2), console.log);
+  program.main(process.argv.slice(2));
 }
-// [END all]
-
-module.exports = program;