1823 lines
52 KiB
JavaScript
1823 lines
52 KiB
JavaScript
// Copyright IBM Corp. 2013,2018. All Rights Reserved.
|
|
// Node module: loopback
|
|
// This file is licensed under the MIT License.
|
|
// License text available at https://opensource.org/licenses/MIT
|
|
|
|
'use strict';
|
|
const loopback = require('../');
|
|
const lt = require('./helpers/loopback-testing-helper');
|
|
const path = require('path');
|
|
const SIMPLE_APP = path.join(__dirname, 'fixtures', 'simple-integration-app');
|
|
const app = require(path.join(SIMPLE_APP, 'server/server.js'));
|
|
const assert = require('assert');
|
|
const expect = require('./helpers/expect');
|
|
const debug = require('debug')('loopback:test:relations.integration');
|
|
const async = require('async');
|
|
|
|
describe('relations - integration', function() {
|
|
lt.beforeEach.withApp(app);
|
|
|
|
lt.beforeEach.givenModel('store');
|
|
beforeEach(function(done) {
|
|
this.widgetName = 'foo';
|
|
this.store.widgets.create({
|
|
name: this.widgetName,
|
|
}, function() {
|
|
done();
|
|
});
|
|
});
|
|
afterEach(function(done) {
|
|
this.app.models.widget.destroyAll(done);
|
|
});
|
|
|
|
describe('polymorphicHasMany', function() {
|
|
before(function defineProductAndCategoryModels() {
|
|
const Team = app.registry.createModel('Team', {name: 'string'});
|
|
const Reader = app.registry.createModel('Reader', {name: 'string'});
|
|
const Picture = app.registry.createModel('Picture',
|
|
{name: 'string', imageableId: 'number', imageableType: 'string'});
|
|
|
|
app.model(Team, {dataSource: 'db'});
|
|
app.model(Reader, {dataSource: 'db'});
|
|
app.model(Picture, {dataSource: 'db'});
|
|
|
|
Reader.hasMany(Picture, {polymorphic: { // alternative syntax
|
|
as: 'imageable', // if not set, default to: reference
|
|
foreignKey: 'imageableId', // defaults to 'as + Id'
|
|
discriminator: 'imageableType', // defaults to 'as + Type'
|
|
}});
|
|
|
|
Picture.belongsTo('imageable', {polymorphic: {
|
|
foreignKey: 'imageableId',
|
|
discriminator: 'imageableType',
|
|
}});
|
|
|
|
Reader.belongsTo(Team);
|
|
});
|
|
|
|
before(function createEvent(done) {
|
|
const test = this;
|
|
app.models.Team.create({name: 'Team 1'},
|
|
function(err, team) {
|
|
if (err) return done(err);
|
|
|
|
test.team = team;
|
|
app.models.Reader.create({name: 'Reader 1'},
|
|
function(err, reader) {
|
|
if (err) return done(err);
|
|
|
|
test.reader = reader;
|
|
reader.pictures.create({name: 'Picture 1'});
|
|
reader.pictures.create({name: 'Picture 2'});
|
|
reader.team(test.team);
|
|
reader.save(done);
|
|
});
|
|
});
|
|
});
|
|
|
|
after(function(done) {
|
|
this.app.models.Reader.destroyAll(done);
|
|
});
|
|
|
|
it('includes the related child model', function(done) {
|
|
const url = '/api/readers/' + this.reader.id;
|
|
this.get(url)
|
|
.query({'filter': {'include': 'pictures'}})
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.name).to.be.equal('Reader 1');
|
|
expect(res.body.pictures).to.be.eql([
|
|
{name: 'Picture 1', id: 1, imageableId: 1, imageableType: 'Reader'},
|
|
{name: 'Picture 2', id: 2, imageableId: 1, imageableType: 'Reader'},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('includes the related parent model', function(done) {
|
|
const url = '/api/pictures';
|
|
this.get(url)
|
|
.query({'filter': {'include': 'imageable'}})
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body[0].name).to.be.equal('Picture 1');
|
|
expect(res.body[1].name).to.be.equal('Picture 2');
|
|
expect(res.body[0].imageable).to.be.eql({name: 'Reader 1', id: 1, teamId: 1});
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('includes related models scoped to the related parent model', function(done) {
|
|
const url = '/api/pictures';
|
|
this.get(url)
|
|
.query({'filter': {'include': {
|
|
'relation': 'imageable',
|
|
'scope': {'include': 'team'},
|
|
}}})
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body[0].name).to.be.equal('Picture 1');
|
|
expect(res.body[1].name).to.be.equal('Picture 2');
|
|
expect(res.body[0].imageable.name).to.be.eql('Reader 1');
|
|
expect(res.body[0].imageable.team).to.be.eql({name: 'Team 1', id: 1});
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('/store/superStores', function() {
|
|
it('should invoke scoped methods remotely', function(done) {
|
|
this.get('/api/stores/superStores')
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.an('array');
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('/store/:id/widgets', function() {
|
|
beforeEach(function() {
|
|
this.url = '/api/stores/' + this.store.id + '/widgets';
|
|
});
|
|
lt.describe.whenCalledRemotely('GET', '/api/stores/:id/widgets', function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
});
|
|
describe('widgets (response.body)', function() {
|
|
beforeEach(function() {
|
|
debug('GET /api/stores/:id/widgets response: %s' +
|
|
'\nheaders: %j\nbody string: %s',
|
|
this.res.statusCode,
|
|
this.res.headers,
|
|
this.res.text);
|
|
this.widgets = this.res.body;
|
|
this.widget = this.res.body && this.res.body[0];
|
|
});
|
|
it('should be an array', function() {
|
|
assert(Array.isArray(this.widgets));
|
|
});
|
|
it('should include a single widget', function() {
|
|
assert(this.widgets.length === 1);
|
|
assert(this.widget);
|
|
});
|
|
it('should be a valid widget', function() {
|
|
assert(this.widget.id);
|
|
assert.equal(this.widget.storeId, this.store.id);
|
|
assert.equal(this.widget.name, this.widgetName);
|
|
});
|
|
});
|
|
});
|
|
describe('POST /api/store/:id/widgets', function() {
|
|
beforeEach(function() {
|
|
this.newWidgetName = 'baz';
|
|
this.newWidget = {
|
|
name: this.newWidgetName,
|
|
};
|
|
});
|
|
beforeEach(function(done) {
|
|
this.http = this.post(this.url, this.newWidget);
|
|
this.http.send(this.newWidget);
|
|
this.http.end(function(err) {
|
|
if (err) return done(err);
|
|
|
|
this.req = this.http.req;
|
|
this.res = this.http.response;
|
|
|
|
done();
|
|
}.bind(this));
|
|
});
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
});
|
|
describe('widget (response.body)', function() {
|
|
beforeEach(function() {
|
|
this.widget = this.res.body;
|
|
});
|
|
it('should be an object', function() {
|
|
assert(typeof this.widget === 'object');
|
|
assert(!Array.isArray(this.widget));
|
|
});
|
|
it('should be a valid widget', function() {
|
|
assert(this.widget.id);
|
|
assert.equal(this.widget.storeId, this.store.id);
|
|
assert.equal(this.widget.name, this.newWidgetName);
|
|
});
|
|
});
|
|
it('should have a single widget with storeId', function(done) {
|
|
this.app.models.widget.count({
|
|
storeId: this.store.id,
|
|
}, function(err, count) {
|
|
if (err) return done(err);
|
|
|
|
assert.equal(count, 2);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('PUT /api/store/:id/widgets/:fk', function() {
|
|
beforeEach(function(done) {
|
|
const self = this;
|
|
this.store.widgets.create({
|
|
name: this.widgetName,
|
|
}, function(err, widget) {
|
|
self.widget = widget;
|
|
self.url = '/api/stores/' + self.store.id + '/widgets/' + widget.id;
|
|
done();
|
|
});
|
|
});
|
|
it('does not add default properties to request body', function(done) {
|
|
const self = this;
|
|
self.request.put(self.url)
|
|
.send({active: true})
|
|
.end(function(err) {
|
|
if (err) return done(err);
|
|
app.models.Widget.findById(self.widget.id, function(err, w) {
|
|
if (err) return done(err);
|
|
expect(w.name).to.equal(self.widgetName);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('/stores/:id/widgets/:fk - 200', function() {
|
|
beforeEach(function(done) {
|
|
const self = this;
|
|
this.store.widgets.create({
|
|
name: this.widgetName,
|
|
}, function(err, widget) {
|
|
self.widget = widget;
|
|
self.url = '/api/stores/' + self.store.id + '/widgets/' + widget.id;
|
|
|
|
done();
|
|
});
|
|
});
|
|
lt.describe.whenCalledRemotely('GET', '/stores/:id/widgets/:fk', function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
assert.equal(this.res.body.id, this.widget.id);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('/stores/:id/widgets/:fk - 404', function() {
|
|
beforeEach(function() {
|
|
this.url = '/api/stores/' + this.store.id + '/widgets/123456';
|
|
});
|
|
lt.describe.whenCalledRemotely('GET', '/stores/:id/widgets/:fk', function() {
|
|
it('should fail with statusCode 404', function() {
|
|
assert.equal(this.res.statusCode, 404);
|
|
assert.equal(this.res.body.error.statusCode, 404);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('/store/:id/widgets/count', function() {
|
|
beforeEach(function() {
|
|
this.url = '/api/stores/' + this.store.id + '/widgets/count';
|
|
});
|
|
lt.describe.whenCalledRemotely('GET', '/api/stores/:id/widgets/count', function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
});
|
|
it('should return the count', function() {
|
|
assert.equal(this.res.body.count, 1);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('/store/:id/widgets/count - filtered (matches)', function() {
|
|
beforeEach(function() {
|
|
this.url = '/api/stores/' + this.store.id + '/widgets/count?where[name]=foo';
|
|
});
|
|
lt.describe.whenCalledRemotely('GET', '/api/stores/:id/widgets/count?where[name]=foo', function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
});
|
|
it('should return the count', function() {
|
|
assert.equal(this.res.body.count, 1);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('/store/:id/widgets/count - filtered (no matches)', function() {
|
|
beforeEach(function() {
|
|
this.url = '/api/stores/' + this.store.id + '/widgets/count?where[name]=bar';
|
|
});
|
|
lt.describe.whenCalledRemotely('GET', '/api/stores/:id/widgets/count?where[name]=bar', function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
});
|
|
it('should return the count', function() {
|
|
assert.equal(this.res.body.count, 0);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('/widgets/:id/store', function() {
|
|
beforeEach(function(done) {
|
|
const self = this;
|
|
this.store.widgets.create({
|
|
name: this.widgetName,
|
|
}, function(err, widget) {
|
|
self.widget = widget;
|
|
self.url = '/api/widgets/' + self.widget.id + '/store';
|
|
|
|
done();
|
|
});
|
|
});
|
|
lt.describe.whenCalledRemotely('GET', '/api/widgets/:id/store', function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
assert.equal(this.res.body.id, this.store.id);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('hasMany through', function() {
|
|
function setup(connecting, cb) {
|
|
const root = {};
|
|
|
|
async.series([
|
|
// Clean up models
|
|
function(done) {
|
|
app.models.physician.destroyAll(function(err) {
|
|
app.models.patient.destroyAll(function(err) {
|
|
app.models.appointment.destroyAll(function(err) {
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
},
|
|
|
|
// Create a physician
|
|
function(done) {
|
|
app.models.physician.create({
|
|
name: 'ph1',
|
|
}, function(err, physician) {
|
|
root.physician = physician;
|
|
|
|
done();
|
|
});
|
|
},
|
|
|
|
// Create a patient
|
|
connecting ? function(done) {
|
|
root.physician.patients.create({
|
|
name: 'pa1',
|
|
}, function(err, patient) {
|
|
root.patient = patient;
|
|
root.relUrl = '/api/physicians/' + root.physician.id +
|
|
'/patients/rel/' + root.patient.id;
|
|
|
|
done();
|
|
});
|
|
} : function(done) {
|
|
app.models.patient.create({
|
|
name: 'pa1',
|
|
}, function(err, patient) {
|
|
root.patient = patient;
|
|
root.relUrl = '/api/physicians/' + root.physician.id +
|
|
'/patients/rel/' + root.patient.id;
|
|
|
|
done();
|
|
});
|
|
}], function(err, done) {
|
|
cb(err, root);
|
|
});
|
|
}
|
|
|
|
describe('PUT /physicians/:id/patients/rel/:fk', function() {
|
|
before(function(done) {
|
|
const self = this;
|
|
setup(false, function(err, root) {
|
|
self.url = root.relUrl;
|
|
self.patient = root.patient;
|
|
self.physician = root.physician;
|
|
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
lt.describe.whenCalledRemotely('PUT', '/api/physicians/:id/patients/rel/:fk', function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
assert.equal(this.res.body.patientId, this.patient.id);
|
|
assert.equal(this.res.body.physicianId, this.physician.id);
|
|
});
|
|
|
|
it('should create a record in appointment', function(done) {
|
|
const self = this;
|
|
app.models.appointment.find(function(err, apps) {
|
|
assert.equal(apps.length, 1);
|
|
assert.equal(apps[0].patientId, self.patient.id);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should connect physician to patient', function(done) {
|
|
const self = this;
|
|
self.physician.patients(function(err, patients) {
|
|
assert.equal(patients.length, 1);
|
|
assert.equal(patients[0].id, self.patient.id);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('PUT /physicians/:id/patients/rel/:fk with data', function() {
|
|
before(function(done) {
|
|
const self = this;
|
|
setup(false, function(err, root) {
|
|
self.url = root.relUrl;
|
|
self.patient = root.patient;
|
|
self.physician = root.physician;
|
|
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
const NOW = Date.now();
|
|
const data = {date: new Date(NOW)};
|
|
|
|
lt.describe.whenCalledRemotely('PUT', '/api/physicians/:id/patients/rel/:fk', data, function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
assert.equal(this.res.body.patientId, this.patient.id);
|
|
assert.equal(this.res.body.physicianId, this.physician.id);
|
|
assert.equal(new Date(this.res.body.date).getTime(), NOW);
|
|
});
|
|
|
|
it('should create a record in appointment', function(done) {
|
|
const self = this;
|
|
app.models.appointment.find(function(err, apps) {
|
|
assert.equal(apps.length, 1);
|
|
assert.equal(apps[0].patientId, self.patient.id);
|
|
assert.equal(apps[0].physicianId, self.physician.id);
|
|
assert.equal(apps[0].date.getTime(), NOW);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should connect physician to patient', function(done) {
|
|
const self = this;
|
|
self.physician.patients(function(err, patients) {
|
|
assert.equal(patients.length, 1);
|
|
assert.equal(patients[0].id, self.patient.id);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('HEAD /physicians/:id/patients/rel/:fk', function() {
|
|
before(function(done) {
|
|
const self = this;
|
|
setup(true, function(err, root) {
|
|
self.url = root.relUrl;
|
|
self.patient = root.patient;
|
|
self.physician = root.physician;
|
|
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
lt.describe.whenCalledRemotely('HEAD', '/api/physicians/:id/patients/rel/:fk', function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('HEAD /physicians/:id/patients/rel/:fk that does not exist', function() {
|
|
before(function(done) {
|
|
const self = this;
|
|
setup(true, function(err, root) {
|
|
self.url = '/api/physicians/' + root.physician.id +
|
|
'/patients/rel/' + '999';
|
|
self.patient = root.patient;
|
|
self.physician = root.physician;
|
|
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
lt.describe.whenCalledRemotely('HEAD', '/api/physicians/:id/patients/rel/:fk', function() {
|
|
it('should succeed with statusCode 404', function() {
|
|
assert.equal(this.res.statusCode, 404);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('DELETE /physicians/:id/patients/rel/:fk', function() {
|
|
before(function(done) {
|
|
const self = this;
|
|
setup(true, function(err, root) {
|
|
self.url = root.relUrl;
|
|
self.patient = root.patient;
|
|
self.physician = root.physician;
|
|
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
it('should create a record in appointment', function(done) {
|
|
const self = this;
|
|
app.models.appointment.find(function(err, apps) {
|
|
assert.equal(apps.length, 1);
|
|
assert.equal(apps[0].patientId, self.patient.id);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should connect physician to patient', function(done) {
|
|
const self = this;
|
|
self.physician.patients(function(err, patients) {
|
|
assert.equal(patients.length, 1);
|
|
assert.equal(patients[0].id, self.patient.id);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
lt.describe.whenCalledRemotely('DELETE', '/api/physicians/:id/patients/rel/:fk', function() {
|
|
it('should succeed with statusCode 204', function() {
|
|
assert.equal(this.res.statusCode, 204);
|
|
});
|
|
|
|
it('should remove the record in appointment', function(done) {
|
|
const self = this;
|
|
app.models.appointment.find(function(err, apps) {
|
|
assert.equal(apps.length, 0);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should remove the connection between physician and patient', function(done) {
|
|
const self = this;
|
|
// Need to refresh the cache
|
|
self.physician.patients(true, function(err, patients) {
|
|
assert.equal(patients.length, 0);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('GET /physicians/:id/patients/:fk', function() {
|
|
before(function(done) {
|
|
const self = this;
|
|
setup(true, function(err, root) {
|
|
self.url = '/api/physicians/' + root.physician.id +
|
|
'/patients/' + root.patient.id;
|
|
self.patient = root.patient;
|
|
self.physician = root.physician;
|
|
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
lt.describe.whenCalledRemotely('GET', '/api/physicians/:id/patients/:fk', function() {
|
|
it('should succeed with statusCode 200', function() {
|
|
assert.equal(this.res.statusCode, 200);
|
|
assert.equal(this.res.body.id, this.physician.id);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('DELETE /physicians/:id/patients/:fk', function() {
|
|
before(function(done) {
|
|
const self = this;
|
|
setup(true, function(err, root) {
|
|
self.url = '/api/physicians/' + root.physician.id +
|
|
'/patients/' + root.patient.id;
|
|
self.patient = root.patient;
|
|
self.physician = root.physician;
|
|
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
lt.describe.whenCalledRemotely('DELETE', '/api/physicians/:id/patients/:fk', function() {
|
|
it('should succeed with statusCode 204', function() {
|
|
assert.equal(this.res.statusCode, 204);
|
|
});
|
|
|
|
it('should remove the record in appointment', function(done) {
|
|
const self = this;
|
|
app.models.appointment.find(function(err, apps) {
|
|
assert.equal(apps.length, 0);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should remove the connection between physician and patient', function(done) {
|
|
const self = this;
|
|
// Need to refresh the cache
|
|
self.physician.patients(true, function(err, patients) {
|
|
assert.equal(patients.length, 0);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should remove the record in patient', function(done) {
|
|
const self = this;
|
|
app.models.patient.find(function(err, patients) {
|
|
assert.equal(patients.length, 0);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('hasAndBelongsToMany', function() {
|
|
beforeEach(function defineProductAndCategoryModels() {
|
|
// Disable "Warning: overriding remoting type product"
|
|
this.app.remotes()._typeRegistry._options.warnWhenOverridingType = false;
|
|
|
|
const product = app.registry.createModel(
|
|
'product',
|
|
{id: 'string', name: 'string'},
|
|
);
|
|
const category = app.registry.createModel(
|
|
'category',
|
|
{id: 'string', name: 'string'},
|
|
);
|
|
app.model(product, {dataSource: 'db'});
|
|
app.model(category, {dataSource: 'db'});
|
|
|
|
product.hasAndBelongsToMany(category);
|
|
category.hasAndBelongsToMany(product);
|
|
});
|
|
|
|
lt.beforeEach.givenModel('category');
|
|
|
|
beforeEach(function createProductsInCategory(done) {
|
|
const test = this;
|
|
this.category.products.create({
|
|
name: 'a-product',
|
|
}, function(err, product) {
|
|
if (err) return done(err);
|
|
|
|
test.product = product;
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
beforeEach(function createAnotherCategoryAndProduct(done) {
|
|
app.models.category.create({name: 'another-category'},
|
|
function(err, cat) {
|
|
if (err) return done(err);
|
|
|
|
cat.products.create({name: 'another-product'}, done);
|
|
});
|
|
});
|
|
|
|
afterEach(function(done) {
|
|
this.app.models.product.destroyAll(done);
|
|
});
|
|
|
|
it.skip('allows to find related objects via where filter', function(done) {
|
|
// TODO https://github.com/strongloop/loopback-datasource-juggler/issues/94
|
|
const expectedProduct = this.product;
|
|
this.get('/api/products?filter[where][categoryId]=' + this.category.id)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.eql([
|
|
{
|
|
id: expectedProduct.id,
|
|
name: expectedProduct.name,
|
|
},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('allows to find related object via URL scope', function(done) {
|
|
const expectedProduct = this.product;
|
|
this.get('/api/categories/' + this.category.id + '/products')
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.eql([
|
|
{
|
|
id: expectedProduct.id,
|
|
name: expectedProduct.name,
|
|
},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('includes requested related models in `find`', function(done) {
|
|
const expectedProduct = this.product;
|
|
const url = '/api/categories/findOne?filter[where][id]=' +
|
|
this.category.id + '&filter[include]=products';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.have.property('products');
|
|
expect(res.body.products).to.eql([
|
|
{
|
|
id: expectedProduct.id,
|
|
name: expectedProduct.name,
|
|
},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it.skip('includes requested related models in `findById`', function(done) {
|
|
// TODO https://github.com/strongloop/loopback-datasource-juggler/issues/93
|
|
const expectedProduct = this.product;
|
|
// Note: the URL format is not final
|
|
const url = '/api/categories/' + this.category.id + '?include=products';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.have.property('products');
|
|
expect(res.body.products).to.eql([
|
|
{
|
|
id: expectedProduct.id,
|
|
name: expectedProduct.name,
|
|
},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('embedsOne', function() {
|
|
before(function defineGroupAndPosterModels() {
|
|
const group = app.registry.createModel(
|
|
'group',
|
|
{name: 'string'},
|
|
{plural: 'groups'},
|
|
);
|
|
app.model(group, {dataSource: 'db'});
|
|
|
|
const poster = app.registry.createModel(
|
|
'poster',
|
|
{url: 'string'},
|
|
);
|
|
app.model(poster, {dataSource: 'db'});
|
|
|
|
group.embedsOne(poster, {as: 'cover'});
|
|
});
|
|
|
|
before(function createImage(done) {
|
|
const test = this;
|
|
app.models.group.create({name: 'Group 1'},
|
|
function(err, group) {
|
|
if (err) return done(err);
|
|
|
|
test.group = group;
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
after(function(done) {
|
|
this.app.models.group.destroyAll(done);
|
|
});
|
|
|
|
it('creates an embedded model', function(done) {
|
|
const url = '/api/groups/' + this.group.id + '/cover';
|
|
|
|
this.post(url)
|
|
.send({url: 'http://image.url'})
|
|
.expect(200, function(err, res) {
|
|
expect(res.body).to.be.eql(
|
|
{url: 'http://image.url'},
|
|
);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('includes the embedded models', function(done) {
|
|
const url = '/api/groups/' + this.group.id;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.name).to.be.equal('Group 1');
|
|
expect(res.body.poster).to.be.eql(
|
|
{url: 'http://image.url'},
|
|
);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns the embedded model', function(done) {
|
|
const url = '/api/groups/' + this.group.id + '/cover';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql(
|
|
{url: 'http://image.url'},
|
|
);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('updates an embedded model', function(done) {
|
|
const url = '/api/groups/' + this.group.id + '/cover';
|
|
|
|
this.put(url)
|
|
.send({url: 'http://changed.url'})
|
|
.expect(200, function(err, res) {
|
|
expect(res.body.url).to.be.equal('http://changed.url');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns the updated embedded model', function(done) {
|
|
const url = '/api/groups/' + this.group.id + '/cover';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql(
|
|
{url: 'http://changed.url'},
|
|
);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('deletes an embedded model', function(done) {
|
|
const url = '/api/groups/' + this.group.id + '/cover';
|
|
this.del(url).expect(204, done);
|
|
});
|
|
|
|
it('deleted the embedded model', function(done) {
|
|
const url = '/api/groups/' + this.group.id + '/cover';
|
|
this.get(url).expect(404, done);
|
|
});
|
|
});
|
|
|
|
describe('embedsMany', function() {
|
|
before(function defineProductAndCategoryModels() {
|
|
const todoList = app.registry.createModel(
|
|
'todoList',
|
|
{name: 'string'},
|
|
{plural: 'todo-lists'},
|
|
);
|
|
app.model(todoList, {dataSource: 'db'});
|
|
|
|
const todoItem = app.registry.createModel(
|
|
'todoItem',
|
|
{content: 'string'}, {forceId: false},
|
|
);
|
|
app.model(todoItem, {dataSource: 'db'});
|
|
|
|
todoList.embedsMany(todoItem, {as: 'items'});
|
|
});
|
|
|
|
before(function createTodoList(done) {
|
|
const test = this;
|
|
app.models.todoList.create({name: 'List A'},
|
|
function(err, list) {
|
|
if (err) return done(err);
|
|
|
|
test.todoList = list;
|
|
list.items.build({content: 'Todo 1'});
|
|
list.items.build({content: 'Todo 2'});
|
|
list.save(done);
|
|
});
|
|
});
|
|
|
|
after(function(done) {
|
|
this.app.models.todoList.destroyAll(done);
|
|
});
|
|
|
|
it('includes the embedded models', function(done) {
|
|
const url = '/api/todo-lists/' + this.todoList.id;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.name).to.be.equal('List A');
|
|
expect(res.body.todoItems).to.be.eql([
|
|
{content: 'Todo 1', id: 1},
|
|
{content: 'Todo 2', id: 2},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns the embedded models', function(done) {
|
|
const url = '/api/todo-lists/' + this.todoList.id + '/items';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{content: 'Todo 1', id: 1},
|
|
{content: 'Todo 2', id: 2},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('filters the embedded models', function(done) {
|
|
let url = '/api/todo-lists/' + this.todoList.id + '/items';
|
|
url += '?filter[where][id]=2';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{content: 'Todo 2', id: 2},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('creates embedded models', function(done) {
|
|
const url = '/api/todo-lists/' + this.todoList.id + '/items';
|
|
|
|
const expected = {content: 'Todo 3', id: 3};
|
|
|
|
this.post(url)
|
|
.send({content: 'Todo 3'})
|
|
.expect(200, function(err, res) {
|
|
expect(res.body).to.be.eql(expected);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('includes the created embedded model', function(done) {
|
|
const url = '/api/todo-lists/' + this.todoList.id + '/items';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{content: 'Todo 1', id: 1},
|
|
{content: 'Todo 2', id: 2},
|
|
{content: 'Todo 3', id: 3},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns an embedded model by (internal) id', function(done) {
|
|
const url = '/api/todo-lists/' + this.todoList.id + '/items/3';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql(
|
|
{content: 'Todo 3', id: 3},
|
|
);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('removes an embedded model', function(done) {
|
|
const expectedProduct = this.product;
|
|
const url = '/api/todo-lists/' + this.todoList.id + '/items/2';
|
|
|
|
this.del(url)
|
|
.expect(200, function(err, res) {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns the embedded models - verify', function(done) {
|
|
const url = '/api/todo-lists/' + this.todoList.id + '/items';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{content: 'Todo 1', id: 1},
|
|
{content: 'Todo 3', id: 3},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns a 404 response when embedded model is not found', function(done) {
|
|
const url = '/api/todo-lists/' + this.todoList.id + '/items/2';
|
|
this.get(url).expect(404, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.error.status).to.be.equal(404);
|
|
expect(res.body.error.message).to.be.equal('Unknown "todoItem" id "2".');
|
|
expect(res.body.error.code).to.be.equal('MODEL_NOT_FOUND');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it.skip('checks if an embedded model exists - ok', function(done) {
|
|
const url = '/api/todo-lists/' + this.todoList.id + '/items/3';
|
|
|
|
this.head(url)
|
|
.expect(200, function(err, res) {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it.skip('checks if an embedded model exists - fail', function(done) {
|
|
const url = '/api/todo-lists/' + this.todoList.id + '/items/2';
|
|
|
|
this.head(url)
|
|
.expect(404, function(err, res) {
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('referencesMany', function() {
|
|
before(function defineProductAndCategoryModels() {
|
|
const recipe = app.registry.createModel(
|
|
'recipe',
|
|
{name: 'string'},
|
|
);
|
|
app.model(recipe, {dataSource: 'db'});
|
|
|
|
const ingredient = app.registry.createModel(
|
|
'ingredient',
|
|
{name: 'string'},
|
|
);
|
|
app.model(ingredient, {dataSource: 'db'});
|
|
|
|
const photo = app.registry.createModel(
|
|
'photo',
|
|
{name: 'string'},
|
|
);
|
|
app.model(photo, {dataSource: 'db'});
|
|
|
|
recipe.referencesMany(ingredient);
|
|
// contrived example for test:
|
|
recipe.hasOne(photo, {as: 'picture', options: {
|
|
http: {path: 'image'},
|
|
}});
|
|
});
|
|
|
|
before(function createRecipe(done) {
|
|
const test = this;
|
|
app.models.recipe.create({name: 'Recipe'},
|
|
function(err, recipe) {
|
|
if (err) return done(err);
|
|
|
|
test.recipe = recipe;
|
|
recipe.ingredients.create({
|
|
name: 'Chocolate'},
|
|
function(err, ing) {
|
|
test.ingredient1 = ing.id;
|
|
recipe.picture.create({name: 'Photo 1'}, done);
|
|
});
|
|
});
|
|
});
|
|
|
|
before(function createIngredient(done) {
|
|
const test = this;
|
|
app.models.ingredient.create({name: 'Sugar'}, function(err, ing) {
|
|
test.ingredient2 = ing.id;
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
after(function(done) {
|
|
const app = this.app;
|
|
app.models.recipe.destroyAll(function() {
|
|
app.models.ingredient.destroyAll(function() {
|
|
app.models.photo.destroyAll(done);
|
|
});
|
|
});
|
|
});
|
|
|
|
it('keeps an array of ids', function(done) {
|
|
const url = '/api/recipes/' + this.recipe.id;
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.ingredientIds).to.eql([test.ingredient1]);
|
|
expect(res.body).to.not.have.property('ingredients');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('creates referenced models', function(done) {
|
|
const url = '/api/recipes/' + this.recipe.id + '/ingredients';
|
|
const test = this;
|
|
|
|
this.post(url)
|
|
.send({name: 'Butter'})
|
|
.expect(200, function(err, res) {
|
|
expect(res.body.name).to.be.eql('Butter');
|
|
test.ingredient3 = res.body.id;
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('has created models', function(done) {
|
|
const url = '/api/ingredients';
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{name: 'Chocolate', id: test.ingredient1},
|
|
{name: 'Sugar', id: test.ingredient2},
|
|
{name: 'Butter', id: test.ingredient3},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns the referenced models', function(done) {
|
|
const url = '/api/recipes/' + this.recipe.id + '/ingredients';
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{name: 'Chocolate', id: test.ingredient1},
|
|
{name: 'Butter', id: test.ingredient3},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('filters the referenced models', function(done) {
|
|
let url = '/api/recipes/' + this.recipe.id + '/ingredients';
|
|
url += '?filter[where][name]=Butter';
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{name: 'Butter', id: test.ingredient3},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('includes the referenced models', function(done) {
|
|
let url = '/api/recipes/findOne?filter[where][id]=' + this.recipe.id;
|
|
url += '&filter[include]=ingredients';
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.ingredientIds).to.eql([
|
|
test.ingredient1, test.ingredient3,
|
|
]);
|
|
expect(res.body.ingredients).to.eql([
|
|
{name: 'Chocolate', id: test.ingredient1},
|
|
{name: 'Butter', id: test.ingredient3},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns a referenced model by id', function(done) {
|
|
let url = '/api/recipes/' + this.recipe.id + '/ingredients/';
|
|
url += this.ingredient3;
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql(
|
|
{name: 'Butter', id: test.ingredient3},
|
|
);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('keeps an array of ids - verify', function(done) {
|
|
const url = '/api/recipes/' + this.recipe.id;
|
|
const test = this;
|
|
|
|
const expected = [test.ingredient1, test.ingredient3];
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.ingredientIds).to.eql(expected);
|
|
expect(res.body).to.not.have.property('ingredients');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('destroys a referenced model', function(done) {
|
|
const expectedProduct = this.product;
|
|
let url = '/api/recipes/' + this.recipe.id + '/ingredients/';
|
|
url += this.ingredient3;
|
|
|
|
this.del(url)
|
|
.expect(200, function(err, res) {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('has destroyed a referenced model', function(done) {
|
|
const url = '/api/ingredients';
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{name: 'Chocolate', id: test.ingredient1},
|
|
{name: 'Sugar', id: test.ingredient2},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns the referenced models without the deleted one', function(done) {
|
|
const url = '/api/recipes/' + this.recipe.id + '/ingredients';
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{name: 'Chocolate', id: test.ingredient1},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('creates/links a reference by id', function(done) {
|
|
let url = '/api/recipes/' + this.recipe.id + '/ingredients';
|
|
url += '/rel/' + this.ingredient2;
|
|
const test = this;
|
|
|
|
this.put(url)
|
|
.expect(200, function(err, res) {
|
|
expect(res.body).to.be.eql(
|
|
{name: 'Sugar', id: test.ingredient2},
|
|
);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns the referenced models - verify', function(done) {
|
|
const url = '/api/recipes/' + this.recipe.id + '/ingredients';
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{name: 'Chocolate', id: test.ingredient1},
|
|
{name: 'Sugar', id: test.ingredient2},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('removes/unlinks a reference by id', function(done) {
|
|
let url = '/api/recipes/' + this.recipe.id + '/ingredients';
|
|
url += '/rel/' + this.ingredient1;
|
|
const test = this;
|
|
|
|
this.del(url)
|
|
.expect(200, function(err, res) {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns the referenced models without the unlinked one', function(done) {
|
|
const url = '/api/recipes/' + this.recipe.id + '/ingredients';
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{name: 'Sugar', id: test.ingredient2},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('has not destroyed an unlinked model', function(done) {
|
|
const url = '/api/ingredients';
|
|
const test = this;
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.eql([
|
|
{name: 'Chocolate', id: test.ingredient1},
|
|
{name: 'Sugar', id: test.ingredient2},
|
|
]);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('uses a custom relation path', function(done) {
|
|
const url = '/api/recipes/' + this.recipe.id + '/image';
|
|
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(err).to.not.exist();
|
|
expect(res.body.name).to.equal('Photo 1');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it.skip('checks if a referenced model exists - ok', function(done) {
|
|
let url = '/api/recipes/' + this.recipe.id + '/ingredients/';
|
|
url += this.ingredient1;
|
|
|
|
this.head(url)
|
|
.expect(200, function(err, res) {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it.skip('checks if an referenced model exists - fail', function(done) {
|
|
let url = '/api/recipes/' + this.recipe.id + '/ingredients/';
|
|
url += this.ingredient3;
|
|
|
|
this.head(url)
|
|
.expect(404, function(err, res) {
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('nested relations', function() {
|
|
let accessOptions;
|
|
|
|
before(function defineModels() {
|
|
const Book = app.registry.createModel(
|
|
'Book',
|
|
{name: 'string'},
|
|
{plural: 'books'},
|
|
);
|
|
app.model(Book, {dataSource: 'db'});
|
|
|
|
const Page = app.registry.createModel(
|
|
'Page',
|
|
{name: 'string'},
|
|
{plural: 'pages'},
|
|
);
|
|
app.model(Page, {dataSource: 'db'});
|
|
|
|
const Image = app.registry.createModel(
|
|
'Image',
|
|
{name: 'string'},
|
|
{plural: 'images'},
|
|
);
|
|
app.model(Image, {dataSource: 'db'});
|
|
|
|
const Note = app.registry.createModel(
|
|
'Note',
|
|
{text: 'string'},
|
|
{plural: 'notes'},
|
|
);
|
|
app.model(Note, {dataSource: 'db'});
|
|
|
|
const Chapter = app.registry.createModel(
|
|
'Chapter',
|
|
{name: 'string'},
|
|
{plural: 'chapters'},
|
|
);
|
|
app.model(Chapter, {dataSource: 'db'});
|
|
|
|
Book.hasMany(Page, {options: {nestRemoting: true}});
|
|
Book.hasMany(Chapter);
|
|
Page.hasMany(Note);
|
|
Page.belongsTo(Book, {options: {nestRemoting: true}});
|
|
Chapter.hasMany(Note);
|
|
Image.belongsTo(Book);
|
|
|
|
// fake a remote method that match the filter in Model.nestRemoting()
|
|
Page.prototype['__throw__errors'] = function() {
|
|
throw new Error('This should not crash the app');
|
|
};
|
|
|
|
Page.remoteMethod('__throw__errors', {isStatic: false, http: {path: '/throws', verb: 'get'},
|
|
accepts: [{arg: 'options', type: 'object', http: 'optionsFromRequest'}]});
|
|
|
|
// Now `pages` has nestRemoting set to true and no need to call nestRemoting()
|
|
// Book.nestRemoting('pages');
|
|
Book.nestRemoting('chapters');
|
|
Image.nestRemoting('book');
|
|
|
|
expect(Book.prototype['__findById__pages']).to.be.a('function');
|
|
expect(Image.prototype['__get__book']).to.be.a('function');
|
|
|
|
Page.beforeRemote('prototype.__findById__notes', function(ctx, result, next) {
|
|
ctx.res.set('x-before', 'before');
|
|
|
|
next();
|
|
});
|
|
|
|
Page.afterRemote('prototype.__findById__notes', function(ctx, result, next) {
|
|
ctx.res.set('x-after', 'after');
|
|
|
|
next();
|
|
});
|
|
|
|
Page.observe('access', function(ctx, next) {
|
|
accessOptions = ctx.options;
|
|
next();
|
|
});
|
|
});
|
|
|
|
beforeEach(function resetAccessOptions() {
|
|
accessOptions = 'access hook not triggered';
|
|
});
|
|
|
|
before(function createBook(done) {
|
|
const test = this;
|
|
app.models.Book.create({name: 'Book 1'},
|
|
function(err, book) {
|
|
if (err) return done(err);
|
|
|
|
test.book = book;
|
|
book.pages.create({name: 'Page 1'},
|
|
function(err, page) {
|
|
if (err) return done(err);
|
|
|
|
test.page = page;
|
|
page.notes.create({text: 'Page Note 1'},
|
|
function(err, note) {
|
|
test.note = note;
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
before(function createChapters(done) {
|
|
const test = this;
|
|
test.book.chapters.create({name: 'Chapter 1'},
|
|
function(err, chapter) {
|
|
if (err) return done(err);
|
|
|
|
test.chapter = chapter;
|
|
chapter.notes.create({text: 'Chapter Note 1'}, function(err, note) {
|
|
test.cnote = note;
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
before(function createCover(done) {
|
|
const test = this;
|
|
app.models.Image.create({name: 'Cover 1', book: test.book},
|
|
function(err, image) {
|
|
if (err) return done(err);
|
|
|
|
test.image = image;
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('has regular relationship routes - pages', function(done) {
|
|
const test = this;
|
|
this.get('/api/books/' + test.book.id + '/pages')
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.an('array');
|
|
expect(res.body).to.have.length(1);
|
|
expect(res.body[0].name).to.equal('Page 1');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('has regular relationship routes - notes', function(done) {
|
|
const test = this;
|
|
this.get('/api/pages/' + test.page.id + '/notes/' + test.note.id)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.headers['x-before']).to.equal('before');
|
|
expect(res.headers['x-after']).to.equal('after');
|
|
expect(res.body).to.be.an('object');
|
|
expect(res.body.text).to.equal('Page Note 1');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('has a basic error handler', function(done) {
|
|
const test = this;
|
|
this.get('/api/books/unknown/pages/' + test.page.id + '/notes')
|
|
.expect(404, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.error).to.be.an('object');
|
|
const expected = 'could not find a model with id unknown';
|
|
expect(res.body.error.message).to.equal(expected);
|
|
expect(res.body.error.code).to.be.equal('MODEL_NOT_FOUND');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('enables nested relationship routes - belongsTo find', function(done) {
|
|
const test = this;
|
|
this.get('/api/images/' + test.image.id + '/book/pages')
|
|
.end(function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.an('array');
|
|
expect(res.body).to.have.length(1);
|
|
expect(res.body[0].name).to.equal('Page 1');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('enables nested relationship routes - belongsTo findById', function(done) {
|
|
const test = this;
|
|
this.get('/api/images/' + test.image.id + '/book/pages/' + test.page.id)
|
|
.expect(200)
|
|
.end(function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.an('object');
|
|
expect(res.body.name).to.equal('Page 1');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('enables nested relationship routes - hasMany find', function(done) {
|
|
const test = this;
|
|
this.get('/api/books/' + test.book.id + '/pages/' + test.page.id + '/notes')
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.an('array');
|
|
expect(res.body).to.have.length(1);
|
|
expect(res.body[0].text).to.equal('Page Note 1');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('enables nested relationship routes - hasMany findById', function(done) {
|
|
const test = this;
|
|
this.get('/api/books/' + test.book.id + '/pages/' + test.page.id + '/notes/' + test.note.id)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.headers['x-before']).to.equal('before');
|
|
expect(res.headers['x-after']).to.equal('after');
|
|
expect(res.body).to.be.an('object');
|
|
expect(res.body.text).to.equal('Page Note 1');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('passes options to nested relationship routes', function() {
|
|
return this.get(`/api/books/${this.book.id}/pages/${this.page.id}/notes/${this.note.id}`)
|
|
.expect(200)
|
|
.then(res => {
|
|
expect(accessOptions).to.have.property('accessToken');
|
|
});
|
|
});
|
|
|
|
it('should nest remote hooks of ModelTo - hasMany findById', function(done) {
|
|
const test = this;
|
|
this.get('/api/books/' + test.book.id + '/chapters/' + test.chapter.id + '/notes/' + test.cnote.id)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.headers['x-before']).to.be.undefined();
|
|
expect(res.headers['x-after']).to.be.undefined();
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should have proper http.path for remoting', function() {
|
|
[app.models.Book, app.models.Image].forEach(function(Model) {
|
|
Model.sharedClass.methods().forEach(function(method) {
|
|
const http = Array.isArray(method.http) ? method.http : [method.http];
|
|
http.forEach(function(opt) {
|
|
// destroyAll has been shared but missing http property
|
|
if (opt.path === undefined) return;
|
|
|
|
expect(opt.path, method.stringName).to.match(/^\/.*/);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should catch error if nested function throws', function(done) {
|
|
const test = this;
|
|
this.get('/api/books/' + test.book.id + '/pages/' + this.page.id + '/throws')
|
|
.end(function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body).to.be.an('object');
|
|
expect(res.body.error).to.be.an('object');
|
|
expect(res.body.error.name).to.equal('Error');
|
|
expect(res.body.error.statusCode).to.equal(500);
|
|
expect(res.body.error.message).to.equal('This should not crash the app');
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('hasOne', function() {
|
|
let cust;
|
|
|
|
before(function createCustomer(done) {
|
|
const test = this;
|
|
app.models.customer.create({name: 'John'}, function(err, c) {
|
|
if (err) return done(err);
|
|
|
|
cust = c;
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
after(function(done) {
|
|
const self = this;
|
|
this.app.models.customer.destroyAll(function(err) {
|
|
if (err) return done(err);
|
|
|
|
self.app.models.profile.destroyAll(done);
|
|
});
|
|
});
|
|
|
|
it('should create the referenced model', function(done) {
|
|
const url = '/api/customers/' + cust.id + '/profile';
|
|
|
|
this.post(url)
|
|
.send({points: 10})
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.points).to.be.eql(10);
|
|
expect(res.body.customerId).to.be.eql(cust.id);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should find the referenced model', function(done) {
|
|
const url = '/api/customers/' + cust.id + '/profile';
|
|
this.get(url)
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.points).to.be.eql(10);
|
|
expect(res.body.customerId).to.be.eql(cust.id);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should not create the referenced model twice', function(done) {
|
|
const url = '/api/customers/' + cust.id + '/profile';
|
|
this.post(url)
|
|
.send({points: 20})
|
|
.expect(500, function(err, res) {
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
it('should update the referenced model', function(done) {
|
|
const url = '/api/customers/' + cust.id + '/profile';
|
|
this.put(url)
|
|
.send({points: 100})
|
|
.expect(200, function(err, res) {
|
|
if (err) return done(err);
|
|
|
|
expect(res.body.points).to.be.eql(100);
|
|
expect(res.body.customerId).to.be.eql(cust.id);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should delete the referenced model', function(done) {
|
|
const url = '/api/customers/' + cust.id + '/profile';
|
|
this.del(url)
|
|
.expect(204, function(err, res) {
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
it('should not find the referenced model', function(done) {
|
|
const url = '/api/customers/' + cust.id + '/profile';
|
|
this.get(url)
|
|
.expect(404, function(err, res) {
|
|
const expected = 'No "profile" instance(s) found';
|
|
expect(res.body.error.message).to.be.equal(
|
|
expected,
|
|
);
|
|
expect(res.body.error.code).to.be.equal('MODEL_NOT_FOUND');
|
|
done(err);
|
|
});
|
|
});
|
|
});
|
|
});
|