rollbar/test/browser.transport.test.js

Effortlessly track and debug errors in your JavaScript applications with Rollbar. This package includes advanced error tracking features and an intuitive interface to help you identify and fix issues more quickly.

/* globals expect */
/* globals describe */
/* 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');
utility.setupJSON();

describe('post', function () {
  var accessToken = 'abc123';
  var options = {
    hostname: 'api.rollbar.com',
    protocol: 'https',
    path: '/api/1/item/',
    timeout: 2000,
  };
  var payload = {
    access_token: accessToken,
    data: { a: 1 },
  };
  it('should handle a failure to make a request', function (done) {
    var requestFactory = function () {
      return null;
    };
    var callback = function (err, resp) {
      expect(err).to.be.ok();
      done(resp);
    };
    t.post(accessToken, options, payload, callback, requestFactory);
  });
  it('should callback with the right value on success', function (done) {
    var requestFactory = requestGenerator('{"err": null, "result": true}', 200);
    var callback = function (err, resp) {
      expect(resp).to.be.ok();
      expect(resp.result).to.be.ok();
      expect(requestFactory.getInstance().timeout).to.equal(options.timeout);
      done(err);
    };
    t.post(accessToken, options, payload, callback, requestFactory.getInstance);
  });
  it('should callback with the server error if 403', function (done) {
    var response =
      '{"err": "bad request", "result": null, "message": "fail whale"}';
    var requestFactory = requestGenerator(response, 403);
    var callback = function (err, resp) {
      expect(resp).to.not.be.ok();
      expect(err.message).to.eql('403');
      expect(requestFactory.getInstance().timeout).to.equal(options.timeout);
      done(resp);
    };
    t.post(accessToken, options, payload, callback, requestFactory.getInstance);
  });
  it('should callback with the server error if 500', function (done) {
    var response =
      '{"err": "bad request", "result": null, "message": "500!!!"}';
    var requestFactory = requestGenerator(response, 500);
    var callback = function (err, resp) {
      expect(resp).to.not.be.ok();
      expect(err.message).to.eql('500');
      expect(requestFactory.getInstance().timeout).to.equal(options.timeout);
      done(resp);
    };
    t.post(accessToken, options, payload, callback, requestFactory.getInstance);
  });
  it('should callback with a retriable error with a weird status', function (done) {
    var response = '{"err": "bad request"}';
    var requestFactory = requestGenerator(response, 12005);
    var callback = function (err, resp) {
      expect(resp).to.not.be.ok();
      expect(err.message).to.match(/connection failure/);
      expect(err.code).to.eql('ENOTFOUND');
      expect(requestFactory.getInstance().timeout).to.equal(options.timeout);
      done(resp);
    };
    t.post(accessToken, options, payload, callback, requestFactory.getInstance);
  });
  it('should callback with some error if normal sending throws', function (done) {
    var response = '{"err": "bad request"}';
    var requestFactory = requestGenerator(response, 500, true);
    var callback = function (err, resp) {
      expect(resp).to.not.be.ok();
      expect(err.message).to.match(/Cannot find a method to transport/);
      expect(requestFactory.getInstance().timeout).to.equal(options.timeout);
      done(resp);
    };
    t.post(accessToken, options, payload, callback, requestFactory.getInstance);
  });
  describe('post', function () {
    beforeEach(function (done) {
      window.fetchStub = sinon.stub(window, 'fetch');
      window.server = sinon.createFakeServer();
      done();
    });

    afterEach(function () {
      window.fetch.restore();
      window.server.restore();
    });

    function stubFetchResponse() {
      window.fetch.returns(
        Promise.resolve(
          new Response(
            JSON.stringify({ err: 0, message: 'OK', result: { uuid: uuid } }),
            {
              status: 200,
              statusText: 'OK',
              headers: { 'Content-Type': 'application/json' },
            },
          ),
        ),
      );
    }

    function stubXhrResponse() {
      window.server.respondWith([
        200,
        { 'Content-Type': 'application/json' },
        '{"err": 0, "result":{ "uuid": "d4c7acef55bf4c9ea95e4fe9428a8287"}}',
      ]);
    }

    var uuid = 'd4c7acef55bf4c9ea95e4fe9428a8287';

    it('should use fetch when requested', function (done) {
      var callback = function (err, resp) {
        expect(window.fetchStub.called).to.be.ok();
        expect(server.requests.length).to.eql(0);
        done(err);
      };
      stubFetchResponse();
      stubXhrResponse();
      server.requests.length = 0;
      options.transport = 'fetch';
      t.post(accessToken, options, payload, callback);
    });
    it('should use xhr when requested', function (done) {
      var callback = function (err, resp) {
        expect(window.fetchStub.called).to.not.be.ok();
        expect(server.requests.length).to.eql(1);
        done(err);
      };
      stubFetchResponse();
      stubXhrResponse();
      server.requests.length = 0;
      options.transport = 'xhr';
      t.post(accessToken, options, payload, callback);
      setTimeout(function () {
        server.respond();
      }, 1);
    });
  });
});

var TestRequest = function (response, status, shouldThrowOnSend) {
  this.method = null;
  this.url = null;
  this.async = false;
  this.headers = [];
  this.data = null;
  this.responseText = response;
  this.status = status;
  this.onreadystatechange = null;
  this.readyState = 0;
  this.shouldThrowOnSend = shouldThrowOnSend;
};
TestRequest.prototype.open = function (m, u, a) {
  this.method = m;
  this.url = u;
  this.async = a;
};
TestRequest.prototype.setRequestHeader = function (key, value) {
  this.headers.push([key, value]);
};
TestRequest.prototype.send = function (data) {
  if (this.shouldThrowOnSend) {
    throw 'Bork Bork';
  }
  this.data = data;
  if (this.onreadystatechange) {
    this.readyState = 4;
    this.onreadystatechange();
  }
};

var requestGenerator = function (response, status, shouldThrow) {
  var request;
  return {
    getInstance: function () {
      if (!request) {
        request = new TestRequest(response, status, shouldThrow);
      }
      return request;
    },
  };
};