@inboxsdk/core 1.1.6 → 1.1.7

package/src/injected-js/xhr-proxy-factory.test.js

@@ -1,1052 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _assert = _interopRequireDefault(require("assert"));
-var _lodash = _interopRequireDefault(require("lodash"));
-var _noop = _interopRequireDefault(require("lodash/noop"));
-var _sinon = _interopRequireDefault(require("sinon"));
-var _pdelay = _interopRequireDefault(require("pdelay"));
-var _MockServer = _interopRequireDefault(require("../../test/lib/MockServer"));
-var _xhrProxyFactory = _interopRequireDefault(require("./xhr-proxy-factory"));
-const testError = new Error('TEST');
-let logErrorTestCalls = 0;
-function logError(error, label) {
-  if (error === testError) {
-    logErrorTestCalls++;
-  } else {
-    console.error('logError:', label, error);
-    throw error || new Error(label);
-  }
-}
-function thrower(err) {
-  return function () {
-    if (typeof err == 'string') {
-      throw new Error(err);
-    } else if (err) {
-      throw err;
-    } else {
-      throw new Error('Should not happen');
-    }
-  };
-}
-const server = new _MockServer.default();
-server.respondWith({
-  method: 'GET',
-  path: '/foo',
-  headers: {
-    'X-Special': 'Value'
-  }
-}, {
-  status: 200,
-  response: 'header value received'
-});
-server.respondWith({
-  method: 'GET',
-  path: '/foo',
-  responseType: 'testing'
-}, {
-  status: 200,
-  response: 'testing here!'
-});
-server.respondWith({
-  method: 'GET',
-  path: '/foo'
-}, {
-  status: 200,
-  response: 'Response here!',
-  partialResponse: 'Response here',
-  headers: {
-    'X-Test': 'Header Value'
-  }
-});
-server.respondWith({
-  method: 'POST',
-  path: '/foo',
-  body: 'somedata'
-}, {
-  status: 200,
-  response: 'body received'
-});
-server.respondWith({
-  method: 'POST',
-  path: '/foo',
-  body: 'testab'
-}, {
-  status: 200,
-  response: 'testab received'
-});
-server.respondWith({
-  method: 'POST',
-  path: '/foo'
-}, {
-  status: 200,
-  response: 'POST request'
-});
-server.respondWith({
-  method: 'GET',
-  path: '/foo2'
-}, {
-  status: 200,
-  response: 'foo2 response!',
-  partialResponse: 'foo2 response'
-});
-server.respondWith({
-  method: 'GET',
-  path: '/fooXml'
-}, {
-  status: 200,
-  response: 'testing here!',
-  responseXML: {
-    fakeXml: true
-  }
-});
-server.respondWith({
-  method: 'GETab',
-  path: '/fooAB'
-}, {
-  status: 200,
-  response: 'fooAB requested, data12 received'
-});
-const XMLHttpRequest = server.XMLHttpRequest;
-const constructors = {
-  XMLHttpRequest: XMLHttpRequest,
-  XHRProxy: (0, _xhrProxyFactory.default)(XMLHttpRequest, [], {
-    logError: logError
-  })
-};
-constructors['XHRProxy²'] = (0, _xhrProxyFactory.default)(constructors.XHRProxy, [], {
-  logError: logError
-});
-constructors['XHRProxy with changers'] = (0, _xhrProxyFactory.default)(XMLHttpRequest, [{
-  isRelevantTo: () => true,
-  requestChanger(connection, request) {
-    return Promise.resolve(request);
-  },
-  responseTextChanger(connection, response) {
-    return Promise.resolve(response);
-  }
-}], {
-  logError: logError
-});
-beforeEach(() => {
-  logErrorTestCalls = 0;
-});
-
-// Test both the mock and the instrumented version
-['XMLHttpRequest', 'XHRProxy', 'XHRProxy²', 'XHRProxy with changers'].forEach(XHRName => {
-  describe(XHRName, () => {
-    let XHRConstructor;
-    let xhr;
-    beforeEach(() => {
-      XHRConstructor = constructors[XHRName];
-      xhr = new XHRConstructor();
-    });
-    ['onreadystatechange', 'addEventListener'].forEach(method => {
-      describe(method, () => {
-        it('should call all states and work on re-used object', done => {
-          const calledForState = {
-            '1': 0,
-            '2': 0,
-            '3': 0,
-            '4': 0
-          };
-          let runCount = 0;
-          const listener = function (event) {
-            _assert.default.strictEqual(this, xhr, 'check for correct this binding');
-            _assert.default.strictEqual(event.target, this, 'check for correct event target');
-            calledForState[this.readyState]++;
-            if (this.readyState >= 2) {
-              _assert.default.equal(this.status, 200, 'check http status');
-            }
-            if (this.readyState >= 3) {
-              _assert.default.equal(this.responseText, this.response, 'check responseText');
-            } else {
-              let responseText;
-              try {
-                responseText = this.responseText;
-              } catch (e) {
-                responseText = '';
-              }
-              _assert.default.strictEqual(responseText, '');
-            }
-            if (this.readyState == 3) {
-              if (XHRName === 'XHRProxy with changers') {
-                // No progress text should be given when a responseTextChanger is in use.
-                _assert.default.strictEqual(this.response, '');
-              } else {
-                _assert.default.strictEqual(this.response, 'Response here');
-              }
-            }
-            if (this.readyState == 4) {
-              runCount++;
-              _assert.default.equal(this.response, 'Response here!');
-              _assert.default.deepEqual(calledForState, {
-                '1': runCount,
-                '2': runCount,
-                '3': runCount,
-                '4': runCount
-              }, 'check that listener was called for each state');
-              if (runCount === 1) {
-                start();
-              } else {
-                done();
-              }
-            }
-          };
-          if (method == 'onreadystatechange') {
-            xhr.onreadystatechange = listener;
-          } else if (method == 'addEventListener') {
-            xhr.addEventListener('readystatechange', listener);
-          }
-          function start() {
-            xhr.open('GET', '/foo');
-            _assert.default.equal(xhr.readyState, 1, 'readyState check');
-            xhr.send();
-          }
-          _assert.default.equal(xhr.readyState, 0, 'readyState check');
-          start();
-        });
-      });
-    });
-    describe('multiple event listeners', () => {
-      it('should fire both together', done => {
-        let simpleFired = false,
-          addedFired = false;
-        xhr.onreadystatechange = function (event) {
-          simpleFired = true;
-        };
-        xhr.addEventListener('readystatechange', function (event) {
-          addedFired = true;
-        });
-        xhr.addEventListener('readystatechange', function (event) {
-          if (this.readyState == 4) {
-            (0, _assert.default)(simpleFired && addedFired, 'check that both listeners fired');
-            done();
-          }
-        });
-        xhr.open('GET', '/foo');
-        xhr.send();
-      });
-    });
-    describe('removeEventListener', () => {
-      it('should work', done => {
-        const badListener = function (event) {
-          throw new Error('this listener should have been removed');
-        };
-        xhr.addEventListener('readystatechange', badListener);
-        xhr.addEventListener('readystatechange', function (event) {
-          if (this.readyState == 4) {
-            done();
-          }
-        });
-        xhr.removeEventListener('readystatechange', badListener);
-        xhr.open('GET', '/foo');
-        xhr.send();
-      });
-    });
-    describe('abort', () => {
-      it('should work after send', done => {
-        let finishCount = 0;
-        xhr.onreadystatechange = function () {
-          if (this.readyState == 4) {
-            if (finishCount++ === 0) {
-              _assert.default.equal(this.responseText, 'Response here', 'response check');
-              xhr.open('GET', '/foo2');
-              xhr.send();
-            } else {
-              _assert.default.equal(this.responseText, 'foo2 response!', 'response check');
-              done();
-            }
-          }
-        };
-        xhr.open('GET', '/foo');
-        xhr.send();
-        xhr.abort();
-      });
-    });
-    describe('open', () => {
-      it('should cancel active request but without abort event', done => {
-        xhr.onreadystatechange = _sinon.default.spy();
-        xhr.onabort = xhr.onerror = xhr.onload = xhr.onloadend = thrower();
-        xhr.open('GET', '/foo');
-        _assert.default.strictEqual(xhr.readyState, 1);
-        (0, _assert.default)(xhr.onreadystatechange.calledOnce);
-        xhr.onreadystatechange = thrower('readyStateChange should not happen here');
-        xhr.send();
-        xhr.open('GET', '/foo2');
-        xhr.send();
-        const stateCounts = {
-          '1': 0,
-          '2': 0,
-          '3': 0,
-          '4': 0
-        };
-        xhr.onreadystatechange = function () {
-          stateCounts[xhr.readyState]++;
-        };
-        xhr.onload = function () {
-          _assert.default.deepEqual(stateCounts, {
-            '1': 0,
-            '2': 1,
-            '3': 1,
-            '4': 1
-          });
-          _assert.default.strictEqual(xhr.responseText, 'foo2 response!');
-          done();
-        };
-        xhr.onloadend = _noop.default;
-      });
-    });
-    describe('sync', () => {
-      it('can do synchronous requests', () => {
-        const onloadSpy = _sinon.default.spy();
-        xhr.onload = function () {
-          _assert.default.strictEqual(this, xhr, 'this check');
-          onloadSpy();
-        };
-        xhr.open('GET', '/foo', false);
-        xhr.send();
-        _assert.default.equal(xhr.readyState, 4, 'readyState check');
-        _assert.default.equal(xhr.responseText, 'Response here!', 'response check');
-        (0, _assert.default)(onloadSpy.calledOnce, 'check onload was ran');
-      });
-      it('async arg as undefined counts as false', () => {
-        const onloadSpy = _sinon.default.spy();
-        xhr.onload = function () {
-          _assert.default.strictEqual(this, xhr, 'this check');
-          onloadSpy();
-        };
-        xhr.open('GET', '/foo', undefined);
-        xhr.send();
-        _assert.default.equal(xhr.readyState, 4, 'readyState check');
-        _assert.default.equal(xhr.responseText, 'Response here!', 'response check');
-        (0, _assert.default)(onloadSpy.calledOnce, 'check onload was ran');
-      });
-    });
-    describe('events', () => {
-      it('readystatechange', done => {
-        const step = _lodash.default.after(2, done);
-        function checkEvent(event) {
-          _assert.default.strictEqual(event.target, xhr);
-          step();
-        }
-        xhr.onreadystatechange = function (event) {
-          if (this.readyState == 4) {
-            step();
-          }
-        };
-        xhr.addEventListener('readystatechange', function (event) {
-          if (this.readyState == 4) {
-            step();
-          }
-        });
-        xhr.open('GET', '/foo');
-        xhr.send();
-      });
-      it('load', done => {
-        const step = _lodash.default.after(2, done);
-        function checkEvent(event) {
-          _assert.default.strictEqual(event.target, xhr);
-          _assert.default.strictEqual(typeof event.lengthComputable, 'boolean');
-          _assert.default.strictEqual(typeof event.loaded, 'number');
-          _assert.default.strictEqual(typeof event.total, 'number');
-          step();
-        }
-        xhr.onload = checkEvent;
-        xhr.addEventListener('load', checkEvent);
-        xhr.onerror = thrower();
-        xhr.open('GET', '/foo');
-        xhr.send();
-      });
-      it('loadstart', done => {
-        const step = _lodash.default.after(2, done);
-        function checkEvent(event) {
-          _assert.default.strictEqual(event.target, xhr);
-          _assert.default.strictEqual(event.lengthComputable, false);
-          _assert.default.strictEqual(typeof event.loaded, 'number');
-          _assert.default.strictEqual(typeof event.total, 'number');
-          step();
-        }
-        xhr.onloadstart = checkEvent;
-        xhr.addEventListener('loadstart', checkEvent);
-        xhr.open('GET', '/foo');
-        xhr.send();
-        xhr.abort();
-      });
-      it('loadend', done => {
-        const step = _lodash.default.after(4, done);
-        function checkEvent(event) {
-          _assert.default.strictEqual(event.target, xhr);
-          _assert.default.strictEqual(typeof event.lengthComputable, 'boolean');
-          _assert.default.strictEqual(typeof event.loaded, 'number');
-          _assert.default.strictEqual(typeof event.total, 'number');
-          step();
-        }
-        xhr.onload = checkEvent;
-        xhr.addEventListener('load', checkEvent);
-        xhr.onloadend = checkEvent;
-        xhr.addEventListener('loadend', checkEvent);
-        xhr.open('GET', '/foo');
-        xhr.send();
-      });
-      it('error', done => {
-        const step = _lodash.default.after(4, done);
-        function checkEvent(event) {
-          _assert.default.strictEqual(event.target, xhr);
-          _assert.default.strictEqual(typeof event.lengthComputable, 'boolean');
-          _assert.default.strictEqual(typeof event.loaded, 'number');
-          _assert.default.strictEqual(typeof event.total, 'number');
-          step();
-        }
-        xhr.onload = thrower();
-        xhr.onloadend = step.bind(null, null);
-        xhr.addEventListener('loadend', step.bind(null, null));
-        xhr.onerror = checkEvent;
-        xhr.addEventListener('error', checkEvent);
-        xhr.open('GET', '/non-existent-page');
-        xhr.send();
-      });
-      it('abort', done => {
-        const step = _lodash.default.after(2, done);
-        function checkEvent(event) {
-          _assert.default.strictEqual(event.target, xhr);
-          _assert.default.strictEqual(typeof event.lengthComputable, 'boolean');
-          _assert.default.strictEqual(typeof event.loaded, 'number');
-          _assert.default.strictEqual(typeof event.total, 'number');
-          step();
-        }
-        xhr.onabort = checkEvent;
-        xhr.addEventListener('abort', checkEvent);
-        xhr.open('GET', '/foo');
-        xhr.send();
-        xhr.abort();
-      });
-    });
-    describe('post', () => {
-      it('works', done => {
-        xhr.open('POST', '/foo');
-        xhr.onload = function () {
-          _assert.default.strictEqual(xhr.responseText, 'body received');
-          done();
-        };
-        xhr.send('somedata');
-      });
-      it('works without body', done => {
-        xhr.open('POST', '/foo');
-        xhr.onload = function () {
-          _assert.default.strictEqual(xhr.responseText, 'POST request');
-          done();
-        };
-        xhr.send();
-      });
-    });
-    describe('properties', () => {
-      it('has the necessary constants', () => {
-        _assert.default.strictEqual(XHRConstructor.UNSENT, 0);
-        _assert.default.strictEqual(XHRConstructor.OPENED, 1);
-        _assert.default.strictEqual(XHRConstructor.HEADERS_RECEIVED, 2);
-        _assert.default.strictEqual(XHRConstructor.LOADING, 3);
-        _assert.default.strictEqual(XHRConstructor.DONE, 4);
-        _assert.default.strictEqual(xhr.UNSENT, 0);
-        _assert.default.strictEqual(xhr.OPENED, 1);
-        _assert.default.strictEqual(xhr.HEADERS_RECEIVED, 2);
-        _assert.default.strictEqual(xhr.LOADING, 3);
-        _assert.default.strictEqual(xhr.DONE, 4);
-      });
-    });
-    describe('responseType', () => {
-      it('supports non-text values', done => {
-        xhr.responseType = 'testing';
-        xhr.onreadystatechange = function () {
-          if (this.readyState == 4) {
-            _assert.default.equal(xhr.response, 'testing here!');
-            let rt = '';
-            try {
-              rt = xhr.responseText;
-            } catch (e) {
-              // ignore
-            }
-            _assert.default.strictEqual(rt, '', 'responseText check');
-            done();
-          }
-        };
-        xhr.open('GET', '/foo');
-        xhr.send();
-      });
-      it('supports responseXml', done => {
-        xhr.onload = function () {
-          _assert.default.equal(xhr.responseText, 'testing here!');
-          _assert.default.deepEqual(xhr.responseXML, {
-            fakeXml: true
-          });
-          done();
-        };
-        xhr.open('GET', '/fooXml');
-        xhr.send();
-      });
-    });
-    describe('getResponseHeader', () => {
-      it('should work', done => {
-        xhr.onreadystatechange = function () {
-          if (this.readyState < 2) {
-            _assert.default.strictEqual(xhr.getResponseHeader('X-Test'), null);
-          } else {
-            _assert.default.equal(this.getResponseHeader('X-Test'), 'Header Value');
-          }
-          if (this.readyState == 4) {
-            done();
-          }
-        };
-        _assert.default.strictEqual(xhr.getResponseHeader('X-Test'), null);
-        xhr.open('GET', '/foo');
-        _assert.default.strictEqual(xhr.getResponseHeader('X-Test'), null);
-        xhr.send();
-        _assert.default.strictEqual(xhr.getResponseHeader('X-Test'), null);
-      });
-    });
-    describe('getAllResponseHeaders', () => {
-      it('should work', done => {
-        xhr.onreadystatechange = function () {
-          if (this.readyState < 2) {
-            _assert.default.strictEqual(xhr.getAllResponseHeaders(), null);
-          } else {
-            _assert.default.equal(this.getAllResponseHeaders().trim().toLowerCase(), 'x-test: header value');
-          }
-          if (this.readyState == 4) {
-            done();
-          }
-        };
-        _assert.default.strictEqual(xhr.getAllResponseHeaders(), null);
-        xhr.open('GET', '/foo');
-        _assert.default.strictEqual(xhr.getAllResponseHeaders(), null);
-        xhr.send();
-        _assert.default.strictEqual(xhr.getAllResponseHeaders(), null);
-      });
-    });
-    describe('setRequestHeader', () => {
-      it('should work', done => {
-        xhr.onreadystatechange = function () {
-          if (this.readyState == 4) {
-            _assert.default.equal(this.response, 'header value received');
-            done();
-          }
-        };
-        xhr.open('GET', '/foo');
-        xhr.setRequestHeader('X-Special', 'Value');
-        xhr.send();
-      });
-    });
-    describe('prototype', () => {
-      it('should be present', () => {
-        (0, _assert.default)('prototype' in XHRConstructor);
-        (0, _assert.default)(typeof XHRConstructor.prototype.open === 'function');
-        (0, _assert.default)(typeof XHRConstructor.prototype.send === 'function');
-      });
-    });
-    describe('MailTrack compatibility', () => {
-      // MailTrack redefines js_frame's XMLHttpRequest.prototype.open to do
-      // some stuff, and then looks up the main frame's
-      // XMLHttpRequest.prototype.open and calls it.
-      // This can result in XHRProxy.prototype.open being called with `this`
-      // set to a real XMLHttpRequest object.
-
-      it('works with MailTrack', done => {
-        const realXhr = new XMLHttpRequest();
-        realXhr.onload = () => done();
-        XHRConstructor.prototype.open.call(realXhr, 'GET', '/foo');
-        realXhr.send();
-      });
-    });
-  });
-});
-describe('XHRProxyFactory', () => {
-  describe('wrappers', () => {
-    it('should be used with responseTextChanger present and work on re-used object', done => {
-      let origResponse;
-      let originalSendBodyLoggerRan = 0;
-      let originalResponseTextLoggerRan = 0;
-      let responseTextChangerRan = 0;
-      let finalResponseTextLoggerRan = 0;
-      let firstAfterListenersRan = 0;
-      let rsc4Ran = 0;
-      let runCount = 0;
-      function checkConnectionParam(connection, expectStatus, expectOriginalSendBody) {
-        _assert.default.equal(connection._flag, true, 'connection object check');
-        if (expectStatus) {
-          _assert.default.equal(connection.status, 200, 'status check');
-          _assert.default.equal(connection.responseType, 'text', 'responseType check');
-        }
-        _assert.default.equal(connection.originalSendBody, expectOriginalSendBody ? 'body test' : undefined, 'body check');
-        _assert.default.equal(connection.method, 'GET', 'method check');
-        _assert.default.equal(connection.url, '/foo', 'url check');
-        _assert.default.deepEqual(connection.params, {}, 'params check');
-      }
-      const wrappers = [{
-        isRelevantTo(connection) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          (0, _assert.default)(!connection._flag, 'check that connection object is fresh');
-          connection._flag = true;
-          checkConnectionParam(connection, false, false);
-          return connection.url == '/foo';
-        },
-        originalSendBodyLogger(connection, body) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          checkConnectionParam(connection, false, true);
-          _assert.default.equal(body, 'body test', 'body check');
-          originalSendBodyLoggerRan++;
-        },
-        originalResponseTextLogger(connection, response) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          checkConnectionParam(connection, true, true);
-          originalResponseTextLoggerRan++;
-          origResponse = response;
-        },
-        responseTextChanger(connection, response) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          checkConnectionParam(connection, true, true);
-          responseTextChangerRan++;
-          _assert.default.equal(response, origResponse);
-          return response + '-modified' + runCount;
-        },
-        finalResponseTextLogger(connection, response) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          checkConnectionParam(connection, true, true);
-          finalResponseTextLoggerRan++;
-          _assert.default.equal(response, origResponse + '-modified' + runCount);
-        },
-        afterListeners(connection) {
-          firstAfterListenersRan++;
-        }
-      }, {
-        isRelevantTo(connection) {
-          return true;
-        },
-        originalSendBodyLogger(connection, body) {
-          originalSendBodyLoggerRan++;
-        },
-        originalResponseTextLogger(connection, response) {
-          originalResponseTextLoggerRan++;
-          _assert.default.equal(response, origResponse);
-        },
-        finalResponseTextLogger(connection, response) {
-          finalResponseTextLoggerRan++;
-          _assert.default.equal(response, origResponse + '-modified' + runCount);
-        },
-        afterListeners(connection) {
-          _assert.default.equal(firstAfterListenersRan, 1 * runCount, 'check that afterListeners ran correct number of times');
-          _assert.default.equal(rsc4Ran, 1 * runCount, 'check that readystatechange listener ran correct number of times');
-          if (runCount === 1) {
-            start();
-          } else {
-            done();
-          }
-        }
-      }, {
-        isRelevantTo(connection) {
-          return false;
-        },
-        originalSendBodyLogger(connection, body) {
-          throw new Error('should not run');
-        },
-        originalResponseTextLogger(connection, response) {
-          throw new Error('should not run');
-        },
-        responseTextChanger(connection, response) {
-          throw new Error('should not run');
-        },
-        finalResponseTextLogger(connection, response) {
-          throw new Error('should not run');
-        },
-        afterListeners(connection) {
-          throw new Error('should not run');
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
-      });
-      const xhr = new XHRProxy();
-      xhr.onreadystatechange = function () {
-        if (this.readyState == 3) {
-          _assert.default.equal(this.response, '', 'check response is empty until end when responseTextChanger is used');
-          _assert.default.equal(this.responseText, this.response, 'check responseText');
-        }
-        if (this.readyState == 4) {
-          runCount++;
-          _assert.default.equal(originalSendBodyLoggerRan, 2 * runCount, 'check that originalSendBodyLogger ran correct number of times');
-          _assert.default.equal(originalResponseTextLoggerRan, 2 * runCount, 'check that originalResponseTextLogger ran correct number of times');
-          _assert.default.equal(responseTextChangerRan, 1 * runCount, 'check that responseTextChanger ran correct number of times');
-          _assert.default.equal(finalResponseTextLoggerRan, 2 * runCount, 'check that finalResponseTextLogger ran correct number of times');
-          _assert.default.equal(firstAfterListenersRan, 1 * (runCount - 1), 'check that afterListeners ran correct number of times');
-          _assert.default.equal(this.response, origResponse + '-modified' + (runCount - 1), 'check that response was modified');
-          _assert.default.equal(this.responseText, this.response, 'check responseText');
-          rsc4Ran++;
-          // done is in afterListener wrapper
-        }
-      };
-
-      function start() {
-        xhr.open('GET', '/foo');
-        xhr.send('body test');
-      }
-      start();
-    });
-    it('should be used without responseTextChanger present', done => {
-      let origResponse;
-      let originalResponseTextLoggerRan = 0;
-      let finalResponseTextLoggerRan = 0;
-      const wrappers = [{
-        isRelevantTo(connection) {
-          return true;
-        },
-        originalResponseTextLogger(connection, response) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          originalResponseTextLoggerRan++;
-          origResponse = response;
-        },
-        finalResponseTextLogger(connection, response) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          finalResponseTextLoggerRan++;
-          _assert.default.equal(response, origResponse);
-        }
-      }, {
-        isRelevantTo(connection) {
-          return false;
-        },
-        responseTextChanger(connection, response) {
-          throw new Error('should not run');
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
-      });
-      const xhr = new XHRProxy();
-      xhr.onreadystatechange = function () {
-        _assert.default.equal(this.responseText, this.response, 'check responseText');
-        if (this.readyState == 3) {
-          _assert.default.equal(this.response, 'Response here', 'check response');
-        }
-        if (this.readyState == 4) {
-          _assert.default.equal(this.response, 'Response here!', 'check response');
-          _assert.default.equal(originalResponseTextLoggerRan, 1, 'check that originalResponseTextLogger ran correct number of times');
-          _assert.default.equal(finalResponseTextLoggerRan, 1, 'check that finalResponseTextLogger ran correct number of times');
-          done();
-        }
-      };
-      xhr.open('GET', '/foo');
-      xhr.send();
-    });
-    it('should not have errors prevent event listeners', done => {
-      let loggerRan = 0;
-      const wrappers = [{
-        isRelevantTo(connection) {
-          throw testError;
-        },
-        originalResponseTextLogger(connection, response) {
-          throw new Error('should not run');
-        }
-      }, {
-        isRelevantTo(connection) {
-          return true;
-        },
-        originalSendBodyLogger(connection, body) {
-          throw testError;
-        },
-        requestChanger(connection, body) {
-          throw testError;
-        },
-        originalResponseTextLogger(connection, response) {
-          loggerRan++;
-          throw testError;
-        },
-        responseTextChanger(connection, response) {
-          throw testError;
-        },
-        finalResponseTextLogger(connection, response) {
-          throw testError;
-        }
-      }, {
-        isRelevantTo(connection) {
-          return true;
-        },
-        originalSendBodyLogger(connection, body) {
-          throw testError;
-        },
-        originalResponseTextLogger(connection, response) {
-          throw testError;
-        },
-        finalResponseTextLogger(connection, response) {
-          throw testError;
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
-      });
-      const xhr = new XHRProxy();
-      xhr.onreadystatechange = function () {
-        if (this.readyState == 4) {
-          _assert.default.equal(logErrorTestCalls, 9, 'check that logError was called correct number of times');
-          _assert.default.equal(loggerRan, 1, 'check that originalResponseTextLogger was attempted');
-          _assert.default.equal(this.response, 'Response here!', 'check response');
-          done();
-        }
-      };
-      xhr.open('GET', '/foo');
-      xhr.send();
-    });
-    it('can have wrappers changed after construction', done => {
-      const wrappers = [{
-        isRelevantTo(connection) {
-          throw new Error('should not run');
-        },
-        originalResponseTextLogger(connection, response) {
-          throw new Error('should not run');
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
-      });
-      let loggerRan = 0;
-      wrappers.length = 0;
-      wrappers.push({
-        isRelevantTo(connection) {
-          return true;
-        },
-        originalResponseTextLogger(connection, response) {
-          loggerRan++;
-        }
-      });
-      const xhr = new XHRProxy();
-      xhr.onreadystatechange = function () {
-        if (this.readyState == 4) {
-          _assert.default.equal(loggerRan, 1, 'check that originalResponseTextLogger has run');
-          done();
-        }
-      };
-      xhr.open('GET', '/foo');
-      xhr.send();
-    });
-    it('should support promises for responseTextChanger', done => {
-      let origResponse;
-      let responseTextChangerRan = 0;
-      let finalResponseTextLoggerRan = 0;
-      function checkConnectionParam(connection) {
-        _assert.default.equal(connection._flag, true, 'connection object check');
-      }
-      const wrappers = [{
-        isRelevantTo(connection) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          connection._flag = true;
-          checkConnectionParam(connection);
-          return connection.url == '/foo';
-        },
-        originalResponseTextLogger(connection, response) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          checkConnectionParam(connection);
-          origResponse = response;
-        },
-        async responseTextChanger(connection, response) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          await (0, _pdelay.default)(1);
-          checkConnectionParam(connection);
-          responseTextChangerRan++;
-          _assert.default.equal(response, origResponse);
-          _assert.default.equal(xhr.readyState, 3, 'check that readyState is still LOADING');
-          return response + '-modified';
-        },
-        finalResponseTextLogger(connection, response) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          checkConnectionParam(connection);
-          finalResponseTextLoggerRan++;
-          _assert.default.equal(response, origResponse + '-modified');
-        }
-      }, {
-        isRelevantTo(connection) {
-          return true;
-        },
-        finalResponseTextLogger(connection, response) {
-          finalResponseTextLoggerRan++;
-          _assert.default.equal(response, origResponse + '-modified');
-        }
-      }, {
-        isRelevantTo(connection) {
-          return false;
-        },
-        requestChanger() {
-          throw new Error('should not run');
-        },
-        responseTextChanger(connection, response) {
-          throw new Error('should not run');
-        },
-        finalResponseTextLogger(connection, response) {
-          throw new Error('should not run');
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
-      });
-      const xhr = new XHRProxy();
-      let methodCalled = false,
-        addedListenerCalled = false;
-      const finishRsc = _lodash.default.after(2, () => {
-        (0, _assert.default)(methodCalled, 'check that onreadystatechange method was called');
-        (0, _assert.default)(addedListenerCalled, 'check that added listener was called');
-        _assert.default.equal(responseTextChangerRan, 1, 'check that responseTextChanger ran correct number of times');
-        _assert.default.equal(finalResponseTextLoggerRan, 2, 'check that finalResponseTextLogger ran correct number of times');
-        done();
-      });
-      xhr.onreadystatechange = function () {
-        _assert.default.equal(this.responseText, this.response, 'check responseText');
-        if (this.readyState == 4) {
-          _assert.default.equal(this.response, origResponse + '-modified', 'check that response was modified');
-          methodCalled = true;
-          finishRsc();
-        }
-      };
-      xhr.addEventListener('readystatechange', function () {
-        if (this.readyState == 4) {
-          _assert.default.equal(this.response, origResponse + '-modified', 'check that response was modified');
-          addedListenerCalled = true;
-          finishRsc();
-        }
-      });
-      xhr.open('GET', '/foo');
-      xhr.send();
-    });
-    it('should have responseTextChanger promises respect abort', done => {
-      const wrappers = [{
-        isRelevantTo(connection) {
-          return connection.url == '/foo';
-        },
-        async responseTextChanger(connection, response) {
-          // start a new request, aborting the current one, so that the result
-          // of this responseTextChanger never gets seen.
-          xhr.open('GET', '/foo2');
-          xhr.send();
-          await (0, _pdelay.default)(1);
-          return response + '-modified';
-        },
-        finalResponseTextLogger(connection, response) {
-          throw new Error('should not run');
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
-      });
-      const xhr = new XHRProxy();
-      xhr.addEventListener('readystatechange', function () {
-        if (this.readyState == 4) {
-          _assert.default.equal(this.responseText, 'foo2 response!');
-          done();
-        }
-      });
-      xhr.open('GET', '/foo');
-      xhr.send();
-    });
-    it('supports multiple responseTextChanger wrappers', done => {
-      const wrappers = [{
-        isRelevantTo: () => true,
-        responseTextChanger(connection, response) {
-          _assert.default.strictEqual(connection.originalResponseText, 'foo2 response!');
-          _assert.default.strictEqual(connection.modifiedResponseText, 'foo2 response!');
-          _assert.default.strictEqual(connection.modifiedResponseText, response);
-          return response + 'a';
-        }
-      }, {
-        isRelevantTo: () => true,
-        responseTextChanger(connection, response) {
-          _assert.default.strictEqual(connection.originalResponseText, 'foo2 response!');
-          _assert.default.strictEqual(connection.modifiedResponseText, 'foo2 response!a');
-          _assert.default.strictEqual(connection.modifiedResponseText, response);
-          return response + 'b';
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
-      });
-      const xhr = new XHRProxy();
-      xhr.onload = function () {
-        _assert.default.strictEqual(this.responseText, 'foo2 response!ab');
-        done();
-      };
-      xhr.open('GET', '/foo2');
-      xhr.send();
-    });
-    it('should ignore invalid responseTextChanger return value', done => {
-      const logErrorSpy = _sinon.default.spy();
-      const wrappers = [{
-        isRelevantTo: () => true,
-        responseTextChanger(connection, response) {
-          return null;
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logErrorSpy
-      });
-      const xhr = new XHRProxy();
-      xhr.onload = function () {
-        _assert.default.strictEqual(this.responseText, 'foo2 response!');
-        (0, _assert.default)(logErrorSpy.calledOnce);
-        done();
-      };
-      xhr.open('GET', '/foo2');
-      xhr.send();
-    });
-    it('requestChanger should work', done => {
-      const wrappers = [{
-        isRelevantTo: () => true,
-        requestChanger(connection, request) {
-          return Promise.resolve({
-            method: request.method + 'a',
-            url: request.url + 'A',
-            body: request.body + '1'
-          });
-        }
-      }, {
-        isRelevantTo: () => true,
-        requestChanger(connection, request) {
-          return {
-            method: request.method + 'b',
-            url: request.url + 'B',
-            body: request.body + '2'
-          };
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
-      });
-      const xhr = new XHRProxy();
-      xhr.onload = function () {
-        _assert.default.strictEqual(this.responseText, 'fooAB requested, data12 received');
-        done();
-      };
-      xhr.onerror = done;
-      xhr.open('GET', '/foo');
-      xhr.send('data');
-    });
-    it('requestChanger should check returned value for sanity', done => {
-      const logErrorSpy = _sinon.default.spy();
-      const wrappers = [{
-        isRelevantTo: () => true,
-        requestChanger(connection, request) {
-          return Promise.resolve({
-            method: request.method + 'a',
-            url: request.url + 'A',
-            _MISSPELL_body: request.body + '1'
-          });
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logErrorSpy
-      });
-      const xhr = new XHRProxy();
-      xhr.onload = function () {
-        _assert.default.strictEqual(this.responseText, 'body received');
-        (0, _assert.default)(logErrorSpy.calledOnce);
-        done();
-      };
-      xhr.onerror = thrower('xhr error');
-      xhr.open('POST', '/foo');
-      xhr.send('somedata');
-    });
-  });
-});