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",
"disallowSpacesInsideObjectBrackets": null,
"jsDoc": false,
"requireDotNotation": false,
"maximumLineLength": {
"value": 150,
"allowComments": true,

3
common/models/user.js
View File

@ -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'}
}
);

2
lib/persisted-model.js
View File

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

50
package.json
View File

@ -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-stub-transport": "^0.1.5",
"nodemailer": "^2.5.0",
"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",
"browserify": "^10.0.0",
"chai": "^2.1.1",
"bluebird": "^3.4.1",
"browserify": "^13.1.0",
"chai": "^3.5.0",
"es5-shim": "^4.1.0",
"grunt": "^0.4.5",
"grunt-browserify": "^3.5.0",
"grunt-cli": "^0.1.13",
"grunt-contrib-jshint": "^0.11.0",
"grunt-contrib-uglify": "^0.9.1",
"grunt-contrib-watch": "^0.6.1",
"grunt-jscs": "^1.5.0",
"grunt-karma": "^0.10.1",
"eslint-config-loopback": "^1.0.0",
"grunt": "^1.0.1",
"grunt-browserify": "^5.0.0",
"grunt-cli": "^1.2.0",
"grunt-contrib-jshint": "^1.0.0",
"grunt-contrib-uglify": "^2.0.0",
"grunt-contrib-watch": "^1.0.0",
"grunt-jscs": "^3.0.1",
"grunt-karma": "^2.0.0",
"grunt-mocha-test": "^0.12.7",
"karma": "^0.12.31",
"karma-browserify": "^4.0.0",
"karma-chrome-launcher": "^0.1.7",
"karma-firefox-launcher": "^0.1.4",
"karma-html2js-preprocessor": "^0.1.0",
"karma-junit-reporter": "^0.2.2",
"karma-mocha": "^0.1.10",
"karma": "^1.1.2",
"karma-browserify": "^4.4.2",
"karma-chrome-launcher": "^1.0.1",
"karma-firefox-launcher": "^1.0.0",
"karma-html2js-preprocessor": "^1.0.0",
"karma-junit-reporter": "^1.0.0",
"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",

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) {
createTestAppAndRequest(this.token, {app:{aclErrorStatus:403}}, done)
createTestAppAndRequest(this.token, {app: {aclErrorStatus: 403}}, done)
.del('/tests/123')
.expect(403)
.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) {
createTestAppAndRequest(this.token, {model:{aclErrorStatus:404}}, done)
createTestAppAndRequest(this.token, {model: {aclErrorStatus: 404}}, done)
.del('/tests/123')
.expect(404)
.set('authorization', this.token.id)

29
test/app.test.js
View File

@ -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');
assert(res.body.started);
// The number can be 0
assert(res.body.uptime !== undefined);
expect(res.body).to.be.an('object');
expect(res.body).to.have.property('started');
expect(res.body.uptime, 'uptime').to.be.gte(0);
var elapsed = Date.now() - Number(new Date(res.body.started));
// elapsed should be a positive number...
assert(elapsed >= 0);
// less than 100 milliseconds
assert(elapsed < 100);
// elapsed should be a small positive number...
expect(elapsed, 'elapsed').to.be.within(0, 300);
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);
});
}

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

@ -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();
});

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

@ -41,17 +41,17 @@ describe('hidden properties', function() {
it('should hide a property remotely', function(done) {
request(this.app)
.get('/products')
.expect('Content-Type', /json/)
.expect(200)
.end(function(err, res) {
if (err) return done(err);
.get('/products')
.expect('Content-Type', /json/)
.expect(200)
.end(function(err, res) {
if (err) return done(err);
var product = res.body[0];
assert.equal(product.secret, undefined);
var product = res.body[0];
assert.equal(product.secret, undefined);
done();
});
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,
// to avoid DISCONNECTED messages
browserDisconnectTimeout : 10000, // default 2000
browserDisconnectTolerance : 1, // default 0
browserNoActivityTimeout : 60000, //default 10000
browserDisconnectTimeout: 10000, // default 2000
browserDisconnectTolerance: 1, // default 0
browserNoActivityTimeout: 60000, //default 10000
// Continuous Integration mode
// 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) {
var url = '/api/readers/' + this.reader.id;
this.get(url)
.query({'filter': {'include' : 'pictures'}})
.query({'filter': {'include': 'pictures'}})
.expect(200, function(err, res) {
if (err) return done(err);
@ -119,7 +119,7 @@ describe('relations - integration', function() {
it('includes the related parent model', function(done) {
var url = '/api/pictures';
this.get(url)
.query({'filter': {'include' : 'imageable'}})
.query({'filter': {'include': 'imageable'}})
.expect(200, function(err, res) {
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) {
var url = '/api/pictures';
this.get(url)
.query({'filter': {'include' : {'relation': 'imageable', 'scope': { 'include' : 'team'}}}})
.query({'filter': {'include': {'relation': 'imageable', 'scope': { 'include': 'team'}}}})
.expect(200, function(err, res) {
if (err) return done(err);

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

@ -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());

530
test/role.test.js
View File

@ -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'});
// Re-attach the models so that they can have isolated store to avoid
// Use local app registry to ensure models are isolated to avoid
// pollutions from other tests
ACL.attachTo(ds);
User.attachTo(ds);
Role.attachTo(ds);
RoleMapping.attachTo(ds);
Application.attachTo(ds);
app = loopback({ localRegistry: true, loadBuiltinModels: true });
app.dataSource('db', { connector: 'memory' });
ACL = app.registry.getModel('ACL');
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,55 +47,91 @@ describe('role model', function() {
Role.applicationModel = Application;
});
it('should define role/role relations', function() {
Role.create({name: 'user'}, function(err, userRole) {
Role.create({name: 'admin'}, function(err, adminRole) {
userRole.principals.create({principalType: RoleMapping.ROLE, principalId: adminRole.id}, function(err, mapping) {
Role.find(function(err, roles) {
assert.equal(roles.length, 2);
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) {
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);
});
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) {
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.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);
});
if (err) return done(err);
async.parallel([
function(next) {
Role.find(function(err, roles) {
if (err) return next(err);
assert.equal(roles.length, 1);
assert.equal(roles[0].name, 'userRole');
next();
});
},
function(next) {
role.principals(function(err, principals) {
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) {
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) {
@ -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) {
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 },
function(err, p) {
Role.isInRole('userRole', { principalType: RoleMapping.USER, principalId: user.id },
function(err, exists) {
assert(!err && exists === true);
});
Role.isInRole('userRole', {principalType: RoleMapping.APP, principalId: user.id}, function(err, exists) {
assert(!err && exists === false);
});
Role.isInRole('userRole', {principalType: RoleMapping.USER, principalId: 100}, function(err, exists) {
assert(!err && exists === false);
});
Role.getRoles({principalType: RoleMapping.USER, principalId: user.id}, function(err, roles) {
assert.equal(roles.length, 3); // everyone, authenticated, userRole
assert(roles.indexOf(role.id) >= 0);
assert(roles.indexOf(Role.EVERYONE) >= 0);
assert(roles.indexOf(Role.AUTHENTICATED) >= 0);
});
Role.getRoles({principalType: RoleMapping.APP, principalId: user.id}, function(err, roles) {
assert.equal(roles.length, 2);
assert(roles.indexOf(Role.EVERYONE) >= 0);
assert(roles.indexOf(Role.AUTHENTICATED) >= 0);
});
Role.getRoles({principalType: RoleMapping.USER, principalId: 100}, function(err, roles) {
assert.equal(roles.length, 2);
assert(roles.indexOf(Role.EVERYONE) >= 0);
assert(roles.indexOf(Role.AUTHENTICATED) >= 0);
});
Role.getRoles({principalType: RoleMapping.USER, principalId: null}, function(err, roles) {
assert.equal(roles.length, 2);
assert(roles.indexOf(Role.EVERYONE) >= 0);
assert(roles.indexOf(Role.UNAUTHENTICATED) >= 0);
});
if (err) return done(err);
assert(p.id);
assert.equal(p.roleId, role.id);
async.parallel([
function(next) {
Role.find(function(err, roles) {
if (err) return next(err);
assert.equal(roles.length, 1);
assert.equal(roles[0].name, 'userRole');
next();
});
},
function(next) {
role.principals(function(err, principals) {
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) {
if (err) return next(err);
assert.equal(users.length, 1);
assert.equal(users[0].id, user.id);
});
next();
},
], done);
});
});
});
});
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) {
return new Promise(function(resolve) {
process.nextTick(function() {
@ -190,61 +298,120 @@ 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 },
function(err, yes) {
assert(!err && yes);
});
User.create({ name: 'Raymond', email: 'x@y.com', password: 'foobar' }, function(err, user) {
if (err) return done(err);
async.parallel([
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 },
function(err, yes) {
assert(!err && yes);
});
Role.isInRole(Role.AUTHENTICATED, { principalType: ACL.USER, principalId: null },
function(err, yes) {
assert(!err && !yes);
});
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);
Album.create({ name: 'Album 2' }, function(err, album2) {
if (err) return next(err);
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);
});
});
@ -252,10 +419,11 @@ describe('role model', 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() {
@ -425,12 +592,17 @@ 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) {
role.principals.create({principalType: principalType, principalId: model.id}, function(err, p) {
Model.create({ name: 'test', email: 'x@y.com', password: 'foobar' }, function(err, model) {
if (err) return done(err);
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) {
@ -444,13 +616,17 @@ describe('role model', function() {
});
it('should apply query', function(done) {
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}, function(err, p) {
var query = {fields:['id', 'name']};
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);
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));

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) {
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);
assert(result[0], 'The query did not find the user');
@ -1225,7 +1225,7 @@ describe('User', function() {
redirect: '/',
protocol: ctx.req.protocol,
host: ctx.req.get('host'),
headers: {'message-id':'custom-header-value'}
headers: {'message-id': 'custom-header-value'}
};
user.verify(options, function(err, result) {
@ -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();
});