@cloudant/couchbackup 2.9.16 → 2.9.17-SNAPSHOT.186

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

@@ -15,23 +15,173 @@
 /* global describe it */
 'use strict';
 
-const u = require('./citestutils.js');
-
-describe('Event tests', function() {
-  it('should get a finished event when using stdout', async function() {
-    u.setTimeout(this, 40);
-    // Use the API so we can get events, pass eventEmitter so we get the emitter back
-    const params = { useApi: true, useStdOut: true };
-    // All API backups now set an event listener for finished and it is part of the backup
-    // promise, so if the backup passes the finished event fired.
-    return u.testBackup(params, 'animaldb', process.stdout);
-  });
-
-  it('should get a finished event when using file output', async function() {
-    u.setTimeout(this, 40);
-    // Use the API so we can get events, pass eventEmitter so we get the emitter back
-    const params = { useApi: true };
-    const actualBackup = `./${this.fileName}`;
-    return u.testBackupToFile(params, 'animaldb', actualBackup);
+const assert = require('assert');
+const backup = require('../app.js').backup;
+const fs = require('fs');
+const nock = require('nock');
+const util = require('util');
+const backupPromise = util.promisify(backup);
+
+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 = async function(url, opts, errorValidationForAssertRejects) {
+  const nullStream = fs.createWriteStream('/dev/null');
+  if (url === goodUrl) {
+    // Nock the goodUrl
+    nock(goodUrl).head('').reply(404, { error: 'not_found', reason: 'missing' });
+  }
+  return assert.rejects(backupPromise(url, nullStream, opts), errorValidationForAssertRejects);
+};
+
+const validateShallowModeArgs = async function(url, opts, msg) {
+  // We pass assertNoValidationError because for these shallow opts
+  // we are expecting only a stderr warning
+  return validateArgs(url, opts, assertNoValidationError()).then(() => {
+    // Assert the warning message was in stderr
+    assert(capturedStderr.indexOf(msg) > -1, 'Log warning message was not present');
+  });
+};
+
+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;
+}
+
+// Return a validation object for use with assert.rejects
+function assertErrorMessage(msg) {
+  return { name: 'InvalidOption', message: msg };
+}
+
+// For cases where validation should pass we reach a real backup that hits a 404
+// mock for a DatabaseNotFound, so that it is the expected in the case assertNoValidationError
+function assertNoValidationError() { return { name: 'DatabaseNotFound' }; }
+
+describe('#unit Validate arguments', function() {
+  it('returns error for invalid URL type', async function() {
+    return validateArgs(true, {}, assertErrorMessage('Invalid URL, must be type string'));
+  });
+  it('returns no error for valid URL type', async function() {
+    return validateArgs(goodUrl, {}, assertNoValidationError());
+  });
+  it('returns error for invalid (no host) URL', async function() {
+    return validateArgs('http://', {}, assertErrorMessage('Invalid URL'));
+  });
+  it('returns error for invalid (no protocol) URL', async function() {
+    return validateArgs('invalid', {}, assertErrorMessage('Invalid URL'));
+  });
+  it('returns error for invalid (wrong protocol) URL', async function() {
+    return validateArgs('ftp://invalid.example.com', {}, assertErrorMessage('Invalid URL protocol.'));
+  });
+  it('returns error for invalid (no path) URL', async function() {
+    return validateArgs('https://invalid.example.com', {}, assertErrorMessage('Invalid URL, missing path element (no database).'));
+  });
+  it('returns error for invalid (no protocol, no host) URL', async function() {
+    return validateArgs('invalid', {}, assertErrorMessage('Invalid URL'));
+  });
+  it('returns error for invalid buffer size type', async function() {
+    return validateArgs(goodUrl, { bufferSize: '123' }, assertErrorMessage('Invalid buffer size option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'));
+  });
+  it('returns error for zero buffer size', async function() {
+    return validateArgs(goodUrl, { bufferSize: 0 }, assertErrorMessage('Invalid buffer size option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'));
+  });
+  it('returns error for float buffer size', async function() {
+    return validateArgs(goodUrl, { bufferSize: 1.23 }, assertErrorMessage('Invalid buffer size option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'));
+  });
+  it('returns no error for valid buffer size type', async function() {
+    return validateArgs(goodUrl, { bufferSize: 123 }, assertNoValidationError());
+  });
+  it('returns error for invalid log type', async function() {
+    return validateArgs(goodUrl, { log: true }, assertErrorMessage('Invalid log option, must be type string'));
+  });
+  it('returns no error for valid log type', async function() {
+    return validateArgs(goodUrl, { log: 'log.txt' }, assertNoValidationError());
+  });
+  it('returns error for invalid mode type', async function() {
+    return validateArgs(goodUrl, { mode: true }, assertErrorMessage('Invalid mode option, must be either "full" or "shallow"'));
+  });
+  it('returns error for invalid mode string', async function() {
+    return validateArgs(goodUrl, { mode: 'foobar' }, assertErrorMessage('Invalid mode option, must be either "full" or "shallow"'));
+  });
+  it('returns no error for valid mode type', async function() {
+    return validateArgs(goodUrl, { mode: 'full' }, assertNoValidationError());
+  });
+  it('returns error for invalid output type', async function() {
+    return validateArgs(goodUrl, { output: true }, assertErrorMessage('Invalid output option, must be type string'));
+  });
+  it('returns no error for valid output type', async function() {
+    return validateArgs(goodUrl, { output: 'output.txt' }, assertNoValidationError());
+  });
+  it('returns error for invalid parallelism type', async function() {
+    return validateArgs(goodUrl, { parallelism: '123' }, assertErrorMessage('Invalid parallelism option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'));
+  });
+  it('returns error for zero parallelism', async function() {
+    return validateArgs(goodUrl, { parallelism: 0 }, assertErrorMessage('Invalid parallelism option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'));
+  });
+  it('returns error for float parallelism', async function() {
+    return validateArgs(goodUrl, { parallelism: 1.23 }, assertErrorMessage('Invalid parallelism option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'));
+  });
+  it('returns no error for valid parallelism type', async function() {
+    return validateArgs(goodUrl, { parallelism: 123 }, assertNoValidationError());
+  });
+  it('returns error for invalid request timeout type', async function() {
+    return validateArgs(goodUrl, { requestTimeout: '123' }, assertErrorMessage('Invalid request timeout option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'));
+  });
+  it('returns error for zero request timeout', async function() {
+    return validateArgs(goodUrl, { requestTimeout: 0 }, assertErrorMessage('Invalid request timeout option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'));
+  });
+  it('returns error for float request timout', async function() {
+    return validateArgs(goodUrl, { requestTimeout: 1.23 }, assertErrorMessage('Invalid request timeout option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'));
+  });
+  it('returns no error for valid request timeout type', async function() {
+    return validateArgs(goodUrl, { requestTimeout: 123 }, assertNoValidationError());
+  });
+  it('returns error for invalid resume type', async function() {
+    return validateArgs(goodUrl, { resume: 'true' }, assertErrorMessage('Invalid resume option, must be type boolean'));
+  });
+  it('returns no error for valid resume type', async function() {
+    return validateArgs(goodUrl, { resume: false }, assertNoValidationError());
+  });
+  it('returns error for invalid key type', async function() {
+    return validateArgs(goodUrl, { iamApiKey: true }, assertErrorMessage('Invalid iamApiKey option, must be type string'));
+  });
+  it('returns error for key and URL credentials supplied', async function() {
+    return validateArgs('https://a:b@example.com/db', { iamApiKey: 'abc123' }, assertErrorMessage('URL user information must not be supplied when using IAM API key.'));
+  });
+  it('warns for log arg in shallow mode', async function() {
+    captureStderr();
+    return validateShallowModeArgs(goodUrl, { mode: 'shallow', log: 'test' },
+      'the options "log" and "resume" are invalid when using shallow mode.').finally(
+      () => {
+        releaseStderr();
+      });
+  });
+  it('warns for resume arg in shallow mode', async function() {
+    captureStderr();
+    return validateShallowModeArgs(goodUrl, { mode: 'shallow', log: 'test', resume: true },
+      'the options "log" and "resume" are invalid when using shallow mode.').finally(
+      () => {
+        releaseStderr();
+      });
+  });
+  it('warns for parallelism arg in shallow mode', async function() {
+    captureStderr();
+    return validateShallowModeArgs(goodUrl, { mode: 'shallow', parallelism: 10 },
+      'the option "parallelism" has no effect when using shallow mode.').finally(
+      () => {
+        releaseStderr();
+      });
   });
 });

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

@@ -16,27 +16,176 @@
 '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', async function() {
-    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
-    return u.testBackup(params, 'animaldb', backupStream).then(() => {
-      assert.fail('Should throw an "EACCES" error');
-    }).catch((resultErr) => {
-      // cleanup temp dir
-      fs.rmdirSync(dirname);
-      // error should have been set
-      assert.ok(resultErr);
-      assert.strictEqual(resultErr.code, 'EACCES');
+const nock = require('nock');
+const request = require('../includes/request.js');
+const changes = require('../includes/spoolchanges.js');
+
+const url = 'http://localhost:7777';
+const dbName = 'fakenockdb';
+const longTestTimeout = 3000;
+
+const db = request.client(`${url}/${dbName}`, { parallelism: 1 });
+
+const seqSuffix = Buffer.alloc(124, 'abc123').toString('base64');
+function provideChanges(batchSize, totalChanges, fullResponse = false) {
+  let pending = totalChanges;
+  const sparseResultsArray = Array(batchSize).fill({
+    seq: null,
+    id: 'doc',
+    changes: [{ rev: '1-abcdef0123456789abcdef0123456789' }]
+  });
+  nock(url)
+    .post(`/${dbName}/_changes`)
+    .query(true)
+    .times(totalChanges / batchSize + (totalChanges % batchSize > 0 ? 1 : 0))
+    .reply(200, (uri, requestBody) => {
+      pending -= batchSize;
+      const lastSeq = (totalChanges - pending);
+      const seq = lastSeq - batchSize;
+      return {
+        results: fullResponse
+          ? Array.from(Array(batchSize), (_, i) => {
+            return {
+              seq: `${seq + i}-${seqSuffix}`,
+              id: `doc${seq + i}`,
+              changes: [{ rev: '1-abcdef0123456789abcdef0123456789' }]
+            };
+          })
+          : sparseResultsArray,
+        pending: pending,
+        last_seq: `${lastSeq}-abc`
+      };
+    });
+}
+
+describe('#unit Check spool changes', function() {
+  it('should terminate on request error', async function() {
+    nock(url)
+      .post(`/${dbName}/_changes`)
+      .query(true)
+      .times(3)
+      .replyWithError({ code: 'ECONNRESET', message: 'socket hang up' });
+
+    return new Promise((resolve, reject) => {
+      changes(db, '/dev/null', 500, null, function(err) {
+        try {
+          assert.strictEqual(err.name, 'SpoolChangesError');
+          assert.strictEqual(err.message, `Failed changes request - socket hang up: post ${url}/${dbName}/_changes`);
+          assert.ok(nock.isDone());
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  }).timeout(longTestTimeout);
+
+  it('should terminate on bad HTTP status code response', async function() {
+    nock(url)
+      .post(`/${dbName}/_changes`)
+      .query(true)
+      .times(3)
+      .reply(500, function(uri, requestBody) {
+        this.req.response.statusMessage = 'Internal Server Error';
+        return { error: 'foo', reason: 'bar' };
+      });
+    return new Promise((resolve, reject) => {
+      changes(db, '/dev/null', 500, null, function(err) {
+        try {
+          assert.strictEqual(err.name, 'HTTPFatalError');
+          assert.strictEqual(err.message, `500 Internal Server Error: post ${url}/${dbName}/_changes - Error: foo, Reason: bar`);
+          assert.ok(nock.isDone());
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  }).timeout(longTestTimeout);
+
+  it('should keep collecting changes', async function() {
+    // This test validates that spooling will correctly
+    // continue across multiple requests
+    // (4 batches of 100000 to be precise).
+    // This test might take up to 10 seconds
+    this.timeout(10 * 1000);
+
+    // Use full changes for this test
+    provideChanges(100000, 400000, true);
+    return new Promise((resolve, reject) => {
+      changes(db, '/dev/null', 500, null, function(err) {
+        try {
+          assert.ok(!err);
+          assert.ok(nock.isDone());
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  });
+
+  it('should keep collecting sparse changes', async function() {
+    // This test checks that making thousands of requests doesn't
+    // make anything bad happen.
+    // This test might take up to 25 seconds
+    this.timeout(25 * 1000);
+    // Use sparse changes for this test and a batch size of 1
+    provideChanges(1, 2500);
+    return new Promise((resolve, reject) => {
+      changes(db, '/dev/null', 500, null, function(err) {
+        try {
+          assert.ok(!err);
+          assert.ok(nock.isDone());
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  });
+});
+
+describe('Longer spool changes checks', function() {
+  it('#slow should keep collecting changes (25M)', async function() {
+    // This test might take up to 5 minutes
+    this.timeout(5 * 60 * 1000);
+    // Note changes spooling uses a constant batch size, we are setting
+    // a test value here and setting the buffer to match
+    const batch = 100000;
+    // Use sparse changes for this test
+    provideChanges(batch, 25000000);
+    return new Promise((resolve, reject) => {
+      changes(db, '/dev/null', batch, null, function(err) {
+        try {
+          assert.ok(!err);
+          assert.ok(nock.isDone());
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  });
+
+  it('#slower should keep collecting changes (500M)', async function() {
+    // This test might take up to 90 minutes
+    this.timeout(90 * 60 * 1000);
+    // Note changes spooling uses a constant batch size, we are setting
+    // a test value here and setting the buffer to match
+    const batch = 1000000;
+    // Use full changes for this test to exercise load
+    provideChanges(batch, 500000000, true);
+    return new Promise((resolve, reject) => {
+      changes(db, '/dev/null', batch, null, function(err) {
+        try {
+          assert.ok(!err);
+          assert.ok(nock.isDone());
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
     });
   });
 });