@inboxsdk/core 0.2.28-alpha.6 → 0.2.28

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

@@ -1,15 +1,15 @@
-"use strict";
+/* @flow */
+
+import assert from 'assert';
+import _ from 'lodash';
+import noop from 'lodash/noop';
+import sinon from 'sinon';
+import delay from 'pdelay';
+import MockServer from '../../test/lib/MockServer';
 
-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++;
@@ -18,6 +18,7 @@ function logError(error, label) {
     throw error || new Error(label);
   }
 }
+
 function thrower(err) {
   return function () {
     if (typeof err == 'string') {
@@ -29,539 +30,550 @@ function thrower(err) {
     }
   };
 }
-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
+
+import XHRProxyFactory from './xhr-proxy-factory';
+
+const server = new MockServer();
+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: 'GETab',
-  path: '/fooAB'
-}, {
-  status: 200,
-  response: 'fooAB requested, data12 received'
-});
+);
+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 = {
+
+const constructors: { [name: string]: typeof XMLHttpRequest } = {
   XMLHttpRequest: XMLHttpRequest,
-  XHRProxy: (0, _xhrProxyFactory.default)(XMLHttpRequest, [], {
-    logError: logError
-  })
+  XHRProxy: XHRProxyFactory(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
+
+constructors['XHRProxy²'] = XHRProxyFactory(constructors.XHRProxy, [], {
+  logError: logError,
 });
+constructors['XHRProxy with changers'] = XHRProxyFactory(
+  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 = '';
+['XMLHttpRequest', 'XHRProxy', 'XHRProxy²', 'XHRProxy with changers'].forEach(
+  (XHRName) => {
+    describe(XHRName, () => {
+      let XHRConstructor: typeof XMLHttpRequest;
+      let xhr: XMLHttpRequest;
+      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: Object) {
+              assert.strictEqual(this, xhr, 'check for correct this binding');
+              assert.strictEqual(
+                event.target,
+                this,
+                'check for correct event target'
+              );
+              calledForState[this.readyState]++;
+
+              if (this.readyState >= 2) {
+                assert.equal(this.status, 200, 'check http status');
               }
-              _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, '');
+              if (this.readyState >= 3) {
+                assert.equal(
+                  this.responseText,
+                  this.response,
+                  'check responseText'
+                );
               } else {
-                _assert.default.strictEqual(this.response, 'Response here');
+                let responseText;
+                try {
+                  responseText = this.responseText;
+                } catch (e) {
+                  responseText = '';
+                }
+                assert.strictEqual(responseText, '');
+              }
+              if (this.readyState == 3) {
+                if (XHRName === 'XHRProxy with changers') {
+                  // No progress text should be given when a responseTextChanger is in use.
+                  assert.strictEqual(this.response, '');
+                } else {
+                  assert.strictEqual(this.response, 'Response here');
+                }
+              }
+              if (this.readyState == 4) {
+                runCount++;
+                assert.equal(this.response, 'Response here!');
+                assert.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.equal(xhr.readyState, 1, 'readyState check');
+              xhr.send();
+            }
+            assert.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: Object) {
+            addedFired = true;
+          });
+          xhr.addEventListener('readystatechange', function (event: Object) {
+            if (this.readyState == 4) {
+              assert(
+                simpleFired && addedFired,
+                'check that both listeners fired'
+              );
+              done();
+            }
+          });
+          xhr.open('GET', '/foo');
+          xhr.send();
+        });
+      });
+
+      describe('removeEventListener', () => {
+        it('should work', (done) => {
+          const badListener = function (event: Object) {
+            throw new Error('this listener should have been removed');
+          };
+          xhr.addEventListener('readystatechange', badListener);
+          xhr.addEventListener('readystatechange', function (event: Object) {
+            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) {
-              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();
+              if (finishCount++ === 0) {
+                assert.equal(
+                  this.responseText,
+                  'Response here',
+                  'response check'
+                );
+                xhr.open('GET', '/foo2');
+                xhr.send();
               } else {
+                assert.equal(
+                  this.responseText,
+                  'foo2 response!',
+                  'response check'
+                );
                 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();
+          xhr.open('GET', '/foo');
+          xhr.send();
+          xhr.abort();
         });
       });
-    });
-    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');
+
+      describe('open', () => {
+        it('should cancel active request but without abort event', (done) => {
+          xhr.onreadystatechange = sinon.spy();
+          xhr.onabort = xhr.onerror = xhr.onload = xhr.onloadend = thrower();
+          xhr.open('GET', '/foo');
+          assert.strictEqual(xhr.readyState, 1);
+          assert(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.deepEqual(stateCounts, { '1': 0, '2': 1, '3': 1, '4': 1 });
+            assert.strictEqual(xhr.responseText, 'foo2 response!');
             done();
-          }
+          };
+          xhr.onloadend = noop;
         });
-        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();
-          }
+
+      describe('sync', () => {
+        it('can do synchronous requests', () => {
+          const onloadSpy = sinon.spy();
+          xhr.onload = function () {
+            assert.strictEqual(this, xhr, 'this check');
+            onloadSpy();
+          };
+          xhr.open('GET', '/foo', false);
+          xhr.send();
+          assert.equal(xhr.readyState, 4, 'readyState check');
+          assert.equal(xhr.responseText, 'Response here!', 'response check');
+          assert(onloadSpy.calledOnce, 'check onload was ran');
+        });
+
+        it('async arg as undefined counts as false', () => {
+          const onloadSpy = sinon.spy();
+          xhr.onload = function () {
+            assert.strictEqual(this, xhr, 'this check');
+            onloadSpy();
+          };
+          xhr.open('GET', '/foo', undefined);
+          xhr.send();
+          assert.equal(xhr.readyState, 4, 'readyState check');
+          assert.equal(xhr.responseText, 'Response here!', 'response check');
+          assert(onloadSpy.calledOnce, 'check onload was ran');
         });
-        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();
-            }
+
+      describe('events', () => {
+        it('readystatechange', (done) => {
+          const step = _.after(2, done);
+          function checkEvent(event: Event) {
+            assert.strictEqual(event.target, xhr);
+            step();
           }
-        };
-        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
+          xhr.onreadystatechange = function (event) {
+            if (this.readyState == 4) {
+              step();
+            }
+          };
+          xhr.addEventListener('readystatechange', function (event: Object) {
+            if (this.readyState == 4) {
+              step();
+            }
           });
-          _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) {
+          xhr.open('GET', '/foo');
+          xhr.send();
+        });
+
+        it('load', (done) => {
+          const step = _.after(2, done);
+          function checkEvent(event: Object) {
+            assert.strictEqual(event.target, xhr);
+            assert.strictEqual(typeof event.lengthComputable, 'boolean');
+            assert.strictEqual(typeof event.loaded, 'number');
+            assert.strictEqual(typeof event.total, 'number');
             step();
           }
-        };
-        xhr.addEventListener('readystatechange', function (event) {
-          if (this.readyState == 4) {
+          xhr.onload = checkEvent;
+          xhr.addEventListener('load', checkEvent);
+          xhr.onerror = thrower();
+          xhr.open('GET', '/foo');
+          xhr.send();
+        });
+
+        it('loadstart', (done) => {
+          const step = _.after(2, done);
+          function checkEvent(event: Object) {
+            assert.strictEqual(event.target, xhr);
+            assert.strictEqual(event.lengthComputable, false);
+            assert.strictEqual(typeof event.loaded, 'number');
+            assert.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 = _.after(4, done);
+          function checkEvent(event: Object) {
+            assert.strictEqual(event.target, xhr);
+            assert.strictEqual(typeof event.lengthComputable, 'boolean');
+            assert.strictEqual(typeof event.loaded, 'number');
+            assert.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 = _.after(4, done);
+          function checkEvent(event: Object) {
+            assert.strictEqual(event.target, xhr);
+            assert.strictEqual(typeof event.lengthComputable, 'boolean');
+            assert.strictEqual(typeof event.loaded, 'number');
+            assert.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 = _.after(2, done);
+          function checkEvent(event: Object) {
+            assert.strictEqual(event.target, xhr);
+            assert.strictEqual(typeof event.lengthComputable, 'boolean');
+            assert.strictEqual(typeof event.loaded, 'number');
+            assert.strictEqual(typeof event.total, 'number');
+            step();
+          }
+          xhr.onabort = checkEvent;
+          xhr.addEventListener('abort', checkEvent);
+          xhr.open('GET', '/foo');
+          xhr.send();
+          xhr.abort();
         });
-        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('post', () => {
+        it('works', (done) => {
+          xhr.open('POST', '/foo');
+          xhr.onload = function () {
+            assert.strictEqual(xhr.responseText, 'body received');
+            done();
+          };
+          xhr.send('somedata');
+        });
+
+        it('works without body', (done) => {
+          xhr.open('POST', '/foo');
+          xhr.onload = function () {
+            assert.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('properties', () => {
+        it('has the necessary constants', () => {
+          assert.strictEqual((XHRConstructor: any).UNSENT, 0);
+          assert.strictEqual((XHRConstructor: any).OPENED, 1);
+          assert.strictEqual((XHRConstructor: any).HEADERS_RECEIVED, 2);
+          assert.strictEqual((XHRConstructor: any).LOADING, 3);
+          assert.strictEqual((XHRConstructor: any).DONE, 4);
+
+          assert.strictEqual((xhr: any).UNSENT, 0);
+          assert.strictEqual((xhr: any).OPENED, 1);
+          assert.strictEqual((xhr: any).HEADERS_RECEIVED, 2);
+          assert.strictEqual((xhr: any).LOADING, 3);
+          assert.strictEqual((xhr: any).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
+
+      describe('responseType', () => {
+        it('supports non-text values', (done) => {
+          xhr.responseType = 'testing';
+          xhr.onreadystatechange = function () {
+            if (this.readyState == 4) {
+              assert.equal(xhr.response, 'testing here!');
+              let rt = '';
+              try {
+                rt = xhr.responseText;
+              } catch (e) {
+                // ignore
+              }
+              assert.strictEqual(rt, '', 'responseText check');
+              done();
             }
-            _assert.default.strictEqual(rt, '', 'responseText check');
+          };
+          xhr.open('GET', '/foo');
+          xhr.send();
+        });
+
+        it('supports responseXml', (done) => {
+          xhr.onload = function () {
+            assert.equal(xhr.responseText, 'testing here!');
+            assert.deepEqual(xhr.responseXML, { fakeXml: true });
             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();
+          };
+          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('getResponseHeader', () => {
+        it('should work', (done) => {
+          xhr.onreadystatechange = function () {
+            if (this.readyState < 2) {
+              assert.strictEqual(xhr.getResponseHeader('X-Test'), null);
+            } else {
+              assert.equal(this.getResponseHeader('X-Test'), 'Header Value');
+            }
+            if (this.readyState == 4) {
+              done();
+            }
+          };
+          assert.strictEqual(xhr.getResponseHeader('X-Test'), null);
+          xhr.open('GET', '/foo');
+          assert.strictEqual(xhr.getResponseHeader('X-Test'), null);
+          xhr.send();
+          assert.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('getAllResponseHeaders', () => {
+        it('should work', (done) => {
+          xhr.onreadystatechange = function () {
+            if (this.readyState < 2) {
+              assert.strictEqual(xhr.getAllResponseHeaders(), null);
+            } else {
+              assert.equal(
+                this.getAllResponseHeaders().trim().toLowerCase(),
+                'x-test: header value'
+              );
+            }
+            if (this.readyState == 4) {
+              done();
+            }
+          };
+          assert.strictEqual(xhr.getAllResponseHeaders(), null);
+          xhr.open('GET', '/foo');
+          assert.strictEqual(xhr.getAllResponseHeaders(), null);
+          xhr.send();
+          assert.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('setRequestHeader', () => {
+        it('should work', (done) => {
+          xhr.onreadystatechange = function () {
+            if (this.readyState == 4) {
+              assert.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('prototype', () => {
+        it('should be present', () => {
+          assert('prototype' in XHRConstructor);
+          assert(typeof XHRConstructor.prototype.open === 'function');
+          assert(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('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 => {
+    it('should be used with responseTextChanger present and work on re-used object', (done) => {
       let origResponse;
       let originalSendBodyLoggerRan = 0;
       let originalResponseTextLoggerRan = 0;
@@ -570,241 +582,325 @@ describe('XHRProxyFactory', () => {
       let firstAfterListenersRan = 0;
       let rsc4Ran = 0;
       let runCount = 0;
-      function checkConnectionParam(connection, expectStatus, expectOriginalSendBody) {
-        _assert.default.equal(connection._flag, true, 'connection object check');
+      function checkConnectionParam(
+        connection,
+        expectStatus,
+        expectOriginalSendBody
+      ) {
+        assert.equal((connection: any)._flag, true, 'connection object check');
         if (expectStatus) {
-          _assert.default.equal(connection.status, 200, 'status check');
-          _assert.default.equal(connection.responseType, 'text', 'responseType check');
+          assert.equal((connection: any).status, 200, 'status check');
+          assert.equal(
+            (connection: any).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');
+        assert.equal(
+          connection.originalSendBody,
+          expectOriginalSendBody ? 'body test' : undefined,
+          'body check'
+        );
+        assert.equal(connection.method, 'GET', 'method check');
+        assert.equal(connection.url, '/foo', 'url check');
+        assert.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++;
+      const wrappers = [
+        {
+          isRelevantTo(connection) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            assert(
+              !(connection: any)._flag,
+              'check that connection object is fresh'
+            );
+            (connection: any)._flag = true;
+            checkConnectionParam(connection, false, false);
+            return connection.url == '/foo';
+          },
+          originalSendBodyLogger(connection, body) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            checkConnectionParam(connection, false, true);
+            assert.equal(body, 'body test', 'body check');
+            originalSendBodyLoggerRan++;
+          },
+          originalResponseTextLogger(connection, response) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            checkConnectionParam(connection, true, true);
+            originalResponseTextLoggerRan++;
+            origResponse = response;
+          },
+          responseTextChanger(connection, response) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            checkConnectionParam(connection, true, true);
+            responseTextChangerRan++;
+            assert.equal(response, origResponse);
+            return response + '-modified' + runCount;
+          },
+          finalResponseTextLogger(connection, response) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            checkConnectionParam(connection, true, true);
+            finalResponseTextLoggerRan++;
+            assert.equal(response, origResponse + '-modified' + runCount);
+          },
+          afterListeners(connection) {
+            firstAfterListenersRan++;
+          },
         },
-        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');
+        {
+          isRelevantTo(connection) {
+            return true;
+          },
+          originalSendBodyLogger(connection, body) {
+            originalSendBodyLoggerRan++;
+          },
+          originalResponseTextLogger(connection, response) {
+            originalResponseTextLoggerRan++;
+            assert.equal(response, origResponse);
+          },
+          finalResponseTextLogger(connection, response) {
+            finalResponseTextLoggerRan++;
+            assert.equal(response, origResponse + '-modified' + runCount);
+          },
+          afterListeners(connection) {
+            assert.equal(
+              firstAfterListenersRan,
+              1 * runCount,
+              'check that afterListeners ran correct number of times'
+            );
+            assert.equal(
+              rsc4Ran,
+              1 * runCount,
+              'check that readystatechange listener ran correct number of times'
+            );
+            if (runCount === 1) {
+              start();
+            } else {
+              done();
+            }
+          },
         },
-        finalResponseTextLogger(connection, response) {
-          throw new Error('should not run');
+        {
+          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');
+          },
         },
-        afterListeners(connection) {
-          throw new Error('should not run');
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
+      ];
+      const XHRProxy = XHRProxyFactory(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');
+          assert.equal(
+            this.response,
+            '',
+            'check response is empty until end when responseTextChanger is used'
+          );
+          assert.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');
+          assert.equal(
+            originalSendBodyLoggerRan,
+            2 * runCount,
+            'check that originalSendBodyLogger ran correct number of times'
+          );
+          assert.equal(
+            originalResponseTextLoggerRan,
+            2 * runCount,
+            'check that originalResponseTextLogger ran correct number of times'
+          );
+          assert.equal(
+            responseTextChangerRan,
+            1 * runCount,
+            'check that responseTextChanger ran correct number of times'
+          );
+          assert.equal(
+            finalResponseTextLoggerRan,
+            2 * runCount,
+            'check that finalResponseTextLogger ran correct number of times'
+          );
+          assert.equal(
+            firstAfterListenersRan,
+            1 * (runCount - 1),
+            'check that afterListeners ran correct number of times'
+          );
+          assert.equal(
+            this.response,
+            origResponse + '-modified' + (runCount - 1),
+            'check that response was modified'
+          );
+          assert.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 => {
+
+    it('should be used without responseTextChanger present', (done) => {
       let origResponse;
       let originalResponseTextLoggerRan = 0;
       let finalResponseTextLoggerRan = 0;
-      const wrappers = [{
-        isRelevantTo(connection) {
-          return true;
+      const wrappers = [
+        {
+          isRelevantTo(connection) {
+            return true;
+          },
+          originalResponseTextLogger(connection, response) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            originalResponseTextLoggerRan++;
+            origResponse = response;
+          },
+          finalResponseTextLogger(connection, response) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            finalResponseTextLoggerRan++;
+            assert.equal(response, origResponse);
+          },
         },
-        originalResponseTextLogger(connection, response) {
-          _assert.default.strictEqual(this, wrappers[0], 'this check');
-          originalResponseTextLoggerRan++;
-          origResponse = response;
+        {
+          isRelevantTo(connection) {
+            return false;
+          },
+          responseTextChanger(connection, response) {
+            throw new Error('should not run');
+          },
         },
-        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 XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
+        logError: logError,
       });
       const xhr = new XHRProxy();
       xhr.onreadystatechange = function () {
-        _assert.default.equal(this.responseText, this.response, 'check responseText');
+        assert.equal(this.responseText, this.response, 'check responseText');
         if (this.readyState == 3) {
-          _assert.default.equal(this.response, 'Response here', 'check response');
+          assert.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');
+          assert.equal(this.response, 'Response here!', 'check response');
+          assert.equal(
+            originalResponseTextLoggerRan,
+            1,
+            'check that originalResponseTextLogger ran correct number of times'
+          );
+          assert.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 => {
+
+    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;
+      const wrappers = [
+        {
+          isRelevantTo(connection) {
+            throw testError;
+          },
+          originalResponseTextLogger(connection, response) {
+            throw new Error('should not run');
+          },
         },
-        originalSendBodyLogger(connection, body) {
-          throw testError;
+        {
+          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;
+          },
         },
-        requestChanger(connection, body) {
-          throw testError;
+        {
+          isRelevantTo(connection) {
+            return true;
+          },
+          originalSendBodyLogger(connection, body) {
+            throw testError;
+          },
+          originalResponseTextLogger(connection, response) {
+            throw testError;
+          },
+          finalResponseTextLogger(connection, response) {
+            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 XHRProxy = XHRProxyFactory(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');
+          assert.equal(
+            logErrorTestCalls,
+            9,
+            'check that logError was called correct number of times'
+          );
+          assert.equal(
+            loggerRan,
+            1,
+            'check that originalResponseTextLogger was attempted'
+          );
+          assert.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');
+
+    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');
+          },
         },
-        originalResponseTextLogger(connection, response) {
-          throw new Error('should not run');
-        }
-      }];
-      const XHRProxy = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
-        logError: logError
+      ];
+
+      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
+        logError: logError,
       });
+
       let loggerRan = 0;
       wrappers.length = 0;
       wrappers.push({
@@ -813,98 +909,130 @@ describe('XHRProxyFactory', () => {
         },
         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');
+          assert.equal(
+            loggerRan,
+            1,
+            'check that originalResponseTextLogger has run'
+          );
           done();
         }
       };
       xhr.open('GET', '/foo');
       xhr.send();
     });
-    it('should support promises for responseTextChanger', done => {
+
+    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');
+        assert.equal((connection: any)._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';
+      const wrappers = [
+        {
+          isRelevantTo(connection) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            (connection: any)._flag = true;
+            checkConnectionParam(connection);
+            return connection.url == '/foo';
+          },
+          originalResponseTextLogger(connection, response) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            checkConnectionParam(connection);
+            origResponse = response;
+          },
+          async responseTextChanger(connection, response) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            await delay(1);
+            checkConnectionParam(connection);
+            responseTextChangerRan++;
+            assert.equal(response, origResponse);
+            assert.equal(
+              xhr.readyState,
+              3,
+              'check that readyState is still LOADING'
+            );
+            return response + '-modified';
+          },
+          finalResponseTextLogger(connection, response) {
+            assert.strictEqual(this, wrappers[0], 'this check');
+            checkConnectionParam(connection);
+            finalResponseTextLoggerRan++;
+            assert.equal(response, origResponse + '-modified');
+          },
         },
-        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';
+        {
+          isRelevantTo(connection) {
+            return true;
+          },
+          finalResponseTextLogger(connection, response) {
+            finalResponseTextLoggerRan++;
+            assert.equal(response, origResponse + '-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;
+        {
+          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');
+          },
         },
-        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 XHRProxy = XHRProxyFactory(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');
+      const finishRsc = _.after(2, () => {
+        assert(methodCalled, 'check that onreadystatechange method was called');
+        assert(addedListenerCalled, 'check that added listener was called');
+        assert.equal(
+          responseTextChangerRan,
+          1,
+          'check that responseTextChanger ran correct number of times'
+        );
+        assert.equal(
+          finalResponseTextLoggerRan,
+          2,
+          'check that finalResponseTextLogger ran correct number of times'
+        );
         done();
       });
+
       xhr.onreadystatechange = function () {
-        _assert.default.equal(this.responseText, this.response, 'check responseText');
+        assert.equal(this.responseText, this.response, 'check responseText');
         if (this.readyState == 4) {
-          _assert.default.equal(this.response, origResponse + '-modified', 'check that response was modified');
+          assert.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');
+          assert.equal(
+            this.response,
+            origResponse + '-modified',
+            'check that response was modified'
+          );
           addedListenerCalled = true;
           finishRsc();
         }
@@ -912,136 +1040,175 @@ describe('XHRProxyFactory', () => {
       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';
+
+    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 delay(1);
+
+            return response + '-modified';
+          },
+          finalResponseTextLogger(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 XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
+        logError: logError,
       });
       const xhr = new XHRProxy();
+
       xhr.addEventListener('readystatechange', function () {
         if (this.readyState == 4) {
-          _assert.default.equal(this.responseText, 'foo2 response!');
+          assert.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
+
+    it('supports multiple responseTextChanger wrappers', (done) => {
+      const wrappers = [
+        {
+          isRelevantTo: () => true,
+          responseTextChanger(connection, response) {
+            assert.strictEqual(
+              connection.originalResponseText,
+              'foo2 response!'
+            );
+            assert.strictEqual(
+              connection.modifiedResponseText,
+              'foo2 response!'
+            );
+            assert.strictEqual(connection.modifiedResponseText, response);
+            return response + 'a';
+          },
+        },
+        {
+          isRelevantTo: () => true,
+          responseTextChanger(connection, response) {
+            assert.strictEqual(
+              connection.originalResponseText,
+              'foo2 response!'
+            );
+            assert.strictEqual(
+              connection.modifiedResponseText,
+              'foo2 response!a'
+            );
+            assert.strictEqual(connection.modifiedResponseText, response);
+            return response + 'b';
+          },
+        },
+      ];
+      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
+        logError: logError,
       });
       const xhr = new XHRProxy();
+
       xhr.onload = function () {
-        _assert.default.strictEqual(this.responseText, 'foo2 response!ab');
+        assert.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
+
+    it('should ignore invalid responseTextChanger return value', (done) => {
+      const logErrorSpy = sinon.spy();
+      const wrappers = [
+        {
+          isRelevantTo: () => true,
+          responseTextChanger(connection, response) {
+            return (null: any);
+          },
+        },
+      ];
+      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
+        logError: logErrorSpy,
       });
       const xhr = new XHRProxy();
+
       xhr.onload = function () {
-        _assert.default.strictEqual(this.responseText, 'foo2 response!');
-        (0, _assert.default)(logErrorSpy.calledOnce);
+        assert.strictEqual(this.responseText, 'foo2 response!');
+        assert(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
+
+    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 = XHRProxyFactory(XMLHttpRequest, wrappers, {
+        logError: logError,
       });
       const xhr = new XHRProxy();
+
       xhr.onload = function () {
-        _assert.default.strictEqual(this.responseText, 'fooAB requested, data12 received');
+        assert.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
+
+    it('requestChanger should check returned value for sanity', (done) => {
+      const logErrorSpy = sinon.spy();
+      const wrappers = [
+        {
+          isRelevantTo: () => true,
+          requestChanger(connection, request): any {
+            return Promise.resolve({
+              method: request.method + 'a',
+              url: request.url + 'A',
+              _MISSPELL_body: request.body + '1',
+            });
+          },
+        },
+      ];
+      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
+        logError: logErrorSpy,
       });
       const xhr = new XHRProxy();
+
       xhr.onload = function () {
-        _assert.default.strictEqual(this.responseText, 'body received');
-        (0, _assert.default)(logErrorSpy.calledOnce);
+        assert.strictEqual(this.responseText, 'body received');
+        assert(logErrorSpy.calledOnce);
         done();
       };
       xhr.onerror = thrower('xhr error');
@@ -1049,4 +1216,4 @@ describe('XHRProxyFactory', () => {
       xhr.send('somedata');
     });
   });
-});
+});