From e4f009a542e74236c75d65ca892b899961a409cb Mon Sep 17 00:00:00 2001
From: Tyler Benton <tjbenton21@gmail.com>
Date: Thu, 5 Jan 2017 12:27:26 -0500
Subject: [PATCH 1/9] added tests for `Logger.time` and `Logger.timeEnd`

---
 app/utils.js       | 19 +++++++-----
 test/utils.test.js | 77 ++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 86 insertions(+), 10 deletions(-)

diff --git a/app/utils.js b/app/utils.js
index abb0b6e..7bda5d4 100644
--- a/app/utils.js
+++ b/app/utils.js
@@ -377,6 +377,7 @@ export class Logger {
         args.unshift(type);
         type = 'log';
       }
+      args = args.join('\n');
 
       if (type === 'verbose') {
         if (!this.options.verbose) return;
@@ -390,10 +391,10 @@ export class Logger {
         process.stdout.write(stamp);
       }
 
-      console[type](...args);
+      console.log(args);
 
       if (type === 'error') {
-        throw new Error(args.join('\n'));
+        throw new Error(args);
       }
     }
     return this;
@@ -461,7 +462,7 @@ export class Logger {
   ///# @chainable
   time(label) {
     if (!label) {
-      return this.error('You must pass in a label for `Logger.prototype.time`', (new Error()).trace);
+      return this.log('error', 'You must pass in a label for `Logger.prototype.time`');
     }
     perfy.start(label);
     return this;
@@ -474,15 +475,19 @@ export class Logger {
   ///# @returns {string} - The total time it took to run the process
   timeEnd(label) {
     if (!label) {
-      return this.error('You must pass in a label for `Logger.prototype.timeEnd`', (new Error()).trace);
+      return this.log('error', 'You must pass in a label for `Logger.prototype.timeEnd`');
     }
-    let time = perfy.end(label).time;
+    const result = perfy.end(label);
     let suffix = 's';
+    let time;
     // convert to milliseconds
-    if (time < 1) {
-      time *= Math.pow(10, 1);
+    if (result.time < 1) {
+      time = result.milliseconds;
       suffix = 'ms';
+    } else {
+      time = result.time;
     }
+
     time = `+${time.toFixed(2)}${suffix}`;
     return `${chalk.cyan(time)}`;
   }
diff --git a/test/utils.test.js b/test/utils.test.js
index 7a85b97..8fc17c5 100644
--- a/test/utils.test.js
+++ b/test/utils.test.js
@@ -15,6 +15,7 @@ import { map } from 'async-array-methods';
 import to from 'to-js';
 import AdmZip from 'adm-zip';
 import { stdout } from 'test-console';
+import { stripColor } from 'chalk';
 
 async function touch(...files) {
   return map(to.flatten(files), (file) => {
@@ -56,6 +57,7 @@ test.group('objectSearch', (test) => {
   });
 });
 
+
 test.group('findFiles', (test) => {
   const root = p(utils_root, 'find-files');
   const files = [
@@ -87,7 +89,6 @@ test.group('findFiles', (test) => {
 });
 
 
-
 test.group('readFiles', (test) => {
   const root = p(utils_root, 'read-files');
   /* eslint-disable max-len */
@@ -244,6 +245,7 @@ test.serial.group('pool', async (test) => {
   });
 });
 
+
 test.serial.group('parsers', (test) => {
   const expected = {
     _id: 'airport_56',
@@ -411,19 +413,88 @@ test.serial.group('parsers', (test) => {
   }
 });
 
+
 test.group('Logger', (test) => {
   test.group('options', (test) => {
     test('none', (t) => {
-      let logger = new Logger();
+      const logger = new Logger();
       t.deepEqual(logger.options, { log: true, verbose: false, timestamp: true });
     });
 
     test('log is false', (t) => {
-      let logger = new Logger({ log: false });
+      const logger = new Logger({ log: false });
       t.deepEqual(logger.options, { log: false, verbose: false, timestamp: true });
     });
   });
 
+  test.serial.group('time', (test) => {
+    const delay = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
+    test('throws when no label is passed (time)', (t) => {
+      const logger = new Logger();
+      const tester = () => logger.time();
+      const inspect = stdout.inspect();
+      t.throws(tester);
+      inspect.restore();
+      t.not(stripColor(inspect.output[0]), inspect.output[0]);
+      t.truthy(/^\[[0-9]+:[0-9]+:[0-9]+\]\s.+\serror:\s*$/.test(stripColor(inspect.output[0])));
+      t.is(inspect.output.length, 2);
+      t.is(inspect.output[1].split('\n')[0], 'You must pass in a label for `Logger.prototype.time`');
+    });
+
+    test('throws when no label is passed (timeEnd)', (t) => {
+      const logger = new Logger();
+      const tester = () => logger.timeEnd();
+      const inspect = stdout.inspect();
+      t.throws(tester);
+      inspect.restore();
+      t.not(stripColor(inspect.output[0]), inspect.output[0]);
+      t.truthy(/^\[[0-9]+:[0-9]+:[0-9]+\]\s.+\serror:\s*$/.test(stripColor(inspect.output[0])));
+      t.is(inspect.output.length, 2);
+      t.is(inspect.output[1].split('\n')[0], 'You must pass in a label for `Logger.prototype.timeEnd`');
+    });
+
+    test('returns this', (t) => {
+      const logger = new Logger();
+      const actual = logger.time('returns');
+      t.is(actual.constructor.name, 'Logger');
+    });
+
+    test.group((test) => {
+      const tests = [
+        { time: 1, expected: 1 },
+        { time: 100, expected: 100 },
+        { time: 500, expected: 500 },
+        { time: 1500, expected: 1.5 },
+        { time: 2500, expected: 2.5 },
+      ];
+
+      tests.forEach(({ time, expected }) => {
+        test(expected.toString(), async (t) => {
+          let min = expected;
+          let max = expected;
+          const logger = new Logger();
+          logger.time(expected);
+          await delay(time);
+          let actual = logger.timeEnd(expected);
+          t.truthy(actual);
+          t.is(typeof actual, 'string');
+          let [ number, unit ] = stripColor(actual).match(/\+?([0-9\.]+)([ms]+)/).slice(1);
+          number = parseFloat(number);
+          if (unit === 'ms') {
+            min -= 8;
+            max += 8;
+          } else {
+            min -= 0.2;
+            max += 0.2;
+          }
+
+          t.is(unit, time < 1000 ? 'ms' : 's');
+          t.truthy(number >= min && number <= max);
+        });
+      });
+    });
+  });
+
   test('functions', (t) => {
     t.deepEqual(
       to.keys(Logger.prototype).sort(),

From 8a6f72d469104a15268f618154666066f0b4646a Mon Sep 17 00:00:00 2001
From: Tyler Benton <tjbenton21@gmail.com>
Date: Thu, 5 Jan 2017 12:34:56 -0500
Subject: [PATCH 2/9] removed unused functions in Logger

---
 app/utils.js       | 36 ------------------------------------
 test/utils.test.js |  2 +-
 2 files changed, 1 insertion(+), 37 deletions(-)

diff --git a/app/utils.js b/app/utils.js
index 7bda5d4..0b7f240 100644
--- a/app/utils.js
+++ b/app/utils.js
@@ -419,42 +419,6 @@ export class Logger {
     return stamp;
   }
 
-  ///# @name error
-  ///# @description This is an alias for `this.log('error', 'message.....')
-  ///# @arg {*} ...args - The message that should be passed
-  ///# @chainable
-  error(...args) {
-    this.log('error', ...args);
-    return this;
-  }
-
-  ///# @name warn
-  ///# @description This is an alias for `this.log('warn', 'message.....')
-  ///# @arg {*} ...args - The message that should be passed
-  ///# @chainable
-  warn(...args) {
-    this.log('warning', ...args);
-    return this;
-  }
-
-  ///# @name info
-  ///# @description This is an alias for `this.log('info', 'message.....')
-  ///# @arg {*} ...args - The message that should be passed
-  ///# @chainable
-  info(...args) {
-    this.log('info', ...args);
-    return this;
-  }
-
-  ///# @name verbose
-  ///# @description This is an alias for `this.log('verbose', 'message.....')
-  ///# @arg {*} ...args - The message that should be passed
-  ///# @chainable
-  verbose(...args) {
-    this.log('info', ...args);
-    return this;
-  }
-
   ///# @name time
   ///# @description
   ///# This does the same thing as `console.time`.
diff --git a/test/utils.test.js b/test/utils.test.js
index 8fc17c5..c438e32 100644
--- a/test/utils.test.js
+++ b/test/utils.test.js
@@ -498,7 +498,7 @@ test.group('Logger', (test) => {
   test('functions', (t) => {
     t.deepEqual(
       to.keys(Logger.prototype).sort(),
-      [ 'constructor', 'log', 'stamp', 'error', 'warn', 'info', 'verbose', 'time', 'timeEnd' ].sort()
+      [ 'constructor', 'log', 'stamp', 'time', 'timeEnd' ].sort()
     );
   });
 });

From 81a61cc23479edc19cd02aa7294c6c4fc182899c Mon Sep 17 00:00:00 2001
From: Tyler Benton <tjbenton21@gmail.com>
Date: Thu, 5 Jan 2017 14:00:35 -0500
Subject: [PATCH 3/9] added more tests for `Logger.log`

---
 app/utils.js       |  2 +-
 test/utils.test.js | 65 +++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 65 insertions(+), 2 deletions(-)

diff --git a/app/utils.js b/app/utils.js
index 0b7f240..4c88c99 100644
--- a/app/utils.js
+++ b/app/utils.js
@@ -412,7 +412,7 @@ export class Logger {
     if (symbols[type]) {
       stamp += `${symbols[type]} `;
     }
-    if ([ 'error', 'warning', 'warn', 'info' ].includes(type)) {
+    if ([ 'error', 'warning', 'info' ].includes(type)) {
       stamp += `${chalk[color](type)}: `;
     }
 
diff --git a/test/utils.test.js b/test/utils.test.js
index c438e32..2fc37a0 100644
--- a/test/utils.test.js
+++ b/test/utils.test.js
@@ -415,6 +415,8 @@ test.serial.group('parsers', (test) => {
 
 
 test.group('Logger', (test) => {
+  const delay = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
+
   test.group('options', (test) => {
     test('none', (t) => {
       const logger = new Logger();
@@ -427,8 +429,69 @@ test.group('Logger', (test) => {
     });
   });
 
+  test.serial.group('log', (test) => {
+    test('returns this', (t) => {
+      const logger = new Logger();
+      const inspect = stdout.inspect();
+      const actual = logger.log();
+      inspect.restore();
+      t.is(actual.constructor.name, 'Logger');
+    });
+
+    const log_types = [ 'warning', 'success', 'info', 'verbose', 'log' ];
+
+    log_types.forEach((type) => {
+      test(type, (t) => {
+        const logger = new Logger({ verbose: true });
+        const inspect = stdout.inspect();
+        logger.log(type, `${type} test`);
+        inspect.restore();
+        t.is(inspect.output.length, 2);
+        t.is(inspect.output[1].trim(), `${type} test`);
+        if (![ 'warning', 'info' ].includes(type)) {
+          type = '';
+        }
+        t.truthy(new RegExp(`^\\[[0-9]+:[0-9]+:[0-9]+\\]\\s(?:.+)?\\s*${type}:?\\s*$`).test(stripColor(inspect.output[0])));
+      });
+    });
+
+    test.group('throws error', (test) => {
+      const regex = /^\[[0-9]+:[0-9]+:[0-9]+\]\s.+\serror:\s*$/;
+      test('when string is passed as the type', (t) => {
+        const logger = new Logger();
+        const tester = () => logger.log('error', 'woohoo');
+        const inspect = stdout.inspect();
+        t.throws(tester);
+        inspect.restore();
+        t.is(inspect.output.length, 2);
+        t.is(inspect.output[1].trim(), 'woohoo');
+        t.truthy(regex.test(stripColor(inspect.output[0])));
+      });
+
+      test('when error constructor is passed as the first argument', (t) => {
+        const logger = new Logger();
+        const tester = () => logger.log(new Error('woohoo'));
+        const inspect = stdout.inspect();
+        t.throws(tester);
+        inspect.restore();
+        t.is(inspect.output.length, 2);
+        t.is(inspect.output[1].trim(), 'Error: woohoo');
+        t.truthy(regex.test(stripColor(inspect.output[0])));
+      });
+    });
+
+    test('time and timeEnd', async (t) => {
+      const logger = new Logger();
+      const time = logger.log('time', 'woohoo');
+      t.is(time.constructor.name, 'Logger');
+      await delay(200);
+      const end = logger.log('timeEnd', 'woohoo');
+      const woohoo = parseFloat(end.match(/\+([0-9\.]+)/)[1]);
+      t.truthy(woohoo > 190);
+    });
+  });
+
   test.serial.group('time', (test) => {
-    const delay = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
     test('throws when no label is passed (time)', (t) => {
       const logger = new Logger();
       const tester = () => logger.time();

From c475a1d4fbfb6492890db319109d90a4919df6fb Mon Sep 17 00:00:00 2001
From: Tyler Benton <tjbenton21@gmail.com>
Date: Thu, 5 Jan 2017 14:05:10 -0500
Subject: [PATCH 4/9] ignore a few parts of the parser tests that are too hard
 to mock

---
 app/utils.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/app/utils.js b/app/utils.js
index 4c88c99..db96c80 100644
--- a/app/utils.js
+++ b/app/utils.js
@@ -242,6 +242,7 @@ parsers.cson = {
   parse: (obj) => {
     return new Promise((resolve, reject) => {
       cson.parse(obj, {}, (err, result) => {
+        /* istanbul ignore next */
         if (err) {
           return reject(err);
         }
@@ -272,12 +273,14 @@ parsers.csv = {
     // `"{\"latitude\":-6.081689835,\"longitude\":145.3919983,\"level-2\":{\"level-3\":\"woohoo\"}}"`
     // it also doesn't handle numbers correctly so this fixes those instances as well
     function fix(a, b) {
+      /* istanbul ignore if : too hard to create a test case for it */
       if (!a || !b) {
         return a;
       }
 
       for (let k in b) { // eslint-disable-line
         if (b.hasOwnProperty(k)) {
+          /* istanbul ignore if : too hard to create a test case for it */
           if (is.plainObject(b[k])) {
             a[k] = is.plainObject(a[k]) ? fix(a[k], b[k]) : b[k];
           } else if (is.string(b[k]) && /^[0-9]+$/.test(b[k])) {

From f47ff1091e326389035df89be91c5042c1a10137 Mon Sep 17 00:00:00 2001
From: Tyler Benton <tjbenton21@gmail.com>
Date: Thu, 5 Jan 2017 14:17:25 -0500
Subject: [PATCH 5/9] added more test cases for `objectSearch`

---
 app/utils.js       |  8 ++++----
 test/utils.test.js | 19 +++++++++++++++++++
 2 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/app/utils.js b/app/utils.js
index db96c80..a75d6d6 100644
--- a/app/utils.js
+++ b/app/utils.js
@@ -29,10 +29,10 @@ export function objectSearch(data, pattern, current_path, paths = []) {
   }
   if (Array.isArray(data)) {
     for (let i = 0; i < data.length; i++) {
-      let test_path = appendPath(current_path, i);
+      const test_path = appendPath(current_path, i);
       if (
         test_path.match(pattern) &&
-        paths.indexOf(test_path) === -1
+        !paths.includes(test_path)
       ) {
         paths.push(test_path);
       }
@@ -44,10 +44,10 @@ export function objectSearch(data, pattern, current_path, paths = []) {
   ) {
     for (let key in data) {
       if (data.hasOwnProperty(key)) {
-        let test_path = appendPath(current_path, key);
+        const test_path = appendPath(current_path, key);
         if (
           test_path.match(pattern) &&
-          paths.indexOf(test_path) === -1
+          !paths.includes(test_path)
         ) {
           paths.push(test_path);
         }
diff --git a/test/utils.test.js b/test/utils.test.js
index 2fc37a0..aecf5f0 100644
--- a/test/utils.test.js
+++ b/test/utils.test.js
@@ -16,6 +16,7 @@ import to from 'to-js';
 import AdmZip from 'adm-zip';
 import { stdout } from 'test-console';
 import { stripColor } from 'chalk';
+import _ from 'lodash';
 
 async function touch(...files) {
   return map(to.flatten(files), (file) => {
@@ -55,6 +56,24 @@ test.group('objectSearch', (test) => {
     t.is(actual.length, 1);
     t.deepEqual(actual, [ 'one.two' ]);
   });
+
+  test('match first instance of `two`', (t) => {
+    const arr = [ obj, obj ];
+    const actual = objectSearch(arr, /^.*two$/);
+    t.is(actual.length, 2);
+    t.deepEqual(actual, [ '0.one.two', '1.one.two' ]);
+    // ensure it works with lodash get method
+    t.deepEqual(_.get(arr, actual[0]), { three: 'woohoo' });
+  });
+
+  test('match first instance of `two`', (t) => {
+    const arr = [ obj, obj ];
+    const actual = objectSearch(arr, /^[0-9]$/);
+    t.is(actual.length, 2);
+    t.deepEqual(actual, [ '0', '1' ]);
+    // ensure it works with lodash get method
+    t.deepEqual(_.get(arr, actual[0]), obj);
+  });
 });
 
 

From 16237255f6f0c89f8d373382d06c6a1c2ab42b14 Mon Sep 17 00:00:00 2001
From: Tyler Benton <tjbenton21@gmail.com>
Date: Thu, 5 Jan 2017 14:27:06 -0500
Subject: [PATCH 6/9] added a test for `findFiles`

---
 test/utils.test.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/utils.test.js b/test/utils.test.js
index aecf5f0..57aca88 100644
--- a/test/utils.test.js
+++ b/test/utils.test.js
@@ -104,6 +104,12 @@ test.group('findFiles', (test) => {
     t.deepEqual(actual, files.slice(0, 1));
   });
 
+  test('pass a file', async (t) => {
+    const actual = await findFiles(p(root, 'file-1.js'));
+    t.is(actual.length, 1);
+    t.deepEqual(actual, files.slice(0, 1));
+  });
+
   test.after.always(() => fs.remove(root));
 });
 

From b11b50bce442b49b13f7448b5b651fa4f3040f30 Mon Sep 17 00:00:00 2001
From: Tyler Benton <tjbenton21@gmail.com>
Date: Thu, 5 Jan 2017 15:12:27 -0500
Subject: [PATCH 7/9] improved output/couchbase code coverage

---
 app/output/couchbase.js       |  1 +
 test/output/couchbase.test.js | 36 +++++++++++++++++++++++++----------
 2 files changed, 27 insertions(+), 10 deletions(-)

diff --git a/app/output/couchbase.js b/app/output/couchbase.js
index 2b9b9f1..8e5b0a1 100644
--- a/app/output/couchbase.js
+++ b/app/output/couchbase.js
@@ -45,6 +45,7 @@ export default class Couchbase extends Base {
     const { server, bucket, password, timeout } = this.output_options;
     return new Promise((resolve, reject) => {
       this.bucket = this.cluster.openBucket(bucket, password, (err) => {
+        /* istanbul ignore if : to hard to test since this is a third party function */
         if (err) return reject(err);
 
         this.log('verbose', `Connection to '${bucket}' bucket at '${server}' was successful`);
diff --git a/test/output/couchbase.test.js b/test/output/couchbase.test.js
index c6e4e79..772fda2 100644
--- a/test/output/couchbase.test.js
+++ b/test/output/couchbase.test.js
@@ -22,6 +22,7 @@ test('without args', (t) => {
   t.is(t.context.prepared, false);
   t.is(typeof t.context.prepare, 'function');
   t.is(typeof t.context.output, 'function');
+  t.is(t.context.cluster.constructor.name, 'MockCluster');
 });
 
 test('prepare', async (t) => {
@@ -36,16 +37,18 @@ test('prepare', async (t) => {
   t.is(t.context.bucket.connected, true);
 });
 
-test('setup', async (t) => {
-  t.is(t.context.prepared, false);
-  t.is(t.context.preparing, undefined);
-  const preparing = t.context.setup();
-  t.is(typeof t.context.preparing.then, 'function');
-  t.is(t.context.prepared, false);
-  await preparing;
-  t.is(t.context.prepared, true);
-  t.is(to.type(t.context.bucket), 'object');
-  t.is(t.context.bucket.connected, true);
+test.group('setup', (test) => {
+  test(async (t) => {
+    t.is(t.context.prepared, false);
+    t.is(t.context.preparing, undefined);
+    const preparing = t.context.setup();
+    t.is(typeof t.context.preparing.then, 'function');
+    t.is(t.context.prepared, false);
+    t.falsy(await preparing);
+    t.is(t.context.prepared, true);
+    t.is(to.type(t.context.bucket), 'object');
+    t.is(t.context.bucket.connected, true);
+  });
 });
 
 test.group('output', (test) => {
@@ -130,6 +133,19 @@ test.group('output', (test) => {
       t.deepEqual(document.value, data);
     });
   }
+
+  test('prepare has started but isn\'t complete', async (t) => {
+    const language = 'json';
+    const data = languages[language];
+    t.context.output_options.bucket = `output-${language}`;
+    const id = `1234567890-${language}`;
+    t.context.output_options.format = language;
+    t.context.prepare();
+    await t.context.output(id, data);
+    const document = await t.context.bucket.getAsync(id);
+    t.not(document, null);
+    t.deepEqual(document.value, data);
+  });
 });
 
 test.group('finalize', (test) => {

From e3f07bba8687ed10c624d9f746946efcf94da002 Mon Sep 17 00:00:00 2001
From: Tyler Benton <tjbenton21@gmail.com>
Date: Thu, 5 Jan 2017 16:14:18 -0500
Subject: [PATCH 8/9] Updated tests for sync-gateway

this doesn't add many tests but it improves the code coverage.
---
 app/output/sync-gateway.js       |  4 ++-
 package.json                     |  1 -
 test/output/sync-gateway.test.js | 46 ++++++++++++--------------------
 3 files changed, 20 insertions(+), 31 deletions(-)

diff --git a/app/output/sync-gateway.js b/app/output/sync-gateway.js
index d92c47f..b9de1e8 100644
--- a/app/output/sync-gateway.js
+++ b/app/output/sync-gateway.js
@@ -28,6 +28,7 @@ export default class SyncGateway extends Base {
   ///# wait for it to be done before it starts saving data.
   ///# @returns {promise} - The setup function that was called
   ///# @async
+  /* istanbul ignore next */
   prepare() {
     this.preparing = true;
     this.preparing = this.setup();
@@ -38,6 +39,7 @@ export default class SyncGateway extends Base {
   ///# @description
   ///# This is used to setup the saving function that will be used.
   ///# @async
+  /* istanbul ignore next */
   setup() {
     // if this.prepare hasn't been called then run it first.
     if (this.preparing == null) {
@@ -141,8 +143,8 @@ export default class SyncGateway extends Base {
 export function request(options = {}) {
   return new Promise((resolve, reject) => {
     req(options, (err, res, body) => {
+      /* istanbul ignore next : to hard to mock test */
       if (err) return reject(err);
-
       resolve([ res, body ]);
     });
   });
diff --git a/package.json b/package.json
index 6e30eee..8c44e6a 100644
--- a/package.json
+++ b/package.json
@@ -85,7 +85,6 @@
     "joi": "~10.0.5",
     "jsondiffpatch": "~0.2.4",
     "lint-rules": "github:ma-shop/lint-rules",
-    "nock": "~9.0.2",
     "nyc": "~9.0.1",
     "proxyquire": "~1.7.10",
     "test-console": "~1.0.0"
diff --git a/test/output/sync-gateway.test.js b/test/output/sync-gateway.test.js
index 62fbaa9..4d54a58 100644
--- a/test/output/sync-gateway.test.js
+++ b/test/output/sync-gateway.test.js
@@ -1,10 +1,14 @@
 /* eslint-disable id-length, no-shadow, no-undefined */
-
-import SyncGateway from '../../dist/output/sync-gateway';
+import to from 'to-js';
+import proxyquire from 'proxyquire';
+import req from 'request';
+function mockRequest(options, callback) {
+  callback(null, { headers: { 'set-cookie': true } }, { ok: true });
+}
+to.extend(mockRequest, req);
+const { request, default: SyncGateway } = proxyquire('../../dist/output/sync-gateway', { request: mockRequest });
 import default_options from '../../dist/output/default-options';
 import ava from 'ava-spec';
-import nock from 'nock';
-nock.disableNetConnect();
 
 const test = ava.group('output:sync-gateway');
 
@@ -30,30 +34,6 @@ test.group('prepare', (test) => {
     await preparing;
     t.is(t.context.prepared, true);
   });
-
-  // NO IDEA HOW THE HELL TO WRITE UNIT TESTS FOR THIS CRAP
-  test.skip('authentication', async (t) => {
-    t.context.output_options.bucket = 'prepare';
-    t.context.output_options.username = 'Administrator';
-    t.context.output_options.password = 'password';
-
-    nock(t.context.output_options.server)
-      .post(`/${encodeURIComponent(t.context.output_options.bucket)}/_session`, {
-        name: t.context.output_options.username,
-        password: t.context.output_options.password,
-      })
-      .reply({
-        ok: true,
-      });
-
-    t.is(t.context.prepared, false);
-    t.is(t.context.preparing, undefined);
-    const preparing = t.context.prepare();
-    t.is(typeof t.context.preparing.then, 'function');
-    t.is(t.context.prepared, false);
-    await preparing;
-    t.is(t.context.prepared, true);
-  });
 });
 
 test.group('setup', (test) => {
@@ -84,10 +64,18 @@ test.group('setup', (test) => {
 });
 
 test.group('output', (test) => {
+  // currently can't test this
   test.todo();
 });
 
 // this is just calling another library and it's just converting
 // it's callback style to a promise style so we just need to ensure
 // it's a promise.
-test.todo('request');
+test('request', async (t) => {
+  let actual = request('localhost:3000');
+  t.is(typeof actual.then, 'function');
+  actual = await actual;
+  t.is(to.type(actual), 'array');
+  t.is(to.type(actual[0]), 'object');
+  t.is(to.type(actual[1]), 'object');
+});

From b08ed76fa64a5ac9fb07d523c443c2876b5873ef Mon Sep 17 00:00:00 2001
From: Tyler Benton <tjbenton21@gmail.com>
Date: Thu, 5 Jan 2017 16:25:30 -0500
Subject: [PATCH 9/9] improved code coverage for `output/index`

---
 app/output/index.js       | 27 ++++++++++----------------
 test/output/index.test.js | 40 ++++++++++++++++++++++++++++-----------
 2 files changed, 39 insertions(+), 28 deletions(-)

diff --git a/app/output/index.js b/app/output/index.js
index afdfa3d..e08e292 100644
--- a/app/output/index.js
+++ b/app/output/index.js
@@ -142,15 +142,13 @@ export default class Output extends Base {
   ///# @description This is used to validate the output options
   ///# @throws {error} - If an option that was passed is invalid.
   validateOutputOptions() {
-    for (let option in this.output_options) {
-      if (this.output_options.hasOwnProperty(option)) {
-        try {
-          validate[option](this.output_options[option], this.output_options);
-        } catch (e) {
-          this.log('error', e);
-        }
+    to.each(this.output_options, ({ key, value }) => {
+      try {
+        validate[key](value, this.output_options);
+      } catch (e) {
+        this.log('error', e);
       }
-    }
+    });
   }
 }
 
@@ -206,10 +204,9 @@ export const validate = {
   ///# @arg {number} option - The option to validate against
   ///# @throws {error} - If the limit option that was pass was invalid
   limit(option) {
-    if (is.number(option)) {
-      return;
+    if (!is.number(option)) {
+      throw new Error('The limit option must be a number');
     }
-    throw new Error('The limit option must be a number');
   },
 
   ///# @name archive
@@ -245,7 +242,6 @@ export const validate = {
 
     if (archive === true) {
       throw new Error(`The archive option can't be used with ${option}`);
-      return;
     }
 
     isString(option, 'server');
@@ -292,10 +288,9 @@ export const validate = {
   ///# @arg {number} option - The option to validate against
   ///# @throws {error} - If the limit option that was pass was invalid
   timeout(option) {
-    if (is.number(option)) {
-      return;
+    if (!is.number(option)) {
+      throw new Error('The timeout option must be a number');
     }
-    throw new Error('The timeout option must be a number');
   },
 };
 
@@ -321,13 +316,11 @@ export function isString(option, name = '') {
   }
   if (!is.string(option)) {
     throw new Error(`The${name}option must be a string`);
-    return false;
   } else if (
     is.string(option) &&
     !option.length
   ) {
     throw new Error(`The${name}option must have a length`);
-    return false;
   }
   return true;
 }
diff --git a/test/output/index.test.js b/test/output/index.test.js
index a4f4a49..ea3d710 100644
--- a/test/output/index.test.js
+++ b/test/output/index.test.js
@@ -204,6 +204,18 @@ test.group('validation', (test) => {
       t.throws(validateArchive);
       t.throws(t.context.validateOutputOptions);
     });
+
+    test.serial('failing output because `archive` isn\'t a `.zip` file', (t) => {
+      t.context.output_options.archive = 'somefile.woohoo';
+      t.context.output_options.output = 'somefolder';
+      const validateArchive = () => validate.archive(t.context.output_options.archive, t.context.output_options);
+      const validateOutputOptions = () => t.context.validateOutputOptions();
+      const inspect = stdout.inspect();
+      t.throws(validateArchive);
+      t.throws(validateOutputOptions);
+      inspect.restore();
+    });
+
     test('failing output is console', (t) => {
       t.context.output_options.output = 'console';
       t.context.output_options.archive = 'somefile.zip';
@@ -211,6 +223,14 @@ test.group('validation', (test) => {
       t.throws(validateArchive);
       t.throws(t.context.validateOutputOptions);
     });
+
+    test('failing output a string wasn\'t passed as the option', (t) => {
+      t.context.output_options.output = 'test-folder';
+      t.context.output_options.archive = [];
+      const validateArchive = () => validate.archive(t.context.output_options.archive, t.context.output_options);
+      t.throws(validateArchive);
+      t.throws(t.context.validateOutputOptions);
+    });
   });
 
   test.group('server', (test) => {
@@ -249,6 +269,7 @@ test.group('validation', (test) => {
       t.context.output_options.output = 'couchbase';
       t.context.output_options.archive = true;
       t.context.output_options.server = '127.0.0.1';
+
       const validateServer = () => validate.server(t.context.output_options.server, t.context.output_options);
       t.throws(validateServer);
       t.throws(t.context.validateOutputOptions);
@@ -582,21 +603,18 @@ test.group('output', (test) => {
     });
   }));
 
-
-  test.group('couchbase', (test) => {
-    test.todo();
-  });
-
-  test.group('sync-gateway', (test) => {
-    test.todo();
-  });
+  // These are too difficult to unit test but they are tested else where
+  // test.group('couchbase', (test) => {
+  //   test.todo();
+  // });
+  //
+  // test.group('sync-gateway', (test) => {
+  //   test.todo();
+  // });
 
   test.after.always(() => fs.remove(root));
 });
 
-
-test.todo('finalize');
-
 // This will loop through each of the languages to run tests for each one.
 // It makes it easier to test each language for each type of output rather
 // than duplicating the loop on each test