@cloudant/couchbackup 2.9.10-SNAPSHOT.113 → 2.9.10

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

@@ -0,0 +1,225 @@
+// Copyright © 2017, 2018 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 backup = require('../app.js').backup;
+const fs = require('fs');
+const nock = require('nock');
+
+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;
+}
+
+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);
+    }
+  };
+}
+
+function assertNoError(done) {
+  return function(err, data) {
+    try {
+      assert(err === null, 'There should be no error message.');
+      done();
+    } catch (e) {
+      done(e);
+    }
+  };
+}
+
+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));
+  });
+  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('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');
+      });
+      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');
+      });
+      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');
+      });
+      done();
+    } catch (e) {
+      done(e);
+    } finally {
+      releaseStderr();
+    }
+  });
+});

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

@@ -0,0 +1,47 @@
+// Copyright © 2017, 2018 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');
+
+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);
+      }
+    });
+  });
+});

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

@@ -0,0 +1,92 @@
+// 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.
+'use strict';
+
+const fs = require('fs');
+const stream = require('stream');
+const liner = require('./liner.js');
+
+const onLine = function(onCommand, getDocs) {
+  const change = new stream.Transform({ objectMode: true });
+
+  change._transform = function(line, encoding, done) {
+    if (line && line[0] === ':') {
+      const obj = {
+        command: null,
+        batch: null,
+        docs: []
+      };
+
+      let matches;
+
+      // extract command
+      matches = line.match(/^:([a-z_]+) ?/);
+      if (matches) {
+        obj.command = matches[1];
+      }
+
+      // extract batch
+      matches = line.match(/ batch([0-9]+)/);
+      if (matches) {
+        obj.batch = parseInt(matches[1]);
+      }
+
+      // extract doc ids
+      if (getDocs && obj.command === 't') {
+        const json = line.replace(/^.* batch[0-9]+ /, '').trim();
+        obj.docs = JSON.parse(json);
+      }
+      onCommand(obj);
+    }
+    done();
+  };
+  return change;
+};
+
+/**
+ * Generate a list of remaining batches from a download file.
+ *
+ * @param {string} log - log file name
+ * @param {function} callback - callback with err, {changesComplete: N, batches: N}.
+ *  changesComplete signifies whether the log file appeared to
+ *  have completed reading the changes feed (contains :changes_complete).
+ *  batches are remaining batch IDs for download.
+ */
+module.exports = function(log, callback) {
+  // our sense of state
+  const state = {
+
+  };
+  let changesComplete = false;
+
+  // called with each line from the log file
+  const onCommand = function(obj) {
+    if (obj.command === 't') {
+      state[obj.batch] = true;
+    } else if (obj.command === 'd') {
+      delete state[obj.batch];
+    } else if (obj.command === 'changes_complete') {
+      changesComplete = true;
+    }
+  };
+
+  // stream through the previous log file
+  fs.createReadStream(log)
+    .pipe(liner())
+    .pipe(onLine(onCommand, false))
+    .on('finish', function() {
+      const obj = { changesComplete: changesComplete, batches: state };
+      callback(null, obj);
+    });
+};

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

@@ -15,22 +15,49 @@
 /* global describe it */
 'use strict';
 
+const fs = require('fs');
 const u = require('./citestutils.js');
 
-describe('Encryption tests', function() {
-  // Note CLI only to use openssl command
-  const p = { useApi: false, encryption: true };
-
-  it('should backup and restore animaldb via an encrypted file', function(done) {
-    // Allow up to 60 s for backup and restore of animaldb
-    u.setTimeout(this, 60);
-    const encryptedBackup = `./${this.fileName}`;
-    u.testBackupAndRestoreViaFile(p, 'animaldb', encryptedBackup, this.dbName, function(err) {
+describe('Event tests', function() {
+  it('should get a finished event when using stdout', function(done) {
+    u.setTimeout(this, 40);
+    // Use the API so we can get events
+    const params = { useApi: true };
+    const backup = u.testBackup(params, 'animaldb', process.stdout, function(err) {
       if (err) {
         done(err);
-      } else {
-        u.assertEncryptedFile(encryptedBackup, done);
       }
     });
+    backup.on('finished', function() {
+      try {
+        // Test will time out if the finished event is not emitted
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+  it('should get a finished event when using file output', function(done) {
+    u.setTimeout(this, 40);
+    // Use the API so we can get events
+    const params = { useApi: true };
+    const actualBackup = `./${this.fileName}`;
+    // Create a file and backup to it
+    const output = fs.createWriteStream(actualBackup);
+    output.on('open', function() {
+      const backup = u.testBackup(params, 'animaldb', output, function(err) {
+        if (err) {
+          done(err);
+        }
+      });
+      backup.on('finished', function() {
+        try {
+          // Test will time out if the finished event is not emitted
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
   });
 });

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

@@ -12,145 +12,57 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-/* global describe it */
+/* global beforeEach afterEach */
 'use strict';
 
-const assert = require('assert');
-const nock = require('nock');
-const request = require('../includes/request.js');
-const changes = require('../includes/spoolchanges.js');
+const { CloudantV1 } = require('@ibm-cloud/cloudant');
+const url = new URL((process.env.COUCH_BACKEND_URL) ? process.env.COUCH_BACKEND_URL : 'https://no-couch-backend-url-set.test');
+const { BasicAuthenticator, NoAuthAuthenticator } = require('ibm-cloud-sdk-core');
+const authenticator = (url.username) ? new BasicAuthenticator({ username: url.username, password: decodeURIComponent(url.password) }) : new NoAuthAuthenticator();
+const serviceOpts = {
+  authenticator: authenticator
+};
+const cloudant = new CloudantV1(serviceOpts);
+// Remove auth from URL before using for service
+cloudant.setServiceUrl(new URL(url.pathname, url.origin).toString());
+const uuid = require('uuid').v4;
+const fs = require('fs');
 
-const url = 'http://localhost:7777';
-const dbName = 'fakenockdb';
-const longTestTimeout = 3000;
+// Mocha hooks that will be at the root context so run for all tests
 
-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', function(done) {
-    nock(url)
-      .post(`/${dbName}/_changes`)
-      .query(true)
-      .times(3)
-      .replyWithError({ code: 'ECONNRESET', message: 'socket hang up' });
-
-    changes(db, '/dev/null', 500, null, function(err) {
-      assert.strictEqual(err.name, 'SpoolChangesError');
-      assert.strictEqual(err.message, `Failed changes request - socket hang up: post ${url}/${dbName}/_changes`);
-      assert.ok(nock.isDone());
-      done();
-    });
-  }).timeout(longTestTimeout);
-
-  it('should terminate on bad HTTP status code response', function(done) {
-    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' };
-      });
-
-    changes(db, '/dev/null', 500, null, function(err) {
-      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());
-      done();
-    });
-  }).timeout(longTestTimeout);
-
-  it('should keep collecting changes', function(done) {
-    // 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
+beforeEach('Create test database', function(done) {
+  // Don't run hook for unit tests, just for CI
+  if (!this.currentTest.fullTitle().includes('#unit')) {
+    // Allow 10 seconds to create the DB
     this.timeout(10 * 1000);
-
-    // Use full changes for this test
-    provideChanges(100000, 400000, true);
-    changes(db, '/dev/null', 500, null, function(err) {
-      assert.ok(!err);
-      assert.ok(nock.isDone());
-      done();
-    });
-  });
-
-  it('should keep collecting sparse changes', function(done) {
-    // 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);
-    changes(db, '/dev/null', 500, null, function(err) {
-      assert.ok(!err);
-      assert.ok(nock.isDone());
-      done();
-    });
-  });
+    const unique = uuid();
+    this.fileName = `${unique}`;
+    this.dbName = 'couchbackup_test_' + unique;
+    cloudant.putDatabase({ db: this.dbName }).then(() => { done(); }).catch((err) => { done(err); });
+  } else {
+    done();
+  }
 });
 
-describe('Longer spool changes checks', function() {
-  it('#slow should keep collecting changes (25M)', function(done) {
-    // 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);
-    changes(db, '/dev/null', batch, null, function(err) {
-      assert.ok(!err);
-      assert.ok(nock.isDone());
-      done();
-    });
-  });
+afterEach('Delete test database', function(done) {
+  // Don't run hook for unit tests, just for CI
+  if (!this.currentTest.fullTitle().includes('#unit')) {
+    // Allow 10 seconds to delete the DB
+    this.timeout(10 * 1000);
+    deleteIfExists(this.fileName);
+    deleteIfExists(`${this.fileName}.log`);
+    cloudant.deleteDatabase({ db: this.dbName }).then(() => { done(); }).catch((err) => { done(err); });
+  } else {
+    done();
+  }
+});
 
-  it('#slower should keep collecting changes (500M)', function(done) {
-    // 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);
-    changes(db, '/dev/null', batch, null, function(err) {
-      assert.ok(!err);
-      assert.ok(nock.isDone());
-      done();
-    });
+function deleteIfExists(fileName) {
+  fs.unlink(fileName, function(err) {
+    if (err) {
+      if (err.code !== 'ENOENT') {
+        console.error(`${err.code} ${err.message}`);
+      }
+    }
   });
-});
+}