rollbar 2.26.4 → 3.0.0-alpha.2

package/test/browser.replay.recorder.test.js

@@ -0,0 +1,430 @@
+/* globals expect */
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals sinon */
+
+import { expect } from 'chai';
+import { EventType } from '@rrweb/types';
+
+import Recorder from '../src/browser/replay/recorder.js';
+
+describe('Recorder', function () {
+  let mockTracing;
+  let mockSpan;
+  let stopFnSpy;
+  let recordFnStub;
+  let emitCallback;
+  let testReplayId;
+
+  beforeEach(function () {
+    mockSpan = {
+      addEvent: sinon.spy(),
+      setAttribute: sinon.spy(),
+      span: { startTime: null },
+      end: sinon.spy(),
+    };
+
+    mockTracing = {
+      startSpan: sinon.stub().returns(mockSpan),
+      exporter: {
+        toPayload: sinon.stub().returns([{ id: 'span1' }]),
+      },
+    };
+
+    testReplayId = 'test-replay-id-123';
+    stopFnSpy = sinon.spy();
+    recordFnStub = sinon.stub().callsFake(function (options) {
+      emitCallback = options.emit;
+      return stopFnSpy;
+    });
+  });
+
+  describe('constructor', function () {
+    it('should initialize with default properties', function () {
+      const recorder = new Recorder({}, recordFnStub);
+
+      expect(recorder.isRecording).to.equal(false);
+      expect(recorder.options).to.deep.equal({
+        enabled: undefined,
+        autoStart: undefined,
+        maxSeconds: undefined,
+        triggerOptions: undefined,
+        debug: undefined,
+      });
+    });
+
+    it('should initialize removing disallowed options', function () {
+      const options = { enabled: true, checkoutEveryNms: 1000 };
+      const recorder = new Recorder(options, recordFnStub);
+
+      expect(recorder.options).to.deep.equal({
+        enabled: true,
+        autoStart: undefined,
+        maxSeconds: undefined,
+        triggerOptions: undefined,
+        debug: undefined,
+      });
+    });
+
+    it('should throw error if no record function is passed', function () {
+      expect(() => new Recorder({}, null)).to.throw(
+        TypeError,
+        "Expected 'recordFn' to be provided",
+      );
+    });
+  });
+
+  describe('recording management', function () {
+    it('should start recording correctly', function () {
+      const recorder = new Recorder(
+        { enabled: true },
+        recordFnStub,
+      );
+      recorder.start();
+
+      expect(recorder.isRecording).to.be.true;
+      expect(recordFnStub.calledOnce).to.be.true;
+      expect(stopFnSpy.called).to.be.false;
+
+      const recordOptions = recordFnStub.firstCall.args[0];
+      expect(recordOptions.checkoutEveryNms).to.equal(5000);
+      expect(typeof recordOptions.emit).to.equal('function');
+    });
+
+    it('should not start if already recording', function () {
+      const recorder = new Recorder(
+        { enabled: true },
+        recordFnStub,
+      );
+      recorder.start();
+      recorder.start();
+
+      expect(recordFnStub.calledOnce).to.be.true;
+    });
+
+    it('should not start if disabled', function () {
+      const recorder = new Recorder(
+        { enabled: false },
+        recordFnStub,
+      );
+      recorder.start();
+
+      expect(recorder.isRecording).to.be.false;
+      expect(recordFnStub.called).to.be.false;
+    });
+
+    it('should stop recording correctly', function () {
+      const recorder = new Recorder(
+        { enabled: true },
+        recordFnStub,
+      );
+      recorder.start();
+      recorder.stop();
+
+      expect(recorder.isRecording).to.be.false;
+      expect(recordFnStub.calledOnce).to.be.true;
+      expect(stopFnSpy.calledOnce).to.be.true;
+    });
+
+    it('should handle stop when not recording', function () {
+      const recorder = new Recorder({}, recordFnStub);
+      recorder.stop();
+
+      expect(recorder.isRecording).to.be.false;
+      expect(stopFnSpy.called).to.be.false;
+    });
+  });
+
+  describe('event handling', function () {
+    it('should handle events correctly', function () {
+      const recorder = new Recorder({}, recordFnStub);
+      recorder.start();
+
+      const event1 = { timestamp: 1000, type: 'event1', data: { a: 1 } };
+      const event2 = { timestamp: 2000, type: 'event2', data: { b: 2 } };
+
+      emitCallback(event1, false);
+      emitCallback(event2, false);
+
+      const result = recorder.dump(mockTracing, testReplayId);
+
+      expect(mockTracing.startSpan.calledOnce).to.be.true;
+      expect(mockSpan.addEvent.calledTwice).to.be.true;
+      expect(mockSpan.setAttribute.calledOnce).to.be.true;
+      expect(mockSpan.setAttribute.calledWith('rollbar.replay.id', testReplayId)).to.be.true;
+
+      const firstCallData = mockSpan.addEvent.firstCall.args[1];
+      expect(firstCallData.eventType).to.equal('event1');
+      expect(JSON.parse(firstCallData.json)).to.deep.equal({ a: 1 });
+      expect(firstCallData['rollbar.replay.id']).to.equal(testReplayId);
+
+      const secondCallData = mockSpan.addEvent.secondCall.args[1];
+      expect(secondCallData.eventType).to.equal('event2');
+      expect(JSON.parse(secondCallData.json)).to.deep.equal({ b: 2 });
+      expect(secondCallData['rollbar.replay.id']).to.equal(testReplayId);
+    });
+
+    it('should handle checkout events correctly', function () {
+      const recorder = new Recorder({}, recordFnStub);
+      recorder.start();
+
+      // First checkout
+      emitCallback({ timestamp: 0, type: EventType.Meta, data: {} }, true);
+      emitCallback(
+        { timestamp: 10, type: EventType.FullSnapshot, data: {} },
+        true,
+      );
+      emitCallback(
+        {
+          timestamp: 1000,
+          type: EventType.IncrementalSnapshot,
+          data: { a: 1 },
+        },
+        false,
+      );
+      emitCallback(
+        {
+          timestamp: 2000,
+          type: EventType.IncrementalSnapshot,
+          data: { b: 2 },
+        },
+        false,
+      );
+
+      // Second checkout
+      emitCallback({ timestamp: 3050, type: EventType.Meta, data: {} }, true);
+      emitCallback(
+        { timestamp: 3100, type: EventType.FullSnapshot, data: {} },
+        true,
+      );
+      emitCallback(
+        {
+          timestamp: 4000,
+          type: EventType.IncrementalSnapshot,
+          data: { c: 3 },
+        },
+        false,
+      );
+
+      // Third checkout
+      emitCallback({ timestamp: 4500, type: EventType.Meta, data: {} }, true);
+      emitCallback(
+        { timestamp: 5000, type: EventType.FullSnapshot, data: {} },
+        true,
+      );
+      emitCallback(
+        {
+          timestamp: 6000,
+          type: EventType.IncrementalSnapshot,
+          data: { d: 4 },
+        },
+        false,
+      );
+
+      recorder.dump(mockTracing, testReplayId);
+
+      // 2nd checkout (meta + fs) + event3 + 3rd checkout (meta + fs) + event4
+      expect(mockSpan.span.startTime).to.be.deep.equal([3, 50000000]); // otel time
+      expect(mockSpan.span.endTime).not.to.be.null;
+
+      expect(mockSpan.addEvent.callCount).to.equal(6);
+
+      [
+        {
+          name: 'rrweb-replay-events',
+          attributes: {
+            eventType: EventType.Meta,
+            json: JSON.stringify({}),
+            'rollbar.replay.id': testReplayId,
+          },
+          timestamp: [3, 50000000],
+        },
+        {
+          name: 'rrweb-replay-events',
+          attributes: {
+            eventType: EventType.FullSnapshot,
+            json: JSON.stringify({}),
+            'rollbar.replay.id': testReplayId,
+          },
+          timestamp: [3, 100000000],
+        },
+        {
+          name: 'rrweb-replay-events',
+          attributes: {
+            eventType: EventType.IncrementalSnapshot,
+            json: JSON.stringify({ c: 3 }),
+            'rollbar.replay.id': testReplayId,
+          },
+          timestamp: [4, 0],
+        },
+        {
+          name: 'rrweb-replay-events',
+          attributes: {
+            eventType: EventType.Meta,
+            json: JSON.stringify({}),
+            'rollbar.replay.id': testReplayId,
+          },
+          timestamp: [4, 500000000],
+        },
+        {
+          name: 'rrweb-replay-events',
+          attributes: {
+            eventType: EventType.FullSnapshot,
+            json: JSON.stringify({}),
+            'rollbar.replay.id': testReplayId,
+          },
+          timestamp: [5, 0],
+        },
+        {
+          name: 'rrweb-replay-events',
+          attributes: {
+            eventType: EventType.IncrementalSnapshot,
+            json: JSON.stringify({ d: 4 }),
+            'rollbar.replay.id': testReplayId,
+          },
+          timestamp: [6, 0],
+        },
+      ].forEach((expected, index) => {
+        const call = mockSpan.addEvent.getCall(index);
+        expect(call.args[0]).to.equal(expected.name);
+        expect(call.args[1]).to.deep.equal(expected.attributes);
+        expect(call.args[2]).to.deep.equal(expected.timestamp);
+      });
+    });
+  });
+
+  describe('dump functionality', function () {
+    it('should create a span with events and return formatted payload', function () {
+      const recorder = new Recorder({}, recordFnStub);
+      recorder.start();
+
+      emitCallback({ timestamp: 1000, type: 'event1', data: { a: 1 } }, false);
+      emitCallback({ timestamp: 2000, type: 'event2', data: { b: 2 } }, false);
+
+      const result = recorder.dump(mockTracing, testReplayId);
+
+      expect(result).to.deep.equal([{ id: 'span1' }]);
+      expect(mockTracing.startSpan.calledOnce).to.be.true;
+      expect(mockSpan.addEvent.calledTwice).to.be.true;
+      expect(mockSpan.end.calledOnce).to.be.true;
+      expect(mockTracing.exporter.toPayload.calledOnce).to.be.true;
+    });
+
+    it('should create a span with the correct span name', function () {
+      const recorder = new Recorder({}, recordFnStub);
+      recorder.start();
+
+      emitCallback({ timestamp: 1000, type: 'event1', data: { a: 1 } }, false);
+      emitCallback({ timestamp: 2000, type: 'event2', data: { b: 2 } }, false);
+
+      recorder.dump(mockTracing, testReplayId);
+
+      expect(mockTracing.startSpan.calledOnce).to.be.true;
+      const spanName = mockTracing.startSpan.firstCall.args[0];
+      expect(spanName).to.equal('rrweb-replay-recording');
+    });
+
+    it('should add events with the correct event name and replayId', function () {
+      const recorder = new Recorder({}, recordFnStub);
+      recorder.start();
+
+      emitCallback(
+        { timestamp: 1000, type: 'fullSnapshot', data: { a: 1 } },
+        false,
+      );
+      emitCallback(
+        { timestamp: 2000, type: 'mouseMove', data: { b: 2 } },
+        false,
+      );
+      emitCallback({ timestamp: 3000, type: 'input', data: { c: 3 } }, false);
+
+      recorder.dump(mockTracing, testReplayId);
+
+      expect(mockSpan.addEvent.callCount).to.equal(3);
+
+      for (let i = 0; i < mockSpan.addEvent.callCount; i++) {
+        const eventName = mockSpan.addEvent.getCall(i).args[0];
+        const eventAttrs = mockSpan.addEvent.getCall(i).args[1];
+        expect(eventName).to.equal(
+          'rrweb-replay-events',
+          `Event at index ${i} should have name "rrweb-replay-events"`
+        );
+        expect(eventAttrs['rollbar.replay.id']).to.equal(testReplayId);
+      }
+    });
+
+    it('should handle no events', function () {
+      const recorder = new Recorder({}, recordFnStub);
+
+      const result = recorder.dump(mockTracing, testReplayId);
+
+      expect(result).to.be.null;
+      expect(mockTracing.startSpan.called).to.be.false;
+      expect(mockTracing.exporter.toPayload.called).to.be.false;
+    });
+
+    it('should handle less than 2 events (invalid recording)', function () {
+      const recorder = new Recorder({}, recordFnStub);
+      recorder.start();
+
+      emitCallback({ timestamp: 1000, type: 'event1', data: { a: 1 } }, false);
+
+      const result = recorder.dump(mockTracing, testReplayId);
+
+      expect(result).to.be.null;
+      expect(mockTracing.startSpan.called).to.be.false;
+      expect(mockTracing.exporter.toPayload.called).to.be.false;
+    });
+  });
+
+  describe('configure', function () {
+    it('should update options', function () {
+      const recorder = new Recorder(
+        { enabled: true },
+        recordFnStub,
+      );
+
+      recorder.configure({ enabled: false, maxSeconds: 20 });
+
+      expect(recorder.options).to.deep.equal({
+        enabled: false,
+        autoStart: undefined,
+        maxSeconds: 20,
+        triggerOptions: undefined,
+        debug: undefined,
+      });
+    });
+
+    it('should set correct checkoutEveryNms', function () {
+      const recorder = new Recorder({ enabled: false });
+
+      recorder.configure({ enabled: true, maxSeconds: 15 });
+
+      expect(recorder.options).to.deep.equal({
+        enabled: true,
+        autoStart: undefined,
+        maxSeconds: 15,
+        triggerOptions: undefined,
+        debug: undefined,
+      });
+
+      expect(recorder.checkoutEveryNms()).to.equal(7500);
+    });
+
+    it('should stop recording if enabled set to false', function () {
+      const recorder = new Recorder(
+        { enabled: true },
+        recordFnStub,
+      );
+      recorder.start();
+
+      expect(recorder.isRecording).to.be.true;
+
+      recorder.configure({ enabled: false });
+
+      expect(recorder.isRecording).to.be.false;
+      expect(stopFnSpy.calledOnce).to.be.true;
+    });
+  });
+});

package/test/browser.rollbar.test.js

@@ -3,7 +3,7 @@
 /* globals it */
 /* globals sinon */
 
-var Rollbar = require('../src/browser/rollbar');
+import Rollbar from '../src/browser/rollbar.js';
 
 const DUMMY_TRACE_ID = 'some-trace-id';
 const DUMMY_SPAN_ID = 'some-span-id';
@@ -115,11 +115,21 @@ describe('Rollbar()', function () {
     var client = new (TestClientGen())();
     var options = {
       scrubFields: ['foobar'],
+      recorder: {
+        enabled: true,
+        },
+      tracing: {
+        endpoint: 'api.rollbar.com/api/1/tracing/',
+      },
     };
     var rollbar = (window.rollbar = new Rollbar(options, client));
 
     expect(rollbar.options.scrubFields).to.contain('foobar');
     expect(rollbar.options.scrubFields).to.contain('password');
+    expect(rollbar.options.recorder.enabled).to.eql(true);
+    expect(rollbar.options.recorder.triggerOptions.item.levels).to.eql(['error', 'critical']);
+    expect(rollbar.options.tracing.endpoint).to.eql('api.rollbar.com/api/1/tracing/');
+    expect(rollbar.options.tracing.enabled).to.eql(false);
     done();
   });
 
@@ -191,6 +201,7 @@ describe('Rollbar()', function () {
     done();
   });
 
+  // Legacy OpenTracing support
   it('should have a tracer if valid tracer is provided', function (done) {
     var options = { tracer: ValidOpenTracingTracerStub };
     var rollbar = (window.rollbar = new Rollbar(options));
@@ -200,6 +211,7 @@ describe('Rollbar()', function () {
     done();
   });
 
+  // Legacy OpenTracing support
   it('should not have a tracer if invalid tracer is provided', function (done) {
     var options = { tracer: InvalidOpenTracingTracerStub };
     var rollbar = (window.rollbar = new Rollbar(options));
@@ -351,7 +363,6 @@ describe('options.captureUncaught', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace.exception.message).to.eql('test error');
       expect(body.data.notifier.diagnostic.raw_error.message).to.eql(
         'test error',
@@ -399,7 +410,6 @@ describe('options.captureUncaught', function () {
 
         var body = JSON.parse(server.requests[0].requestBody);
 
-        expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
         expect(body.data.body.trace.exception.message).to.eql('test error');
         expect(body.data.notifier.diagnostic.is_anonymous).to.not.be.ok();
 
@@ -453,7 +463,6 @@ describe('options.captureUncaught', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace.exception.message).to.eql('anon error');
       expect(body.data.notifier.diagnostic.is_anonymous).to.eql(true);
 
@@ -494,7 +503,6 @@ describe('options.captureUncaught', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace.exception.message).to.eql('test error');
 
       // karma doesn't unload the browser between tests, so the onerror handler
@@ -535,7 +543,6 @@ describe('options.captureUncaught', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace.exception.message).to.eql('test error');
 
       // karma doesn't unload the browser between tests, so the onerror handler
@@ -567,7 +574,6 @@ describe('options.captureUncaught', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace_chain[0].exception.message).to.eql(
         'test DOMException',
       );
@@ -604,7 +610,6 @@ describe('options.captureUncaught', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace.exception.message).to.eql('deep stack error');
       expect(body.data.body.trace.frames.length).to.be.above(20);
 
@@ -640,7 +645,6 @@ describe('options.captureUncaught', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace.exception.message).to.eql(
         'event handler error',
       );
@@ -696,7 +700,6 @@ describe('options.captureUnhandledRejections', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace.exception.message).to.eql('test reject');
       expect(body.data.notifier.diagnostic.is_uncaught).to.eql(true);
 
@@ -731,7 +734,6 @@ describe('options.captureUnhandledRejections', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace.exception.message).to.eql('test reject');
 
       server.requests.length = 0;
@@ -881,6 +883,51 @@ describe('log', function () {
     }, 1);
   });
 
+  it('should add tracing attributes when called in an active span', function (done) {
+    const server = window.server;
+    stubResponse(server);
+    server.requests.length = 0;
+
+    const options = {
+      accessToken: 'POST_CLIENT_ITEM_TOKEN',
+      recorder: {
+        enabled: true,
+      },
+    };
+    const rollbar = (window.rollbar = new Rollbar(options));
+
+    const err = new Error('test error');
+
+    rollbar.tracing.withSpan('test', {}, () => {
+      rollbar.error(err);
+    });
+
+    setTimeout(function () {
+      try{
+        server.respond();
+
+        var body = JSON.parse(server.requests[0].requestBody);
+
+        expect(body.data.body.trace.exception.message).to.eql('test error');
+        expect(body.data.attributes).to.be.an('array');
+        expect(body.data.attributes.length).to.eql(4);
+        expect(body.data.attributes[0].key).to.eql('replay_id');
+        expect(body.data.attributes[0].value).to.match(/^[a-f0-9]{16}$/);
+        expect(body.data.attributes[1].key).to.eql('session_id');
+        expect(body.data.attributes[1].value).to.match(/^[a-f0-9]{32}$/);
+        expect(body.data.attributes[2].key).to.eql('span_id');
+        expect(body.data.attributes[2].value).to.match(/^[a-f0-9]{16}$/);
+        expect(body.data.attributes[3].key).to.eql('trace_id');
+        expect(body.data.attributes[3].value).to.match(/^[a-f0-9]{32}$/);
+
+        done();
+      } catch (e) {
+        done(e);
+      }
+    }, 1);
+  });
+
+
   it('should send message when called with only null arguments', function (done) {
     var server = window.server;
     stubResponse(server);
@@ -1019,7 +1066,6 @@ describe('onerror', function () {
 
       var body = JSON.parse(server.requests[0].requestBody);
 
-      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
       expect(body.data.body.trace.exception.message).to.eql(
         'testing window.onerror',
       );

package/test/browser.telemetry.test.js

@@ -3,7 +3,7 @@
 /* globals it */
 /* globals sinon */
 
-var Instrumenter = require('../src/browser/telemetry');
+import Instrumenter from '../src/browser/telemetry.js';
 
 describe('instrumentNetwork', function () {
   it('should capture XHR requests with string URL', function (done) {

package/test/browser.transforms.test.js

@@ -3,8 +3,8 @@
 /* globals it */
 /* globals sinon */
 
-var Rollbar = require('../src/browser/rollbar');
-var t = require('../src/browser/transforms');
+import Rollbar from '../src/browser/rollbar.js';
+import t from '../src/browser/transforms.js';
 
 function TestClientGen() {
   var TestClient = function () {
@@ -527,7 +527,7 @@ describe('addBody', function () {
 });
 
 describe('scrubPayload', function () {
-  it('only scrubs payload data', function (done) {
+  it('only scrubs payload data', async function () {
     var args = [
       'a message',
       { scooby: 'doo', okay: 'fizz=buzz&fuzz=baz', user: { id: 42 } },
@@ -547,16 +547,23 @@ describe('scrubPayload', function () {
     expect(payload.data.custom.okay).to.eql('fizz=buzz&fuzz=baz');
     expect(payload.data.custom.user.id).to.eql(42);
 
-    var scrub = require('../src/scrub');
-    t.addScrubber(scrub)(payload, options, function (e, i) {
-      expect(i.access_token).to.eql(accessToken);
-      expect(i.data.custom.scooby).to.not.eql('doo');
-      expect(payload.data.custom.okay).to.not.eql('fizz=buzz&fuzz=baz');
-      expect(payload.data.custom.okay).to.match(/fizz=\*+&fuzz=baz/);
-      expect(payload.data.custom.user.id).to.not.be.ok();
-      expect(payload.data.custom.user).to.match(/\*+/);
-      expect(i.data.message).to.eql('a message');
-      done(e);
+    const scrubModule = await import('../src/scrub.js');
+    const scrub = scrubModule.default;
+
+    const scrubberFn = t.addScrubber(scrub);
+    const result = await new Promise((resolve, reject) => {
+      scrubberFn(payload, options, (err, result) => {
+        if (err) reject(err);
+        else resolve(result);
+      });
     });
+
+    expect(result.access_token).to.eql(accessToken);
+    expect(result.data.custom.scooby).to.not.eql('doo');
+    expect(payload.data.custom.okay).to.not.eql('fizz=buzz&fuzz=baz');
+    expect(payload.data.custom.okay).to.match(/fizz=\*+&fuzz=baz/);
+    expect(payload.data.custom.user.id).to.not.be.ok();
+    expect(payload.data.custom.user).to.match(/\*+/);
+    expect(result.data.message).to.eql('a message');
   });
 });

package/test/browser.transport.test.js

@@ -3,10 +3,10 @@
 /* globals it */
 /* globals sinon */
 
-var truncation = require('../src/truncation');
-var Transport = require('../src/browser/transport');
-var t = new Transport(truncation);
-var utility = require('../src/utility');
+import truncation from '../src/truncation.js';
+import Transport from '../src/browser/transport.js';
+const t = new Transport(truncation);
+import * as utility from '../src/utility.js';
 utility.setupJSON();
 
 describe('post', function () {
@@ -166,6 +166,7 @@ var TestRequest = function (response, status, shouldThrowOnSend) {
   this.onreadystatechange = null;
   this.readyState = 0;
   this.shouldThrowOnSend = shouldThrowOnSend;
+  this.getResponseHeader = (key) => undefined;
 };
 TestRequest.prototype.open = function (m, u, a) {
   this.method = m;