vsoft-datasource-juggler
Version:
Vsoft DataSoure Juggler
1,494 lines (1,334 loc) • 105 kB
JavaScript
// This test written in mocha+should.js
var should = require('./init.js');
var jdb = require('../');
var DataSource = jdb.DataSource;
var db, tmp, Book, Chapter, Author, Reader;
var Category, Job;
var Picture, PictureLink;
var Person, Address;
var Link;
var getTransientDataSource = function(settings) {
return new DataSource('transient', settings, db.modelBuilder);
};
var getMemoryDataSource = function(settings) {
return new DataSource('memory', settings, db.modelBuilder);
};
describe('relations', function () {
describe('hasMany', function () {
before(function (done) {
db = getSchema();
Book = db.define('Book', {name: String, type: String});
Chapter = db.define('Chapter', {name: {type: String, index: true},
bookType: String});
Author = db.define('Author', {name: String});
Reader = db.define('Reader', {name: String});
db.automigrate(function () {
Book.destroyAll(function () {
Chapter.destroyAll(function () {
Author.destroyAll(function () {
Reader.destroyAll(done);
});
});
});
});
});
it('can be declared in different ways', function (done) {
Book.hasMany(Chapter);
Book.hasMany(Reader, {as: 'users'});
Book.hasMany(Author, {foreignKey: 'projectId'});
var b = new Book;
b.chapters.should.be.an.instanceOf(Function);
b.users.should.be.an.instanceOf(Function);
b.authors.should.be.an.instanceOf(Function);
Object.keys((new Chapter).toObject()).should.include('bookId');
Object.keys((new Author).toObject()).should.include('projectId');
db.automigrate(done);
});
it('can be declared in short form', function (done) {
Author.hasMany('readers');
(new Author).readers.should.be.an.instanceOf(Function);
Object.keys((new Reader).toObject()).should.include('authorId');
db.autoupdate(done);
});
it('should build record on scope', function (done) {
Book.create(function (err, book) {
var c = book.chapters.build();
c.bookId.should.equal(book.id);
c.save(done);
});
});
it('should create record on scope', function (done) {
Book.create(function (err, book) {
book.chapters.create(function (err, c) {
should.not.exist(err);
should.exist(c);
c.bookId.should.equal(book.id);
done();
});
});
});
it('should fetch all scoped instances', function (done) {
Book.create(function (err, book) {
book.chapters.create({name: 'a'}, function () {
book.chapters.create({name: 'z'}, function () {
book.chapters.create({name: 'c'}, function () {
verify(book);
});
});
});
});
function verify(book) {
book.chapters(function (err, ch) {
should.not.exist(err);
should.exist(ch);
ch.should.have.lengthOf(3);
var chapters = book.chapters();
chapters.should.eql(ch);
book.chapters({order: 'name DESC'}, function (e, c) {
should.not.exist(e);
should.exist(c);
c.shift().name.should.equal('z');
c.pop().name.should.equal('a');
done();
});
});
}
});
it('should find scoped record', function (done) {
var id;
Book.create(function (err, book) {
book.chapters.create({name: 'a'}, function (err, ch) {
id = ch.id;
book.chapters.create({name: 'z'}, function () {
book.chapters.create({name: 'c'}, function () {
verify(book);
});
});
});
});
function verify(book) {
book.chapters.findById(id, function (err, ch) {
should.not.exist(err);
should.exist(ch);
ch.id.should.eql(id);
done();
});
}
});
it('should count scoped records - all and filtered', function (done) {
Book.create(function (err, book) {
book.chapters.create({name: 'a'}, function (err, ch) {
book.chapters.create({name: 'b'}, function () {
book.chapters.create({name: 'c'}, function () {
verify(book);
});
});
});
});
function verify(book) {
book.chapters.count(function (err, count) {
should.not.exist(err);
count.should.equal(3);
book.chapters.count({ name: 'b' }, function (err, count) {
should.not.exist(err);
count.should.equal(1);
done();
});
});
}
});
it('should set targetClass on scope property', function() {
should.equal(Book.prototype.chapters._targetClass, 'Chapter');
});
it('should update scoped record', function (done) {
var id;
Book.create(function (err, book) {
book.chapters.create({name: 'a'}, function (err, ch) {
id = ch.id;
book.chapters.updateById(id, {name: 'aa'}, function(err, ch) {
verify(book);
});
});
});
function verify(book) {
book.chapters.findById(id, function (err, ch) {
should.not.exist(err);
should.exist(ch);
ch.id.should.eql(id);
ch.name.should.equal('aa');
done();
});
}
});
it('should destroy scoped record', function (done) {
var id;
Book.create(function (err, book) {
book.chapters.create({name: 'a'}, function (err, ch) {
id = ch.id;
book.chapters.destroy(id, function(err, ch) {
verify(book);
});
});
});
function verify(book) {
book.chapters.findById(id, function (err, ch) {
should.exist(err);
done();
});
}
});
it('should check existence of a scoped record', function (done) {
var id;
Book.create(function (err, book) {
book.chapters.create({name: 'a'}, function (err, ch) {
id = ch.id;
book.chapters.create({name: 'z'}, function () {
book.chapters.create({name: 'c'}, function () {
verify(book);
});
});
});
});
function verify(book) {
book.chapters.exists(id, function (err, flag) {
should.not.exist(err);
flag.should.be.eql(true);
done();
});
}
});
it('should check ignore related data on creation - array', function (done) {
Book.create({ chapters: [] }, function (err, book) {
should.not.exist(err);
book.chapters.should.be.a.function;
var obj = book.toObject();
should.not.exist(obj.chapters);
done();
});
});
it('should check ignore related data on creation - object', function (done) {
Book.create({ chapters: {} }, function (err, book) {
should.not.exist(err);
book.chapters.should.be.a.function;
var obj = book.toObject();
should.not.exist(obj.chapters);
done();
});
});
});
describe('hasMany through', function () {
var Physician, Patient, Appointment, Address;
before(function (done) {
db = getSchema();
Physician = db.define('Physician', {name: String});
Patient = db.define('Patient', {name: String});
Appointment = db.define('Appointment', {date: {type: Date,
default: function () {
return new Date();
}}});
Address = db.define('Address', {name: String});
Physician.hasMany(Patient, {through: Appointment});
Patient.hasMany(Physician, {through: Appointment});
Patient.belongsTo(Address);
Appointment.belongsTo(Patient);
Appointment.belongsTo(Physician);
db.automigrate(['Physician', 'Patient', 'Appointment', 'Address'], function (err) {
done(err);
});
});
it('should build record on scope', function (done) {
Physician.create(function (err, physician) {
var patient = physician.patients.build();
patient.physicianId.should.equal(physician.id);
patient.save(done);
});
});
it('should create record on scope', function (done) {
Physician.create(function (err, physician) {
physician.patients.create(function (err, patient) {
should.not.exist(err);
should.exist(patient);
Appointment.find({where: {physicianId: physician.id, patientId: patient.id}},
function(err, apps) {
should.not.exist(err);
apps.should.have.lengthOf(1);
done();
});
});
});
});
it('should fetch all scoped instances', function (done) {
Physician.create(function (err, physician) {
physician.patients.create({name: 'a'}, function () {
physician.patients.create({name: 'z'}, function () {
physician.patients.create({name: 'c'}, function () {
verify(physician);
});
});
});
});
function verify(physician) {
physician.patients(function (err, ch) {
var patients = physician.patients();
patients.should.eql(ch);
should.not.exist(err);
should.exist(ch);
ch.should.have.lengthOf(3);
done();
});
}
});
it('should find scoped record', function (done) {
var id;
Physician.create(function (err, physician) {
physician.patients.create({name: 'a'}, function (err, ch) {
id = ch.id;
physician.patients.create({name: 'z'}, function () {
physician.patients.create({name: 'c'}, function () {
verify(physician);
});
});
});
});
function verify(physician) {
physician.patients.findById(id, function (err, ch) {
should.not.exist(err);
should.exist(ch);
ch.id.should.eql(id);
done();
});
}
});
it('should allow to use include syntax on related data', function (done) {
Physician.create(function (err, physician) {
physician.patients.create({name: 'a'}, function (err, patient) {
Address.create({name: 'z'}, function (err, address) {
should.not.exist(err);
patient.address(address);
patient.save(function() {
verify(physician, address.id);
});
});
});
});
function verify(physician, addressId) {
physician.patients({include: 'address'}, function (err, ch) {
should.not.exist(err);
should.exist(ch);
ch.should.have.lengthOf(1);
ch[0].addressId.should.eql(addressId);
var address = ch[0].address();
should.exist(address);
address.should.be.an.instanceof(Address);
address.name.should.equal('z');
done();
});
}
});
it('should set targetClass on scope property', function() {
should.equal(Physician.prototype.patients._targetClass, 'Patient');
});
it('should update scoped record', function (done) {
var id;
Physician.create(function (err, physician) {
physician.patients.create({name: 'a'}, function (err, ch) {
id = ch.id;
physician.patients.updateById(id, {name: 'aa'}, function(err, ch) {
verify(physician);
});
});
});
function verify(physician) {
physician.patients.findById(id, function (err, ch) {
should.not.exist(err);
should.exist(ch);
ch.id.should.eql(id);
ch.name.should.equal('aa');
done();
});
}
});
it('should destroy scoped record', function (done) {
var id;
Physician.create(function (err, physician) {
physician.patients.create({name: 'a'}, function (err, ch) {
id = ch.id;
physician.patients.destroy(id, function(err, ch) {
verify(physician);
});
});
});
function verify(physician) {
physician.patients.findById(id, function (err, ch) {
should.exist(err);
done();
});
}
});
it('should check existence of a scoped record', function (done) {
var id;
Physician.create(function (err, physician) {
physician.patients.create({name: 'a'}, function (err, ch) {
should.not.exist(err);
id = ch.id;
physician.patients.create({name: 'z'}, function () {
physician.patients.create({name: 'c'}, function () {
verify(physician);
});
});
});
});
function verify(physician) {
physician.patients.exists(id, function (err, flag) {
should.not.exist(err);
flag.should.be.eql(true);
done();
});
}
});
it('should allow to add connection with instance', function (done) {
Physician.create({name: 'ph1'}, function (e, physician) {
Patient.create({name: 'pa1'}, function (e, patient) {
physician.patients.add(patient, function (e, app) {
should.not.exist(e);
should.exist(app);
app.should.be.an.instanceOf(Appointment);
app.physicianId.should.equal(physician.id);
app.patientId.should.equal(patient.id);
done();
});
});
});
});
it('should allow to add connection with through data', function (done) {
Physician.create({name: 'ph1'}, function (e, physician) {
Patient.create({name: 'pa1'}, function (e, patient) {
var now = Date.now();
physician.patients.add(patient, { date: new Date(now) }, function (e, app) {
should.not.exist(e);
should.exist(app);
app.should.be.an.instanceOf(Appointment);
app.physicianId.should.equal(physician.id);
app.patientId.should.equal(patient.id);
app.patientId.should.equal(patient.id);
app.date.getTime().should.equal(now);
done();
});
});
});
});
it('should allow to remove connection with instance', function (done) {
var id;
Physician.create(function (err, physician) {
physician.patients.create({name: 'a'}, function (err, patient) {
id = patient.id;
physician.patients.remove(id, function (err, ch) {
verify(physician);
});
});
});
function verify(physician) {
physician.patients.exists(id, function (err, flag) {
should.not.exist(err);
flag.should.be.eql(false);
done();
});
}
});
beforeEach(function (done) {
Appointment.destroyAll(function (err) {
Physician.destroyAll(function (err) {
Patient.destroyAll(done);
});
});
});
});
describe('hasMany through - collect', function () {
var Physician, Patient, Appointment, Address;
beforeEach(function (done) {
db = getSchema();
Physician = db.define('Physician', {name: String});
Patient = db.define('Patient', {name: String});
Appointment = db.define('Appointment', {date: {type: Date,
default: function () {
return new Date();
}}});
Address = db.define('Address', {name: String});
db.automigrate(['Physician', 'Patient', 'Appointment', 'Address'], function (err) {
done(err);
});
});
describe('with default options', function () {
it('can determine the collect by modelTo\'s name as default', function () {
Physician.hasMany(Patient, {through: Appointment});
Patient.hasMany(Physician, {through: Appointment, as: 'yyy'});
Patient.belongsTo(Address);
Appointment.belongsTo(Physician);
Appointment.belongsTo(Patient);
var physician = new Physician({id: 1});
var scope1 = physician.patients._scope;
scope1.should.have.property('collect', 'patient');
scope1.should.have.property('include', 'patient');
var patient = new Patient({id: 1});
var scope2 = patient.yyy._scope;
scope2.should.have.property('collect', 'physician');
scope2.should.have.property('include', 'physician');
});
});
describe('when custom reverse belongsTo names for both sides', function () {
it('can determine the collect via keyThrough', function () {
Physician.hasMany(Patient, {through: Appointment, foreignKey: 'fooId', keyThrough: 'barId'});
Patient.hasMany(Physician, {through: Appointment, foreignKey: 'barId', keyThrough: 'fooId', as: 'yyy'});
Appointment.belongsTo(Physician, {as: 'foo'});
Appointment.belongsTo(Patient, {as: 'bar'});
Patient.belongsTo(Address); // jam.
Appointment.belongsTo(Patient, {as: 'car'}); // jam. Should we complain in this case???
var physician = new Physician({id: 1});
var scope1 = physician.patients._scope;
scope1.should.have.property('collect', 'bar');
scope1.should.have.property('include', 'bar');
var patient = new Patient({id: 1});
var scope2 = patient.yyy._scope;
scope2.should.have.property('collect', 'foo');
scope2.should.have.property('include', 'foo');
});
it('can determine the collect via modelTo name', function () {
Physician.hasMany(Patient, {through: Appointment});
Patient.hasMany(Physician, {through: Appointment, as: 'yyy'});
Appointment.belongsTo(Physician, {as: 'foo', foreignKey: 'physicianId'});
Appointment.belongsTo(Patient, {as: 'bar', foreignKey: 'patientId'});
Patient.belongsTo(Address); // jam.
var physician = new Physician({id: 1});
var scope1 = physician.patients._scope;
scope1.should.have.property('collect', 'bar');
scope1.should.have.property('include', 'bar');
var patient = new Patient({id: 1});
var scope2 = patient.yyy._scope;
scope2.should.have.property('collect', 'foo');
scope2.should.have.property('include', 'foo');
});
it('can determine the collect via modelTo name (with jams)', function () {
Physician.hasMany(Patient, {through: Appointment});
Patient.hasMany(Physician, {through: Appointment, as: 'yyy'});
Appointment.belongsTo(Physician, {as: 'foo', foreignKey: 'physicianId'});
Appointment.belongsTo(Patient, {as: 'bar', foreignKey: 'patientId'});
Patient.belongsTo(Address); // jam.
Appointment.belongsTo(Physician, {as: 'goo', foreignKey: 'physicianId'}); // jam. Should we complain in this case???
Appointment.belongsTo(Patient, {as: 'car', foreignKey: 'patientId'}); // jam. Should we complain in this case???
var physician = new Physician({id: 1});
var scope1 = physician.patients._scope;
scope1.should.have.property('collect', 'bar');
scope1.should.have.property('include', 'bar');
var patient = new Patient({id: 1});
var scope2 = patient.yyy._scope;
scope2.should.have.property('collect', 'foo'); // first matched relation
scope2.should.have.property('include', 'foo'); // first matched relation
});
});
describe('when custom reverse belongsTo name for one side only', function () {
beforeEach(function () {
Physician.hasMany(Patient, {as: 'xxx', through: Appointment, foreignKey: 'fooId'});
Patient.hasMany(Physician, {as: 'yyy', through: Appointment, keyThrough: 'fooId'});
Appointment.belongsTo(Physician, {as: 'foo'});
Appointment.belongsTo(Patient);
Patient.belongsTo(Address); // jam.
Appointment.belongsTo(Physician, {as: 'bar'}); // jam. Should we complain in this case???
});
it('can determine the collect via model name', function () {
var physician = new Physician({id: 1});
var scope1 = physician.xxx._scope;
scope1.should.have.property('collect', 'patient');
scope1.should.have.property('include', 'patient');
});
it('can determine the collect via keyThrough', function () {
var patient = new Patient({id: 1});
var scope2 = patient.yyy._scope;
scope2.should.have.property('collect', 'foo');
scope2.should.have.property('include', 'foo');
});
});
});
describe('hasMany through - between same model', function () {
var User, Follow, Address;
before(function (done) {
db = getSchema();
User = db.define('User', {name: String});
Follow = db.define('Follow', {date: {type: Date,
default: function () {
return new Date();
}}});
Address = db.define('Address', {name: String});
User.hasMany(User, {as: 'followers', foreignKey: 'followeeId', keyThrough: 'followerId', through: Follow});
User.hasMany(User, {as: 'following', foreignKey: 'followerId', keyThrough: 'followeeId', through: Follow});
User.belongsTo(Address);
Follow.belongsTo(User, {as: 'follower'});
Follow.belongsTo(User, {as: 'followee'});
db.automigrate(['User', 'Follow', 'Address'], function (err) {
done(err);
});
});
it('can determine the collect via keyThrough for each side', function () {
var user = new User({id: 1});
var scope1 = user.followers._scope;
scope1.should.have.property('collect', 'follower');
scope1.should.have.property('include', 'follower');
var scope2 = user.following._scope;
scope2.should.have.property('collect', 'followee');
scope2.should.have.property('include', 'followee');
});
});
describe('hasMany with properties', function () {
it('can be declared with properties', function (done) {
Book.hasMany(Chapter, { properties: { type: 'bookType' } });
db.automigrate(done);
});
it('should create record on scope', function (done) {
Book.create({ type: 'fiction' }, function (err, book) {
book.chapters.create(function (err, c) {
should.not.exist(err);
should.exist(c);
c.bookId.should.equal(book.id);
c.bookType.should.equal('fiction');
done();
});
});
});
});
describe('hasMany with scope and properties', function () {
it('can be declared with properties', function (done) {
db = getSchema();
Category = db.define('Category', {name: String, jobType: String});
Job = db.define('Job', {name: String, type: String});
Category.hasMany(Job, {
properties: function(inst) {
if (!inst.jobType) return; // skip
return { type: inst.jobType };
},
scope: function(inst, filter) {
var m = this.properties(inst); // re-use properties
if (m) return { where: m };
}
});
db.automigrate(done);
});
it('should create record on scope', function (done) {
Category.create(function (err, c) {
c.jobs.create({ type: 'book' }, function(err, p) {
p.categoryId.should.equal(c.id);
p.type.should.equal('book');
c.jobs.create({ type: 'widget' }, function(err, p) {
p.categoryId.should.equal(c.id);
p.type.should.equal('widget');
done();
});
});
});
});
it('should find records on scope', function (done) {
Category.findOne(function (err, c) {
c.jobs(function(err, jobs) {
jobs.should.have.length(2);
done();
});
});
});
it('should find record on scope - filtered', function (done) {
Category.findOne(function (err, c) {
c.jobs({ where: { type: 'book' } }, function(err, jobs) {
jobs.should.have.length(1);
jobs[0].type.should.equal('book');
done();
});
});
});
// So why not just do the above? In LoopBack, the context
// that gets passed into a beforeRemote handler contains
// a reference to the parent scope/instance: ctx.instance
// in order to enforce a (dynamic scope) at runtime
// a temporary property can be set in the beforeRemoting
// handler. Optionally,properties dynamic properties can be declared.
//
// The code below simulates this.
it('should create record on scope - properties', function (done) {
Category.findOne(function (err, c) {
c.jobType = 'tool'; // temporary
c.jobs.create(function(err, p) {
p.categoryId.should.equal(c.id);
p.type.should.equal('tool');
done();
});
});
});
it('should find records on scope', function (done) {
Category.findOne(function (err, c) {
c.jobs(function(err, jobs) {
jobs.should.have.length(3);
done();
});
});
});
it('should find record on scope - scoped', function (done) {
Category.findOne(function (err, c) {
c.jobType = 'book'; // temporary, for scoping
c.jobs(function(err, jobs) {
jobs.should.have.length(1);
jobs[0].type.should.equal('book');
done();
});
});
});
it('should find record on scope - scoped', function (done) {
Category.findOne(function (err, c) {
c.jobType = 'tool'; // temporary, for scoping
c.jobs(function(err, jobs) {
jobs.should.have.length(1);
jobs[0].type.should.equal('tool');
done();
});
});
});
it('should find count of records on scope - scoped', function (done) {
Category.findOne(function (err, c) {
c.jobType = 'tool'; // temporary, for scoping
c.jobs.count(function(err, count) {
count.should.equal(1);
done();
});
});
});
it('should delete records on scope - scoped', function (done) {
Category.findOne(function (err, c) {
c.jobType = 'tool'; // temporary, for scoping
c.jobs.destroyAll(function(err, result) {
done();
});
});
});
it('should find record on scope - verify', function (done) {
Category.findOne(function (err, c) {
c.jobs(function(err, jobs) {
jobs.should.have.length(2);
done();
});
});
});
});
describe('polymorphic hasOne', function () {
before(function (done) {
db = getSchema();
Picture = db.define('Picture', {name: String});
Author = db.define('Author', {name: String});
Reader = db.define('Reader', {name: String});
db.automigrate(function () {
Picture.destroyAll(function () {
Author.destroyAll(function () {
Reader.destroyAll(done);
});
});
});
});
it('can be declared', function (done) {
Author.hasOne(Picture, { as: 'avatar', polymorphic: 'imageable' });
Reader.hasOne(Picture, { as: 'mugshot', polymorphic: 'imageable' });
Picture.belongsTo('imageable', { polymorphic: true });
db.automigrate(done);
});
it('should create polymorphic relation - author', function (done) {
Author.create({name: 'Author 1' }, function (err, author) {
author.avatar.create({ name: 'Avatar' }, function (err, p) {
should.not.exist(err);
should.exist(p);
p.imageableId.should.equal(author.id);
p.imageableType.should.equal('Author');
done();
});
});
});
it('should create polymorphic relation - reader', function (done) {
Reader.create({name: 'Reader 1' }, function (err, reader) {
reader.mugshot.create({ name: 'Mugshot' }, function (err, p) {
should.not.exist(err);
should.exist(p);
p.imageableId.should.equal(reader.id);
p.imageableType.should.equal('Reader');
done();
});
});
});
it('should find polymorphic relation - author', function (done) {
Author.findOne(function (err, author) {
author.avatar(function (err, p) {
should.not.exist(err);
var avatar = author.avatar();
avatar.should.equal(p);
p.name.should.equal('Avatar');
p.imageableId.should.eql(author.id);
p.imageableType.should.equal('Author');
done();
});
});
});
it('should find polymorphic relation - reader', function (done) {
Reader.findOne(function (err, reader) {
reader.mugshot(function (err, p) {
should.not.exist(err);
p.name.should.equal('Mugshot');
p.imageableId.should.eql(reader.id);
p.imageableType.should.equal('Reader');
done();
});
});
});
it('should find inverse polymorphic relation - author', function (done) {
Picture.findOne({ where: { name: 'Avatar' } }, function (err, p) {
p.imageable(function (err, imageable) {
should.not.exist(err);
imageable.should.be.instanceof(Author);
imageable.name.should.equal('Author 1');
done();
});
});
});
it('should find inverse polymorphic relation - reader', function (done) {
Picture.findOne({ where: { name: 'Mugshot' } }, function (err, p) {
p.imageable(function (err, imageable) {
should.not.exist(err);
imageable.should.be.instanceof(Reader);
imageable.name.should.equal('Reader 1');
done();
});
});
});
});
describe('polymorphic hasMany', function () {
before(function (done) {
db = getSchema();
Picture = db.define('Picture', {name: String});
Author = db.define('Author', {name: String});
Reader = db.define('Reader', {name: String});
db.automigrate(function () {
Picture.destroyAll(function () {
Author.destroyAll(function () {
Reader.destroyAll(done);
});
});
});
});
it('can be declared', function (done) {
Author.hasMany(Picture, { polymorphic: 'imageable' });
Reader.hasMany(Picture, { polymorphic: { // alt syntax
as: 'imageable', foreignKey: 'imageableId',
discriminator: 'imageableType'
} });
Picture.belongsTo('imageable', { polymorphic: true });
Author.relations['pictures'].toJSON().should.eql({
name: 'pictures',
type: 'hasMany',
modelFrom: 'Author',
keyFrom: 'id',
modelTo: 'Picture',
keyTo: 'imageableId',
multiple: true,
polymorphic: {
as: 'imageable',
foreignKey: 'imageableId',
discriminator: 'imageableType'
}
});
Picture.relations['imageable'].toJSON().should.eql({
name: 'imageable',
type: 'belongsTo',
modelFrom: 'Picture',
keyFrom: 'imageableId',
modelTo: '<polymorphic>',
keyTo: 'id',
multiple: false,
polymorphic: {
as: 'imageable',
foreignKey: 'imageableId',
discriminator: 'imageableType'
}
});
db.automigrate(done);
});
it('should create polymorphic relation - author', function (done) {
Author.create({ name: 'Author 1' }, function (err, author) {
author.pictures.create({ name: 'Author Pic' }, function (err, p) {
should.not.exist(err);
should.exist(p);
p.imageableId.should.eql(author.id);
p.imageableType.should.equal('Author');
done();
});
});
});
it('should create polymorphic relation - reader', function (done) {
Reader.create({ name: 'Reader 1' }, function (err, reader) {
reader.pictures.create({ name: 'Reader Pic' }, function (err, p) {
should.not.exist(err);
should.exist(p);
p.imageableId.should.eql(reader.id);
p.imageableType.should.equal('Reader');
done();
});
});
});
it('should find polymorphic items - author', function (done) {
Author.findOne(function (err, author) {
author.pictures(function (err, pics) {
should.not.exist(err);
var pictures = author.pictures();
pictures.should.eql(pics);
pics.should.have.length(1);
pics[0].name.should.equal('Author Pic');
done();
});
});
});
it('should find polymorphic items - reader', function (done) {
Reader.findOne(function (err, reader) {
reader.pictures(function (err, pics) {
should.not.exist(err);
pics.should.have.length(1);
pics[0].name.should.equal('Reader Pic');
done();
});
});
});
it('should find the inverse of polymorphic relation - author', function (done) {
Picture.findOne({ where: { name: 'Author Pic' } }, function (err, p) {
should.not.exist(err);
p.imageableType.should.equal('Author');
p.imageable(function(err, imageable) {
should.not.exist(err);
imageable.should.be.instanceof(Author);
imageable.name.should.equal('Author 1');
done();
});
});
});
it('should find the inverse of polymorphic relation - reader', function (done) {
Picture.findOne({ where: { name: 'Reader Pic' } }, function (err, p) {
should.not.exist(err);
p.imageableType.should.equal('Reader');
p.imageable(function(err, imageable) {
should.not.exist(err);
imageable.should.be.instanceof(Reader);
imageable.name.should.equal('Reader 1');
done();
});
});
});
it('should include the inverse of polymorphic relation', function (done) {
Picture.find({ include: 'imageable' }, function (err, pics) {
should.not.exist(err);
pics.should.have.length(2);
pics[0].name.should.equal('Author Pic');
pics[0].imageable().name.should.equal('Author 1');
pics[1].name.should.equal('Reader Pic');
pics[1].imageable().name.should.equal('Reader 1');
done();
});
});
it('should assign a polymorphic relation', function(done) {
Author.create({ name: 'Author 2' }, function(err, author) {
var p = new Picture({ name: 'Sample' });
p.imageable(author); // assign
p.imageableId.should.eql(author.id);
p.imageableType.should.equal('Author');
p.save(done);
});
});
it('should find polymorphic items - author', function (done) {
Author.findOne({ where: { name: 'Author 2' } }, function (err, author) {
author.pictures(function (err, pics) {
should.not.exist(err);
pics.should.have.length(1);
pics[0].name.should.equal('Sample');
done();
});
});
});
it('should find the inverse of polymorphic relation - author', function (done) {
Picture.findOne({ where: { name: 'Sample' } }, function (err, p) {
should.not.exist(err);
p.imageableType.should.equal('Author');
p.imageable(function(err, imageable) {
should.not.exist(err);
imageable.should.be.instanceof(Author);
imageable.name.should.equal('Author 2');
done();
});
});
});
});
describe('polymorphic hasAndBelongsToMany through', function () {
before(function (done) {
db = getSchema();
Picture = db.define('Picture', {name: String});
Author = db.define('Author', {name: String});
Reader = db.define('Reader', {name: String});
PictureLink = db.define('PictureLink', {});
db.automigrate(function () {
Picture.destroyAll(function () {
PictureLink.destroyAll(function () {
Author.destroyAll(function () {
Reader.destroyAll(done);
});
});
});
});
});
it('can be declared', function (done) {
Author.hasAndBelongsToMany(Picture, { through: PictureLink, polymorphic: 'imageable' });
Reader.hasAndBelongsToMany(Picture, { through: PictureLink, polymorphic: 'imageable' });
// Optionally, define inverse relations:
Picture.hasMany(Author, { through: PictureLink, polymorphic: 'imageable', invert: true });
Picture.hasMany(Reader, { through: PictureLink, polymorphic: 'imageable', invert: true });
db.automigrate(done);
});
it('can determine the collect via modelTo name', function () {
Author.hasAndBelongsToMany(Picture, { through: PictureLink, polymorphic: 'imageable' });
Reader.hasAndBelongsToMany(Picture, { through: PictureLink, polymorphic: 'imageable' });
// Optionally, define inverse relations:
Picture.hasMany(Author, { through: PictureLink, polymorphic: 'imageable', invert: true });
Picture.hasMany(Reader, { through: PictureLink, polymorphic: 'imageable', invert: true });
var author = new Author({id: 1});
var scope1 = author.pictures._scope;
scope1.should.have.property('collect', 'picture');
scope1.should.have.property('include', 'picture');
var reader = new Reader({id: 1});
var scope2 = reader.pictures._scope;
scope2.should.have.property('collect', 'picture');
scope2.should.have.property('include', 'picture');
var picture = new Picture({id: 1});
var scope3 = picture.authors._scope;
scope3.should.have.property('collect', 'imageable');
scope3.should.have.property('include', 'imageable');
var scope4 = picture.readers._scope;
scope4.should.have.property('collect', 'imageable');
scope4.should.have.property('include', 'imageable');
});
var author, reader, pictures = [];
it('should create polymorphic relation - author', function (done) {
Author.create({ name: 'Author 1' }, function (err, a) {
should.not.exist(err);
author = a;
author.pictures.create({ name: 'Author Pic 1' }, function (err, p) {
should.not.exist(err);
pictures.push(p);
author.pictures.create({ name: 'Author Pic 2' }, function (err, p) {
should.not.exist(err);
pictures.push(p);
done();
});
});
});
});
it('should create polymorphic relation - reader', function (done) {
Reader.create({ name: 'Reader 1' }, function (err, r) {
should.not.exist(err);
reader = r;
reader.pictures.create({ name: 'Reader Pic 1' }, function (err, p) {
should.not.exist(err);
pictures.push(p);
done();
});
});
});
it('should create polymorphic through model', function (done) {
PictureLink.findOne(function(err, link) {
should.not.exist(err);
link.pictureId.should.eql(pictures[0].id); // eql for mongo ObjectId
link.imageableId.should.eql(author.id);
link.imageableType.should.equal('Author');
link.imageable(function(err, imageable) {
imageable.should.be.instanceof(Author);
imageable.id.should.eql(author.id);
done();
});
});
});
it('should get polymorphic relation through model - author', function (done) {
Author.findById(author.id, function(err, author) {
should.not.exist(err);
author.name.should.equal('Author 1');
author.pictures(function(err, pics) {
should.not.exist(err);
pics.should.have.length(2);
pics[0].name.should.equal('Author Pic 1');
pics[1].name.should.equal('Author Pic 2');
done();
});
});
});
it('should get polymorphic relation through model - reader', function (done) {
Reader.findById(reader.id, function(err, reader) {
should.not.exist(err);
reader.name.should.equal('Reader 1');
reader.pictures(function(err, pics) {
should.not.exist(err);
pics.should.have.length(1);
pics[0].name.should.equal('Reader Pic 1');
done();
});
});
});
it('should include polymorphic items', function (done) {
Author.find({ include: 'pictures' }, function(err, authors) {
authors.should.have.length(1);
authors[0].pictures(function(err, pics) {
pics.should.have.length(2);
pics[0].name.should.equal('Author Pic 1');
pics[1].name.should.equal('Author Pic 2');
done();
});
});
});
var anotherPicture;
it('should add to a polymorphic relation - author', function (done) {
Author.findById(author.id, function(err, author) {
Picture.create({name: 'Example' }, function(err, p) {
should.not.exist(err);
pictures.push(p);
anotherPicture = p;
author.pictures.add(p, function(err, link) {
link.should.be.instanceof(PictureLink);
link.pictureId.should.eql(p.id);
link.imageableId.should.eql(author.id);
link.imageableType.should.equal('Author');
done();
});
});
});
});
it('should create polymorphic through model', function (done) {
PictureLink.findOne({ where: { pictureId: anotherPicture.id, imageableType: 'Author' } }, function(err, link) {
should.not.exist(err);
link.pictureId.should.eql(anotherPicture.id);
link.imageableId.should.eql(author.id);
link.imageableType.should.equal('Author');
done();
});
});
var anotherAuthor, anotherReader;
it('should add to a polymorphic relation - author', function (done) {
Author.create({ name: 'Author 2' }, function (err, author) {
should.not.exist(err);
anotherAuthor = author;
author.pictures.add(anotherPicture.id, function (err, p) {
should.not.exist(err);
done();
});
});
});
it('should add to a polymorphic relation - author', function (done) {
Reader.create({name: 'Reader 2' }, function (err, reader) {
should.not.exist(err);
anotherReader = reader;
reader.pictures.add(anotherPicture.id, function (err, p) {
should.not.exist(err);
done();
});
});
});
it('should get the inverse polymorphic relation - author', function (done) {
Picture.findById(anotherPicture.id, function(err, p) {
p.authors(function(err, authors) {
authors.should.have.length(2);
authors[0].name.should.equal('Author 1');
authors[1].name.should.equal('Author 2');
done();
});
});
});
it('should get the inverse polymorphic relation - reader', function (done) {
Picture.findById(anotherPicture.id, function(err, p) {
p.readers(function(err, readers) {
readers.should.have.length(1);
readers[0].name.should.equal('Reader 2');
done();
});
});
});
it('should find polymorphic items - author', function (done) {
Author.findById(author.id, function(err, author) {
author.pictures(function(err, pics) {
pics.should.have.length(3);
pics[0].name.should.equal('Author Pic 1');
pics[1].name.should.equal('Author Pic 2');
pics[2].name.should.equal('Example');
done();
});
});
});
it('should check if polymorphic relation exists - author', function (done) {
Author.findById(author.id, function(err, author) {
author.pictures.exists(anotherPicture.id, function(err, exists) {
exists.should.be.true;
done();
});
});
});
it('should remove from a polymorphic relation - author', function (done) {
Author.findById(author.id, function(err, author) {
author.pictures.remove(anotherPicture.id, function(err) {
should.not.exist(err);
done();
});
});
});
it('should find polymorphic items - author', function (done) {
Author.findById(author.id, function(err, author) {
author.pictures(function(err, pics) {
pics.should.have.length(2);
pics[0].name.should.equal('Author Pic 1');
pics[1].name.should.equal('Author Pic 2');
done();
});
});
});
it('should check if polymorphic relation exists - author', function (done) {
Author.findById(author.id, function(err, author) {
author.pictures.exists(7, function(err, exists) {
exists.should.be.false;
done();
});
});
});
it('should create polymorphic item through relation scope', function (done) {
Picture.findById(anotherPicture.id, function(err, p) {
p.authors.create({ name: 'Author 3' }, function(err, a) {
should.not.exist(err);
author = a;
author.name.should.equal('Author 3');
done();
});
});
});
it('should create polymorphic through model - new author', function (done) {
PictureLink.findOne({ where: {
pictureId: anotherPicture.id, imageableId: author.id, imageableType: 'Author'
} }, function(err, link) {
should.not.exist(err);
link.pictureId.should.eql(anotherPicture.id);
link.imageableId.should.eql(author.id);
link.imageableType.should.equal('Author');
done();
});
});
it('should find polymorphic items - new author', function (done) {
Author.findById(author.id, function(err, author) {
author.pictures(function(err, pics) {
pics.should.have.length(1);
pics[0].id.should.eql(anotherPicture.id);
pics[0].name.should.equal('Example');
done();
});
});
});
});
describe('belongsTo', function () {
var List, Item, Fear, Mind;
var listId, itemId;
it('can be declared in different ways', function () {
List = db.define('List', {name: String});
Item = db.define('Item', {name: String});
Fear = db.define('Fear');
Mind = db.define('Mind');
// syntax 1 (old)
Item.belongsTo(List);
Object.keys((new Item).toObject()).should.include('listId');
(new Item).list.should.be.an.instanceOf(Function);
// syntax 2 (new)
Fear.belongsTo('mind');
Object.keys((new Fear).toObject()).should.include('mindId');
(new Fear).mind.should.be.an.instanceOf(Function);
// (new Fear).mind.build().should.be.an.instanceOf(Mind);
});
it('can be used to query data', function (done) {
List.hasMany('todos', {model: Item});
db.automigrate(function () {
List.create({name: 'List 1'}, function (e, list) {
listId = list.id;
should.not.exist(e);
should.exist(list);
list.todos.create({name: 'Item 1'},function (err, todo) {
itemId = todo.id;
todo.list(function (e, l) {
should.not.exist(e);
should.exist(l);
l.should.be.an.instanceOf(List);
todo.list().id.should.equal(l.id);
todo.list().name.should.equal('List 1');
done();
});
});
});
});
});
it('could accept objects when creating on scope', function (done) {
List.create(function (e, list) {
should.not.exist(e);
should.exist(list);
Item.create({list: list}, function (err, item) {
should.not.exist(err);
should.exist(item);
should.exist(item.listId);
item.listId.should.equal(list.id);
item.__cachedRelations.list.should.equal(list);
done();
});
});
});
it('should update related item on scope', function(done) {
Item.findById(itemId, function (e, todo) {
todo.list.update({name: 'List A'}, function(err, list) {
should.not.exist(err);
should.exist(list);
list.name.should.equal('List A');
done();
});
});
});
it('should get related item on scope', function(done) {
Item.findById(itemId, function (e, todo) {
todo.list(function(err, list) {
should.not.exist(err);
should.exist(list);
list.name.should.equal('List A');
done();
});
});
});
it('should destroy related item on scope', function(done) {
Item.findById(itemId, function (e, todo) {
todo.list.destroy(function(err) {
should.not.exist(err);
done();
});
});
});
it('should get related item on scope - verify', function(done) {
Item.findById(itemId, function (e, todo) {
todo.list(function(err, list) {
should.not.exist(err);
should.not.exist(list);
done();
});
});
});
it('should not have deleted related item', function(done) {
List.findById(listId, function (e, list) {
should.not.exist(e);
should.exist(list);
done();
});
});
});
describe('belongsTo with scope', function () {
var Person, Passport;
it('can be declared with scope and properties', function (done) {
Person = db.define('Person', {name: String, age: Number, passportNotes: String});
Passport = db.define('Passport', {name: String, notes: String});
Pa