@cloudant/couchbackup 2.9.10 → 2.9.11-SNAPSHOT.115

package/.scannerwork/scanner-report/source-34.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,214 +12,136 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-/* global describe it */
+/* global describe it beforeEach */
 'use strict';
 
 const assert = require('assert');
-const backup = require('../app.js').backup;
 const fs = require('fs');
 const nock = require('nock');
+const request = require('../includes/request.js');
+const writer = require('../includes/writer.js');
+const noopEmitter = new (require('events')).EventEmitter();
+const liner = require('../includes/liner.js');
 
-const goodUrl = 'http://localhost:5984/db';
-// The real validateArgs function of app.js isn't
-// exported - so we call the exported backup method
-// instead. We don't get as far as a real backup when
-// testing error cases. For success cases we nock the
-// goodUrl and
-const validateArgs = function(url, opts, callback) {
-  const nullStream = fs.createWriteStream('/dev/null');
-  let cb = callback;
-  if (url === goodUrl) {
-    // Nock the goodUrl
-    nock(goodUrl).head('').reply(404, { error: 'not_found', reason: 'missing' });
-    // replace the callback to handle the nock response
-    // to avoid attempting a real backup
-    cb = function(err) {
-      nullStream.end();
-      if (err.name === 'DatabaseNotFound') {
-        // This is what we expect if we reached the backup
-        // This is success for valid args cases.
-        err = null;
-      }
-      callback(err);
-    };
-  }
-  backup(url, nullStream, opts, cb);
-  return true;
-};
-
-const stderrWriteFun = process.stderr.write;
-let capturedStderr;
-
-function captureStderr() {
-  process.stderr.write = function(string, encoding, fd) {
-    capturedStderr += string;
-  };
-}
-
-function releaseStderr() {
-  process.stderr.write = stderrWriteFun;
-  capturedStderr = null;
-}
+const longTestTimeout = 3000;
 
-function assertErrorMessage(msg, done) {
-  return function(err, data) {
-    try {
-      assert(err.message, 'There should be an error message');
-      assert(err.message.indexOf(msg) >= 0);
-      assert(data === null || data === undefined, 'There should only be an error.');
-      done();
-    } catch (e) {
-      done(e);
-    }
-  };
+// The writer expects a line-by-line stream so this utility function does that
+// processing for the tests (which normally happens in the internal restore
+// function).
+function testLinestream(fixture = './test/fixtures/animaldb_expected.json') {
+  return fs.createReadStream(fixture)
+    .pipe(liner());
 }
 
-function assertNoError(done) {
-  return function(err, data) {
-    try {
-      assert(err === null, 'There should be no error message.');
-      done();
-    } catch (e) {
-      done(e);
-    }
-  };
-}
+describe('#unit Check database restore writer', function() {
+  const dbUrl = 'http://localhost:5984/animaldb';
+  const db = request.client(dbUrl, { parallelism: 1 });
 
-describe('#unit Validate arguments', function() {
-  it('returns error for invalid URL type', function(done) {
-    validateArgs(true, {}, assertErrorMessage('Invalid URL, must be type string', done));
-  });
-  it('returns no error for valid URL type', function(done) {
-    validateArgs(goodUrl, {}, assertNoError(done));
-  });
-  it('returns error for invalid (no host) URL', function(done) {
-    validateArgs('http://', {}, assertErrorMessage('Invalid URL', done));
-  });
-  it('returns error for invalid (no protocol) URL', function(done) {
-    validateArgs('invalid', {}, assertErrorMessage('Invalid URL', done));
-  });
-  it('returns error for invalid (wrong protocol) URL', function(done) {
-    validateArgs('ftp://invalid.example.com', {}, assertErrorMessage('Invalid URL protocol.', done));
-  });
-  it('returns error for invalid (no path) URL', function(done) {
-    validateArgs('https://invalid.example.com', {}, assertErrorMessage('Invalid URL, missing path element (no database).', done));
-  });
-  it('returns error for invalid (no protocol, no host) URL', function(done) {
-    validateArgs('invalid', {}, assertErrorMessage('Invalid URL', done));
-  });
-  it('returns error for invalid buffer size type', function(done) {
-    validateArgs(goodUrl, { bufferSize: '123' }, assertErrorMessage('Invalid buffer size option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]', done));
-  });
-  it('returns error for zero buffer size', function(done) {
-    validateArgs(goodUrl, { bufferSize: 0 }, assertErrorMessage('Invalid buffer size option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]', done));
-  });
-  it('returns error for float buffer size', function(done) {
-    validateArgs(goodUrl, { bufferSize: 1.23 }, assertErrorMessage('Invalid buffer size option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]', done));
-  });
-  it('returns no error for valid buffer size type', function(done) {
-    validateArgs(goodUrl, { bufferSize: 123 }, assertNoError(done));
-  });
-  it('returns error for invalid log type', function(done) {
-    validateArgs(goodUrl, { log: true }, assertErrorMessage('Invalid log option, must be type string', done));
-  });
-  it('returns no error for valid log type', function(done) {
-    validateArgs(goodUrl, { log: 'log.txt' }, assertNoError(done));
-  });
-  it('returns error for invalid mode type', function(done) {
-    validateArgs(goodUrl, { mode: true }, assertErrorMessage('Invalid mode option, must be either "full" or "shallow"', done));
-  });
-  it('returns error for invalid mode string', function(done) {
-    validateArgs(goodUrl, { mode: 'foobar' }, assertErrorMessage('Invalid mode option, must be either "full" or "shallow"', done));
-  });
-  it('returns no error for valid mode type', function(done) {
-    validateArgs(goodUrl, { mode: 'full' }, assertNoError(done));
-  });
-  it('returns error for invalid output type', function(done) {
-    validateArgs(goodUrl, { output: true }, assertErrorMessage('Invalid output option, must be type string', done));
-  });
-  it('returns no error for valid output type', function(done) {
-    validateArgs(goodUrl, { output: 'output.txt' }, assertNoError(done));
-  });
-  it('returns error for invalid parallelism type', function(done) {
-    validateArgs(goodUrl, { parallelism: '123' }, assertErrorMessage('Invalid parallelism option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]', done));
-  });
-  it('returns error for zero parallelism', function(done) {
-    validateArgs(goodUrl, { parallelism: 0 }, assertErrorMessage('Invalid parallelism option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]', done));
-  });
-  it('returns error for float parallelism', function(done) {
-    validateArgs(goodUrl, { parallelism: 1.23 }, assertErrorMessage('Invalid parallelism option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]', done));
+  beforeEach('Reset nocks', function() {
+    nock.cleanAll();
   });
-  it('returns no error for valid parallelism type', function(done) {
-    validateArgs(goodUrl, { parallelism: 123 }, assertNoError(done));
-  });
-  it('returns error for invalid request timeout type', function(done) {
-    validateArgs(goodUrl, { requestTimeout: '123' }, assertErrorMessage('Invalid request timeout option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]', done));
-  });
-  it('returns error for zero request timeout', function(done) {
-    validateArgs(goodUrl, { requestTimeout: 0 }, assertErrorMessage('Invalid request timeout option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]', done));
-  });
-  it('returns error for float request timout', function(done) {
-    validateArgs(goodUrl, { requestTimeout: 1.23 }, assertErrorMessage('Invalid request timeout option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]', done));
-  });
-  it('returns no error for valid request timeout type', function(done) {
-    validateArgs(goodUrl, { requestTimeout: 123 }, assertNoError(done));
-  });
-  it('returns error for invalid resume type', function(done) {
-    validateArgs(goodUrl, { resume: 'true' }, assertErrorMessage('Invalid resume option, must be type boolean', done));
-  });
-  it('returns no error for valid resume type', function(done) {
-    validateArgs(goodUrl, { resume: false }, assertNoError(done));
-  });
-  it('returns error for invalid key type', function(done) {
-    validateArgs(goodUrl, { iamApiKey: true }, assertErrorMessage('Invalid iamApiKey option, must be type string', done));
-  });
-  it('returns error for key and URL credentials supplied', function(done) {
-    validateArgs('https://a:b@example.com/db', { iamApiKey: 'abc123' }, assertErrorMessage('URL user information must not be supplied when using IAM API key.', done));
+
+  it('should complete successfully', function(done) {
+    nock(dbUrl)
+      .post('/_bulk_docs')
+      .reply(200, []); // success
+
+    testLinestream()
+      .pipe(writer(db, 500, 1, noopEmitter))
+      .on('error', function(err) {
+        done(err);
+      })
+      .on('finished', function(data) {
+        assert.strictEqual(data.total, 15);
+        assert.ok(nock.isDone());
+        done();
+      });
   });
-  it('warns for log arg in shallow mode', function(done) {
-    captureStderr();
-    try {
-      validateArgs(goodUrl, { mode: 'shallow', log: 'test' }, function(err, data) {
-        assert.ok(err);
-        assert.ok(!data);
-        assert(capturedStderr.indexOf('The options "log" and "resume" are invalid when using shallow mode.') > -1, 'Log warning message was not present');
+
+  it('should terminate on a fatal error', function(done) {
+    nock(dbUrl)
+      .post('/_bulk_docs')
+      .reply(401, { error: 'Unauthorized' }); // fatal error
+
+    testLinestream()
+      .pipe(writer(db, 500, 1, noopEmitter))
+      .on('error', function(err) {
+        assert.strictEqual(err.name, 'Unauthorized');
+        assert.strictEqual(err.message, 'Access is denied due to invalid credentials.');
+        assert.ok(nock.isDone());
+        done();
       });
-      done();
-    } catch (e) {
-      done(e);
-    } finally {
-      releaseStderr();
-    }
   });
-  it('warns for resume arg in shallow mode', function(done) {
-    captureStderr();
-    try {
-      validateArgs(goodUrl, { mode: 'shallow', log: 'test', resume: true }, function(err, data) {
-        assert.ok(err);
-        assert.ok(!data);
-        assert(capturedStderr.indexOf('The options "log" and "resume" are invalid when using shallow mode.') > -1, 'Log warning message was not present');
+
+  it('should retry on transient errors', function(done) {
+    nock(dbUrl)
+      .post('/_bulk_docs')
+      .reply(429, { error: 'Too Many Requests' }) // transient error
+      .post('/_bulk_docs')
+      .reply(500, { error: 'Internal Server Error' }) // transient error
+      .post('/_bulk_docs')
+      .reply(200, { ok: true }); // third time lucky success
+
+    testLinestream()
+      .pipe(writer(db, 500, 1, noopEmitter))
+      .on('error', function(err) {
+        done(err);
+      })
+      .on('finished', function(data) {
+        assert.strictEqual(data.total, 15);
+        assert.ok(nock.isDone());
+        done();
+      });
+  }).timeout(longTestTimeout);
+
+  it('should fail after 3 transient errors', function(done) {
+    nock(dbUrl)
+      .post('/_bulk_docs')
+      .reply(429, { error: 'Too Many Requests' }) // transient error
+      .post('/_bulk_docs')
+      .reply(500, { error: 'Internal Server Error' }) // transient error
+      .post('/_bulk_docs')
+      .reply(503, { error: 'Service Unavailable' }); // Final transient error
+
+    testLinestream()
+      .pipe(writer(db, 500, 1, noopEmitter))
+      .on('error', function(err) {
+        assert.strictEqual(err.name, 'HTTPFatalError');
+        assert.strictEqual(err.message, `503 : post ${dbUrl}/_bulk_docs - Error: Service Unavailable`);
+        assert.ok(nock.isDone());
+        done();
+      });
+  }).timeout(longTestTimeout);
+
+  it('should restore shallow backups without rev info successfully', function(done) {
+    nock(dbUrl)
+      .post('/_bulk_docs')
+      .reply(200, [{ ok: true, id: 'foo', rev: '1-abc' }]); // success
+
+    testLinestream('./test/fixtures/animaldb_old_shallow.json')
+      .pipe(writer(db, 500, 1, noopEmitter))
+      .on('error', function(err) {
+        done(err);
+      })
+      .on('finished', function(data) {
+        assert.strictEqual(data.total, 11);
+        assert.ok(nock.isDone());
+        done();
       });
-      done();
-    } catch (e) {
-      done(e);
-    } finally {
-      releaseStderr();
-    }
   });
-  it('warns for parallism arg in shallow mode', function(done) {
-    captureStderr();
-    try {
-      validateArgs(goodUrl, { mode: 'shallow', parallelsim: 10 }, function(err, data) {
-        assert.ok(err);
-        assert.ok(!data);
-        assert(capturedStderr.indexOf('The option "parallelism" has no effect when using shallow mode.') > -1, 'Log warning message was not present');
+
+  it('should get a batch error for non-empty array response with new_edits false', function(done) {
+    nock(dbUrl)
+      .post('/_bulk_docs')
+      .reply(200, [{ id: 'foo', error: 'foo', reason: 'bar' }]);
+
+    testLinestream()
+      .pipe(writer(db, 500, 1, noopEmitter))
+      .on('error', function(err) {
+        assert.strictEqual(err.name, 'Error');
+        assert.strictEqual(err.message, 'Error writing batch with new_edits:false and 1 items');
+        assert.ok(nock.isDone());
+        done();
       });
-      done();
-    } catch (e) {
-      done(e);
-    } finally {
-      releaseStderr();
-    }
   });
 });

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

@@ -1,4 +1,5 @@
-// Copyright © 2017, 2018 IBM Corp. All rights reserved.
+#!/usr/bin/env node
+// 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.
@@ -11,37 +12,66 @@
 // 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 error = require('../includes/error.js');
 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 cliutils = require('../includes/cliutils.js');
+const couchbackup = require('../app.js');
+const parser = require('../includes/parser.js');
+const debug = require('debug');
+const backupDebug = debug('couchbackup:backup');
+const backupBatchDebug = debug('couchbackup:backup:batch');
+
+backupDebug.enabled = true;
+
+const program = parser.parseBackupArgs();
+
+const databaseUrl = cliutils.databaseUrl(program.url, program.db);
+const opts = {
+  bufferSize: program.bufferSize,
+  log: program.log,
+  mode: program.mode,
+  parallelism: program.parallelism,
+  requestTimeout: program.requestTimeout,
+  resume: program.resume,
+  iamApiKey: program.iamApiKey,
+  iamTokenUrl: program.iamTokenUrl
+};
+
+// log configuration to console
+console.error('='.repeat(80));
+console.error('Performing backup on ' + databaseUrl.replace(/\/\/.+@/g, '//****:****@') + ' using configuration:');
+console.error(JSON.stringify(opts, null, 2).replace(/"iamApiKey": "[^"]+"/, '"iamApiKey": "****"'));
+console.error('='.repeat(80));
+
+backupBatchDebug.enabled = !program.quiet;
+
+let ws = process.stdout;
+
+// open output file
+if (program.output) {
+  let flags = 'w';
+  if (program.log && program.resume) {
+    flags = 'a';
+  }
+  const fd = fs.openSync(program.output, flags);
+  ws = fs.createWriteStream(null, { fd: fd });
+}
+
+backupDebug('Fetching all database changes...');
+
+return couchbackup.backup(
+  databaseUrl,
+  ws,
+  opts,
+  error.terminationCallback
+).on('changes', function(batch) {
+  backupBatchDebug('Total batches received:', batch + 1);
+}).on('written', function(obj) {
+  backupBatchDebug('Written batch ID:', obj.batch, 'Total document revisions written:', obj.total, 'Time:', obj.time);
+}).on('error', function(e) {
+  backupDebug('ERROR', e);
+}).on('finished', function(obj) {
+  backupDebug('Finished - Total document revisions written:', obj.total);
 });