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