rqlite-js 2.5.6 → 2.6.0

package/lib/http-request/test.unit.js

@@ -0,0 +1,560 @@
+"use strict";var _chai = require("chai");
+var _http = require("http");
+var _https = require("https");
+var _apiDataQueryNock = require("../test/api-data-query-nock");
+
+
+
+
+
+
+var _apiDataExecuteNock = require("../test/api-data-execute-nock");
+
+
+
+
+
+
+var _contentTypes = require("./content-types");
+var _retryable = require("./retryable");
+
+
+
+
+var _ = _interopRequireWildcard(require("."));var cache;function _interopRequireWildcard(e, t) {if (!t && e && e.__esModule) return e;var r,c,a = Object.defineProperty,n = { __proto__: null, default: e };if (Object(e) !== e) return n;if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) {if (cache.has(e)) return cache.get(e);cache.set(e, n);}for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]);return n;}
+
+const username = 'TestUsername';
+const password = 'TestPassword';
+const auth = Object.freeze({
+  user: username,
+  pass: password
+});
+
+/**
+ * Capture the stream data and resolve a promise with the parsed JSON
+ */
+function handleRequestStreamAsPromise(request) {
+  return new Promise((resolve, reject) => {
+    let json = Buffer.from('');
+    request.
+    on('data', (data) => {
+      json = Buffer.concat([json, data]);
+    }).
+    on('end', () => resolve(JSON.parse(json))).
+    on('error', reject);
+  });
+}
+const ERROR_CODE_NOT_RETRYABLE = 'UNKNOWN';
+const HTTP_STATUS_CODE_NOT_RETRYABLE = 418; // I am little tea pot
+
+describe('http-request', () => {
+  describe('construtor()', () => {
+    it('should throw an error if no hosts are provided', () => {
+      _chai.assert.throws(() => new _.default(''), 'At least one host must be provided');
+    });
+    it('should set the hosts when provided as a string', () => {
+      const host1 = 'http://www.rqlite.com:4001';
+      const host2 = 'http://www.rqlite.com:4002';
+      const request = new _.default(`${host1}, ${host2}`);
+      _chai.assert.deepEqual(request.getHosts(), [host1, host2]);
+    });
+    it('should set the hosts provided as an array', () => {
+      const host1 = 'http://www.rqlite.com:4001';
+      const host2 = 'http://www.rqlite.com:4002';
+      const request = new _.default([host1, host2]);
+      _chai.assert.deepEqual(request.getHosts(), [host1, host2]);
+    });
+  });
+  describe('Function: createDefaultHeaders()', () => {
+    it(`should add the Accept header with a value of ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON}`, () => {
+      _chai.assert.deepEqual({ Accept: _contentTypes.CONTENT_TYPE_APPLICATION_JSON }, (0, _.createDefaultHeaders)());
+    });
+  });
+  describe('Function: getWaitTimeExponential()', () => {
+    it('should get the exponential value for attempt 0', () => {
+      _chai.assert.equal((0, _.getWaitTimeExponential)(0, 100, 2), 0);
+    });
+    it('should get the exponential value for attempt 1', () => {
+      _chai.assert.equal((0, _.getWaitTimeExponential)(1, 100, 2), 200);
+    });
+    it('should get the exponential value for attempt 2', () => {
+      _chai.assert.equal((0, _.getWaitTimeExponential)(2, 100, 2), 400);
+    });
+  });
+  describe('Method: HttpRequest.requestIsRetryable()', () => {
+    const url = 'http://www.rqlite.com:4001';
+    let httpRequest;
+    before('create http request instance', () => {
+      httpRequest = new _.default(url);
+    });
+    _retryable.RETRYABLE_HTTP_METHODS.forEach((httpMethod) => {
+      _retryable.RETRYABLE_STATUS_CODES.forEach((statusCode) => {
+        it(`should return true for HTTP method ${httpMethod} and status code ${statusCode}`, () => {
+          _chai.assert.isTrue(httpRequest.requestIsRetryable({
+            statusCode,
+            httpMethod
+          }));
+        });
+      });
+      _retryable.RETRYABLE_ERROR_CODES.forEach((errorCode) => {
+        it(`should return true for HTTP method ${httpMethod} error code ${errorCode}`, () => {
+          _chai.assert.isTrue(httpRequest.requestIsRetryable({
+            httpMethod,
+            statusCode: HTTP_STATUS_CODE_NOT_RETRYABLE,
+            errorCode
+          }));
+        });
+      });
+      it(`should return false for HTTP method ${httpMethod} and status code ${HTTP_STATUS_CODE_NOT_RETRYABLE}`, () => {
+        _chai.assert.isFalse(httpRequest.requestIsRetryable({
+          httpMethod,
+          statusCode: HTTP_STATUS_CODE_NOT_RETRYABLE
+        }));
+      });
+      it(`should return false for HTTP method ${httpMethod} and error code ${ERROR_CODE_NOT_RETRYABLE}`, () => {
+        _chai.assert.isFalse(httpRequest.requestIsRetryable({
+          httpMethod,
+          statusCode: HTTP_STATUS_CODE_NOT_RETRYABLE,
+          errorCode: ERROR_CODE_NOT_RETRYABLE
+        }));
+      });
+    });
+    it('should return false for HTTP method UNKNOWN', () => {
+      _chai.assert.isFalse(httpRequest.requestIsRetryable({
+        httpMethod: 'UNKNOWN'
+      }));
+    });
+  });
+  describe('Method: HttpRequest.get()', () => {
+    it('should set and get an http agent', async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpAgent = new _http.Agent();
+      const httpRequest = new _.default(url, { httpAgent });
+      _chai.assert.equal(httpRequest.getHttpAgent(), httpAgent, 'http agent is set on http request');
+    });
+    it('should set and get an https agent', async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpsAgent = new _https.Agent();
+      const httpRequest = new _.default(url, { httpsAgent });
+      _chai.assert.equal(httpRequest.getHttpsAgent(), httpsAgent, 'https agent is set on http request');
+    });
+    it('should perform a HTTP GET request', async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url);
+      const path = '/test';
+      const scope = (0, _apiDataQueryNock.querySuccess)({ url, path, query: {} });
+      const res = await httpRequest.get({ uri: path });
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(_apiDataQueryNock.QUERY_SUCCESS_RESPONSE, res.body);
+    });
+    _retryable.RETRYABLE_STATUS_CODES.forEach((statusCode) => {
+      it(`should perform a HTTP GET request and retry using the next host on retryable http status code ${statusCode}`, async () => {
+        const host1 = 'http://www.rqlite.com:4001';
+        const host2 = 'http://www.rqlite.com:4002';
+        const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+        const path = '/test';
+        const scopeFailure = (0, _apiDataQueryNock.queryFailureHttpStatusCode)({ url: host1, path, statusCode });
+        const scopeSuccess = (0, _apiDataQueryNock.querySuccess)({ url: host2, path });
+        const res = await httpRequest.get({ uri: path });
+        _chai.assert.isTrue(scopeSuccess.isDone(), 'http success request captured by nock');
+        _chai.assert.isTrue(scopeFailure.isDone(), 'http failure request captured by nock');
+        _chai.assert.deepEqual(_apiDataQueryNock.QUERY_SUCCESS_RESPONSE, res.body);
+      });
+      it(`should perform a HTTP GET request, retry using the next host on retryable http status code ${statusCode} and reject on max retries`, async () => {
+        const host1 = 'http://www.rqlite.com:4001';
+        const host2 = 'http://www.rqlite.com:4002';
+        const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+        const path = '/test';
+        const scopes = [
+        (0, _apiDataQueryNock.queryFailureHttpStatusCode)({ url: host1, path, statusCode }),
+        (0, _apiDataQueryNock.queryFailureHttpStatusCode)({ url: host2, path, statusCode }),
+        (0, _apiDataQueryNock.queryFailureHttpStatusCode)({ url: host1, path, statusCode }),
+        (0, _apiDataQueryNock.queryFailureHttpStatusCode)({ url: host2, path, statusCode }),
+        (0, _apiDataQueryNock.queryFailureHttpStatusCode)({ url: host1, path, statusCode }),
+        (0, _apiDataQueryNock.queryFailureHttpStatusCode)({ url: host2, path, statusCode }),
+        // Circles back to original host on last retry
+        (0, _apiDataQueryNock.queryFailureHttpStatusCode)({ url: host1, path, statusCode })];
+
+        await _chai.assert.isRejected(httpRequest.get({ uri: path }), `Request failed with status code ${statusCode}`);
+        scopes.forEach((scope, i) => {
+          _chai.assert.isTrue(scope.isDone(), `http failure request attempt ${i} captured by nock`);
+        });
+      });
+    });
+    it(`should perform a HTTP GET request and not retry on http status code ${HTTP_STATUS_CODE_NOT_RETRYABLE}`, async () => {
+      const host1 = 'http://www.rqlite.com:4001';
+      const host2 = 'http://www.rqlite.com:4002';
+      const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+      const path = '/test';
+      const scopeFailure = (0, _apiDataQueryNock.queryFailureHttpStatusCode)({
+        url: host1, path, statusCode: HTTP_STATUS_CODE_NOT_RETRYABLE
+      });
+      const scopeSuccess = (0, _apiDataQueryNock.querySuccess)({ url: host2, path });
+      await _chai.assert.isRejected(httpRequest.get({ uri: path }), `Request failed with status code ${HTTP_STATUS_CODE_NOT_RETRYABLE}`);
+      _chai.assert.isFalse(scopeSuccess.isDone(), 'http success request captured by nock, but not performed');
+      _chai.assert.isTrue(scopeFailure.isDone(), 'http failure request captured by nock');
+    });
+    _retryable.RETRYABLE_ERROR_CODES.forEach((errorCode) => {
+      it(`should perform a HTTP GET request and retry using the next host on retryable error code ${errorCode}`, async () => {
+        const host1 = 'http://www.rqlite.com:4001';
+        const host2 = 'http://www.rqlite.com:4002';
+        const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+        const path = '/test';
+        const scopeFailure = (0, _apiDataQueryNock.queryFailureErrorCode)({ url: host1, path, errorCode });
+        const scopeSuccess = (0, _apiDataQueryNock.querySuccess)({ url: host2, path });
+        const res = await httpRequest.get({ uri: path });
+        _chai.assert.isTrue(scopeSuccess.isDone(), 'http success request captured by nock');
+        _chai.assert.isTrue(scopeFailure.isDone(), 'http failure request captured by nock');
+        _chai.assert.deepEqual(_apiDataQueryNock.QUERY_SUCCESS_RESPONSE, res.body);
+      });
+      it(`should perform a HTTP GET request, retry using the next host on retryable error code ${errorCode} and reject on max retries`, async () => {
+        const host1 = 'http://www.rqlite.com:4001';
+        const host2 = 'http://www.rqlite.com:4002';
+        const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+        const path = '/test';
+        const scopes = [
+        (0, _apiDataQueryNock.queryFailureErrorCode)({ url: host1, path, errorCode }),
+        (0, _apiDataQueryNock.queryFailureErrorCode)({ url: host2, path, errorCode }),
+        (0, _apiDataQueryNock.queryFailureErrorCode)({ url: host1, path, errorCode }),
+        (0, _apiDataQueryNock.queryFailureErrorCode)({ url: host2, path, errorCode }),
+        (0, _apiDataQueryNock.queryFailureErrorCode)({ url: host1, path, errorCode }),
+        (0, _apiDataQueryNock.queryFailureErrorCode)({ url: host2, path, errorCode }),
+        // Circles back to original host on last retry
+        (0, _apiDataQueryNock.queryFailureErrorCode)({ url: host1, path, errorCode })];
+
+        await _chai.assert.isRejected(httpRequest.get({ uri: path }), errorCode);
+        scopes.forEach((scope, i) => {
+          _chai.assert.isTrue(scope.isDone(), `http failure request attempt ${i} captured by nock`);
+        });
+      });
+    });
+    it(`should perform a HTTP GET request and not retry on error code ${ERROR_CODE_NOT_RETRYABLE}`, async () => {
+      const host1 = 'http://www.rqlite.com:4001';
+      const host2 = 'http://www.rqlite.com:4002';
+      const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+      const path = '/test';
+      const scopeFailure = (0, _apiDataQueryNock.queryFailureErrorCode)({
+        url: host1, path, errorCode: ERROR_CODE_NOT_RETRYABLE
+      });
+      const scopeSuccess = (0, _apiDataQueryNock.querySuccess)({ url: host2, path });
+      await _chai.assert.isRejected(httpRequest.get({ uri: path }), ERROR_CODE_NOT_RETRYABLE);
+      _chai.assert.isFalse(scopeSuccess.isDone(), 'http success request captured by nock, but not performed');
+      _chai.assert.isTrue(scopeFailure.isDone(), 'http failure request captured by nock');
+    });
+    it('should perform a HTTP GET request with a query', async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url);
+      const path = '/test';
+      const query = { test: '123' };
+      const scope = (0, _apiDataQueryNock.querySuccess)({ url, path, query });
+      const res = await httpRequest.get({ uri: path, query });
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(_apiDataQueryNock.QUERY_SUCCESS_RESPONSE, res.body);
+    });
+    it('should perform a HTTP GET request with a query and follow redirects', async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const urlRedirectDestination = 'http://www.rqlite.com:4002';
+      const httpRequest = new _.default(url);
+      const path = '/test';
+      const query = { test: '123' };
+      const scopeRedirect = (0, _apiDataQueryNock.queryRedirectSuccess)({
+        url,
+        path,
+        query,
+        redirectLocation: `${urlRedirectDestination}${path}`
+      });
+      const scope = (0, _apiDataQueryNock.querySuccess)({ url: urlRedirectDestination, path, query });
+      const res = await httpRequest.get({ uri: path, query });
+      _chai.assert.isTrue(scopeRedirect.isDone(), 'http redirect request captured by nock');
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(_apiDataQueryNock.QUERY_SUCCESS_RESPONSE, res.body);
+    });
+    it('should perform a HTTP GET request with basic authentication', async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url, {
+        authentication: {
+          username,
+          password
+        }
+      });
+      const path = '/test';
+      const query = { test: '123' };
+      const scope = (0, _apiDataQueryNock.querySuccess)({ url, path, auth, query });
+      const res = await httpRequest.get({ uri: path, query });
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(_apiDataQueryNock.QUERY_SUCCESS_RESPONSE, res.body);
+    });
+    it('should perform a HTTP GET request with a query when the stream option is true', async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url);
+      const path = '/test';
+      const query = { test: '123' };
+      const scope = (0, _apiDataQueryNock.querySuccess)({ url, path, query });
+      const request = await httpRequest.get({ uri: path, query, stream: true });
+      const result = await handleRequestStreamAsPromise(request);
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(result, _apiDataQueryNock.QUERY_SUCCESS_RESPONSE);
+    });
+    it('should perform a HTTP GET request with a query when the stream option is true and follow redirects', async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const urlRedirectDestination = 'http://www.rqlite.com:4002';
+      const httpRequest = new _.default(url);
+      const path = '/test';
+      const query = { test: '123' };
+      const scopeRedirect = (0, _apiDataQueryNock.queryRedirectSuccess)({
+        url,
+        path,
+        query,
+        redirectLocation: `${urlRedirectDestination}${path}`
+      });
+      const scope = (0, _apiDataQueryNock.querySuccess)({ url: urlRedirectDestination, path, query });
+      const request = await httpRequest.get({ uri: path, query, stream: true });
+      const result = await handleRequestStreamAsPromise(request);
+      _chai.assert.isTrue(scopeRedirect.isDone(), 'http redirect request captured by nock');
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(result, _apiDataQueryNock.QUERY_SUCCESS_RESPONSE);
+    });
+    it('should perform a HTTP GET request with basic authentication when the stream option is true', async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url, {
+        authentication: {
+          username,
+          password
+        }
+      });
+      const path = '/test';
+      const query = { test: '123' };
+      const scope = (0, _apiDataQueryNock.querySuccess)({ url, path, auth, query });
+      const request = await httpRequest.get({ uri: path, query, stream: true });
+      const result = await handleRequestStreamAsPromise(request);
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(result, _apiDataQueryNock.QUERY_SUCCESS_RESPONSE);
+    });
+  });
+  describe('Method: HttpRequest.post()', () => {
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body`, async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url);
+      const path = '/test';
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scope = (0, _apiDataExecuteNock.executeSuccess)({ url, path, body });
+      const res = await httpRequest.post({ uri: path, body });
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(res.body, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+    });
+    _retryable.RETRYABLE_STATUS_CODES.forEach((statusCode) => {
+      it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body and retry using the next host on retryable http status code ${statusCode}`, async () => {
+        const host1 = 'http://www.rqlite.com:4001';
+        const host2 = 'http://www.rqlite.com:4002';
+        const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+        const path = '/test';
+        const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+        const scopeFailure = (0, _apiDataExecuteNock.executeFailureHttpStatusCode)({ url: host1, path, body, statusCode });
+        const scopeSuccess = (0, _apiDataExecuteNock.executeSuccess)({ url: host2, path, body });
+        const res = await httpRequest.post({ uri: path, body });
+        _chai.assert.isTrue(scopeSuccess.isDone(), 'http success request captured by nock');
+        _chai.assert.isTrue(scopeFailure.isDone(), 'http failure request captured by nock');
+        _chai.assert.deepEqual(res.body, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+      });
+      it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body and retry using the next host on retryable http status code ${statusCode} and reject on max retries`, async () => {
+        const host1 = 'http://www.rqlite.com:4001';
+        const host2 = 'http://www.rqlite.com:4002';
+        const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+        const path = '/test';
+        const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+        const scopes = [
+        (0, _apiDataExecuteNock.executeFailureHttpStatusCode)({ url: host1, path, body, statusCode }),
+        (0, _apiDataExecuteNock.executeFailureHttpStatusCode)({ url: host2, path, body, statusCode }),
+        (0, _apiDataExecuteNock.executeFailureHttpStatusCode)({ url: host1, path, body, statusCode }),
+        (0, _apiDataExecuteNock.executeFailureHttpStatusCode)({ url: host2, path, body, statusCode }),
+        (0, _apiDataExecuteNock.executeFailureHttpStatusCode)({ url: host1, path, body, statusCode }),
+        (0, _apiDataExecuteNock.executeFailureHttpStatusCode)({ url: host2, path, body, statusCode }),
+        // Circles back to original host on last retry
+        (0, _apiDataExecuteNock.executeFailureHttpStatusCode)({ url: host1, path, body, statusCode })];
+
+        await _chai.assert.isRejected(httpRequest.post({ uri: path, body }), `Request failed with status code ${statusCode}`);
+        scopes.forEach((scope, i) => {
+          _chai.assert.isTrue(scope.isDone(), `http failure request attempt ${i} captured by nock`);
+        });
+      });
+    });
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body and not retry on http status code ${HTTP_STATUS_CODE_NOT_RETRYABLE}`, async () => {
+      const host1 = 'http://www.rqlite.com:4001';
+      const host2 = 'http://www.rqlite.com:4002';
+      const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+      const path = '/test';
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scopeFailure = (0, _apiDataExecuteNock.executeFailureHttpStatusCode)({
+        url: host1, path, body, statusCode: HTTP_STATUS_CODE_NOT_RETRYABLE
+      });
+      const scopeSuccess = (0, _apiDataExecuteNock.executeSuccess)({ url: host2, path, body });
+      await _chai.assert.isRejected(httpRequest.post({ uri: path, body }), `Request failed with status code ${HTTP_STATUS_CODE_NOT_RETRYABLE}`);
+      _chai.assert.isFalse(scopeSuccess.isDone(), 'http success request captured by nock, but not called');
+      _chai.assert.isTrue(scopeFailure.isDone(), 'http failure request captured by nock');
+    });
+    _retryable.RETRYABLE_ERROR_CODES.forEach((errorCode) => {
+      it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body and retry using the next host on retryable error code ${errorCode}`, async () => {
+        const host1 = 'http://www.rqlite.com:4001';
+        const host2 = 'http://www.rqlite.com:4002';
+        const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+        const path = '/test';
+        const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+        const scopeFailure = (0, _apiDataExecuteNock.executeFailureErrorCode)({ url: host1, path, body, errorCode });
+        const scopeSuccess = (0, _apiDataExecuteNock.executeSuccess)({ url: host2, path, body });
+        const res = await httpRequest.post({ uri: path, body });
+        _chai.assert.isTrue(scopeSuccess.isDone(), 'http success request captured by nock');
+        _chai.assert.isTrue(scopeFailure.isDone(), 'http failure request captured by nock');
+        _chai.assert.deepEqual(res.body, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+      });
+      it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body and retry using the next host on retryable error code ${errorCode} and reject on max retries`, async () => {
+        const host1 = 'http://www.rqlite.com:4001';
+        const host2 = 'http://www.rqlite.com:4002';
+        const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+        const path = '/test';
+        const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+        const scopes = [
+        (0, _apiDataExecuteNock.executeFailureErrorCode)({ url: host1, path, body, errorCode }),
+        (0, _apiDataExecuteNock.executeFailureErrorCode)({ url: host2, path, body, errorCode }),
+        (0, _apiDataExecuteNock.executeFailureErrorCode)({ url: host1, path, body, errorCode }),
+        (0, _apiDataExecuteNock.executeFailureErrorCode)({ url: host2, path, body, errorCode }),
+        (0, _apiDataExecuteNock.executeFailureErrorCode)({ url: host1, path, body, errorCode }),
+        (0, _apiDataExecuteNock.executeFailureErrorCode)({ url: host2, path, body, errorCode }),
+        // Circles back to original host on last retry
+        (0, _apiDataExecuteNock.executeFailureErrorCode)({ url: host1, path, body, errorCode })];
+
+        await _chai.assert.isRejected(httpRequest.post({ uri: path, body }), errorCode);
+        scopes.forEach((scope, i) => {
+          _chai.assert.isTrue(scope.isDone(), `http failure request attempt ${i} captured by nock`);
+        });
+      });
+    });
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body and not retry on error code ${ERROR_CODE_NOT_RETRYABLE}`, async () => {
+      const host1 = 'http://www.rqlite.com:4001';
+      const host2 = 'http://www.rqlite.com:4002';
+      const httpRequest = new _.default(`${host1},${host2}`, { exponentailBackoffBase: 0, exponentailBackoffExponent: 0 });
+      const path = '/test';
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scopeFailure = (0, _apiDataExecuteNock.executeFailureErrorCode)({
+        url: host1, path, body, errorCode: ERROR_CODE_NOT_RETRYABLE
+      });
+      const scopeSuccess = (0, _apiDataExecuteNock.executeSuccess)({ url: host2, path, body });
+      await _chai.assert.isRejected(httpRequest.post({ uri: path, body }), ERROR_CODE_NOT_RETRYABLE);
+      _chai.assert.isFalse(scopeSuccess.isDone(), 'http success request captured by nock, but not called');
+      _chai.assert.isTrue(scopeFailure.isDone(), 'http failure request captured by nock');
+    });
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body and follow redirects`, async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const urlRedirectDestination = 'http://www.rqlite.com:4002';
+      const httpRequest = new _.default(url);
+      const path = '/test';
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scopeRedirect = (0, _apiDataExecuteNock.executeRedirectSuccess)({
+        url,
+        path,
+        redirectLocation: `${urlRedirectDestination}${path}`,
+        body
+      });
+      const scope = (0, _apiDataExecuteNock.executeSuccess)({ url: urlRedirectDestination, path });
+      const res = await httpRequest.post({ uri: path, body });
+      _chai.assert.isTrue(scopeRedirect.isDone(), 'http redirect request captured by nock');
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(res.body, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+    });
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body and follow redirects when useLeader is true plus redirect host is not in host list`, async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const urlRedirectDestination = 'http://www.rqlite.com:4002';
+      const httpRequest = new _.default(url);
+      const path = '/test';
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scopeRedirect = (0, _apiDataExecuteNock.executeRedirectSuccess)({
+        url,
+        path,
+        redirectLocation: `${urlRedirectDestination}${path}`,
+        body
+      });
+      const scope = (0, _apiDataExecuteNock.executeSuccess)({ url: urlRedirectDestination, path });
+      const res = await httpRequest.post({ uri: path, body, useLeader: true });
+      _chai.assert.isTrue(scopeRedirect.isDone(), 'http redirect request captured by nock');
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(res.body, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+    });
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body and follow redirects when useLeader is true plus redirect host is in host list`, async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const urlRedirectDestination = 'http://www.rqlite.com:4002';
+      const path = '/test';
+      const httpRequest = new _.default(`${url},${urlRedirectDestination}${path}`);
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scopeRedirect = (0, _apiDataExecuteNock.executeRedirectSuccess)({
+        url,
+        path,
+        redirectLocation: `${urlRedirectDestination}${path}`,
+        body
+      });
+      const scope = (0, _apiDataExecuteNock.executeSuccess)({ url: urlRedirectDestination, path });
+      const res = await httpRequest.post({ uri: path, body, useLeader: true });
+      _chai.assert.isTrue(scopeRedirect.isDone(), 'http redirect request captured by nock');
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(res.body, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+      _chai.assert.equal(httpRequest.getLeaderHostIndex(), 1, 'leader host index matches redirect');
+    });
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body with basic auth`, async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url, {
+        authentication: {
+          username,
+          password
+        }
+      });
+      const path = '/test';
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scope = (0, _apiDataExecuteNock.executeSuccess)({ url, path, auth });
+      const res = await httpRequest.post({ uri: path, body });
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(res.body, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+    });
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body when the stream option is true`, async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url);
+      const path = '/test';
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scope = (0, _apiDataExecuteNock.executeSuccess)({ url, path });
+      const request = await httpRequest.post({ uri: path, body, stream: true });
+      const result = await handleRequestStreamAsPromise(request);
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(result, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+    });
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body with basic auth when the stream option is true`, async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url, {
+        authentication: {
+          username,
+          password
+        }
+      });
+      const path = '/test';
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scope = (0, _apiDataExecuteNock.executeSuccess)({ url, path, auth });
+      const request = await httpRequest.post({ uri: path, body, stream: true });
+      const result = await handleRequestStreamAsPromise(request);
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(result, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+    });
+    it(`should send a HTTP POST request including ${_contentTypes.CONTENT_TYPE_APPLICATION_JSON} body with basic auth used in constructor when the stream option is true`, async () => {
+      const url = 'http://www.rqlite.com:4001';
+      const httpRequest = new _.default(url, {
+        authentication: {
+          username,
+          password
+        }
+      });
+      const path = '/test';
+      const body = ['INSERT INTO foo(name) VALUES("fiona")'];
+      const scope = (0, _apiDataExecuteNock.executeSuccess)({ url, path, auth });
+      const request = await httpRequest.post({ uri: path, body, stream: true });
+      const result = await handleRequestStreamAsPromise(request);
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(result, _apiDataExecuteNock.EXECUTE_SUCCESS_RESPONSE);
+    });
+  });
+});
+//# sourceMappingURL=test.unit.js.map