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 226 additions and 422 deletions
test/integration/include.test.js
...@@ -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);
},
taskUser: ['task', 'user', function(callback, results) {
results.task.setUser(results.user).done(callback);
}],
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: { where: {
id: results.task.id id: task.id
}, },
include: [ include: [
{model: User}, {model: User},
{model: Group} {model: Group}
] ]
}).done(function(err, task) { });
expect(err).not.to.be.ok; }).then(function(task) {
expect(task.User).to.be.ok; expect(task.User).to.be.ok;
expect(task.Group).to.be.ok; expect(task.Group).to.be.ok;
done();
});
});
}); });
}); });
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);
},
userTask: ['user', 'task', function(callback, results) {
results.user.setTask(results.task).done(callback);
}],
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: { where: {
id: results.group.id id: user.Group.id
}, },
include: [ include: [
{model: User, include: [ {model: User, include: [
{model: Task} {model: Task}
]} ]}
] ]
}).done(function(err, group) { });
expect(err).not.to.be.ok; }).then(function(group) {
expect(group.User).to.be.ok; expect(group.User).to.be.ok;
expect(group.User.Task).to.be.ok; expect(group.User.Task).to.be.ok;
done();
});
});
}); });
}); });
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([ include: [Task]
{ProjectId: results.projects[0].id}, })
{ProjectId: results.projects[1].id}, ]);
{ProjectId: results.projects[0].id}, }).spread(function (projects, user) {
{ProjectId: results.projects[1].id} return User.find({
]).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: { where: {
id: results.user.id id: user.id
}, },
include: [ include: [
{model: Task, include: [ {model: Task, include: [
{model: Project} {model: Project}
]} ]}
] ]
}).done(function(err, user) { });
expect(err).not.to.be.ok; }).then(function(user) {
expect(user.Tasks).to.be.ok; expect(user.Tasks).to.be.ok;
expect(user.Tasks.length).to.equal(4); expect(user.Tasks.length).to.equal(4);
user.Tasks.forEach(function(task) { user.Tasks.forEach(function(task) {
expect(task.Project).to.be.ok; expect(task.Project).to.be.ok;
}); });
done();
});
});
}); });
}); });
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);
},
tasks: function(callback) {
Task.bulkCreate([
{},
{},
{},
{}
]).done(function() {
Task.findAll().done(callback);
}); });
}, }).then(function (project) {
projectTasks: ['project', 'tasks', function(callback, results) { return Worker.find({
results.project.setTasks(results.tasks).done(callback);
}],
projectWorker: ['project', 'worker', function(callback, results) {
results.worker.setProject(results.project).done(callback);
}]
}, function(err, results) {
Worker.find({
where: { where: {
id: results.worker.id id: project.Workers[0].id
}, },
include: [ include: [
{model: Project, include: [ {model: Project, include: [
{model: Task} {model: Task}
]} ]}
] ]
}).done(function(err, worker) { });
expect(err).not.to.be.ok; }).then(function(worker) {
expect(worker.Project).to.be.ok; expect(worker.Project).to.be.ok;
expect(worker.Project.Tasks).to.be.ok; expect(worker.Project.Tasks).to.be.ok;
expect(worker.Project.Tasks.length).to.equal(4); expect(worker.Project.Tasks.length).to.equal(4);
done();
});
});
}); });
}); });
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,48 +400,39 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -462,48 +400,39 @@ 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); }, {
}); include: [Product]
}, }).then(function() {
tags: function(callback) { return Product.findAll({order: [['id']]});
}),
Tag.bulkCreate([ Tag.bulkCreate([
{name: 'A'}, {name: 'A'},
{name: 'B'}, {name: 'B'},
{name: 'C'} {name: 'C'}
]).done(function() { ]).then(function() {
Tag.findAll({order: [['id']]}).done(callback); return Tag.findAll({order: [['id']]});
}); })
}, ]);
userProducts: ['user', 'products', function(callback, results) { }).spread(function (products, tags) {
results.user.setProducts(results.products).done(callback); return Promise.all([
}], products[0].setTags([tags[0], tags[2]]),
productTags: ['products', 'tags', function(callback, results) { products[1].setTags([tags[1]]),
var chainer = new Sequelize.Utils.QueryChainer(); products[2].setTags([tags[0], tags[1], tags[2]])
]);
chainer.add(results.products[0].setTags([results.tags[0], results.tags[2]])); }).then(function () {
chainer.add(results.products[1].setTags([results.tags[1]])); return User.find({
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: { where: {
id: results.user.id id: 1
}, },
include: [ include: [
{model: Product, include: [ {model: Product, include: [
...@@ -514,21 +443,17 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -514,21 +443,17 @@ describe(Support.getTestDialectTeaser('Include'), function() {
User.rawAttributes.id, User.rawAttributes.id,
[Product, 'id'] [Product, 'id']
] ]
}).done(function(err, user) { });
expect(err).not.to.be.ok; }).then(function(user) {
expect(user.Products.length).to.equal(4); expect(user.Products.length).to.equal(4);
expect(user.Products[0].Tags.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[1].Tags.length).to.equal(1);
expect(user.Products[2].Tags.length).to.equal(3); expect(user.Products[2].Tags.length).to.equal(3);
expect(user.Products[3].Tags.length).to.equal(0); expect(user.Products[3].Tags.length).to.equal(0);
done();
});
});
}); });
}); });
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,77 +501,43 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -576,77 +501,43 @@ 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() { include: { model: GroupMember, as: 'Memberships', include: [Group, Rank]}
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([ Tag.bulkCreate([
{name: 'A'}, {name: 'A'},
{name: 'B'}, {name: 'B'},
{name: 'C'} {name: 'C'}
]).done(function() { ]).then(function() {
Tag.findAll().done(callback); return Tag.findAll();
}); })
}, ]);
userProducts: ['user', 'products', function(callback, results) { }).spread(function (product1, product2, user, tags) {
results.user.setProducts(results.products).done(callback); return Promise.all([
}], user.setProducts([product1, product2]),
productTags: ['products', 'tags', function(callback, results) { product1.setTags([tags[0], tags[2]]),
var chainer = new Sequelize.Utils.QueryChainer(); product2.setTags([tags[1]]),
product1.setCategory(tags[1])
chainer.add(results.products[0].setTags([results.tags[0], results.tags[2]])); ]);
chainer.add(results.products[1].setTags([results.tags[1]])); }).then(function () {
chainer.add(results.products[0].setCategory(results.tags[1])); return User.find({
where: {id: 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: [ include: [
{model: GroupMember, as: 'Memberships', include: [ {model: GroupMember, as: 'Memberships', include: [
Group, Group,
...@@ -658,7 +549,8 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -658,7 +549,8 @@ describe(Support.getTestDialectTeaser('Include'), function() {
Price Price
]} ]}
] ]
}).done(function(err, user) { });
}).then(function(user) {
user.Memberships.sort(sortById); user.Memberships.sort(sortById);
expect(user.Memberships.length).to.equal(2); expect(user.Memberships.length).to.equal(2);
expect(user.Memberships[0].Group.name).to.equal('Developers'); expect(user.Memberships[0].Group.name).to.equal('Developers');
...@@ -675,14 +567,10 @@ describe(Support.getTestDialectTeaser('Include'), function() { ...@@ -675,14 +567,10 @@ describe(Support.getTestDialectTeaser('Include'), function() {
expect(user.Products[0].Prices.length).to.equal(2); expect(user.Products[0].Prices.length).to.equal(2);
expect(user.Products[1].Prices.length).to.equal(4); expect(user.Products[1].Prices.length).to.equal(4);
done();
});
});
}); });
}); });
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({ });
}).then(function() {
return Task.findAll({
attributes: ['title'], attributes: ['title'],
include: [ include: [
{model: Project, attributes: ['title']} {model: Project, attributes: ['title']}
] ]
}).done(function(err, tasks) { });
expect(err).not.to.be.ok; }).then(function(tasks) {
expect(tasks[0].title).to.equal('FooBar'); expect(tasks[0].title).to.equal('FooBar');
expect(tasks[0].Project.title).to.equal('BarFoo'); expect(tasks[0].Project.title).to.equal('BarFoo');
expect(_.omit(tasks[0].get(), 'Project')).to.deep.equal({ title: 'FooBar' }); expect(_.omit(tasks[0].get(), 'Project')).to.deep.equal({ title: 'FooBar' });
expect(tasks[0].Project.get()).to.deep.equal({ title: 'BarFoo'}); expect(tasks[0].Project.get()).to.deep.equal({ title: 'BarFoo'});
done();
});
});
});
});
}); });
}); });
...@@ -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));
}).then(function() {
return Group.find({
where: { where: {
id: groups[0].id id: this.groups[0].id
}, },
include: [{model: Group, as: 'OutsourcingCompanies'}] include: [{model: Group, as: 'OutsourcingCompanies'}]
}).done(function(err, group) {
expect(err).not.to.be.ok;
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({ ]);
}).spread(function(user, group) {
this.user = user;
return user.addGroup(group);
}).then(function() {
return User.find({
where: { where: {
id: user.id id: this.user.id
}, },
include: [Group] include: [Group]
}).success(function(user) { });
}).then(function(user) {
expect(user.dateField.getTime()).to.equal(Date.UTC(2014, 1, 20)); expect(user.dateField.getTime()).to.equal(Date.UTC(2014, 1, 20));
expect(user.groups[0].dateField.getTime()).to.equal(Date.UTC(2014, 1, 20)); expect(user.groups[0].dateField.getTime()).to.equal(Date.UTC(2014, 1, 20));
done();
});
});
});
});
}); });
}); });
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) {
this.owner = owner;
this.member = member;
this.group = group;
return owner.addGroup(group);
}).then(function() {
return this.group.addMember(this.member);
}).then(function() {
return this.owner.getGroups({
include: [{ include: [{
model: User, model: User,
as: 'Members' as: 'Members'
}] }]
}).success(function(groups) { });
}).then(function(groups) {
expect(groups.length).to.equal(1); expect(groups.length).to.equal(1);
expect(groups[0].Members[0].name).to.equal('Member'); expect(groups[0].Members[0].name).to.equal('Member');
done();
});
});
});
});
});
});
}); });
}); });
}); });
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.sequelize.sync().done(function() { this.User = User;
async.auto({ this.Item = Item;
users: function(callback) {
User.bulkCreate([{}, {}, {}]).done(function() { return this.sequelize.sync({ force: true }).then(function() {
User.findAll().done(callback); return Promise.all([
}); 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'}
]).done(function() { ]).then(function() {
Item.findAll().done(callback); return Item.findAll();
})
]);
}).spread(function (users, items) {
return Promise.all([
users[0].setItem(items[0]),
users[1].setItem(items[1]),
users[2].setItem(items[2])
]);
}); });
}, };
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); 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;
it('should support Sequelize.and()', function() {
return this.User.findAll({
include: [
{model: this.Item, where: Sequelize.and({ test: 'def' })}
]
}).then(function(result) {
expect(result.length).to.eql(1); expect(result.length).to.eql(1);
expect(result[0].Item.test).to.eql('def'); expect(result[0].Item.test).to.eql('def');
done();
});
});
}); });
}); });
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);
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.findAll({include: [
{model: Item, where: Sequelize.or({
test: 'def' test: 'def'
}, { }, {
test: 'abc' test: 'abc'
})} })}
]}).done(function(err, result) { ]
expect(err).not.to.be.ok; })).to.eventually.have.length(2);
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; });
}).then(function(result) {
expect(result.count).to.eql(1); expect(result.count).to.eql(1);
expect(result.rows.length).to.eql(1); expect(result.rows.length).to.eql(1);
expect(result.rows[0].Item.test).to.eql('def'); expect(result.rows[0].Item.test).to.eql('def');
done();
});
});
}); });
}); });
}); });
......
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!