loopback-datasource-juggler-regevbr
Version:
LoopBack DataSoure Juggler
1,458 lines (1,250 loc) • 115 kB
JavaScript
// 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
'use strict';
var ValidationError = require('../').ValidationError;
var contextTestHelpers = require('./helpers/context-test-helpers');
var ContextRecorder = contextTestHelpers.ContextRecorder;
var deepCloneToObject = contextTestHelpers.deepCloneToObject;
var aCtxForModel = contextTestHelpers.aCtxForModel;
var uid = require('./helpers/uid-generator');
var getLastGeneratedUid = uid.last;
var HookMonitor = require('./helpers/hook-monitor');
module.exports = function(dataSource, should, connectorCapabilities) {
if (!connectorCapabilities) connectorCapabilities = {};
if (connectorCapabilities.replaceOrCreateReportsNewInstance === undefined) {
console.warn('The connector does not support a recently added feature: ' +
'replaceOrCreateReportsNewInstance');
}
describe('Persistence hooks', function() {
var ctxRecorder, hookMonitor, expectedError;
var TestModel, existingInstance;
var migrated = false;
var undefinedValue = undefined;
beforeEach(function setupDatabase(done) {
ctxRecorder = new ContextRecorder('hook not called');
hookMonitor = new HookMonitor({includeModelName: false});
expectedError = new Error('test error');
TestModel = dataSource.createModel('TestModel', {
// Set id.generated to false to honor client side values
id: {type: String, id: true, generated: false, default: uid.next},
name: {type: String, required: true},
extra: {type: String, required: false},
});
uid.reset();
if (migrated) {
TestModel.deleteAll(done);
} else {
dataSource.automigrate(TestModel.modelName, function(err) {
migrated = true;
done(err);
});
}
});
beforeEach(function createTestData(done) {
TestModel.create({name: 'first'}, function(err, instance) {
if (err) return done(err);
// Look it up from DB so that default values are retrieved
TestModel.findById(instance.id, function(err, instance) {
existingInstance = instance;
undefinedValue = existingInstance.extra;
TestModel.create({name: 'second'}, function(err) {
if (err) return done(err);
done();
});
});
});
});
describe('PersistedModel.find', function() {
it('triggers hooks in the correct order', function(done) {
monitorHookExecution();
TestModel.find(
{where: {id: '1'}},
function(err, list) {
if (err) return done(err);
hookMonitor.names.should.eql([
'access',
'loaded',
]);
done();
});
});
it('triggers correct hooks when near filter is used', function(done) {
monitorHookExecution();
var query = {where:
{location: {near: '10,20', maxDistance: '10', unit: 'meters'}},
};
TestModel.find(query, function(err, list) {
if (err) return done(err);
hookMonitor.names.should.eql(['access']);
done();
});
});
it('should not trigger hooks, if notify is false', function(done) {
monitorHookExecution();
TestModel.find(
{where: {id: '1'}},
{notify: false},
function(err, list) {
if (err) return done(err);
hookMonitor.names.should.be.empty();
done();
});
});
it('should not trigger hooks for geo queries, if notify is false',
function(done) {
monitorHookExecution();
TestModel.find(
{where: {geo: [{near: '10,20'}]}},
{notify: false},
function(err, list) {
if (err) return done(err);
hookMonitor.names.should.be.empty();
done();
});
});
it('should apply updates from `access` hook', function(done) {
TestModel.observe('access', function(ctx, next) {
ctx.query = {where: {name: 'second'}};
next();
});
TestModel.find({name: 'first'}, function(err, list) {
if (err) return done(err);
list.map(get('name')).should.eql(['second']);
done();
});
});
it('triggers `access` hook', function(done) {
TestModel.observe('access', ctxRecorder.recordAndNext());
TestModel.find({where: {id: '1'}}, function(err, list) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
query: {where: {id: '1'}},
}));
done();
});
});
it('aborts when `access` hook fails', function(done) {
TestModel.observe('access', nextWithError(expectedError));
TestModel.find(function(err, list) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `access` hook', function(done) {
TestModel.observe('access', function(ctx, next) {
ctx.query = {where: {id: existingInstance.id}};
next();
});
TestModel.find(function(err, list) {
if (err) return done(err);
list.map(get('name')).should.eql([existingInstance.name]);
done();
});
});
it('triggers `access` hook for geo queries', function(done) {
TestModel.observe('access', ctxRecorder.recordAndNext());
TestModel.find({where: {geo: [{near: '10,20'}]}}, function(err, list) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
query: {where: {geo: [{near: '10,20'}]}},
}));
done();
});
});
it('applies updates from `access` hook for geo queries', function(done) {
TestModel.observe('access', function(ctx, next) {
ctx.query = {where: {id: existingInstance.id}};
next();
});
TestModel.find({where: {geo: {near: '10,20'}}}, function(err, list) {
if (err) return done(err);
list.map(get('name')).should.eql([existingInstance.name]);
done();
});
});
it('applies updates from `loaded` hook', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) {
ctx.instance.extra = 'hook data';
}));
TestModel.find(
{where: {id: 1}},
function(err, list) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {
id: '1',
name: 'first',
extra: 'hook data',
},
isNewInstance: false,
options: {},
}));
done();
});
});
it('emits error when `loaded` hook fails', function(done) {
TestModel.observe('loaded', nextWithError(expectedError));
TestModel.find(
{where: {id: 1}},
function(err, list) {
[err].should.eql([expectedError]);
done();
});
});
});
describe('PersistedModel.create', function() {
it('triggers hooks in the correct order', function(done) {
monitorHookExecution();
TestModel.create(
{name: 'created'},
function(err, record, created) {
if (err) return done(err);
hookMonitor.names.should.eql([
'before save',
'persist',
'loaded',
'after save',
]);
done();
});
});
it('triggers `before save` hook', function(done) {
TestModel.observe('before save', ctxRecorder.recordAndNext());
TestModel.create({name: 'created'}, function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {
id: instance.id,
name: 'created',
extra: undefined,
},
isNewInstance: true,
}));
done();
});
});
it('aborts when `before save` hook fails', function(done) {
TestModel.observe('before save', nextWithError(expectedError));
TestModel.create({name: 'created'}, function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `before save` hook', function(done) {
TestModel.observe('before save', function(ctx, next) {
ctx.instance.should.be.instanceOf(TestModel);
ctx.instance.extra = 'hook data';
next();
});
TestModel.create({id: uid.next(), name: 'a-name'}, function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
it('sends `before save` for each model in an array', function(done) {
TestModel.observe('before save', ctxRecorder.recordAndNext());
TestModel.create(
[{name: '1'}, {name: '2'}],
function(err, list) {
if (err) return done(err);
// Creation of multiple instances is executed in parallel
ctxRecorder.records.sort(function(c1, c2) {
return c1.instance.name - c2.instance.name;
});
ctxRecorder.records.should.eql([
aCtxForModel(TestModel, {
instance: {id: list[0].id, name: '1', extra: undefined},
isNewInstance: true,
}),
aCtxForModel(TestModel, {
instance: {id: list[1].id, name: '2', extra: undefined},
isNewInstance: true,
}),
]);
done();
});
});
it('validates model after `before save` hook', function(done) {
TestModel.observe('before save', invalidateTestModel());
TestModel.create({name: 'created'}, function(err) {
(err || {}).should.be.instanceOf(ValidationError);
(err.details.codes || {}).should.eql({name: ['presence']});
done();
});
});
it('triggers `persist` hook', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext());
TestModel.create(
{id: 'new-id', name: 'a name'},
function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {id: 'new-id', name: 'a name'},
isNewInstance: true,
currentInstance: {extra: null, id: 'new-id', name: 'a name'},
}));
done();
});
});
it('applies updates from `persist` hook', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
// By default, the instance passed to create callback is NOT updated
// with the changes made through persist/loaded hooks. To preserve
// backwards compatibility, we introduced a new setting updateOnLoad,
// which if set, will apply these changes to the model instance too.
TestModel.settings.updateOnLoad = true;
TestModel.create(
{id: 'new-id', name: 'a name'},
function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
// Also query the database here to verify that, on `create`
// updates from `persist` hook are reflected into database
TestModel.findById('new-id', function(err, dbInstance) {
if (err) return done(err);
should.exists(dbInstance);
dbInstance.toObject(true).should.eql({
id: 'new-id',
name: 'a name',
extra: 'hook data',
});
done();
});
});
});
it('triggers `loaded` hook', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext());
// By default, the instance passed to create callback is NOT updated
// with the changes made through persist/loaded hooks. To preserve
// backwards compatibility, we introduced a new setting updateOnLoad,
// which if set, will apply these changes to the model instance too.
TestModel.settings.updateOnLoad = true;
TestModel.create(
{id: 'new-id', name: 'a name'},
function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {id: 'new-id', name: 'a name'},
isNewInstance: true,
}));
done();
});
});
it('emits error when `loaded` hook fails', function(done) {
TestModel.observe('loaded', nextWithError(expectedError));
TestModel.create(
{id: 'new-id', name: 'a name'},
function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `loaded` hook', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
// By default, the instance passed to create callback is NOT updated
// with the changes made through persist/loaded hooks. To preserve
// backwards compatibility, we introduced a new setting updateOnLoad,
// which if set, will apply these changes to the model instance too.
TestModel.settings.updateOnLoad = true;
TestModel.create(
{id: 'new-id', name: 'a name'},
function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
it('triggers `after save` hook', function(done) {
TestModel.observe('after save', ctxRecorder.recordAndNext());
TestModel.create({name: 'created'}, function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {
id: instance.id,
name: 'created',
extra: undefined,
},
isNewInstance: true,
}));
done();
});
});
it('aborts when `after save` hook fails', function(done) {
TestModel.observe('after save', nextWithError(expectedError));
TestModel.create({name: 'created'}, function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `after save` hook', function(done) {
TestModel.observe('after save', function(ctx, next) {
ctx.instance.should.be.instanceOf(TestModel);
ctx.instance.extra = 'hook data';
next();
});
TestModel.create({name: 'a-name'}, function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
it('sends `after save` for each model in an array', function(done) {
TestModel.observe('after save', ctxRecorder.recordAndNext());
TestModel.create(
[{name: '1'}, {name: '2'}],
function(err, list) {
if (err) return done(err);
// Creation of multiple instances is executed in parallel
ctxRecorder.records.sort(function(c1, c2) {
return c1.instance.name - c2.instance.name;
});
ctxRecorder.records.should.eql([
aCtxForModel(TestModel, {
instance: {id: list[0].id, name: '1', extra: undefined},
isNewInstance: true,
}),
aCtxForModel(TestModel, {
instance: {id: list[1].id, name: '2', extra: undefined},
isNewInstance: true,
}),
]);
done();
});
});
it('emits `after save` when some models were not saved', function(done) {
TestModel.observe('before save', function(ctx, next) {
if (ctx.instance.name === 'fail')
next(expectedError);
else
next();
});
TestModel.observe('after save', ctxRecorder.recordAndNext());
TestModel.create(
[{name: 'ok'}, {name: 'fail'}],
function(err, list) {
(err || []).should.have.length(2);
err[1].should.eql(expectedError);
// NOTE(bajtos) The current implementation of `Model.create(array)`
// passes all models in the second callback argument, including
// the models that were not created due to an error.
list.map(get('name')).should.eql(['ok', 'fail']);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {id: list[0].id, name: 'ok', extra: undefined},
isNewInstance: true,
}));
done();
});
});
});
describe('PersistedModel.findOrCreate', function() {
it('triggers `access` hook', function(done) {
TestModel.observe('access', ctxRecorder.recordAndNext());
TestModel.findOrCreate(
{where: {name: 'new-record'}},
{name: 'new-record'},
function(err, record, created) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: {
where: {name: 'new-record'},
limit: 1,
offset: 0,
skip: 0,
}}));
done();
});
});
if (dataSource.connector.findOrCreate) {
it('triggers `before save` hook when found', function(done) {
TestModel.observe('before save', ctxRecorder.recordAndNext());
TestModel.findOrCreate(
{where: {name: existingInstance.name}},
{name: existingInstance.name},
function(err, record, created) {
if (err) return done(err);
record.id.should.eql(existingInstance.id);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {
id: getLastGeneratedUid(),
name: existingInstance.name,
extra: undefined,
},
isNewInstance: true,
}));
done();
});
});
}
it('triggers `before save` hook when not found', function(done) {
TestModel.observe('before save', ctxRecorder.recordAndNext());
TestModel.findOrCreate(
{where: {name: 'new-record'}},
{name: 'new-record'},
function(err, record, created) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {
id: record.id,
name: 'new-record',
extra: undefined,
},
isNewInstance: true,
}));
done();
});
});
it('validates model after `before save` hook', function(done) {
TestModel.observe('before save', invalidateTestModel());
TestModel.findOrCreate(
{where: {name: 'new-record'}},
{name: 'new-record'},
function(err) {
(err || {}).should.be.instanceOf(ValidationError);
(err.details.codes || {}).should.eql({name: ['presence']});
done();
});
});
it('triggers hooks in the correct order when not found', function(done) {
monitorHookExecution();
TestModel.findOrCreate(
{where: {name: 'new-record'}},
{name: 'new-record'},
function(err, record, created) {
if (err) return done(err);
hookMonitor.names.should.eql([
'access',
'before save',
'persist',
'loaded',
'after save',
]);
done();
});
});
it('triggers hooks in the correct order when found', function(done) {
monitorHookExecution();
TestModel.findOrCreate(
{where: {name: existingInstance.name}},
{name: existingInstance.name},
function(err, record, created) {
if (err) return done(err);
if (dataSource.connector.findOrCreate) {
hookMonitor.names.should.eql([
'access',
'before save',
'persist',
'loaded',
]);
} else {
hookMonitor.names.should.eql([
'access',
'loaded',
]);
}
done();
});
});
it('aborts when `access` hook fails', function(done) {
TestModel.observe('access', nextWithError(expectedError));
TestModel.findOrCreate(
{where: {id: 'does-not-exist'}},
{name: 'does-not-exist'},
function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
it('aborts when `before save` hook fails', function(done) {
TestModel.observe('before save', nextWithError(expectedError));
TestModel.findOrCreate(
{where: {id: 'does-not-exist'}},
{name: 'does-not-exist'},
function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
if (dataSource.connector.findOrCreate) {
it('triggers `persist` hook when found', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext());
TestModel.findOrCreate(
{where: {name: existingInstance.name}},
{name: existingInstance.name},
function(err, record, created) {
if (err) return done(err);
record.id.should.eql(existingInstance.id);
// `findOrCreate` creates a new instance of the object everytime.
// So, `data.id` as well as `currentInstance.id` always matches
// the newly generated UID.
// Hence, the test below asserts both `data.id` and
// `currentInstance.id` to match getLastGeneratedUid().
// On same lines, it also asserts `isNewInstance` to be true.
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {
id: getLastGeneratedUid(),
name: existingInstance.name,
},
isNewInstance: true,
currentInstance: {
id: getLastGeneratedUid(),
name: record.name,
extra: null,
},
where: {name: existingInstance.name},
}));
done();
});
});
}
it('triggers `persist` hook when not found', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext());
TestModel.findOrCreate(
{where: {name: 'new-record'}},
{name: 'new-record'},
function(err, record, created) {
if (err) return done(err);
// `context.where` is present in Optimized connector context,
// but, unoptimized connector does NOT have it.
if (dataSource.connector.findOrCreate) {
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {
id: record.id,
name: 'new-record',
},
isNewInstance: true,
currentInstance: {
id: record.id,
name: record.name,
extra: null,
},
where: {name: 'new-record'},
}));
} else {
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {
id: record.id,
name: 'new-record',
},
isNewInstance: true,
currentInstance: {id: record.id, name: record.name, extra: null},
}));
}
done();
});
});
if (dataSource.connector.findOrCreate) {
it('applies updates from `persist` hook when found', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
TestModel.findOrCreate(
{where: {name: existingInstance.name}},
{name: existingInstance.name},
function(err, instance) {
if (err) return done(err);
// instance returned by `findOrCreate` context does not
// have the values updated from `persist` hook
instance.should.not.have.property('extra', 'hook data');
// Query the database. Here, since record already exists
// `findOrCreate`, does not update database for
// updates from `persist` hook
TestModel.findById(existingInstance.id, function(err, dbInstance) {
if (err) return done(err);
should.exists(dbInstance);
dbInstance.toObject(true).should.eql({
id: existingInstance.id,
name: existingInstance.name,
extra: undefined,
});
});
done();
});
});
}
it('applies updates from `persist` hook when not found', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
TestModel.findOrCreate(
{where: {name: 'new-record'}},
{name: 'new-record'},
function(err, instance) {
if (err) return done(err);
if (dataSource.connector.findOrCreate) {
instance.should.have.property('extra', 'hook data');
} else {
// Unoptimized connector gives a call to `create. And during
// create the updates applied through persist hook are
// reflected into the database, but the same updates are
// NOT reflected in the instance object obtained in callback
// of create.
// So, this test asserts unoptimized connector to
// NOT have `extra` property. And then verifes that the
// property `extra` is actually updated in DB
instance.should.not.have.property('extra', 'hook data');
TestModel.findById(instance.id, function(err, dbInstance) {
if (err) return done(err);
should.exists(dbInstance);
dbInstance.toObject(true).should.eql({
id: instance.id,
name: instance.name,
extra: 'hook data',
});
});
}
done();
});
});
if (dataSource.connector.findOrCreate) {
it('triggers `loaded` hook when found', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext());
TestModel.findOrCreate(
{where: {name: existingInstance.name}},
{name: existingInstance.name},
function(err, record, created) {
if (err) return done(err);
record.id.should.eql(existingInstance.id);
// After the call to `connector.findOrCreate`, since the record
// already exists, `data.id` matches `existingInstance.id`
// as against the behaviour noted for `persist` hook
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {
id: existingInstance.id,
name: existingInstance.name,
},
isNewInstance: false,
}));
done();
});
});
}
it('triggers `loaded` hook when not found', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext());
TestModel.findOrCreate(
{where: {name: 'new-record'}},
{name: 'new-record'},
function(err, record, created) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {
id: record.id,
name: 'new-record',
},
isNewInstance: true,
}));
done();
});
});
it('emits error when `loaded` hook fails', function(done) {
TestModel.observe('loaded', nextWithError(expectedError));
TestModel.findOrCreate(
{where: {name: 'new-record'}},
{name: 'new-record'},
function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
if (dataSource.connector.findOrCreate) {
it('applies updates from `loaded` hook when found', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
TestModel.findOrCreate(
{where: {name: existingInstance.name}},
{name: existingInstance.name},
function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
}
it('applies updates from `loaded` hook when not found', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
// Unoptimized connector gives a call to `create. But,
// by default, the instance passed to create callback is NOT updated
// with the changes made through persist/loaded hooks. To preserve
// backwards compatibility, we introduced a new setting updateOnLoad,
// which if set, will apply these changes to the model instance too.
// Note - in case of findOrCreate, this setting is needed ONLY for
// unoptimized connector.
TestModel.settings.updateOnLoad = true;
TestModel.findOrCreate(
{where: {name: 'new-record'}},
{name: 'new-record'},
function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
it('triggers `after save` hook when not found', function(done) {
TestModel.observe('after save', ctxRecorder.recordAndNext());
TestModel.findOrCreate(
{where: {name: 'new name'}},
{name: 'new name'},
function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {
id: instance.id,
name: 'new name',
extra: undefined,
},
isNewInstance: true,
}));
done();
});
});
it('does not trigger `after save` hook when found', function(done) {
TestModel.observe('after save', ctxRecorder.recordAndNext());
TestModel.findOrCreate(
{where: {id: existingInstance.id}},
{name: existingInstance.name},
function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql('hook not called');
done();
});
});
});
describe('PersistedModel.count', function(done) {
it('triggers `access` hook', function(done) {
TestModel.observe('access', ctxRecorder.recordAndNext());
TestModel.count({id: existingInstance.id}, function(err, count) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {query: {
where: {id: existingInstance.id},
}}));
done();
});
});
it('applies updates from `access` hook', function(done) {
TestModel.observe('access', function(ctx, next) {
ctx.query.where = {id: existingInstance.id};
next();
});
TestModel.count(function(err, count) {
if (err) return done(err);
count.should.equal(1);
done();
});
});
});
describe('PersistedModel.prototype.save', function() {
it('triggers hooks in the correct order', function(done) {
monitorHookExecution();
existingInstance.save(
function(err, record, created) {
if (err) return done(err);
hookMonitor.names.should.eql([
'before save',
'persist',
'loaded',
'after save',
]);
done();
});
});
it('triggers `before save` hook', function(done) {
TestModel.observe('before save', ctxRecorder.recordAndNext());
existingInstance.name = 'changed';
existingInstance.save(function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {instance: {
id: existingInstance.id,
name: 'changed',
extra: undefined,
}, options: {throws: false, validate: true}}));
done();
});
});
it('aborts when `before save` hook fails', function(done) {
TestModel.observe('before save', nextWithError(expectedError));
existingInstance.save(function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `before save` hook', function(done) {
TestModel.observe('before save', function(ctx, next) {
ctx.instance.should.be.instanceOf(TestModel);
ctx.instance.extra = 'hook data';
next();
});
existingInstance.save(function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
it('validates model after `before save` hook', function(done) {
TestModel.observe('before save', invalidateTestModel());
existingInstance.save(function(err) {
(err || {}).should.be.instanceOf(ValidationError);
(err.details.codes || {}).should.eql({name: ['presence']});
done();
});
});
it('triggers `persist` hook', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext());
existingInstance.name = 'changed';
existingInstance.save(function(err, instance) {
if (err) return done(err);
// HACK: extra is undefined for NoSQL and null for SQL
delete ctxRecorder.records.data.extra;
delete ctxRecorder.records.currentInstance.extra;
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {
id: existingInstance.id,
name: 'changed',
},
currentInstance: {
id: existingInstance.id,
name: 'changed',
},
where: {id: existingInstance.id},
options: {throws: false, validate: true},
}));
done();
});
});
it('applies updates from `persist` hook', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
existingInstance.save(function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
it('triggers `loaded` hook', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext());
existingInstance.extra = 'changed';
existingInstance.save(function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {
id: existingInstance.id,
name: existingInstance.name,
extra: 'changed',
},
isNewInstance: false,
options: {throws: false, validate: true},
}));
done();
});
});
it('emits error when `loaded` hook fails', function(done) {
TestModel.observe('loaded', nextWithError(expectedError));
existingInstance.save(
function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `loaded` hook', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
existingInstance.save(function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
it('triggers `after save` hook on update', function(done) {
TestModel.observe('after save', ctxRecorder.recordAndNext());
existingInstance.name = 'changed';
existingInstance.save(function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {
id: existingInstance.id,
name: 'changed',
extra: undefined,
},
isNewInstance: false,
options: {throws: false, validate: true},
}));
done();
});
});
it('triggers `after save` hook on create', function(done) {
TestModel.observe('after save', ctxRecorder.recordAndNext());
// The rationale behind passing { persisted: true } is to bypass the check
// made by DAO to determine whether the instance should be saved via
// PersistedModel.create and force it to call connector.save()
var instance = new TestModel(
{id: 'new-id', name: 'created'},
{persisted: true});
instance.save(function(err, instance) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {
id: instance.id,
name: 'created',
extra: undefined,
},
isNewInstance: true,
options: {throws: false, validate: true},
}));
done();
});
});
it('aborts when `after save` hook fails', function(done) {
TestModel.observe('after save', nextWithError(expectedError));
existingInstance.save(function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `after save` hook', function(done) {
TestModel.observe('after save', function(ctx, next) {
ctx.instance.should.be.instanceOf(TestModel);
ctx.instance.extra = 'hook data';
next();
});
existingInstance.save(function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
});
describe('PersistedModel.prototype.updateAttributes', function() {
it('triggers hooks in the correct order', function(done) {
monitorHookExecution();
existingInstance.updateAttributes(
{name: 'changed'},
function(err, record, created) {
if (err) return done(err);
hookMonitor.names.should.eql([
'before save',
'persist',
'loaded',
'after save',
]);
done();
});
});
it('triggers `before save` hook', function(done) {
TestModel.observe('before save', ctxRecorder.recordAndNext());
var currentInstance = deepCloneToObject(existingInstance);
existingInstance.updateAttributes({name: 'changed'}, function(err) {
if (err) return done(err);
existingInstance.name.should.equal('changed');
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
where: {id: existingInstance.id},
data: {name: 'changed'},
currentInstance: currentInstance,
}));
done();
});
});
it('aborts when `before save` hook fails', function(done) {
TestModel.observe('before save', nextWithError(expectedError));
existingInstance.updateAttributes({name: 'updated'}, function(err) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `before save` hook', function(done) {
TestModel.observe('before save', function(ctx, next) {
ctx.data.extra = 'extra data';
ctx.data.name = 'hooked name';
next();
});
existingInstance.updateAttributes({name: 'updated'}, function(err) {
if (err) return done(err);
// We must query the database here because `updateAttributes`
// returns effectively `this`, not the data from the datasource
TestModel.findById(existingInstance.id, function(err, instance) {
if (err) return done(err);
should.exists(instance);
instance.toObject(true).should.eql({
id: existingInstance.id,
name: 'hooked name',
extra: 'extra data',
});
done();
});
});
});
it('validates model after `before save` hook', function(done) {
TestModel.observe('before save', invalidateTestModel());
existingInstance.updateAttributes({name: 'updated'}, function(err) {
(err || {}).should.be.instanceOf(ValidationError);
(err.details.codes || {}).should.eql({name: ['presence']});
done();
});
});
it('triggers `persist` hook', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext());
existingInstance.updateAttributes({name: 'changed'}, function(err) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
where: {id: existingInstance.id},
data: {name: 'changed'},
currentInstance: {
id: existingInstance.id,
name: 'changed',
extra: null,
},
isNewInstance: false,
}));
done();
});
});
it('applies updates from `persist` hook', function(done) {
TestModel.observe('persist', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
// By default, the instance passed to updateAttributes callback is NOT updated
// with the changes made through persist/loaded hooks. To preserve
// backwards compatibility, we introduced a new setting updateOnLoad,
// which if set, will apply these changes to the model instance too.
TestModel.settings.updateOnLoad = true;
existingInstance.updateAttributes({name: 'changed'}, function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
it('applies updates from `persist` hook - for nested model instance', function(done) {
var Address = dataSource.createModel('NestedAddress', {
id: {type: String, id: true, default: 1},
city: {type: String, required: true},
country: {type: String, required: true},
});
var User = dataSource.createModel('UserWithAddress', {
id: {type: String, id: true, default: uid.next},
name: {type: String, required: true},
address: {type: Address, required: false},
extra: {type: String},
});
dataSource.automigrate(['UserWithAddress', 'NestedAddress'], function(err) {
if (err) return done(err);
User.create({name: 'Joe'}, function(err, instance) {
if (err) return done(err);
var existingUser = instance;
User.observe('persist', ctxRecorder.recordAndNext(function(ctx) {
should.exist(ctx.data.address);
ctx.data.address.should.be.type('object');
ctx.data.address.should.not.be.instanceOf(Address);
ctx.data.extra = 'hook data';
}));
// By default, the instance passed to updateAttributes callback is NOT updated
// with the changes made through persist/loaded hooks. To preserve
// backwards compatibility, we introduced a new setting updateOnLoad,
// which if set, will apply these changes to the model instance too.
User.settings.updateOnLoad = true;
existingUser.updateAttributes(
{address: new Address({city: 'Springfield', country: 'USA'})},
function(err, inst) {
if (err) return done(err);
inst.should.have.property('extra', 'hook data');
User.findById(existingUser.id, function(err, dbInstance) {
if (err) return done(err);
dbInstance.toObject(true).should.eql({
id: existingUser.id,
name: existingUser.name,
address: {id: '1', city: 'Springfield', country: 'USA'},
extra: 'hook data',
});
done();
});
});
});
});
});
it('triggers `loaded` hook', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext());
existingInstance.updateAttributes({name: 'changed'}, function(err) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
data: {name: 'changed'},
isNewInstance: false,
}));
done();
});
});
it('emits error when `loaded` hook fails', function(done) {
TestModel.observe('loaded', nextWithError(expectedError));
existingInstance.updateAttributes(
{name: 'changed'},
function(err, instance) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `loaded` hook updateAttributes', function(done) {
TestModel.observe('loaded', ctxRecorder.recordAndNext(function(ctx) {
ctx.data.extra = 'hook data';
}));
// By default, the instance passed to updateAttributes callback is NOT updated
// with the changes made through persist/loaded hooks. To preserve
// backwards compatibility, we introduced a new setting updateOnLoad,
// which if set, will apply these changes to the model instance too.
TestModel.settings.updateOnLoad = true;
existingInstance.updateAttributes({name: 'changed'}, function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
it('triggers `after save` hook', function(done) {
TestModel.observe('after save', ctxRecorder.recordAndNext());
existingInstance.name = 'changed';
existingInstance.updateAttributes({name: 'changed'}, function(err) {
if (err) return done(err);
ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
instance: {
id: existingInstance.id,
name: 'changed',
extra: undefined,
},
isNewInstance: false,
}));
done();
});
});
it('aborts when `after save` hook fails', function(done) {
TestModel.observe('after save', nextWithError(expectedError));
existingInstance.updateAttributes({name: 'updated'}, function(err) {
[err].should.eql([expectedError]);
done();
});
});
it('applies updates from `after save` hook', function(done) {
TestModel.observe('after save', function(ctx, next) {
ctx.instance.should.be.instanceOf(TestModel);
ctx.instance.extra = 'hook data';
next();
});
existingInstance.updateAttributes({name: 'updated'}, function(err, instance) {
if (err) return done(err);
instance.should.have.property('extra', 'hook data');
done();
});
});
});
if (!dataSource.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, cre