@cloudant/couchbackup 2.9.13-SNAPSHOT.143 → 2.9.13

package/.scannerwork/scanner-report/source-21.txt

@@ -0,0 +1,119 @@
+// Copyright © 2017 IBM Corp. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/* global describe it */
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const u = require('./citestutils.js');
+
+[{ useApi: true }, { useApi: false }].forEach(function(params) {
+  describe(u.scenario('Resume tests', params), function() {
+    it('should create a log file', function(done) {
+      // Allow up to 90 s for this test
+      u.setTimeout(this, 60);
+
+      const actualBackup = `./${this.fileName}`;
+      const logFile = `./${this.fileName}` + '.log';
+      // Use abort parameter to terminate the backup a given number of ms after
+      // the first data write to the output file.
+      const p = u.p(params, { opts: { log: logFile } });
+      u.testBackupToFile(p, 'animaldb', actualBackup, function(err) {
+        if (err) {
+          done(err);
+        } else {
+          // Assert the log file exists
+          try {
+            assert.ok(fs.existsSync(logFile), 'The log file should exist.');
+            done();
+          } catch (err) {
+            done(err);
+          }
+        }
+      });
+    });
+
+    it('should restore corrupted animaldb to a database correctly', function(done) {
+      // Allow up to 60 s to restore and compare (again it should be faster)!
+      u.setTimeout(this, 60);
+      const input = fs.createReadStream('./test/fixtures/animaldb_corrupted.json');
+      const dbName = this.dbName;
+      input.on('open', function() {
+        u.testRestore(params, input, dbName, function(err) {
+          if (err) {
+            done(err);
+          } else {
+            u.dbCompare('animaldb', dbName, done);
+          }
+        });
+      });
+    });
+
+    it('should restore resumed animaldb with blank line to a database correctly', function(done) {
+      // Allow up to 60 s to restore and compare (again it should be faster)!
+      u.setTimeout(this, 60);
+      const input = fs.createReadStream('./test/fixtures/animaldb_resumed_blank.json');
+      const dbName = this.dbName;
+      input.on('open', function() {
+        u.testRestore(params, input, dbName, function(err) {
+          if (err) {
+            done(err);
+          } else {
+            u.dbCompare('animaldb', dbName, done);
+          }
+        });
+      });
+    });
+  });
+});
+
+describe('Resume tests', function() {
+  // Currently cannot abort API backups, when we do this test should be run for
+  // both API and CLI
+  it('should correctly backup and restore backup10m', function(done) {
+    // Allow up to 90 s for this test
+    u.setTimeout(this, 90);
+
+    const actualBackup = `./${this.fileName}`;
+    const logFile = `./${this.fileName}` + '.log';
+    // Use abort parameter to terminate the backup a given number of ms after
+    // the first data write to the output file.
+    const p = u.p(params, { abort: true }, { opts: { log: logFile } });
+    const restoreDb = this.dbName;
+    // Set the database doc count as fewer than this should be written during
+    // resumed backup.
+    p.exclusiveMaxExpected = 5096;
+
+    u.testBackupAbortResumeRestore(p, 'backup10m', actualBackup, restoreDb, done);
+  });
+  // Note --output is only valid for CLI usage, this test should only run for CLI
+  const params = { useApi: false };
+  it('should correctly backup and restore backup10m using --output', function(done) {
+    // Allow up to 90 s for this test
+    u.setTimeout(this, 90);
+
+    const actualBackup = `./${this.fileName}`;
+    const logFile = `./${this.fileName}` + '.log';
+    // Use abort parameter to terminate the backup a given number of ms after
+    // the first data write to the output file.
+    const p = u.p(params, { abort: true }, { opts: { output: actualBackup, log: logFile } });
+    const restoreDb = this.dbName;
+    // Set the database doc count as fewer than this should be written during
+    // resumed backup.
+    p.exclusiveMaxExpected = 5096;
+
+    u.testBackupAbortResumeRestore(p, 'backup10m', actualBackup, restoreDb, done);
+  });
+});

package/.scannerwork/scanner-report/source-35.txt

@@ -1,4 +1,4 @@
-// Copyright © 2017 IBM Corp. All rights reserved.
+// Copyright © 2017, 2021 IBM Corp. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,18 +12,355 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-/* global describe it */
+/* global describe afterEach before after it */
 'use strict';
 
-const u = require('./citestutils.js');
+const assert = require('assert');
+const parser = require('../includes/parser.js');
 
-[{ useApi: true }, { useApi: false }].forEach(function(params) {
-  describe(u.scenario('#slowest End to end backup and restore', params), function() {
-    // 10 GB is about the largest the CI can handle before getting very upset
-    // about how long things are taking
-    it('should backup and restore largedb10g', function(done) {
-      u.setTimeout(this, 350 * 60);
-      u.testDirectBackupAndRestore(params, 'largedb10g', this.dbName, done);
+describe('#unit Default parameters', function() {
+  let processEnvCopy;
+  let processArgvCopy;
+
+  before('Set process data for test', function() {
+    // Copy env and argv so we can reset them after the tests
+    processEnvCopy = JSON.parse(JSON.stringify(process.env));
+    processArgvCopy = JSON.parse(JSON.stringify(process.argv));
+
+    // setup environment variables
+    process.env.COUCH_URL = 'http://user:pass@myurl.com';
+    process.env.COUCH_DATABASE = 'mydb';
+    process.env.COUCH_BUFFER_SIZE = '1000';
+    process.env.COUCH_PARALLELISM = '20';
+    process.env.COUCH_REQUEST_TIMEOUT = '20000';
+    process.env.COUCH_LOG = 'my.log';
+    process.env.COUCH_RESUME = 'true';
+    process.env.COUCH_OUTPUT = 'myfile.txt';
+    process.env.COUCH_MODE = 'shallow';
+    process.env.CLOUDANT_IAM_API_KEY = 'ABC123-ZYX987_cba789-xyz321';
+    process.env.COUCH_QUIET = 'true';
+  });
+
+  after('Reset process data', function() {
+    process.env = processEnvCopy;
+    process.argv = processArgvCopy;
+  });
+
+  afterEach(function() {
+    delete require.cache[require.resolve('commander')];
+  });
+
+  describe('Backup command-line', function() {
+    it('respects the COUCH_URL env variable if the --url backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.url, 'string');
+      assert.strictEqual(program.url, process.env.COUCH_URL);
+      done();
+    });
+
+    it('respects the COUCH_DATABASE env variable if the --db backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.db, 'string');
+      assert.strictEqual(program.db, process.env.COUCH_DATABASE);
+      done();
+    });
+
+    it('respects the COUCH_BUFFER_SIZE env variable if the --buffer-size backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.bufferSize, 'number');
+      assert.strictEqual(program.bufferSize, parseInt(process.env.COUCH_BUFFER_SIZE, 10));
+      done();
+    });
+
+    it('respects the COUCH_PARALLELISM env variable if the --parallelism backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.parallelism, 'number');
+      assert.strictEqual(program.parallelism, parseInt(process.env.COUCH_PARALLELISM, 10));
+      done();
+    });
+
+    it('respects the COUCH_REQUEST_TIMEOUT env variable if the --request-timeout backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.requestTimeout, 'number');
+      assert.strictEqual(program.requestTimeout, parseInt(process.env.COUCH_REQUEST_TIMEOUT, 10));
+      done();
+    });
+
+    it('respects the CLOUDANT_IAM_API_KEY env variable if the --iam-api-key backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.iamApiKey, 'string');
+      assert.strictEqual(program.iamApiKey, process.env.CLOUDANT_IAM_API_KEY);
+      done();
+    });
+
+    it('respects the COUCH_LOG env variable if the --log backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.log, 'string');
+      assert.strictEqual(program.log, process.env.COUCH_LOG);
+      done();
+    });
+
+    it('respects the COUCH_RESUME env variable if the --resume backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.resume, 'boolean');
+      assert.strictEqual(program.resume, true);
+      done();
+    });
+
+    it('respects the COUCH_OUTPUT env variable if the --output backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.output, 'string');
+      assert.strictEqual(program.output, process.env.COUCH_OUTPUT);
+      done();
+    });
+
+    it('respects the COUCH_MODE env variable if the --mode backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.mode, 'string');
+      assert.strictEqual(program.mode, process.env.COUCH_MODE);
+      done();
+    });
+
+    it('respects the COUCH_QUIET env variable if the --quiet backup command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.quiet, 'boolean');
+      assert.strictEqual(program.quiet, true);
+      done();
+    });
+
+    it('respects the backup --url command-line parameter', function(done) {
+      const url = 'http://user:pass@myurl2.com';
+      process.argv = ['node', 'test', '--url', url];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.url, 'string');
+      assert.strictEqual(program.url, url);
+      done();
+    });
+
+    it('respects the backup --db command-line parameter', function(done) {
+      const db = 'mydb2';
+      process.argv = ['node', 'test', '--db', db];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.db, 'string');
+      assert.strictEqual(program.db, db);
+      done();
+    });
+
+    it('respects the backup --buffer-size command-line parameter', function(done) {
+      const bufferSize = 500;
+      process.argv = ['node', 'test', '--buffer-size', bufferSize];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.bufferSize, 'number');
+      assert.strictEqual(program.bufferSize, bufferSize);
+      done();
+    });
+
+    it('respects the backup --parallelism command-line parameter', function(done) {
+      const parallelism = 10;
+      process.argv = ['node', 'test', '--parallelism', parallelism];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.parallelism, 'number');
+      assert.strictEqual(program.parallelism, parallelism);
+      done();
+    });
+
+    it('respects the backup --request-timeout command-line parameter', function(done) {
+      const requestTimeout = 10000;
+      process.argv = ['node', 'test', '--request-timeout', requestTimeout];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.requestTimeout, 'number');
+      assert.strictEqual(program.requestTimeout, requestTimeout);
+      done();
+    });
+
+    it('respects the backup --iam-api-key command-line parameter', function(done) {
+      const key = '123abc-789zyx_CBA987-XYZ321';
+      process.argv = ['node', 'test', '--iam-api-key', key];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.iamApiKey, 'string');
+      assert.strictEqual(program.iamApiKey, key);
+      done();
+    });
+
+    it('respects the backup --log command-line parameter', function(done) {
+      const filename = 'my2.log';
+      process.argv = ['node', 'test', '--log', filename];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.log, 'string');
+      assert.strictEqual(program.log, filename);
+      done();
+    });
+
+    it('respects the backup --resume command-line parameter', function(done) {
+      process.argv = ['node', 'test', '--resume'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.resume, 'boolean');
+      assert.strictEqual(program.resume, true);
+      done();
+    });
+
+    it('respects the backup --output command-line parameter', function(done) {
+      const filename = 'myfile2.txt';
+      process.argv = ['node', 'test', '--output', filename];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.output, 'string');
+      assert.strictEqual(program.output, filename);
+      done();
+    });
+
+    it('respects the backup --mode full command-line parameter', function(done) {
+      process.argv = ['node', 'test', '--mode', 'full'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.mode, 'string');
+      assert.strictEqual(program.mode, 'full');
+      done();
+    });
+
+    it('respects the backup --mode shallow command-line parameter', function(done) {
+      process.argv = ['node', 'test', '--mode', 'shallow'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.mode, 'string');
+      assert.strictEqual(program.mode, 'shallow');
+      done();
+    });
+
+    it('respects the backup --quiet command-line parameter', function(done) {
+      process.argv = ['node', 'test', '--quiet'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.quiet, 'boolean');
+      assert.strictEqual(program.quiet, true);
+      done();
+    });
+  });
+
+  describe('Restore command-line', function() {
+    it('respects the COUCH_URL env variable if the --url restore command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.url, 'string');
+      assert.strictEqual(program.url, process.env.COUCH_URL);
+      done();
+    });
+
+    it('respects the COUCH_DATABASE env variable if the --db restore command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.db, 'string');
+      assert.strictEqual(program.db, process.env.COUCH_DATABASE);
+      done();
+    });
+
+    it('respects the COUCH_BUFFER_SIZE env variable if the --buffer-size restore command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.bufferSize, 'number');
+      assert.strictEqual(program.bufferSize, parseInt(process.env.COUCH_BUFFER_SIZE, 10));
+      done();
+    });
+
+    it('respects the COUCH_PARALLELISM env variable if the --parallelism restore command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.parallelism, 'number');
+      assert.strictEqual(program.parallelism, parseInt(process.env.COUCH_PARALLELISM, 10));
+      done();
+    });
+
+    it('respects the COUCH_REQUEST_TIMEOUT env variable if the --request-timeout restore command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.requestTimeout, 'number');
+      assert.strictEqual(program.requestTimeout, parseInt(process.env.COUCH_REQUEST_TIMEOUT, 10));
+      done();
+    });
+
+    it('respects the CLOUDANT_IAM_API_KEY env variable if the --iam-api-key restore command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.iamApiKey, 'string');
+      assert.strictEqual(program.iamApiKey, process.env.CLOUDANT_IAM_API_KEY);
+      done();
+    });
+
+    it('respects the COUCH_QUIET env variable if the --quiet restorer command-line parameter is missing', function(done) {
+      process.argv = ['node', 'test'];
+      const program = parser.parseBackupArgs();
+      assert.strictEqual(typeof program.quiet, 'boolean');
+      assert.strictEqual(program.quiet, true);
+      done();
+    });
+
+    it('respects the restore --url command-line parameter', function(done) {
+      const url = 'https://a:b@myurl3.com';
+      process.argv = ['node', 'test', '--url', url];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.url, 'string');
+      assert.strictEqual(program.url, url);
+      done();
+    });
+
+    it('respects the restore --db command-line parameter', function(done) {
+      const db = 'mydb3';
+      process.argv = ['node', 'test', '--db', db];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.db, 'string');
+      assert.strictEqual(program.db, db);
+      done();
+    });
+
+    it('respects the restore --buffer-size command-line parameter', function(done) {
+      const bufferSize = 250;
+      process.argv = ['node', 'test', '--buffer-size', bufferSize];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.bufferSize, 'number');
+      assert.strictEqual(program.bufferSize, bufferSize);
+      done();
+    });
+
+    it('respects the restore --parallelism command-line parameter', function(done) {
+      const parallelism = 5;
+      process.argv = ['node', 'test', '--parallelism', parallelism];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.parallelism, 'number');
+      assert.strictEqual(program.parallelism, parallelism);
+      done();
+    });
+
+    it('respects the restore --request-timeout command-line parameter', function(done) {
+      const requestTimeout = 10000;
+      process.argv = ['node', 'test', '--request-timeout', requestTimeout];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.requestTimeout, 'number');
+      assert.strictEqual(program.requestTimeout, requestTimeout);
+      done();
+    });
+
+    it('respects the restore --iam-api-key command-line parameter', function(done) {
+      const key = '123abc-789zyx_CBA987-XYZ321';
+      process.argv = ['node', 'test', '--iam-api-key', key];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.iamApiKey, 'string');
+      assert.strictEqual(program.iamApiKey, key);
+      done();
+    });
+
+    it('respects the restore --quiet command-line parameter', function(done) {
+      process.argv = ['node', 'test', '--quiet'];
+      const program = parser.parseRestoreArgs();
+      assert.strictEqual(typeof program.quiet, 'boolean');
+      assert.strictEqual(program.quiet, true);
+      done();
     });
   });
 });

package/.scannerwork/scanner-report/source-36.txt

@@ -1,4 +1,4 @@
-// Copyright © 2017, 2018 IBM Corp. All rights reserved.
+// Copyright © 2017, 2021 IBM Corp. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,36 +12,131 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-/* global describe it */
+/* global describe it before after */
 'use strict';
 
 const assert = require('assert');
-const fs = require('fs');
-const u = require('./citestutils.js');
-
-describe('Write error tests', function() {
-  it('calls callback with error set when stream is not writeable', function(done) {
-    u.setTimeout(this, 10);
-    const dirname = fs.mkdtempSync('test_backup_');
-    // make temp dir read only
-    fs.chmodSync(dirname, 0o444);
-    const filename = dirname + '/test.backup';
-    const backupStream = fs.createWriteStream(filename, { flags: 'w' });
-    const params = { useApi: true };
-    // try to do backup and check err was set in callback
-    u.testBackup(params, 'animaldb', backupStream, function(resultErr) {
-      let err = null;
-      try {
-        // cleanup temp dir
-        fs.rmdirSync(dirname);
-        // error should have been set
-        assert.ok(resultErr);
-        assert.strictEqual(resultErr.code, 'EACCES');
-      } catch (thrownErr) {
-        err = thrownErr;
-      } finally {
-        done(err);
-      }
-    });
+const applyEnvVars = require('../includes/config.js').applyEnvironmentVariables;
+
+describe('#unit Configuration', function() {
+  let processEnvCopy;
+
+  before('Save env', function() {
+    // Copy env so we can reset it after the tests
+    processEnvCopy = JSON.parse(JSON.stringify(process.env));
+  });
+
+  after('Reset env', function() {
+    process.env = processEnvCopy;
+  });
+
+  it('respects the COUCH_URL env variable', function(done) {
+    process.env.COUCH_URL = 'http://user:pass@myurl.com';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.url, 'string');
+    assert.strictEqual(config.url, process.env.COUCH_URL);
+    done();
+  });
+
+  it('respects the COUCH_DATABASE env variable', function(done) {
+    process.env.COUCH_DATABASE = 'mydb';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.db, 'string');
+    assert.strictEqual(config.db, process.env.COUCH_DATABASE);
+    done();
+  });
+
+  it('respects the COUCH_BUFFER_SIZE env variable', function(done) {
+    process.env.COUCH_BUFFER_SIZE = '1000';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.bufferSize, 'number');
+    assert.strictEqual(config.bufferSize, 1000);
+    done();
+  });
+
+  it('respects the COUCH_PARALLELISM env variable', function(done) {
+    process.env.COUCH_PARALLELISM = '20';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.parallelism, 'number');
+    assert.strictEqual(config.parallelism, 20);
+    done();
+  });
+
+  it('respects the COUCH_REQUEST_TIMEOUT env variable', function(done) {
+    process.env.COUCH_REQUEST_TIMEOUT = '10000';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.requestTimeout, 'number');
+    assert.strictEqual(config.requestTimeout, 10000);
+    done();
+  });
+
+  it('respects the CLOUDANT_IAM_API_KEY env variable', function(done) {
+    const key = 'ABC123-ZYX987_cba789-xyz321';
+    process.env.CLOUDANT_IAM_API_KEY = key;
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.iamApiKey, 'string');
+    assert.strictEqual(config.iamApiKey, key);
+    done();
+  });
+
+  it('respects the CLOUDANT_IAM_TOKEN_URL env variable', function(done) {
+    const u = 'https://testhost.example:1234/identity/token';
+    process.env.CLOUDANT_IAM_TOKEN_URL = u;
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.iamTokenUrl, 'string');
+    assert.strictEqual(config.iamTokenUrl, u);
+    done();
+  });
+
+  it('respects the COUCH_LOG env variable', function(done) {
+    process.env.COUCH_LOG = 'my.log';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.log, 'string');
+    assert.strictEqual(config.log, process.env.COUCH_LOG);
+    done();
+  });
+
+  it('respects the COUCH_RESUME env variable', function(done) {
+    process.env.COUCH_RESUME = 'true';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.resume, 'boolean');
+    assert.strictEqual(config.resume, true);
+    done();
+  });
+
+  it('respects the COUCH_OUTPUT env variable', function(done) {
+    process.env.COUCH_OUTPUT = 'myfile.txt';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.output, 'string');
+    assert.strictEqual(config.output, process.env.COUCH_OUTPUT);
+    done();
+  });
+
+  it('respects the COUCH_MODE env variable', function(done) {
+    process.env.COUCH_MODE = 'shallow';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.mode, 'string');
+    assert.strictEqual(config.mode, 'shallow');
+    done();
+  });
+
+  it('respects the COUCH_QUIET env variable', function(done) {
+    process.env.COUCH_QUIET = 'true';
+    const config = {};
+    applyEnvVars(config);
+    assert.strictEqual(typeof config.quiet, 'boolean');
+    assert.strictEqual(config.quiet, true);
+    done();
   });
 });