@inboxsdk/core 0.2.28-alpha.4 → 0.2.28-alpha.5

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

@@ -1,15 +1,15 @@
-/* @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';
+"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++;
@@ -18,7 +18,6 @@ function logError(error, label) {
     throw error || new Error(label);
   }
 }
-
 function thrower(err) {
   return function () {
     if (typeof err == 'string') {
@@ -30,550 +29,539 @@ function thrower(err) {
     }
   };
 }
-
-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' },
+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: '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' }
-);
+});
+server.respondWith({
+  method: 'GETab',
+  path: '/fooAB'
+}, {
+  status: 200,
+  response: 'fooAB requested, data12 received'
+});
 const XMLHttpRequest = server.XMLHttpRequest;
-
-const constructors: { [name: string]: typeof XMLHttpRequest } = {
+const constructors = {
   XMLHttpRequest: XMLHttpRequest,
-  XHRProxy: XHRProxyFactory(XMLHttpRequest, [], { logError: logError }),
+  XHRProxy: (0, _xhrProxyFactory.default)(XMLHttpRequest, [], {
+    logError: logError
+  })
 };
-
-constructors['XHRProxy²'] = XHRProxyFactory(constructors.XHRProxy, [], {
-  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 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: 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');
+['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 = '';
               }
-              if (this.readyState >= 3) {
-                assert.equal(
-                  this.responseText,
-                  this.response,
-                  'check 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 {
-                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();
-                }
+                _assert.default.strictEqual(this.response, 'Response here');
               }
-            };
-            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) {
-              if (finishCount++ === 0) {
-                assert.equal(
-                  this.responseText,
-                  'Response here',
-                  'response check'
-                );
-                xhr.open('GET', '/foo2');
-                xhr.send();
+              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 {
-                assert.equal(
-                  this.responseText,
-                  'foo2 response!',
-                  'response check'
-                );
                 done();
               }
             }
           };
-          xhr.open('GET', '/foo');
-          xhr.send();
-          xhr.abort();
+          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('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!');
+    });
+    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.onloadend = noop;
+          }
         });
+        xhr.open('GET', '/foo');
+        xhr.send();
       });
-
-      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');
+    });
+    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('events', () => {
-        it('readystatechange', (done) => {
-          const step = _.after(2, done);
-          function checkEvent(event: Event) {
-            assert.strictEqual(event.target, xhr);
-            step();
-          }
-          xhr.onreadystatechange = function (event) {
-            if (this.readyState == 4) {
-              step();
-            }
-          };
-          xhr.addEventListener('readystatechange', function (event: Object) {
-            if (this.readyState == 4) {
-              step();
+    });
+    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();
-        });
-
-        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.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');
+        };
+        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.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');
+        };
+        xhr.addEventListener('readystatechange', function (event) {
+          if (this.readyState == 4) {
             step();
           }
-          xhr.onabort = checkEvent;
-          xhr.addEventListener('abort', checkEvent);
-          xhr.open('GET', '/foo');
-          xhr.send();
-          xhr.abort();
         });
+        xhr.open('GET', '/foo');
+        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();
-        });
+      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();
       });
-
-      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);
-        });
+      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();
       });
-
-      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();
+      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
             }
-          };
-          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 });
+            _assert.default.strictEqual(rt, '', 'responseText check');
             done();
-          };
-          xhr.open('GET', '/fooXml');
-          xhr.send();
-        });
+          }
+        };
+        xhr.open('GET', '/foo');
+        xhr.send();
       });
-
-      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);
-        });
+      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('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('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('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('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('prototype', () => {
-        it('should be present', () => {
-          assert('prototype' in XHRConstructor);
-          assert(typeof XHRConstructor.prototype.open === 'function');
-          assert(typeof XHRConstructor.prototype.send === 'function');
-        });
+    });
+    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('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('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) => {
+    it('should be used with responseTextChanger present and work on re-used object', done => {
       let origResponse;
       let originalSendBodyLoggerRan = 0;
       let originalResponseTextLoggerRan = 0;
@@ -582,325 +570,241 @@ describe('XHRProxyFactory', () => {
       let firstAfterListenersRan = 0;
       let rsc4Ran = 0;
       let runCount = 0;
-      function checkConnectionParam(
-        connection,
-        expectStatus,
-        expectOriginalSendBody
-      ) {
-        assert.equal((connection: any)._flag, true, 'connection object check');
+      function checkConnectionParam(connection, expectStatus, expectOriginalSendBody) {
+        _assert.default.equal(connection._flag, true, 'connection object check');
         if (expectStatus) {
-          assert.equal((connection: any).status, 200, 'status check');
-          assert.equal(
-            (connection: any).responseType,
-            'text',
-            'responseType check'
-          );
+          _assert.default.equal(connection.status, 200, 'status check');
+          _assert.default.equal(connection.responseType, 'text', 'responseType 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');
+        _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.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++;
-          },
+      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';
         },
-        {
-          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();
-            }
-          },
+        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;
         },
-        {
-          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');
-          },
+        finalResponseTextLogger(connection, response) {
+          _assert.default.strictEqual(this, wrappers[0], 'this check');
+          checkConnectionParam(connection, true, true);
+          finalResponseTextLoggerRan++;
+          _assert.default.equal(response, origResponse + '-modified' + runCount);
         },
-      ];
-      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
-        logError: logError,
+        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.equal(
-            this.response,
-            '',
-            'check response is empty until end when responseTextChanger is used'
-          );
-          assert.equal(this.responseText, this.response, 'check responseText');
+          _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.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');
+          _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) => {
+    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.strictEqual(this, wrappers[0], 'this check');
-            originalResponseTextLoggerRan++;
-            origResponse = response;
-          },
-          finalResponseTextLogger(connection, response) {
-            assert.strictEqual(this, wrappers[0], 'this check');
-            finalResponseTextLoggerRan++;
-            assert.equal(response, origResponse);
-          },
+      const wrappers = [{
+        isRelevantTo(connection) {
+          return true;
         },
-        {
-          isRelevantTo(connection) {
-            return false;
-          },
-          responseTextChanger(connection, response) {
-            throw new Error('should not run');
-          },
+        originalResponseTextLogger(connection, response) {
+          _assert.default.strictEqual(this, wrappers[0], 'this check');
+          originalResponseTextLoggerRan++;
+          origResponse = response;
         },
-      ];
-      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
-        logError: logError,
+        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.equal(this.responseText, this.response, 'check responseText');
+        _assert.default.equal(this.responseText, this.response, 'check responseText');
         if (this.readyState == 3) {
-          assert.equal(this.response, 'Response here', 'check response');
+          _assert.default.equal(this.response, 'Response here', 'check response');
         }
         if (this.readyState == 4) {
-          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'
-          );
+          _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) => {
+    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');
-          },
+      const wrappers = [{
+        isRelevantTo(connection) {
+          throw testError;
+        },
+        originalResponseTextLogger(connection, response) {
+          throw new Error('should not run');
+        }
+      }, {
+        isRelevantTo(connection) {
+          return true;
         },
-        {
-          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;
-          },
+        originalSendBodyLogger(connection, body) {
+          throw testError;
         },
-        {
-          isRelevantTo(connection) {
-            return true;
-          },
-          originalSendBodyLogger(connection, body) {
-            throw testError;
-          },
-          originalResponseTextLogger(connection, response) {
-            throw testError;
-          },
-          finalResponseTextLogger(connection, response) {
-            throw testError;
-          },
+        requestChanger(connection, body) {
+          throw testError;
         },
-      ];
-      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
-        logError: logError,
+        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.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');
+          _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');
-          },
+    it('can have wrappers changed after construction', done => {
+      const wrappers = [{
+        isRelevantTo(connection) {
+          throw new Error('should not run');
         },
-      ];
-
-      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
-        logError: logError,
+        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({
@@ -909,130 +813,98 @@ describe('XHRProxyFactory', () => {
         },
         originalResponseTextLogger(connection, response) {
           loggerRan++;
-        },
+        }
       });
-
       const xhr = new XHRProxy();
       xhr.onreadystatechange = function () {
         if (this.readyState == 4) {
-          assert.equal(
-            loggerRan,
-            1,
-            'check that originalResponseTextLogger has run'
-          );
+          _assert.default.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.equal((connection: any)._flag, true, 'connection object check');
+        _assert.default.equal(connection._flag, true, 'connection object check');
       }
-      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');
-          },
+      const wrappers = [{
+        isRelevantTo(connection) {
+          _assert.default.strictEqual(this, wrappers[0], 'this check');
+          connection._flag = true;
+          checkConnectionParam(connection);
+          return connection.url == '/foo';
         },
-        {
-          isRelevantTo(connection) {
-            return true;
-          },
-          finalResponseTextLogger(connection, response) {
-            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 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) {
+          _assert.default.strictEqual(this, wrappers[0], 'this check');
+          checkConnectionParam(connection);
+          finalResponseTextLoggerRan++;
+          _assert.default.equal(response, origResponse + '-modified');
+        }
+      }, {
+        isRelevantTo(connection) {
+          return true;
         },
-      ];
-      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
-        logError: logError,
+        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 = _.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'
-        );
+      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.equal(this.responseText, this.response, 'check responseText');
+        _assert.default.equal(this.responseText, this.response, 'check responseText');
         if (this.readyState == 4) {
-          assert.equal(
-            this.response,
-            origResponse + '-modified',
-            'check that response was modified'
-          );
+          _assert.default.equal(this.response, origResponse + '-modified', 'check that response was modified');
           methodCalled = true;
           finishRsc();
         }
       };
       xhr.addEventListener('readystatechange', function () {
         if (this.readyState == 4) {
-          assert.equal(
-            this.response,
-            origResponse + '-modified',
-            'check that response was modified'
-          );
+          _assert.default.equal(this.response, origResponse + '-modified', 'check that response was modified');
           addedListenerCalled = true;
           finishRsc();
         }
@@ -1040,175 +912,136 @@ 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 delay(1);
-
-            return response + '-modified';
-          },
-          finalResponseTextLogger(connection, response) {
-            throw new Error('should not run');
-          },
+    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';
         },
-      ];
-      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
-        logError: logError,
+        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.equal(this.responseText, 'foo2 response!');
+          _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.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,
+    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.strictEqual(this.responseText, 'foo2 response!ab');
+        _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.spy();
-      const wrappers = [
-        {
-          isRelevantTo: () => true,
-          responseTextChanger(connection, response) {
-            return (null: any);
-          },
-        },
-      ];
-      const XHRProxy = XHRProxyFactory(XMLHttpRequest, wrappers, {
-        logError: logErrorSpy,
+    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.strictEqual(this.responseText, 'foo2 response!');
-        assert(logErrorSpy.calledOnce);
+        _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 = XHRProxyFactory(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 = (0, _xhrProxyFactory.default)(XMLHttpRequest, wrappers, {
+        logError: logError
       });
       const xhr = new XHRProxy();
-
       xhr.onload = function () {
-        assert.strictEqual(
-          this.responseText,
-          'fooAB requested, data12 received'
-        );
+        _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.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,
+    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.strictEqual(this.responseText, 'body received');
-        assert(logErrorSpy.calledOnce);
+        _assert.default.strictEqual(this.responseText, 'body received');
+        (0, _assert.default)(logErrorSpy.calledOnce);
         done();
       };
       xhr.onerror = thrower('xhr error');
@@ -1216,4 +1049,4 @@ describe('XHRProxyFactory', () => {
       xhr.send('somedata');
     });
   });
-});
+});