verdnatura-mirror
/
loopback-connector-remote
mirror of https://github.com/strongloop/loopback-connector-remote.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #82 from strongloop/code-cleanup 

Code cleanup
This commit is contained in:
Miroslav Bajtoš 2017-12-11 15:43:40 +01:00 committed by GitHub
parent fafc0e36f3 55cb88f727
commit ffaaec8973
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 318 additions and 467 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.eslintignore Normal file
View File

@ -0,0 +1 @@
coverage

133
.eslintrc
View File

@ -1,134 +1,3 @@
{ {
"env": { "extends": "loopback"
"browser": false,
"node": true,
"amd": true
},
"rules": {
"no-alert": 2,
"no-array-constructor": 2,
"no-bitwise": 2,
"no-caller": 2,
"no-catch-shadow": 2,
"no-comma-dangle": 2,
"no-cond-assign": 2,
"no-console": 1,
"no-constant-condition": 2,
"no-control-regex": 2,
"no-debugger": 2,
"no-delete-var": 2,
"no-div-regex": 1,
"no-dupe-keys": 2,
"no-else-return": 2,
"no-empty": 2,
"no-empty-class": 2,
"no-empty-label": 2,
"no-eq-null": 2,
"no-eval": 2,
"no-ex-assign": 2,
"no-extend-native": 2,
"no-extra-boolean-cast": 2,
"no-extra-parens": 1,
"no-extra-semi": 2,
"no-extra-strict": 2,
"no-fallthrough": 2,
"no-floating-decimal": 1,
"no-func-assign": 2,
"no-global-strict": 2,
"no-implied-eval": 2,
"no-inner-declarations": [2, "functions"],
"no-invalid-regexp": 2,
"no-iterator": 2,
"no-label-var": 2,
"no-labels": 2,
"no-lone-blocks": 2,
"no-lonely-if": 2,
"no-loop-func": 2,
"no-mixed-requires": [2, false],
"no-multi-str": 2,
"no-native-reassign": 2,
"no-negated-in-lhs": 2,
"no-nested-ternary": 1,
"no-new": 2,
"no-new-func": 2,
"no-new-object": 2,
"no-new-require": 1,
"no-new-wrappers": 2,
"no-obj-calls": 2,
"no-octal": 2,
"no-octal-escape": 2,
"no-path-concat": 0,
"no-plusplus": 2,
"no-process-exit": 2,
"no-proto": 2,
"no-redeclare": 2,
"no-regex-spaces": 2,
"no-restricted-modules": 0,
"no-return-assign": 2,
"no-script-url": 2,
"no-self-compare": 0,
"no-sequences": 2,
"no-shadow": 2,
"no-shadow-restricted-names": 2,
"no-spaced-func": 2,
"no-space-before-semi": 2,
"no-sparse-arrays": 2,
"no-sync": 0,
"no-ternary": 2,
"no-trailing-spaces": 2,
"no-undef": 2,
"no-undefined": 1,
"no-undef-init": 2,
"no-underscore-dangle": 0,
"no-unreachable": 2,
"no-unused-expressions": 2,
"no-unused-vars": [2, {"vars": "all", "args": "after-used"}],
"no-use-before-define": 2,
"no-warning-comments": [1, { "terms": ["todo", "fixme", "xxx"], "location": "start" }],
"no-with": 2,
"no-wrap-func": 2,
"no-mixed-spaces-and-tabs": [2, false],
"block-scoped-var": 1,
"brace-style": [2, "1tbs"],
"camelcase": 2,
"complexity": [0, 11],
"consistent-return": 2,
"consistent-this": [2, "that"],
"curly": [2, "all"],
"default-case": 1,
"dot-notation": 2,
"eol-last": 2,
"eqeqeq": 2,
"func-names": 0,
"func-style": [2, "declaration"],
"guard-for-in": 1,
"max-depth": [0, 4],
"max-len": [1, 80, 4],
"max-nested-callbacks": [1, 2],
"max-params": [0, 3],
"max-statements": [0, 10],
"handle-callback-err": 1,
"new-cap": 2,
"new-parens": 2,
"one-var": 0,
"quote-props": 1,
"quotes": [2, "single"],
"radix": 2,
"semi": 2,
"sort-vars": 1,
"space-after-keywords": [2, "always"],
"space-in-brackets": [1, "never"],
"space-infix-ops": 2,
"space-return-throw-case": 2,
"space-unary-word-ops": 1,
"strict": 0,
"use-isnan": 2,
"valid-jsdoc": 2,
"valid-typeof": 2,
"wrap-iife": 1,
"wrap-regex": 1,
"yoda": [2, "never"]
}
} }

36
Gruntfile.js
View File

@ -3,7 +3,9 @@
// This file is licensed under the MIT License. // This file is licensed under the MIT License.
// License text available at https://opensource.org/licenses/MIT // License text available at https://opensource.org/licenses/MIT
/*global module:false*/ 'use strict';
/* global module:false */
module.exports = function(grunt) { module.exports = function(grunt) {
// Project configuration. // Project configuration.
grunt.initConfig({ grunt.initConfig({
@ -15,46 +17,34 @@ module.exports = function(grunt) {
'* Copyright (c) <%= grunt.template.today("yyyy") %> ' + '* Copyright (c) <%= grunt.template.today("yyyy") %> ' +
'<%= pkg.author.name %>;' + '<%= pkg.author.name %>;' +
' Licensed <%= _.pluck(pkg.licenses, "type").join(", ") %> */\n', ' Licensed <%= _.pluck(pkg.licenses, "type").join(", ") %> */\n',
// Task configuration.
jshint: {
options: {
jshintrc: true
},
gruntfile: {
src: 'Gruntfile.js'
},
libTest: {
src: ['lib/**/*.js', 'test/**/*.js']
}
},
mochaTest: { mochaTest: {
'integration': { 'integration': {
src: 'test/integration/*.js', src: 'test/integration/*.js',
options: { options: {
reporter: 'dot' reporter: 'dot',
} },
}, },
'integration-xml': { 'integration-xml': {
src: 'test/integration/*.js', src: 'test/integration/*.js',
options: { options: {
reporter: 'xunit', reporter: 'xunit',
captureFile: 'xintegration.xml' captureFile: 'xintegration.xml',
} },
}, },
'unit': { 'unit': {
src: 'test/*.js', src: 'test/*.js',
options: { options: {
reporter: 'dot' reporter: 'dot',
} },
}, },
'unit-xml': { 'unit-xml': {
src: 'test/*.js', src: 'test/*.js',
options: { options: {
reporter: 'xunit', reporter: 'xunit',
captureFile: 'xunit.xml' captureFile: 'xunit.xml',
} },
} },
} },
}); });
// These plugins provide necessary tasks. // These plugins provide necessary tasks.

6
index.js
View File

@ -1,6 +0,0 @@
// Copyright IBM Corp. 2014. All Rights Reserved.
// Node module: loopback-connector-remote
// This file is licensed under the MIT License.
// License text available at https://opensource.org/licenses/MIT
module.exports = require('./lib/remote-connector');

2
lib/relations.js
View File

@ -231,6 +231,6 @@ function defineRelationProperty(modelClass, def) {
return that['__findById__' + def.name].apply(that, arguments); return that['__findById__' + def.name].apply(that, arguments);
}; };
return scope; return scope;
} },
}); });
} }

5
lib/remote-connector.js
View File

@ -29,7 +29,7 @@ module.exports = RemoteConnector;
function RemoteConnector(settings) { function RemoteConnector(settings) {
assert(typeof settings === assert(typeof settings ===
'object', 'object',
'cannot initialize RemoteConnector without a settings object'); 'cannot initialize RemoteConnector without a settings object');
this.client = settings.client; this.client = settings.client;
this.adapter = settings.adapter || 'rest'; this.adapter = settings.adapter || 'rest';
this.protocol = settings.protocol || 'http'; this.protocol = settings.protocol || 'http';
@ -48,7 +48,6 @@ function RemoteConnector(settings) {
// handle mixins in the define() method // handle mixins in the define() method
var DAO = this.DataAccessObject = function() { var DAO = this.DataAccessObject = function() {
}; };
} }
RemoteConnector.prototype.connect = function() { RemoteConnector.prototype.connect = function() {
@ -67,7 +66,7 @@ RemoteConnector.prototype.define = function(definition) {
var remotes = this.remotes; var remotes = this.remotes;
assert(Model.sharedClass, assert(Model.sharedClass,
'cannot attach ' + 'cannot attach ' +
Model.modelName + Model.modelName +
' to a remote connector without a Model.sharedClass'); ' to a remote connector without a Model.sharedClass');

9
package.json
View File

@ -2,7 +2,7 @@
"name": "loopback-connector-remote", "name": "loopback-connector-remote",
"version": "3.2.0", "version": "3.2.0",
"description": "Remote REST API connector for Loopback", "description": "Remote REST API connector for Loopback",
"main": "index.js", "main": "lib/remote-connector.js",
"keywords": [ "keywords": [
"web", "web",
"restful", "restful",
@ -10,7 +10,9 @@
"StrongLoop" "StrongLoop"
], ],
"scripts": { "scripts": {
"test": "grunt" "test": "grunt",
"posttest": "npm run lint",
"lint": "eslint ."
}, },
"engines": { "engines": {
"node": ">=4.0.0" "node": ">=4.0.0"
@ -29,6 +31,8 @@
}, },
"homepage": "http://loopback.io", "homepage": "http://loopback.io",
"dependencies": { "dependencies": {
"eslint": "^4.13.0",
"eslint-config-loopback": "^8.0.0",
"loopback-datasource-juggler": "^3.0.0", "loopback-datasource-juggler": "^3.0.0",
"strong-remoting": "^3.0.0" "strong-remoting": "^3.0.0"
}, },
@ -37,7 +41,6 @@
"bluebird": "^3.3.5", "bluebird": "^3.3.5",
"grunt": "^1.0.1", "grunt": "^1.0.1",
"grunt-cli": "^1.2.0", "grunt-cli": "^1.2.0",
"grunt-contrib-jshint": "^1.0.0",
"grunt-mocha-test": "^0.12.7", "grunt-mocha-test": "^0.12.7",
"loopback": "^3.0.0", "loopback": "^3.0.0",
"mocha": "^3.0.2", "mocha": "^3.0.2",

39
test/helper.js
View File

@ -10,21 +10,19 @@ var loopback = require('loopback');
var remoteConnector = require('..'); var remoteConnector = require('..');
exports.createMemoryDataSource = createMemoryDataSource; exports.createMemoryDataSource = createMemoryDataSource;
exports.createModel = createModel;
exports.createRemoteDataSource = createRemoteDataSource; exports.createRemoteDataSource = createRemoteDataSource;
exports.createRemoteDataSourceWithOptions = createRemoteDataSourceWithOptions;
exports.createRestAppAndListen = createRestAppAndListen; exports.createRestAppAndListen = createRestAppAndListen;
exports.getUserProperties = getUserProperties; exports.getUserProperties = getUserProperties;
function createRestAppAndListen() { function createRestAppAndListen() {
var app = loopback(); const app = loopback({localRegistry: true});
app.set('host', '127.0.0.1'); app.set('host', '127.0.0.1');
app.set('port', 0); app.set('port', 0);
app.set('legacyExplorer', false); app.set('legacyExplorer', false);
app.set('remoting', { app.set('remoting', {
errorHandler: { debug: true, log: false }, errorHandler: {debug: true, log: false},
context: false, context: false,
}); });
@ -34,38 +32,17 @@ function createRestAppAndListen() {
return app; return app;
} }
function createMemoryDataSource() { function createMemoryDataSource(app) {
return loopback.createDataSource({connector: 'memory'}); return app.dataSource('db', {connector: 'memory'});
} }
function createRemoteDataSource(remoteApp) { function createRemoteDataSource(app, serverApp) {
return loopback.createDataSource({ return app.dataSource('remote', {
url: 'http://' + remoteApp.get('host') + ':' + remoteApp.get('port'), url: 'http://' + serverApp.get('host') + ':' + serverApp.get('port'),
connector: remoteConnector
});
}
function createRemoteDataSourceWithOptions(remoteApp, options) {
return loopback.createDataSource({
url: 'http://anyURL.com',
connector: remoteConnector, connector: remoteConnector,
options: options
}); });
} }
/**
* Used to create models based on a set of options. May associate or link to an
* app.
*/
function createModel(options) {
var modelOptions = extend({ forceId: false }, options.options);
var Model = loopback.PersistedModel.extend(options.parent, options.properties,
modelOptions);
if (options.app) options.app.model(Model);
if (options.datasource) Model.attachTo(options.datasource);
return Model;
}
function getUserProperties() { function getUserProperties() {
return { return {
'first': String, 'first': String,
@ -74,6 +51,6 @@ function getUserProperties() {
'password': String, 'password': String,
'gender': String, 'gender': String,
'domain': String, 'domain': String,
'email': String 'email': String,
}; };
} }

36
test/integration/promise-support.js
View File

@ -1,9 +1,16 @@
var assert = require('assert'); // Copyright IBM Corp. 2016. All Rights Reserved.
var helper = require('../helper'); // Node module: loopback-connector-remote
var Promise = require('bluebird'); // This file is licensed under the MIT License.
// License text available at https://opensource.org/licenses/MIT
var globalPromiseSetManually = false; 'use strict';
var User;
const assert = require('assert');
const helper = require('../helper');
const Promise = require('bluebird');
let globalPromiseSetManually = false;
let User;
describe('promise support', function() { describe('promise support', function() {
before(setGlobalPromise); before(setGlobalPromise);
@ -12,21 +19,21 @@ describe('promise support', function() {
context('create', function() { context('create', function() {
it('supports promises', function() { it('supports promises', function() {
var retval = User.create(); const retval = User.create();
assert(retval && typeof retval.then === 'function'); assert(retval && typeof retval.then === 'function');
}); });
}); });
context('find', function() { context('find', function() {
it('supports promises', function() { it('supports promises', function() {
var retval = User.find(); const retval = User.find();
assert(retval && typeof retval.then === 'function'); assert(retval && typeof retval.then === 'function');
}); });
}); });
context('findById', function() { context('findById', function() {
it('supports promises', function() { it('supports promises', function() {
var retval = User.findById(1); const retval = User.findById(1);
assert(retval && typeof retval.then === 'function'); assert(retval && typeof retval.then === 'function');
}); });
}); });
@ -40,12 +47,15 @@ function setGlobalPromise() {
} }
function createUserModel() { function createUserModel() {
User = helper.createModel({ const app = helper.createRestAppAndListen();
parent: 'user', const db = helper.createMemoryDataSource(app);
app: helper.createRestAppAndListen(),
datasource: helper.createMemoryDataSource(), User = app.registry.createModel({
properties: helper.getUserProperties() name: 'user',
properties: helper.getUserProperties(),
options: {forceId: false},
}); });
app.model(User, {dataSource: db});
} }
function resetGlobalPromise() { function resetGlobalPromise() {

196
test/models.test.js
View File

@ -5,61 +5,65 @@
'use strict'; 'use strict';
var assert = require('assert'); const assert = require('assert');
var helper = require('./helper'); const helper = require('./helper');
var TaskEmitter = require('strong-task-emitter'); const loopback = require('loopback');
const TaskEmitter = require('strong-task-emitter');
describe('Model tests', function() { describe('Model tests', function() {
var User; let User;
beforeEach(function() { beforeEach(function() {
User = helper.createModel({ const app = helper.createRestAppAndListen();
parent: 'user', const db = helper.createMemoryDataSource(app);
app: helper.createRestAppAndListen(),
datasource: helper.createMemoryDataSource(), User = app.registry.createModel({
properties: helper.getUserProperties() name: 'user',
properties: helper.getUserProperties(),
options: {forceId: false},
}); });
app.model(User, {dataSource: db});
}); });
describe('Model.validatesPresenceOf(properties...)', function() { describe('Model.validatesPresenceOf(properties...)', function() {
it('should require a model to include a property to be considered valid', it('should require a model to include a property to be considered valid',
function() { function() {
User.validatesPresenceOf('first', 'last', 'age'); User.validatesPresenceOf('first', 'last', 'age');
var joe = new User({first: 'joe'}); const joe = new User({first: 'joe'});
assert(joe.isValid() === false, 'model should not validate'); assert(joe.isValid() === false, 'model should not validate');
assert(joe.errors.last, 'should have a missing last error'); assert(joe.errors.last, 'should have a missing last error');
assert(joe.errors.age, 'should have a missing age error'); assert(joe.errors.age, 'should have a missing age error');
}); });
}); });
describe('Model.validatesLengthOf(property, options)', function() { describe('Model.validatesLengthOf(property, options)', function() {
it('should require a property length to be within a specified range', it('should require a property length to be within a specified range',
function() { function() {
User.validatesLengthOf('password', {min: 5, message: {min: User.validatesLengthOf('password', {min: 5, message: {min:
'Password is too short'}}); 'Password is too short'}});
var joe = new User({password: '1234'}); const joe = new User({password: '1234'});
assert(joe.isValid() === false, 'model should not be valid'); assert(joe.isValid() === false, 'model should not be valid');
assert(joe.errors.password, 'should have password error'); assert(joe.errors.password, 'should have password error');
}); });
}); });
describe('Model.validatesInclusionOf(property, options)', function() { describe('Model.validatesInclusionOf(property, options)', function() {
it('should require a value for `property` to be in the specified array', it('should require a value for `property` to be in the specified array',
function() { function() {
User.validatesInclusionOf('gender', {in: ['male', 'female']}); User.validatesInclusionOf('gender', {in: ['male', 'female']});
var foo = new User({gender: 'bar'}); const foo = new User({gender: 'bar'});
assert(foo.isValid() === false, 'model should not be valid'); assert(foo.isValid() === false, 'model should not be valid');
assert(foo.errors.gender, 'should have gender error'); assert(foo.errors.gender, 'should have gender error');
}); });
}); });
describe('Model.validatesExclusionOf(property, options)', function() { describe('Model.validatesExclusionOf(property, options)', function() {
it('should require a value for `property` to not exist in the specified ' + it('should require a value for `property` to not exist in the specified ' +
'array', function() { 'array', function() {
User.validatesExclusionOf('domain', {in: ['www', 'billing', 'admin']}); User.validatesExclusionOf('domain', {in: ['www', 'billing', 'admin']});
var foo = new User({domain: 'www'}); const foo = new User({domain: 'www'});
var bar = new User({domain: 'billing'}); const bar = new User({domain: 'billing'});
var bat = new User({domain: 'admin'}); const bat = new User({domain: 'admin'});
assert(foo.isValid() === false); assert(foo.isValid() === false);
assert(bar.isValid() === false); assert(bar.isValid() === false);
assert(bat.isValid() === false); assert(bat.isValid() === false);
@ -73,9 +77,9 @@ describe('Model tests', function() {
it('should require a value for `property` to be a specific type of ' + it('should require a value for `property` to be a specific type of ' +
'`Number`', function() { '`Number`', function() {
User.validatesNumericalityOf('age', {int: true}); User.validatesNumericalityOf('age', {int: true});
var joe = new User({age: 10.2}); const joe = new User({age: 10.2});
assert(joe.isValid() === false); assert(joe.isValid() === false);
var bob = new User({age: 0}); const bob = new User({age: 0});
assert(bob.isValid() === true); assert(bob.isValid() === true);
assert(joe.errors.age, 'model should have an age error'); assert(joe.errors.age, 'model should have an age error');
}); });
@ -84,15 +88,15 @@ describe('Model tests', function() {
describe('myModel.isValid()', function() { describe('myModel.isValid()', function() {
it('should validate the model instance', function() { it('should validate the model instance', function() {
User.validatesNumericalityOf('age', {int: true}); User.validatesNumericalityOf('age', {int: true});
var user = new User({first: 'joe', age: 'flarg'}); const user = new User({first: 'joe', age: 'flarg'});
var valid = user.isValid(); const valid = user.isValid();
assert(valid === false); assert(valid === false);
assert(user.errors.age, 'model should have age error'); assert(user.errors.age, 'model should have age error');
}); });
it('should validate the model asynchronously', function(done) { it('should validate the model asynchronously', function(done) {
User.validatesNumericalityOf('age', {int: true}); User.validatesNumericalityOf('age', {int: true});
var user = new User({first: 'joe', age: 'flarg'}); const user = new User({first: 'joe', age: 'flarg'});
user.isValid(function(valid) { user.isValid(function(valid) {
assert(valid === false); assert(valid === false);
assert(user.errors.age, 'model should have age error'); assert(user.errors.age, 'model should have age error');
@ -103,63 +107,63 @@ describe('Model tests', function() {
describe('Model.create([data], [callback])', function() { describe('Model.create([data], [callback])', function() {
it('should create an instance and save to the attached data source', it('should create an instance and save to the attached data source',
function(done) { function(done) {
User.create({first: 'Joe', last: 'Bob'}, function(err, user) { User.create({first: 'Joe', last: 'Bob'}, function(err, user) {
if (err) return done(err); if (err) return done(err);
assert(user instanceof User); assert(user instanceof User);
done(); done();
});
}); });
});
}); });
describe('model.save([options], [callback])', function() { describe('model.save([options], [callback])', function() {
it('should save an instance of a Model to the attached data source', it('should save an instance of a Model to the attached data source',
function(done) { function(done) {
var joe = new User({first: 'Joe', last: 'Bob'}); const joe = new User({first: 'Joe', last: 'Bob'});
joe.save(function(err, user) { joe.save(function(err, user) {
if (err) return done(err); if (err) return done(err);
assert(user.id); assert(user.id);
assert(!user.errors); assert(!user.errors);
done(); done();
});
}); });
});
}); });
describe('model.updateAttributes(data, [callback])', function() { describe('model.updateAttributes(data, [callback])', function() {
it('should save specified attributes to the attached data source', it('should save specified attributes to the attached data source',
function(done) { function(done) {
User.create({first: 'joe', age: 100}, function(err, user) { User.create({first: 'joe', age: 100}, function(err, user) {
if (err) return done(err);
assert.equal(user.first, 'joe');
user.updateAttributes({
first: 'updatedFirst',
last: 'updatedLast'
}, function(err, updatedUser) {
if (err) return done(err); if (err) return done(err);
assert.equal(updatedUser.first, 'updatedFirst'); assert.equal(user.first, 'joe');
assert.equal(updatedUser.last, 'updatedLast');
assert.equal(updatedUser.age, 100); user.updateAttributes({
done(); first: 'updatedFirst',
last: 'updatedLast',
}, function(err, updatedUser) {
if (err) return done(err);
assert.equal(updatedUser.first, 'updatedFirst');
assert.equal(updatedUser.last, 'updatedLast');
assert.equal(updatedUser.age, 100);
done();
});
}); });
}); });
});
}); });
describe('Model.upsert(data, callback)', function() { describe('Model.upsert(data, callback)', function() {
it('should update when a record with id=data.id is found, insert otherwise', it('should update when a record with id=data.id is found, insert otherwise',
function(done) { function(done) {
User.upsert({first: 'joe', id: 7}, function(err, user) { User.upsert({first: 'joe', id: 7}, function(err, user) {
if (err) return done(err);
assert.equal(user.first, 'joe');
User.upsert({first: 'bob', id: 7}, function(err, updatedUser) {
if (err) return done(err); if (err) return done(err);
assert.equal(updatedUser.first, 'bob'); assert.equal(user.first, 'joe');
done();
User.upsert({first: 'bob', id: 7}, function(err, updatedUser) {
if (err) return done(err);
assert.equal(updatedUser.first, 'bob');
done();
});
}); });
}); });
});
}); });
describe('model.destroy([callback])', function() { describe('model.destroy([callback])', function() {
@ -184,19 +188,19 @@ describe('Model tests', function() {
describe('Model.deleteById(id, [callback])', function() { describe('Model.deleteById(id, [callback])', function() {
it('should delete a model instance from the attached data source', it('should delete a model instance from the attached data source',
function(done) { function(done) {
User.create({first: 'joe', last: 'bob'}, function(err, user) { User.create({first: 'joe', last: 'bob'}, function(err, user) {
if (err) return done(err);
User.deleteById(user.id, function(err) {
if (err) return done(err); if (err) return done(err);
User.findById(user.id, function(err, notFound) { User.deleteById(user.id, function(err) {
if (err) return done(err); if (err) return done(err);
assert.equal(notFound, null); User.findById(user.id, function(err, notFound) {
done(); if (err) return done(err);
assert.equal(notFound, null);
done();
});
}); });
}); });
}); });
});
}); });
describe('Model.findById(id, callback)', function() { describe('Model.findById(id, callback)', function() {
@ -217,21 +221,21 @@ describe('Model tests', function() {
describe('Model.count([query], callback)', function() { describe('Model.count([query], callback)', function() {
it('should return the count of Model instances in data source', it('should return the count of Model instances in data source',
function(done) { function(done) {
var taskEmitter = new TaskEmitter(); const taskEmitter = new TaskEmitter();
taskEmitter taskEmitter
.task(User, 'create', {first: 'jill', age: 100}) .task(User, 'create', {first: 'jill', age: 100})
.task(User, 'create', {first: 'bob', age: 200}) .task(User, 'create', {first: 'bob', age: 200})
.task(User, 'create', {first: 'jan'}) .task(User, 'create', {first: 'jan'})
.task(User, 'create', {first: 'sam'}) .task(User, 'create', {first: 'sam'})
.task(User, 'create', {first: 'suzy'}) .task(User, 'create', {first: 'suzy'})
.on('done', function() { .on('done', function() {
User.count({age: {gt: 99}}, function(err, count) { User.count({age: {gt: 99}}, function(err, count) {
if (err) return done(err); if (err) return done(err);
assert.equal(count, 2); assert.equal(count, 2);
done(); done();
});
}); });
}); });
});
}); });
}); });

124
test/remote-connector.test.js
View File

@ -5,43 +5,45 @@
'use strict'; 'use strict';
var assert = require('assert'); const assert = require('assert');
var helper = require('./helper'); const helper = require('./helper');
const loopback = require('loopback');
describe('RemoteConnector', function() { describe('RemoteConnector', function() {
var ctx = this; let serverApp, clientApp, ServerModel, ClientModel;
before(function setupServer(done) { before(function setupServer(done) {
ctx.serverApp = helper.createRestAppAndListen(); const app = serverApp = helper.createRestAppAndListen();
ctx.ServerModel = helper.createModel({ const db = helper.createMemoryDataSource(app);
parent: 'TestModel',
app: ctx.serverApp, ServerModel = app.registry.createModel({
datasource: helper.createMemoryDataSource() name: 'TestModel',
}); });
ctx.serverApp.locals.handler.on('listening', function() { done(); }); app.model(ServerModel, {dataSource: db});
app.locals.handler.on('listening', function() { done(); });
}); });
before(function setupRemoteClient(done) { before(function setupRemoteClient() {
ctx.remoteApp = helper.createRestAppAndListen(); const app = clientApp = loopback({localRegistry: true});
ctx.RemoteModel = helper.createModel({ const remoteDs = helper.createRemoteDataSource(clientApp, serverApp);
parent: 'TestModel',
app: ctx.remoteApp, ClientModel = app.registry.createModel({
datasource: helper.createRemoteDataSource(ctx.serverApp) name: 'TestModel',
}); });
ctx.remoteApp.locals.handler.on('listening', function() { done(); }); app.model(ClientModel, {dataSource: remoteDs});
}); });
after(function() { after(function() {
ctx.serverApp.locals.handler.close(); serverApp.locals.handler.close();
ctx.remoteApp.locals.handler.close(); ServerModel = null;
ctx.ServerModel = null; ClientModel = null;
ctx.RemoteModel = null;
}); });
it('should support the save method', function(done) { it('should support the save method', function(done) {
var calledServerCreate = false; let calledServerCreate = false;
ctx.ServerModel.create = function(data, options, cb, callback) { ServerModel.create = function(data, options, cb, callback) {
if (typeof options === 'function') { if (typeof options === 'function') {
callback = cb; callback = cb;
cb = options; cb = options;
@ -54,20 +56,20 @@ describe('RemoteConnector', function() {
else cb(null, data); else cb(null, data);
}; };
var m = new ctx.RemoteModel({foo: 'bar'}); const m = new ClientModel({foo: 'bar'});
m.save(function(err, instance) { m.save(function(err, instance) {
if (err) return done(err); if (err) return done(err);
assert(instance); assert(instance);
assert(instance instanceof ctx.RemoteModel); assert(instance instanceof ClientModel);
assert(calledServerCreate); assert(calledServerCreate);
done(); done();
}); });
}); });
it('should support aliases', function(done) { it('should support aliases', function(done) {
var calledServerUpsert = false; let calledServerUpsert = false;
ctx.ServerModel.patchOrCreate = ServerModel.patchOrCreate =
ctx.ServerModel.upsert = function(id, options, cb) { ServerModel.upsert = function(id, options, cb) {
if (typeof options === 'function') { if (typeof options === 'function') {
cb = options; cb = options;
options = {}; options = {};
@ -77,10 +79,10 @@ describe('RemoteConnector', function() {
cb(); cb();
}; };
ctx.RemoteModel.updateOrCreate({}, function(err, instance) { ClientModel.updateOrCreate({}, function(err, instance) {
if (err) return done(err); if (err) return done(err);
assert(instance); assert(instance);
assert(instance instanceof ctx.RemoteModel); assert(instance instanceof ClientModel);
assert(calledServerUpsert, 'server upsert should have been called'); assert(calledServerUpsert, 'server upsert should have been called');
done(); done();
}); });
@ -88,46 +90,45 @@ describe('RemoteConnector', function() {
}); });
describe('Custom Path', function() { describe('Custom Path', function() {
var ctx = this; let serverApp, clientApp, ServerModel, ClientModel;
before(function setupServer(done) { before(function setupServer(done) {
ctx.serverApp = helper.createRestAppAndListen(); const app = serverApp = helper.createRestAppAndListen();
ctx.ServerModel = helper.createModel({ const db = helper.createMemoryDataSource(app);
parent: 'TestModel',
app: ctx.serverApp, ServerModel = app.registry.createModel({
datasource: helper.createMemoryDataSource(), name: 'TestModel',
options: { options: {
http: {path: '/custom'} http: {path: '/custom'},
} },
}); });
ctx.serverApp.locals.handler.on('listening', function() { done(); }); app.model(ServerModel, {dataSource: db});
serverApp.locals.handler.on('listening', function() { done(); });
}); });
before(function setupRemoteClient(done) { before(function setupRemoteClient() {
ctx.remoteApp = helper.createRestAppAndListen(); const app = clientApp = loopback({localRegistry: true});
ctx.RemoteModel = helper.createModel({ const remoteDs = helper.createRemoteDataSource(clientApp, serverApp);
parent: 'TestModel',
app: ctx.remoteApp, ClientModel = app.registry.createModel({
datasource: helper.createRemoteDataSource(ctx.serverApp), name: 'TestModel',
options: { options: {
dataSource: 'remote', dataSource: 'remote',
http: {path: '/custom'} http: {path: '/custom'},
} },
}); });
ctx.remoteApp.locals.handler.on('listening', function() { done(); }); app.model(ClientModel, {dataSource: remoteDs});
}); });
after(function(done) after(function() {
{ serverApp.locals.handler.close();
ctx.serverApp.locals.handler.close(); ServerModel = null;
ctx.remoteApp.locals.handler.close(); ClientModel = null;
ctx.ServerModel = null;
ctx.RemoteModel = null;
done();
}); });
it('should support http.path configuration', function(done) { it('should support http.path configuration', function(done) {
ctx.RemoteModel.create({}, function(err, instance) { ClientModel.create({}, function(err, instance) {
if (err) return done(err); if (err) return done(err);
assert(instance); assert(instance);
done(); done();
@ -137,12 +138,13 @@ describe('Custom Path', function() {
describe('RemoteConnector with options', () => { describe('RemoteConnector with options', () => {
it('should have the remoting options passed to the remote object', () => { it('should have the remoting options passed to the remote object', () => {
const serverApp = helper.createRestAppAndListen(); const app = loopback();
const dataSource = app.dataSource('remote', {
url: 'http://example.com',
connector: require('..'),
options: {'test': 'abc'},
});
const datasource = helper.createRemoteDataSourceWithOptions( assert.deepEqual(dataSource.connector.remotes.options, {test: 'abc'});
serverApp,
{'test': 'abc'});
assert.deepEqual(datasource.connector.remotes.options, {test: 'abc'});
}); });
}); });

198
test/remote-models.test.js
View File

@ -5,157 +5,159 @@
'use strict'; 'use strict';
var assert = require('assert'); const assert = require('assert');
var helper = require('./helper'); const helper = require('./helper');
var TaskEmitter = require('strong-task-emitter'); const loopback = require('loopback');
const TaskEmitter = require('strong-task-emitter');
describe('Remote model tests', function() { describe('Remote model tests', function() {
var ctx = this; let serverApp, ServerModel, clientApp, ClientModel;
beforeEach(function(done) { beforeEach(function setupServer(done) {
ctx.serverApp = helper.createRestAppAndListen(); const app = serverApp = helper.createRestAppAndListen();
ctx.ServerModel = helper.createModel({ const db = helper.createMemoryDataSource(app);
parent: 'TestModel',
app: ctx.serverApp, ServerModel = app.registry.createModel({
datasource: helper.createMemoryDataSource(), name: 'TestModel',
properties: helper.userProperties properties: helper.userProperties,
options: {forceId: false},
}); });
ctx.serverApp.locals.handler.on('listening', function() { done(); }); app.model(ServerModel, {dataSource: db});
serverApp.locals.handler.on('listening', function() { done(); });
}); });
beforeEach(function setupRemoteClient(done) { beforeEach(function setupRemoteClient() {
ctx.remoteApp = helper.createRestAppAndListen(); const app = clientApp = loopback({localRegistry: true});
ctx.RemoteModel = helper.createModel({ const remoteDs = helper.createRemoteDataSource(clientApp, serverApp);
parent: 'TestModel',
app: ctx.remoteApp, ClientModel = app.registry.createModel({
datasource: helper.createRemoteDataSource(ctx.serverApp), name: 'TestModel',
properties: helper.userProperties
}); });
ctx.remoteApp.locals.handler.on('listening', function() { done(); }); app.model(ClientModel, {dataSource: remoteDs});
}); });
afterEach(function() { afterEach(function() {
ctx.serverApp.locals.handler.close(); serverApp.locals.handler.close();
ctx.remoteApp.locals.handler.close(); ServerModel = null;
ctx.ServerModel = null; ClientModel = null;
ctx.RemoteModel = null;
}); });
describe('Model.create([data], [callback])', function() { describe('Model.create([data], [callback])', function() {
it('should create an instance and save to the attached data source', it('should create an instance and save to the attached data source',
function(done) { function(done) {
ctx.RemoteModel.create({first: 'Joe', last: 'Bob'}, function(err, user) { ClientModel.create({first: 'Joe', last: 'Bob'}, function(err, user) {
if (err) return done(err); if (err) return done(err);
assert(user instanceof ctx.RemoteModel); assert(user instanceof ClientModel);
done(); done();
});
}); });
});
}); });
describe('model.save([options], [callback])', function() { describe('model.save([options], [callback])', function() {
it('should save an instance of a Model to the attached data source', it('should save an instance of a Model to the attached data source',
function(done) { function(done) {
var joe = new ctx.RemoteModel({first: 'Joe', last: 'Bob'}); const joe = new ClientModel({first: 'Joe', last: 'Bob'});
joe.save(function(err, user) { joe.save(function(err, user) {
if (err) return done(err); if (err) return done(err);
assert(user.id); assert(user.id);
assert(!user.errors); assert(!user.errors);
done(); done();
});
}); });
});
}); });
describe('model.updateAttributes(data, [callback])', function() { describe('model.updateAttributes(data, [callback])', function() {
it('should save specified attributes to the attached data source', it('should save specified attributes to the attached data source',
function(done) { function(done) {
ctx.ServerModel.create({first: 'joe', age: 100}, function(err, user) { ServerModel.create({first: 'joe', age: 100}, function(err, user) {
if (err) return done(err);
assert.equal(user.first, 'joe');
user.updateAttributes({
first: 'updatedFirst',
last: 'updatedLast'
}, function(err, updatedUser) {
if (err) return done(err); if (err) return done(err);
assert.equal(updatedUser.first, 'updatedFirst'); assert.equal(user.first, 'joe');
assert.equal(updatedUser.last, 'updatedLast');
assert.equal(updatedUser.age, 100); user.updateAttributes({
done(); first: 'updatedFirst',
last: 'updatedLast',
}, function(err, updatedUser) {
if (err) return done(err);
assert.equal(updatedUser.first, 'updatedFirst');
assert.equal(updatedUser.last, 'updatedLast');
assert.equal(updatedUser.age, 100);
done();
});
}); });
}); });
});
}); });
describe('Model.upsert(data, callback)', function() { describe('Model.upsert(data, callback)', function() {
it('should update when a record with id=data.id is found, insert otherwise', it('should update when a record with id=data.id is found, insert otherwise',
function(done) { function(done) {
ctx.RemoteModel.upsert({first: 'joe', id: 7}, function(err, user) { ClientModel.upsert({first: 'joe', id: 7}, function(err, user) {
if (err) return done(err);
assert.equal(user.first, 'joe');
ctx.RemoteModel.upsert({first: 'bob', id: 7}, function(err,
updatedUser) {
if (err) return done(err); if (err) return done(err);
assert.equal(updatedUser.first, 'bob'); assert.equal(user.first, 'joe');
done();
ClientModel.upsert({first: 'bob', id: 7}, function(err,
updatedUser) {
if (err) return done(err);
assert.equal(updatedUser.first, 'bob');
done();
});
}); });
}); });
});
}); });
describe('Model.deleteById(id, [callback])', function() { describe('Model.deleteById(id, [callback])', function() {
it('should delete a model instance from the attached data source', it('should delete a model instance from the attached data source',
function(done) { function(done) {
ctx.ServerModel.create({first: 'joe', last: 'bob'}, function(err, user) { ServerModel.create({first: 'joe', last: 'bob'}, function(err, user) {
if (err) return done(err);
ctx.RemoteModel.deleteById(user.id, function(err) {
if (err) return done(err); if (err) return done(err);
ctx.RemoteModel.findById(user.id, function(err, notFound) { ClientModel.deleteById(user.id, function(err) {
assert.equal(notFound, null); if (err) return done(err);
assert(err && err.statusCode === 404, ClientModel.findById(user.id, function(err, notFound) {
'should have failed with HTTP 404'); assert.equal(notFound, null);
done(); assert(err && err.statusCode === 404,
'should have failed with HTTP 404');
done();
});
}); });
}); });
}); });
});
}); });
describe('Model.findById(id, callback)', function() { describe('Model.findById(id, callback)', function() {
it('should find an instance by id from the attached data source', it('should find an instance by id from the attached data source',
function(done) { function(done) {
ctx.ServerModel.create({first: 'michael', last: 'jordan', id: 23}, ServerModel.create({first: 'michael', last: 'jordan', id: 23},
function(err) { function(err) {
if (err) return done(err); if (err) return done(err);
ctx.RemoteModel.findById(23, function(err, user) { ClientModel.findById(23, function(err, user) {
if (err) return done(err); if (err) return done(err);
assert.equal(user.id, 23); assert.equal(user.id, 23);
assert.equal(user.first, 'michael'); assert.equal(user.first, 'michael');
assert.equal(user.last, 'jordan'); assert.equal(user.last, 'jordan');
done(); done();
}); });
});
}); });
});
}); });
describe('Model.count([query], callback)', function() { describe('Model.count([query], callback)', function() {
it('should return the count of Model instances from both data source', it('should return the count of Model instances from both data source',
function(done) { function(done) {
var taskEmitter = new TaskEmitter(); const taskEmitter = new TaskEmitter();
taskEmitter taskEmitter
.task(ctx.ServerModel, 'create', {first: 'jill', age: 100}) .task(ServerModel, 'create', {first: 'jill', age: 100})
.task(ctx.RemoteModel, 'create', {first: 'bob', age: 200}) .task(ClientModel, 'create', {first: 'bob', age: 200})
.task(ctx.RemoteModel, 'create', {first: 'jan'}) .task(ClientModel, 'create', {first: 'jan'})
.task(ctx.ServerModel, 'create', {first: 'sam'}) .task(ServerModel, 'create', {first: 'sam'})
.task(ctx.ServerModel, 'create', {first: 'suzy'}) .task(ServerModel, 'create', {first: 'suzy'})
.on('done', function(err) { .on('done', function(err) {
if (err) return done(err);
ctx.RemoteModel.count({age: {gt: 99}}, function(err, count) {
if (err) return done(err); if (err) return done(err);
assert.equal(count, 2); ClientModel.count({age: {gt: 99}}, function(err, count) {
done(); if (err) return done(err);
assert.equal(count, 2);
done();
});
}); });
}); });
});
}); });
}); });