Skip to content

public / sequelize

Go to a project

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

Commit 796b6b7d by Andy Edwards Committed by GitHub
Options

test(integration/instance): asyncify (#12285)

1 parent 3e4b5ed7
Expand all
Inline Side-by-side
Showing with 250 additions and 305 deletions
test/integration/instance/increment.test.js
......@@ -20,7 +20,7 @@ describe(Support.getTestDialectTeaser('Instance'), () => {
this.clock.restore();
});
beforeEach(function() {
beforeEach(async function() {
this.User = this.sequelize.define('User', {
username: { type: DataTypes.STRING },
uuidv1: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV1 },
......@@ -52,169 +52,132 @@ describe(Support.getTestDialectTeaser('Instance'), () => {
}
});
return this.User.sync({ force: true });
await this.User.sync({ force: true });
});
describe('increment', () => {
beforeEach(function() {
return this.User.create({ id: 1, aNumber: 0, bNumber: 0 });
beforeEach(async function() {
await this.User.create({ id: 1, aNumber: 0, bNumber: 0 });
});
if (current.dialect.supports.transactions) {
it('supports transactions', function() {
return Support.prepareTransactionTest(this.sequelize).then(sequelize => {
const User = sequelize.define('User', { number: Support.Sequelize.INTEGER });
return User.sync({ force: true }).then(() => {
return User.create({ number: 1 }).then(user => {
return sequelize.transaction().then(t => {
return user.increment('number', { by: 2, transaction: t }).then(() => {
return User.findAll().then(users1 => {
return User.findAll({ transaction: t }).then(users2 => {
expect(users1[0].number).to.equal(1);
expect(users2[0].number).to.equal(3);
return t.rollback();
});
});
});
});
});
});
});
it('supports transactions', async function() {
const sequelize = await Support.prepareTransactionTest(this.sequelize);
const User = sequelize.define('User', { number: Support.Sequelize.INTEGER });
await User.sync({ force: true });
const user = await User.create({ number: 1 });
const t = await sequelize.transaction();
await user.increment('number', { by: 2, transaction: t });
const users1 = await User.findAll();
const users2 = await User.findAll({ transaction: t });
expect(users1[0].number).to.equal(1);
expect(users2[0].number).to.equal(3);
await t.rollback();
});
}
if (current.dialect.supports.returnValues.returning) {
it('supports returning', function() {
return this.User.findByPk(1).then(user1 => {
return user1.increment('aNumber', { by: 2 }).then(() => {
expect(user1.aNumber).to.be.equal(2);
return user1.increment('bNumber', { by: 2, returning: false }).then(user3 => {
expect(user3.bNumber).to.be.equal(0);
});
});
});
it('supports returning', async function() {
const user1 = await this.User.findByPk(1);
await user1.increment('aNumber', { by: 2 });
expect(user1.aNumber).to.be.equal(2);
const user3 = await user1.increment('bNumber', { by: 2, returning: false });
expect(user3.bNumber).to.be.equal(0);
});
}
it('supports where conditions', function() {
return this.User.findByPk(1).then(user1 => {
return user1.increment(['aNumber'], { by: 2, where: { bNumber: 1 } }).then(() => {
return this.User.findByPk(1).then(user3 => {
expect(user3.aNumber).to.be.equal(0);
});
});
});
it('supports where conditions', async function() {
const user1 = await this.User.findByPk(1);
await user1.increment(['aNumber'], { by: 2, where: { bNumber: 1 } });
const user3 = await this.User.findByPk(1);
expect(user3.aNumber).to.be.equal(0);
});
it('with array', function() {
return this.User.findByPk(1).then(user1 => {
return user1.increment(['aNumber'], { by: 2 }).then(() => {
return this.User.findByPk(1).then(user3 => {
expect(user3.aNumber).to.be.equal(2);
});
});
});
it('with array', async function() {
const user1 = await this.User.findByPk(1);
await user1.increment(['aNumber'], { by: 2 });
const user3 = await this.User.findByPk(1);
expect(user3.aNumber).to.be.equal(2);
});
it('with single field', function() {
return this.User.findByPk(1).then(user1 => {
return user1.increment('aNumber', { by: 2 }).then(() => {
return this.User.findByPk(1).then(user3 => {
expect(user3.aNumber).to.be.equal(2);
});
});
});
it('with single field', async function() {
const user1 = await this.User.findByPk(1);
await user1.increment('aNumber', { by: 2 });
const user3 = await this.User.findByPk(1);
expect(user3.aNumber).to.be.equal(2);
});
it('with single field and no value', function() {
return this.User.findByPk(1).then(user1 => {
return user1.increment('aNumber').then(() => {
return this.User.findByPk(1).then(user2 => {
expect(user2.aNumber).to.be.equal(1);
});
});
});
it('with single field and no value', async function() {
const user1 = await this.User.findByPk(1);
await user1.increment('aNumber');
const user2 = await this.User.findByPk(1);
expect(user2.aNumber).to.be.equal(1);
});
it('should still work right with other concurrent updates', function() {
return this.User.findByPk(1).then(user1 => {
// Select the user again (simulating a concurrent query)
return this.User.findByPk(1).then(user2 => {
return user2.update({
aNumber: user2.aNumber + 1
}).then(() => {
return user1.increment(['aNumber'], { by: 2 }).then(() => {
return this.User.findByPk(1).then(user5 => {
expect(user5.aNumber).to.be.equal(3);
});
});
});
});
it('should still work right with other concurrent updates', async function() {
const user1 = await this.User.findByPk(1);
// Select the user again (simulating a concurrent query)
const user2 = await this.User.findByPk(1);
await user2.update({
aNumber: user2.aNumber + 1
});
await user1.increment(['aNumber'], { by: 2 });
const user5 = await this.User.findByPk(1);
expect(user5.aNumber).to.be.equal(3);
});
it('should still work right with other concurrent increments', function() {
return this.User.findByPk(1).then(user1 => {
return Promise.all([
user1.increment(['aNumber'], { by: 2 }),
user1.increment(['aNumber'], { by: 2 }),
user1.increment(['aNumber'], { by: 2 })
]).then(() => {
return this.User.findByPk(1).then(user2 => {
expect(user2.aNumber).to.equal(6);
});
});
});
it('should still work right with other concurrent increments', async function() {
const user1 = await this.User.findByPk(1);
await Promise.all([
user1.increment(['aNumber'], { by: 2 }),
user1.increment(['aNumber'], { by: 2 }),
user1.increment(['aNumber'], { by: 2 })
]);
const user2 = await this.User.findByPk(1);
expect(user2.aNumber).to.equal(6);
});
it('with key value pair', function() {
return this.User.findByPk(1).then(user1 => {
return user1.increment({ 'aNumber': 1, 'bNumber': 2 }).then(() => {
return this.User.findByPk(1).then(user3 => {
expect(user3.aNumber).to.be.equal(1);
expect(user3.bNumber).to.be.equal(2);
});
});
});
it('with key value pair', async function() {
const user1 = await this.User.findByPk(1);
await user1.increment({ 'aNumber': 1, 'bNumber': 2 });
const user3 = await this.User.findByPk(1);
expect(user3.aNumber).to.be.equal(1);
expect(user3.bNumber).to.be.equal(2);
});
it('with timestamps set to true', function() {
it('with timestamps set to true', async function() {
const User = this.sequelize.define('IncrementUser', {
aNumber: DataTypes.INTEGER
}, { timestamps: true });
let oldDate;
await User.sync({ force: true });
const user1 = await User.create({ aNumber: 1 });
const oldDate = user1.get('updatedAt');
return User.sync({ force: true })
.then(() => User.create({ aNumber: 1 }))
.then(user => {
oldDate = user.get('updatedAt');
this.clock.tick(1000);
const user0 = await user1.increment('aNumber', { by: 1 });
const user = await user0.reload();
this.clock.tick(1000);
return user.increment('aNumber', { by: 1 });
})
.then(user => user.reload())
.then(user => {
return expect(user).to.have.property('updatedAt').afterTime(oldDate);
});
await expect(user).to.have.property('updatedAt').afterTime(oldDate);
});
it('with timestamps set to true and options.silent set to true', function() {
it('with timestamps set to true and options.silent set to true', async function() {
const User = this.sequelize.define('IncrementUser', {
aNumber: DataTypes.INTEGER
}, { timestamps: true });
let oldDate;
return User.sync({ force: true }).then(() => {
return User.create({ aNumber: 1 });
}).then(user => {
oldDate = user.updatedAt;
this.clock.tick(1000);
return user.increment('aNumber', { by: 1, silent: true });
}).then(() => {
return expect(User.findByPk(1)).to.eventually.have.property('updatedAt').equalTime(oldDate);
});
await User.sync({ force: true });
const user = await User.create({ aNumber: 1 });
const oldDate = user.updatedAt;
this.clock.tick(1000);
await user.increment('aNumber', { by: 1, silent: true });
await expect(User.findByPk(1)).to.eventually.have.property('updatedAt').equalTime(oldDate);
});
});
});
test/integration/instance/to-json.test.js
......@@ -7,7 +7,7 @@ const chai = require('chai'),
describe(Support.getTestDialectTeaser('Instance'), () => {
describe('toJSON', () => {
beforeEach(function() {
beforeEach(async function() {
this.User = this.sequelize.define('User', {
username: { type: DataTypes.STRING },
age: DataTypes.INTEGER,
......@@ -26,45 +26,41 @@ describe(Support.getTestDialectTeaser('Instance'), () => {
this.User.hasMany(this.Project, { as: 'Projects', foreignKey: 'lovelyUserId' });
this.Project.belongsTo(this.User, { as: 'LovelyUser', foreignKey: 'lovelyUserId' });
return this.User.sync({ force: true }).then(() => {
return this.Project.sync({ force: true });
});
await this.User.sync({ force: true });
await this.Project.sync({ force: true });
});
it("doesn't return instance that isn't defined", function() {
return this.Project.create({ lovelyUserId: null })
.then(project => {
return this.Project.findOne({
where: {
id: project.id
},
include: [
{ model: this.User, as: 'LovelyUser' }
]
});
})
.then(project => {
const json = project.toJSON();
expect(json.LovelyUser).to.be.equal(null);
});
it("doesn't return instance that isn't defined", async function() {
const project0 = await this.Project.create({ lovelyUserId: null });
const project = await this.Project.findOne({
where: {
id: project0.id
},
include: [
{ model: this.User, as: 'LovelyUser' }
]
});
const json = project.toJSON();
expect(json.LovelyUser).to.be.equal(null);
});
it("doesn't return instances that aren't defined", function() {
return this.User.create({ username: 'cuss' })
.then(user => {
return this.User.findOne({
where: {
id: user.id
},
include: [
{ model: this.Project, as: 'Projects' }
]
});
})
.then(user => {
expect(user.Projects).to.be.instanceof(Array);
expect(user.Projects).to.be.length(0);
});
it("doesn't return instances that aren't defined", async function() {
const user0 = await this.User.create({ username: 'cuss' });
const user = await this.User.findOne({
where: {
id: user0.id
},
include: [
{ model: this.Project, as: 'Projects' }
]
});
expect(user.Projects).to.be.instanceof(Array);
expect(user.Projects).to.be.length(0);
});
describe('build', () => {
......@@ -104,125 +100,123 @@ describe(Support.getTestDialectTeaser('Instance'), () => {
});
describe('create', () => {
it('returns an object containing all values', function() {
return this.User.create({
it('returns an object containing all values', async function() {
const user = await this.User.create({
username: 'Adam',
age: 22,
level: -1,
isUser: false,
isAdmin: true
}).then(user => {
expect(user.toJSON()).to.deep.equal({
id: user.get('id'),
username: 'Adam',
age: 22,
isUser: false,
isAdmin: true,
level: -1
});
});
expect(user.toJSON()).to.deep.equal({
id: user.get('id'),
username: 'Adam',
age: 22,
isUser: false,
isAdmin: true,
level: -1
});
});
it('returns a response that can be stringified', function() {
return this.User.create({
it('returns a response that can be stringified', async function() {
const user = await this.User.create({
username: 'test.user',
age: 99,
isAdmin: true,
isUser: false,
level: null
}).then(user => {
expect(JSON.stringify(user)).to.deep.equal(`{"id":${user.get('id')},"username":"test.user","age":99,"isAdmin":true,"isUser":false,"level":null}`);
});
expect(JSON.stringify(user)).to.deep.equal(`{"id":${user.get('id')},"username":"test.user","age":99,"isAdmin":true,"isUser":false,"level":null}`);
});
it('returns a response that can be stringified and then parsed', function() {
return this.User.create({
it('returns a response that can be stringified and then parsed', async function() {
const user = await this.User.create({
username: 'test.user',
age: 99,
isAdmin: true,
level: null
}).then(user => {
expect(JSON.parse(JSON.stringify(user))).to.deep.equal({
age: 99,
id: user.get('id'),
isAdmin: true,
isUser: false,
level: null,
username: 'test.user'
});
});
expect(JSON.parse(JSON.stringify(user))).to.deep.equal({
age: 99,
id: user.get('id'),
isAdmin: true,
isUser: false,
level: null,
username: 'test.user'
});
});
});
describe('find', () => {
it('returns an object containing all values', function() {
return this.User.create({
it('returns an object containing all values', async function() {
const user0 = await this.User.create({
username: 'Adam',
age: 22,
level: -1,
isUser: false,
isAdmin: true
});
const user = await this.User.findByPk(user0.get('id'));
expect(user.toJSON()).to.deep.equal({
id: user.get('id'),
username: 'Adam',
age: 22,
level: -1,
isUser: false,
isAdmin: true
}).then(user => this.User.findByPk(user.get('id'))).then(user => {
expect(user.toJSON()).to.deep.equal({
id: user.get('id'),
username: 'Adam',
age: 22,
level: -1,
isUser: false,
isAdmin: true
});
});
});
it('returns a response that can be stringified', function() {
return this.User.create({
it('returns a response that can be stringified', async function() {
const user0 = await this.User.create({
username: 'test.user',
age: 99,
isAdmin: true,
isUser: false
}).then(user => this.User.findByPk(user.get('id'))).then(user => {
expect(JSON.stringify(user)).to.deep.equal(`{"id":${user.get('id')},"username":"test.user","age":99,"level":null,"isUser":false,"isAdmin":true}`);
});
const user = await this.User.findByPk(user0.get('id'));
expect(JSON.stringify(user)).to.deep.equal(`{"id":${user.get('id')},"username":"test.user","age":99,"level":null,"isUser":false,"isAdmin":true}`);
});
it('returns a response that can be stringified and then parsed', function() {
return this.User.create({
it('returns a response that can be stringified and then parsed', async function() {
const user0 = await this.User.create({
username: 'test.user',
age: 99,
isAdmin: true
}).then(user => this.User.findByPk(user.get('id'))).then(user => {
expect(JSON.parse(JSON.stringify(user))).to.deep.equal({
id: user.get('id'),
username: 'test.user',
age: 99,
isAdmin: true,
isUser: false,
level: null
});
});
const user = await this.User.findByPk(user0.get('id'));
expect(JSON.parse(JSON.stringify(user))).to.deep.equal({
id: user.get('id'),
username: 'test.user',
age: 99,
isAdmin: true,
isUser: false,
level: null
});
});
});
it('includes the eagerly loaded associations', function() {
return this.User.create({ username: 'fnord', age: 1, isAdmin: true }).then(user => {
return this.Project.create({ title: 'fnord' }).then(project => {
return user.setProjects([project]).then(() => {
return this.User.findAll({ include: [{ model: this.Project, as: 'Projects' }] }).then(users => {
const _user = users[0];
it('includes the eagerly loaded associations', async function() {
const user = await this.User.create({ username: 'fnord', age: 1, isAdmin: true });
const project = await this.Project.create({ title: 'fnord' });
await user.setProjects([project]);
const users = await this.User.findAll({ include: [{ model: this.Project, as: 'Projects' }] });
const _user = users[0];
expect(_user.Projects).to.exist;
expect(JSON.parse(JSON.stringify(_user)).Projects).to.exist;
expect(_user.Projects).to.exist;
expect(JSON.parse(JSON.stringify(_user)).Projects).to.exist;
return this.Project.findAll({ include: [{ model: this.User, as: 'LovelyUser' }] }).then(projects => {
const _project = projects[0];
const projects = await this.Project.findAll({ include: [{ model: this.User, as: 'LovelyUser' }] });
const _project = projects[0];
expect(_project.LovelyUser).to.exist;
expect(JSON.parse(JSON.stringify(_project)).LovelyUser).to.exist;
});
});
});
});
});
expect(_project.LovelyUser).to.exist;
expect(JSON.parse(JSON.stringify(_project)).LovelyUser).to.exist;
});
});
});
test/integration/instance/values.test.js
......@@ -105,7 +105,7 @@ describe(Support.getTestDialectTeaser('DAO'), () => {
expect(user.dataValues.email).not.to.be.ok;
});
it('allows use of sequelize.fn and sequelize.col in date and bool fields', function() {
it('allows use of sequelize.fn and sequelize.col in date and bool fields', async function() {
const User = this.sequelize.define('User', {
d: DataTypes.DATE,
b: DataTypes.BOOLEAN,
......@@ -115,30 +115,26 @@ describe(Support.getTestDialectTeaser('DAO'), () => {
}
}, { timestamps: false });
return User.sync({ force: true }).then(() => {
return User.create({}).then(user => {
// Create the user first to set the proper default values. PG does not support column references in insert,
// so we must create a record with the right value for always_false, then reference it in an update
let now = dialect === 'sqlite' ? this.sequelize.fn('', this.sequelize.fn('datetime', 'now')) : this.sequelize.fn('NOW');
if (dialect === 'mssql') {
now = this.sequelize.fn('', this.sequelize.fn('getdate'));
}
user.set({
d: now,
b: this.sequelize.col('always_false')
});
expect(user.get('d')).to.be.instanceof(Sequelize.Utils.Fn);
expect(user.get('b')).to.be.instanceof(Sequelize.Utils.Col);
return user.save().then(() => {
return user.reload().then(() => {
expect(user.d).to.equalDate(new Date());
expect(user.b).to.equal(false);
});
});
});
await User.sync({ force: true });
const user = await User.create({});
// Create the user first to set the proper default values. PG does not support column references in insert,
// so we must create a record with the right value for always_false, then reference it in an update
let now = dialect === 'sqlite' ? this.sequelize.fn('', this.sequelize.fn('datetime', 'now')) : this.sequelize.fn('NOW');
if (dialect === 'mssql') {
now = this.sequelize.fn('', this.sequelize.fn('getdate'));
}
user.set({
d: now,
b: this.sequelize.col('always_false')
});
expect(user.get('d')).to.be.instanceof(Sequelize.Utils.Fn);
expect(user.get('b')).to.be.instanceof(Sequelize.Utils.Col);
await user.save();
await user.reload();
expect(user.d).to.equalDate(new Date());
expect(user.b).to.equal(false);
});
describe('includes', () => {
......@@ -288,7 +284,7 @@ describe(Support.getTestDialectTeaser('DAO'), () => {
expect(product.toJSON()).to.deep.equal({ withTaxes: 1250, price: 1000, id: null });
});
it('should work with save', function() {
it('should work with save', async function() {
const Contact = this.sequelize.define('Contact', {
first: { type: Sequelize.STRING },
last: { type: Sequelize.STRING },
......@@ -304,18 +300,16 @@ describe(Support.getTestDialectTeaser('DAO'), () => {
}
});
return this.sequelize.sync().then(() => {
const contact = Contact.build({
first: 'My',
last: 'Name',
tags: ['yes', 'no']
});
expect(contact.get('tags')).to.deep.equal(['yes', 'no']);
return contact.save().then(me => {
expect(me.get('tags')).to.deep.equal(['yes', 'no']);
});
await this.sequelize.sync();
const contact = Contact.build({
first: 'My',
last: 'Name',
tags: ['yes', 'no']
});
expect(contact.get('tags')).to.deep.equal(['yes', 'no']);
const me = await contact.save();
expect(me.get('tags')).to.deep.equal(['yes', 'no']);
});
describe('plain', () => {
......@@ -432,22 +426,18 @@ describe(Support.getTestDialectTeaser('DAO'), () => {
});
describe('changed', () => {
it('should return false if object was built from database', function() {
it('should return false if object was built from database', async function() {
const User = this.sequelize.define('User', {
name: { type: DataTypes.STRING }
});
return User.sync().then(() => {
return User.create({ name: 'Jan Meier' }).then(user => {
expect(user.changed('name')).to.be.false;
expect(user.changed()).not.to.be.ok;
});
}).then(() => {
return User.bulkCreate([{ name: 'Jan Meier' }]).then(([user]) => {
expect(user.changed('name')).to.be.false;
expect(user.changed()).not.to.be.ok;
});
});
await User.sync();
const user0 = await User.create({ name: 'Jan Meier' });
expect(user0.changed('name')).to.be.false;
expect(user0.changed()).not.to.be.ok;
const [user] = await User.bulkCreate([{ name: 'Jan Meier' }]);
expect(user.changed('name')).to.be.false;
expect(user.changed()).not.to.be.ok;
});
it('should return true if previous value is different', function() {
......@@ -463,27 +453,25 @@ describe(Support.getTestDialectTeaser('DAO'), () => {
expect(user.changed()).to.be.ok;
});
it('should return false immediately after saving', function() {
it('should return false immediately after saving', async function() {
const User = this.sequelize.define('User', {
name: { type: DataTypes.STRING }
});
return User.sync().then(() => {
const user = User.build({
name: 'Jan Meier'
});
user.set('name', 'Mick Hansen');
expect(user.changed('name')).to.be.true;
expect(user.changed()).to.be.ok;
return user.save().then(() => {
expect(user.changed('name')).to.be.false;
expect(user.changed()).not.to.be.ok;
});
await User.sync();
const user = User.build({
name: 'Jan Meier'
});
user.set('name', 'Mick Hansen');
expect(user.changed('name')).to.be.true;
expect(user.changed()).to.be.ok;
await user.save();
expect(user.changed('name')).to.be.false;
expect(user.changed()).not.to.be.ok;
});
it('should be available to a afterUpdate hook', function() {
it('should be available to a afterUpdate hook', async function() {
const User = this.sequelize.define('User', {
name: { type: DataTypes.STRING }
});
......@@ -494,20 +482,20 @@ describe(Support.getTestDialectTeaser('DAO'), () => {
return;
});
return User.sync({ force: true }).then(() => {
return User.create({
name: 'Ford Prefect'
});
}).then(user => {
return user.update({
name: 'Arthur Dent'
});
}).then(user => {
expect(changed).to.be.ok;
expect(changed.length).to.be.ok;
expect(changed).to.include('name');
expect(user.changed()).not.to.be.ok;
await User.sync({ force: true });
const user0 = await User.create({
name: 'Ford Prefect'
});
const user = await user0.update({
name: 'Arthur Dent'
});
expect(changed).to.be.ok;
expect(changed.length).to.be.ok;
expect(changed).to.include('name');
expect(user.changed()).not.to.be.ok;
});
});
......
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!