Merge pull request #2585 from strongloop/update-deps-2x

Update dependencies to their latest versions and fix CI failures [2.x]

.jscsrc

@@ -10,6 +10,8 @@
   ],
   "disallowMultipleVarDecl": "exceptUndefined",
   "disallowSpacesInsideObjectBrackets": null,
+  "jsDoc": false,
+  "requireDotNotation": false,
   "maximumLineLength": {
      "value": 150,
      "allowComments": true,

common/models/user.js

@@ -672,8 +672,7 @@ module.exports = function(User) {
             return tokenID;
           }, description: 'Do not supply this argument, it is automatically extracted ' +
             'from request headers.'
-          }
+        }],
-        ],
         http: {verb: 'all'}
       }
     );

package.json

@@ -32,7 +32,7 @@
     "test": "grunt mocha-and-karma"
   },
   "dependencies": {
-    "async": "^0.9.0",
+    "async": "^2.0.1",
     "bcryptjs": "^2.1.0",
     "body-parser": "^1.12.0",
     "canonical-json": "0.0.4",
@@ -46,8 +46,8 @@
     "inflection": "^1.6.0",
     "loopback-connector-remote": "^1.0.3",
     "loopback-phase": "^1.2.0",
-    "nodemailer": "^1.3.1",
+    "nodemailer": "^2.5.0",
-    "nodemailer-stub-transport": "^0.1.5",
+    "nodemailer-stub-transport": "^1.0.0",
     "serve-favicon": "^2.2.0",
     "stable": "^0.1.5",
     "strong-remoting": "^2.21.0",
@@ -58,37 +58,39 @@
     "loopback-datasource-juggler": "^2.19.0"
   },
   "devDependencies": {
-    "bluebird": "^2.9.9",
+    "bluebird": "^3.4.1",
-    "browserify": "^10.0.0",
+    "browserify": "^13.1.0",
-    "chai": "^2.1.1",
+    "chai": "^3.5.0",
     "es5-shim": "^4.1.0",
-    "grunt": "^0.4.5",
+    "eslint-config-loopback": "^1.0.0",
-    "grunt-browserify": "^3.5.0",
+    "grunt": "^1.0.1",
-    "grunt-cli": "^0.1.13",
+    "grunt-browserify": "^5.0.0",
-    "grunt-contrib-jshint": "^0.11.0",
+    "grunt-cli": "^1.2.0",
-    "grunt-contrib-uglify": "^0.9.1",
+    "grunt-contrib-jshint": "^1.0.0",
-    "grunt-contrib-watch": "^0.6.1",
+    "grunt-contrib-uglify": "^2.0.0",
-    "grunt-jscs": "^1.5.0",
+    "grunt-contrib-watch": "^1.0.0",
-    "grunt-karma": "^0.10.1",
+    "grunt-jscs": "^3.0.1",
+    "grunt-karma": "^2.0.0",
     "grunt-mocha-test": "^0.12.7",
-    "karma": "^0.12.31",
+    "karma": "^1.1.2",
-    "karma-browserify": "^4.0.0",
+    "karma-browserify": "^4.4.2",
-    "karma-chrome-launcher": "^0.1.7",
+    "karma-chrome-launcher": "^1.0.1",
-    "karma-firefox-launcher": "^0.1.4",
+    "karma-firefox-launcher": "^1.0.0",
-    "karma-html2js-preprocessor": "^0.1.0",
+    "karma-html2js-preprocessor": "^1.0.0",
-    "karma-junit-reporter": "^0.2.2",
+    "karma-junit-reporter": "^1.0.0",
-    "karma-mocha": "^0.1.10",
+    "karma-mocha": "^1.1.1",
     "karma-phantomjs-launcher": "^1.0.0",
-    "karma-script-launcher": "^0.1.0",
+    "karma-script-launcher": "^1.0.0",
     "loopback-boot": "^2.7.0",
     "loopback-datasource-juggler": "^2.19.1",
     "loopback-testing": "~1.1.0",
-    "mocha": "^2.1.0",
+    "mocha": "^3.0.0",
     "phantomjs-prebuilt": "^2.1.7",
     "sinon": "^1.13.0",
     "sinon-chai": "^2.8.0",
+    "strong-error-handler": "^1.0.1",
     "strong-task-emitter": "^0.0.6",
-    "supertest": "^0.15.0"
+    "supertest": "^2.0.0"
   },
   "repository": {
     "type": "git",

test/app.test.js

@@ -14,6 +14,7 @@ var loopback = require('../');
 var PersistedModel = loopback.PersistedModel;
 
 var describe = require('./util/describe');
+var expect = require('chai').expect;
 var it = require('./util/it');
 
 describe('app', function() {
@@ -945,18 +946,14 @@ describe('app', function() {
         .end(function(err, res) {
           if (err) return done(err);
 
-          assert.equal(typeof res.body, 'object');
+          expect(res.body).to.be.an('object');
-          assert(res.body.started);
+          expect(res.body).to.have.property('started');
-          // The number can be 0
+          expect(res.body.uptime, 'uptime').to.be.gte(0);
-          assert(res.body.uptime !== undefined);
 
           var elapsed = Date.now() - Number(new Date(res.body.started));
 
-          // elapsed should be a positive number...
+          // elapsed should be a small positive number...
-          assert(elapsed >= 0);
+          expect(elapsed, 'elapsed').to.be.within(0, 300);
-
-          // less than 100 milliseconds
-          assert(elapsed < 100);
 
           done();
         });
@@ -1049,8 +1046,18 @@ describe('app', function() {
 });
 
 function executeMiddlewareHandlers(app, urlPath, callback) {
+  var handlerError;
   var server = http.createServer(function(req, res) {
-    app.handle(req, res, callback);
+    app.handle(req, res, function(err) {
+      if (err) {
+        handlerError = err;
+        res.statusCode = err.status || err.statusCode || 500;
+        res.end(err.stack || err);
+      } else {
+        res.statusCode = 204;
+        res.end();
+      }
+    });
   });
 
   if (callback === undefined && typeof urlPath === 'function') {
@@ -1061,6 +1068,6 @@ function executeMiddlewareHandlers(app, urlPath, callback) {
   request(server)
     .get(urlPath)
     .end(function(err) {
-      if (err) return callback(err);
+      callback(handlerError || err);
     });
 }

test/error-handler.test.js

@@ -5,7 +5,7 @@
 
 var loopback = require('../');
 var app;
-var assert = require('assert');
+var expect = require('chai').expect;
 var request = require('supertest');
 
 describe('loopback.errorHandler(options)', function() {
@@ -21,7 +21,8 @@ describe('loopback.errorHandler(options)', function() {
     request(app)
       .get('/url-does-not-exist')
       .end(function(err, res) {
-        assert.ok(res.error.text.match(/<ul id="stacktrace"><li> &nbsp; &nbsp;at raiseUrlNotFoundError/));
+        expect(res.error.text).to.match(
+          /<ul id="stacktrace"><li>( &nbsp;)+at raiseUrlNotFoundError/);
 
         done();
       });
@@ -38,7 +39,7 @@ describe('loopback.errorHandler(options)', function() {
     request(app)
       .get('/url-does-not-exist')
       .end(function(err, res) {
-        assert.ok(res.error.text.match(/<ul id="stacktrace"><\/ul>/));
+        expect(res.error.text).to.match(/<ul id="stacktrace"><\/ul>/);
 
         done();
       });

test/rest.middleware.test.js

@@ -18,9 +18,6 @@ describe('loopback.rest', function() {
     MyModel.attachTo(db);
   });
 
-  if (process.env.CI)
-    this.timeout(3000);
-
   it('works out-of-the-box', function(done) {
     app.model(MyModel);
     app.use(loopback.rest());

test/role.test.js

@@ -6,11 +6,6 @@
 var assert = require('assert');
 var sinon = require('sinon');
 var loopback = require('../index');
-var Role = loopback.Role;
-var RoleMapping = loopback.RoleMapping;
-var User = loopback.User;
-var Application = loopback.Application;
-var ACL = loopback.ACL;
 var async = require('async');
 var expect = require('chai').expect;
 var Promise = require('bluebird');
@@ -20,17 +15,29 @@ function checkResult(err, result) {
 }
 
 describe('role model', function() {
-  var ds;
+  var app, Role, RoleMapping, User, Application, ACL;
 
   beforeEach(function() {
-    ds = loopback.createDataSource({connector: 'memory'});
+    // Use local app registry to ensure models are isolated to avoid
-    // Re-attach the models so that they can have isolated store to avoid
     // pollutions from other tests
-    ACL.attachTo(ds);
+    app = loopback({ localRegistry: true, loadBuiltinModels: true });
-    User.attachTo(ds);
+    app.dataSource('db', { connector: 'memory' });
-    Role.attachTo(ds);
+
-    RoleMapping.attachTo(ds);
+    ACL = app.registry.getModel('ACL');
-    Application.attachTo(ds);
+    app.model(ACL, { dataSource: 'db' });
+
+    User = app.registry.getModel('User');
+    app.model(User, { dataSource: 'db' });
+
+    Role = app.registry.getModel('Role');
+    app.model(Role, { dataSource: 'db' });
+
+    RoleMapping = app.registry.getModel('RoleMapping');
+    app.model(RoleMapping, { dataSource: 'db' });
+
+    Application = app.registry.getModel('Application');
+    app.model(Application, { dataSource: 'db' });
+
     ACL.roleModel = Role;
     ACL.roleMappingModel = RoleMapping;
     ACL.userModel = User;
@@ -40,57 +47,93 @@ describe('role model', function() {
     Role.applicationModel = Application;
   });
 
-  it('should define role/role relations', function() {
+  it('should define role/role relations', function(done) {
     Role.create({ name: 'user' }, function(err, userRole) {
+      if (err) return done(err);
       Role.create({ name: 'admin' }, function(err, adminRole) {
-        userRole.principals.create({principalType: RoleMapping.ROLE, principalId: adminRole.id}, function(err, mapping) {
+        if (err) return done(err);
+        userRole.principals.create(
+          { principalType: RoleMapping.ROLE, principalId: adminRole.id },
+          function(err, mapping) {
+            if (err) return done(err);
+
+            async.parallel([
+              function(next) {
                 Role.find(function(err, roles) {
+                  if (err) return next(err);
                   assert.equal(roles.length, 2);
+                  next();
                 });
+              },
+              function(next) {
                 RoleMapping.find(function(err, mappings) {
+                  if (err) return next(err);
                   assert.equal(mappings.length, 1);
                   assert.equal(mappings[0].principalType, RoleMapping.ROLE);
                   assert.equal(mappings[0].principalId, adminRole.id);
+                  next();
                 });
+              },
+              function(next) {
                 userRole.principals(function(err, principals) {
+                  if (err) return next(err);
                   assert.equal(principals.length, 1);
+                  next();
                 });
+              },
+              function(next) {
                 userRole.roles(function(err, roles) {
+                  if (err) return next(err);
                   assert.equal(roles.length, 1);
+                  next();
+                });
+              },
+            ], done);
           });
       });
     });
   });
 
-  });
+  it('should define role/user relations', function(done) {
-
-  it('should define role/user relations', function() {
     User.create({ name: 'Raymond', email: 'x@y.com', password: 'foobar' }, function(err, user) {
+      if (err) return done(err);
       Role.create({ name: 'userRole' }, function(err, role) {
+        if (err) return done(err);
         role.principals.create({ principalType: RoleMapping.USER, principalId: user.id },
         function(err, p) {
+          if (err) return done(err);
+          async.parallel([
+            function(next) {
               Role.find(function(err, roles) {
-            assert(!err);
+                if (err) return next(err);
                 assert.equal(roles.length, 1);
                 assert.equal(roles[0].name, 'userRole');
+                next();
               });
+            },
+            function(next) {
               role.principals(function(err, principals) {
-            assert(!err);
+                if (err) return next(err);
                 assert.equal(principals.length, 1);
                 assert.equal(principals[0].principalType, RoleMapping.USER);
                 assert.equal(principals[0].principalId, user.id);
+                next();
               });
+            },
+            function(next) {
               role.users(function(err, users) {
-            assert(!err);
+                if (err) return next(err);
                 assert.equal(users.length, 1);
                 assert.equal(users[0].id, user.id);
+                next();
+              });
+            },
+          ], done);
         });
       });
     });
   });
 
-  });
-
   it('should not allow duplicate role name', function(done) {
     Role.create({ name: 'userRole' }, function(err, role) {
       if (err) return done(err);
@@ -107,81 +150,146 @@ describe('role model', function() {
     });
   });
 
-  it('should automatically generate role id', function() {
+  it('should automatically generate role id', function(done) {
     User.create({ name: 'Raymond', email: 'x@y.com', password: 'foobar' }, function(err, user) {
+      if (err) return done(err);
       Role.create({ name: 'userRole' }, function(err, role) {
+        if (err) return done(err);
         assert(role.id);
-        role.principals.create({principalType: RoleMapping.USER, principalId: user.id}, function(err, p) {
+        role.principals.create({ principalType: RoleMapping.USER, principalId: user.id },
+        function(err, p) {
+          if (err) return done(err);
           assert(p.id);
           assert.equal(p.roleId, role.id);
+          async.parallel([
+            function(next) {
               Role.find(function(err, roles) {
-            assert(!err);
+                if (err) return next(err);
                 assert.equal(roles.length, 1);
                 assert.equal(roles[0].name, 'userRole');
+                next();
               });
+            },
+            function(next) {
               role.principals(function(err, principals) {
-            assert(!err);
+                if (err) return next(err);
                 assert.equal(principals.length, 1);
                 assert.equal(principals[0].principalType, RoleMapping.USER);
                 assert.equal(principals[0].principalId, user.id);
+                next();
               });
+            },
+            function(next) {
               role.users(function(err, users) {
-            assert(!err);
+                if (err) return next(err);
                 assert.equal(users.length, 1);
                 assert.equal(users[0].id, user.id);
               });
+              next();
+            },
+          ], done);
+        });
       });
     });
   });
 
-  });
+  it('should support getRoles() and isInRole()', function(done) {
-
-  it('should support getRoles() and isInRole()', function() {
     User.create({ name: 'Raymond', email: 'x@y.com', password: 'foobar' }, function(err, user) {
+      if (err) return done(err);
       Role.create({ name: 'userRole' }, function(err, role) {
+        if (err) return done(err);
         role.principals.create({ principalType: RoleMapping.USER, principalId: user.id },
         function(err, p) {
-          Role.isInRole('userRole', { principalType: RoleMapping.USER, principalId: user.id },
+          if (err) return done(err);
-          function(err, exists) {
+          async.series([
-            assert(!err && exists === true);
+            function(next) {
+              Role.isInRole(
+                'userRole',
+                { principalType: RoleMapping.USER, principalId: user.id },
+                function(err, inRole) {
+                  if (err) return next(err);
+                  // NOTE(bajtos) Apparently isRole is not a boolean,
+                  // but the matchin role object instead
+                  assert(!!inRole);
+                  next();
                 });
-
+            },
-          Role.isInRole('userRole', {principalType: RoleMapping.APP, principalId: user.id}, function(err, exists) {
+            function(next) {
-            assert(!err && exists === false);
+              Role.isInRole(
+                'userRole',
+                { principalType: RoleMapping.APP, principalId: user.id },
+                function(err, inRole) {
+                  if (err) return next(err);
+                  assert(!inRole);
+                  next();
                 });
-
+            },
-          Role.isInRole('userRole', {principalType: RoleMapping.USER, principalId: 100}, function(err, exists) {
+            function(next) {
-            assert(!err && exists === false);
+              Role.isInRole(
+                'userRole',
+                { principalType: RoleMapping.USER, principalId: 100 },
+                function(err, inRole) {
+                  if (err) return next(err);
+                  assert(!inRole);
+                  next();
                 });
-
+            },
-          Role.getRoles({principalType: RoleMapping.USER, principalId: user.id}, function(err, roles) {
+            function(next) {
-            assert.equal(roles.length, 3); // everyone, authenticated, userRole
+              Role.getRoles(
-            assert(roles.indexOf(role.id) >= 0);
+                { principalType: RoleMapping.USER, principalId: user.id },
-            assert(roles.indexOf(Role.EVERYONE) >= 0);
+                function(err, roles) {
-            assert(roles.indexOf(Role.AUTHENTICATED) >= 0);
+                  if (err) return next(err);
+                  expect(roles).to.eql([
+                    Role.AUTHENTICATED,
+                    Role.EVERYONE,
+                    role.id,
+                  ]);
+                  next();
                 });
-          Role.getRoles({principalType: RoleMapping.APP, principalId: user.id}, function(err, roles) {
+            },
-            assert.equal(roles.length, 2);
+            function(next) {
-            assert(roles.indexOf(Role.EVERYONE) >= 0);
+              Role.getRoles(
-            assert(roles.indexOf(Role.AUTHENTICATED) >= 0);
+                { principalType: RoleMapping.APP, principalId: user.id },
+                function(err, roles) {
+                  if (err) return next(err);
+                  expect(roles).to.eql([
+                    Role.AUTHENTICATED,
+                    Role.EVERYONE,
+                  ]);
+                  next();
                 });
-          Role.getRoles({principalType: RoleMapping.USER, principalId: 100}, function(err, roles) {
+            },
-            assert.equal(roles.length, 2);
+            function(next) {
-            assert(roles.indexOf(Role.EVERYONE) >= 0);
+              Role.getRoles(
-            assert(roles.indexOf(Role.AUTHENTICATED) >= 0);
+                { principalType: RoleMapping.USER, principalId: 100 },
+                function(err, roles) {
+                  if (err) return next(err);
+                  expect(roles).to.eql([
+                    Role.AUTHENTICATED,
+                    Role.EVERYONE,
+                  ]);
+                  next();
                 });
-          Role.getRoles({principalType: RoleMapping.USER, principalId: null}, function(err, roles) {
+            },
-            assert.equal(roles.length, 2);
+            function(next) {
-            assert(roles.indexOf(Role.EVERYONE) >= 0);
+              Role.getRoles(
-            assert(roles.indexOf(Role.UNAUTHENTICATED) >= 0);
+                { principalType: RoleMapping.USER, principalId: null },
+                function(err, roles) {
+                  if (err) return next(err);
+                  expect(roles).to.eql([
+                    Role.UNAUTHENTICATED,
+                    Role.EVERYONE,
+                  ]);
+                  next();
+                });
+            },
+          ], done);
         });
       });
     });
   });
 
-  });
+  it('should support owner role resolver', function(done) {
-
-  it('should support owner role resolver', function() {
     Role.registerResolver('returnPromise', function(role, context) {
       return new Promise(function(resolve) {
         process.nextTick(function() {
@@ -190,72 +298,132 @@ describe('role model', function() {
       });
     });
 
-    var Album = ds.createModel('Album', {
+    var Album = app.registry.createModel('Album', {
       name: String,
-      userId: Number
+      userId: Number,
     }, {
       relations: {
         user: {
           type: 'belongsTo',
           model: 'User',
-          foreignKey: 'userId'
+          foreignKey: 'userId',
-        }
+        },
-      }
+      },
     });
+    app.model(Album, { dataSource: 'db' });
 
     User.create({ name: 'Raymond', email: 'x@y.com', password: 'foobar' }, function(err, user) {
-      Role.isInRole('returnPromise', { principalType: ACL.USER, principalId: user.id },
+      if (err) return done(err);
+      async.parallel([
+        function(next) {
+          Role.isInRole(
+            'returnPromise',
+            { principalType: ACL.USER, principalId: user.id },
             function(err, yes) {
-        assert(!err && yes);
+              if (err) return next(err);
+              assert(yes);
+              next();
             });
-
+        },
-      Role.isInRole(Role.AUTHENTICATED, { principalType: ACL.USER, principalId: user.id },
+        function(next) {
+          Role.isInRole(
+            Role.AUTHENTICATED,
+            { principalType: ACL.USER, principalId: user.id },
             function(err, yes) {
-        assert(!err && yes);
+              if (err) next(err);
+              assert(yes);
+              next();
             });
-
+        },
-      Role.isInRole(Role.AUTHENTICATED, { principalType: ACL.USER, principalId: null },
+        function(next) {
+          Role.isInRole(
+            Role.AUTHENTICATED,
+            { principalType: ACL.USER, principalId: null },
             function(err, yes) {
-        assert(!err && !yes);
+              if (err) next(err);
+              assert(!yes);
+              next();
             });
-
+        },
-      Role.isInRole(Role.UNAUTHENTICATED, {principalType: ACL.USER, principalId: user.id}, function(err, yes) {
+        function(next) {
-        assert(!err && !yes);
+          Role.isInRole(
+            Role.UNAUTHENTICATED,
+            { principalType: ACL.USER, principalId: user.id },
+            function(err, yes) {
+              if (err) return next(err);
+              assert(!yes);
+              next();
             });
-      Role.isInRole(Role.UNAUTHENTICATED, {principalType: ACL.USER, principalId: null}, function(err, yes) {
+        },
-        assert(!err && yes);
+        function(next) {
+          Role.isInRole(
+            Role.UNAUTHENTICATED,
+            { principalType: ACL.USER, principalId: null },
+            function(err, yes) {
+              if (err) return next(err);
+              assert(yes);
+              next();
             });
-
+        },
-      Role.isInRole(Role.EVERYONE, {principalType: ACL.USER, principalId: user.id}, function(err, yes) {
+        function(next) {
-        assert(!err && yes);
+          Role.isInRole(
+            Role.EVERYONE,
+            { principalType: ACL.USER, principalId: user.id },
+            function(err, yes) {
+              if (err) return next(err);
+              assert(yes);
+              next();
             });
-
+        },
-      Role.isInRole(Role.EVERYONE, {principalType: ACL.USER, principalId: null}, function(err, yes) {
+        function(next) {
-        assert(!err && yes);
+          Role.isInRole(
+            Role.EVERYONE,
+            { principalType: ACL.USER, principalId: null },
+            function(err, yes) {
+              if (err) return next(err);
+              assert(yes);
+              next();
             });
-
+        },
+        function(next) {
           Album.create({ name: 'Album 1', userId: user.id }, function(err, album1) {
-        var role = { principalType: ACL.USER, principalId: user.id, model: Album, id: album1.id };
+            if (err) return done(err);
+            var role = {
+              principalType: ACL.USER, principalId: user.id,
+              model: Album, id: album1.id,
+            };
             Role.isInRole(Role.OWNER, role, function(err, yes) {
-          assert(!err && yes);
+              if (err) return next(err);
-        });
+              assert(yes);
+
               Album.create({ name: 'Album 2' }, function(err, album2) {
-          Role.isInRole(Role.OWNER, {principalType: ACL.USER, principalId: user.id, model: Album, id: album2.id}, function(err, yes) {
+                if (err) return next(err);
-            assert(!err && !yes);
+                role = {
+                  principalType: ACL.USER, principalId: user.id,
+                  model: Album, id: album2.id,
+                };
+                Role.isInRole(Role.OWNER, role, function(err, yes) {
+                  if (err) return next(err);
+                  assert(!yes);
+                  next();
                 });
               });
             });
           });
+        },
+      ], done);
+    });
   });
 
   describe('isMappedToRole', function() {
     var user, app, role;
 
     beforeEach(function(done) {
+      this.timeout(5000);
       User.create({
         username: 'john',
         email: 'john@gmail.com',
-        password: 'jpass'
+        password: 'jpass',
       }, function(err, u) {
         if (err) return done(err);
 
@@ -263,18 +431,18 @@ describe('role model', function() {
         User.create({
           username: 'mary',
           email: 'mary@gmail.com',
-          password: 'mpass'
+          password: 'mpass',
         }, function(err, u) {
           if (err) return done(err);
 
           Application.create({
-            name: 'demo'
+            name: 'demo',
           }, function(err, a) {
             if (err) return done(err);
 
             app = a;
             Role.create({
-              name: 'admin'
+              name: 'admin',
             }, function(err, r) {
               if (err) return done(err);
 
@@ -282,12 +450,12 @@ describe('role model', function() {
               var principals = [
                 {
                   principalType: ACL.USER,
-                  principalId: user.id
+                  principalId: user.id,
                 },
                 {
                   principalType: ACL.APP,
-                  principalId: app.id
+                  principalId: app.id,
-                }
+                },
               ];
               async.each(principals, function(p, done) {
                 role.principals.create(p, done);
@@ -398,7 +566,6 @@ describe('role model', function() {
         done();
       });
     });
-
   });
 
   describe('listByPrincipalType', function() {
@@ -426,11 +593,16 @@ describe('role model', function() {
       mappings.forEach(function(principalType) {
         var Model = principalTypesToModels[principalType];
         Model.create({ name: 'test', email: 'x@y.com', password: 'foobar' }, function(err, model) {
-          Role.create({name:'testRole'}, function(err, role) {
+          if (err) return done(err);
-            role.principals.create({principalType: principalType, principalId: model.id}, function(err, p) {
+          var uniqueRoleName = 'testRoleFor' + principalType;
+          Role.create({ name: uniqueRoleName }, function(err, role) {
+            if (err) return done(err);
+            role.principals.create({ principalType: principalType, principalId: model.id },
+            function(err, p) {
+              if (err) return done(err);
               var pluralName = Model.pluralModelName.toLowerCase();
               role[pluralName](function(err, models) {
-                assert(!err);
+                if (err) return done(err);
                 assert.equal(models.length, 1);
 
                 if (++runs === mappings.length) {
@@ -445,12 +617,16 @@ describe('role model', function() {
 
     it('should apply query', function(done) {
       User.create({ name: 'Raymond', email: 'x@y.com', password: 'foobar' }, function(err, user) {
+        if (err) return done(err);
         Role.create({ name: 'userRole' }, function(err, role) {
-          role.principals.create({principalType: RoleMapping.USER, principalId: user.id}, function(err, p) {
+          if (err) return done(err);
+          role.principals.create({ principalType: RoleMapping.USER, principalId: user.id },
+          function(err, p) {
+            if (err) return done(err);
             var query = { fields: ['id', 'name'] };
             sandbox.spy(User, 'find');
             role.users(query, function(err, users) {
-              assert(!err);
+              if (err) return done(err);
               assert.equal(users.length, 1);
               assert.equal(users[0].id, user.id);
               assert(User.find.calledWith(query));

test/user.test.js

@@ -1680,7 +1680,7 @@ describe('User', function() {
           .end(function(err, res) {
             if (err) return done(err);
 
-            assert.deepEqual(res.body, { });
+            assert.deepEqual(res.body, '');
 
             done();
           });