Skip to content

public / sequelize

Go to a project

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

Commit 09b60285 by Jan Aagaard Meier
Options

Updated include.test to use promises

1 parent 953b1e8c
Inline Side-by-side
Showing with 346 additions and 542 deletions
test/integration/include.test.js
...@@ -82,7 +82,7 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -82,7 +82,7 @@ describe(Support.getTestDialectTeaser('Include'), function() {
, Person = this.sequelize.define('Person', {}); , Person = this.sequelize.define('Person', {});
Company.hasOne(Person, {as: 'CEO'}); Company.hasOne(Person, {as: 'CEO'});
return this.sequelize.sync({force: true}).then(function() { return this.sequelize.sync({force: true}).then(function() {
return Company.create().then(function() { return Company.create().then(function() {
return Company.find({ return Company.find({
...@@ -246,7 +246,7 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -246,7 +246,7 @@ describe(Support.getTestDialectTeaser('Include'), function() {
}); });
}); });
it('should support a simple sibling set of belongsTo include', function(done) { it('should support a simple sibling set of belongsTo include', function() {
var Task = this.sequelize.define('Task', {}) var Task = this.sequelize.define('Task', {})
, User = this.sequelize.define('User', {}) , User = this.sequelize.define('User', {})
, Group = this.sequelize.define('Group', {}); , Group = this.sequelize.define('Group', {});
...@@ -254,92 +254,63 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -254,92 +254,63 @@ describe(Support.getTestDialectTeaser('Include'), function() {
Task.belongsTo(User); Task.belongsTo(User);
Task.belongsTo(Group); Task.belongsTo(Group);
this.sequelize.sync({force: true}).done(function() { return this.sequelize.sync({force: true}).then(function() {
async.auto({ return Task.create({
task: function(callback) { User: {},
Task.create().done(callback); Group: {}
}, }, {
user: function(callback) { include: [User, Group]
User.create().done(callback); });
}, }).then(function(task) {
group: function(callback) { return Task.find({
Group.create().done(callback); where: {
id: task.id
}, },
taskUser: ['task', 'user', function(callback, results) { include: [
results.task.setUser(results.user).done(callback); {model: User},
}], {model: Group}
taskGroup: ['task', 'group', function(callback, results) { ]
results.task.setGroup(results.group).done(callback);
}]
}, function(err, results) {
expect(err).not.to.be.ok;
Task.find({
where: {
id: results.task.id
},
include: [
{model: User},
{model: Group}
]
}).done(function(err, task) {
expect(err).not.to.be.ok;
expect(task.User).to.be.ok;
expect(task.Group).to.be.ok;
done();
});
}); });
}).then(function(task) {
expect(task.User).to.be.ok;
expect(task.Group).to.be.ok;
}); });
}); });
it('should support a simple nested hasOne -> hasOne include', function(done) { it('should support a simple nested hasOne -> hasOne include', function() {
var Task = this.sequelize.define('Task', {}) var Task = this.sequelize.define('Task', {})
, User = this.sequelize.define('User', {}) , User = this.sequelize.define('User', {})
, Group = this.sequelize.define('Group', {}); , Group = this.sequelize.define('Group', {});
User.hasOne(Task); User.hasOne(Task);
Group.hasOne(User); Group.hasOne(User);
User.belongsTo(Group);
this.sequelize.sync({force: true}).done(function() { return this.sequelize.sync({force: true}).then(function() {
async.auto({ return User.create({
task: function(callback) { Task: {},
Task.create().done(callback); Group: {}
}, }, {
user: function(callback) { include: [Task, Group]
User.create().done(callback); });
}, }).then(function(user) {
group: function(callback) { return Group.find({
Group.create().done(callback); where: {
id: user.Group.id
}, },
userTask: ['user', 'task', function(callback, results) { include: [
results.user.setTask(results.task).done(callback); {model: User, include: [
}], {model: Task}
groupUser: ['group', 'user', function(callback, results) { ]}
results.group.setUser(results.user).done(callback); ]
}]
}, function(err, results) {
expect(err).not.to.be.ok;
Group.find({
where: {
id: results.group.id
},
include: [
{model: User, include: [
{model: Task}
]}
]
}).done(function(err, group) {
expect(err).not.to.be.ok;
expect(group.User).to.be.ok;
expect(group.User.Task).to.be.ok;
done();
});
}); });
}).then(function(group) {
expect(group.User).to.be.ok;
expect(group.User.Task).to.be.ok;
}); });
}); });
it('should support a simple nested hasMany -> belongsTo include', function(done) { it('should support a simple nested hasMany -> belongsTo include', function() {
var Task = this.sequelize.define('Task', {}) var Task = this.sequelize.define('Task', {})
, User = this.sequelize.define('User', {}) , User = this.sequelize.define('User', {})
, Project = this.sequelize.define('Project', {}); , Project = this.sequelize.define('Project', {});
...@@ -347,109 +318,76 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -347,109 +318,76 @@ describe(Support.getTestDialectTeaser('Include'), function() {
User.hasMany(Task); User.hasMany(Task);
Task.belongsTo(Project); Task.belongsTo(Project);
this.sequelize.sync({force: true}).done(function() { return this.sequelize.sync({force: true}).then(function() {
async.auto({ return Promise.all([
user: function(callback) { Project.bulkCreate([{ id: 1 }, { id: 2 }]),
User.create().done(callback); User.create({
}, Tasks: [
projects: function(callback) { {ProjectId: 1},
Project.bulkCreate([{}, {}]).done(function() { {ProjectId: 2},
Project.findAll().done(callback); {ProjectId: 1},
}); {ProjectId: 2}
},
tasks: ['projects', function(callback, results) {
Task.bulkCreate([
{ProjectId: results.projects[0].id},
{ProjectId: results.projects[1].id},
{ProjectId: results.projects[0].id},
{ProjectId: results.projects[1].id}
]).done(function() {
Task.findAll().done(callback);
});
}],
userTasks: ['user', 'tasks', function(callback, results) {
results.user.setTasks(results.tasks).done(callback);
}]
}, function(err, results) {
User.find({
where: {
id: results.user.id
},
include: [
{model: Task, include: [
{model: Project}
]}
] ]
}).done(function(err, user) { }, {
expect(err).not.to.be.ok; include: [Task]
expect(user.Tasks).to.be.ok; })
expect(user.Tasks.length).to.equal(4); ]);
}).spread(function (projects, user) {
user.Tasks.forEach(function(task) { return User.find({
expect(task.Project).to.be.ok; where: {
}); id: user.id
},
include: [
{model: Task, include: [
{model: Project}
]}
]
});
}).then(function(user) {
expect(user.Tasks).to.be.ok;
expect(user.Tasks.length).to.equal(4);
done(); user.Tasks.forEach(function(task) {
}); expect(task.Project).to.be.ok;
}); });
}); });
}); });
it('should support a simple nested belongsTo -> hasMany include', function(done) { it('should support a simple nested belongsTo -> hasMany include', function() {
var Task = this.sequelize.define('Task', {}) var Task = this.sequelize.define('Task', {})
, Worker = this.sequelize.define('Worker', {}) , Worker = this.sequelize.define('Worker', {})
, Project = this.sequelize.define('Project', {}); , Project = this.sequelize.define('Project', {});
Worker.belongsTo(Project); Worker.belongsTo(Project);
Project.hasMany(Worker);
Project.hasMany(Task); Project.hasMany(Task);
this.sequelize.sync({force: true}).done(function() { return this.sequelize.sync({force: true}).then(function() {
async.auto({ return Project.create({
worker: function(callback) { Workers: [{}],
Worker.create().done(callback); Tasks: [{}, {}, {}, {}]
}, }, {
project: function(callback) { include: [Worker, Task]
Project.create().done(callback); });
}, }).then(function (project) {
tasks: function(callback) { return Worker.find({
Task.bulkCreate([ where: {
{}, id: project.Workers[0].id
{},
{},
{}
]).done(function() {
Task.findAll().done(callback);
});
}, },
projectTasks: ['project', 'tasks', function(callback, results) { include: [
results.project.setTasks(results.tasks).done(callback); {model: Project, include: [
}], {model: Task}
projectWorker: ['project', 'worker', function(callback, results) { ]}
results.worker.setProject(results.project).done(callback); ]
}]
}, function(err, results) {
Worker.find({
where: {
id: results.worker.id
},
include: [
{model: Project, include: [
{model: Task}
]}
]
}).done(function(err, worker) {
expect(err).not.to.be.ok;
expect(worker.Project).to.be.ok;
expect(worker.Project.Tasks).to.be.ok;
expect(worker.Project.Tasks.length).to.equal(4);
done();
});
}); });
}).then(function(worker) {
expect(worker.Project).to.be.ok;
expect(worker.Project.Tasks).to.be.ok;
expect(worker.Project.Tasks.length).to.equal(4);
}); });
}); });
it('should support a simple nested hasMany <-> hasMany include', function(done) { it('should support a simple nested hasMany <-> hasMany include', function() {
var User = this.sequelize.define('User', {}) var User = this.sequelize.define('User', {})
, Product = this.sequelize.define('Product', { , Product = this.sequelize.define('Product', {
title: DataTypes.STRING title: DataTypes.STRING
...@@ -462,73 +400,60 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -462,73 +400,60 @@ describe(Support.getTestDialectTeaser('Include'), function() {
Product.hasMany(Tag); Product.hasMany(Tag);
Tag.hasMany(Product); Tag.hasMany(Product);
this.sequelize.sync({force: true}).done(function() { return this.sequelize.sync({force: true}).then(function() {
async.auto({ return Promise.all([
user: function(callback) { User.create({
User.create().done(callback); id: 1,
}, Products: [
products: function(callback) {
Product.bulkCreate([
{title: 'Chair'}, {title: 'Chair'},
{title: 'Desk'}, {title: 'Desk'},
{title: 'Dress'}, {title: 'Dress'},
{title: 'Bed'} {title: 'Bed'}
]).done(function() {
Product.findAll({order: [['id']]}).done(callback);
});
},
tags: function(callback) {
Tag.bulkCreate([
{name: 'A'},
{name: 'B'},
{name: 'C'}
]).done(function() {
Tag.findAll({order: [['id']]}).done(callback);
});
},
userProducts: ['user', 'products', function(callback, results) {
results.user.setProducts(results.products).done(callback);
}],
productTags: ['products', 'tags', function(callback, results) {
var chainer = new Sequelize.Utils.QueryChainer();
chainer.add(results.products[0].setTags([results.tags[0], results.tags[2]]));
chainer.add(results.products[1].setTags([results.tags[1]]));
chainer.add(results.products[2].setTags([results.tags[0], results.tags[1], results.tags[2]]));
chainer.run().done(callback);
}]
}, function(err, results) {
expect(err).not.to.be.ok;
User.find({
where: {
id: results.user.id
},
include: [
{model: Product, include: [
{model: Tag}
]}
],
order: [
User.rawAttributes.id,
[Product, 'id']
] ]
}).done(function(err, user) { }, {
expect(err).not.to.be.ok; include: [Product]
}).then(function() {
expect(user.Products.length).to.equal(4); return Product.findAll({order: [['id']]});
expect(user.Products[0].Tags.length).to.equal(2); }),
expect(user.Products[1].Tags.length).to.equal(1); Tag.bulkCreate([
expect(user.Products[2].Tags.length).to.equal(3); {name: 'A'},
expect(user.Products[3].Tags.length).to.equal(0); {name: 'B'},
done(); {name: 'C'}
}); ]).then(function() {
return Tag.findAll({order: [['id']]});
})
]);
}).spread(function (products, tags) {
return Promise.all([
products[0].setTags([tags[0], tags[2]]),
products[1].setTags([tags[1]]),
products[2].setTags([tags[0], tags[1], tags[2]])
]);
}).then(function () {
return User.find({
where: {
id: 1
},
include: [
{model: Product, include: [
{model: Tag}
]}
],
order: [
User.rawAttributes.id,
[Product, 'id']
]
}); });
}).then(function(user) {
expect(user.Products.length).to.equal(4);
expect(user.Products[0].Tags.length).to.equal(2);
expect(user.Products[1].Tags.length).to.equal(1);
expect(user.Products[2].Tags.length).to.equal(3);
expect(user.Products[3].Tags.length).to.equal(0);
}); });
}); });
it('should support an include with multiple different association types', function(done) { it('should support an include with multiple different association types', function() {
var User = this.sequelize.define('User', {}) var User = this.sequelize.define('User', {})
, Product = this.sequelize.define('Product', { , Product = this.sequelize.define('Product', {
title: DataTypes.STRING title: DataTypes.STRING
...@@ -576,113 +501,76 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -576,113 +501,76 @@ describe(Support.getTestDialectTeaser('Include'), function() {
GroupMember.belongsTo(Group); GroupMember.belongsTo(Group);
Group.hasMany(GroupMember, {as: 'Memberships'}); Group.hasMany(GroupMember, {as: 'Memberships'});
this.sequelize.sync({force: true}).done(function() { return this.sequelize.sync({force: true}).then(function() {
async.auto({ return Promise.all([
user: function(callback) { Product.create({
User.create().done(callback); title: 'Chair',
}, Prices: [{ value: 5 }, { value: 10 } ]
groups: function(callback) { }, { include: [Price]}),
Group.bulkCreate([ Product.create({
{name: 'Developers'}, title: 'Desk',
{name: 'Designers'} Prices: [{ value: 5 }, { value: 10 }, { value: 15 }, { value: 20 }]
]).done(function() { }, { include: [Price]}),
Group.findAll().done(callback); User.create({
}); id: 1,
}, Memberships: [
ranks: function(callback) { { Group: {name: 'Developers'}, Rank: {name: 'Admin', canInvite: 1, canRemove: 1}},
Rank.bulkCreate([ { Group: {name: 'Designers'}, Rank: {name: 'Member', canInvite: 1, canRemove: 0}}
{name: 'Admin', canInvite: 1, canRemove: 1},
{name: 'Member', canInvite: 1, canRemove: 0}
]).done(function() {
Rank.findAll().done(callback);
});
},
memberships: ['user', 'groups', 'ranks', function(callback, results) {
GroupMember.bulkCreate([
{UserId: results.user.id, GroupId: results.groups[0].id, RankId: results.ranks[0].id},
{UserId: results.user.id, GroupId: results.groups[1].id, RankId: results.ranks[1].id}
]).done(callback);
}],
products: function(callback) {
Product.bulkCreate([
{title: 'Chair'},
{title: 'Desk'}
]).done(function() {
Product.findAll().done(callback);
});
},
tags: function(callback) {
Tag.bulkCreate([
{name: 'A'},
{name: 'B'},
{name: 'C'}
]).done(function() {
Tag.findAll().done(callback);
});
},
userProducts: ['user', 'products', function(callback, results) {
results.user.setProducts(results.products).done(callback);
}],
productTags: ['products', 'tags', function(callback, results) {
var chainer = new Sequelize.Utils.QueryChainer();
chainer.add(results.products[0].setTags([results.tags[0], results.tags[2]]));
chainer.add(results.products[1].setTags([results.tags[1]]));
chainer.add(results.products[0].setCategory(results.tags[1]));
chainer.run().done(callback);
}],
prices: ['products', function(callback, results) {
Price.bulkCreate([
{ProductId: results.products[0].id, value: 5},
{ProductId: results.products[0].id, value: 10},
{ProductId: results.products[1].id, value: 5},
{ProductId: results.products[1].id, value: 10},
{ProductId: results.products[1].id, value: 15},
{ProductId: results.products[1].id, value: 20}
]).done(callback);
}]
}, function(err, results) {
expect(err).not.to.be.ok;
User.find({
where: {id: results.user.id},
include: [
{model: GroupMember, as: 'Memberships', include: [
Group,
Rank
]},
{model: Product, include: [
Tag,
{model: Tag, as: 'Category'},
Price
]}
] ]
}).done(function(err, user) { }, {
user.Memberships.sort(sortById); include: { model: GroupMember, as: 'Memberships', include: [Group, Rank]}
expect(user.Memberships.length).to.equal(2); }),
expect(user.Memberships[0].Group.name).to.equal('Developers'); Tag.bulkCreate([
expect(user.Memberships[0].Rank.canRemove).to.equal(1); {name: 'A'},
expect(user.Memberships[1].Group.name).to.equal('Designers'); {name: 'B'},
expect(user.Memberships[1].Rank.canRemove).to.equal(0); {name: 'C'}
]).then(function() {
user.Products.sort(sortById); return Tag.findAll();
expect(user.Products.length).to.equal(2); })
expect(user.Products[0].Tags.length).to.equal(2); ]);
expect(user.Products[1].Tags.length).to.equal(1); }).spread(function (product1, product2, user, tags) {
expect(user.Products[0].Category).to.be.ok; return Promise.all([
expect(user.Products[1].Category).not.to.be.ok; user.setProducts([product1, product2]),
product1.setTags([tags[0], tags[2]]),
expect(user.Products[0].Prices.length).to.equal(2); product2.setTags([tags[1]]),
expect(user.Products[1].Prices.length).to.equal(4); product1.setCategory(tags[1])
]);
done(); }).then(function () {
}); return User.find({
where: {id: 1},
include: [
{model: GroupMember, as: 'Memberships', include: [
Group,
Rank
]},
{model: Product, include: [
Tag,
{model: Tag, as: 'Category'},
Price
]}
]
}); });
}).then(function(user) {
user.Memberships.sort(sortById);
expect(user.Memberships.length).to.equal(2);
expect(user.Memberships[0].Group.name).to.equal('Developers');
expect(user.Memberships[0].Rank.canRemove).to.equal(1);
expect(user.Memberships[1].Group.name).to.equal('Designers');
expect(user.Memberships[1].Rank.canRemove).to.equal(0);
user.Products.sort(sortById);
expect(user.Products.length).to.equal(2);
expect(user.Products[0].Tags.length).to.equal(2);
expect(user.Products[1].Tags.length).to.equal(1);
expect(user.Products[0].Category).to.be.ok;
expect(user.Products[1].Category).not.to.be.ok;
expect(user.Products[0].Prices.length).to.equal(2);
expect(user.Products[1].Prices.length).to.equal(4);
}); });
}); });
it('should support specifying attributes', function(done) { it('should support specifying attributes', function() {
var Project = this.sequelize.define('Project', { var Project = this.sequelize.define('Project', {
title: Sequelize.STRING title: Sequelize.STRING
}); });
...@@ -695,30 +583,26 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -695,30 +583,26 @@ describe(Support.getTestDialectTeaser('Include'), function() {
Project.hasMany(Task); Project.hasMany(Task);
Task.belongsTo(Project); Task.belongsTo(Project);
this.sequelize.sync({force: true}).done(function() { return this.sequelize.sync({force: true}).then(function() {
Project.create({ return Task.create({
title: 'BarFoo' title: 'FooBar',
}).done(function(err, project) { Project: {title: 'BarFoo'}
Task.create({title: 'FooBar'}).done(function(err, task) { }, {
task.setProject(project).done(function() { include: [Project]
Task.findAll({ });
attributes: ['title'], }).then(function() {
include: [ return Task.findAll({
{model: Project, attributes: ['title']} attributes: ['title'],
] include: [
}).done(function(err, tasks) { {model: Project, attributes: ['title']}
expect(err).not.to.be.ok; ]
expect(tasks[0].title).to.equal('FooBar');
expect(tasks[0].Project.title).to.equal('BarFoo');
expect(_.omit(tasks[0].get(), 'Project')).to.deep.equal({ title: 'FooBar' });
expect(tasks[0].Project.get()).to.deep.equal({ title: 'BarFoo'});
done();
});
});
});
}); });
}).then(function(tasks) {
expect(tasks[0].title).to.equal('FooBar');
expect(tasks[0].Project.title).to.equal('BarFoo');
expect(_.omit(tasks[0].get(), 'Project')).to.deep.equal({ title: 'FooBar' });
expect(tasks[0].Project.get()).to.deep.equal({ title: 'BarFoo'});
}); });
}); });
...@@ -767,42 +651,38 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -767,42 +651,38 @@ describe(Support.getTestDialectTeaser('Include'), function() {
}); });
}); });
it('should support self associated hasMany (with through) include', function(done) { it('should support self associated hasMany (with through) include', function() {
var Group = this.sequelize.define('Group', { var Group = this.sequelize.define('Group', {
name: DataTypes.STRING name: DataTypes.STRING
}); });
Group.hasMany(Group, { through: 'groups_outsourcing_companies', as: 'OutsourcingCompanies'}); Group.hasMany(Group, { through: 'groups_outsourcing_companies', as: 'OutsourcingCompanies'});
this.sequelize.sync({force: true}).done(function(err) { return this.sequelize.sync({force: true}).bind({}).then(function() {
expect(err).not.to.be.ok; return Group.bulkCreate([
Group.bulkCreate([
{name: 'SoccerMoms'}, {name: 'SoccerMoms'},
{name: 'Coca Cola'}, {name: 'Coca Cola'},
{name: 'Dell'}, {name: 'Dell'},
{name: 'Pepsi'} {name: 'Pepsi'}
]).done(function() { ]);
Group.findAll().done(function(err, groups) { }).then(function() {
groups[0].setOutsourcingCompanies(groups.slice(1)).done(function(err) { return Group.findAll();
expect(err).not.to.be.ok; }).then(function(groups) {
this.groups = groups;
Group.find({ return groups[0].setOutsourcingCompanies(groups.slice(1));
where: { }).then(function() {
id: groups[0].id return Group.find({
}, where: {
include: [{model: Group, as: 'OutsourcingCompanies'}] id: this.groups[0].id
}).done(function(err, group) { },
expect(err).not.to.be.ok; include: [{model: Group, as: 'OutsourcingCompanies'}]
expect(group.OutsourcingCompanies.length).to.equal(3);
done();
});
});
});
}); });
}).then(function(group) {
expect(group.OutsourcingCompanies).to.have.length(3);
}); });
}); });
it('should support including date fields, with the correct timeszone', function(done) { it('should support including date fields, with the correct timeszone', function() {
var User = this.sequelize.define('user', { var User = this.sequelize.define('user', {
dateField: Sequelize.DATE dateField: Sequelize.DATE
}, {timestamps: false}) }, {timestamps: false})
...@@ -813,28 +693,28 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -813,28 +693,28 @@ describe(Support.getTestDialectTeaser('Include'), function() {
User.hasMany(Group); User.hasMany(Group);
Group.hasMany(User); Group.hasMany(User);
this.sequelize.sync().success(function() { return this.sequelize.sync({ force: true }).bind({}).then(function() {
User.create({ dateField: Date.UTC(2014, 1, 20) }).success(function(user) { return Promise.all([
Group.create({ dateField: Date.UTC(2014, 1, 20) }).success(function(group) { User.create({ dateField: Date.UTC(2014, 1, 20) }),
user.addGroup(group).success(function() { Group.create({ dateField: Date.UTC(2014, 1, 20) })
User.find({ ]);
where: { }).spread(function(user, group) {
id: user.id this.user = user;
}, return user.addGroup(group);
include: [Group] }).then(function() {
}).success(function(user) { return User.find({
expect(user.dateField.getTime()).to.equal(Date.UTC(2014, 1, 20)); where: {
expect(user.groups[0].dateField.getTime()).to.equal(Date.UTC(2014, 1, 20)); id: this.user.id
},
done(); include: [Group]
});
});
});
}); });
}).then(function(user) {
expect(user.dateField.getTime()).to.equal(Date.UTC(2014, 1, 20));
expect(user.groups[0].dateField.getTime()).to.equal(Date.UTC(2014, 1, 20));
}); });
}); });
it('should support include when retrieving associated objects', function(done) { it('should support include when retrieving associated objects', function() {
var User = this.sequelize.define('user', { var User = this.sequelize.define('user', {
name: DataTypes.STRING name: DataTypes.STRING
}) })
...@@ -844,6 +724,7 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -844,6 +724,7 @@ describe(Support.getTestDialectTeaser('Include'), function() {
, UserGroup = this.sequelize.define('user_group', { , UserGroup = this.sequelize.define('user_group', {
vip: DataTypes.INTEGER vip: DataTypes.INTEGER
}); });
User.hasMany(Group); User.hasMany(Group);
Group.belongsTo(User); Group.belongsTo(User);
User.hasMany(Group, { User.hasMany(Group, {
...@@ -855,186 +736,109 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -855,186 +736,109 @@ describe(Support.getTestDialectTeaser('Include'), function() {
as: 'Members' as: 'Members'
}); });
this.sequelize.sync().success(function() { return this.sequelize.sync({ force: true }).bind({}).then(function() {
User.create({ name: 'Owner' }).success(function(owner) { return Promise.all([
User.create({ name: 'Member' }).success(function(member) { User.create({ name: 'Owner' }),
Group.create({ name: 'Group' }).success(function(group) { User.create({ name: 'Member' }),
owner.addGroup(group).success(function() { Group.create({ name: 'Group' })
group.addMember(member).success(function() { ]);
owner.getGroups({ }).spread(function (owner, member, group) {
include: [{ this.owner = owner;
model: User, this.member = member;
as: 'Members' this.group = group;
}] return owner.addGroup(group);
}).success(function(groups) { }).then(function() {
expect(groups.length).to.equal(1); return this.group.addMember(this.member);
expect(groups[0].Members[0].name).to.equal('Member'); }).then(function() {
return this.owner.getGroups({
done(); include: [{
}); model: User,
}); as: 'Members'
}); }]
});
});
}); });
}).then(function(groups) {
expect(groups.length).to.equal(1);
expect(groups[0].Members[0].name).to.equal('Member');
}); });
}); });
}); });
describe('where', function() { var createUsersAndItems = function () {
it('should support Sequelize.and()', function(done) { var User = this.sequelize.define('User', {})
var User = this.sequelize.define('User', {}) , Item = this.sequelize.define('Item', {'test': DataTypes.STRING});
, Item = this.sequelize.define('Item', {'test': DataTypes.STRING});
User.hasOne(Item);
User.hasOne(Item); Item.belongsTo(User);
Item.belongsTo(User);
this.User = User;
this.sequelize.sync().done(function() { this.Item = Item;
async.auto({
users: function(callback) { return this.sequelize.sync({ force: true }).then(function() {
User.bulkCreate([{}, {}, {}]).done(function() { return Promise.all([
User.findAll().done(callback); User.bulkCreate([{}, {}, {}]).then(function() {
}); return User.findAll();
}, }),
items: function(callback) { Item.bulkCreate([
Item.bulkCreate([ {'test': 'abc'},
{'test': 'abc'}, {'test': 'def'},
{'test': 'def'}, {'test': 'ghi'}
{'test': 'ghi'} ]).then(function() {
]).done(function() { return Item.findAll();
Item.findAll().done(callback); })
}); ]);
}, }).spread(function (users, items) {
associate: ['users', 'items', function(callback, results) { return Promise.all([
var chainer = new Sequelize.Utils.QueryChainer(); users[0].setItem(items[0]),
users[1].setItem(items[1]),
var users = results.users; users[2].setItem(items[2])
var items = results.items; ]);
});
chainer.add(users[0].setItem(items[0])); };
chainer.add(users[1].setItem(items[1]));
chainer.add(users[2].setItem(items[2]));
chainer.run().done(callback); describe('where', function() {
}] beforeEach(function () {
}, function() { return createUsersAndItems.bind(this)();
User.findAll({include: [ });
{model: Item, where: Sequelize.and({
test: 'def'
})}
]}).done(function(err, result) {
expect(err).not.to.be.ok;
expect(result.length).to.eql(1); it('should support Sequelize.and()', function() {
expect(result[0].Item.test).to.eql('def'); return this.User.findAll({
done(); include: [
}); {model: this.Item, where: Sequelize.and({ test: 'def' })}
}); ]
}).then(function(result) {
expect(result.length).to.eql(1);
expect(result[0].Item.test).to.eql('def');
}); });
}); });
it('should support Sequelize.or()', function(done) { it('should support Sequelize.or()', function() {
var User = this.sequelize.define('User', {}) return expect(this.User.findAll({
, Item = this.sequelize.define('Item', {'test': DataTypes.STRING}); include: [
{model: this.Item, where: Sequelize.or({
User.hasOne(Item); test: 'def'
Item.belongsTo(User); }, {
test: 'abc'
this.sequelize.sync().done(function() { })}
async.auto({ ]
users: function(callback) { })).to.eventually.have.length(2);
User.bulkCreate([{}, {}, {}]).done(function() {
User.findAll().done(callback);
});
},
items: function(callback) {
Item.bulkCreate([
{'test': 'abc'},
{'test': 'def'},
{'test': 'ghi'}
]).done(function() {
Item.findAll().done(callback);
});
},
associate: ['users', 'items', function(callback, results) {
var chainer = new Sequelize.Utils.QueryChainer();
var users = results.users;
var items = results.items;
chainer.add(users[0].setItem(items[0]));
chainer.add(users[1].setItem(items[1]));
chainer.add(users[2].setItem(items[2]));
chainer.run().done(callback);
}]
}, function() {
User.findAll({include: [
{model: Item, where: Sequelize.or({
test: 'def'
}, {
test: 'abc'
})}
]}).done(function(err, result) {
expect(err).not.to.be.ok;
expect(result.length).to.eql(2);
done();
});
});
});
}); });
}); });
describe('findAndCountAll', function() { describe('findAndCountAll', function() {
it('should include associations to findAndCountAll', function(done) { it('should include associations to findAndCountAll', function() {
var User = this.sequelize.define('User', {}) return createUsersAndItems.bind(this)().bind(this).then(function () {
, Item = this.sequelize.define('Item', {'test': DataTypes.STRING}); return this.User.findAndCountAll({
include: [
User.hasOne(Item); {model: this.Item, where: {
Item.belongsTo(User);
this.sequelize.sync().done(function() {
async.auto({
users: function(callback) {
User.bulkCreate([{}, {}, {}]).done(function() {
User.findAll().done(callback);
});
},
items: function(callback) {
Item.bulkCreate([
{'test': 'abc'},
{'test': 'def'},
{'test': 'ghi'}
]).done(function() {
Item.findAll().done(callback);
});
},
associate: ['users', 'items', function(callback, results) {
var chainer = new Sequelize.Utils.QueryChainer();
var users = results.users;
var items = results.items;
chainer.add(users[0].setItem(items[0]));
chainer.add(users[1].setItem(items[1]));
chainer.add(users[2].setItem(items[2]));
chainer.run().done(callback);
}]
}, function() {
User.findAndCountAll({include: [
{model: Item, where: {
test: 'def' test: 'def'
}} }}
]}).done(function(err, result) { ]
expect(err).not.to.be.ok;
expect(result.count).to.eql(1);
expect(result.rows.length).to.eql(1);
expect(result.rows[0].Item.test).to.eql('def');
done();
});
}); });
}).then(function(result) {
expect(result.count).to.eql(1);
expect(result.rows.length).to.eql(1);
expect(result.rows[0].Item.test).to.eql('def');
}); });
}); });
}); });
......
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!