verdnatura-mirror
/
loopback
mirror of https://github.com/strongloop/loopback.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

Update dependencies to their latest versions and fix CI failures [2.x]
This commit is contained in:
Miroslav Bajtoš 2016-08-05 13:35:36 +02:00 committed by GitHub
parent 7f5f8d6df5 0eff26199c
commit 52f1645713
13 changed files with 425 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.jscsrc
View File

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

3
common/models/user.js
View File

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

2
lib/persisted-model.js
View File

@ -702,7 +702,7 @@ module.exports = function(registry) {
accepts: [ accepts: [
{arg: 'since', type: 'number', description: 'Find deltas since this checkpoint'}, {arg: 'since', type: 'number', description: 'Find deltas since this checkpoint'},
{arg: 'remoteChanges', type: 'array', description: 'an array of change objects', {arg: 'remoteChanges', type: 'array', description: 'an array of change objects',
http: {source: 'body'}} http: {source: 'body'}}
], ],
returns: {arg: 'result', type: 'object', root: true}, returns: {arg: 'result', type: 'object', root: true},
http: {verb: 'post', path: '/diff'} http: {verb: 'post', path: '/diff'}

50
package.json
View File

@ -32,7 +32,7 @@
"test": "grunt mocha-and-karma" "test": "grunt mocha-and-karma"
}, },
"dependencies": { "dependencies": {
"async": "^0.9.0", "async": "^2.0.1",
"bcryptjs": "^2.1.0", "bcryptjs": "^2.1.0",
"body-parser": "^1.12.0", "body-parser": "^1.12.0",
"canonical-json": "0.0.4", "canonical-json": "0.0.4",
@ -46,8 +46,8 @@
"inflection": "^1.6.0", "inflection": "^1.6.0",
"loopback-connector-remote": "^1.0.3", "loopback-connector-remote": "^1.0.3",
"loopback-phase": "^1.2.0", "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", "serve-favicon": "^2.2.0",
"stable": "^0.1.5", "stable": "^0.1.5",
"strong-remoting": "^2.21.0", "strong-remoting": "^2.21.0",
@ -58,37 +58,39 @@
"loopback-datasource-juggler": "^2.19.0" "loopback-datasource-juggler": "^2.19.0"
}, },
"devDependencies": { "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", "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", "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-phantomjs-launcher": "^1.0.0",
"karma-script-launcher": "^0.1.0", "karma-script-launcher": "^1.0.0",
"loopback-boot": "^2.7.0", "loopback-boot": "^2.7.0",
"loopback-datasource-juggler": "^2.19.1", "loopback-datasource-juggler": "^2.19.1",
"loopback-testing": "~1.1.0", "loopback-testing": "~1.1.0",
"mocha": "^2.1.0", "mocha": "^3.0.0",
"phantomjs-prebuilt": "^2.1.7", "phantomjs-prebuilt": "^2.1.7",
"sinon": "^1.13.0", "sinon": "^1.13.0",
"sinon-chai": "^2.8.0", "sinon-chai": "^2.8.0",
"strong-error-handler": "^1.0.1",
"strong-task-emitter": "^0.0.6", "strong-task-emitter": "^0.0.6",
"supertest": "^0.15.0" "supertest": "^2.0.0"
}, },
"repository": { "repository": {
"type": "git", "type": "git",

4
test/access-token.test.js
View File

@ -421,7 +421,7 @@ describe('app.enableAuth()', function() {
}); });
it('prevent remote call with app setting status on denied ACL', function(done) { it('prevent remote call with app setting status on denied ACL', function(done) {
createTestAppAndRequest(this.token, {app:{aclErrorStatus:403}}, done) createTestAppAndRequest(this.token, {app: {aclErrorStatus: 403}}, done)
.del('/tests/123') .del('/tests/123')
.expect(403) .expect(403)
.set('authorization', this.token.id) .set('authorization', this.token.id)
@ -439,7 +439,7 @@ describe('app.enableAuth()', function() {
}); });
it('prevent remote call with app setting status on denied ACL', function(done) { it('prevent remote call with app setting status on denied ACL', function(done) {
createTestAppAndRequest(this.token, {model:{aclErrorStatus:404}}, done) createTestAppAndRequest(this.token, {model: {aclErrorStatus: 404}}, done)
.del('/tests/123') .del('/tests/123')
.expect(404) .expect(404)
.set('authorization', this.token.id) .set('authorization', this.token.id)

29
test/app.test.js
View File

@ -14,6 +14,7 @@ var loopback = require('../');
var PersistedModel = loopback.PersistedModel; var PersistedModel = loopback.PersistedModel;
var describe = require('./util/describe'); var describe = require('./util/describe');
var expect = require('chai').expect;
var it = require('./util/it'); var it = require('./util/it');
describe('app', function() { describe('app', function() {
@ -945,18 +946,14 @@ describe('app', function() {
.end(function(err, res) { .end(function(err, res) {
if (err) return done(err); 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)); 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(); done();
}); });
@ -1049,8 +1046,18 @@ describe('app', function() {
}); });
function executeMiddlewareHandlers(app, urlPath, callback) { function executeMiddlewareHandlers(app, urlPath, callback) {
var handlerError;
var server = http.createServer(function(req, res) { 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') { if (callback === undefined && typeof urlPath === 'function') {
@ -1061,6 +1068,6 @@ function executeMiddlewareHandlers(app, urlPath, callback) {
request(server) request(server)
.get(urlPath) .get(urlPath)
.end(function(err) { .end(function(err) {
if (err) return callback(err); callback(handlerError || err);
}); });
} }

7
test/error-handler.test.js
View File

@ -5,7 +5,7 @@
var loopback = require('../'); var loopback = require('../');
var app; var app;
var assert = require('assert'); var expect = require('chai').expect;
var request = require('supertest'); var request = require('supertest');
describe('loopback.errorHandler(options)', function() { describe('loopback.errorHandler(options)', function() {
@ -21,7 +21,8 @@ describe('loopback.errorHandler(options)', function() {
request(app) request(app)
.get('/url-does-not-exist') .get('/url-does-not-exist')
.end(function(err, res) { .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(); done();
}); });
@ -38,7 +39,7 @@ describe('loopback.errorHandler(options)', function() {
request(app) request(app)
.get('/url-does-not-exist') .get('/url-does-not-exist')
.end(function(err, res) { .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(); done();
}); });

18
test/hidden-properties.test.js
View File

@ -41,17 +41,17 @@ describe('hidden properties', function() {
it('should hide a property remotely', function(done) { it('should hide a property remotely', function(done) {
request(this.app) request(this.app)
.get('/products') .get('/products')
.expect('Content-Type', /json/) .expect('Content-Type', /json/)
.expect(200) .expect(200)
.end(function(err, res) { .end(function(err, res) {
if (err) return done(err); if (err) return done(err);
var product = res.body[0]; var product = res.body[0];
assert.equal(product.secret, undefined); assert.equal(product.secret, undefined);
done(); done();
}); });
}); });
it('should hide a property of nested models', function(done) { it('should hide a property of nested models', function(done) {

6
test/karma.conf.js
View File

@ -73,9 +73,9 @@ module.exports = function(config) {
captureTimeout: 60000, captureTimeout: 60000,
// to avoid DISCONNECTED messages // to avoid DISCONNECTED messages
browserDisconnectTimeout : 10000, // default 2000 browserDisconnectTimeout: 10000, // default 2000
browserDisconnectTolerance : 1, // default 0 browserDisconnectTolerance: 1, // default 0
browserNoActivityTimeout : 60000, //default 10000 browserNoActivityTimeout: 60000, //default 10000
// Continuous Integration mode // Continuous Integration mode
// if true, it capture browsers, run tests and exit // if true, it capture browsers, run tests and exit

6
test/relations.integration.js
View File

@ -102,7 +102,7 @@ describe('relations - integration', function() {
it('includes the related child model', function(done) { it('includes the related child model', function(done) {
var url = '/api/readers/' + this.reader.id; var url = '/api/readers/' + this.reader.id;
this.get(url) this.get(url)
.query({'filter': {'include' : 'pictures'}}) .query({'filter': {'include': 'pictures'}})
.expect(200, function(err, res) { .expect(200, function(err, res) {
if (err) return done(err); if (err) return done(err);
@ -119,7 +119,7 @@ describe('relations - integration', function() {
it('includes the related parent model', function(done) { it('includes the related parent model', function(done) {
var url = '/api/pictures'; var url = '/api/pictures';
this.get(url) this.get(url)
.query({'filter': {'include' : 'imageable'}}) .query({'filter': {'include': 'imageable'}})
.expect(200, function(err, res) { .expect(200, function(err, res) {
if (err) return done(err); if (err) return done(err);
@ -134,7 +134,7 @@ describe('relations - integration', function() {
it('includes related models scoped to the related parent model', function(done) { it('includes related models scoped to the related parent model', function(done) {
var url = '/api/pictures'; var url = '/api/pictures';
this.get(url) this.get(url)
.query({'filter': {'include' : {'relation': 'imageable', 'scope': { 'include' : 'team'}}}}) .query({'filter': {'include': {'relation': 'imageable', 'scope': { 'include': 'team'}}}})
.expect(200, function(err, res) { .expect(200, function(err, res) {
if (err) return done(err); if (err) return done(err);

3
test/rest.middleware.test.js
View File

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

530
test/role.test.js
View File

@ -6,11 +6,6 @@
var assert = require('assert'); var assert = require('assert');
var sinon = require('sinon'); var sinon = require('sinon');
var loopback = require('../index'); 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 async = require('async');
var expect = require('chai').expect; var expect = require('chai').expect;
var Promise = require('bluebird'); var Promise = require('bluebird');
@ -20,17 +15,29 @@ function checkResult(err, result) {
} }
describe('role model', function() { describe('role model', function() {
var ds; var app, Role, RoleMapping, User, Application, ACL;
beforeEach(function() { 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 // 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.roleModel = Role;
ACL.roleMappingModel = RoleMapping; ACL.roleMappingModel = RoleMapping;
ACL.userModel = User; ACL.userModel = User;
@ -40,55 +47,91 @@ describe('role model', function() {
Role.applicationModel = Application; 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) { Role.create({ name: 'user' }, function(err, userRole) {
Role.create({name: 'admin'}, function(err, adminRole) { if (err) return done(err);
userRole.principals.create({principalType: RoleMapping.ROLE, principalId: adminRole.id}, function(err, mapping) { Role.create({ name: 'admin' }, function(err, adminRole) {
Role.find(function(err, roles) { if (err) return done(err);
assert.equal(roles.length, 2); 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);
}); });
RoleMapping.find(function(err, mappings) {
assert.equal(mappings.length, 1);
assert.equal(mappings[0].principalType, RoleMapping.ROLE);
assert.equal(mappings[0].principalId, adminRole.id);
});
userRole.principals(function(err, principals) {
assert.equal(principals.length, 1);
});
userRole.roles(function(err, roles) {
assert.equal(roles.length, 1);
});
});
}); });
}); });
}); });
it('should define role/user relations', function() { it('should define role/user relations', function(done) {
User.create({ name: 'Raymond', email: 'x@y.com', password: 'foobar' }, function(err, user) { 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.create({ name: 'userRole' }, function(err, role) {
if (err) return done(err);
role.principals.create({ principalType: RoleMapping.USER, principalId: user.id }, role.principals.create({ principalType: RoleMapping.USER, principalId: user.id },
function(err, p) { function(err, p) {
Role.find(function(err, roles) { if (err) return done(err);
assert(!err); async.parallel([
assert.equal(roles.length, 1); function(next) {
assert.equal(roles[0].name, 'userRole'); Role.find(function(err, roles) {
}); if (err) return next(err);
role.principals(function(err, principals) { assert.equal(roles.length, 1);
assert(!err); assert.equal(roles[0].name, 'userRole');
assert.equal(principals.length, 1); next();
assert.equal(principals[0].principalType, RoleMapping.USER); });
assert.equal(principals[0].principalId, user.id); },
}); function(next) {
role.users(function(err, users) { role.principals(function(err, principals) {
assert(!err); if (err) return next(err);
assert.equal(users.length, 1); assert.equal(principals.length, 1);
assert.equal(users[0].id, user.id); assert.equal(principals[0].principalType, RoleMapping.USER);
}); assert.equal(principals[0].principalId, user.id);
next();
});
},
function(next) {
role.users(function(err, users) {
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) { it('should not allow duplicate role name', function(done) {
@ -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) { 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.create({ name: 'userRole' }, function(err, role) {
if (err) return done(err);
assert(role.id); assert(role.id);
role.principals.create({principalType: RoleMapping.USER, principalId: user.id}, function(err, p) {
assert(p.id);
assert.equal(p.roleId, role.id);
Role.find(function(err, roles) {
assert(!err);
assert.equal(roles.length, 1);
assert.equal(roles[0].name, 'userRole');
});
role.principals(function(err, principals) {
assert(!err);
assert.equal(principals.length, 1);
assert.equal(principals[0].principalType, RoleMapping.USER);
assert.equal(principals[0].principalId, user.id);
});
role.users(function(err, users) {
assert(!err);
assert.equal(users.length, 1);
assert.equal(users[0].id, user.id);
});
});
});
});
});
it('should support getRoles() and isInRole()', function() {
User.create({ name: 'Raymond', email: 'x@y.com', password: 'foobar' }, function(err, user) {
Role.create({ name: 'userRole' }, function(err, role) {
role.principals.create({ principalType: RoleMapping.USER, principalId: user.id }, role.principals.create({ principalType: RoleMapping.USER, principalId: user.id },
function(err, p) { function(err, p) {
Role.isInRole('userRole', { principalType: RoleMapping.USER, principalId: user.id }, if (err) return done(err);
function(err, exists) { assert(p.id);
assert(!err && exists === true); assert.equal(p.roleId, role.id);
}); async.parallel([
function(next) {
Role.isInRole('userRole', {principalType: RoleMapping.APP, principalId: user.id}, function(err, exists) { Role.find(function(err, roles) {
assert(!err && exists === false); if (err) return next(err);
}); assert.equal(roles.length, 1);
assert.equal(roles[0].name, 'userRole');
Role.isInRole('userRole', {principalType: RoleMapping.USER, principalId: 100}, function(err, exists) { next();
assert(!err && exists === false); });
}); },
function(next) {
Role.getRoles({principalType: RoleMapping.USER, principalId: user.id}, function(err, roles) { role.principals(function(err, principals) {
assert.equal(roles.length, 3); // everyone, authenticated, userRole if (err) return next(err);
assert(roles.indexOf(role.id) >= 0); assert.equal(principals.length, 1);
assert(roles.indexOf(Role.EVERYONE) >= 0); assert.equal(principals[0].principalType, RoleMapping.USER);
assert(roles.indexOf(Role.AUTHENTICATED) >= 0); assert.equal(principals[0].principalId, user.id);
}); next();
Role.getRoles({principalType: RoleMapping.APP, principalId: user.id}, function(err, roles) { });
assert.equal(roles.length, 2); },
assert(roles.indexOf(Role.EVERYONE) >= 0); function(next) {
assert(roles.indexOf(Role.AUTHENTICATED) >= 0); role.users(function(err, users) {
}); if (err) return next(err);
Role.getRoles({principalType: RoleMapping.USER, principalId: 100}, function(err, roles) { assert.equal(users.length, 1);
assert.equal(roles.length, 2); assert.equal(users[0].id, user.id);
assert(roles.indexOf(Role.EVERYONE) >= 0); });
assert(roles.indexOf(Role.AUTHENTICATED) >= 0); next();
}); },
Role.getRoles({principalType: RoleMapping.USER, principalId: null}, function(err, roles) { ], done);
assert.equal(roles.length, 2);
assert(roles.indexOf(Role.EVERYONE) >= 0);
assert(roles.indexOf(Role.UNAUTHENTICATED) >= 0);
});
}); });
}); });
}); });
}); });
it('should support owner role resolver', function() { it('should support getRoles() and isInRole()', 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);
role.principals.create({ principalType: RoleMapping.USER, principalId: user.id },
function(err, p) {
if (err) return done(err);
async.series([
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();
});
},
function(next) {
Role.isInRole(
'userRole',
{ principalType: RoleMapping.APP, principalId: user.id },
function(err, inRole) {
if (err) return next(err);
assert(!inRole);
next();
});
},
function(next) {
Role.isInRole(
'userRole',
{ principalType: RoleMapping.USER, principalId: 100 },
function(err, inRole) {
if (err) return next(err);
assert(!inRole);
next();
});
},
function(next) {
Role.getRoles(
{ principalType: RoleMapping.USER, principalId: user.id },
function(err, roles) {
if (err) return next(err);
expect(roles).to.eql([
Role.AUTHENTICATED,
Role.EVERYONE,
role.id,
]);
next();
});
},
function(next) {
Role.getRoles(
{ principalType: RoleMapping.APP, principalId: user.id },
function(err, roles) {
if (err) return next(err);
expect(roles).to.eql([
Role.AUTHENTICATED,
Role.EVERYONE,
]);
next();
});
},
function(next) {
Role.getRoles(
{ principalType: RoleMapping.USER, principalId: 100 },
function(err, roles) {
if (err) return next(err);
expect(roles).to.eql([
Role.AUTHENTICATED,
Role.EVERYONE,
]);
next();
});
},
function(next) {
Role.getRoles(
{ 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) {
Role.registerResolver('returnPromise', function(role, context) { Role.registerResolver('returnPromise', function(role, context) {
return new Promise(function(resolve) { return new Promise(function(resolve) {
process.nextTick(function() { process.nextTick(function() {
@ -190,61 +298,120 @@ describe('role model', function() {
}); });
}); });
var Album = ds.createModel('Album', { var Album = app.registry.createModel('Album', {
name: String, name: String,
userId: Number userId: Number,
}, { }, {
relations: { relations: {
user: { user: {
type: 'belongsTo', type: 'belongsTo',
model: 'User', model: 'User',
foreignKey: 'userId' foreignKey: 'userId',
} },
} },
}); });
app.model(Album, { dataSource: 'db' });
User.create({name: 'Raymond', email: 'x@y.com', password: 'foobar'}, function(err, user) { 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);
function(err, yes) { async.parallel([
assert(!err && yes); function(next) {
}); Role.isInRole(
'returnPromise',
{ principalType: ACL.USER, principalId: user.id },
function(err, yes) {
if (err) return next(err);
assert(yes);
next();
});
},
function(next) {
Role.isInRole(
Role.AUTHENTICATED,
{ principalType: ACL.USER, principalId: user.id },
function(err, yes) {
if (err) next(err);
assert(yes);
next();
});
},
function(next) {
Role.isInRole(
Role.AUTHENTICATED,
{ principalType: ACL.USER, principalId: null },
function(err, yes) {
if (err) next(err);
assert(!yes);
next();
});
},
function(next) {
Role.isInRole(
Role.UNAUTHENTICATED,
{ principalType: ACL.USER, principalId: user.id },
function(err, yes) {
if (err) return next(err);
assert(!yes);
next();
});
},
function(next) {
Role.isInRole(
Role.UNAUTHENTICATED,
{ principalType: ACL.USER, principalId: null },
function(err, yes) {
if (err) return next(err);
assert(yes);
next();
});
},
function(next) {
Role.isInRole(
Role.EVERYONE,
{ principalType: ACL.USER, principalId: user.id },
function(err, yes) {
if (err) return next(err);
assert(yes);
next();
});
},
function(next) {
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) {
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) {
if (err) return next(err);
assert(yes);
Role.isInRole(Role.AUTHENTICATED, { principalType: ACL.USER, principalId: user.id }, Album.create({ name: 'Album 2' }, function(err, album2) {
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.AUTHENTICATED, { principalType: ACL.USER, principalId: null }, };
function(err, yes) { Role.isInRole(Role.OWNER, role, function(err, yes) {
assert(!err && !yes); if (err) return next(err);
}); assert(!yes);
next();
Role.isInRole(Role.UNAUTHENTICATED, {principalType: ACL.USER, principalId: user.id}, function(err, yes) { });
assert(!err && !yes); });
}); });
Role.isInRole(Role.UNAUTHENTICATED, {principalType: ACL.USER, principalId: null}, function(err, yes) {
assert(!err && yes);
});
Role.isInRole(Role.EVERYONE, {principalType: ACL.USER, principalId: user.id}, function(err, yes) {
assert(!err && yes);
});
Role.isInRole(Role.EVERYONE, {principalType: ACL.USER, principalId: null}, function(err, yes) {
assert(!err && yes);
});
Album.create({ name: 'Album 1', userId: user.id }, function(err, album1) {
var role = { principalType: ACL.USER, principalId: user.id, model: Album, id: album1.id };
Role.isInRole(Role.OWNER, role, function(err, yes) {
assert(!err && 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) {
assert(!err && !yes);
}); });
}); },
}); ], done);
}); });
}); });
@ -252,10 +419,11 @@ describe('role model', function() {
var user, app, role; var user, app, role;
beforeEach(function(done) { beforeEach(function(done) {
this.timeout(5000);
User.create({ User.create({
username: 'john', username: 'john',
email: 'john@gmail.com', email: 'john@gmail.com',
password: 'jpass' password: 'jpass',
}, function(err, u) { }, function(err, u) {
if (err) return done(err); if (err) return done(err);
@ -263,18 +431,18 @@ describe('role model', function() {
User.create({ User.create({
username: 'mary', username: 'mary',
email: 'mary@gmail.com', email: 'mary@gmail.com',
password: 'mpass' password: 'mpass',
}, function(err, u) { }, function(err, u) {
if (err) return done(err); if (err) return done(err);
Application.create({ Application.create({
name: 'demo' name: 'demo',
}, function(err, a) { }, function(err, a) {
if (err) return done(err); if (err) return done(err);
app = a; app = a;
Role.create({ Role.create({
name: 'admin' name: 'admin',
}, function(err, r) { }, function(err, r) {
if (err) return done(err); if (err) return done(err);
@ -282,12 +450,12 @@ describe('role model', function() {
var principals = [ var principals = [
{ {
principalType: ACL.USER, principalType: ACL.USER,
principalId: user.id principalId: user.id,
}, },
{ {
principalType: ACL.APP, principalType: ACL.APP,
principalId: app.id principalId: app.id,
} },
]; ];
async.each(principals, function(p, done) { async.each(principals, function(p, done) {
role.principals.create(p, done); role.principals.create(p, done);
@ -398,7 +566,6 @@ describe('role model', function() {
done(); done();
}); });
}); });
}); });
describe('listByPrincipalType', function() { describe('listByPrincipalType', function() {
@ -425,12 +592,17 @@ describe('role model', function() {
mappings.forEach(function(principalType) { mappings.forEach(function(principalType) {
var Model = principalTypesToModels[principalType]; var Model = principalTypesToModels[principalType];
Model.create({name:'test', email:'x@y.com', password: 'foobar'}, function(err, model) { 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(); var pluralName = Model.pluralModelName.toLowerCase();
role[pluralName](function(err, models) { role[pluralName](function(err, models) {
assert(!err); if (err) return done(err);
assert.equal(models.length, 1); assert.equal(models.length, 1);
if (++runs === mappings.length) { if (++runs === mappings.length) {
@ -444,13 +616,17 @@ describe('role model', function() {
}); });
it('should apply query', function(done) { it('should apply query', function(done) {
User.create({name: 'Raymond', email: 'x@y.com', password: 'foobar'}, function(err, user) { User.create({ name: 'Raymond', email: 'x@y.com', password: 'foobar' }, function(err, user) {
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.create({ name: 'userRole' }, function(err, role) {
var query = {fields:['id', 'name']}; 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'); sandbox.spy(User, 'find');
role.users(query, function(err, users) { role.users(query, function(err, users) {
assert(!err); if (err) return done(err);
assert.equal(users.length, 1); assert.equal(users.length, 1);
assert.equal(users[0].id, user.id); assert.equal(users[0].id, user.id);
assert(User.find.calledWith(query)); assert(User.find.calledWith(query));

6
test/user.test.js
View File

@ -388,7 +388,7 @@ describe('User', function() {
it('Should be able to find lowercase email with mixed-case email query', function(done) { it('Should be able to find lowercase email with mixed-case email query', function(done) {
User.settings.caseSensitiveEmail = false; User.settings.caseSensitiveEmail = false;
User.find({where:{email: validMixedCaseEmailCredentials.email}}, function(err, result) { User.find({where: {email: validMixedCaseEmailCredentials.email}}, function(err, result) {
if (err) done(err); if (err) done(err);
assert(result[0], 'The query did not find the user'); assert(result[0], 'The query did not find the user');
@ -1225,7 +1225,7 @@ describe('User', function() {
redirect: '/', redirect: '/',
protocol: ctx.req.protocol, protocol: ctx.req.protocol,
host: ctx.req.get('host'), host: ctx.req.get('host'),
headers: {'message-id':'custom-header-value'} headers: {'message-id': 'custom-header-value'}
}; };
user.verify(options, function(err, result) { user.verify(options, function(err, result) {
@ -1680,7 +1680,7 @@ describe('User', function() {
.end(function(err, res) { .end(function(err, res) {
if (err) return done(err); if (err) return done(err);
assert.deepEqual(res.body, { }); assert.deepEqual(res.body, '');
done(); done();
}); });