// Copyright IBM Corp. 2015,2016. All Rights Reserved. // Node module: loopback-datasource-juggler // This file is licensed under the MIT License. // License text available at https://opensource.org/licenses/MIT var ValidationError = require('../').ValidationError; var contextTestHelpers = require('./helpers/context-test-helpers'); var ContextRecorder = contextTestHelpers.ContextRecorder; var deepCloneToObject = contextTestHelpers.deepCloneToObject; var aCtxForModel = contextTestHelpers.aCtxForModel; var uid = require('./helpers/uid-generator'); var getLastGeneratedUid = uid.last; var HookMonitor = require('./helpers/hook-monitor'); module.exports = function(dataSource, should, connectorCapabilities) { if (!connectorCapabilities) connectorCapabilities = {}; if (connectorCapabilities.replaceOrCreateReportsNewInstance === undefined) { console.warn('The connector does not support a recently added feature: ' + 'replaceOrCreateReportsNewInstance'); } describe('Persistence hooks', function() { var ctxRecorder, hookMonitor, expectedError; var TestModel, existingInstance; var migrated = false; var undefinedValue = undefined; beforeEach(function setupDatabase(done) { ctxRecorder = new ContextRecorder('hook not called'); hookMonitor = new HookMonitor({includeModelName: false}); expectedError = new Error('test error'); TestModel = dataSource.createModel('TestModel', { // Set id.generated to false to honor client side values id: {type: String, id: true, generated: false, default: uid.next}, name: {type: String, required: true}, extra: {type: String, required: false}, }); uid.reset(); if (migrated) { TestModel.deleteAll(done); } else { dataSource.automigrate(TestModel.modelName, function(err) { migrated = true; done(err); }); } }); beforeEach(function createTestData(done) { TestModel.create({name: 'first'}, function(err, instance) { if (err) return done(err); // Look it up from DB so that default values are retrieved TestModel.findById(instance.id, function(err, instance) { existingInstance = instance; undefinedValue = existingInstance.extra; TestModel.create({name: 'second'}, function(err) { if (err) return done(err); done(); }); }); }); }); describe('PersistedModel.find', function() { it('triggers hooks in the correct order', function(done) { monitorHookExecution(); TestModel.find( {where: {id: '1'}}, function(err, list) { if (err) return done(err); hookMonitor.names.should.eql([ 'access', 'loaded', ]); done(); }); }); it('triggers correct hooks when near filter is used', function(done) { monitorHookExecution(); var query = {where: {location: {near: '10,20', maxDistance: '10', unit: 'meters'}}, }; TestModel.find(query, function(err, list) { if (err) return done(err); hookMonitor.names.should.eql(['access']); done(); }); }); it('should not trigger hooks, if notify is false', function(done) { monitorHookExecution(); TestModel.find( {where: {id: '1'}}, {notify: false}, function(err, list) { if (err) return done(err); hookMonitor.names.should.be.empty(); done(); }); }); it('should not trigger hooks for geo queries, if notify is false', function(done) { monitorHookExecution(); TestModel.find( {where: {geo: [{near: '10,20'}]}}, {notify: false}, function(err, list) { if (err) return done(err); hookMonitor.names.should.be.empty(); done(); }); }); it('should apply updates from `access` hook', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {name: 'second'}}; next(); }); TestModel.find({name: 'first'}, function(err, list) { if (err) return done(err); list.map(get('name')).should.eql(['second']); done(); }); }); it('triggers `access` hook', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.find({where: {id: '1'}}, function(err, list) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { query: {where: {id: '1'}}, })); done(); }); }); it('aborts when `access` hook fails', function(done) { TestModel.observe('access', nextWithError(expectedError)); TestModel.find(function(err, list) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `access` hook', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: existingInstance.id}}; next(); }); TestModel.find(function(err, list) { if (err) return done(err); list.map(get('name')).should.eql([existingInstance.name]); done(); }); }); it('triggers `access` hook for geo queries', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.find({where: {geo: [{near: '10,20'}]}}, function(err, list) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { query: {where: {geo: [{near: '10,20'}]}}, })); done(); }); }); it('applies updates from `access` hook for geo queries', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: existingInstance.id}}; next(); }); TestModel.find({where: {geo: {near: '10,20'}}}, function(err, list) { if (err) return done(err); list.map(get('name')).should.eql([existingInstance.name]); done(); }); }); it('applies updates from `loaded` hook', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) { ctx.instance.extra = 'hook data'; })); TestModel.find( {where: {id: 1}}, function(err, list) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: '1', name: 'first', extra: 'hook data', }, isNewInstance: false, options: {}, })); done(); }); }); it('emits error when `loaded` hook fails', function(done) { TestModel.observe('loaded', nextWithError(expectedError)); TestModel.find( {where: {id: 1}}, function(err, list) { [err].should.eql([expectedError]); done(); }); }); }); describe('PersistedModel.create', function() { it('triggers hooks in the correct order', function(done) { monitorHookExecution(); TestModel.create( {name: 'created'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'before save', 'persist', 'loaded', 'after save', ]); done(); }); }); it('triggers `before save` hook', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.create({name: 'created'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: instance.id, name: 'created', extra: undefined, }, isNewInstance: true, })); done(); }); }); it('aborts when `before save` hook fails', function(done) { TestModel.observe('before save', nextWithError(expectedError)); TestModel.create({name: 'created'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `before save` hook', function(done) { TestModel.observe('before save', function(ctx, next) { ctx.instance.should.be.instanceOf(TestModel); ctx.instance.extra = 'hook data'; next(); }); TestModel.create({id: uid.next(), name: 'a-name'}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); it('sends `before save` for each model in an array', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.create( [{name: '1'}, {name: '2'}], function(err, list) { if (err) return done(err); // Creation of multiple instances is executed in parallel ctxRecorder.records.sort(function(c1, c2) { return c1.instance.name - c2.instance.name; }); ctxRecorder.records.should.eql([ aCtxForModel(TestModel, { instance: {id: list[0].id, name: '1', extra: undefined}, isNewInstance: true, }), aCtxForModel(TestModel, { instance: {id: list[1].id, name: '2', extra: undefined}, isNewInstance: true, }), ]); done(); }); }); it('validates model after `before save` hook', function(done) { TestModel.observe('before save', invalidateTestModel()); TestModel.create({name: 'created'}, function(err) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); it('triggers `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.create( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: {id: 'new-id', name: 'a name'}, isNewInstance: true, currentInstance: {extra: null, id: 'new-id', name: 'a name'}, })); done(); }); }); it('applies updates from `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); // By default, the instance passed to create callback is NOT updated // with the changes made through persist/loaded hooks. To preserve // backwards compatibility, we introduced a new setting updateOnLoad, // which if set, will apply these changes to the model instance too. TestModel.settings.updateOnLoad = true; TestModel.create( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); // Also query the database here to verify that, on `create` // updates from `persist` hook are reflected into database TestModel.findById('new-id', function(err, dbInstance) { if (err) return done(err); should.exists(dbInstance); dbInstance.toObject(true).should.eql({ id: 'new-id', name: 'a name', extra: 'hook data', }); done(); }); }); }); it('triggers `loaded` hook', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); // By default, the instance passed to create callback is NOT updated // with the changes made through persist/loaded hooks. To preserve // backwards compatibility, we introduced a new setting updateOnLoad, // which if set, will apply these changes to the model instance too. TestModel.settings.updateOnLoad = true; TestModel.create( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: {id: 'new-id', name: 'a name'}, isNewInstance: true, })); done(); }); }); it('emits error when `loaded` hook fails', function(done) { TestModel.observe('loaded', nextWithError(expectedError)); TestModel.create( {id: 'new-id', name: 'a name'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `loaded` hook', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); // By default, the instance passed to create callback is NOT updated // with the changes made through persist/loaded hooks. To preserve // backwards compatibility, we introduced a new setting updateOnLoad, // which if set, will apply these changes to the model instance too. TestModel.settings.updateOnLoad = true; TestModel.create( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); it('triggers `after save` hook', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.create({name: 'created'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: instance.id, name: 'created', extra: undefined, }, isNewInstance: true, })); done(); }); }); it('aborts when `after save` hook fails', function(done) { TestModel.observe('after save', nextWithError(expectedError)); TestModel.create({name: 'created'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `after save` hook', function(done) { TestModel.observe('after save', function(ctx, next) { ctx.instance.should.be.instanceOf(TestModel); ctx.instance.extra = 'hook data'; next(); }); TestModel.create({name: 'a-name'}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); it('sends `after save` for each model in an array', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.create( [{name: '1'}, {name: '2'}], function(err, list) { if (err) return done(err); // Creation of multiple instances is executed in parallel ctxRecorder.records.sort(function(c1, c2) { return c1.instance.name - c2.instance.name; }); ctxRecorder.records.should.eql([ aCtxForModel(TestModel, { instance: {id: list[0].id, name: '1', extra: undefined}, isNewInstance: true, }), aCtxForModel(TestModel, { instance: {id: list[1].id, name: '2', extra: undefined}, isNewInstance: true, }), ]); done(); }); }); it('emits `after save` when some models were not saved', function(done) { TestModel.observe('before save', function(ctx, next) { if (ctx.instance.name === 'fail') next(expectedError); else next(); }); TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.create( [{name: 'ok'}, {name: 'fail'}], function(err, list) { (err || []).should.have.length(2); err[1].should.eql(expectedError); // NOTE(bajtos) The current implementation of `Model.create(array)` // passes all models in the second callback argument, including // the models that were not created due to an error. list.map(get('name')).should.eql(['ok', 'fail']); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: {id: list[0].id, name: 'ok', extra: undefined}, isNewInstance: true, })); done(); }); }); }); describe('PersistedModel.findOrCreate', function() { it('triggers `access` hook', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.findOrCreate( {where: {name: 'new-record'}}, {name: 'new-record'}, function(err, record, created) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: { where: {name: 'new-record'}, limit: 1, offset: 0, skip: 0, }})); done(); }); }); if (dataSource.connector.findOrCreate) { it('triggers `before save` hook when found', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.findOrCreate( {where: {name: existingInstance.name}}, {name: existingInstance.name}, function(err, record, created) { if (err) return done(err); record.id.should.eql(existingInstance.id); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: getLastGeneratedUid(), name: existingInstance.name, extra: undefined, }, isNewInstance: true, })); done(); }); }); } it('triggers `before save` hook when not found', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.findOrCreate( {where: {name: 'new-record'}}, {name: 'new-record'}, function(err, record, created) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: record.id, name: 'new-record', extra: undefined, }, isNewInstance: true, })); done(); }); }); it('validates model after `before save` hook', function(done) { TestModel.observe('before save', invalidateTestModel()); TestModel.findOrCreate( {where: {name: 'new-record'}}, {name: 'new-record'}, function(err) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); it('triggers hooks in the correct order when not found', function(done) { monitorHookExecution(); TestModel.findOrCreate( {where: {name: 'new-record'}}, {name: 'new-record'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'access', 'before save', 'persist', 'loaded', 'after save', ]); done(); }); }); it('triggers hooks in the correct order when found', function(done) { monitorHookExecution(); TestModel.findOrCreate( {where: {name: existingInstance.name}}, {name: existingInstance.name}, function(err, record, created) { if (err) return done(err); if (dataSource.connector.findOrCreate) { hookMonitor.names.should.eql([ 'access', 'before save', 'persist', 'loaded', ]); } else { hookMonitor.names.should.eql([ 'access', 'loaded', ]); } done(); }); }); it('aborts when `access` hook fails', function(done) { TestModel.observe('access', nextWithError(expectedError)); TestModel.findOrCreate( {where: {id: 'does-not-exist'}}, {name: 'does-not-exist'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('aborts when `before save` hook fails', function(done) { TestModel.observe('before save', nextWithError(expectedError)); TestModel.findOrCreate( {where: {id: 'does-not-exist'}}, {name: 'does-not-exist'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); if (dataSource.connector.findOrCreate) { it('triggers `persist` hook when found', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.findOrCreate( {where: {name: existingInstance.name}}, {name: existingInstance.name}, function(err, record, created) { if (err) return done(err); record.id.should.eql(existingInstance.id); // `findOrCreate` creates a new instance of the object everytime. // So, `data.id` as well as `currentInstance.id` always matches // the newly generated UID. // Hence, the test below asserts both `data.id` and // `currentInstance.id` to match getLastGeneratedUid(). // On same lines, it also asserts `isNewInstance` to be true. ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: getLastGeneratedUid(), name: existingInstance.name, }, isNewInstance: true, currentInstance: { id: getLastGeneratedUid(), name: record.name, extra: null, }, where: {name: existingInstance.name}, })); done(); }); }); } it('triggers `persist` hook when not found', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.findOrCreate( {where: {name: 'new-record'}}, {name: 'new-record'}, function(err, record, created) { if (err) return done(err); // `context.where` is present in Optimized connector context, // but, unoptimized connector does NOT have it. if (dataSource.connector.findOrCreate) { ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: record.id, name: 'new-record', }, isNewInstance: true, currentInstance: { id: record.id, name: record.name, extra: null, }, where: {name: 'new-record'}, })); } else { ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: record.id, name: 'new-record', }, isNewInstance: true, currentInstance: {id: record.id, name: record.name, extra: null}, })); } done(); }); }); if (dataSource.connector.findOrCreate) { it('applies updates from `persist` hook when found', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); TestModel.findOrCreate( {where: {name: existingInstance.name}}, {name: existingInstance.name}, function(err, instance) { if (err) return done(err); // instance returned by `findOrCreate` context does not // have the values updated from `persist` hook instance.should.not.have.property('extra', 'hook data'); // Query the database. Here, since record already exists // `findOrCreate`, does not update database for // updates from `persist` hook TestModel.findById(existingInstance.id, function(err, dbInstance) { if (err) return done(err); should.exists(dbInstance); dbInstance.toObject(true).should.eql({ id: existingInstance.id, name: existingInstance.name, extra: undefined, }); }); done(); }); }); } it('applies updates from `persist` hook when not found', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); TestModel.findOrCreate( {where: {name: 'new-record'}}, {name: 'new-record'}, function(err, instance) { if (err) return done(err); if (dataSource.connector.findOrCreate) { instance.should.have.property('extra', 'hook data'); } else { // Unoptimized connector gives a call to `create. And during // create the updates applied through persist hook are // reflected into the database, but the same updates are // NOT reflected in the instance object obtained in callback // of create. // So, this test asserts unoptimized connector to // NOT have `extra` property. And then verifes that the // property `extra` is actually updated in DB instance.should.not.have.property('extra', 'hook data'); TestModel.findById(instance.id, function(err, dbInstance) { if (err) return done(err); should.exists(dbInstance); dbInstance.toObject(true).should.eql({ id: instance.id, name: instance.name, extra: 'hook data', }); }); } done(); }); }); if (dataSource.connector.findOrCreate) { it('triggers `loaded` hook when found', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); TestModel.findOrCreate( {where: {name: existingInstance.name}}, {name: existingInstance.name}, function(err, record, created) { if (err) return done(err); record.id.should.eql(existingInstance.id); // After the call to `connector.findOrCreate`, since the record // already exists, `data.id` matches `existingInstance.id` // as against the behaviour noted for `persist` hook ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: existingInstance.id, name: existingInstance.name, }, isNewInstance: false, })); done(); }); }); } it('triggers `loaded` hook when not found', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); TestModel.findOrCreate( {where: {name: 'new-record'}}, {name: 'new-record'}, function(err, record, created) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: record.id, name: 'new-record', }, isNewInstance: true, })); done(); }); }); it('emits error when `loaded` hook fails', function(done) { TestModel.observe('loaded', nextWithError(expectedError)); TestModel.findOrCreate( {where: {name: 'new-record'}}, {name: 'new-record'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); if (dataSource.connector.findOrCreate) { it('applies updates from `loaded` hook when found', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); TestModel.findOrCreate( {where: {name: existingInstance.name}}, {name: existingInstance.name}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); } it('applies updates from `loaded` hook when not found', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); // Unoptimized connector gives a call to `create. But, // by default, the instance passed to create callback is NOT updated // with the changes made through persist/loaded hooks. To preserve // backwards compatibility, we introduced a new setting updateOnLoad, // which if set, will apply these changes to the model instance too. // Note - in case of findOrCreate, this setting is needed ONLY for // unoptimized connector. TestModel.settings.updateOnLoad = true; TestModel.findOrCreate( {where: {name: 'new-record'}}, {name: 'new-record'}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); it('triggers `after save` hook when not found', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.findOrCreate( {where: {name: 'new name'}}, {name: 'new name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: instance.id, name: 'new name', extra: undefined, }, isNewInstance: true, })); done(); }); }); it('does not trigger `after save` hook when found', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.findOrCreate( {where: {id: existingInstance.id}}, {name: existingInstance.name}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql('hook not called'); done(); }); }); }); describe('PersistedModel.count', function(done) { it('triggers `access` hook', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.count({id: existingInstance.id}, function(err, count) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: { where: {id: existingInstance.id}, }})); done(); }); }); it('applies updates from `access` hook', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query.where = {id: existingInstance.id}; next(); }); TestModel.count(function(err, count) { if (err) return done(err); count.should.equal(1); done(); }); }); }); describe('PersistedModel.prototype.save', function() { it('triggers hooks in the correct order', function(done) { monitorHookExecution(); existingInstance.save( function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'before save', 'persist', 'loaded', 'after save', ]); done(); }); }); it('triggers `before save` hook', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); existingInstance.name = 'changed'; existingInstance.save(function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {instance: { id: existingInstance.id, name: 'changed', extra: undefined, }, options: {throws: false, validate: true}})); done(); }); }); it('aborts when `before save` hook fails', function(done) { TestModel.observe('before save', nextWithError(expectedError)); existingInstance.save(function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `before save` hook', function(done) { TestModel.observe('before save', function(ctx, next) { ctx.instance.should.be.instanceOf(TestModel); ctx.instance.extra = 'hook data'; next(); }); existingInstance.save(function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); it('validates model after `before save` hook', function(done) { TestModel.observe('before save', invalidateTestModel()); existingInstance.save(function(err) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); it('triggers `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); existingInstance.name = 'changed'; existingInstance.save(function(err, instance) { if (err) return done(err); // HACK: extra is undefined for NoSQL and null for SQL delete ctxRecorder.records.data.extra; delete ctxRecorder.records.currentInstance.extra; ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: existingInstance.id, name: 'changed', }, currentInstance: { id: existingInstance.id, name: 'changed', }, where: {id: existingInstance.id}, options: {throws: false, validate: true}, })); done(); }); }); it('applies updates from `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); existingInstance.save(function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); it('triggers `loaded` hook', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); existingInstance.extra = 'changed'; existingInstance.save(function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: existingInstance.id, name: existingInstance.name, extra: 'changed', }, isNewInstance: false, options: {throws: false, validate: true}, })); done(); }); }); it('emits error when `loaded` hook fails', function(done) { TestModel.observe('loaded', nextWithError(expectedError)); existingInstance.save( function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `loaded` hook', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); existingInstance.save(function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); it('triggers `after save` hook on update', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); existingInstance.name = 'changed'; existingInstance.save(function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: existingInstance.id, name: 'changed', extra: undefined, }, isNewInstance: false, options: {throws: false, validate: true}, })); done(); }); }); it('triggers `after save` hook on create', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); // The rationale behind passing { persisted: true } is to bypass the check // made by DAO to determine whether the instance should be saved via // PersistedModel.create and force it to call connector.save() var instance = new TestModel( {id: 'new-id', name: 'created'}, {persisted: true}); instance.save(function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: instance.id, name: 'created', extra: undefined, }, isNewInstance: true, options: {throws: false, validate: true}, })); done(); }); }); it('aborts when `after save` hook fails', function(done) { TestModel.observe('after save', nextWithError(expectedError)); existingInstance.save(function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `after save` hook', function(done) { TestModel.observe('after save', function(ctx, next) { ctx.instance.should.be.instanceOf(TestModel); ctx.instance.extra = 'hook data'; next(); }); existingInstance.save(function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); }); describe('PersistedModel.prototype.updateAttributes', function() { it('triggers hooks in the correct order', function(done) { monitorHookExecution(); existingInstance.updateAttributes( {name: 'changed'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'before save', 'persist', 'loaded', 'after save', ]); done(); }); }); it('triggers `before save` hook', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); var currentInstance = deepCloneToObject(existingInstance); existingInstance.updateAttributes({name: 'changed'}, function(err) { if (err) return done(err); existingInstance.name.should.equal('changed'); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: existingInstance.id}, data: {name: 'changed'}, currentInstance: currentInstance, })); done(); }); }); it('aborts when `before save` hook fails', function(done) { TestModel.observe('before save', nextWithError(expectedError)); existingInstance.updateAttributes({name: 'updated'}, function(err) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `before save` hook', function(done) { TestModel.observe('before save', function(ctx, next) { ctx.data.extra = 'extra data'; ctx.data.name = 'hooked name'; next(); }); existingInstance.updateAttributes({name: 'updated'}, function(err) { if (err) return done(err); // We must query the database here because `updateAttributes` // returns effectively `this`, not the data from the datasource TestModel.findById(existingInstance.id, function(err, instance) { if (err) return done(err); should.exists(instance); instance.toObject(true).should.eql({ id: existingInstance.id, name: 'hooked name', extra: 'extra data', }); done(); }); }); }); it('validates model after `before save` hook', function(done) { TestModel.observe('before save', invalidateTestModel()); existingInstance.updateAttributes({name: 'updated'}, function(err) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); it('triggers `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); existingInstance.updateAttributes({name: 'changed'}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: existingInstance.id}, data: {name: 'changed'}, currentInstance: { id: existingInstance.id, name: 'changed', extra: null, }, isNewInstance: false, })); done(); }); }); it('applies updates from `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); // By default, the instance passed to updateAttributes callback is NOT updated // with the changes made through persist/loaded hooks. To preserve // backwards compatibility, we introduced a new setting updateOnLoad, // which if set, will apply these changes to the model instance too. TestModel.settings.updateOnLoad = true; existingInstance.updateAttributes({name: 'changed'}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); it('applies updates from `persist` hook - for nested model instance', function(done) { var Address = dataSource.createModel('NestedAddress', { id: {type: String, id: true, default: 1}, city: {type: String, required: true}, country: {type: String, required: true}, }); var User = dataSource.createModel('UserWithAddress', { id: {type: String, id: true, default: uid.next}, name: {type: String, required: true}, address: {type: Address, required: false}, extra: {type: String}, }); dataSource.automigrate(['UserWithAddress', 'NestedAddress'], function(err) { if (err) return done(err); User.create({name: 'Joe'}, function(err, instance) { if (err) return done(err); var existingUser = instance; User.observe('persist', ctxRecorder.recordAndNext(function(ctx) { should.exist(ctx.data.address); ctx.data.address.should.be.type('object'); ctx.data.address.should.not.be.instanceOf(Address); ctx.data.extra = 'hook data'; })); // By default, the instance passed to updateAttributes callback is NOT updated // with the changes made through persist/loaded hooks. To preserve // backwards compatibility, we introduced a new setting updateOnLoad, // which if set, will apply these changes to the model instance too. User.settings.updateOnLoad = true; existingUser.updateAttributes( {address: new Address({city: 'Springfield', country: 'USA'})}, function(err, inst) { if (err) return done(err); inst.should.have.property('extra', 'hook data'); User.findById(existingUser.id, function(err, dbInstance) { if (err) return done(err); dbInstance.toObject(true).should.eql({ id: existingUser.id, name: existingUser.name, address: {id: '1', city: 'Springfield', country: 'USA'}, extra: 'hook data', }); done(); }); }); }); }); }); it('triggers `loaded` hook', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); existingInstance.updateAttributes({name: 'changed'}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: {name: 'changed'}, isNewInstance: false, })); done(); }); }); it('emits error when `loaded` hook fails', function(done) { TestModel.observe('loaded', nextWithError(expectedError)); existingInstance.updateAttributes( {name: 'changed'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `loaded` hook updateAttributes', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); // By default, the instance passed to updateAttributes callback is NOT updated // with the changes made through persist/loaded hooks. To preserve // backwards compatibility, we introduced a new setting updateOnLoad, // which if set, will apply these changes to the model instance too. TestModel.settings.updateOnLoad = true; existingInstance.updateAttributes({name: 'changed'}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); it('triggers `after save` hook', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); existingInstance.name = 'changed'; existingInstance.updateAttributes({name: 'changed'}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: existingInstance.id, name: 'changed', extra: undefined, }, isNewInstance: false, })); done(); }); }); it('aborts when `after save` hook fails', function(done) { TestModel.observe('after save', nextWithError(expectedError)); existingInstance.updateAttributes({name: 'updated'}, function(err) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `after save` hook', function(done) { TestModel.observe('after save', function(ctx, next) { ctx.instance.should.be.instanceOf(TestModel); ctx.instance.extra = 'hook data'; next(); }); existingInstance.updateAttributes({name: 'updated'}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); }); if (!getSchema().connector.replaceById) { describe.skip('replaceById - not implemented', function() {}); } else { describe('PersistedModel.prototype.replaceAttributes', function() { it('triggers hooks in the correct order', function(done) { monitorHookExecution(); existingInstance.replaceAttributes( {name: 'replaced'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'before save', 'persist', 'loaded', 'after save', ]); done(); }); }); it('triggers `before save` hook', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); existingInstance.replaceAttributes({name: 'changed'}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: existingInstance.id, name: 'changed', extra: undefined, }, isNewInstance: false, })); done(); }); }); it('aborts when `before save` hook fails', function(done) { TestModel.observe('before save', nextWithError(expectedError)); existingInstance.replaceAttributes({name: 'replaced'}, function(err) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `before save` hook', function(done) { TestModel.observe('before save', function(ctx, next) { ctx.instance.extra = 'extra data'; ctx.instance.name = 'hooked name'; next(); }); existingInstance.replaceAttributes({name: 'updated'}, function(err) { if (err) return done(err); TestModel.findById(existingInstance.id, function(err, instance) { if (err) return done(err); should.exists(instance); instance.toObject(true).should.eql({ id: existingInstance.id, name: 'hooked name', extra: 'extra data', }); done(); }); }); }); it('validates model after `before save` hook', function(done) { TestModel.observe('before save', invalidateTestModel()); existingInstance.replaceAttributes({name: 'updated'}, function(err) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); it('triggers `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); existingInstance.replaceAttributes({name: 'replacedName'}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: existingInstance.id}, data: { name: 'replacedName', id: existingInstance.id, }, currentInstance: { id: existingInstance.id, name: 'replacedName', extra: null, }, isNewInstance: false, })); done(); }); }); it('applies delete from `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) { delete ctx.data.extra; })); existingInstance.replaceAttributes({name: 'changed'}, function(err, instance) { if (err) return done(err); instance.should.not.have.property('extra', 'hook data'); done(); }); }); it('applies updates from `persist` hook - for nested model instance', function(done) { var Address = dataSource.createModel('NestedAddress', { id: {type: String, id: true, default: 1}, city: {type: String, required: true}, country: {type: String, required: true}, }); var User = dataSource.createModel('UserWithAddress', { id: {type: String, id: true, default: uid.next}, name: {type: String, required: true}, address: {type: Address, required: false}, extra: {type: String}, }); dataSource.automigrate(['UserWithAddress', 'NestedAddress'], function(err) { if (err) return done(err); User.create({name: 'Joe'}, function(err, instance) { if (err) return done(err); var existingUser = instance; User.observe('persist', ctxRecorder.recordAndNext(function(ctx) { should.exist(ctx.data.address); ctx.data.address.should.be.type('object'); ctx.data.address.should.not.be.instanceOf(Address); ctx.data.extra = 'hook data'; })); existingUser.replaceAttributes( {name: 'John', address: new Address({city: 'Springfield', country: 'USA'})}, function(err, inst) { if (err) return done(err); inst.should.have.property('extra', 'hook data'); User.findById(existingUser.id, function(err, dbInstance) { if (err) return done(err); dbInstance.toObject(true).should.eql({ id: existingUser.id, name: 'John', address: {id: '1', city: 'Springfield', country: 'USA'}, extra: 'hook data', }); done(); }); }); }); }); }); it('triggers `loaded` hook', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); existingInstance.replaceAttributes({name: 'changed'}, function(err, data) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { name: 'changed', id: data.id, }, isNewInstance: false, })); done(); }); }); it('emits error when `loaded` hook fails', function(done) { TestModel.observe('loaded', nextWithError(expectedError)); existingInstance.replaceAttributes( {name: 'replaced'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `loaded` hook replaceAttributes', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) { ctx.data.name = 'changed in hook'; })); existingInstance.replaceAttributes({name: 'changed'}, function(err, instance) { if (err) return done(err); instance.should.have.property('name', 'changed in hook'); done(); }); }); it('triggers `after save` hook', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); existingInstance.name = 'replaced'; existingInstance.replaceAttributes({name: 'replaced'}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: existingInstance.id, name: 'replaced', extra: undefined, }, isNewInstance: false, })); done(); }); }); it('aborts when `after save` hook fails', function(done) { TestModel.observe('after save', nextWithError(expectedError)); existingInstance.replaceAttributes({name: 'replaced'}, function(err) { [err].should.eql([expectedError]); done(); }); }); it('applies updates from `after save` hook', function(done) { TestModel.observe('after save', function(ctx, next) { ctx.instance.should.be.instanceOf(TestModel); ctx.instance.extra = 'hook data'; next(); }); existingInstance.replaceAttributes({name: 'updated'}, function(err, instance) { if (err) return done(err); instance.should.have.property('extra', 'hook data'); done(); }); }); }); } describe('PersistedModel.updateOrCreate', function() { it('triggers hooks in the correct order on create', function(done) { monitorHookExecution(); TestModel.updateOrCreate( {id: 'not-found', name: 'not found'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'access', 'before save', 'persist', 'loaded', 'after save', ]); done(); }); }); it('triggers hooks in the correct order on update', function(done) { monitorHookExecution(); TestModel.updateOrCreate( {id: existingInstance.id, name: 'new name'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'access', 'before save', 'persist', 'loaded', 'after save', ]); done(); }); }); it('triggers `access` hook on create', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: 'not-found', name: 'not found'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: { where: {id: 'not-found'}, }})); done(); }); }); it('triggers `access` hook on update', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: existingInstance.id, name: 'new name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: { where: {id: existingInstance.id}, }})); done(); }); }); it('does not trigger `access` on missing id', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {name: 'new name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.equal('hook not called'); done(); }); }); it('applies updates from `access` hook when found', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); TestModel.updateOrCreate( {id: existingInstance.id, name: 'new name'}, function(err, instance) { if (err) return done(err); findTestModels({fields: ['id', 'name']}, function(err, list) { if (err) return done(err); (list || []).map(toObject).should.eql([ {id: existingInstance.id, name: existingInstance.name, extra: undefined}, {id: instance.id, name: 'new name', extra: undefined}, ]); done(); }); }); }); it('applies updates from `access` hook when not found', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: 'not-found'}}; next(); }); TestModel.updateOrCreate( {id: existingInstance.id, name: 'new name'}, function(err, instance) { if (err) return done(err); findTestModels({fields: ['id', 'name']}, function(err, list) { if (err) return done(err); (list || []).map(toObject).should.eql([ {id: existingInstance.id, name: existingInstance.name, extra: undefined}, {id: list[1].id, name: 'second', extra: undefined}, {id: instance.id, name: 'new name', extra: undefined}, ]); done(); }); }); }); it('triggers hooks only once', function(done) { monitorHookExecution(['access', 'before save']); TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); TestModel.updateOrCreate( {id: 'ignored', name: 'new name'}, function(err, instance) { if (err) return done(err); hookMonitor.names.should.eql(['access', 'before save']); done(); }); }); it('triggers `before save` hook on update', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: existingInstance.id, name: 'updated name'}, function(err, instance) { if (err) return done(err); if (dataSource.connector.updateOrCreate) { // Atomic implementations of `updateOrCreate` cannot // provide full instance as that depends on whether // UPDATE or CREATE will be triggered ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: existingInstance.id}, data: {id: existingInstance.id, name: 'updated name'}, })); } else { // currentInstance is set, because a non-atomic `updateOrCreate` // will use `prototype.updateAttributes` internally, which // exposes this to the context ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: existingInstance.id}, data: {id: existingInstance.id, name: 'updated name'}, currentInstance: existingInstance, })); } done(); }); }); it('triggers `before save` hook on create', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); if (dataSource.connector.updateOrCreate) { // Atomic implementations of `updateOrCreate` cannot // provide full instance as that depends on whether // UPDATE or CREATE will be triggered ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: 'new-id'}, data: {id: 'new-id', name: 'a name'}, })); } else { // The default unoptimized implementation runs // `instance.save` and thus a full instance is availalbe ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: {id: 'new-id', name: 'a name', extra: undefined}, isNewInstance: true, })); } done(); }); }); it('applies updates from `before save` hook on update', function(done) { TestModel.observe('before save', function(ctx, next) { ctx.data.name = 'hooked'; next(); }); TestModel.updateOrCreate( {id: existingInstance.id, name: 'updated name'}, function(err, instance) { if (err) return done(err); instance.name.should.equal('hooked'); done(); }); }); it('applies updates from `before save` hook on create', function(done) { TestModel.observe('before save', function(ctx, next) { if (ctx.instance) { ctx.instance.name = 'hooked'; } else { ctx.data.name = 'hooked'; } next(); }); TestModel.updateOrCreate( {id: 'new-id', name: 'new name'}, function(err, instance) { if (err) return done(err); instance.name.should.equal('hooked'); done(); }); }); // FIXME(bajtos) this fails with connector-specific updateOrCreate // implementations, see the comment inside lib/dao.js (updateOrCreate) it.skip('validates model after `before save` hook on update', function(done) { TestModel.observe('before save', invalidateTestModel()); TestModel.updateOrCreate( {id: existingInstance.id, name: 'updated name'}, function(err, instance) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); // FIXME(bajtos) this fails with connector-specific updateOrCreate // implementations, see the comment inside lib/dao.js (updateOrCreate) it.skip('validates model after `before save` hook on create', function(done) { TestModel.observe('before save', invalidateTestModel()); TestModel.updateOrCreate( {id: 'new-id', name: 'new name'}, function(err, instance) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); it('triggers `persist` hook on create', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); if (dataSource.connector.updateOrCreate) { ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: 'new-id'}, data: {id: 'new-id', name: 'a name'}, currentInstance: { id: 'new-id', name: 'a name', extra: undefined, }, })); } else { ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: 'new-id', name: 'a name', }, isNewInstance: true, currentInstance: { id: 'new-id', name: 'a name', extra: undefined, }, })); } done(); }); }); it('triggers `persist` hook on update', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: existingInstance.id, name: 'updated name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { where: {id: existingInstance.id}, data: { id: existingInstance.id, name: 'updated name', }, currentInstance: { id: existingInstance.id, name: 'updated name', extra: undefined, }, }); if (!dataSource.connector.updateOrCreate) { // When the connector does not provide updateOrCreate, // DAO falls back to updateAttributes which sets this flag expectedContext.isNewInstance = false; } ctxRecorder.records.should.eql(expectedContext); done(); }); }); it('triggers `loaded` hook on create', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: 'new-id', name: 'a name', }, isNewInstance: true, })); done(); }); }); it('triggers `loaded` hook on update', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: existingInstance.id, name: 'updated name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: { id: existingInstance.id, name: 'updated name', }, isNewInstance: false, })); done(); }); }); it('emits error when `loaded` hook fails', function(done) { TestModel.observe('loaded', nextWithError(expectedError)); TestModel.updateOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('triggers `after save` hook on update', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: existingInstance.id, name: 'updated name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: existingInstance.id, name: 'updated name', extra: undefined, }, isNewInstance: false, })); done(); }); }); it('triggers `after save` hook on create', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.updateOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: instance.id, name: 'a name', extra: undefined, }, isNewInstance: true, })); done(); }); }); }); if (!getSchema().connector.replaceById) { describe.skip('replaceById - not implemented', function() {}); } else { describe('PersistedModel.replaceOrCreate', function() { it('triggers hooks in the correct order on create', function(done) { monitorHookExecution(); TestModel.replaceOrCreate( {id: 'not-found', name: 'not found'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'access', 'before save', 'persist', 'loaded', 'after save', ]); done(); }); }); it('triggers hooks in the correct order on replace', function(done) { monitorHookExecution(); TestModel.replaceOrCreate( {id: existingInstance.id, name: 'new name'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'access', 'before save', 'persist', 'loaded', 'after save', ]); done(); }); }); it('triggers `access` hook on create', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: 'not-found', name: 'not found'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: { where: {id: 'not-found'}, }})); done(); }); }); it('triggers `access` hook on replace', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: existingInstance.id, name: 'new name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: { where: {id: existingInstance.id}, }})); done(); }); }); it('does not trigger `access` on missing id', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {name: 'new name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.equal('hook not called'); done(); }); }); it('applies updates from `access` hook when found', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); TestModel.replaceOrCreate( {id: existingInstance.id, name: 'new name'}, function(err, instance) { if (err) return done(err); findTestModels({fields: ['id', 'name']}, function(err, list) { if (err) return done(err); (list || []).map(toObject).should.eql([ {id: existingInstance.id, name: existingInstance.name, extra: undefined}, {id: instance.id, name: 'new name', extra: undefined}, ]); done(); }); }); }); it('applies updates from `access` hook when not found', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: 'not-found'}}; next(); }); TestModel.replaceOrCreate( {id: existingInstance.id, name: 'new name'}, function(err, instance) { if (err) return done(err); findTestModels({fields: ['id', 'name']}, function(err, list) { if (err) return done(err); (list || []).map(toObject).should.eql([ {id: existingInstance.id, name: existingInstance.name, extra: undefined}, {id: list[1].id, name: 'second', extra: undefined}, {id: instance.id, name: 'new name', extra: undefined}, ]); done(); }); }); }); it('triggers hooks only once', function(done) { monitorHookExecution(['access', 'before save']); TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); TestModel.replaceOrCreate( {id: 'ignored', name: 'new name'}, function(err, instance) { if (err) return done(err); hookMonitor.names.should.eql(['access', 'before save']); done(); }); }); it('triggers `before save` hookon create', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate({id: existingInstance.id, name: 'new name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { instance: instance, }); if (!dataSource.connector.replaceOrCreate) { expectedContext.isNewInstance = false; } done(); }); }); it('triggers `before save` hook on replace', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: existingInstance.id, name: 'replaced name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { instance: { id: existingInstance.id, name: 'replaced name', extra: undefined, }, }); if (!dataSource.connector.replaceOrCreate) { expectedContext.isNewInstance = false; } ctxRecorder.records.should.eql(expectedContext); done(); }); }); it('triggers `before save` hook on create', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { instance: { id: 'new-id', name: 'a name', extra: undefined, }, }); if (!dataSource.connector.replaceOrCreate) { expectedContext.isNewInstance = true; } ctxRecorder.records.should.eql(expectedContext); done(); }); }); it('applies updates from `before save` hook on create', function(done) { TestModel.observe('before save', function(ctx, next) { ctx.instance.name = 'hooked'; next(); }); TestModel.replaceOrCreate( {id: 'new-id', name: 'new name'}, function(err, instance) { if (err) return done(err); instance.name.should.equal('hooked'); done(); }); }); it('validates model after `before save` hook on create', function(done) { TestModel.observe('before save', invalidateTestModel()); TestModel.replaceOrCreate( {id: 'new-id', name: 'new name'}, function(err, instance) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); it('triggers `persist` hook on create', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { currentInstance: { id: 'new-id', name: 'a name', extra: undefined, }, data: { id: 'new-id', name: 'a name', }, }); if (dataSource.connector.replaceOrCreate) { expectedContext.where = {id: 'new-id'}; } else { // non-atomic implementation does not provide ctx.where // because a new instance is being created, so there // are not records to match where filter. expectedContext.isNewInstance = true; } ctxRecorder.records.should.eql(expectedContext); done(); }); }); it('triggers `persist` hook on replace', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: existingInstance.id, name: 'replaced name'}, function(err, instance) { if (err) return done(err); var expected = { where: {id: existingInstance.id}, data: { id: existingInstance.id, name: 'replaced name', }, currentInstance: { id: existingInstance.id, name: 'replaced name', extra: undefined, }, }; var expectedContext = aCtxForModel(TestModel, expected); var expectedContext; if (!dataSource.connector.replaceOrCreate) { expectedContext.isNewInstance = false; } ctxRecorder.records.should.eql(expectedContext); done(); }); }); it('triggers `loaded` hook on create', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); var expected = { data: { id: 'new-id', name: 'a name', }, }; expected.isNewInstance = connectorCapabilities.replaceOrCreateReportsNewInstance ? true : undefined; ctxRecorder.records.should.eql(aCtxForModel(TestModel, expected)); done(); }); }); it('triggers `loaded` hook on replace', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: existingInstance.id, name: 'replaced name'}, function(err, instance) { if (err) return done(err); var expected = { data: { id: existingInstance.id, name: 'replaced name', }, }; expected.isNewInstance = connectorCapabilities.replaceOrCreateReportsNewInstance ? false : undefined; ctxRecorder.records.should.eql(aCtxForModel(TestModel, expected)); done(); }); }); it('emits error when `loaded` hook fails', function(done) { TestModel.observe('loaded', nextWithError(expectedError)); TestModel.replaceOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('triggers `after save` hook on replace', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: existingInstance.id, name: 'replaced name'}, function(err, instance) { if (err) return done(err); var expected = { instance: { id: existingInstance.id, name: 'replaced name', extra: undefined, }, }; expected.isNewInstance = connectorCapabilities.replaceOrCreateReportsNewInstance ? false : undefined; ctxRecorder.records.should.eql(aCtxForModel(TestModel, expected)); done(); }); }); it('triggers `after save` hook on create', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.replaceOrCreate( {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); var expected = { instance: { id: instance.id, name: 'a name', extra: undefined, }, }; expected.isNewInstance = connectorCapabilities.replaceOrCreateReportsNewInstance ? true : undefined; ctxRecorder.records.should.eql(aCtxForModel(TestModel, expected)); done(); }); }); }); } describe('PersistedModel.deleteAll', function() { it('triggers `access` hook with query', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.deleteAll({name: existingInstance.name}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { query: {where: {name: existingInstance.name}}, })); done(); }); }); it('triggers `access` hook without query', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.deleteAll(function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: {where: {}}})); done(); }); }); it('applies updates from `access` hook', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); TestModel.deleteAll(function(err) { if (err) return done(err); findTestModels(function(err, list) { if (err) return done(err); (list || []).map(get('id')).should.eql([existingInstance.id]); done(); }); }); }); it('triggers `before delete` hook with query', function(done) { TestModel.observe('before delete', ctxRecorder.recordAndNext()); TestModel.deleteAll({name: existingInstance.name}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {name: existingInstance.name}, })); done(); }); }); it('triggers `before delete` hook without query', function(done) { TestModel.observe('before delete', ctxRecorder.recordAndNext()); TestModel.deleteAll(function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {where: {}})); done(); }); }); it('applies updates from `before delete` hook', function(done) { TestModel.observe('before delete', function(ctx, next) { ctx.where = {id: {neq: existingInstance.id}}; next(); }); TestModel.deleteAll(function(err) { if (err) return done(err); findTestModels(function(err, list) { if (err) return done(err); (list || []).map(get('id')).should.eql([existingInstance.id]); done(); }); }); }); it('aborts when `before delete` hook fails', function(done) { TestModel.observe('before delete', nextWithError(expectedError)); TestModel.deleteAll(function(err, list) { [err].should.eql([expectedError]); TestModel.findById(existingInstance.id, function(err, inst) { if (err) return done(err); (inst ? inst.toObject() : 'null').should. eql(existingInstance.toObject()); done(); }); }); }); it('triggers `after delete` hook without query', function(done) { TestModel.observe('after delete', ctxRecorder.recordAndNext()); TestModel.deleteAll(function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {where: {}})); done(); }); }); it('triggers `after delete` hook without query', function(done) { TestModel.observe('after delete', ctxRecorder.recordAndNext()); TestModel.deleteAll({name: existingInstance.name}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {name: existingInstance.name}, })); done(); }); }); it('aborts when `after delete` hook fails', function(done) { TestModel.observe('after delete', nextWithError(expectedError)); TestModel.deleteAll(function(err) { [err].should.eql([expectedError]); done(); }); }); }); describe('PersistedModel.prototype.delete', function() { it('triggers `access` hook', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); existingInstance.delete(function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { query: {where: {id: existingInstance.id}}, })); done(); }); }); it('applies updated from `access` hook', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); existingInstance.delete(function(err) { if (err) return done(err); findTestModels(function(err, list) { if (err) return done(err); (list || []).map(get('id')).should.eql([existingInstance.id]); done(); }); }); }); it('triggers `before delete` hook', function(done) { TestModel.observe('before delete', ctxRecorder.recordAndNext()); existingInstance.delete(function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: existingInstance.id}, instance: existingInstance, })); done(); }); }); it('applies updated from `before delete` hook', function(done) { TestModel.observe('before delete', function(ctx, next) { ctx.where = {id: {neq: existingInstance.id}}; next(); }); existingInstance.delete(function(err) { if (err) return done(err); findTestModels(function(err, list) { if (err) return done(err); (list || []).map(get('id')).should.eql([existingInstance.id]); done(); }); }); }); it('aborts when `before delete` hook fails', function(done) { TestModel.observe('before delete', nextWithError(expectedError)); existingInstance.delete(function(err, list) { [err].should.eql([expectedError]); TestModel.findById(existingInstance.id, function(err, inst) { if (err) return done(err); (inst ? inst.toObject() : 'null').should.eql( existingInstance.toObject()); done(); }); }); }); it('triggers `after delete` hook', function(done) { TestModel.observe('after delete', ctxRecorder.recordAndNext()); existingInstance.delete(function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: existingInstance.id}, instance: existingInstance, })); done(); }); }); it('triggers `after delete` hook without query', function(done) { TestModel.observe('after delete', ctxRecorder.recordAndNext()); TestModel.deleteAll({name: existingInstance.name}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {name: existingInstance.name}, })); done(); }); }); it('aborts when `after delete` hook fails', function(done) { TestModel.observe('after delete', nextWithError(expectedError)); TestModel.deleteAll(function(err) { [err].should.eql([expectedError]); done(); }); }); it('propagates hookState from `before delete` to `after delete`', function(done) { TestModel.observe('before delete', ctxRecorder.recordAndNext(function(ctx) { ctx.hookState.foo = 'bar'; })); TestModel.observe('after delete', ctxRecorder.recordAndNext(function(ctx) { ctx.hookState.foo = ctx.hookState.foo.toUpperCase(); })); existingInstance.delete(function(err) { if (err) return done(err); ctxRecorder.records.should.eql([ aCtxForModel(TestModel, { hookState: {foo: 'bar'}, where: {id: '1'}, instance: existingInstance, }), aCtxForModel(TestModel, { hookState: {foo: 'BAR'}, where: {id: '1'}, instance: existingInstance, }), ]); done(); }); }); it('triggers hooks only once', function(done) { monitorHookExecution(); TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); existingInstance.delete(function(err) { if (err) return done(err); hookMonitor.names.should.eql(['access', 'before delete', 'after delete']); done(); }); }); }); describe('PersistedModel.updateAll', function() { it('triggers `access` hook', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.updateAll( {name: 'searched'}, {name: 'updated'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: { where: {name: 'searched'}, }})); done(); }); }); it('applies updates from `access` hook', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); TestModel.updateAll( {id: existingInstance.id}, {name: 'new name'}, function(err) { if (err) return done(err); findTestModels({fields: ['id', 'name']}, function(err, list) { if (err) return done(err); (list || []).map(toObject).should.eql([ {id: existingInstance.id, name: existingInstance.name, extra: undefined}, {id: '2', name: 'new name', extra: undefined}, ]); done(); }); }); }); it('triggers `before save` hook', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.updateAll( {name: 'searched'}, {name: 'updated'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {name: 'searched'}, data: {name: 'updated'}, })); done(); }); }); it('applies updates from `before save` hook', function(done) { TestModel.observe('before save', function(ctx, next) { ctx.data = {name: 'hooked', extra: 'added'}; next(); }); TestModel.updateAll( {id: existingInstance.id}, {name: 'updated name'}, function(err) { if (err) return done(err); loadTestModel(existingInstance.id, function(err, instance) { if (err) return done(err); instance.should.have.property('name', 'hooked'); instance.should.have.property('extra', 'added'); done(); }); }); }); it('triggers `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.updateAll( {name: existingInstance.name}, {name: 'changed'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: {name: 'changed'}, where: {name: existingInstance.name}, })); done(); }); }); it('applies updates from `persist` hook', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) { ctx.data.extra = 'hook data'; })); TestModel.updateAll( {id: existingInstance.id}, {name: 'changed'}, function(err) { if (err) return done(err); loadTestModel(existingInstance.id, function(err, instance) { instance.should.have.property('extra', 'hook data'); done(); }); }); }); it('does not trigger `loaded`', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); TestModel.updateAll( {id: existingInstance.id}, {name: 'changed'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql('hook not called'); done(); }); }); it('triggers `after save` hook', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.updateAll( {id: existingInstance.id}, {name: 'updated name'}, function(err) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { where: {id: existingInstance.id}, data: {name: 'updated name'}, })); done(); }); }); it('accepts hookState from options', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.updateAll( {id: existingInstance.id}, {name: 'updated name'}, {foo: 'bar'}, function(err) { if (err) return done(err); ctxRecorder.records.options.should.eql({ foo: 'bar', }); done(); }); }); }); describe('PersistedModel.upsertWithWhere', function() { it('triggers hooks in the correct order on create', function(done) { monitorHookExecution(); TestModel.upsertWithWhere({extra: 'not-found'}, {id: 'not-found', name: 'not found', extra: 'not-found'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'access', 'before save', 'persist', 'loaded', 'after save', ]); TestModel.findById('not-found', function(err, data) { if (err) return done(err); data.name.should.equal('not found'); data.extra.should.equal('not-found'); done(); }); }); }); it('triggers hooks in the correct order on update', function(done) { monitorHookExecution(); TestModel.upsertWithWhere({id: existingInstance.id}, {name: 'new name', extra: 'new extra'}, function(err, record, created) { if (err) return done(err); hookMonitor.names.should.eql([ 'access', 'before save', 'persist', 'loaded', 'after save', ]); TestModel.findById(existingInstance.id, function(err, data) { if (err) return done(err); data.name.should.equal('new name'); data.extra.should.equal('new extra'); done(); }); }); }); it('triggers `access` hook on create', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({extra: 'not-found'}, {id: 'not-found', name: 'not found'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: { where: {extra: 'not-found'}, }})); done(); }); }); it('triggers `access` hook on update', function(done) { TestModel.observe('access', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({id: existingInstance.id}, {name: 'new name', extra: 'new extra'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: { where: {id: existingInstance.id}, }})); done(); }); }); it('triggers hooks only once', function(done) { monitorHookExecution(['access', 'before save']); TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); TestModel.upsertWithWhere({id: existingInstance.id}, {name: 'new name'}, function(err, instance) { if (err) return done(err); hookMonitor.names.should.eql(['access', 'before save']); done(); }); }); it('applies updates from `access` hook when found', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: {neq: existingInstance.id}}}; next(); }); TestModel.upsertWithWhere({id: existingInstance.id}, {name: 'new name'}, function(err, instance) { if (err) return done(err); findTestModels({fields: ['id', 'name']}, function(err, list) { if (err) return done(err); (list || []).map(toObject).should.eql([ {id: existingInstance.id, name: existingInstance.name, extra: undefined}, {id: instance.id, name: 'new name', extra: undefined}, ]); done(); }); }); }); it('applies updates from `access` hook when not found', function(done) { TestModel.observe('access', function(ctx, next) { ctx.query = {where: {id: 'not-found'}}; next(); }); TestModel.upsertWithWhere({id: existingInstance.id}, {name: 'new name'}, function(err, instance) { if (err) return done(err); findTestModels({fields: ['id', 'name']}, function(err, list) { if (err) return done(err); (list || []).map(toObject).should.eql([ {id: existingInstance.id, name: existingInstance.name, extra: undefined}, {id: list[1].id, name: 'second', extra: undefined}, {id: instance.id, name: 'new name', extra: undefined}, ]); done(); }); }); }); it('triggers `before save` hook on update', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({id: existingInstance.id}, {id: existingInstance.id, name: 'updated name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { where: {id: existingInstance.id}, data: { id: existingInstance.id, name: 'updated name', }, }); if (!dataSource.connector.upsertWithWhere) { // the difference between `existingInstance` and the following // plain-data object is `currentInstance` the missing fields are // null in `currentInstance`, wehere as in `existingInstance` they // are undefined; please see other tests for example see: // test for "PersistedModel.create triggers `persist` hook" expectedContext.currentInstance = {id: existingInstance.id, name: 'first', extra: null}; } ctxRecorder.records.should.eql(expectedContext); done(); }); }); it('triggers `before save` hook on create', function(done) { TestModel.observe('before save', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({id: 'new-id'}, {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { }); if (dataSource.connector.upsertWithWhere) { expectedContext.data = {id: 'new-id', name: 'a name'}; expectedContext.where = {id: 'new-id'}; } else { expectedContext.instance = {id: 'new-id', name: 'a name', extra: null}; expectedContext.isNewInstance = true; } ctxRecorder.records.should.eql(expectedContext); done(); }); }); it('applies updates from `before save` hook on update', function(done) { TestModel.observe('before save', function(ctx, next) { ctx.data.name = 'hooked'; next(); }); TestModel.upsertWithWhere({id: existingInstance.id}, {name: 'updated name'}, function(err, instance) { if (err) return done(err); instance.name.should.equal('hooked'); done(); }); }); it('applies updates from `before save` hook on create', function(done) { TestModel.observe('before save', function(ctx, next) { if (ctx.instance) { ctx.instance.name = 'hooked'; } else { ctx.data.name = 'hooked'; } next(); }); TestModel.upsertWithWhere({id: 'new-id'}, {id: 'new-id', name: 'new name'}, function(err, instance) { if (err) return done(err); instance.name.should.equal('hooked'); done(); }); }); it('validates model after `before save` hook on create', function(done) { TestModel.observe('before save', invalidateTestModel()); TestModel.upsertWithWhere({id: 'new-id'}, {id: 'new-id', name: 'new name'}, function(err, instance) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); it('validates model after `before save` hook on update', function(done) { TestModel.observe('before save', invalidateTestModel()); TestModel.upsertWithWhere({id: existingInstance.id}, {id: existingInstance.id, name: 'updated name'}, function(err, instance) { (err || {}).should.be.instanceOf(ValidationError); (err.details.codes || {}).should.eql({name: ['presence']}); done(); }); }); it('triggers `persist` hook on create', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({id: 'new-id'}, {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { data: {id: 'new-id', name: 'a name'}, currentInstance: { id: 'new-id', name: 'a name', extra: undefined, }, }); if (dataSource.connector.upsertWithWhere) { expectedContext.where = {id: 'new-id'}; } else { expectedContext.isNewInstance = true; } ctxRecorder.records.should.eql(expectedContext); done(); }); }); it('triggers persist hook on update', function(done) { TestModel.observe('persist', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({id: existingInstance.id}, {id: existingInstance.id, name: 'updated name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { where: {id: existingInstance.id}, data: { id: existingInstance.id, name: 'updated name', }, currentInstance: { id: existingInstance.id, name: 'updated name', extra: undefined, }, }); if (!dataSource.connector.upsertWithWhere) { expectedContext.isNewInstance = false; } ctxRecorder.records.should.eql(expectedContext); done(); }); }); it('triggers `loaded` hook on create', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({id: 'new-id'}, {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { data: {id: 'new-id', name: 'a name'}, isNewInstance: true, })); done(); }); }); it('triggers `loaded` hook on update', function(done) { TestModel.observe('loaded', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({id: existingInstance.id}, {id: existingInstance.id, name: 'updated name'}, function(err, instance) { if (err) return done(err); var expectedContext = aCtxForModel(TestModel, { data: { id: existingInstance.id, name: 'updated name', }, isNewInstance: false, }); ctxRecorder.records.should.eql(aCtxForModel(TestModel, expectedContext)); done(); }); }); it('emits error when `loaded` hook fails', function(done) { TestModel.observe('loaded', nextWithError(expectedError)); TestModel.upsertWithWhere({id: 'new-id'}, {id: 'new-id', name: 'a name'}, function(err, instance) { [err].should.eql([expectedError]); done(); }); }); it('triggers `after save` hook on update', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({id: existingInstance.id}, {id: existingInstance.id, name: 'updated name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: existingInstance.id, name: 'updated name', extra: undefined, }, isNewInstance: false, })); done(); }); }); it('triggers `after save` hook on create', function(done) { TestModel.observe('after save', ctxRecorder.recordAndNext()); TestModel.upsertWithWhere({id: 'new-id'}, {id: 'new-id', name: 'a name'}, function(err, instance) { if (err) return done(err); ctxRecorder.records.should.eql(aCtxForModel(TestModel, { instance: { id: instance.id, name: 'a name', extra: undefined, }, isNewInstance: true, })); done(); }); }); }); function nextWithError(err) { return function(context, next) { next(err); }; } function invalidateTestModel() { return function(context, next) { if (context.instance) { context.instance.name = ''; } else { context.data.name = ''; } next(); }; } function findTestModels(query, cb) { if (cb === undefined && typeof query === 'function') { cb = query; query = null; } TestModel.find(query, {notify: false}, cb); } function loadTestModel(id, cb) { TestModel.findOne({where: {id: id}}, {notify: false}, cb); } function monitorHookExecution(hookNames) { hookMonitor.install(TestModel, hookNames); } require('./operation-hooks.suite')(dataSource, should, connectorCapabilities); }); function get(propertyName) { return function(obj) { return obj[propertyName]; }; } function toObject(obj) { return obj.toObject ? obj.toObject() : obj; } };