709 lines
22 KiB
JavaScript
709 lines
22 KiB
JavaScript
var async = require('async');
|
|
var loopback = require('../');
|
|
var ACL = loopback.ACL;
|
|
var Change = loopback.Change;
|
|
|
|
describe('Model', function() {
|
|
|
|
var User, memory;
|
|
|
|
beforeEach(function () {
|
|
memory = loopback.createDataSource({connector: loopback.Memory});
|
|
User = memory.createModel('user', {
|
|
'first': String,
|
|
'last': String,
|
|
'age': Number,
|
|
'password': String,
|
|
'gender': String,
|
|
'domain': String,
|
|
'email': String
|
|
});
|
|
});
|
|
|
|
describe('Model.validatesPresenceOf(properties...)', function() {
|
|
it("Require a model to include a property to be considered valid", function() {
|
|
User.validatesPresenceOf('first', 'last', 'age');
|
|
var joe = new User({first: 'joe'});
|
|
assert(joe.isValid() === false, 'model should not validate');
|
|
assert(joe.errors.last, 'should have a missing last error');
|
|
assert(joe.errors.age, 'should have a missing age error');
|
|
});
|
|
});
|
|
|
|
describe('Model.validatesLengthOf(property, options)', function() {
|
|
it("Require a property length to be within a specified range", function() {
|
|
User.validatesLengthOf('password', {min: 5, message: {min: 'Password is too short'}});
|
|
var joe = new User({password: '1234'});
|
|
assert(joe.isValid() === false, 'model should not be valid');
|
|
assert(joe.errors.password, 'should have password error');
|
|
});
|
|
});
|
|
|
|
describe('Model.validatesInclusionOf(property, options)', function() {
|
|
it("Require a value for `property` to be in the specified array", function() {
|
|
User.validatesInclusionOf('gender', {in: ['male', 'female']});
|
|
var foo = new User({gender: 'bar'});
|
|
assert(foo.isValid() === false, 'model should not be valid');
|
|
assert(foo.errors.gender, 'should have gender error');
|
|
});
|
|
});
|
|
|
|
describe('Model.validatesExclusionOf(property, options)', function() {
|
|
it("Require a value for `property` to not exist in the specified array", function() {
|
|
User.validatesExclusionOf('domain', {in: ['www', 'billing', 'admin']});
|
|
var foo = new User({domain: 'www'});
|
|
var bar = new User({domain: 'billing'});
|
|
var bat = new User({domain: 'admin'});
|
|
assert(foo.isValid() === false);
|
|
assert(bar.isValid() === false);
|
|
assert(bat.isValid() === false);
|
|
assert(foo.errors.domain, 'model should have a domain error');
|
|
assert(bat.errors.domain, 'model should have a domain error');
|
|
assert(bat.errors.domain, 'model should have a domain error');
|
|
});
|
|
});
|
|
|
|
describe('Model.validatesNumericalityOf(property, options)', function() {
|
|
it("Require a value for `property` to be a specific type of `Number`", function() {
|
|
User.validatesNumericalityOf('age', {int: true});
|
|
var joe = new User({age: 10.2});
|
|
assert(joe.isValid() === false);
|
|
var bob = new User({age: 0});
|
|
assert(bob.isValid() === true);
|
|
assert(joe.errors.age, 'model should have an age error');
|
|
});
|
|
});
|
|
|
|
describe('Model.validatesUniquenessOf(property, options)', function() {
|
|
it("Ensure the value for `property` is unique", function(done) {
|
|
User.validatesUniquenessOf('email', {message: 'email is not unique'});
|
|
|
|
var joe = new User({email: 'joe@joe.com'});
|
|
var joe2 = new User({email: 'joe@joe.com'});
|
|
|
|
joe.save(function () {
|
|
joe2.save(function (err) {
|
|
assert(err, 'should get a validation error');
|
|
assert(joe2.errors.email, 'model should have email error');
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('myModel.isValid()', function() {
|
|
it("Validate the model instance", function() {
|
|
User.validatesNumericalityOf('age', {int: true});
|
|
var user = new User({first: 'joe', age: 'flarg'})
|
|
var valid = user.isValid();
|
|
assert(valid === false);
|
|
assert(user.errors.age, 'model should have age error');
|
|
});
|
|
|
|
it('Asynchronously validate the model', function(done) {
|
|
User.validatesNumericalityOf('age', {int: true});
|
|
var user = new User({first: 'joe', age: 'flarg'})
|
|
user.isValid(function (valid) {
|
|
assert(valid === false);
|
|
assert(user.errors.age, 'model should have age error');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.attachTo(dataSource)', function() {
|
|
it("Attach a model to a [DataSource](#data-source)", function() {
|
|
var MyModel = loopback.createModel('my-model', {name: String});
|
|
|
|
assert(MyModel.find === undefined, 'should not have data access methods');
|
|
|
|
MyModel.attachTo(memory);
|
|
|
|
assert(typeof MyModel.find === 'function', 'should have data access methods after attaching to a data source');
|
|
});
|
|
});
|
|
|
|
describe('Model.create([data], [callback])', function() {
|
|
it("Create an instance of Model with given data and save to the attached data source", function(done) {
|
|
User.create({first: 'Joe', last: 'Bob'}, function(err, user) {
|
|
assert(user instanceof User);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('model.save([options], [callback])', function() {
|
|
it("Save an instance of a Model to the attached data source", function(done) {
|
|
var joe = new User({first: 'Joe', last: 'Bob'});
|
|
joe.save(function(err, user) {
|
|
assert(user.id);
|
|
assert(!err);
|
|
assert(!user.errors);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('model.updateAttributes(data, [callback])', function() {
|
|
it("Save specified attributes to the attached data source", function(done) {
|
|
User.create({first: 'joe', age: 100}, function (err, user) {
|
|
assert(!err);
|
|
assert.equal(user.first, 'joe');
|
|
|
|
user.updateAttributes({
|
|
first: 'updatedFirst',
|
|
last: 'updatedLast'
|
|
}, function (err, updatedUser) {
|
|
assert(!err);
|
|
assert.equal(updatedUser.first, 'updatedFirst');
|
|
assert.equal(updatedUser.last, 'updatedLast');
|
|
assert.equal(updatedUser.age, 100);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.upsert(data, callback)', function() {
|
|
it("Update when record with id=data.id found, insert otherwise", function(done) {
|
|
User.upsert({first: 'joe', id: 7}, function (err, user) {
|
|
assert(!err);
|
|
assert.equal(user.first, 'joe');
|
|
|
|
User.upsert({first: 'bob', id: 7}, function (err, updatedUser) {
|
|
assert(!err);
|
|
assert.equal(updatedUser.first, 'bob');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('model.destroy([callback])', function() {
|
|
it("Remove a model from the attached data source", function(done) {
|
|
User.create({first: 'joe', last: 'bob'}, function (err, user) {
|
|
User.findById(user.id, function (err, foundUser) {
|
|
assert.equal(user.id, foundUser.id);
|
|
foundUser.destroy(function () {
|
|
User.findById(user.id, function (err, notFound) {
|
|
assert(!err);
|
|
assert.equal(notFound, null);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.deleteById([callback])', function () {
|
|
it("Delete a model instance from the attached data source", function (done) {
|
|
User.create({first: 'joe', last: 'bob'}, function (err, user) {
|
|
User.deleteById(user.id, function (err) {
|
|
User.findById(user.id, function (err, notFound) {
|
|
assert(!err);
|
|
assert.equal(notFound, null);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.destroyAll(callback)', function() {
|
|
it("Delete all Model instances from data source", function(done) {
|
|
(new TaskEmitter())
|
|
.task(User, 'create', {first: 'jill'})
|
|
.task(User, 'create', {first: 'bob'})
|
|
.task(User, 'create', {first: 'jan'})
|
|
.task(User, 'create', {first: 'sam'})
|
|
.task(User, 'create', {first: 'suzy'})
|
|
.on('done', function () {
|
|
User.count(function (err, count) {
|
|
assert.equal(count, 5);
|
|
User.destroyAll(function () {
|
|
User.count(function (err, count) {
|
|
assert.equal(count, 0);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.findById(id, callback)', function() {
|
|
it("Find an instance by id", function(done) {
|
|
User.create({first: 'michael', last: 'jordan', id: 23}, function () {
|
|
User.findById(23, function (err, user) {
|
|
assert.equal(user.id, 23);
|
|
assert.equal(user.first, 'michael');
|
|
assert.equal(user.last, 'jordan');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.count([query], callback)', function() {
|
|
it("Query count of Model instances in data source", function(done) {
|
|
(new TaskEmitter())
|
|
.task(User, 'create', {first: 'jill', age: 100})
|
|
.task(User, 'create', {first: 'bob', age: 200})
|
|
.task(User, 'create', {first: 'jan'})
|
|
.task(User, 'create', {first: 'sam'})
|
|
.task(User, 'create', {first: 'suzy'})
|
|
.on('done', function () {
|
|
User.count({age: {gt: 99}}, function (err, count) {
|
|
assert.equal(count, 2);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Remote Methods', function(){
|
|
beforeEach(function () {
|
|
User.login = function (username, password, fn) {
|
|
if(username === 'foo' && password === 'bar') {
|
|
fn(null, 123);
|
|
} else {
|
|
throw new Error('bad username and password!');
|
|
}
|
|
}
|
|
|
|
loopback.remoteMethod(
|
|
User.login,
|
|
{
|
|
accepts: [
|
|
{arg: 'username', type: 'string', required: true},
|
|
{arg: 'password', type: 'string', required: true}
|
|
],
|
|
returns: {arg: 'sessionId', type: 'any', root: true},
|
|
http: {path: '/sign-in', verb: 'get'}
|
|
}
|
|
);
|
|
|
|
app.use(loopback.rest());
|
|
app.model(User);
|
|
});
|
|
|
|
describe('Example Remote Method', function () {
|
|
it('Call the method using HTTP / REST', function(done) {
|
|
request(app)
|
|
.get('/users/sign-in?username=foo&password=bar')
|
|
.expect('Content-Type', /json/)
|
|
.expect(200)
|
|
.end(function(err, res){
|
|
if(err) return done(err);
|
|
assert.equal(res.body, 123);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('Converts null result of findById to 404 Not Found', function(done) {
|
|
request(app)
|
|
.get('/users/not-found')
|
|
.expect(404)
|
|
.end(done);
|
|
});
|
|
});
|
|
|
|
describe('Model.beforeRemote(name, fn)', function(){
|
|
it('Run a function before a remote method is called by a client', function(done) {
|
|
var hookCalled = false;
|
|
|
|
User.beforeRemote('create', function(ctx, user, next) {
|
|
hookCalled = true;
|
|
next();
|
|
});
|
|
|
|
// invoke save
|
|
request(app)
|
|
.post('/users')
|
|
.send({data: {first: 'foo', last: 'bar'}})
|
|
.expect('Content-Type', /json/)
|
|
.expect(200)
|
|
.end(function(err, res) {
|
|
if(err) return done(err);
|
|
assert(hookCalled, 'hook wasnt called');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.afterRemote(name, fn)', function(){
|
|
it('Run a function after a remote method is called by a client', function(done) {
|
|
var beforeCalled = false;
|
|
var afterCalled = false;
|
|
|
|
User.beforeRemote('create', function(ctx, user, next) {
|
|
assert(!afterCalled);
|
|
beforeCalled = true;
|
|
next();
|
|
});
|
|
User.afterRemote('create', function(ctx, user, next) {
|
|
assert(beforeCalled);
|
|
afterCalled = true;
|
|
next();
|
|
});
|
|
|
|
// invoke save
|
|
request(app)
|
|
.post('/users')
|
|
.send({data: {first: 'foo', last: 'bar'}})
|
|
.expect('Content-Type', /json/)
|
|
.expect(200)
|
|
.end(function(err, res) {
|
|
if(err) return done(err);
|
|
assert(beforeCalled, 'before hook was not called');
|
|
assert(afterCalled, 'after hook was not called');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Remote Method invoking context', function () {
|
|
// describe('ctx.user', function() {
|
|
// it("The remote user model calling the method remotely", function(done) {
|
|
// done(new Error('test not implemented'));
|
|
// });
|
|
// });
|
|
|
|
describe('ctx.req', function() {
|
|
it("The express ServerRequest object", function(done) {
|
|
var hookCalled = false;
|
|
|
|
User.beforeRemote('create', function(ctx, user, next) {
|
|
hookCalled = true;
|
|
assert(ctx.req);
|
|
assert(ctx.req.url);
|
|
assert(ctx.req.method);
|
|
assert(ctx.res);
|
|
assert(ctx.res.write);
|
|
assert(ctx.res.end);
|
|
next();
|
|
});
|
|
|
|
// invoke save
|
|
request(app)
|
|
.post('/users')
|
|
.send({data: {first: 'foo', last: 'bar'}})
|
|
.expect('Content-Type', /json/)
|
|
.expect(200)
|
|
.end(function(err, res) {
|
|
if(err) return done(err);
|
|
assert(hookCalled);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('ctx.res', function() {
|
|
it("The express ServerResponse object", function(done) {
|
|
var hookCalled = false;
|
|
|
|
User.beforeRemote('create', function(ctx, user, next) {
|
|
hookCalled = true;
|
|
assert(ctx.req);
|
|
assert(ctx.req.url);
|
|
assert(ctx.req.method);
|
|
assert(ctx.res);
|
|
assert(ctx.res.write);
|
|
assert(ctx.res.end);
|
|
next();
|
|
});
|
|
|
|
// invoke save
|
|
request(app)
|
|
.post('/users')
|
|
.send({data: {first: 'foo', last: 'bar'}})
|
|
.expect('Content-Type', /json/)
|
|
.expect(200)
|
|
.end(function(err, res) {
|
|
if(err) return done(err);
|
|
assert(hookCalled);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
})
|
|
});
|
|
|
|
describe('Model.hasMany(Model)', function() {
|
|
it("Define a one to many relationship", function(done) {
|
|
var Book = memory.createModel('book', {title: String, author: String});
|
|
var Chapter = memory.createModel('chapter', {title: String});
|
|
|
|
// by referencing model
|
|
Book.hasMany(Chapter);
|
|
|
|
Book.create({title: 'Into the Wild', author: 'Jon Krakauer'}, function(err, book) {
|
|
// using 'chapters' scope for build:
|
|
var c = book.chapters.build({title: 'Chapter 1'});
|
|
book.chapters.create({title: 'Chapter 2'}, function () {
|
|
c.save(function () {
|
|
Chapter.count({bookId: book.id}, function (err, count) {
|
|
assert.equal(count, 2);
|
|
book.chapters({where: {title: 'Chapter 1'}}, function(err, chapters) {
|
|
assert.equal(chapters.length, 1);
|
|
assert.equal(chapters[0].title, 'Chapter 1');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.properties', function(){
|
|
it('Normalized properties passed in originally by loopback.createModel()', function() {
|
|
var props = {
|
|
s: String,
|
|
n: {type: 'Number'},
|
|
o: {type: 'String', min: 10, max: 100},
|
|
d: Date,
|
|
g: loopback.GeoPoint
|
|
};
|
|
|
|
var MyModel = loopback.createModel('foo', props);
|
|
|
|
Object.keys(MyModel.definition.properties).forEach(function (key) {
|
|
var p = MyModel.definition.properties[key];
|
|
var o = MyModel.definition.properties[key];
|
|
assert(p);
|
|
assert(o);
|
|
assert(typeof p.type === 'function');
|
|
|
|
if(typeof o === 'function') {
|
|
// the normalized property
|
|
// should match the given property
|
|
assert(
|
|
p.type.name === o.name
|
|
||
|
|
p.type.name === o
|
|
)
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.extend()', function(){
|
|
it('Create a new model by extending an existing model', function() {
|
|
var User = loopback.Model.extend('test-user', {
|
|
email: String
|
|
});
|
|
|
|
User.foo = function () {
|
|
return 'bar';
|
|
}
|
|
|
|
User.prototype.bar = function () {
|
|
return 'foo';
|
|
}
|
|
|
|
var MyUser = User.extend('my-user', {
|
|
a: String,
|
|
b: String
|
|
});
|
|
|
|
assert.equal(MyUser.prototype.bar, User.prototype.bar);
|
|
assert.equal(MyUser.foo, User.foo);
|
|
|
|
var user = new MyUser({
|
|
email: 'foo@bar.com',
|
|
a: 'foo',
|
|
b: 'bar'
|
|
});
|
|
|
|
assert.equal(user.email, 'foo@bar.com');
|
|
assert.equal(user.a, 'foo');
|
|
assert.equal(user.b, 'bar');
|
|
});
|
|
});
|
|
|
|
describe('Model.extend() events', function() {
|
|
it('create isolated emitters for subclasses', function() {
|
|
var User1 = loopback.createModel('User1', {
|
|
'first': String,
|
|
'last': String
|
|
});
|
|
|
|
var User2 = loopback.createModel('User2', {
|
|
'name': String
|
|
});
|
|
|
|
var user1Triggered = false;
|
|
User1.once('x', function(event) {
|
|
user1Triggered = true;
|
|
});
|
|
|
|
|
|
var user2Triggered = false;
|
|
User2.once('x', function(event) {
|
|
user2Triggered = true;
|
|
});
|
|
|
|
assert(User1.once !== User2.once);
|
|
assert(User1.once !== loopback.Model.once);
|
|
|
|
User1.emit('x', User1);
|
|
|
|
assert(user1Triggered);
|
|
assert(!user2Triggered);
|
|
});
|
|
|
|
});
|
|
|
|
describe('Model.checkAccessTypeForMethod(remoteMethod)', function () {
|
|
shouldReturn('create', ACL.WRITE);
|
|
shouldReturn('updateOrCreate', ACL.WRITE);
|
|
shouldReturn('upsert', ACL.WRITE);
|
|
shouldReturn('exists', ACL.READ);
|
|
shouldReturn('findById', ACL.READ);
|
|
shouldReturn('find', ACL.READ);
|
|
shouldReturn('findOne', ACL.READ);
|
|
shouldReturn('destroyById', ACL.WRITE);
|
|
shouldReturn('deleteById', ACL.WRITE);
|
|
shouldReturn('removeById', ACL.WRITE);
|
|
shouldReturn('count', ACL.READ);
|
|
shouldReturn('unkown-model-method', ACL.EXECUTE);
|
|
|
|
function shouldReturn(methodName, expectedAccessType) {
|
|
describe(methodName, function () {
|
|
it('should return ' + expectedAccessType, function() {
|
|
var remoteMethod = {name: methodName};
|
|
assert.equal(
|
|
User._getAccessTypeForMethod(remoteMethod),
|
|
expectedAccessType
|
|
);
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
describe('Model.getChangeModel()', function() {
|
|
it('Get the Change Model', function () {
|
|
var UserChange = User.getChangeModel();
|
|
var change = new UserChange();
|
|
assert(change instanceof Change);
|
|
});
|
|
});
|
|
|
|
describe('Model.getSourceId(callback)', function() {
|
|
it('Get the Source Id', function (done) {
|
|
User.getSourceId(function(err, id) {
|
|
assert.equal('memory-user', id);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.checkpoint(callback)', function() {
|
|
it('Create a checkpoint', function (done) {
|
|
var Checkpoint = User.getChangeModel().getCheckpointModel();
|
|
var tasks = [
|
|
getCurrentCheckpoint,
|
|
checkpoint
|
|
];
|
|
var result;
|
|
var current;
|
|
|
|
async.parallel(tasks, function(err) {
|
|
if(err) return done(err);
|
|
|
|
assert.equal(result, current + 1);
|
|
done();
|
|
});
|
|
|
|
function getCurrentCheckpoint(cb) {
|
|
Checkpoint.current(function(err, cp) {
|
|
current = cp;
|
|
cb(err);
|
|
});
|
|
}
|
|
|
|
function checkpoint(cb) {
|
|
User.checkpoint(function(err, cp) {
|
|
result = cp.id;
|
|
cb(err);
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('Replication / Change APIs', function() {
|
|
beforeEach(function(done) {
|
|
var test = this;
|
|
this.dataSource = loopback.createDataSource({connector: loopback.Memory});
|
|
var SourceModel = this.SourceModel = this.dataSource.createModel('SourceModel', {}, {
|
|
trackChanges: true
|
|
});
|
|
var TargetModel = this.TargetModel = this.dataSource.createModel('TargetModel', {}, {
|
|
trackChanges: true
|
|
});
|
|
|
|
var createOne = SourceModel.create.bind(SourceModel, {
|
|
name: 'baz'
|
|
});
|
|
|
|
async.parallel([
|
|
createOne,
|
|
function(cb) {
|
|
SourceModel.currentCheckpoint(function(err, id) {
|
|
if(err) return cb(err);
|
|
test.startingCheckpoint = id;
|
|
cb();
|
|
});
|
|
}
|
|
], process.nextTick.bind(process, done));
|
|
});
|
|
|
|
describe('Model.changes(since, filter, callback)', function() {
|
|
it('Get changes since the given checkpoint', function (done) {
|
|
this.SourceModel.changes(this.startingCheckpoint, {}, function(err, changes) {
|
|
assert.equal(changes.length, 1);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Model.replicate(since, targetModel, options, callback)', function() {
|
|
it('Replicate data using the target model', function (done) {
|
|
var test = this;
|
|
var options = {};
|
|
var sourceData;
|
|
var targetData;
|
|
|
|
this.SourceModel.replicate(this.startingCheckpoint, this.TargetModel,
|
|
options, function(err, conflicts) {
|
|
assert(conflicts.length === 0);
|
|
async.parallel([
|
|
function(cb) {
|
|
test.SourceModel.find(function(err, result) {
|
|
if(err) return cb(err);
|
|
sourceData = result;
|
|
cb();
|
|
});
|
|
},
|
|
function(cb) {
|
|
test.TargetModel.find(function(err, result) {
|
|
if(err) return cb(err);
|
|
targetData = result;
|
|
cb();
|
|
});
|
|
}
|
|
], function(err) {
|
|
if(err) return done(err);
|
|
|
|
assert.deepEqual(sourceData, targetData);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|