loopback-datasource-juggler/test/persistence-hooks.suite.js

// 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('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.data.extra = 'hook data';
        }));

        TestModel.find(
          { where: { id: 1 }},
          function(err, list) {
            if (err) return done(err);

            ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
              data: {
                id: '1',
                name: 'first',
                extra: 'hook data',
              },
              isNewInstance: false,
              options: {},
            }));

            list[0].should.have.property('extra', 'hook data');
            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());

        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' },
          }));

          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);

            if (dataSource.connector.updateOrCreate) {
              ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                data: { id: 'new-id', name: 'a name' },
                isNewInstance: true,
              }));
            } else {
              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);

            if (dataSource.connector.updateOrCreate) {
              ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                data: {
                  id: existingInstance.id,
                  name: 'updated name',
                },
                isNewInstance: false,
              }));
            } else {
              ctxRecorder.records.should.eql(
                aCtxForModel(TestModel, {
                  data: {
                    id: existingInstance.id,
                    name: 'updated name',
                  },
                })
              );
            }
            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();
          });
      });

    });

    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;
  }
};