rollbar 2.26.2 → 2.26.4

package/test/react-native.transforms.test.js

@@ -7,16 +7,16 @@ var Rollbar = require('../src/react-native/rollbar');
 var t = require('../src/react-native/transforms');
 
 function TestClientGen() {
-  var TestClient = function() {
+  var TestClient = function () {
     this.notifier = {
-      addTransform: function() {
+      addTransform: function () {
         return this.notifier;
-      }.bind(this)
+      }.bind(this),
     };
     this.queue = {
-      addPredicate: function() {
+      addPredicate: function () {
         return this.queue;
-      }.bind(this)
+      }.bind(this),
     };
   };
   return TestClient;
@@ -24,47 +24,45 @@ function TestClientGen() {
 
 function itemFromArgs(args) {
   var client = new (TestClientGen())();
-  var rollbar = new Rollbar({autoInstrument: false}, client);
+  var rollbar = new Rollbar({ autoInstrument: false }, client);
   var item = rollbar._createItem(args);
   item.level = 'debug';
   return item;
 }
 
-describe('handleItemWithError', function() {
-  it('should create stackInfo', function(done) {
+describe('handleItemWithError', function () {
+  it('should create stackInfo', function (done) {
     var err = new Error('test');
     var args = ['a message', err];
     var item = itemFromArgs(args);
-    var options = (new Rollbar({})).options;
-    t.handleItemWithError(item, options, function(e, i) {
-      expect(item.stackInfo.exception).to.eql({class: 'Error', message: 'test'});
+    var options = new Rollbar({}).options;
+    t.handleItemWithError(item, options, function (e, i) {
+      expect(item.stackInfo.exception).to.eql({
+        class: 'Error',
+        message: 'test',
+      });
       done(e);
     });
   });
 });
-describe('_matchFilename', function() {
+describe('_matchFilename', function () {
   var filenames = {
     before: [
       '/var/mobile/Containers/Data/Application/1122ABCD-FF02-4942-A0D7-632E691D342F/.app/main.jsbundle',
       '/var/mobile/Containers/Data/Application/1122ABCD-FF02-4942-A0D7-632E691D342F/Library/Application Support/CodePush/2071980d74d1fef682fdab1d1cab345f33f498e3b51f68585c1b0b5469334df7/codepush_ios/main.jsbundle',
       '/data/user/0/com.example/files/CodePush/2071980d74d1fef682fdab1d1cab345f33f498e3b51f68585c1b0b5469334df7/codepush_android/index.android.bundle',
-      'index.android.bundle'
-    ],
-    after: [
-      'main.jsbundle',
-      'main.jsbundle',
       'index.android.bundle',
-      null
-    ]
-  }
+    ],
+    after: ['main.jsbundle', 'main.jsbundle', 'index.android.bundle', null],
+  };
 
-  it('should rewrite filenames', function(done) {
-    var options = (new Rollbar({})).options;
+  it('should rewrite filenames', function (done) {
+    var options = new Rollbar({}).options;
     console.log(options);
 
     var length = filenames.before.length;
 
-    for(var i = 0; i < length; i++){
+    for (var i = 0; i < length; i++) {
       var filename = t._matchFilename(filenames.before[i], options);
       expect(filename).to.eql(filenames.after[i]);
     }

package/test/react-native.transport.test.js

@@ -9,16 +9,16 @@ var t = new Transport(truncation);
 var utility = require('../src/utility');
 utility.setupJSON();
 
-describe('post', function() {
+describe('post', function () {
   var accessToken = 'abc123';
   var options = {
     hostname: 'api.rollbar.com',
     protocol: 'https',
-    path: '/api/1/item/'
+    path: '/api/1/item/',
   };
   var payload = {
     access_token: accessToken,
-    data: {a: 1}
+    data: { a: 1 },
   };
   var uuid = 'd4c7acef55bf4c9ea95e4fe9428a8287';
 
@@ -33,16 +33,28 @@ describe('post', function() {
   });
 
   function stubResponse(code, err, message) {
-    window.fetch.returns(Promise.resolve(new Response(
-      JSON.stringify({ err: err, message: message, result: { uuid: uuid }}),
-      { status: code, statusText: message, headers: { 'Content-Type': 'application/json' }}
-    )));
+    window.fetch.returns(
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            err: err,
+            message: message,
+            result: { uuid: uuid },
+          }),
+          {
+            status: code,
+            statusText: message,
+            headers: { 'Content-Type': 'application/json' },
+          },
+        ),
+      ),
+    );
   }
 
-  it('should callback with the right value on success', function(done) {
+  it('should callback with the right value on success', function (done) {
     stubResponse(200, 0, 'OK');
 
-    var callback = function(err, data) {
+    var callback = function (err, data) {
       expect(err).to.eql(null);
       expect(data).to.be.ok();
       expect(data.uuid).to.eql(uuid);
@@ -51,10 +63,10 @@ describe('post', function() {
     t.post(accessToken, options, payload, callback);
   });
 
-  it('should callback with the server error if 403', function(done) {
+  it('should callback with the server error if 403', function (done) {
     stubResponse(403, '403', 'bad request');
 
-    var callback = function(err, resp) {
+    var callback = function (err, resp) {
       expect(resp).to.not.be.ok();
       expect(err.message).to.eql('Api error: bad request');
       done();

package/test/server.lambda.test.js

@@ -14,50 +14,59 @@ function promisePending(promise, callback) {
   // behavior of Promise.race(), which always returns the first
   // already resolved promise in the array.
   Promise.race([promise, Promise.resolve(testValue)])
-    .then(function(value){
+    .then(function (value) {
       if (value === testValue) {
         return callback(true);
       } else {
         return callback(false);
       }
     })
-    .catch(function(_error){
+    .catch(function (_error) {
       return callback(false);
-    })
+    });
 }
 
-function fakePostItem(_item, callback){
+function fakePostItem(_item, callback) {
   // 1000ms simulates low API response, and allows testing the state before completion.
-  setTimeout(function(){ callback(); }, 1000);
+  setTimeout(function () {
+    callback();
+  }, 1000);
 }
 
 var stubContext = {
-  getRemainingTimeInMillis: function() { return 2000 }
-}
+  getRemainingTimeInMillis: function () {
+    return 2000;
+  },
+};
 
-vows.describe('lambda')
+vows
+  .describe('lambda')
   .addBatch({
     'async handler sends message': {
-      topic: function() {
+      topic: function () {
         var rollbar = new Rollbar({
           accessToken: 'abc123',
           captureUncaught: true,
-          captureLambdaTimeouts: false
+          captureLambdaTimeouts: false,
         });
         var api = rollbar.client.notifier.queue.api;
-        rollbar.requestStub = sinon.stub(api, 'postItem').callsFake(fakePostItem);
-
-        rollbar.testHandlerInstance = rollbar.lambdaHandler(async (_event, _context) => {
-          // Testing the condition where the client handler sends a message before exit.
-          // The Rollbar wrapper should send, and should not resolve until the API request
-          // has completed.
-          rollbar.info('lambda test message');
-          return 'done';
-        });
+        rollbar.requestStub = sinon
+          .stub(api, 'postItem')
+          .callsFake(fakePostItem);
+
+        rollbar.testHandlerInstance = rollbar.lambdaHandler(
+          async (_event, _context) => {
+            // Testing the condition where the client handler sends a message before exit.
+            // The Rollbar wrapper should send, and should not resolve until the API request
+            // has completed.
+            rollbar.info('lambda test message');
+            return 'done';
+          },
+        );
 
         return rollbar;
       },
-      'invokes handler and receives promise': function(r) {
+      'invokes handler and receives promise': function (r) {
         var handler = r.testHandlerInstance;
 
         // rollbar.lambdaHandler in the above topic should have returned a
@@ -70,31 +79,31 @@ vows.describe('lambda')
         r.testPromise = handler({}, stubContext);
       },
       'after handler invoked': {
-        topic: function(r) {
+        topic: function (r) {
           var callback = this.callback;
 
           // This timeout allows a few extra ticks so that without the wait in
           // the wrapper this test should fail.
           setTimeout(function () {
-            promisePending(r.testPromise, function(pending){
+            promisePending(r.testPromise, function (pending) {
               r.promiseIsPending = pending;
               callback(r);
             });
           }, 10);
         },
-        'promise is pending': function(r) {
+        'promise is pending': function (r) {
           assert.isTrue(r.promiseIsPending);
         },
         'after promise resolved': {
-          topic: function(r) {
+          topic: function (r) {
             var callback = this.callback;
 
-            r.testPromise.then(function(value){
+            r.testPromise.then(function (value) {
               assert.equal(value, 'done');
               callback(r);
             });
           },
-          'sends message before exit': function(r) {
+          'sends message before exit': function (r) {
             var requestStub = r.requestStub;
 
             // If the handler is allowed to exit prematurely, this will fail.
@@ -103,32 +112,36 @@ vows.describe('lambda')
             assert.equal(data.body.message.body, 'lambda test message');
 
             requestStub.reset();
-          }
-        }
-      }
-    }
+          },
+        },
+      },
+    },
   })
   .addBatch({
     'async handler catches exception': {
-      topic: function() {
+      topic: function () {
         var rollbar = new Rollbar({
           accessToken: 'abc123',
           captureUncaught: true,
-          captureLambdaTimeouts: false
+          captureLambdaTimeouts: false,
         });
         var api = rollbar.client.notifier.queue.api;
-        rollbar.requestStub = sinon.stub(api, 'postItem').callsFake(fakePostItem);
-
-        rollbar.testHandlerInstance = rollbar.lambdaHandler(async (_event, _context) => {
-          // Testing the condition where the client handler throws.
-          // The Rollbar wrapper should catch and report, and should not reject
-          // until the API request has completed.
-          throw new Error('lambda test error');
-        });
+        rollbar.requestStub = sinon
+          .stub(api, 'postItem')
+          .callsFake(fakePostItem);
+
+        rollbar.testHandlerInstance = rollbar.lambdaHandler(
+          async (_event, _context) => {
+            // Testing the condition where the client handler throws.
+            // The Rollbar wrapper should catch and report, and should not reject
+            // until the API request has completed.
+            throw new Error('lambda test error');
+          },
+        );
 
         return rollbar;
       },
-      'invokes handler and receives promise': function(r) {
+      'invokes handler and receives promise': function (r) {
         var handler = r.testHandlerInstance;
 
         // rollbar.lambdaHandler in the above topic should have returned a
@@ -141,37 +154,41 @@ vows.describe('lambda')
         r.testPromise = handler({}, stubContext);
       },
       'after handler invoked': {
-        topic: function(r) {
+        topic: function (r) {
           var callback = this.callback;
 
-          promisePending(r.testPromise, function(pending){
+          promisePending(r.testPromise, function (pending) {
             r.promiseIsPending = pending;
             callback(r);
           });
         },
-        'promise is pending': function(r) {
+        'promise is pending': function (r) {
           assert.isTrue(r.promiseIsPending);
         },
         'after promise rejected': {
-          topic: function(r) {
+          topic: function (r) {
             var callback = this.callback;
 
-            r.testPromise.catch(function(error){
+            r.testPromise.catch(function (error) {
               assert.equal(error.message, 'lambda test error');
               callback(r);
             });
           },
-          'sends message before exit': function(r) {
+          'sends message before exit': function (r) {
             var requestStub = r.requestStub;
 
             // If the handler is allowed to exit prematurely, this will fail.
             assert.isTrue(requestStub.called);
             var data = requestStub.getCall(0).args[0];
-            assert.equal(data.body.trace_chain[0].exception.message, 'lambda test error');
+            assert.equal(
+              data.body.trace_chain[0].exception.message,
+              'lambda test error',
+            );
 
             requestStub.reset();
-          }
-        }
-      }
-    }
-  }).export(module, {error: false});
+          },
+        },
+      },
+    },
+  })
+  .export(module, { error: false });