loopback-datasource-juggler/test/loopback-dl.test.js

2031 lines
60 KiB
JavaScript
Raw Normal View History

2016-04-06 14:51:49 +00:00
// Copyright IBM Corp. 2013,2016. All Rights Reserved.
// Node module: loopback-datasource-juggler
// This file is licensed under the MIT License.
// License text available at https://opensource.org/licenses/MIT
2016-10-19 21:35:26 +00:00
'use strict';
2016-04-06 14:51:49 +00:00
2013-05-28 20:50:59 +00:00
// This test written in mocha+should.js
var should = require('./init.js');
2013-07-12 19:39:38 +00:00
var assert = require('assert');
2014-03-04 01:16:37 +00:00
var async = require('async');
2013-05-28 20:50:59 +00:00
var jdb = require('../');
var ModelBuilder = jdb.ModelBuilder;
var DataSource = jdb.DataSource;
describe('ModelBuilder', function() {
it('supports plain models', function(done) {
2014-01-24 17:09:53 +00:00
var modelBuilder = new ModelBuilder();
2014-01-24 17:09:53 +00:00
var User = modelBuilder.define('User', {
name: String,
bio: ModelBuilder.Text,
approved: Boolean,
joinedAt: Date,
age: Number,
});
2014-01-24 17:09:53 +00:00
// define any custom method
User.prototype.getNameAndAge = function() {
2014-01-24 17:09:53 +00:00
return this.name + ', ' + this.age;
};
modelBuilder.models.should.be.type('object').and.have.property('User').exactly(User);
modelBuilder.definitions.should.be.type('object').and.have.property('User');
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', age: 20, xyz: false});
2014-01-24 17:09:53 +00:00
User.modelName.should.equal('User');
user.should.be.type('object').and.have.property('name', 'Joe');
2014-01-24 17:09:53 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('age', 20);
user.should.have.property('xyz', false);
user.should.have.property('bio', undefined);
2014-01-24 17:09:53 +00:00
done(null, User);
});
it('ignores unknown properties in strict mode', function(done) {
2014-01-24 17:09:53 +00:00
var modelBuilder = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = modelBuilder.define('User', {name: String, bio: String}, {strict: true});
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', age: 20});
2014-01-24 17:09:53 +00:00
User.modelName.should.equal('User');
user.should.be.type('object');
2014-02-04 04:52:01 +00:00
user.should.have.property('name', 'Joe');
user.should.not.have.property('age');
user.toObject().should.not.have.property('age');
user.toObject(true).should.not.have.property('age');
user.should.have.property('bio', undefined);
2014-01-24 17:09:53 +00:00
done(null, User);
});
it('ignores non-predefined properties in strict mode', function(done) {
var modelBuilder = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = modelBuilder.define('User', {name: String, bio: String}, {strict: true});
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe'});
user.age = 10;
user.bio = 'me';
2014-02-04 04:52:01 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('bio', 'me');
// Non predefined property age should be ignored in strict mode if schemaOnly parameter is not false
user.toObject().should.not.have.property('age');
user.toObject(true).should.not.have.property('age');
user.toObject(false).should.have.property('age', 10);
// Predefined property bio should be kept in strict mode
user.toObject().should.have.property('bio', 'me');
user.toObject(true).should.have.property('bio', 'me');
user.toObject(false).should.have.property('bio', 'me');
done(null, User);
});
it('throws an error when unknown properties are used if strict=throw', function(done) {
2014-01-24 17:09:53 +00:00
var modelBuilder = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = modelBuilder.define('User', {name: String, bio: String}, {strict: 'throw'});
2013-05-28 20:50:59 +00:00
2014-01-24 17:09:53 +00:00
try {
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', age: 20});
2014-01-24 17:09:53 +00:00
assert(false, 'The code should have thrown an error');
} catch (e) {
assert(true, 'The code is expected to throw an error');
}
done(null, User);
});
2013-05-28 20:50:59 +00:00
it('supports open models', function(done) {
2014-01-24 17:09:53 +00:00
var modelBuilder = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = modelBuilder.define('User', {}, {strict: false});
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', age: 20});
2014-01-24 17:09:53 +00:00
User.modelName.should.equal('User');
user.should.be.type('object').and.have.property('name', 'Joe');
2014-01-24 17:09:53 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('age', 20);
user.should.not.have.property('bio');
done(null, User);
});
it('accepts non-predefined properties in non-strict mode', function(done) {
var modelBuilder = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = modelBuilder.define('User', {name: String, bio: String}, {strict: false});
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe'});
user.age = 10;
user.bio = 'me';
2014-02-04 04:52:01 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('bio', 'me');
// Non predefined property age should be kept in non-strict mode
user.toObject().should.have.property('age', 10);
user.toObject(true).should.have.property('age', 10);
user.toObject(false).should.have.property('age', 10);
// Predefined property bio should be kept
user.toObject().should.have.property('bio', 'me');
user.toObject(true).should.have.property('bio', 'me');
user.toObject(false).should.have.property('bio', 'me');
done(null, User);
});
it('uses non-strict mode by default', function(done) {
2014-01-24 17:09:53 +00:00
var modelBuilder = new ModelBuilder();
2013-07-11 21:24:47 +00:00
2014-01-24 17:09:53 +00:00
var User = modelBuilder.define('User', {});
2013-07-11 21:24:47 +00:00
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', age: 20});
2013-07-11 21:24:47 +00:00
2014-01-24 17:09:53 +00:00
User.modelName.should.equal('User');
user.should.be.type('object').and.have.property('name', 'Joe');
2014-01-24 17:09:53 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('age', 20);
user.should.not.have.property('bio');
done(null, User);
});
2013-07-11 21:24:47 +00:00
it('supports nested model definitions', function(done) {
2014-01-24 17:09:53 +00:00
var modelBuilder = new ModelBuilder();
2013-07-11 21:24:47 +00:00
2014-01-24 17:09:53 +00:00
// simplier way to describe model
var User = modelBuilder.define('User', {
name: String,
bio: ModelBuilder.Text,
approved: Boolean,
joinedAt: Date,
age: Number,
address: {
street: String,
city: String,
state: String,
zipCode: String,
country: String,
2014-01-24 17:09:53 +00:00
},
emails: [
{
label: String,
email: String,
},
2014-01-24 17:09:53 +00:00
],
friends: [String],
2013-07-11 21:24:47 +00:00
});
2014-01-24 17:09:53 +00:00
// define any custom method
User.prototype.getNameAndAge = function() {
2014-01-24 17:09:53 +00:00
return this.name + ', ' + this.age;
};
modelBuilder.models.should.be.type('object').and.have.property('User', User);
modelBuilder.definitions.should.be.type('object').and.have.property('User');
2014-01-24 17:09:53 +00:00
var user = new User({
name: 'Joe', age: 20,
2016-10-19 21:04:05 +00:00
address: {street: '123 Main St', 'city': 'San Jose', state: 'CA'},
2014-01-24 17:09:53 +00:00
emails: [
2016-10-19 21:04:05 +00:00
{label: 'work', email: 'xyz@sample.com'},
2014-01-24 17:09:53 +00:00
],
friends: ['Mary', 'John'],
2014-01-24 17:09:53 +00:00
});
User.modelName.should.equal('User');
user.should.be.type('object').and.have.property('name', 'Joe');
2014-01-24 17:09:53 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('age', 20);
user.should.have.property('bio', undefined);
2014-01-24 17:09:53 +00:00
user.should.have.property('address');
user.address.should.have.property('city', 'San Jose');
user.address.should.have.property('state', 'CA');
user = user.toObject();
user.emails.should.have.property('length', 1);
user.emails[0].should.have.property('label', 'work');
user.emails[0].should.have.property('email', 'xyz@sample.com');
user.friends.should.have.property('length', 2);
assert.equal(user.friends[0], 'Mary');
assert.equal(user.friends[1], 'John');
done(null, User);
});
it('allows models to be referenced by name before they are defined', function(done) {
2014-01-24 17:09:53 +00:00
var modelBuilder = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = modelBuilder.define('User', {name: String, address: 'Address'});
2014-01-24 17:09:53 +00:00
var user;
try {
2016-10-19 21:04:05 +00:00
user = new User({name: 'Joe', address: {street: '123 Main St', 'city': 'San Jose', state: 'CA'}});
2014-01-24 17:09:53 +00:00
assert(false, 'An exception should have been thrown');
} catch (e) {
// Ignore
}
var Address = modelBuilder.define('Address', {
street: String,
city: String,
state: String,
zipCode: String,
country: String,
});
2016-10-19 21:04:05 +00:00
user = new User({name: 'Joe', address: {street: '123 Main St', 'city': 'San Jose', state: 'CA'}});
2013-07-11 21:24:47 +00:00
2014-01-24 17:09:53 +00:00
User.modelName.should.equal('User');
User.definition.properties.address.should.have.property('type', Address);
user.should.be.type('object');
2014-01-24 17:09:53 +00:00
assert(user.name === 'Joe');
user.address.should.have.property('city', 'San Jose');
user.address.should.have.property('state', 'CA');
done(null, User);
});
2013-05-28 20:50:59 +00:00
it('defines an id property for composite ids', function() {
var modelBuilder = new ModelBuilder();
var Follow = modelBuilder.define('Follow', {
2016-10-19 21:04:05 +00:00
followerId: {type: String, id: 1},
followeeId: {type: String, id: 2},
followAt: Date,
});
2016-10-19 21:04:05 +00:00
var follow = new Follow({followerId: 1, followeeId: 2});
follow.should.have.property('id');
2016-10-19 21:04:05 +00:00
assert.deepEqual(follow.id, {followerId: 1, followeeId: 2});
});
2014-01-24 17:09:53 +00:00
});
2013-05-28 20:50:59 +00:00
describe('DataSource ping', function() {
var ds = new DataSource('memory');
ds.settings.connectionTimeout = 50; // ms
ds.connector.connect = function(cb) {
// Mock up the long delay
setTimeout(cb, 100);
};
ds.connector.ping = function(cb) {
cb(new Error('bad connection 2'));
};
it('reports connection errors during ping', function(done) {
ds.ping(function(err) {
(!!err).should.be.true;
err.message.should.be.eql('bad connection 2');
done();
});
});
it('cancels invocation after timeout', function(done) {
ds.connected = false; // Force connect
var Post = ds.define('Post', {
2016-10-19 21:04:05 +00:00
title: {type: String, length: 255},
});
Post.create(function(err) {
(!!err).should.be.true;
err.message.should.be.eql('Timeout in connecting after 50 ms');
done();
});
});
});
describe('DataSource define model', function() {
it('supports plain model definitions', function() {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2013-05-28 20:50:59 +00:00
// define models
2014-01-24 17:09:53 +00:00
var Post = ds.define('Post', {
2016-10-19 21:04:05 +00:00
title: {type: String, length: 255},
content: {type: ModelBuilder.Text},
date: {type: Date, default: function() {
2014-01-24 17:09:53 +00:00
return new Date();
2016-10-19 21:04:05 +00:00
}},
timestamp: {type: Number, default: Date.now},
published: {type: Boolean, default: false, index: true},
2014-01-24 17:09:53 +00:00
});
2013-05-28 20:50:59 +00:00
// simpler way to describe model
2014-01-24 17:09:53 +00:00
var User = ds.define('User', {
name: String,
bio: ModelBuilder.Text,
approved: Boolean,
2016-10-19 21:04:05 +00:00
joinedAt: {type: Date, default: Date},
age: Number,
2014-01-24 17:09:53 +00:00
});
2013-05-28 20:50:59 +00:00
2016-10-19 21:04:05 +00:00
var Group = ds.define('Group', {group: String});
2014-01-24 17:09:53 +00:00
User.mixin(Group);
2013-05-28 20:50:59 +00:00
// define any custom method
User.prototype.getNameAndAge = function() {
2014-01-24 17:09:53 +00:00
return this.name + ', ' + this.age;
};
2013-05-28 20:50:59 +00:00
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', group: 'G1'});
2014-01-24 17:09:53 +00:00
assert.equal(user.name, 'Joe');
assert.equal(user.group, 'G1');
2013-05-28 20:50:59 +00:00
assert(user.joinedAt instanceof Date);
2014-01-24 17:09:53 +00:00
// setup relationships
2016-10-19 21:04:05 +00:00
User.hasMany(Post, {as: 'posts', foreignKey: 'userId'});
2013-05-28 20:50:59 +00:00
2016-10-19 21:04:05 +00:00
Post.belongsTo(User, {as: 'author', foreignKey: 'userId'});
2013-05-28 20:50:59 +00:00
2014-01-24 17:09:53 +00:00
User.hasAndBelongsToMany('groups');
2013-05-28 20:50:59 +00:00
2016-10-19 21:04:05 +00:00
var user2 = new User({name: 'Smith'});
user2.save(function(err) {
2016-10-19 21:04:05 +00:00
var post = user2.posts.build({title: 'Hello world'});
post.save(function(err, data) {
2014-01-24 17:09:53 +00:00
// console.log(err ? err : data);
});
});
2013-05-28 20:50:59 +00:00
2016-10-19 21:04:05 +00:00
Post.findOne({where: {published: false}, order: 'date DESC'}, function(err, data) {
2014-01-24 17:09:53 +00:00
// console.log(data);
});
2013-05-28 20:50:59 +00:00
2016-10-19 21:04:05 +00:00
User.create({name: 'Jeff'}, function(err, data) {
2014-01-24 17:09:53 +00:00
if (err) {
console.log(err);
return;
}
2016-10-19 21:04:05 +00:00
var post = data.posts.build({title: 'My Post'});
2014-01-24 17:09:53 +00:00
});
2013-05-28 20:50:59 +00:00
2016-10-19 21:04:05 +00:00
User.create({name: 'Ray'}, function(err, data) {
2014-01-24 17:09:53 +00:00
// console.log(data);
});
2016-10-19 21:04:05 +00:00
var Article = ds.define('Article', {title: String});
var Tag = ds.define('Tag', {name: String});
2014-01-24 17:09:53 +00:00
Article.hasAndBelongsToMany('tags');
2013-05-28 20:50:59 +00:00
Article.create(function(e, article) {
2016-10-19 21:04:05 +00:00
article.tags.create({name: 'popular'}, function(err, data) {
Article.findOne(function(e, article) {
article.tags(function(e, tags) {
2014-01-24 17:09:53 +00:00
// console.log(tags);
});
2013-05-28 20:50:59 +00:00
});
2014-01-24 17:09:53 +00:00
});
});
2013-05-28 20:50:59 +00:00
// should be able to attach a data source to an existing model
2014-01-24 17:09:53 +00:00
var modelBuilder = new ModelBuilder();
2013-05-28 20:50:59 +00:00
2014-01-24 17:09:53 +00:00
var Color = modelBuilder.define('Color', {
name: String,
2014-01-24 17:09:53 +00:00
});
2013-05-28 20:50:59 +00:00
2014-01-24 17:09:53 +00:00
Color.should.not.have.property('create');
2013-05-28 20:50:59 +00:00
// attach
2014-01-24 17:09:53 +00:00
ds.attach(Color);
Color.should.have.property('create');
2013-05-28 20:50:59 +00:00
2016-10-19 21:04:05 +00:00
Color.create({name: 'red'});
Color.create({name: 'green'});
Color.create({name: 'blue'});
2013-05-28 20:50:59 +00:00
Color.all(function(err, colors) {
2014-01-24 17:09:53 +00:00
colors.should.have.lengthOf(3);
2013-05-28 20:50:59 +00:00
});
2014-01-24 17:09:53 +00:00
});
it('emits events during attach', function() {
var ds = new DataSource('memory');
var modelBuilder = new ModelBuilder();
var User = modelBuilder.define('User', {
name: String,
});
var seq = 0;
var dataAccessConfigured = -1;
var dataSourceAttached = -1;
User.on('dataAccessConfigured', function(model) {
dataAccessConfigured = seq++;
assert(User.create);
assert(User.hasMany);
});
User.on('dataSourceAttached', function(model) {
assert(User.dataSource instanceof DataSource);
dataSourceAttached = seq++;
});
ds.attach(User);
assert.equal(dataAccessConfigured, 0);
assert.equal(dataSourceAttached, 1);
});
it('ignores unknown properties in strict mode', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String, bio: String}, {strict: true});
2016-10-19 21:04:05 +00:00
User.create({name: 'Joe', age: 20}, function(err, user) {
2014-01-24 17:09:53 +00:00
User.modelName.should.equal('User');
user.should.be.type('object');
2014-01-24 17:09:53 +00:00
assert(user.name === 'Joe');
assert(user.age === undefined);
assert(user.toObject().age === undefined);
assert(user.toObject(true).age === undefined);
assert(user.bio === undefined);
done(null, User);
});
2014-01-24 17:09:53 +00:00
});
it('throws an error when unknown properties are used if strict=throw', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String, bio: String}, {strict: 'throw'});
2014-01-24 17:09:53 +00:00
try {
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', age: 20});
2014-01-24 17:09:53 +00:00
assert(false, 'The code should have thrown an error');
} catch (e) {
assert(true, 'The code is expected to throw an error');
}
done(null, User);
});
describe('strict mode "validate"', function() {
it('reports validation errors for unknown properties', function() {
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String}, {strict: 'validate'});
var user = new User({name: 'Joe', age: 20});
user.isValid().should.be.false;
var codes = user.errors && user.errors.codes || {};
codes.should.have.property('age').eql(['unknown-property']);
});
});
it('supports open model definitions', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {}, {strict: false});
2014-01-24 17:09:53 +00:00
User.modelName.should.equal('User');
2016-10-19 21:04:05 +00:00
User.create({name: 'Joe', age: 20}, function(err, user) {
user.should.be.type('object').and.have.property('name', 'Joe');
2014-01-24 17:09:53 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('age', 20);
user.should.not.have.property('bio');
User.findById(user.id, function(err, user) {
user.should.be.type('object').and.have.property('name', 'Joe');
2014-01-24 17:09:53 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('age', 20);
user.should.not.have.property('bio');
done(null, User);
});
});
2014-01-24 17:09:53 +00:00
});
it('uses non-strict mode by default', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2014-01-24 17:09:53 +00:00
var User = ds.define('User', {});
2016-10-19 21:04:05 +00:00
User.create({name: 'Joe', age: 20}, function(err, user) {
2014-01-24 17:09:53 +00:00
User.modelName.should.equal('User');
user.should.be.type('object').and.have.property('name', 'Joe');
2014-01-24 17:09:53 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('age', 20);
user.should.not.have.property('bio');
done(null, User);
});
2014-01-24 17:09:53 +00:00
});
it('uses strict mode by default for relational DBs', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
ds.connector.relational = true; // HACK
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String, bio: String}, {strict: true});
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', age: 20});
2014-01-24 17:09:53 +00:00
User.modelName.should.equal('User');
user.should.be.type('object');
2014-01-24 17:09:53 +00:00
assert(user.name === 'Joe');
assert(user.age === undefined);
assert(user.toObject().age === undefined);
assert(user.toObject(true).age === undefined);
assert(user.bio === undefined);
done(null, User);
});
it('throws an error with unknown properties in non-strict mode for relational DBs', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
ds.connector.relational = true; // HACK
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String, bio: String}, {strict: 'throw'});
2014-01-24 17:09:53 +00:00
try {
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', age: 20});
2014-01-24 17:09:53 +00:00
assert(false, 'The code should have thrown an error');
} catch (e) {
assert(true, 'The code is expected to throw an error');
}
done(null, User);
});
it('changes the property value for save in non-strict mode', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');// define models
var Post = ds.define('Post');
2016-10-19 21:04:05 +00:00
Post.create({price: 900}, function(err, post) {
2014-01-24 17:09:53 +00:00
assert.equal(post.price, 900);
post.price = 1000;
post.save(function(err, result) {
2014-01-24 17:09:53 +00:00
assert.equal(1000, result.price);
done(err, result);
});
});
2014-01-24 17:09:53 +00:00
});
it('supports instance level strict mode', function() {
2014-02-11 06:46:25 +00:00
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String, bio: String}, {strict: true});
2014-02-11 06:46:25 +00:00
2016-10-19 21:04:05 +00:00
var user = new User({name: 'Joe', age: 20}, {strict: false});
2014-02-11 06:46:25 +00:00
user.should.have.property('__strict', false);
user.should.be.type('object');
2014-02-11 06:46:25 +00:00
user.should.have.property('name', 'Joe');
user.should.have.property('age', 20);
user.toObject().should.have.property('age', 20);
user.toObject(true).should.have.property('age', 20);
user.setStrict(true);
user.toObject().should.not.have.property('age');
user.toObject(true).should.not.have.property('age');
user.toObject(false).should.have.property('age', 20);
});
it('updates instances with unknown properties in non-strict mode', function(done) {
var ds = new DataSource('memory');// define models
2016-10-19 21:35:26 +00:00
var Post = ds.define('Post', {
2016-10-19 21:04:05 +00:00
title: {type: String, length: 255, index: true},
content: {type: String},
});
2016-10-19 21:04:05 +00:00
Post.create({title: 'a', content: 'AAA'}, function(err, post) {
post.updateAttributes({title: 'b', xyz: 'xyz'}, function(err, p) {
should.not.exist(err);
p.id.should.be.equal(post.id);
p.content.should.be.equal(post.content);
p.xyz.should.be.equal('xyz');
Post.findById(post.id, function(err, p) {
p.id.should.be.equal(post.id);
p.content.should.be.equal(post.content);
p.xyz.should.be.equal('xyz');
p.title.should.be.equal('b');
done();
});
});
});
});
it('injects id by default', function(done) {
var ds = new ModelBuilder();
var User = ds.define('User', {});
assert.deepEqual(User.definition.properties.id,
2016-10-19 21:04:05 +00:00
{type: Number, id: 1, generated: true});
done();
});
it('disables idInjection if the value is false', function(done) {
var ds = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User1 = ds.define('User', {}, {idInjection: false});
assert(!User1.definition.properties.id);
done();
});
it('updates generated id type by the connector', function(done) {
var builder = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = builder.define('User', {id: {type: String, generated: true, id: true}});
assert.deepEqual(User.definition.properties.id,
2016-10-19 21:04:05 +00:00
{type: String, id: 1, generated: true});
var ds = new DataSource('memory');// define models
User.attachTo(ds);
assert.deepEqual(User.definition.properties.id,
2016-10-19 21:04:05 +00:00
{type: Number, id: 1, generated: true});
done();
});
it('allows an explicit remoting path', function() {
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String, bio: String}, {
http: {path: 'accounts'},
});
User.http.path.should.equal('/accounts');
});
it('allows an explicit remoting path with leading /', function() {
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String, bio: String}, {
http: {path: '/accounts'},
});
User.http.path.should.equal('/accounts');
});
2013-05-28 20:50:59 +00:00
});
2013-05-28 22:26:12 +00:00
describe('Model loaded with a base', function() {
it('has a base class according to the base option', function() {
var ds = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String});
2013-11-08 17:02:17 +00:00
2014-01-24 17:09:53 +00:00
User.staticMethod = function staticMethod() {
};
User.prototype.instanceMethod = function instanceMethod() {
};
2013-11-08 17:02:17 +00:00
2016-10-19 21:04:05 +00:00
var Customer = ds.define('Customer', {vip: Boolean}, {base: 'User'});
assert(Customer.prototype instanceof User);
2013-11-08 17:02:17 +00:00
assert(Customer.staticMethod === User.staticMethod);
assert(Customer.prototype.instanceMethod === User.prototype.instanceMethod);
assert.equal(Customer.base, User);
assert.equal(Customer.base, Customer.super_);
try {
2016-10-19 21:04:05 +00:00
var Customer1 = ds.define('Customer1', {vip: Boolean}, {base: 'User1'});
2014-01-24 17:09:53 +00:00
} catch (e) {
assert(e);
}
});
it('inherits properties from base model', function() {
var ds = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String});
2016-10-19 21:04:05 +00:00
var Customer = ds.define('Customer', {vip: Boolean}, {base: 'User'});
Customer.definition.properties.should.have.property('name');
Customer.definition.properties.name.should.have.property('type', String);
});
it('inherits properties by clone from base model', function() {
var ds = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String});
2016-10-19 21:04:05 +00:00
var Customer1 = ds.define('Customer1', {vip: Boolean}, {base: 'User'});
var Customer2 = ds.define('Customer2', {vip: Boolean}, {base: 'User'});
Customer1.definition.properties.should.have.property('name');
Customer2.definition.properties.should.have.property('name');
Customer1.definition.properties.name.should.not.be.equal(
Customer2.definition.properties.name);
Customer1.definition.properties.name.should.eql(
Customer2.definition.properties.name);
});
it('can remove properties from base model', function() {
2015-03-03 18:27:22 +00:00
var ds = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {username: String, email: String});
2015-03-03 18:27:22 +00:00
var Customer = ds.define('Customer',
2016-10-19 21:04:05 +00:00
{name: String, username: null, email: false},
{base: 'User'});
2015-03-03 18:27:22 +00:00
Customer.definition.properties.should.have.property('name');
// username/email are now shielded
Customer.definition.properties.should.not.have.property('username');
Customer.definition.properties.should.not.have.property('email');
2016-10-19 21:04:05 +00:00
var c = new Customer({name: 'John'});
2015-03-03 18:27:22 +00:00
c.should.have.property('username', undefined);
c.should.have.property('email', undefined);
c.should.have.property('name', 'John');
2016-10-19 21:04:05 +00:00
var u = new User({username: 'X', email: 'x@y.com'});
2015-03-03 18:27:22 +00:00
u.should.not.have.property('name');
u.should.have.property('username', 'X');
u.should.have.property('email', 'x@y.com');
});
it('can configure base class via parent argument', function() {
var ds = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String});
User.staticMethod = function staticMethod() {
};
User.prototype.instanceMethod = function instanceMethod() {
};
2016-10-19 21:04:05 +00:00
var Customer = ds.define('Customer', {vip: Boolean}, {}, User);
Customer.definition.properties.should.have.property('name');
Customer.definition.properties.name.should.have.property('type', String);
assert(Customer.prototype instanceof User);
assert(Customer.staticMethod === User.staticMethod);
assert(Customer.prototype.instanceMethod === User.prototype.instanceMethod);
assert.equal(Customer.base, User);
assert.equal(Customer.base, Customer.super_);
});
});
2013-05-28 22:26:12 +00:00
describe('Models attached to a dataSource', function() {
var Post;
before(function() {
var ds = new DataSource('memory');// define models
Post = ds.define('Post', {
2016-10-19 21:04:05 +00:00
title: {type: String, length: 255, index: true},
content: {type: String},
comments: [String],
});
});
beforeEach(function(done) {
Post.destroyAll(done);
});
describe('updateOrCreate', function() {
it('updates instances', function(done) {
Post.create({title: 'a', content: 'AAA'}, function(err, post) {
post.title = 'b';
Post.updateOrCreate(post, function(err, p) {
should.not.exist(err);
p.id.should.be.equal(post.id);
p.content.should.be.equal(post.content);
should.not.exist(p._id);
Post.findById(post.id, function(err, p) {
p.id.should.be.equal(post.id);
should.not.exist(p._id);
p.content.should.be.equal(post.content);
p.title.should.be.equal('b');
done();
});
});
});
});
it('updates instances without removing existing properties', function(done) {
Post.create({title: 'a', content: 'AAA', comments: ['Comment1']}, function(err, post) {
post = post.toObject();
delete post.title;
delete post.comments;
Post.updateOrCreate(post, function(err, p) {
should.not.exist(err);
p.id.should.be.equal(post.id);
p.content.should.be.equal(post.content);
should.not.exist(p._id);
Post.findById(post.id, function(err, p) {
p.id.should.be.equal(post.id);
should.not.exist(p._id);
p.content.should.be.equal(post.content);
p.title.should.be.equal('a');
p.comments.length.should.be.equal(1);
p.comments[0].should.be.equal('Comment1');
done();
});
});
});
});
it('creates a new instance if it does not exist', function(done) {
var post = {id: 123, title: 'a', content: 'AAA'};
Post.updateOrCreate(post, function(err, p) {
should.not.exist(err);
p.title.should.be.equal(post.title);
p.content.should.be.equal(post.content);
p.id.should.be.equal(post.id);
Post.findById(p.id, function(err, p) {
p.id.should.be.equal(post.id);
should.not.exist(p._id);
p.content.should.be.equal(post.content);
p.title.should.be.equal(post.title);
p.id.should.be.equal(post.id);
done();
});
});
});
});
describe('save', function() {
it('updates instance with the same id', function(done) {
Post.create({title: 'a', content: 'AAA'}, function(err, post) {
post.title = 'b';
post.save(function(err, p) {
should.not.exist(err);
p.id.should.be.equal(post.id);
p.content.should.be.equal(post.content);
should.not.exist(p._id);
Post.findById(post.id, function(err, p) {
p.id.should.be.equal(post.id);
should.not.exist(p._id);
p.content.should.be.equal(post.content);
p.title.should.be.equal('b');
done();
});
});
});
});
it('updates the instance without removing existing properties', function(done) {
Post.create({title: 'a', content: 'AAA'}, function(err, post) {
delete post.title;
post.save(function(err, p) {
should.not.exist(err);
p.id.should.be.equal(post.id);
p.content.should.be.equal(post.content);
should.not.exist(p._id);
Post.findById(post.id, function(err, p) {
p.id.should.be.equal(post.id);
should.not.exist(p._id);
p.content.should.be.equal(post.content);
p.title.should.be.equal('a');
done();
});
});
});
});
it('creates a new instance if it does not exist', function(done) {
var post = new Post({id: '123', title: 'a', content: 'AAA'});
post.save(post, function(err, p) {
should.not.exist(err);
p.title.should.be.equal(post.title);
p.content.should.be.equal(post.content);
p.id.should.be.equal(post.id);
Post.findById(p.id, function(err, p) {
p.id.should.be.equal(post.id);
should.not.exist(p._id);
p.content.should.be.equal(post.content);
p.title.should.be.equal(post.title);
p.id.should.be.equal(post.id);
done();
});
});
});
});
it('save should create a new instance if it does not exist', function(done) {
2016-10-19 21:04:05 +00:00
var post = new Post({id: '123', title: 'a', content: 'AAA'});
post.save(post, function(err, p) {
should.not.exist(err);
p.title.should.be.equal(post.title);
p.content.should.be.equal(post.content);
p.id.should.be.equal(post.id);
Post.findById(p.id, function(err, p) {
p.id.should.be.equal(post.id);
should.not.exist(p._id);
p.content.should.be.equal(post.content);
p.title.should.be.equal(post.title);
p.id.should.be.equal(post.id);
done();
});
});
});
});
describe('DataSource connector types', function() {
it('returns an array of types using getTypes', function() {
var ds = new DataSource('memory');
var types = ds.getTypes();
assert.deepEqual(types, ['db', 'nosql', 'memory']);
});
describe('supportTypes', function() {
it('tests supported types by string', function() {
var ds = new DataSource('memory');
var result = ds.supportTypes('db');
assert(result);
});
it('tests supported types by array', function() {
var ds = new DataSource('memory');
var result = ds.supportTypes(['db', 'memory']);
assert(result);
});
it('tests unsupported types by string', function() {
var ds = new DataSource('memory');
var result = ds.supportTypes('rdbms');
assert(!result);
});
it('tests unsupported types by array', function() {
var ds = new DataSource('memory');
var result = ds.supportTypes(['rdbms', 'memory']);
assert(!result);
result = ds.supportTypes(['rdbms']);
assert(!result);
});
});
});
describe('DataSource constructor', function() {
// Mocked require
var loader = function(name) {
if (name.indexOf('./connectors/') !== -1) {
// ./connectors/<name> doesn't exist
return null;
}
if (name === 'loopback-connector-abc') {
// Assume loopback-connector-abc doesn't exist
return null;
}
return {
name: name,
};
};
it('resolves connector by path', function() {
var connector = DataSource._resolveConnector(__dirname + '/../lib/connectors/memory');
assert(connector.connector);
});
it('resolves connector by internal name', function() {
var connector = DataSource._resolveConnector('memory');
assert(connector.connector);
});
it('resolves connector by module name starting with loopback-connector-', function() {
var connector = DataSource._resolveConnector('loopback-connector-xyz', loader);
assert(connector.connector);
});
it('resolves connector by short module name with full name first', function() {
var connector = DataSource._resolveConnector('xyz', loader);
assert(connector.connector);
assert.equal(connector.connector.name, 'loopback-connector-xyz');
});
it('resolves connector by short module name', function() {
var connector = DataSource._resolveConnector('abc', loader);
assert(connector.connector);
assert.equal(connector.connector.name, 'abc');
});
it('resolves connector by short module name for known connectors', function() {
var connector = DataSource._resolveConnector('oracle', loader);
assert(connector.connector);
assert.equal(connector.connector.name, 'loopback-connector-oracle');
});
it('resolves connector by full module name', function() {
var connector = DataSource._resolveConnector('loopback-xyz', loader);
assert(connector.connector);
});
it('fails to resolve connector by module name starting with loopback-connector-', function() {
var connector = DataSource._resolveConnector('loopback-connector-xyz');
assert(!connector.connector);
assert(connector.error.indexOf('loopback-connector-xyz') !== -1);
});
it('fails resolve invalid connector by short module name', function() {
var connector = DataSource._resolveConnector('xyz');
assert(!connector.connector);
assert(connector.error.indexOf('loopback-connector-xyz') !== -1);
});
it('fails to resolve invalid connector by full module name', function() {
var connector = DataSource._resolveConnector('loopback-xyz');
assert(!connector.connector);
assert(connector.error.indexOf('loopback-connector-loopback-xyz') !== -1);
});
});
describe('Model define with relations configuration', function() {
it('sets up hasMany relations', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var Post = ds.define('Post', {userId: Number, content: String});
2016-05-10 21:25:33 +00:00
var User = ds.define(
'User',
2016-10-19 21:04:05 +00:00
{name: String},
{relations: {posts: {type: 'hasMany', model: 'Post'}}}
2016-05-10 21:25:33 +00:00
);
2014-01-24 17:09:53 +00:00
assert(User.relations['posts']);
done();
});
it('sets up belongsTo relations', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String});
2016-05-10 21:25:33 +00:00
var Post = ds.define(
'Post',
2016-10-19 21:04:05 +00:00
{userId: Number, content: String},
{relations: {user: {type: 'belongsTo', model: 'User'}}}
2016-05-10 21:25:33 +00:00
);
2014-01-24 17:09:53 +00:00
assert(Post.relations['user']);
done();
});
it('sets up referencesMany relations', function(done) {
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var Post = ds.define('Post', {userId: Number, content: String});
2016-05-10 21:25:33 +00:00
var User = ds.define(
'User',
2016-10-19 21:04:05 +00:00
{name: String},
{relations: {posts: {type: 'referencesMany', model: 'Post'}}}
2016-05-10 21:25:33 +00:00
);
assert(User.relations['posts']);
done();
});
it('sets up embedsMany relations', function(done) {
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var Post = ds.define('Post', {userId: Number, content: String});
2016-05-10 21:25:33 +00:00
var User = ds.define(
'User',
2016-10-19 21:04:05 +00:00
{name: String},
{relations: {posts: {type: 'embedsMany', model: 'Post'}}}
2016-05-10 21:25:33 +00:00
);
assert(User.relations['posts']);
done();
});
it('sets up polymorphic relations', function(done) {
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var Author = ds.define('Author', {name: String}, {relations: {
pictures: {type: 'hasMany', model: 'Picture', polymorphic: 'imageable'},
}});
2016-10-19 21:04:05 +00:00
var Picture = ds.define('Picture', {name: String}, {relations: {
imageable: {type: 'belongsTo', polymorphic: true},
}});
assert(Author.relations['pictures']);
assert.deepEqual(Author.relations['pictures'].toJSON(), {
name: 'pictures',
type: 'hasMany',
modelFrom: 'Author',
keyFrom: 'id',
modelTo: 'Picture',
keyTo: 'imageableId',
multiple: true,
polymorphic: {
as: 'imageable',
foreignKey: 'imageableId',
discriminator: 'imageableType',
},
});
assert(Picture.relations['imageable']);
assert.deepEqual(Picture.relations['imageable'].toJSON(), {
name: 'imageable',
type: 'belongsTo',
modelFrom: 'Picture',
keyFrom: 'imageableId',
modelTo: '<polymorphic>',
keyTo: 'id',
multiple: false,
polymorphic: {
as: 'imageable',
foreignKey: 'imageableId',
discriminator: 'imageableType',
},
});
done();
});
it('creates a foreign key with the correct type', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2016-05-10 21:25:33 +00:00
var User = ds.define(
'User',
2016-10-19 21:04:05 +00:00
{name: String, id: {type: String, id: true}}
2016-05-10 21:25:33 +00:00
);
var Post = ds.define(
'Post',
2016-10-19 21:04:05 +00:00
{content: String},
{relations: {user: {type: 'belongsTo', model: 'User'}}}
2016-05-10 21:25:33 +00:00
);
2014-01-24 17:09:53 +00:00
var fk = Post.definition.properties['userId'];
assert(fk, 'The foreign key should be added');
assert(fk.type === String, 'The foreign key should be the same type as primary key');
assert(Post.relations['user'], 'User relation should be set');
done();
});
it('sets up related hasMany and belongsTo relations', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2016-05-10 21:25:33 +00:00
var User = ds.define(
'User',
2016-10-19 21:04:05 +00:00
{name: String},
2016-05-10 21:25:33 +00:00
{
relations: {
posts: {
type: 'hasMany',
model: 'Post',
},
accounts: {
type: 'hasMany',
model: 'Account',
},
},
}
);
2014-01-24 17:09:53 +00:00
assert(!User.relations['posts']);
assert(!User.relations['accounts']);
2016-05-10 21:25:33 +00:00
var Post = ds.define(
'Post',
2016-10-19 21:04:05 +00:00
{userId: Number, content: String},
{relations: {user: {type: 'belongsTo', model: 'User'}}}
2016-05-10 21:25:33 +00:00
);
2016-05-10 21:25:33 +00:00
var Account = ds.define(
'Account',
2016-10-19 21:04:05 +00:00
{userId: Number, type: String},
{relations: {user: {type: 'belongsTo', model: 'User'}}}
2016-05-10 21:25:33 +00:00
);
2014-01-24 17:09:53 +00:00
assert(Post.relations['user']);
2014-06-15 22:53:58 +00:00
assert.deepEqual(Post.relations['user'].toJSON(), {
name: 'user',
2014-01-24 17:09:53 +00:00
type: 'belongsTo',
2014-06-15 22:53:58 +00:00
modelFrom: 'Post',
2014-01-24 17:09:53 +00:00
keyFrom: 'userId',
2014-06-15 22:53:58 +00:00
modelTo: 'User',
2014-01-24 17:09:53 +00:00
keyTo: 'id',
multiple: false,
2014-01-24 17:09:53 +00:00
});
assert(User.relations['posts']);
2014-06-15 22:53:58 +00:00
assert.deepEqual(User.relations['posts'].toJSON(), {
name: 'posts',
2014-01-24 17:09:53 +00:00
type: 'hasMany',
2014-06-15 22:53:58 +00:00
modelFrom: 'User',
2014-01-24 17:09:53 +00:00
keyFrom: 'id',
2014-06-15 22:53:58 +00:00
modelTo: 'Post',
2014-01-24 17:09:53 +00:00
keyTo: 'userId',
multiple: true,
2014-01-24 17:09:53 +00:00
});
assert(User.relations['accounts']);
2014-06-15 22:53:58 +00:00
assert.deepEqual(User.relations['accounts'].toJSON(), {
name: 'accounts',
2014-01-24 17:09:53 +00:00
type: 'hasMany',
2014-06-15 22:53:58 +00:00
modelFrom: 'User',
2014-01-24 17:09:53 +00:00
keyFrom: 'id',
2014-06-15 22:53:58 +00:00
modelTo: 'Account',
2014-01-24 17:09:53 +00:00
keyTo: 'userId',
multiple: true,
});
2014-01-24 17:09:53 +00:00
done();
});
it('throws an error if a relation is missing type', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var Post = ds.define('Post', {userId: Number, content: String});
2014-01-24 17:09:53 +00:00
try {
2016-05-10 21:25:33 +00:00
var User = ds.define(
'User',
2016-10-19 21:04:05 +00:00
{name: String},
{relations: {posts: {model: 'Post'}}}
2016-05-10 21:25:33 +00:00
);
2014-01-24 17:09:53 +00:00
} catch (e) {
done();
}
});
it('throws an error if a relation type is invalid', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var Post = ds.define('Post', {userId: Number, content: String});
2014-01-24 17:09:53 +00:00
try {
2016-05-10 21:25:33 +00:00
var User = ds.define(
'User',
2016-10-19 21:04:05 +00:00
{name: String},
{relations: {posts: {type: 'hasXYZ', model: 'Post'}}}
2016-05-10 21:25:33 +00:00
);
2014-01-24 17:09:53 +00:00
} catch (e) {
done();
}
});
it('sets up hasMany through relations', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
var Physician = ds.createModel('Physician', {
name: String,
2016-10-19 21:04:05 +00:00
}, {relations: {patients: {model: 'Patient', type: 'hasMany', through: 'Appointment'}}});
2014-01-24 17:09:53 +00:00
var Patient = ds.createModel('Patient', {
name: String,
2016-10-19 21:04:05 +00:00
}, {relations: {physicians: {model: 'Physician', type: 'hasMany', through: 'Appointment'}}});
2014-01-24 17:09:53 +00:00
assert(!Physician.relations['patients']); // Appointment hasn't been resolved yet
assert(!Patient.relations['physicians']); // Appointment hasn't been resolved yet
2016-05-10 21:25:33 +00:00
var Appointment = ds.createModel('Appointment',
2016-10-19 21:04:05 +00:00
{physicianId: Number, patientId: Number, appointmentDate: Date},
2016-05-10 21:25:33 +00:00
{
relations: {
patient: {
type: 'belongsTo',
model: 'Patient',
},
physician: {
type: 'belongsTo',
model: 'Physician',
},
},
}
);
2014-01-24 17:09:53 +00:00
assert(Physician.relations['patients']);
assert(Patient.relations['physicians']);
done();
});
it('sets up hasMany through relations with options', function(done) {
var ds = new DataSource('memory');
2016-05-10 21:25:33 +00:00
var Physician = ds.createModel('Physician',
2016-10-19 21:04:05 +00:00
{name: String},
2016-05-10 21:25:33 +00:00
{
relations: {
patients: {
model: 'Patient',
type: 'hasMany',
foreignKey: 'leftId',
through: 'Appointment',
},
},
}
);
var Patient = ds.createModel('Patient',
2016-10-19 21:04:05 +00:00
{name: String},
2016-05-10 21:25:33 +00:00
{
relations: {
physicians: {
model: 'Physician',
type: 'hasMany',
foreignKey: 'rightId',
through: 'Appointment',
},
},
}
);
var Appointment = ds.createModel('Appointment',
2016-10-19 21:04:05 +00:00
{physicianId: Number, patientId: Number, appointmentDate: Date},
2016-05-10 21:25:33 +00:00
{
relations: {
patient: {
type: 'belongsTo',
model: 'Patient',
},
physician: {
type: 'belongsTo',
model: 'Physician',
},
},
}
);
assert(Physician.relations['patients'].keyTo === 'leftId');
assert(Patient.relations['physicians'].keyTo === 'rightId');
done();
});
it('sets up relations after attach', function(done) {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
var modelBuilder = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var Post = modelBuilder.define('Post', {userId: Number, content: String});
2016-05-10 21:25:33 +00:00
var User = modelBuilder.define(
'User',
2016-10-19 21:04:05 +00:00
{name: String},
{relations: {posts: {type: 'hasMany', model: 'Post'}}}
2016-05-10 21:25:33 +00:00
);
2014-01-24 17:09:53 +00:00
assert(!User.relations['posts']);
Post.attachTo(ds);
User.attachTo(ds);
assert(User.relations['posts']);
done();
});
});
describe('Model define with scopes configuration', function() {
it('creates scopes', function(done) {
2014-03-04 01:16:37 +00:00
var ds = new DataSource('memory');
2016-10-19 21:04:05 +00:00
var User = ds.define('User', {name: String, vip: Boolean, age: Number},
{scopes: {vips: {where: {vip: true}}, top5: {limit: 5, order: 'age'}}});
2014-03-04 01:16:37 +00:00
var users = [];
for (var i = 0; i < 10; i++) {
2016-10-19 21:04:05 +00:00
users.push({name: 'User' + i, vip: i % 3 === 0, age: 20 + i * 2});
2014-03-04 01:16:37 +00:00
}
async.each(users, function(user, callback) {
2014-03-04 01:16:37 +00:00
User.create(user, callback);
}, function(err) {
User.vips(function(err, vips) {
if (err) {
2014-03-04 01:16:37 +00:00
return done(err);
}
assert.equal(vips.length, 4);
User.top5(function(err, top5) {
2014-03-04 01:16:37 +00:00
assert.equal(top5.length, 5);
done(err);
});
});
});
});
});
describe('DataAccessObject', function() {
var ds, model, where, error;
before(function() {
ds = new DataSource('memory');
model = ds.createModel('M1', {
2016-10-19 21:04:05 +00:00
id: {type: String, id: true},
age: Number,
vip: Boolean,
date: Date,
location: 'GeoPoint',
scores: [Number],
2013-12-04 05:27:46 +00:00
});
});
beforeEach(function() {
error = null;
});
it('coerces where clause for string types', function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({id: 1});
assert.deepEqual(where, {id: '1'});
where = model._coerce({id: '1'});
assert.deepEqual(where, {id: '1'});
2015-07-01 21:58:14 +00:00
// Mockup MongoDB ObjectID
function ObjectID(id) {
this.id = id;
}
ObjectID.prototype.toString = function() {
return this.id;
};
2016-10-19 21:04:05 +00:00
where = model._coerce({id: new ObjectID('1')});
assert.deepEqual(where, {id: '1'});
});
2013-12-04 05:27:46 +00:00
it('coerces where clause for number types', function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({age: '10'});
assert.deepEqual(where, {age: 10});
2013-12-04 05:27:46 +00:00
2016-10-19 21:04:05 +00:00
where = model._coerce({age: 10});
assert.deepEqual(where, {age: 10});
2013-12-04 05:27:46 +00:00
2016-10-19 21:04:05 +00:00
where = model._coerce({age: {gt: 10}});
assert.deepEqual(where, {age: {gt: 10}});
2013-12-04 05:27:46 +00:00
2016-10-19 21:04:05 +00:00
where = model._coerce({age: {gt: '10'}});
assert.deepEqual(where, {age: {gt: 10}});
2013-12-04 05:27:46 +00:00
2016-10-19 21:04:05 +00:00
where = model._coerce({age: {between: ['10', '20']}});
assert.deepEqual(where, {age: {between: [10, 20]}});
2013-12-04 05:27:46 +00:00
});
it('coerces where clause for array types', function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({scores: ['10', '20']});
assert.deepEqual(where, {scores: [10, 20]});
});
it('coerces where clause for date types', function() {
var d = new Date();
2016-10-19 21:04:05 +00:00
where = model._coerce({date: d});
assert.deepEqual(where, {date: d});
2016-10-19 21:04:05 +00:00
where = model._coerce({date: d.toISOString()});
assert.deepEqual(where, {date: d});
});
it('coerces where clause for boolean types', function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({vip: 'true'});
assert.deepEqual(where, {vip: true});
2016-10-19 21:04:05 +00:00
where = model._coerce({vip: true});
assert.deepEqual(where, {vip: true});
2016-10-19 21:04:05 +00:00
where = model._coerce({vip: 'false'});
assert.deepEqual(where, {vip: false});
2016-10-19 21:04:05 +00:00
where = model._coerce({vip: false});
assert.deepEqual(where, {vip: false});
2016-10-19 21:04:05 +00:00
where = model._coerce({vip: '1'});
assert.deepEqual(where, {vip: true});
2016-10-19 21:04:05 +00:00
where = model._coerce({vip: 0});
assert.deepEqual(where, {vip: false});
2016-10-19 21:04:05 +00:00
where = model._coerce({vip: ''});
assert.deepEqual(where, {vip: false});
});
it('coerces where clause with and operators', function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({and: [{age: '10'}, {vip: 'true'}]});
assert.deepEqual(where, {and: [{age: 10}, {vip: true}]});
});
it('coerces where clause with or operators', function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({or: [{age: '10'}, {vip: 'true'}]});
assert.deepEqual(where, {or: [{age: 10}, {vip: true}]});
});
it('continues to coerce properties after a logical operator', function() {
var clause = {and: [{age: '10'}], vip: 'true'};
// Key order is predictable but not guaranteed. We prefer false negatives (failure) to false positives.
assert(Object.keys(clause)[0] === 'and', 'Unexpected key order.');
where = model._coerce(clause);
assert.deepEqual(where, {and: [{age: 10}], vip: true});
});
it('throws an error if the where property is not an object', function() {
try {
// The where clause has to be an object
2014-06-04 21:23:53 +00:00
model._coerce('abc');
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if the where property is an array', function() {
try {
// The where clause cannot be an array
2014-06-04 21:23:53 +00:00
model._coerce([
2016-10-19 21:04:05 +00:00
{vip: true},
]);
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if the and operator is not configured with an array', function() {
try {
// The and operator only takes an array of objects
2016-10-19 21:04:05 +00:00
model._coerce({and: {x: 1}});
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if the or operator does not take an array', function() {
try {
// The or operator only takes an array of objects
2016-10-19 21:04:05 +00:00
model._coerce({or: {x: 1}});
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if the or operator not configured with an array of objects', function() {
try {
// The or operator only takes an array of objects
2016-10-19 21:04:05 +00:00
model._coerce({or: ['x']});
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error when malformed logical operators follow valid logical clauses', function() {
var invalid = {and: [{x: 1}], or: 'bogus'};
// Key order is predictable but not guaranteed. We prefer false negatives (failure) to false positives.
assert(Object.keys(invalid)[0] !== 'or', 'Unexpected key order.');
try {
model._coerce(invalid);
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if the filter property is not an object', function() {
var filter = null;
try {
// The filter clause has to be an object
filter = model._normalize('abc');
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if the filter.limit property is not a number', function() {
try {
// The limit param must be a valid number
2016-10-19 21:04:05 +00:00
filter = model._normalize({limit: 'x'});
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if the filter.limit property is nagative', function() {
try {
// The limit param must be a valid number
2016-10-19 21:04:05 +00:00
filter = model._normalize({limit: -1});
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if the filter.limit property is not an integer', function() {
try {
// The limit param must be a valid number
2016-10-19 21:04:05 +00:00
filter = model._normalize({limit: 5.8});
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if filter.offset property is not a number', function() {
try {
// The limit param must be a valid number
2016-10-19 21:04:05 +00:00
filter = model._normalize({offset: 'x'});
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('throws an error if the filter.skip property is not a number', function() {
try {
// The limit param must be a valid number
2016-10-19 21:04:05 +00:00
filter = model._normalize({skip: '_'});
} catch (err) {
error = err;
}
assert(error, 'An error should have been thrown');
});
it('normalizes limit/offset/skip', function() {
2016-10-19 21:35:26 +00:00
var filter = model._normalize({limit: '10', skip: 5});
2016-10-19 21:04:05 +00:00
assert.deepEqual(filter, {limit: 10, offset: 5, skip: 5});
});
it('uses a default value for limit', function() {
2016-10-19 21:35:26 +00:00
var filter = model._normalize({skip: 5});
2016-10-19 21:04:05 +00:00
assert.deepEqual(filter, {limit: 100, offset: 5, skip: 5});
});
it('applies settings for handling undefined', function() {
2016-10-19 21:35:26 +00:00
var filter = model._normalize({filter: {x: undefined}});
2016-10-19 21:04:05 +00:00
assert.deepEqual(filter, {filter: {}});
ds.settings.normalizeUndefinedInQuery = 'ignore';
2016-10-19 21:04:05 +00:00
filter = model._normalize({filter: {x: undefined}});
assert.deepEqual(filter, {filter: {}}, 'Should ignore undefined');
ds.settings.normalizeUndefinedInQuery = 'nullify';
2016-10-19 21:04:05 +00:00
filter = model._normalize({filter: {x: undefined}});
assert.deepEqual(filter, {filter: {x: null}}, 'Should nullify undefined');
ds.settings.normalizeUndefinedInQuery = 'throw';
2016-10-19 21:04:05 +00:00
(function() { model._normalize({filter: {x: undefined}}); }).should.throw(/`undefined` in query/);
});
it('does not coerce GeoPoint', function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({location: {near: {lng: 10, lat: 20}, maxDistance: 20}});
assert.deepEqual(where, {location: {near: {lng: 10, lat: 20}, maxDistance: 20}});
});
it('does not coerce null values', function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({date: null});
assert.deepEqual(where, {date: null});
2013-12-16 16:36:15 +00:00
});
2013-12-14 17:54:28 +00:00
it('does not coerce undefined values', function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({date: undefined});
assert.deepEqual(where, {date: undefined});
2013-12-14 17:54:28 +00:00
});
it('does not coerce to a number for a simple value that produces NaN',
function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({age: 'xyz'});
assert.deepEqual(where, {age: 'xyz'});
2014-01-24 17:09:53 +00:00
});
2013-12-16 06:51:47 +00:00
it('does not coerce to a number for a simple value in an array that produces NaN',
function() {
2016-10-19 21:04:05 +00:00
where = model._coerce({age: {inq: ['xyz', '12']}});
assert.deepEqual(where, {age: {inq: ['xyz', 12]}});
2014-01-24 17:09:53 +00:00
});
2013-12-16 06:51:47 +00:00
// settings
it('gets settings in priority',
function() {
ds.settings.test = 'test';
assert.equal(model._getSetting('test'), ds.settings.test, 'Should get datasource setting');
ds.settings.test = undefined;
model.settings.test = 'test';
assert.equal(model._getSetting('test'), model.settings.test, 'Should get model settings');
ds.settings.test = 'willNotGet';
assert.notEqual(model._getSetting('test'), ds.settings.test, 'Should not get datasource setting');
});
2013-12-04 05:27:46 +00:00
});
describe('ModelBuilder processing json files', function() {
var path = require('path'),
fs = require('fs');
/**
* Load LDL schemas from a json doc
* @param schemaFile The dataSource json file
* @returns A map of schemas keyed by name
*/
function loadSchemasSync(schemaFile, dataSource) {
var modelBuilder, createModel;
// Set up the data source
if (!dataSource) {
modelBuilder = new ModelBuilder();
} else {
modelBuilder = dataSource.modelBuilder;
createModel = dataSource.createModel.bind(dataSource);
}
2013-05-28 22:26:12 +00:00
// Read the dataSource JSON file
var schemas = JSON.parse(fs.readFileSync(schemaFile));
return modelBuilder.buildModels(schemas, createModel);
}
2013-05-28 22:26:12 +00:00
it('defines models', function() {
2014-01-24 17:09:53 +00:00
var models = loadSchemasSync(path.join(__dirname, 'test1-schemas.json'));
2013-05-28 22:26:12 +00:00
2014-01-24 17:09:53 +00:00
models.should.have.property('AnonymousModel_0');
models.AnonymousModel_0.should.have.property('modelName', 'AnonymousModel_0');
2013-05-28 22:26:12 +00:00
2016-10-19 21:04:05 +00:00
var m1 = new models.AnonymousModel_0({title: 'Test'});
2014-01-24 17:09:53 +00:00
m1.should.have.property('title', 'Test');
m1.should.have.property('author', 'Raymond');
2013-05-28 22:26:12 +00:00
2014-01-24 17:09:53 +00:00
models = loadSchemasSync(path.join(__dirname, 'test2-schemas.json'));
models.should.have.property('Address');
models.should.have.property('Account');
models.should.have.property('Customer');
for (var s in models) {
var m = models[s];
assert(new m());
}
});
2013-05-28 22:26:12 +00:00
it('attaches models to a specified dataSource', function() {
var ds = new DataSource('memory');
var models = loadSchemasSync(path.join(__dirname, 'test2-schemas.json'), ds);
models.should.have.property('Address');
models.should.have.property('Account');
models.should.have.property('Customer');
assert.equal(models.Address.dataSource, ds);
});
it('allows customization of default model base class', function() {
var modelBuilder = new ModelBuilder();
var User = modelBuilder.define('User', {
name: String,
bio: ModelBuilder.Text,
approved: Boolean,
joinedAt: Date,
age: Number,
});
modelBuilder.defaultModelBaseClass = User;
2016-10-19 21:04:05 +00:00
var Customer = modelBuilder.define('Customer', {customerId: {type: String, id: true}});
assert(Customer.prototype instanceof User);
});
it('accepts a model base class', function() {
var modelBuilder = new ModelBuilder();
var User = modelBuilder.define('User', {
name: String,
bio: ModelBuilder.Text,
approved: Boolean,
joinedAt: Date,
age: Number,
});
var Customer = modelBuilder.define('Customer',
2016-10-19 21:04:05 +00:00
{customerId: {type: String, id: true}}, {}, User);
assert(Customer.prototype instanceof User);
});
it('allows model extension', function(done) {
2014-01-24 17:09:53 +00:00
var modelBuilder = new ModelBuilder();
2013-05-28 22:26:12 +00:00
2014-01-24 17:09:53 +00:00
var User = modelBuilder.define('User', {
name: String,
bio: ModelBuilder.Text,
approved: Boolean,
joinedAt: Date,
age: Number,
2013-05-28 22:26:12 +00:00
});
2016-10-19 21:04:05 +00:00
var Customer = User.extend('Customer', {customerId: {type: String, id: true}});
2016-10-19 21:04:05 +00:00
var customer = new Customer({name: 'Joe', age: 20, customerId: 'c01'});
customer.should.be.type('object').and.have.property('name', 'Joe');
2014-01-24 17:09:53 +00:00
customer.should.have.property('name', 'Joe');
customer.should.have.property('age', 20);
customer.should.have.property('customerId', 'c01');
customer.should.have.property('bio', undefined);
2014-01-24 17:09:53 +00:00
// The properties are defined at prototype level
assert.equal(Object.keys(customer).filter(function(k) {
// Remove internal properties
return k.indexOf('__') === -1;
}).length, 0);
2014-01-24 17:09:53 +00:00
var count = 0;
for (var p in customer) {
if (p.indexOf('__') === 0) {
continue;
}
2014-01-24 17:09:53 +00:00
if (typeof customer[p] !== 'function') {
count++;
}
}
assert.equal(count, 7); // Please note there is an injected id from User prototype
assert.equal(Object.keys(customer.toObject()).filter(function(k) {
// Remove internal properties
return k.indexOf('__') === -1;
}).length, 6);
2014-01-24 17:09:53 +00:00
done(null, customer);
});
2013-12-06 23:52:39 +00:00
it('allows model extension with merged settings', function(done) {
2013-12-06 23:52:39 +00:00
var modelBuilder = new ModelBuilder();
var User = modelBuilder.define('User', {
name: String,
2013-12-06 23:52:39 +00:00
}, {
defaultPermission: 'ALLOW',
acls: [
{
principalType: 'ROLE',
principalId: '$everyone',
permission: 'ALLOW',
},
2013-12-06 23:52:39 +00:00
],
relations: {
posts: {
type: 'hasMany',
model: 'Post',
},
},
2013-12-06 23:52:39 +00:00
});
2014-01-24 17:09:53 +00:00
var Customer = User.extend('Customer',
2016-10-19 21:04:05 +00:00
{customerId: {type: String, id: true}},
2014-01-24 17:09:53 +00:00
{
2013-12-06 23:52:39 +00:00
defaultPermission: 'DENY',
acls: [
{
principalType: 'ROLE',
principalId: '$unauthenticated',
permission: 'DENY',
},
2013-12-06 23:52:39 +00:00
],
relations: {
orders: {
type: 'hasMany',
model: 'Order',
},
},
2014-01-24 17:09:53 +00:00
}
);
2013-12-06 23:52:39 +00:00
2014-01-24 17:09:53 +00:00
assert.deepEqual(User.settings, {
defaultPermission: 'ALLOW',
acls: [
{
principalType: 'ROLE',
principalId: '$everyone',
permission: 'ALLOW',
},
2014-01-24 17:09:53 +00:00
],
relations: {
posts: {
type: 'hasMany',
model: 'Post',
},
2014-01-24 17:09:53 +00:00
},
strict: false,
2013-12-06 23:52:39 +00:00
});
2013-05-28 22:26:12 +00:00
2014-01-24 17:09:53 +00:00
assert.deepEqual(Customer.settings, {
defaultPermission: 'DENY',
acls: [
{
principalType: 'ROLE',
principalId: '$everyone',
permission: 'ALLOW',
2014-01-24 17:09:53 +00:00
},
{
principalType: 'ROLE',
principalId: '$unauthenticated',
permission: 'DENY',
},
2014-01-24 17:09:53 +00:00
],
relations: {
posts: {
type: 'hasMany',
model: 'Post',
2014-01-24 17:09:53 +00:00
},
orders: {
type: 'hasMany',
model: 'Order',
},
2014-01-24 17:09:53 +00:00
},
strict: false,
base: User,
});
2014-01-24 17:09:53 +00:00
done();
});
});
describe('DataSource constructor', function() {
it('takes url as the settings', function() {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory://localhost/mydb?x=1');
assert.equal(ds.connector.name, 'memory');
});
it('takes connector name', function() {
2014-01-24 17:09:53 +00:00
var ds = new DataSource('memory');
assert.equal(ds.connector.name, 'memory');
});
it('takes settings object', function() {
2016-10-19 21:04:05 +00:00
var ds = new DataSource({connector: 'memory'});
2014-01-24 17:09:53 +00:00
assert.equal(ds.connector.name, 'memory');
});
it('takes settings object and name', function() {
2016-10-19 21:04:05 +00:00
var ds = new DataSource('x', {connector: 'memory'});
2014-01-24 17:09:53 +00:00
assert.equal(ds.connector.name, 'memory');
});
});
describe('ModelBuilder options.models', function() {
it('injects model classes from models', function() {
var builder = new ModelBuilder();
var M1 = builder.define('M1');
2016-10-19 21:04:05 +00:00
var M2 = builder.define('M2', {}, {models: {
'M1': M1,
}});
assert.equal(M2.M1, M1, 'M1 should be injected to M2');
});
it('injects model classes by name in the models', function() {
var builder = new ModelBuilder();
var M1 = builder.define('M1');
2016-10-19 21:04:05 +00:00
var M2 = builder.define('M2', {}, {models: {
'M1': 'M1',
}});
assert.equal(M2.M1, M1, 'M1 should be injected to M2');
});
it('injects model classes by name in the models before the class is defined',
function() {
var builder = new ModelBuilder();
2016-10-19 21:04:05 +00:00
var M2 = builder.define('M2', {}, {models: {
'M1': 'M1',
}});
assert(M2.M1, 'M1 should be injected to M2');
assert(M2.M1.settings.unresolved, 'M1 is still a proxy');
var M1 = builder.define('M1');
assert.equal(M2.M1, M1, 'M1 should be injected to M2');
2014-01-24 17:09:53 +00:00
});
it('uses non-strict mode for embedded models by default', function() {
var builder = new ModelBuilder();
var M1 = builder.define('testEmbedded', {
name: 'string',
address: {
street: 'string',
},
});
var m1 = new M1({
name: 'Jim',
address: {
street: 'washington st',
number: 5512,
},
});
assert.equal(m1.address.number, 5512, 'm1 should contain number property in address');
});
it('uses the strictEmbeddedModels setting (true) when applied on modelBuilder', function() {
var builder = new ModelBuilder();
builder.settings.strictEmbeddedModels = true;
var M1 = builder.define('testEmbedded', {
name: 'string',
address: {
street: 'string',
},
});
var m1 = new M1({
name: 'Jim',
address: {
street: 'washington st',
number: 5512,
},
});
assert.equal(m1.address.number, undefined, 'm1 should not contain number property in address');
});
it('should use strictEmbeddedModels setting (validate) when applied on modelBuilder', function() {
var builder = new ModelBuilder();
builder.settings.strictEmbeddedModels = 'validate';
var M1 = builder.define('testEmbedded', {
name: 'string',
address: {
street: 'string',
},
});
var m1 = new M1({
name: 'Jim',
address: {
street: 'washington st',
number: 5512,
},
});
assert.equal(m1.address.number, undefined, 'm1 should not contain number property in address');
assert.equal(m1.address.isValid(), false, 'm1 address should not validate with extra property');
var codes = m1.address.errors && m1.address.errors.codes || {};
assert.deepEqual(codes.number, ['unknown-property']);
});
it('should use the strictEmbeddedModels setting (throw) when applied on modelBuilder', function() {
var builder = new ModelBuilder();
builder.settings.strictEmbeddedModels = 'throw';
var M1 = builder.define('testEmbedded', {
name: 'string',
address: {
street: 'string',
},
});
assert.throws(function() {
var m1 = new M1({
name: 'Jim',
address: {
street: 'washington st',
number: 5512,
},
});
});
});
2013-12-19 01:14:54 +00:00
});