@cloudant/couchbackup 2.9.9 → 2.9.10-SNAPSHOT.105

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

@@ -11,168 +11,356 @@
 // 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 afterEach before after it */
 'use strict';
 
-const pkg = require('../package.json');
-const stream = require('stream');
-const { CloudantV1, CouchdbSessionAuthenticator } = require('@ibm-cloud/cloudant');
-const { IamAuthenticator, NoAuthAuthenticator } = require('ibm-cloud-sdk-core');
-const retryPlugin = require('retry-axios');
-
-const userAgent = 'couchbackup-cloudant/' + pkg.version + ' (Node.js ' +
-      process.version + ')';
-
-// Class for streaming _changes error responses into
-// In general the response is a small error/reason JSON object
-// so it is OK to have this in memory.
-class ResponseWriteable extends stream.Writable {
-  constructor(options) {
-    super(options);
-    this.data = [];
-  }
-
-  _write(chunk, encoding, callback) {
-    this.data.push(chunk);
-    callback();
-  }
-
-  stringBody() {
-    return Buffer.concat(this.data).toString();
-  }
-}
-
-// An interceptor function to help augment error bodies with a little
-// extra information so we can continue to use consistent messaging
-// after the ugprade to @ibm-cloud/cloudant
-const errorHelper = async function(err) {
-  let method;
-  let requestUrl;
-  if (err.response) {
-    if (err.response.config.url) {
-      requestUrl = err.response.config.url;
-      method = err.response.config.method;
-    }
-    // Override the status text with an improved message
-    let errorMsg = `${err.response.status} ${err.response.statusText || ''}: ` +
-    `${method} ${requestUrl}`;
-    if (err.response.data) {
-      // Check if we have a JSON response and try to get the error/reason
-      if (err.response.headers['content-type'] === 'application/json') {
-        if (!err.response.data.error && err.response.data.pipe) {
-          // If we didn't find a JSON object with `error` then we might have a stream response.
-          // Detect the stream by the presence of `pipe` and use it to get the body and parse
-          // the error information.
-          const p = new Promise((resolve, reject) => {
-            const errorBody = new ResponseWriteable();
-            err.response.data.pipe(errorBody)
-              .on('finish', () => { resolve(JSON.parse(errorBody.stringBody())); })
-              .on('error', () => { reject(err); });
-          });
-          // Replace the stream on the response with the parsed object
-          err.response.data = await p;
-        }
-        // Append the error/reason if available
-        if (err.response.data.error) {
-          // Override the status text with our more complete message
-          errorMsg += ` - Error: ${err.response.data.error}`;
-          if (err.response.data.reason) {
-            errorMsg += `, Reason: ${err.response.data.reason}`;
-          }
-        }
-      } else {
-        errorMsg += err.response.data;
-      }
-      // Set a new message for use by the node-sdk-core
-      // We use the errors array because it gets processed
-      // ahead of all other service errors.
-      err.response.data.errors = [{ message: errorMsg }];
-    }
-  } else if (err.request) {
-    if (!err.message.includes(err.config.url)) {
-      // Augment the message with the URL and method
-      // but don't do it again if we already have the URL.
-      err.message = `${err.message}: ${err.config.method} ${err.config.url}`;
-    }
-  }
-  return Promise.reject(err);
-};
-
-module.exports = {
-  client: function(rawUrl, opts) {
-    const url = new URL(rawUrl);
-    // Split the URL to separate service from database
-    // Use origin as the "base" to remove auth elements
-    const actUrl = new URL(url.pathname.substring(0, url.pathname.lastIndexOf('/')), url.origin);
-    const dbName = url.pathname.substring(url.pathname.lastIndexOf('/') + 1);
-    let authenticator;
-    // Default to cookieauth unless an IAM key is provided
-    if (opts.iamApiKey) {
-      const iamAuthOpts = { apikey: opts.iamApiKey };
-      if (opts.iamTokenUrl) {
-        iamAuthOpts.url = opts.iamTokenUrl;
-      }
-      authenticator = new IamAuthenticator(iamAuthOpts);
-    } else if (url.username) {
-      authenticator = new CouchdbSessionAuthenticator({
-        username: decodeURIComponent(url.username),
-        password: decodeURIComponent(url.password)
-      });
-    } else {
-      authenticator = new NoAuthAuthenticator();
-    }
-    const serviceOpts = {
-      authenticator: authenticator,
-      timeout: opts.requestTimeout,
-      // Axios performance options
-      maxContentLength: -1
-    };
-
-    const service = new CloudantV1(serviceOpts);
-    // Configure retries
-    const maxRetries = 2; // for 3 total attempts
-    service.getHttpClient().defaults.raxConfig = {
-      // retries for status codes
-      retry: maxRetries,
-      // retries for non-response e.g. ETIMEDOUT
-      noResponseRetries: maxRetries,
-      backoffType: 'exponential',
-      httpMethodsToRetry: ['GET', 'HEAD', 'POST'],
-      statusCodesToRetry: [
-        [429, 429],
-        [500, 599]
-      ],
-      shouldRetry: err => {
-        const cfg = retryPlugin.getConfig(err);
-        // cap at max retries regardless of response/non-response type
-        if (cfg.currentRetryAttempt >= maxRetries) {
-          return false;
-        } else {
-          return retryPlugin.shouldRetryRequest(err);
-        }
-      },
-      instance: service.getHttpClient()
-    };
-    retryPlugin.attach(service.getHttpClient());
-
-    service.setServiceUrl(actUrl.toString());
-    if (authenticator instanceof CouchdbSessionAuthenticator) {
-      // Awkward workaround for known Couch issue with compression on _session requests
-      // It is not feasible to disable compression on all requests with the amount of
-      // data this lib needs to move, so override the property in the tokenManager instance.
-      authenticator.tokenManager.requestWrapperInstance.compressRequestData = false;
-    }
-    if (authenticator.tokenManager && authenticator.tokenManager.requestWrapperInstance) {
-      authenticator.tokenManager.requestWrapperInstance.axiosInstance.interceptors.response.use(null, errorHelper);
-    }
-    // Add error interceptors to put URLs in error messages
-    service.getHttpClient().interceptors.response.use(null, errorHelper);
-
-    // Add request interceptor to add user-agent (adding it with custom request headers gets overwritten)
-    service.getHttpClient().interceptors.request.use(function(requestConfig) {
-      requestConfig.headers['User-Agent'] = userAgent;
-      return requestConfig;
-    }, null);
-
-    return { service: service, db: dbName, url: actUrl.toString() };
-  }
-};
+const assert = require('assert');
+const parser = require('../includes/parser.js');
+
+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();
+    });
+  });
+});