@cloudant/couchbackup 2.9.8 → 2.9.9-SNAPSHOT.100

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

@@ -15,211 +15,54 @@
 /* global describe it */
 'use strict';
 
-const assert = require('assert');
-const backup = require('../app.js').backup;
 const fs = require('fs');
-const nock = require('nock');
+const u = require('./citestutils.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;
-};
+[{ useApi: true }, { useApi: false }].forEach(function(params) {
+  describe(u.scenario('Compression tests', params), function() {
+    const p = u.p(params, { compression: 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;
-}
+    it('should backup animaldb to a compressed file', function(done) {
+      // Allow up to 60 s for backup of animaldb
+      u.setTimeout(this, 60);
+      const compressedBackup = `./${this.fileName}`;
+      const output = fs.createWriteStream(compressedBackup);
+      output.on('open', function() {
+        u.testBackup(p, 'animaldb', output, function(err) {
+          if (err) {
+            done(err);
+          } else {
+            u.assertGzipFile(compressedBackup, done);
+          }
+        });
+      });
+    });
 
-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);
-    }
-  };
-}
+    it('should backup and restore animaldb via a compressed file', function(done) {
+      // Allow up to 60 s for backup and restore of animaldb
+      u.setTimeout(this, 60);
+      const compressedBackup = `./${this.fileName}`;
+      u.testBackupAndRestoreViaFile(p, 'animaldb', compressedBackup, this.dbName, function(err) {
+        if (err) {
+          done(err);
+        } else {
+          u.assertGzipFile(compressedBackup, done);
+        }
+      });
+    });
 
-function assertNoError(done) {
-  return function(err, data) {
-    try {
-      assert(err === null, 'There should be no error message.');
-      done();
-    } catch (e) {
-      done(e);
-    }
-  };
-}
+    it('should backup and restore animaldb via a compressed stream', function(done) {
+      // Allow up to 60 s for backup and restore of animaldb
+      u.setTimeout(this, 60);
+      u.testDirectBackupAndRestore(p, 'animaldb', this.dbName, done);
+    });
 
-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();
-    }
+    it('should backup and restore largedb2g via a compressed file #slower', function(done) {
+      // Takes ~ 25 min using CLI, but sometimes over an hour with API
+      u.setTimeout(this, 180 * 60);
+      const compressedBackup = `./${this.fileName}`;
+      params.compression = true;
+      u.testBackupAndRestoreViaFile(p, 'largedb2g', compressedBackup, this.dbName, done);
+    });
   });
 });

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

@@ -12,103 +12,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-/* global after before describe */
+/* global describe it */
 'use strict';
 
-const url = require('url');
-const toxy = require('toxy');
-// Import the common hooks
-require('../test/hooks.js');
+delete require.cache[require.resolve('./citestutils.js')];
+const u = require('./citestutils.js');
 
-const tpoisons = toxy.poisons;
-const trules = toxy.rules;
-
-function setupProxy(poison) {
-  const backendUrl = new url.URL(process.env.COUCH_BACKEND_URL);
-  const proxy = toxy({
-    auth: `${backendUrl.username}:${backendUrl.password}`,
-    changeOrigin: true
-  });
-
-  // Forward traffic to DB
-  proxy.forward(process.env.COUCH_BACKEND_URL);
-
-  switch (poison) {
-    case 'normal':
-      // No poisons to add
-      break;
-    case 'bandwidth-limit':
-      // https://github.com/h2non/toxy#bandwidth
-      // Note the implementation of bandwidth is simplistic and the threshold
-      // delay is applied to every write of the buffer, so use the smallest
-      // delay possible and adjust the rate using the bytes size instead.
-      proxy
-        .poison(tpoisons.bandwidth({ bytes: 512, threshold: 1 })); // 0.5 MB/s
-      break;
-    case 'latency':
-      // https://github.com/h2non/toxy#latency
-      proxy
-        .poison(tpoisons.latency({ max: 1500, min: 250 }))
-        .withRule(trules.probability(60));
-      break;
-    case 'slow-read':
-      // https://github.com/h2non/toxy#slow-read
-      // Note this only impacts read of data from requests so only for non-GET
-      // In practice this means that it impacts restore much more than backup
-      // since although backup POSTs to _bulk_get the content is much smaller
-      // than what is POSTed to _bulk_docs for a restore.
-      // Similarly to bandwidth-limit use a 1 ms threshold
-      proxy
-        .poison(tpoisons.slowRead({ chunk: 256, threshold: 1 }))
-        // Slow read for 10 % of the time e.g. 10 ms in every 100
-        .withRule(trules.timeThreshold({ duration: 10, period: 100 }));
-      break;
-    case 'rate-limit':
-      // https://github.com/h2non/toxy#rate-limit
-      // Simulate the Cloudant free plan with 20 lookups ps and 10 writes ps
-      proxy.post('/*/_bulk_get')
-        .poison(tpoisons.rateLimit({ limit: 20, threshold: 1000 }));
-      proxy.post('/*/_bulk_docs')
-        .poison(tpoisons.rateLimit({ limit: 10, threshold: 1000 }));
-      break;
-    default:
-      throw Error('Unknown toxy poison ' + poison);
-  }
-
-  // Catch remaining traffic
-  proxy.all('/*');
-  return proxy;
-}
-
-const poisons = [
-  'normal',
-  'bandwidth-limit',
-  'latency',
-  'slow-read',
-  'rate-limit'
-];
-
-poisons.forEach(function(poison) {
-  describe('unreliable network tests (using toxy poison ' + poison + ')', function() {
-    let proxy;
-
-    before('start toxy server', function() {
-      proxy = setupProxy(poison);
-      console.log('Using toxy poison ' + poison);
-
-      // For these tests COUCH_URL points to the toxy proxy on localhost whereas
-      // COUCH_BACKEND_URL is the real CouchDb instance.
-      const toxyUrl = new url.URL(process.env.COUCH_URL);
-      // Listen on the specified hostname only, so if using localhost we don't
-      // need external connections.
-      proxy.listen(toxyUrl.port, toxyUrl.hostname);
+[{ useApi: true }, { useApi: false }].forEach(function(params) {
+  describe(u.scenario('End to end backup and restore', params), function() {
+    it('should backup and restore animaldb', function(done) {
+      // Allow up to 60 s for backup and restore of animaldb
+      u.setTimeout(this, 60);
+      u.testDirectBackupAndRestore(params, 'animaldb', this.dbName, done);
     });
-
-    after('stop toxy server', function() {
-      proxy.close();
+    it('should backup and restore largedb1g #slow', function(done) {
+      // Allow up to 30 m for backup and restore of largedb1g
+      // This is a long time but when many builds run in parallel it can take a
+      // while to get this done.
+      u.setTimeout(this, 30 * 60);
+      u.testDirectBackupAndRestore(params, 'largedb1g', this.dbName, done);
     });
-
-    delete require.cache[require.resolve('../test/ci_e2e.js')];
-    require('../test/ci_e2e.js');
   });
 });

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

@@ -1,167 +1,68 @@
-<testsuites name="test-iam">
-  <testsuite name="Basic backup and restore using API" tests="3" errors="0" failures="0" skipped="0" timestamp="2023-04-04T15:56:32" time="4.678">
-    <testcase classname="test-iam.Basic backup and restore using API" name="should backup animaldb to a file correctly" time="1.171">
-      <system-out><![CDATA[{ total: 15 }
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Basic backup and restore using API" name="should restore animaldb to a database correctly" time="1.83">
-      <system-out><![CDATA[{ total: 15 }
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Basic backup and restore using API" name="should execute a shallow mode backup successfully" time="0.566">
-      <system-out><![CDATA[{ total: 11 }
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="Basic backup and restore using API Buffer size tests using API" tests="3" errors="0" failures="0" skipped="0" timestamp="2023-04-04T15:56:37" time="11.461">
-    <testcase classname="test-iam.Basic backup and restore using API Buffer size tests using API" name="should backup/restore animaldb with the same buffer size" time="3.681">
-      <system-out><![CDATA[{ total: 15 }
-{ total: 15 }
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Basic backup and restore using API Buffer size tests using API" name="should backup/restore animaldb with backup buffer &gt; restore buffer" time="3.359">
-      <system-out><![CDATA[{ total: 15 }
-{ total: 15 }
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Basic backup and restore using API Buffer size tests using API" name="should backup/restore animaldb with backup buffer &lt; restore buffer" time="3.638">
-      <system-out><![CDATA[{ total: 15 }
-{ total: 15 }
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="Basic backup and restore using CLI" tests="3" errors="0" failures="0" skipped="0" timestamp="2023-04-04T15:56:48" time="5.169">
-    <testcase classname="test-iam.Basic backup and restore using CLI" name="should backup animaldb to a file correctly" time="1.238">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Basic backup and restore using CLI" name="should restore animaldb to a database correctly" time="2.179">
-    </testcase>
-    <testcase classname="test-iam.Basic backup and restore using CLI" name="should execute a shallow mode backup successfully" time="0.971">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="Basic backup and restore using CLI Buffer size tests using CLI" tests="3" errors="0" failures="0" skipped="0" timestamp="2023-04-04T15:56:53" time="14.231">
-    <testcase classname="test-iam.Basic backup and restore using CLI Buffer size tests using CLI" name="should backup/restore animaldb with the same buffer size" time="4.769">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Basic backup and restore using CLI Buffer size tests using CLI" name="should backup/restore animaldb with backup buffer &gt; restore buffer" time="4.218">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Basic backup and restore using CLI Buffer size tests using CLI" name="should backup/restore animaldb with backup buffer &lt; restore buffer" time="4.462">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="Compression tests using API" tests="3" errors="0" failures="0" skipped="0" timestamp="2023-04-04T15:57:08" time="6.477">
-    <testcase classname="test-iam.Compression tests using API" name="should backup animaldb to a compressed file" time="1.01">
-      <system-out><![CDATA[{ total: 15 }
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Compression tests using API" name="should backup and restore animaldb via a compressed file" time="2.595">
-      <system-out><![CDATA[{ total: 15 }
-{ total: 15 }
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Compression tests using API" name="should backup and restore animaldb via a compressed stream" time="2.092">
-      <system-out><![CDATA[{ total: 15 }
-{ total: 15 }
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="Compression tests using CLI" tests="3" errors="0" failures="0" skipped="0" timestamp="2023-04-04T15:57:14" time="8.76">
-    <testcase classname="test-iam.Compression tests using CLI" name="should backup animaldb to a compressed file" time="1.247">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Compression tests using CLI" name="should backup and restore animaldb via a compressed file" time="4.042">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Compression tests using CLI" name="should backup and restore animaldb via a compressed stream" time="2.687">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="End to end backup and restore using API" tests="2" errors="0" failures="0" skipped="0" timestamp="2023-04-04T15:57:23" time="345.506">
-    <testcase classname="test-iam.End to end backup and restore using API" name="should backup and restore animaldb" time="2.083">
-      <system-out><![CDATA[{ total: 15 }
-{ total: 15 }
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.End to end backup and restore using API" name="should backup and restore largedb1g #slow" time="342.642">
-      <system-out><![CDATA[{ total: 522948 }
-{ total: 522948 }
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="End to end backup and restore using CLI" tests="2" errors="0" failures="0" skipped="0" timestamp="2023-04-04T16:03:08" time="546.769">
-    <testcase classname="test-iam.End to end backup and restore using CLI" name="should backup and restore animaldb" time="2.865">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.End to end backup and restore using CLI" name="should backup and restore largedb1g #slow" time="543.145">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="Encryption tests" tests="1" errors="0" failures="0" skipped="0" timestamp="2023-04-04T16:12:15" time="4.02">
-    <testcase classname="test-iam.Encryption tests" name="should backup and restore animaldb via an encrypted file" time="3.76">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="Write error tests" tests="1" errors="0" failures="0" skipped="0" timestamp="2023-04-04T16:12:20" time="0.267">
-    <testcase classname="test-iam.Write error tests" name="calls callback with error set when stream is not writeable" time="0.01">
-    </testcase>
-  </testsuite>
-  <testsuite name="Event tests" tests="2" errors="0" failures="0" skipped="0" timestamp="2023-04-04T16:12:20" time="2.19">
-    <testcase classname="test-iam.Event tests" name="should get a finished event when using stdout" time="0.824">
-    </testcase>
-    <testcase classname="test-iam.Event tests" name="should get a finished event when using file output" time="0.837">
-    </testcase>
-  </testsuite>
-  <testsuite name="Resume tests using API" tests="3" errors="0" failures="0" skipped="0" timestamp="2023-04-04T16:12:22" time="5.219">
-    <testcase classname="test-iam.Resume tests using API" name="should create a log file" time="0.84">
-      <system-out><![CDATA[{ total: 15 }
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Resume tests using API" name="should restore corrupted animaldb to a database correctly" time="1.746">
-      <system-out><![CDATA[{ total: 15 }
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Resume tests using API" name="should restore resumed animaldb with blank line to a database correctly" time="1.796">
-      <system-out><![CDATA[{ total: 15 }
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="Resume tests using CLI" tests="3" errors="0" failures="0" skipped="0" timestamp="2023-04-04T16:12:27" time="6.555">
-    <testcase classname="test-iam.Resume tests using CLI" name="should create a log file" time="1.362">
-      <system-out><![CDATA[Backup process close 0 null
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Resume tests using CLI" name="should restore corrupted animaldb to a database correctly" time="2.226">
-    </testcase>
-    <testcase classname="test-iam.Resume tests using CLI" name="should restore resumed animaldb with blank line to a database correctly" time="2.173">
-    </testcase>
-  </testsuite>
-  <testsuite name="Resume tests" tests="2" errors="0" failures="0" skipped="0" timestamp="2023-04-04T16:12:34" time="34.654">
-    <testcase classname="test-iam.Resume tests" name="should correctly backup and restore backup10m" time="17.304">
-      <system-out><![CDATA[Backup process close null SIGTERM
-Backup process close 0 null
-]]></system-out>
-    </testcase>
-    <testcase classname="test-iam.Resume tests" name="should correctly backup and restore backup10m using --output" time="16.835">
-      <system-out><![CDATA[Backup process close null SIGTERM
-Backup process close 0 null
-]]></system-out>
-    </testcase>
-  </testsuite>
-  <testsuite name="Longer spool changes checks" tests="1" errors="0" failures="0" skipped="0" timestamp="2023-04-04T16:13:09" time="53.696">
-    <testcase classname="test-iam.Longer spool changes checks" name="#slow should keep collecting changes (25M)" time="53.435">
-    </testcase>
-  </testsuite>
-</testsuites>
+// 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.
+// 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 beforeEach afterEach */
+'use strict';
+
+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');
+
+// Mocha hooks that will be at the root context so run for all tests
+
+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);
+    const unique = uuid();
+    this.fileName = `${unique}`;
+    this.dbName = 'couchbackup_test_' + unique;
+    cloudant.putDatabase({ db: this.dbName }).then(() => { done(); }).catch((err) => { done(err); });
+  } else {
+    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();
+  }
+});
+
+function deleteIfExists(fileName) {
+  fs.unlink(fileName, function(err) {
+    if (err) {
+      if (err.code !== 'ENOENT') {
+        console.error(`${err.code} ${err.message}`);
+      }
+    }
+  });
+}