@cloudant/couchbackup 2.9.8-SNAPSHOT.94 → 2.9.8

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

@@ -1,4 +1,4 @@
-// Copyright © 2017, 2021 IBM Corp. All rights reserved.
+// 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.
@@ -16,141 +16,104 @@
 'use strict';
 
 const assert = require('assert');
-const nock = require('nock');
-const request = require('../includes/request.js');
-const changes = require('../includes/spoolchanges.js');
+const fs = require('fs');
+const u = require('./citestutils.js');
 
-const url = 'http://localhost:7777';
-const dbName = 'fakenockdb';
-const longTestTimeout = 3000;
+[{ 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 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`
-      };
+      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);
+          }
+        }
+      });
     });
-}
-
-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();
+    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);
+          }
+        });
+      });
     });
-  }).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' };
+    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);
+          }
+        });
       });
-
-    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
-    this.timeout(10 * 1000);
+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);
 
-    // 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();
-    });
-  });
+    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;
 
-  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();
-    });
+    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);
 
-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();
-    });
-  });
+    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;
 
-  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();
-    });
+    u.testBackupAbortResumeRestore(p, 'backup10m', actualBackup, restoreDb, done);
   });
 });

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

@@ -1,4 +1,4 @@
-// Copyright © 2017 IBM Corp. All rights reserved.
+// Copyright © 2018, 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.
@@ -15,20 +15,78 @@
 /* global describe it */
 'use strict';
 
-const assert = require('assert');
-const logfilesummary = require('../includes/logfilesummary.js');
-
-describe('#unit Fetching summary from the log file', function() {
-  it('should fetch a summary correctly', function(done) {
-    logfilesummary('./test/fixtures/test.log', function(err, data) {
-      assert.ok(!err);
-      assert.ok(data);
-      assert.strictEqual(data.changesComplete, true);
-      assert.strictEqual(typeof data.batches, 'object');
-      assert.strictEqual(Object.keys(data.batches).length, 2);
-      assert.deepStrictEqual(data.batches['1'], true);
-      assert.deepStrictEqual(data.batches['4'], true);
-      done();
+const fs = require('fs');
+const readline = require('readline');
+const u = require('./citestutils.js');
+const uuid = require('uuid').v4;
+
+const params = { useApi: true };
+
+describe(u.scenario('Concurrent database backups', params), function() {
+  it('should run concurrent API database backups correctly #slower', function(done) {
+    // Allow up to 900 s to backup and compare (it should be much faster)!
+    u.setTimeout(this, 900);
+
+    let doneCount = 0;
+    let doneErr;
+    const finished = function(err) {
+      doneCount++;
+      if (doneCount === 2) {
+        done(doneErr || err);
+      }
+      doneErr = err;
+    };
+
+    const checkForEmptyBatches = function(fileName, cb) {
+      let foundEmptyBatch = false;
+
+      const rd = readline.createInterface({
+        input: fs.createReadStream(fileName),
+        output: fs.createWriteStream('/dev/null'),
+        terminal: false
+      });
+
+      rd.on('line', function(line) {
+        if (JSON.parse(line).length === 0) {
+          // Note: Empty batch arrays indicate that the running backup is
+          // incorrectly sharing a log file with another ongoing backup job.
+          foundEmptyBatch = true;
+        }
+      });
+
+      rd.on('close', function() {
+        if (foundEmptyBatch) {
+          cb(new Error(`Log file '${fileName}' contains empty batches`));
+        } else {
+          cb();
+        }
+      });
+    };
+
+    // [1] Run 'largedb2g' database backup
+    const actualBackup1 = `./${uuid()}`;
+    const output1 = fs.createWriteStream(actualBackup1);
+    output1.on('open', function() {
+      u.testBackup(params, 'largedb2g', output1, function(err) {
+        if (err) {
+          finished(err);
+        } else {
+          checkForEmptyBatches(actualBackup1, finished);
+        }
+      });
+    });
+
+    // [2] Run 'largedb1g' database backup
+    const actualBackup2 = `./${uuid()}`;
+    const output2 = fs.createWriteStream(actualBackup2);
+    output2.on('open', function() {
+      u.testBackup(params, 'largedb1g', output2, function(err) {
+        if (err) {
+          finished(err);
+        } else {
+          checkForEmptyBatches(actualBackup2, finished);
+        }
+      });
     });
   });
 });