Skip to content

public / sequelize

Go to a project

不要怂，就是干，撸起袖子干！

Commit e5b3c0cd by Mick Hansen
Options

Merge pull request #3929 from sequelize/rewriteAssoc 

Rewrite hasMany and belongsToMany
2 parents 6e899e27 350980c8
Expand all
Inline Side-by-side
Showing with 220 additions and 322 deletions
lib/associations/base.js
var Association = function () {};
'use strict';
module.exports = Association;
\ No newline at end of file
var Association = function() {};
// Normalize input - may be array or single obj, instance or primary key - convert it to an array of built objects
Association.prototype.toInstanceArray = function (objs) {
if (!Array.isArray(objs)) {
objs = [objs];
}
return objs.map(function(obj) {
if (!(obj instanceof this.target.Instance)) {
var tmpInstance = {};
tmpInstance[this.target.primaryKeyAttribute] = obj;
return this.target.build(tmpInstance, {
isNewRecord: false
});
}
return obj;
}, this);
};
module.exports = Association;
lib/associations/belongs-to.js
......@@ -2,6 +2,7 @@
var Utils = require('./../utils')
, Helpers = require('./helpers')
, _ = require('lodash')
, Transaction = require('../transaction')
, Association = require('./base')
, util = require('util');
......@@ -18,7 +19,7 @@ var BelongsTo = function(source, target, options) {
this.isSelfAssociation = (this.source === this.target);
this.as = this.options.as;
if (Utils._.isObject(this.options.foreignKey)) {
if (_.isObject(this.options.foreignKey)) {
this.foreignKeyAttribute = this.options.foreignKey;
this.foreignKey = this.foreignKeyAttribute.name || this.foreignKeyAttribute.fieldName;
} else {
......@@ -37,18 +38,18 @@ var BelongsTo = function(source, target, options) {
}
if (!this.options.foreignKey) {
this.options.foreignKey = Utils._.camelizeIf(
this.options.foreignKey = _.camelizeIf(
[
Utils._.underscoredIf(this.as, this.source.options.underscored),
_.underscoredIf(this.as, this.source.options.underscored),
this.target.primaryKeyAttribute
].join('_'),
!this.source.options.underscored
);
}
this.identifier = this.foreignKey || Utils._.camelizeIf(
this.identifier = this.foreignKey || _.camelizeIf(
[
Utils._.underscoredIf(this.options.name.singular, this.target.options.underscored),
_.underscoredIf(this.options.name.singular, this.target.options.underscored),
this.target.primaryKeyAttribute
].join('_'),
!this.target.options.underscored
......@@ -74,7 +75,7 @@ util.inherits(BelongsTo, Association);
BelongsTo.prototype.injectAttributes = function() {
var newAttributes = {};
newAttributes[this.identifier] = Utils._.defaults(this.foreignKeyAttribute, { type: this.options.keyType || this.target.rawAttributes[this.targetIdentifier].type });
newAttributes[this.identifier] = _.defaults(this.foreignKeyAttribute, { type: this.options.keyType || this.target.rawAttributes[this.targetIdentifier].type });
if (this.options.constraints !== false) {
this.options.onDelete = this.options.onDelete || 'SET NULL';
this.options.onUpdate = this.options.onUpdate || 'CASCADE';
......@@ -141,7 +142,7 @@ BelongsTo.prototype.injectSetter = function(instancePrototype) {
if (options.save === false) return;
options = Utils._.extend({
options = _.extend({
fields: [association.identifier],
allowNull: [association.identifier],
association: true
......
lib/associations/has-many-single-linked.js deleted 100644 → 0
'use strict';
var Utils = require('./../utils')
, _ = require('lodash');
var HasManySingleLinked = function(association, instance) {
this.association = association;
this.instance = instance;
this.target = this.association.target;
this.source = this.association.source;
};
HasManySingleLinked.prototype.injectGetter = function(options) {
var scopeWhere = this.association.scope ? {} : null;
if (this.association.scope) {
Object.keys(this.association.scope).forEach(function (attribute) {
scopeWhere[attribute] = this.association.scope[attribute];
}.bind(this));
}
options.where = {
$and: [
new Utils.where(
this.target.rawAttributes[this.association.identifier],
this.instance[this.source.primaryKeyAttribute]
),
scopeWhere,
options.where
]
};
var model = this.association.target;
if (options.hasOwnProperty('scope')) {
if (!options.scope) {
model = model.unscoped();
} else {
model = model.scope(options.scope);
}
}
return model.all(options);
};
HasManySingleLinked.prototype.injectSetter = function(oldAssociations, newAssociations, defaultAttributes) {
var self = this
, primaryKeys
, primaryKey
, updateWhere
, associationKeys = Object.keys((oldAssociations[0] || newAssociations[0] || {Model: {primaryKeys: {}}}).Model.primaryKeys || {})
, associationKey = (associationKeys.length === 1) ? associationKeys[0] : 'id'
, options = defaultAttributes
, promises = []
, obsoleteAssociations = oldAssociations.filter(function(old) {
return !Utils._.find(newAssociations, function(obj) {
return obj[associationKey] === old[associationKey];
});
})
, unassociatedObjects = newAssociations.filter(function(obj) {
return !Utils._.find(oldAssociations, function(old) {
return obj[associationKey] === old[associationKey];
});
})
, update;
if (obsoleteAssociations.length > 0) {
// clear the old associations
var obsoleteIds = obsoleteAssociations.map(function(associatedObject) {
associatedObject[self.association.identifier] = (newAssociations.length < 1 ? null : self.instance.id);
return associatedObject[associationKey];
});
update = {};
update[self.association.identifier] = null;
primaryKeys = Object.keys(this.association.target.primaryKeys);
primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : 'id';
updateWhere = {};
updateWhere[primaryKey] = obsoleteIds;
promises.push(this.association.target.unscoped().update(
update,
Utils._.extend(options, {
allowNull: [self.association.identifier],
where: updateWhere
})
));
}
if (unassociatedObjects.length > 0) {
// For the self.instance
var pkeys = Object.keys(self.instance.Model.primaryKeys)
, pkey = pkeys.length === 1 ? pkeys[0] : 'id';
primaryKeys = Object.keys(this.association.target.primaryKeys);
primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : 'id';
updateWhere = {};
// set the new associations
var unassociatedIds = unassociatedObjects.map(function(associatedObject) {
associatedObject[self.association.identifier] = self.instance[pkey] || self.instance.id;
return associatedObject[associationKey];
});
update = {};
update[self.association.identifier] = (newAssociations.length < 1 ? null : self.instance[pkey] || self.instance.id);
if (this.association.scope) {
_.assign(update, this.association.scope);
}
updateWhere[primaryKey] = unassociatedIds;
promises.push(this.association.target.unscoped().update(
update,
Utils._.extend(options, {
allowNull: [self.association.identifier],
where: updateWhere
})
));
}
return Utils.Promise.all(promises);
};
HasManySingleLinked.prototype.injectAdder = function(newAssociation, options) {
newAssociation.set(this.association.identifier, this.instance.get(this.instance.Model.primaryKeyAttribute));
if (this.association.scope) {
Object.keys(this.association.scope).forEach(function (attribute) {
newAssociation.set(attribute, this.association.scope[attribute]);
}.bind(this));
}
return newAssociation.save(options);
};
module.exports = HasManySingleLinked;
lib/associations/has-one.js
......@@ -2,6 +2,7 @@
var Utils = require('./../utils')
, Helpers = require('./helpers')
, _ = require('lodash')
, Association = require('./base')
, util = require('util');
......@@ -16,7 +17,7 @@ var HasOne = function(srcModel, targetModel, options) {
this.isSelfAssociation = (this.source === this.target);
this.as = this.options.as;
if (Utils._.isObject(this.options.foreignKey)) {
if (_.isObject(this.options.foreignKey)) {
this.foreignKeyAttribute = this.options.foreignKey;
this.foreignKey = this.foreignKeyAttribute.name || this.foreignKeyAttribute.fieldName;
} else {
......@@ -35,18 +36,18 @@ var HasOne = function(srcModel, targetModel, options) {
}
if (!this.options.foreignKey) {
this.options.foreignKey = Utils._.camelizeIf(
this.options.foreignKey = _.camelizeIf(
[
Utils._.underscoredIf(Utils.singularize(this.source.name), this.target.options.underscored),
_.underscoredIf(Utils.singularize(this.source.name), this.target.options.underscored),
this.source.primaryKeyAttribute
].join('_'),
!this.source.options.underscored
);
}
this.identifier = this.foreignKey || Utils._.camelizeIf(
this.identifier = this.foreignKey || _.camelizeIf(
[
Utils._.underscoredIf(this.source.options.name.singular, this.source.options.underscored),
_.underscoredIf(this.source.options.name.singular, this.source.options.underscored),
this.source.primaryKeyAttribute
].join('_'),
!this.source.options.underscored
......@@ -73,7 +74,7 @@ HasOne.prototype.injectAttributes = function() {
var newAttributes = {}
, keyType = this.source.rawAttributes[this.sourceIdentifier].type;
newAttributes[this.identifier] = Utils._.defaults(this.foreignKeyAttribute, { type: this.options.keyType || keyType });
newAttributes[this.identifier] = _.defaults(this.foreignKeyAttribute, { type: this.options.keyType || keyType });
Utils.mergeDefaults(this.target.rawAttributes, newAttributes);
this.identifierField = this.target.rawAttributes[this.identifier].field || this.identifier;
......@@ -136,7 +137,7 @@ HasOne.prototype.injectSetter = function(instancePrototype) {
return instance[association.accessors.get](options).then(function(oldInstance) {
if (oldInstance) {
oldInstance[association.identifier] = null;
return oldInstance.save(Utils._.extend({}, options, {
return oldInstance.save(_.extend({}, options, {
fields: [association.identifier],
allowNull: [association.identifier],
association: true
......
lib/associations/mixin.js
'use strict';
var Utils = require('./../utils')
, _ = require('lodash')
, HasOne = require('./has-one')
, HasMany = require('./has-many')
, BelongsToMany = require('./belongs-to-many')
......@@ -109,7 +110,7 @@ var singleLinked = function (Type) {
options.useHooks = options.hooks;
// the id is in the foreign table
var association = new Type(sourceModel, targetModel, Utils._.extend(options, sourceModel.options));
var association = new Type(sourceModel, targetModel, _.extend(options, sourceModel.options));
sourceModel.associations[association.associationAccessor] = association.injectAttributes();
association.injectGetter(sourceModel.Instance.prototype);
......@@ -255,7 +256,7 @@ Mixin.hasMany = function(targetModel, options) {
options.hooks = options.hooks === undefined ? false : Boolean(options.hooks);
options.useHooks = options.hooks;
options = Utils._.extend(options, Utils._.omit(sourceModel.options, ['hooks']));
options = _.extend(options, _.omit(sourceModel.options, ['hooks']));
// the id is in the foreign table or in a connecting table
var association = new HasMany(sourceModel, targetModel, options);
......@@ -349,7 +350,7 @@ Mixin.belongsToMany = function(targetModel, options) {
options.hooks = options.hooks === undefined ? false : Boolean(options.hooks);
options.useHooks = options.hooks;
options = Utils._.extend(options, Utils._.omit(sourceModel.options, ['hooks']));
options = _.extend(options, _.omit(sourceModel.options, ['hooks']));
// the id is in the foreign table or in a connecting table
var association = new BelongsToMany(sourceModel, targetModel, options);
......
test/integration/associations/belongs-to-many.test.js
......@@ -844,6 +844,17 @@ describe(Support.getTestDialectTeaser('BelongsToMany'), function() {
return this.task.getUsers();
}).then(function(users) {
expect(users).to.have.length(3);
// Re-add user 0's object, this should be harmless
// Re-add user 0's id, this should be harmless
return Promise.all([
expect(this.task.addUsers([this.users[0]])).not.to.be.rejected,
expect(this.task.addUsers([this.users[0].id])).not.to.be.rejected
]);
}).then(function() {
return this.task.getUsers();
}).then(function(users) {
expect(users).to.have.length(3);
});
});
});
......@@ -1065,7 +1076,7 @@ describe(Support.getTestDialectTeaser('BelongsToMany'), function() {
logging: spy
}).return (user);
}).then(function(user) {
expect(spy.calledOnce).to.be.ok;
expect(spy).to.have.been.calledTwice;
spy.reset();
return Promise.join(
user,
......@@ -1119,8 +1130,7 @@ describe(Support.getTestDialectTeaser('BelongsToMany'), function() {
logging: spy
}).return (project);
}).then(function(project) {
expect(spy.calledTwice).to.be.ok; // Once for SELECT, once for REMOVE
return self.user.setProjects([project]);
expect(spy).to.have.been.calledOnce;
});
});
......@@ -1762,8 +1772,7 @@ describe(Support.getTestDialectTeaser('BelongsToMany'), function() {
if (current.dialect.supports.constraints.restrict) {
it('can restrict deletes both ways', function() {
var self = this
, spy = sinon.spy();
var self = this;
this.User.belongsToMany(this.Task, { onDelete: 'RESTRICT', through: 'tasksusers' });
this.Task.belongsToMany(this.User, { onDelete: 'RESTRICT', through: 'tasksusers' });
......@@ -1786,17 +1795,14 @@ describe(Support.getTestDialectTeaser('BelongsToMany'), function() {
]);
}).then(function() {
return Promise.all([
this.user1.destroy().catch (self.sequelize.ForeignKeyConstraintError, spy), // Fails because of RESTRICT constraint
this.task2.destroy().catch (self.sequelize.ForeignKeyConstraintError, spy)
expect(this.user1.destroy()).to.have.been.rejectedWith(self.sequelize.ForeignKeyConstraintError), // Fails because of RESTRICT constraint
expect(this.task2.destroy()).to.have.been.rejectedWith(self.sequelize.ForeignKeyConstraintError)
]);
}).then(function() {
expect(spy).to.have.been.calledTwice;
});
});
it('can cascade and restrict deletes', function() {
var spy = sinon.spy()
, self = this;
var self = this;
self.User.belongsToMany(self.Task, { onDelete: 'RESTRICT', through: 'tasksusers' });
self.Task.belongsToMany(self.User, { onDelete: 'CASCADE', through: 'tasksusers' });
......@@ -1819,11 +1825,10 @@ describe(Support.getTestDialectTeaser('BelongsToMany'), function() {
);
}).then(function() {
return Sequelize.Promise.join(
this.user1.destroy().catch(self.sequelize.ForeignKeyConstraintError, spy), // Fails because of RESTRICT constraint
expect(this.user1.destroy()).to.have.been.rejectedWith(self.sequelize.ForeignKeyConstraintError), // Fails because of RESTRICT constraint
this.task2.destroy()
);
}).then(function() {
expect(spy).to.have.been.calledOnce;
return self.sequelize.model('tasksusers').findAll({ where: { taskId: this.task2.id }});
}).then(function(usertasks) {
// This should not exist because deletes cascade
......
test/integration/associations/has-many.test.js
......@@ -634,54 +634,6 @@ describe(Support.getTestDialectTeaser('HasMany'), function() {
});
});
describe('optimizations using bulk create, destroy and update', function() {
beforeEach(function() {
this.User = this.sequelize.define('User', { username: DataTypes.STRING }, {timestamps: false});
this.Task = this.sequelize.define('Task', { title: DataTypes.STRING }, {timestamps: false});
this.User.hasMany(this.Task);
return this.sequelize.sync({ force: true });
});
it('uses one UPDATE statement', function() {
var self = this
, spy = sinon.spy();
return this.User.create({ username: 'foo' }).bind({}).then(function(user) {
this.user = user;
return self.Task.create({ title: 'task1' });
}).then(function(task1) {
this.task1 = task1;
return self.Task.create({ title: 'task2' });
}).then(function(task2) {
this.task2 = task2;
return this.user.setTasks([this.task1, this.task2], {logging: spy});
}).then(function() {
expect(spy).to.have.been.calledTwice; // Once for SELECT, once for UPDATE
});
});
it('uses one UPDATE statement', function() {
var self = this
, spy = sinon.spy();
return this.User.create({ username: 'foo' }).bind(this).then(function(user) {
this.user = user;
return self.Task.create({ title: 'task1' });
}).then(function(task1) {
this.task1 = task1;
return self.Task.create({ title: 'task2' });
}).then(function(task2) {
return this.user.setTasks([this.task1, task2]);
}).then(function() {
return this.user.setTasks(null, {logging: spy});
}).then(function() {
expect(spy).to.have.been.calledTwice; // Once for SELECT, once for UPDATE
});
});
}); // end optimization using bulk create, destroy and update
describe('selfAssociations', function() {
it('should work with alias', function() {
var Person = this.sequelize.define('Group', {});
......
test/integration/hooks.test.js
......@@ -4606,39 +4606,24 @@ describe(Support.getTestDialectTeaser('Hooks'), function() {
describe('#remove', function() {
it('with no errors', function() {
var self = this
, beforeProject = false
, afterProject = false
, beforeTask = false
, afterTask = false;
this.Projects.beforeCreate(function(project, options, fn) {
beforeProject = true;
fn();
});
, beforeProject = sinon.spy()
, afterProject = sinon.spy()
, beforeTask = sinon.spy()
, afterTask = sinon.spy();
this.Projects.afterCreate(function(project, options, fn) {
afterProject = true;
fn();
});
this.Tasks.beforeUpdate(function(task, options, fn) {
beforeTask = true;
fn();
});
this.Tasks.afterUpdate(function(task, options, fn) {
afterTask = true;
fn();
});
this.Projects.beforeCreate(beforeProject);
this.Projects.afterCreate(afterProject);
this.Tasks.beforeUpdate(beforeTask);
this.Tasks.afterUpdate(afterTask);
return this.Projects.create({title: 'New Project'}).then(function(project) {
return self.Tasks.create({title: 'New Task'}).then(function(task) {
return project.addTask(task).then(function() {
return project.removeTask(task).then(function() {
expect(beforeProject).to.be.true;
expect(afterProject).to.be.true;
expect(beforeTask).to.be.true;
expect(afterTask).to.be.true;
expect(beforeProject).to.have.been.called;
expect(afterProject).to.have.been.called;
expect(beforeTask).not.to.have.been.called;
expect(afterTask).not.to.have.been.called;
});
});
});
......@@ -4813,39 +4798,24 @@ describe(Support.getTestDialectTeaser('Hooks'), function() {
describe('#remove', function() {
it('with no errors', function() {
var self = this
, beforeProject = false
, afterProject = false
, beforeTask = false
, afterTask = false;
this.Projects.beforeCreate(function(project, options, fn) {
beforeProject = true;
fn();
});
, beforeProject = sinon.spy()
, afterProject = sinon.spy()
, beforeTask = sinon.spy()
, afterTask = sinon.spy();
this.Projects.afterCreate(function(project, options, fn) {
afterProject = true;
fn();
});
this.Tasks.beforeUpdate(function(task, options, fn) {
beforeTask = true;
fn();
});
this.Tasks.afterUpdate(function(task, options, fn) {
afterTask = true;
fn();
});
this.Projects.beforeCreate(beforeProject);
this.Projects.afterCreate(afterProject);
this.Tasks.beforeUpdate(beforeTask);
this.Tasks.afterUpdate(afterTask);
return this.Projects.create({title: 'New Project'}).then(function(project) {
return self.Tasks.create({title: 'New Task'}).then(function(task) {
return project.addTask(task).then(function() {
return project.removeTask(task).then(function() {
expect(beforeProject).to.be.true;
expect(afterProject).to.be.true;
expect(beforeTask).to.be.true;
expect(afterTask).to.be.true;
expect(beforeProject).to.have.been.called;
expect(afterProject).to.have.been.called;
expect(beforeTask).not.to.have.been.called;
expect(afterTask).not.to.have.been.called;
});
});
});
......
test/integration/model/findAll.test.js
......@@ -299,42 +299,6 @@ describe(Support.getTestDialectTeaser('Model'), function() {
});
});
it('should be able to return a record with primaryKey being null for new inserts', function() {
var Session = this.sequelize.define('Session', {
token: { type: DataTypes.TEXT, allowNull: false },
lastUpdate: { type: DataTypes.DATE, allowNull: false }
}, {
charset: 'utf8',
collate: 'utf8_general_ci',
omitNull: true
})
, User = this.sequelize.define('User', {
name: { type: DataTypes.STRING, allowNull: false, unique: true },
password: { type: DataTypes.STRING, allowNull: false },
isAdmin: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false }
}, {
charset: 'utf8',
collate: 'utf8_general_ci'
});
User.hasMany(Session, { as: 'Sessions' });
Session.belongsTo(User);
return this.sequelize.sync({ force: true }).then(function() {
return User.create({name: 'Name1', password: '123', isAdmin: false}).then(function(user) {
var sess = Session.build({
lastUpdate: new Date(),
token: '123'
});
return user.addSession(sess).then(function(u) {
expect(u.token).to.equal('123');
});
});
});
});
it('should be able to find a row between a certain date', function() {
return this.User.findAll({
where: {
......
test/unit/associations/belongs-to-many.test.js
......@@ -2,30 +2,88 @@
/* jshint -W030 */
var chai = require('chai')
, sinon = require('sinon')
, expect = chai.expect
, stub = sinon.stub
, Support = require(__dirname + '/../support')
, current = Support.sequelize;
, DataTypes = require(__dirname + '/../../../lib/data-types')
, current = Support.sequelize
, Promise = current.Promise;
describe(Support.getTestDialectTeaser('Associations'), function() {
describe('belongsToMany', function () {
it('works with singular and plural name for self-associations', function () {
// Models taken from https://github.com/sequelize/sequelize/issues/3796
var Service = current.define('service', {})
, Instance = Service.Instance;
describe(Support.getTestDialectTeaser('belongsToMany'), function() {
describe('optimizations using bulk create, destroy and update', function() {
var User = current.define('User', { username: DataTypes.STRING })
, Task = current.define('Task', { title: DataTypes.STRING })
, UserTasks = current.define('UserTasks', {});
Service.belongsToMany(Service, {through: 'Supplements', as: 'supplements'});
Service.belongsToMany(Service, {through: 'Supplements', as: {singular: 'supplemented', plural: 'supplemented'}});
User.belongsToMany(Task, { through: UserTasks });
Task.belongsToMany(User, { through: UserTasks });
expect(Instance.prototype).to.have.property('getSupplements').which.is.a.function;
var user = User.build({
id: 42
}),
task1 = Task.build({
id: 15
}),
task2 = Task.build({
id: 16
});
beforeEach(function () {
this.findAll = stub(UserTasks, 'findAll').returns(Promise.resolve([]));
this.bulkCreate = stub(UserTasks, 'bulkCreate').returns(Promise.resolve([]));
this.destroy = stub(UserTasks, 'destroy').returns(Promise.resolve([]));
});
afterEach(function () {
this.findAll.restore();
this.bulkCreate.restore();
this.destroy.restore();
});
it('uses one insert into statement', function() {
return user.setTasks([task1, task2]).bind(this).then(function () {
expect(this.findAll).to.have.been.calledOnce;
expect(this.bulkCreate).to.have.been.calledOnce;
});
});
it('uses one delete from statement', function() {
this.findAll
.onFirstCall().returns(Promise.resolve([]))
.onSecondCall().returns(Promise.resolve([
{ userId: 42, taskId: 15 },
{ userId: 42, taskId: 16 }
]));
return user.setTasks([task1, task2]).bind(this).then(function () {
return user.setTasks(null);
}).then(function () {
expect(this.findAll).to.have.been.calledTwice;
expect(this.destroy).to.have.been.calledOnce;
});
});
describe('belongsToMany', function () {
it('works with singular and plural name for self-associations', function () {
// Models taken from https://github.com/sequelize/sequelize/issues/3796
var Service = current.define('service', {})
, Instance = Service.Instance;
Service.belongsToMany(Service, {through: 'Supplements', as: 'supplements'});
Service.belongsToMany(Service, {through: 'Supplements', as: {singular: 'supplemented', plural: 'supplemented'}});
expect(Instance.prototype).to.have.property('getSupplements').which.is.a.function;
expect(Instance.prototype).to.have.property('addSupplement').which.is.a.function;
expect(Instance.prototype).to.have.property('addSupplements').which.is.a.function;
expect(Instance.prototype).to.have.property('addSupplement').which.is.a.function;
expect(Instance.prototype).to.have.property('addSupplements').which.is.a.function;
expect(Instance.prototype).to.have.property('getSupplemented').which.is.a.function;
expect(Instance.prototype).not.to.have.property('getSupplementeds').which.is.a.function;
expect(Instance.prototype).to.have.property('getSupplemented').which.is.a.function;
expect(Instance.prototype).not.to.have.property('getSupplementeds').which.is.a.function;
expect(Instance.prototype).to.have.property('addSupplemented').which.is.a.function;
expect(Instance.prototype).not.to.have.property('addSupplementeds').which.is.a.function;
expect(Instance.prototype).to.have.property('addSupplemented').which.is.a.function;
expect(Instance.prototype).not.to.have.property('addSupplementeds').which.is.a.function;
});
});
});
});
test/unit/associations/has-many.test.js 0 → 100644
'use strict';
/* jshint -W030 */
var chai = require('chai')
, sinon = require('sinon')
, expect = chai.expect
, stub = sinon.stub
, Support = require(__dirname + '/../support')
, DataTypes = require(__dirname + '/../../../lib/data-types')
, current = Support.sequelize
, Promise = current.Promise;
describe(Support.getTestDialectTeaser('hasMany'), function() {
describe('optimizations using bulk create, destroy and update', function() {
var User = current.define('User', { username: DataTypes.STRING })
, Task = current.define('Task', { title: DataTypes.STRING });
User.hasMany(Task);
var user = User.build({
id: 42
}),
task1 = Task.build({
id: 15
}),
task2 = Task.build({
id: 16
});
beforeEach(function () {
this.findAll = stub(Task, 'findAll').returns(Promise.resolve([]));
this.update = stub(Task, 'update').returns(Promise.resolve([]));
});
afterEach(function () {
this.findAll.restore();
this.update.restore();
});
it('uses one update statement for addition', function() {
return user.setTasks([task1, task2]).bind(this). then(function() {
expect(this.findAll).to.have.been.calledOnce;
expect(this.update).to.have.been.calledOnce;
});
});
it('uses one delete from statement', function() {
this.findAll
.onFirstCall().returns(Promise.resolve([]))
.onSecondCall().returns(Promise.resolve([
{ userId: 42, taskId: 15 },
{ userId: 42, taskId: 16 }
]));
return user.setTasks([task1, task2]).bind(this).then(function () {
this.update.reset();
return user.setTasks(null);
}).then(function () {
expect(this.findAll).to.have.been.calledTwice;
expect(this.update).to.have.been.calledOnce;
});
});
});
});
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!