3290 lines
93 KiB
JavaScript
3290 lines
93 KiB
JavaScript
// Copyright IBM Corp. 2014,2019. All Rights Reserved.
|
|
// Node module: loopback-boot
|
|
// This file is licensed under the MIT License.
|
|
// License text available at https://opensource.org/licenses/MIT
|
|
|
|
'use strict';
|
|
|
|
var boot = require('../');
|
|
var fs = require('fs-extra');
|
|
var path = require('path');
|
|
var expect = require('chai').expect;
|
|
var sandbox = require('./helpers/sandbox');
|
|
var appdir = require('./helpers/appdir');
|
|
|
|
// add coffee-script to require.extensions
|
|
require('coffeescript/register');
|
|
|
|
var SIMPLE_APP = path.join(__dirname, 'fixtures', 'simple-app');
|
|
|
|
describe('compiler', function() {
|
|
beforeEach(sandbox.reset);
|
|
beforeEach(appdir.init);
|
|
|
|
function expectCompileToThrow(err, options, done) {
|
|
if (typeof options === 'function') {
|
|
done = options;
|
|
options = undefined;
|
|
}
|
|
boot.compile(options || appdir.PATH, function(err) {
|
|
expect(function() {
|
|
if (err) throw err;
|
|
}).to.throw(err);
|
|
done();
|
|
});
|
|
}
|
|
|
|
function expectCompileToNotThrow(options, done) {
|
|
if (typeof options === 'function') {
|
|
done = options;
|
|
options = undefined;
|
|
}
|
|
boot.compile(options || appdir.PATH, function(err) {
|
|
expect(function() {
|
|
if (err) throw err;
|
|
}).to.not.throw();
|
|
done();
|
|
});
|
|
}
|
|
|
|
describe('from options', function() {
|
|
var options, instructions, appConfig;
|
|
|
|
beforeEach(function(done) {
|
|
options = {
|
|
application: {
|
|
port: 3000,
|
|
host: '127.0.0.1',
|
|
restApiRoot: '/rest-api',
|
|
foo: {bar: 'bat'},
|
|
baz: true,
|
|
},
|
|
models: {
|
|
'foo-bar-bat-baz': {
|
|
dataSource: 'the-db',
|
|
},
|
|
},
|
|
dataSources: {
|
|
'the-db': {
|
|
connector: 'memory',
|
|
defaultForType: 'db',
|
|
},
|
|
},
|
|
};
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
appConfig = context.instructions.application;
|
|
instructions = context.instructions;
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('has port setting', function() {
|
|
expect(appConfig).to.have.property('port', 3000);
|
|
});
|
|
|
|
it('has host setting', function() {
|
|
expect(appConfig).to.have.property('host', '127.0.0.1');
|
|
});
|
|
|
|
it('has restApiRoot setting', function() {
|
|
expect(appConfig).to.have.property('restApiRoot', '/rest-api');
|
|
});
|
|
|
|
it('has other settings', function() {
|
|
expect(appConfig).to.have.property('baz', true);
|
|
expect(appConfig.foo, 'appConfig.foo').to.eql({
|
|
bar: 'bat',
|
|
});
|
|
});
|
|
|
|
it('has models definition', function() {
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.eql({
|
|
name: 'foo-bar-bat-baz',
|
|
config: {
|
|
dataSource: 'the-db',
|
|
},
|
|
definition: undefined,
|
|
sourceFile: undefined,
|
|
});
|
|
});
|
|
|
|
it('has datasources definition', function() {
|
|
expect(instructions.dataSources).to.eql(options.dataSources);
|
|
});
|
|
|
|
describe('with custom model definitions', function(done) {
|
|
var dataSources = {
|
|
'the-db': {connector: 'memory'},
|
|
};
|
|
|
|
it('loads model without definition', function(done) {
|
|
var instruction = boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
models: {
|
|
'model-without-definition': {
|
|
dataSource: 'the-db',
|
|
},
|
|
},
|
|
modelDefinitions: [],
|
|
dataSources: dataSources,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.models[0].name).to.equal(
|
|
'model-without-definition'
|
|
);
|
|
expect(instructions.models[0].definition).to.equal(undefined);
|
|
expect(instructions.models[0].sourceFile).to.equal(undefined);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('loads coffeescript models', function(done) {
|
|
var modelScript = appdir.writeFileSync(
|
|
'custom-models/coffee-model-with-definition.coffee',
|
|
''
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
models: {
|
|
'coffee-model-with-definition': {
|
|
dataSource: 'the-db',
|
|
},
|
|
},
|
|
modelDefinitions: [
|
|
{
|
|
definition: {
|
|
name: 'coffee-model-with-definition',
|
|
},
|
|
sourceFile: modelScript,
|
|
},
|
|
],
|
|
dataSources: dataSources,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.models[0].name).to.equal(
|
|
'coffee-model-with-definition'
|
|
);
|
|
expect(instructions.models[0].definition).to.eql({
|
|
name: 'coffee-model-with-definition',
|
|
});
|
|
expect(instructions.models[0].sourceFile).to.equal(modelScript);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('handles sourceFile path without extension (.js)', function(done) {
|
|
var modelScript = appdir.writeFileSync(
|
|
'custom-models/model-without-ext.coffee',
|
|
''
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
models: {
|
|
'model-without-ext': {
|
|
dataSource: 'the-db',
|
|
},
|
|
},
|
|
modelDefinitions: [
|
|
{
|
|
definition: {
|
|
name: 'model-without-ext',
|
|
},
|
|
sourceFile: pathWithoutExtension(modelScript),
|
|
},
|
|
],
|
|
dataSources: dataSources,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.models[0].name).to.equal('model-without-ext');
|
|
expect(instructions.models[0].sourceFile).to.equal(modelScript);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('handles sourceFile path without extension (.coffee)', function(done) {
|
|
var modelScript = appdir.writeFileSync(
|
|
'custom-models/model-without-ext.coffee',
|
|
''
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
models: {
|
|
'model-without-ext': {
|
|
dataSource: 'the-db',
|
|
},
|
|
},
|
|
modelDefinitions: [
|
|
{
|
|
definition: {
|
|
name: 'model-without-ext',
|
|
},
|
|
sourceFile: pathWithoutExtension(modelScript),
|
|
},
|
|
],
|
|
dataSources: dataSources,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.models[0].name).to.equal('model-without-ext');
|
|
expect(instructions.models[0].sourceFile).to.equal(modelScript);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('sets source file path if the file exist', function(done) {
|
|
var modelScript = appdir.writeFileSync(
|
|
'custom-models/model-with-definition.js',
|
|
''
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
models: {
|
|
'model-with-definition': {
|
|
dataSource: 'the-db',
|
|
},
|
|
},
|
|
modelDefinitions: [
|
|
{
|
|
definition: {
|
|
name: 'model-with-definition',
|
|
},
|
|
sourceFile: modelScript,
|
|
},
|
|
],
|
|
dataSources: dataSources,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.models[0].name).to.equal(
|
|
'model-with-definition'
|
|
);
|
|
expect(instructions.models[0].definition).not.to.equal(undefined);
|
|
expect(instructions.models[0].sourceFile).to.equal(modelScript);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('does not set source file path if the file does not exist.',
|
|
function(done) {
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
models: {
|
|
'model-with-definition-with-falsey-source-file': {
|
|
dataSource: 'the-db',
|
|
},
|
|
},
|
|
modelDefinitions: [
|
|
{
|
|
definition: {
|
|
name: 'model-with-definition-with-falsey-source-file',
|
|
},
|
|
sourceFile: appdir.resolve(
|
|
'custom-models',
|
|
'file-does-not-exist.js'
|
|
),
|
|
},
|
|
],
|
|
dataSources: dataSources,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.models[0].name).to.equal(
|
|
'model-with-definition-with-falsey-source-file'
|
|
);
|
|
expect(instructions.models[0].definition).not.to.equal(undefined);
|
|
expect(instructions.models[0].sourceFile).to.equal(undefined);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('does not set source file path if no source file supplied.',
|
|
function(done) {
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
models: {
|
|
'model-with-definition-without-source-file-property': {
|
|
dataSource: 'the-db',
|
|
},
|
|
},
|
|
modelDefinitions: [
|
|
{
|
|
definition: {
|
|
name: 'model-with-definition-without-source-file-property',
|
|
},
|
|
// sourceFile is not set
|
|
},
|
|
],
|
|
dataSources: dataSources,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.models[0].name).to.equal(
|
|
'model-with-definition-without-source-file-property'
|
|
);
|
|
expect(instructions.models[0].definition).not.to.equal(undefined);
|
|
expect(instructions.models[0].sourceFile).to.equal(undefined);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('loads models defined in `models` only.', function(done) {
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
models: {
|
|
'some-model': {
|
|
dataSource: 'the-db',
|
|
},
|
|
},
|
|
modelDefinitions: [
|
|
{
|
|
definition: {
|
|
name: 'some-model',
|
|
},
|
|
},
|
|
{
|
|
definition: {
|
|
name: 'another-model',
|
|
},
|
|
},
|
|
],
|
|
dataSources: dataSources,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.models.map(getNameProperty)).to.eql([
|
|
'some-model',
|
|
]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('from directory', function(done) {
|
|
it('loads config files', function(done) {
|
|
boot.compile(SIMPLE_APP, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.eql({
|
|
name: 'User',
|
|
config: {
|
|
dataSource: 'db',
|
|
},
|
|
definition: undefined,
|
|
sourceFile: undefined,
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('merges datasource configs from multiple files', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeConfigFileSync('datasources.local.json', {
|
|
db: {local: 'applied'},
|
|
});
|
|
|
|
var env = process.env.NODE_ENV || 'development';
|
|
appdir.writeConfigFileSync('datasources.' + env + '.json', {
|
|
db: {env: 'applied'},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var db = instructions.dataSources.db;
|
|
expect(db).to.have.property('local', 'applied');
|
|
expect(db).to.have.property('env', 'applied');
|
|
|
|
var expectedLoadOrder = ['local', 'env'];
|
|
var actualLoadOrder = Object.keys(db).filter(function(k) {
|
|
return expectedLoadOrder.indexOf(k) !== -1;
|
|
});
|
|
|
|
expect(actualLoadOrder, 'load order').to.eql(expectedLoadOrder);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports .js for custom datasource config files', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeFileSync(
|
|
'datasources.local.js',
|
|
'module.exports = { db: { fromJs: true } };'
|
|
);
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var db = instructions.dataSources.db;
|
|
expect(db).to.have.property('fromJs', true);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('merges new Object values', function(done) {
|
|
var objectValue = {key: 'value'};
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeConfigFileSync('datasources.local.json', {
|
|
db: {nested: objectValue},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var db = instructions.dataSources.db;
|
|
expect(db).to.have.property('nested');
|
|
expect(db.nested).to.eql(objectValue);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('deeply merges Object values', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{
|
|
email: {
|
|
transport: {
|
|
host: 'localhost',
|
|
},
|
|
},
|
|
}
|
|
);
|
|
|
|
appdir.writeConfigFileSync('datasources.local.json', {
|
|
email: {
|
|
transport: {
|
|
host: 'mail.example.com',
|
|
},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
var email = instructions.dataSources.email;
|
|
expect(email.transport.host).to.equal('mail.example.com');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('deeply merges Array values of the same length', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{
|
|
rest: {
|
|
operations: [
|
|
{
|
|
template: {
|
|
method: 'POST',
|
|
url: 'http://localhost:12345',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('datasources.local.json', {
|
|
rest: {
|
|
operations: [
|
|
{
|
|
template: {
|
|
url: 'http://api.example.com',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var rest = instructions.dataSources.rest;
|
|
expect(rest.operations[0].template).to.eql({
|
|
method: 'POST', // the value from datasources.json
|
|
url: 'http://api.example.com', // overriden in datasources.local.json
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('merges Array properties', function(done) {
|
|
var arrayValue = ['value'];
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeConfigFileSync('datasources.local.json', {
|
|
db: {nested: arrayValue},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var db = instructions.dataSources.db;
|
|
expect(db).to.have.property('nested');
|
|
expect(db.nested).to.eql(arrayValue);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('does not cache loaded values', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
'strong-error-handler': {params: {debug: false}},
|
|
});
|
|
appdir.writeConfigFileSync('middleware.development.json', {
|
|
'strong-error-handler': {params: {debug: true}},
|
|
});
|
|
|
|
// Here we load main config and merge it with DEV overrides
|
|
var bootOptions = {
|
|
appRootDir: appdir.PATH,
|
|
env: 'development',
|
|
phases: ['load'],
|
|
};
|
|
var productionBootOptions = {
|
|
appRootDir: appdir.PATH,
|
|
env: 'production',
|
|
phases: ['load'],
|
|
};
|
|
boot.compile(bootOptions, function(err, context) {
|
|
var config = context.configurations.middleware;
|
|
expect(
|
|
config['strong-error-handler'].params.debug,
|
|
'debug in development'
|
|
).to.equal(true);
|
|
|
|
boot.compile(productionBootOptions, function(err, context2) {
|
|
var config = context2.configurations.middleware;
|
|
expect(
|
|
config['strong-error-handler'].params.debug,
|
|
'debug in production'
|
|
).to.equal(false);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
it('allows env specific model-config json', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeConfigFileSync('model-config.local.json', {
|
|
foo: {dataSource: 'db'},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.have.property('name', 'foo');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('allows env specific model-config json to be merged', function(done) {
|
|
appdir.createConfigFilesSync(null, null, {
|
|
foo: {dataSource: 'mongo', public: false},
|
|
});
|
|
appdir.writeConfigFileSync('model-config.local.json', {
|
|
foo: {dataSource: 'db'},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.have.property('name', 'foo');
|
|
expect(instructions.models[0].config).to.eql({
|
|
dataSource: 'db',
|
|
public: false,
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('allows env specific model-config js', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeFileSync(
|
|
'model-config.local.js',
|
|
"module.exports = { foo: { dataSource: 'db' } };"
|
|
);
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.have.property('name', 'foo');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('refuses to merge Array properties of different length', function(done) {
|
|
appdir.createConfigFilesSync({
|
|
nest: {
|
|
array: [],
|
|
},
|
|
});
|
|
|
|
appdir.writeConfigFileSync('config.local.json', {
|
|
nest: {
|
|
array: [
|
|
{
|
|
key: 'value',
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
expectCompileToThrow(
|
|
/array values of different length.*nest\.array/,
|
|
done
|
|
);
|
|
});
|
|
|
|
it('refuses to merge Array of different length in Array', function(done) {
|
|
appdir.createConfigFilesSync({
|
|
key: [[]],
|
|
});
|
|
|
|
appdir.writeConfigFileSync('config.local.json', {
|
|
key: [['value']],
|
|
});
|
|
|
|
expectCompileToThrow(/array values of different length.*key\[0\]/, done);
|
|
});
|
|
|
|
it('returns full key of an incorrect Array value', function(done) {
|
|
appdir.createConfigFilesSync({
|
|
toplevel: [
|
|
{
|
|
nested: [],
|
|
},
|
|
],
|
|
});
|
|
|
|
appdir.writeConfigFileSync('config.local.json', {
|
|
toplevel: [
|
|
{
|
|
nested: ['value'],
|
|
},
|
|
],
|
|
});
|
|
|
|
expectCompileToThrow(
|
|
/array values of different length.*toplevel\[0\]\.nested/,
|
|
done
|
|
);
|
|
});
|
|
|
|
it('refuses to merge incompatible object properties', function(done) {
|
|
appdir.createConfigFilesSync({
|
|
key: [],
|
|
});
|
|
appdir.writeConfigFileSync('config.local.json', {
|
|
key: {},
|
|
});
|
|
|
|
expectCompileToThrow(/incompatible types.*key/, done);
|
|
});
|
|
|
|
it('refuses to merge incompatible array items', function(done) {
|
|
appdir.createConfigFilesSync({
|
|
key: [[]],
|
|
});
|
|
appdir.writeConfigFileSync('config.local.json', {
|
|
key: [{}],
|
|
});
|
|
|
|
expectCompileToThrow(/incompatible types.*key\[0\]/, done);
|
|
});
|
|
|
|
it('merges app configs from multiple files', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
|
|
appdir.writeConfigFileSync('config.local.json', {cfgLocal: 'applied'});
|
|
|
|
var env = process.env.NODE_ENV || 'development';
|
|
appdir.writeConfigFileSync('config.' + env + '.json', {
|
|
cfgEnv: 'applied',
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
var appConfig = instructions.application;
|
|
|
|
expect(appConfig).to.have.property('cfgLocal', 'applied');
|
|
expect(appConfig).to.have.property('cfgEnv', 'applied');
|
|
|
|
var expectedLoadOrder = ['cfgLocal', 'cfgEnv'];
|
|
var actualLoadOrder = Object.keys(appConfig).filter(function(k) {
|
|
return expectedLoadOrder.indexOf(k) !== -1;
|
|
});
|
|
|
|
expect(actualLoadOrder, 'load order').to.eql(expectedLoadOrder);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports .js for custom app config files', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeFileSync(
|
|
'config.local.js',
|
|
'module.exports = { fromJs: true };'
|
|
);
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
var appConfig = instructions.application;
|
|
|
|
expect(appConfig).to.have.property('fromJs', true);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports `appConfigRootDir` option', function(done) {
|
|
appdir.createConfigFilesSync({port: 3000});
|
|
|
|
var customDir = path.resolve(appdir.PATH, 'custom');
|
|
fs.mkdirsSync(customDir);
|
|
fs.renameSync(
|
|
path.resolve(appdir.PATH, 'config.json'),
|
|
path.resolve(customDir, 'config.json')
|
|
);
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
appConfigRootDir: path.resolve(appdir.PATH, 'custom'),
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.application).to.have.property('port');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('supports `dsRootDir` option', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
|
|
var customDir = path.resolve(appdir.PATH, 'custom');
|
|
fs.mkdirsSync(customDir);
|
|
fs.renameSync(
|
|
path.resolve(appdir.PATH, 'datasources.json'),
|
|
path.resolve(customDir, 'datasources.json')
|
|
);
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
dsRootDir: path.resolve(appdir.PATH, 'custom'),
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.dataSources).to.have.property('db');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('supports `modelsRootDir` option', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeConfigFileSync('custom/model-config.json', {
|
|
foo: {dataSource: 'db'},
|
|
});
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
modelsRootDir: path.resolve(appdir.PATH, 'custom'),
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.have.property('name', 'foo');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('includes boot/*.js scripts', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync(
|
|
'boot/init.js',
|
|
'module.exports = function(app) { app.fnCalled = true; };'
|
|
);
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports `bootDirs` option', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync(
|
|
'custom-boot/init.js',
|
|
'module.exports = function(app) { app.fnCalled = true; };'
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootDirs: [path.dirname(initJs)],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should resolve relative path in `bootDirs`', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync(
|
|
'custom-boot/init.js',
|
|
'module.exports = function(app) { app.fnCalled = true; };'
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootDirs: ['./custom-boot'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should resolve non-relative path in `bootDirs`', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync('custom-boot/init.js', '');
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootDirs: ['custom-boot'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('ignores index.js in `bootDirs`', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeFileSync('custom-boot/index.js', '');
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootDirs: ['./custom-boot'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.have.length(0);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('prefers coffeescript over json in `appRootDir/bootDir`',
|
|
function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var coffee = appdir.writeFileSync('./custom-boot/init.coffee', '');
|
|
appdir.writeFileSync('./custom-boot/init.json', {});
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootDirs: ['./custom-boot'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([coffee]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('prefers coffeescript over json in `bootDir` non-relative path',
|
|
function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var coffee = appdir.writeFileSync('custom-boot/init.coffee', '');
|
|
appdir.writeFileSync('custom-boot/init.json', '');
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootDirs: ['custom-boot'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([coffee]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('supports `bootScripts` option', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync(
|
|
'custom-boot/init.js',
|
|
'module.exports = function(app) { app.fnCalled = true; };'
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootScripts: [initJs],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should remove duplicate scripts', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync(
|
|
'custom-boot/init.js',
|
|
'module.exports = function(app) { app.fnCalled = true; };'
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootDirs: [path.dirname(initJs)],
|
|
bootScripts: [initJs],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should resolve relative path in `bootScripts`', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync(
|
|
'custom-boot/init.js',
|
|
'module.exports = function(app) { app.fnCalled = true; };'
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootScripts: ['./custom-boot/init.js'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should resolve non-relative path in `bootScripts`', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync('custom-boot/init.js', '');
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootScripts: ['custom-boot/init.js'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('resolves missing extensions in `bootScripts`', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync('custom-boot/init.js', '');
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootScripts: ['./custom-boot/init'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('resolves missing extensions in `bootScripts` in module relative path',
|
|
function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync('node_modules/custom-boot/init.js',
|
|
'');
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootScripts: ['custom-boot/init'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('resolves module relative path for `bootScripts`', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var initJs = appdir.writeFileSync('node_modules/custom-boot/init.js', '');
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootScripts: ['custom-boot/init.js'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([initJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('explores `bootScripts` in app relative path', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
var appJs = appdir.writeFileSync('./custom-boot/init.js', '');
|
|
|
|
appdir.writeFileSync('node_modules/custom-boot/init.js', '');
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
bootScripts: ['custom-boot/init.js'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.bootScripts).to.eql([appJs]);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('ignores models/ subdirectory', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeFileSync('models/my-model.js', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.bootScripts).to.not.have.property('models');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('throws when models-config.json contains 1.x `properties`',
|
|
function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
foo: {properties: {name: 'string'}},
|
|
}
|
|
);
|
|
|
|
expectCompileToThrow(/unsupported 1\.x format/, done);
|
|
});
|
|
|
|
it('throws when model-config.json contains 1.x `options.base`',
|
|
function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Customer: {options: {base: 'User'}},
|
|
}
|
|
);
|
|
|
|
expectCompileToThrow(/unsupported 1\.x format/, done);
|
|
});
|
|
|
|
it('loads models from `./models`', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {name: 'Car'});
|
|
appdir.writeFileSync('models/car.js', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.eql({
|
|
name: 'Car',
|
|
config: {
|
|
dataSource: 'db',
|
|
},
|
|
definition: {
|
|
name: 'Car',
|
|
},
|
|
sourceFile: path.resolve(appdir.PATH, 'models', 'car.js'),
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('loads coffeescript models from `./models`', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {name: 'Car'});
|
|
appdir.writeFileSync('models/car.coffee', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.eql({
|
|
name: 'Car',
|
|
config: {
|
|
dataSource: 'db',
|
|
},
|
|
definition: {
|
|
name: 'Car',
|
|
},
|
|
sourceFile: path.resolve(appdir.PATH, 'models', 'car.coffee'),
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports `modelSources` option', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('custom-models/car.json', {name: 'Car'});
|
|
appdir.writeFileSync('custom-models/car.js', '');
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
modelSources: ['./custom-models'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.eql({
|
|
name: 'Car',
|
|
config: {
|
|
dataSource: 'db',
|
|
},
|
|
definition: {
|
|
name: 'Car',
|
|
},
|
|
sourceFile: path.resolve(appdir.PATH, 'custom-models', 'car.js'),
|
|
});
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('supports `sources` option in `model-config.json`', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
_meta: {
|
|
sources: ['./custom-models'],
|
|
},
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('custom-models/car.json', {name: 'Car'});
|
|
appdir.writeFileSync('custom-models/car.js', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.eql({
|
|
name: 'Car',
|
|
config: {
|
|
dataSource: 'db',
|
|
},
|
|
definition: {
|
|
name: 'Car',
|
|
},
|
|
sourceFile: path.resolve(appdir.PATH, 'custom-models', 'car.js'),
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports sources relative to node_modules', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
User: {dataSource: 'db'},
|
|
}
|
|
);
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
modelSources: [
|
|
'loopback/common/models',
|
|
'loopback/common/dir-does-not-exist',
|
|
],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0]).to.eql({
|
|
name: 'User',
|
|
config: {
|
|
dataSource: 'db',
|
|
},
|
|
definition: require('loopback/common/models/user.json'),
|
|
sourceFile: require.resolve('loopback/common/models/user.js'),
|
|
});
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('resolves relative path in `modelSources` option', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('custom-models/car.json', {name: 'Car'});
|
|
var appJS = appdir.writeFileSync('custom-models/car.js', '');
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
modelSources: ['./custom-models'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0].sourceFile).to.equal(appJS);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('resolves module relative path in `modelSources` option',
|
|
function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('node_modules/custom-models/car.json', {
|
|
name: 'Car',
|
|
});
|
|
var appJS = appdir.writeFileSync('node_modules/custom-models/car.js',
|
|
'');
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
modelSources: ['custom-models'],
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0].sourceFile).to.equal(appJS);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('resolves relative path in `sources` option in `model-config.json`',
|
|
function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
_meta: {
|
|
sources: ['./custom-models'],
|
|
},
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('custom-models/car.json', {name: 'Car'});
|
|
var appJS = appdir.writeFileSync('custom-models/car.js', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0].sourceFile).to.equal(appJS);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('resolves module relative path in `sources` option in model-config.json',
|
|
function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
_meta: {
|
|
sources: ['custom-models'],
|
|
},
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('node_modules/custom-models/car.json', {
|
|
name: 'Car',
|
|
});
|
|
|
|
var appJS = appdir.writeFileSync('node_modules/custom-models/car.js',
|
|
'');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.have.length(1);
|
|
expect(instructions.models[0].sourceFile).to.equal(appJS);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('handles model definitions with no code', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {name: 'Car'});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.eql([
|
|
{
|
|
name: 'Car',
|
|
config: {
|
|
dataSource: 'db',
|
|
},
|
|
definition: {
|
|
name: 'Car',
|
|
},
|
|
sourceFile: undefined,
|
|
},
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('excludes models not listed in `model-config.json`', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {name: 'Car'});
|
|
appdir.writeConfigFileSync('models/bar.json', {name: 'Bar'});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var models = instructions.models.map(getNameProperty);
|
|
expect(models).to.eql(['Car']);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('includes models used as Base models', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {
|
|
name: 'Car',
|
|
base: 'Vehicle',
|
|
});
|
|
appdir.writeConfigFileSync('models/vehicle.json', {
|
|
name: 'Vehicle',
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
var models = instructions.models;
|
|
var modelNames = models.map(getNameProperty);
|
|
|
|
expect(modelNames).to.eql(['Vehicle', 'Car']);
|
|
expect(models[0].config).to.equal(undefined);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('excludes pre-built base models', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {
|
|
name: 'Car',
|
|
base: 'Model',
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var modelNames = instructions.models.map(getNameProperty);
|
|
expect(modelNames).to.eql(['Car']);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('sorts models, base models first', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Vehicle: {dataSource: 'db'},
|
|
FlyingCar: {dataSource: 'db'},
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {
|
|
name: 'Car',
|
|
base: 'Vehicle',
|
|
});
|
|
appdir.writeConfigFileSync('models/vehicle.json', {
|
|
name: 'Vehicle',
|
|
});
|
|
appdir.writeConfigFileSync('models/flying-car.json', {
|
|
name: 'FlyingCar',
|
|
base: 'Car',
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var modelNames = instructions.models.map(getNameProperty);
|
|
expect(modelNames).to.eql(['Vehicle', 'Car', 'FlyingCar']);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('detects circular Model dependencies', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Vehicle: {dataSource: 'db'},
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {
|
|
name: 'Car',
|
|
base: 'Vehicle',
|
|
});
|
|
appdir.writeConfigFileSync('models/vehicle.json', {
|
|
name: 'Vehicle',
|
|
base: 'Car',
|
|
});
|
|
|
|
expectCompileToThrow(/cyclic dependency/i, done);
|
|
});
|
|
|
|
it('uses file name as default value for model name', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var modelNames = instructions.models.map(getNameProperty);
|
|
expect(modelNames).to.eql(['Car']);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('uses `OrderItem` as default model name for file with name `order-item`',
|
|
function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
OrderItem: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/order-item.json', {});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var modelNames = instructions.models.map(getNameProperty);
|
|
expect(modelNames).to.eql(['OrderItem']);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('uses `OrderItem` as default model name for file with name `order_item`',
|
|
function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
OrderItem: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/order_item.json', {});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var modelNames = instructions.models.map(getNameProperty);
|
|
expect(modelNames).to.eql(['OrderItem']);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('uses `OrderItem` as default model name for file with name `order item`',
|
|
function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
OrderItem: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/order item.json', {});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var modelNames = instructions.models.map(getNameProperty);
|
|
expect(modelNames).to.eql(['OrderItem']);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('overrides `default model name` by `name` in model definition',
|
|
function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
overrideCar: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {name: 'overrideCar'});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var modelNames = instructions.models.map(getNameProperty);
|
|
expect(modelNames).to.eql(['overrideCar']);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('overwrites model with same default name', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
OrderItem: {dataSource: 'db'},
|
|
}
|
|
);
|
|
|
|
appdir.writeConfigFileSync('models/order-item.json', {
|
|
properties: {
|
|
price: {type: 'number'},
|
|
},
|
|
});
|
|
appdir.writeFileSync('models/order-item.js', '');
|
|
|
|
appdir.writeConfigFileSync('models/orderItem.json', {
|
|
properties: {
|
|
quantity: {type: 'number'},
|
|
},
|
|
});
|
|
var appJS = appdir.writeFileSync('models/orderItem.js', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.eql([
|
|
{
|
|
name: 'OrderItem',
|
|
config: {
|
|
dataSource: 'db',
|
|
},
|
|
definition: {
|
|
name: 'OrderItem',
|
|
properties: {
|
|
quantity: {type: 'number'},
|
|
},
|
|
},
|
|
sourceFile: appJS,
|
|
},
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('overwrites model with same name in model definition', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
customOrder: {dataSource: 'db'},
|
|
}
|
|
);
|
|
|
|
appdir.writeConfigFileSync('models/order1.json', {
|
|
name: 'customOrder',
|
|
properties: {
|
|
price: {type: 'number'},
|
|
},
|
|
});
|
|
appdir.writeFileSync('models/order1.js', '');
|
|
|
|
appdir.writeConfigFileSync('models/order2.json', {
|
|
name: 'customOrder',
|
|
properties: {
|
|
quantity: {type: 'number'},
|
|
},
|
|
});
|
|
var appJS = appdir.writeFileSync('models/order2.js', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.models).to.eql([
|
|
{
|
|
name: 'customOrder',
|
|
config: {
|
|
dataSource: 'db',
|
|
},
|
|
definition: {
|
|
name: 'customOrder',
|
|
properties: {
|
|
quantity: {type: 'number'},
|
|
},
|
|
},
|
|
sourceFile: appJS,
|
|
},
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns a new copy of JSON data', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
instructions.application.modified = true;
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.application).to.not.have.property('modified');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('for mixins', function() {
|
|
describe(' - mixinDirs', function(done) {
|
|
function verifyMixinIsFoundViaMixinDirs(sourceFile, mixinDirs, done) {
|
|
var appJS = appdir.writeFileSync(sourceFile, '');
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
mixinDirs: mixinDirs,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.mixins[0].sourceFile).to.eql(appJS);
|
|
done();
|
|
}
|
|
);
|
|
}
|
|
|
|
it('supports `mixinDirs` option', function(done) {
|
|
verifyMixinIsFoundViaMixinDirs(
|
|
'custom-mixins/other.js',
|
|
['./custom-mixins'],
|
|
done
|
|
);
|
|
});
|
|
|
|
it('resolves relative path in `mixinDirs` option', function(done) {
|
|
verifyMixinIsFoundViaMixinDirs(
|
|
'custom-mixins/other.js',
|
|
['./custom-mixins'],
|
|
done
|
|
);
|
|
});
|
|
|
|
it('resolves module relative path in `mixinDirs` option',
|
|
function(done) {
|
|
verifyMixinIsFoundViaMixinDirs(
|
|
'node_modules/custom-mixins/other.js',
|
|
['custom-mixins'],
|
|
done
|
|
);
|
|
});
|
|
});
|
|
|
|
describe(' - mixinSources', function() {
|
|
beforeEach(function() {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
Car: {dataSource: 'db'},
|
|
}
|
|
);
|
|
appdir.writeConfigFileSync('models/car.json', {
|
|
name: 'Car',
|
|
mixins: {TimeStamps: {}},
|
|
});
|
|
});
|
|
|
|
function verifyMixinIsFoundViaMixinSources(
|
|
sourceFile,
|
|
mixinSources,
|
|
done
|
|
) {
|
|
var appJS = appdir.writeFileSync(sourceFile, '');
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
mixinSources: mixinSources,
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.mixins[0].sourceFile).to.eql(appJS);
|
|
done();
|
|
}
|
|
);
|
|
}
|
|
|
|
it('supports `mixinSources` option', function(done) {
|
|
verifyMixinIsFoundViaMixinSources(
|
|
'mixins/time-stamps.js',
|
|
['./mixins'],
|
|
done
|
|
);
|
|
});
|
|
|
|
it('resolves relative path in `mixinSources` option', function(done) {
|
|
verifyMixinIsFoundViaMixinSources(
|
|
'custom-mixins/time-stamps.js',
|
|
['./custom-mixins'],
|
|
done
|
|
);
|
|
});
|
|
|
|
it('resolves module relative path in `mixinSources` option',
|
|
function(done) {
|
|
verifyMixinIsFoundViaMixinSources(
|
|
'node_modules/custom-mixins/time-stamps.js',
|
|
['custom-mixins'],
|
|
done
|
|
);
|
|
});
|
|
|
|
it('supports `mixins` option in `model-config.json`', function(done) {
|
|
appdir.createConfigFilesSync(
|
|
{},
|
|
{},
|
|
{
|
|
_meta: {
|
|
mixins: ['./custom-mixins'],
|
|
},
|
|
Car: {
|
|
dataSource: 'db',
|
|
},
|
|
}
|
|
);
|
|
|
|
var appJS = appdir.writeFileSync('custom-mixins/time-stamps.js', '');
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.mixins[0].sourceFile).to.eql(appJS);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('sets by default `mixinSources` to `mixins` directory',
|
|
function(done) {
|
|
var appJS = appdir.writeFileSync('mixins/time-stamps.js', '');
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.mixins[0].sourceFile).to.eql(appJS);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('loads only mixins used by models', function(done) {
|
|
var appJS = appdir.writeFileSync('mixins/time-stamps.js', '');
|
|
appdir.writeFileSync('mixins/foo.js', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.mixins).to.have.length(1);
|
|
expect(instructions.mixins[0].sourceFile).to.eql(appJS);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('loads mixins from model using mixin name in JSON file',
|
|
function(done) {
|
|
var appJS = appdir.writeFileSync('mixins/time-stamps.js', '');
|
|
appdir.writeConfigFileSync('mixins/time-stamps.json', {
|
|
name: 'Timestamping',
|
|
});
|
|
|
|
appdir.writeConfigFileSync('models/car.json', {
|
|
name: 'Car',
|
|
mixins: {Timestamping: {}},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.mixins).to.have.length(1);
|
|
expect(instructions.mixins[0].sourceFile).to.eql(appJS);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('loads mixin only once for dirs common to mixinDirs & mixinSources',
|
|
function(done) {
|
|
var appJS = appdir.writeFileSync('custom-mixins/time-stamps.js',
|
|
'');
|
|
|
|
var options = {
|
|
appRootDir: appdir.PATH,
|
|
mixinDirs: ['./custom-mixins'],
|
|
mixinSources: ['./custom-mixins'],
|
|
};
|
|
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.mixins).to.have.length(1);
|
|
expect(instructions.mixins[0].sourceFile).to.eql(appJS);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('loads mixin from mixinSources, when it is also found in mixinDirs',
|
|
function(done) {
|
|
appdir.writeFileSync('mixinDir/time-stamps.js', '');
|
|
var appJS = appdir.writeFileSync('mixinSource/time-stamps.js', '');
|
|
|
|
var options = {
|
|
appRootDir: appdir.PATH,
|
|
mixinDirs: ['./mixinDir'],
|
|
mixinSources: ['./mixinSource'],
|
|
};
|
|
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.mixins).to.have.length(1);
|
|
expect(instructions.mixins[0].sourceFile).to.eql(appJS);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('loads mixin from the most recent mixin definition', function(done) {
|
|
appdir.writeFileSync('mixins1/time-stamps.js', '');
|
|
var mixins2 = appdir.writeFileSync('mixins2/time-stamps.js', '');
|
|
|
|
var options = {
|
|
appRootDir: appdir.PATH,
|
|
mixinSources: ['./mixins1', './mixins2'],
|
|
};
|
|
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.mixins).to.have.length(1);
|
|
expect(instructions.mixins[0].sourceFile).to.eql(mixins2);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('name normalization', function() {
|
|
var options;
|
|
beforeEach(function() {
|
|
options = {appRootDir: appdir.PATH, mixinDirs: ['./custom-mixins']};
|
|
|
|
appdir.writeFileSync('custom-mixins/foo.js', '');
|
|
appdir.writeFileSync('custom-mixins/time-stamps.js', '');
|
|
appdir.writeFileSync('custom-mixins/camelCase.js', '');
|
|
appdir.writeFileSync('custom-mixins/PascalCase.js', '');
|
|
appdir.writeFileSync('custom-mixins/space name.js', '');
|
|
});
|
|
|
|
it('supports classify', function(done) {
|
|
options.normalization = 'classify';
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var mixins = instructions.mixins;
|
|
var mixinNames = mixins.map(getNameProperty);
|
|
|
|
expect(mixinNames).to.eql([
|
|
'CamelCase',
|
|
'Foo',
|
|
'PascalCase',
|
|
'SpaceName',
|
|
'TimeStamps',
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports dasherize', function(done) {
|
|
options.normalization = 'dasherize';
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var mixins = instructions.mixins;
|
|
var mixinNames = mixins.map(getNameProperty);
|
|
|
|
expect(mixinNames).to.eql([
|
|
'camel-case',
|
|
'foo',
|
|
'pascal-case',
|
|
'space-name',
|
|
'time-stamps',
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports custom function', function(done) {
|
|
var normalize = function(name) {
|
|
return name.toUpperCase();
|
|
};
|
|
options.normalization = normalize;
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var mixins = instructions.mixins;
|
|
var mixinNames = mixins.map(getNameProperty);
|
|
|
|
expect(mixinNames).to.eql([
|
|
'CAMELCASE',
|
|
'FOO',
|
|
'PASCALCASE',
|
|
'SPACE NAME',
|
|
'TIME-STAMPS',
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports none', function(done) {
|
|
options.normalization = 'none';
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var mixins = instructions.mixins;
|
|
var mixinNames = mixins.map(getNameProperty);
|
|
|
|
expect(mixinNames).to.eql([
|
|
'camelCase',
|
|
'foo',
|
|
'PascalCase',
|
|
'space name',
|
|
'time-stamps',
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports false', function(done) {
|
|
options.normalization = false;
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var mixins = instructions.mixins;
|
|
var mixinNames = mixins.map(getNameProperty);
|
|
|
|
expect(mixinNames).to.eql([
|
|
'camelCase',
|
|
'foo',
|
|
'PascalCase',
|
|
'space name',
|
|
'time-stamps',
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('defaults to classify', function(done) {
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var mixins = instructions.mixins;
|
|
var mixinNames = mixins.map(getNameProperty);
|
|
|
|
expect(mixinNames).to.eql([
|
|
'CamelCase',
|
|
'Foo',
|
|
'PascalCase',
|
|
'SpaceName',
|
|
'TimeStamps',
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('throws error for invalid normalization format', function(done) {
|
|
options.normalization = 'invalidFormat';
|
|
|
|
expectCompileToThrow(
|
|
/Invalid normalization format - "invalidFormat"/,
|
|
options,
|
|
done
|
|
);
|
|
});
|
|
});
|
|
|
|
it('overrides default mixin name, by `name` in JSON', function(done) {
|
|
appdir.writeFileSync('mixins/foo.js', '');
|
|
appdir.writeConfigFileSync('mixins/foo.json', {name: 'fooBar'});
|
|
|
|
var options = {
|
|
appRootDir: appdir.PATH,
|
|
mixinDirs: ['./mixins'],
|
|
};
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.mixins[0].name).to.eql('fooBar');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('extends definition from JSON with same file name', function(done) {
|
|
var appJS = appdir.writeFileSync('custom-mixins/foo-bar.js', '');
|
|
|
|
appdir.writeConfigFileSync('custom-mixins/foo-bar.json', {
|
|
description: 'JSON file name same as JS file name',
|
|
});
|
|
appdir.writeConfigFileSync('custom-mixins/FooBar.json', {
|
|
description: 'JSON file name same as normalized name of mixin',
|
|
});
|
|
|
|
var options = {
|
|
appRootDir: appdir.PATH,
|
|
mixinDirs: ['./custom-mixins'],
|
|
normalization: 'classify',
|
|
};
|
|
boot.compile(options, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.mixins).to.eql([
|
|
{
|
|
name: 'FooBar',
|
|
description: 'JSON file name same as JS file name',
|
|
sourceFile: appJS,
|
|
},
|
|
]);
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('for middleware', function() {
|
|
function testMiddlewareRegistration(middlewareId, sourceFile, done) {
|
|
var json = {
|
|
initial: {},
|
|
custom: {},
|
|
};
|
|
|
|
json.custom[middlewareId] = {
|
|
params: 'some-config-data',
|
|
};
|
|
|
|
appdir.writeConfigFileSync('middleware.json', json);
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware).to.eql({
|
|
phases: ['initial', 'custom'],
|
|
middleware: [
|
|
{
|
|
sourceFile: sourceFile,
|
|
config: {
|
|
phase: 'custom',
|
|
params: 'some-config-data',
|
|
},
|
|
},
|
|
],
|
|
});
|
|
done();
|
|
});
|
|
}
|
|
|
|
var sourceFileForUrlNotFound;
|
|
beforeEach(function() {
|
|
fs.copySync(SIMPLE_APP, appdir.PATH);
|
|
sourceFileForUrlNotFound = require.resolve(
|
|
'loopback/server/middleware/url-not-found'
|
|
);
|
|
});
|
|
|
|
it('emits middleware instructions', function(done) {
|
|
testMiddlewareRegistration(
|
|
'loopback/server/middleware/url-not-found',
|
|
sourceFileForUrlNotFound,
|
|
done
|
|
);
|
|
});
|
|
|
|
it('emits middleware instructions for fragment', function(done) {
|
|
testMiddlewareRegistration(
|
|
'loopback#url-not-found',
|
|
sourceFileForUrlNotFound,
|
|
done
|
|
);
|
|
});
|
|
|
|
it('supports `middlewareRootDir` option', function(done) {
|
|
var middlewareJson = {
|
|
initial: {},
|
|
custom: {
|
|
'loopback/server/middleware/url-not-found': {
|
|
params: 'some-config-data',
|
|
},
|
|
},
|
|
};
|
|
var customDir = path.resolve(appdir.PATH, 'custom');
|
|
fs.mkdirsSync(customDir);
|
|
fs.writeJsonSync(
|
|
path.resolve(customDir, 'middleware.json'),
|
|
middlewareJson
|
|
);
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
middlewareRootDir: customDir,
|
|
},
|
|
function(err, context) {
|
|
var instructions = context.instructions;
|
|
expect(instructions.middleware).to.eql({
|
|
phases: ['initial', 'custom'],
|
|
middleware: [
|
|
{
|
|
sourceFile: sourceFileForUrlNotFound,
|
|
config: {
|
|
phase: 'custom',
|
|
params: 'some-config-data',
|
|
},
|
|
},
|
|
],
|
|
});
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('fails when a module middleware cannot be resolved', function(done) {
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
final: {
|
|
'loopback/path-does-not-exist': {},
|
|
},
|
|
});
|
|
|
|
expectCompileToThrow(/path-does-not-exist/, done);
|
|
});
|
|
|
|
it('does not fail when an optional middleware cannot be resolved',
|
|
function(done) {
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
final: {
|
|
'loopback/path-does-not-exist': {
|
|
optional: 'this middleware is optional',
|
|
},
|
|
},
|
|
});
|
|
|
|
expectCompileToNotThrow(done);
|
|
});
|
|
|
|
it('fails when a module middleware fragment cannot be resolved',
|
|
function(done) {
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
final: {
|
|
'loopback#path-does-not-exist': {},
|
|
},
|
|
});
|
|
|
|
expectCompileToThrow(/path-does-not-exist/, done);
|
|
});
|
|
|
|
it('does not fail when an optional middleware fragment cannot be resolved',
|
|
function(done) {
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
final: {
|
|
'loopback#path-does-not-exist': {
|
|
optional: 'this middleware is optional',
|
|
},
|
|
},
|
|
});
|
|
|
|
expectCompileToNotThrow(done);
|
|
});
|
|
|
|
it('resolves paths relatively to appRootDir', function(done) {
|
|
appdir.writeFileSync('my-middleware.js', '');
|
|
appdir.writeConfigFileSync('./middleware.json', {
|
|
routes: {
|
|
// resolves to ./my-middleware.js
|
|
'./my-middleware': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware).to.eql({
|
|
phases: ['routes'],
|
|
middleware: [
|
|
{
|
|
sourceFile: path.resolve(appdir.PATH, 'my-middleware.js'),
|
|
config: {phase: 'routes'},
|
|
},
|
|
],
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('merges config.params', function(done) {
|
|
appdir.writeConfigFileSync('./middleware.json', {
|
|
routes: {
|
|
'./middleware': {
|
|
params: {
|
|
key: 'initial value',
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
appdir.writeConfigFileSync('./middleware.local.json', {
|
|
routes: {
|
|
'./middleware': {
|
|
params: {
|
|
key: 'custom value',
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expectFirstMiddlewareParams(instructions).to.eql({
|
|
key: 'custom value',
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('merges config.enabled', function(done) {
|
|
appdir.writeConfigFileSync('./middleware.json', {
|
|
routes: {
|
|
'./middleware': {
|
|
params: {
|
|
key: 'initial value',
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
appdir.writeConfigFileSync('./middleware.local.json', {
|
|
routes: {
|
|
'./middleware': {
|
|
enabled: false,
|
|
},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware[0].config).to.have.property(
|
|
'enabled',
|
|
false
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
function verifyMiddlewareConfig(done) {
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware).to.eql([
|
|
{
|
|
sourceFile: path.resolve(appdir.PATH, 'middleware'),
|
|
config: {
|
|
phase: 'routes',
|
|
params: {
|
|
key: 'initial value',
|
|
},
|
|
},
|
|
},
|
|
{
|
|
sourceFile: path.resolve(appdir.PATH, 'middleware'),
|
|
config: {
|
|
phase: 'routes',
|
|
params: {
|
|
key: 'custom value',
|
|
},
|
|
},
|
|
},
|
|
]);
|
|
done();
|
|
});
|
|
}
|
|
|
|
it('merges config.params array to array', function(done) {
|
|
appdir.writeConfigFileSync('./middleware.json', {
|
|
routes: {
|
|
'./middleware': [
|
|
{
|
|
params: {
|
|
key: 'initial value',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
appdir.writeConfigFileSync('./middleware.local.json', {
|
|
routes: {
|
|
'./middleware': [
|
|
{
|
|
params: {
|
|
key: 'custom value',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
verifyMiddlewareConfig(done);
|
|
});
|
|
|
|
it('merges config.params array to object', function(done) {
|
|
appdir.writeConfigFileSync('./middleware.json', {
|
|
routes: {
|
|
'./middleware': {
|
|
params: {
|
|
key: 'initial value',
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
appdir.writeConfigFileSync('./middleware.local.json', {
|
|
routes: {
|
|
'./middleware': [
|
|
{
|
|
params: {
|
|
key: 'custom value',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
verifyMiddlewareConfig(done);
|
|
});
|
|
|
|
it('merges config.params object to array', function(done) {
|
|
appdir.writeConfigFileSync('./middleware.json', {
|
|
routes: {
|
|
'./middleware': [
|
|
{
|
|
params: {
|
|
key: 'initial value',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
appdir.writeConfigFileSync('./middleware.local.json', {
|
|
routes: {
|
|
'./middleware': {
|
|
params: {
|
|
key: 'custom value',
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
verifyMiddlewareConfig(done);
|
|
});
|
|
|
|
it('merges config.params array to empty object', function(done) {
|
|
appdir.writeConfigFileSync('./middleware.json', {
|
|
routes: {
|
|
'./middleware': {},
|
|
},
|
|
});
|
|
|
|
appdir.writeConfigFileSync('./middleware.local.json', {
|
|
routes: {
|
|
'./middleware': [
|
|
{
|
|
params: {
|
|
key: 'custom value',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware).to.eql([
|
|
{
|
|
sourceFile: path.resolve(appdir.PATH, 'middleware'),
|
|
config: {
|
|
phase: 'routes',
|
|
params: {
|
|
key: 'custom value',
|
|
},
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
done();
|
|
});
|
|
|
|
it('merges config.params array to array by name', function(done) {
|
|
appdir.writeConfigFileSync('./middleware.json', {
|
|
routes: {
|
|
'./middleware': [
|
|
{
|
|
name: 'a',
|
|
params: {
|
|
key: 'initial value',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
appdir.writeConfigFileSync('./middleware.local.json', {
|
|
routes: {
|
|
'./middleware': [
|
|
{
|
|
name: 'a',
|
|
params: {
|
|
key: 'custom value',
|
|
},
|
|
},
|
|
{
|
|
params: {
|
|
key: '2nd value',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware).to.eql([
|
|
{
|
|
sourceFile: path.resolve(appdir.PATH, 'middleware'),
|
|
config: {
|
|
name: 'a',
|
|
phase: 'routes',
|
|
params: {
|
|
key: 'custom value',
|
|
},
|
|
},
|
|
},
|
|
{
|
|
sourceFile: path.resolve(appdir.PATH, 'middleware'),
|
|
config: {
|
|
phase: 'routes',
|
|
params: {
|
|
key: '2nd value',
|
|
},
|
|
},
|
|
},
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('flattens sub-phases', function(done) {
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
'initial:after': {},
|
|
'custom:before': {
|
|
'loopback/server/middleware/url-not-found': {
|
|
params: 'some-config-data',
|
|
},
|
|
},
|
|
'custom:after': {},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.phases, 'phases').to.eql([
|
|
'initial',
|
|
'custom',
|
|
]);
|
|
expect(instructions.middleware.middleware, 'middleware').to.eql([
|
|
{
|
|
sourceFile: require.resolve(
|
|
'loopback/server/middleware/url-not-found'
|
|
),
|
|
config: {
|
|
phase: 'custom:before',
|
|
params: 'some-config-data',
|
|
},
|
|
},
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports multiple instances of the same middleware', function(done) {
|
|
appdir.writeFileSync('my-middleware.js', '');
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
final: {
|
|
'./my-middleware': [
|
|
{
|
|
params: 'first',
|
|
},
|
|
{
|
|
params: 'second',
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware).to.eql([
|
|
{
|
|
sourceFile: path.resolve(appdir.PATH, 'my-middleware.js'),
|
|
config: {
|
|
phase: 'final',
|
|
params: 'first',
|
|
},
|
|
},
|
|
{
|
|
sourceFile: path.resolve(appdir.PATH, 'my-middleware.js'),
|
|
config: {
|
|
phase: 'final',
|
|
params: 'second',
|
|
},
|
|
},
|
|
]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports shorthand notation for middleware paths', function(done) {
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
final: {
|
|
'loopback#url-not-found': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware[0].sourceFile).to.equal(
|
|
require.resolve('loopback/server/middleware/url-not-found')
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports shorthand notation for relative paths', function(done) {
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
routes: {
|
|
'./middleware/index#myMiddleware': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware[0].sourceFile).to.equal(
|
|
path.resolve(appdir.PATH, './middleware/index.js')
|
|
);
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'fragment',
|
|
'myMiddleware'
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports shorthand notation when the fragment name matches a property',
|
|
function(done) {
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
final: {
|
|
'loopback#errorHandler': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'sourceFile',
|
|
pathWithoutIndex(require.resolve('loopback'))
|
|
);
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'fragment',
|
|
'errorHandler'
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('resolves modules relative to appRootDir', function(done) {
|
|
var HANDLER_FILE = 'node_modules/handler/index.js';
|
|
appdir.writeFileSync(
|
|
HANDLER_FILE,
|
|
'module.exports = function(req, res, next) { next(); }'
|
|
);
|
|
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
initial: {
|
|
handler: {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'sourceFile',
|
|
pathWithoutIndex(appdir.resolve(HANDLER_FILE))
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('prefers appRootDir over node_modules for middleware', function(done) {
|
|
var appJS = appdir.writeFileSync('./my-middleware.js', '');
|
|
appdir.writeFileSync('node_modules/my-middleware.js', '');
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
routes: {
|
|
'./my-middleware': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware).to.have.length(1);
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'sourceFile',
|
|
appJS
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('does not treat module relative path as `appRootDir` relative',
|
|
function(done) {
|
|
appdir.writeFileSync('./my-middleware.js', '');
|
|
var moduleJS = appdir.writeFileSync('node_modules/my-middleware.js',
|
|
'');
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
routes: {
|
|
'my-middleware': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware).to.have.length(1);
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'sourceFile',
|
|
moduleJS
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('loads middleware from coffeescript in appRootdir', function(done) {
|
|
var coffee = appdir.writeFileSync('my-middleware.coffee', '');
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
routes: {
|
|
'./my-middleware': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'sourceFile',
|
|
coffee
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('loads coffeescript from middleware under node_modules', function(done) {
|
|
var file = appdir.writeFileSync(
|
|
'node_modules/my-middleware/index.coffee',
|
|
''
|
|
);
|
|
appdir.writeFileSync('node_modules/my-middleware/index.json', '');
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
routes: {
|
|
'my-middleware': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware).to.have.length(1);
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'sourceFile',
|
|
pathWithoutIndex(file)
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('prefers coffeescript over json for relative middleware path',
|
|
function(done) {
|
|
var coffee = appdir.writeFileSync('my-middleware.coffee', '');
|
|
appdir.writeFileSync('my-middleware.json', '');
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
routes: {
|
|
'./my-middleware': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware).to.have.length(1);
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'sourceFile',
|
|
coffee
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('prefers coffeescript over json for module relative middleware path',
|
|
function(done) {
|
|
var coffee = appdir.writeFileSync(
|
|
'node_modules/my-middleware.coffee',
|
|
''
|
|
);
|
|
appdir.writeFileSync('node_modules/my-middleware.json', '');
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
routes: {
|
|
'my-middleware': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware).to.have.length(1);
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'sourceFile',
|
|
coffee
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('ignores sourcmap files when loading middleware', function(done) {
|
|
var middleware = appdir.writeFileSync(
|
|
'my-middleware.js',
|
|
'// I am the middleware'
|
|
);
|
|
var sourcemap = appdir.writeFileSync(
|
|
'my-middleware.js.map',
|
|
'// I am a sourcemap'
|
|
);
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
routes: {
|
|
'./my-middleware': {},
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.middleware.middleware[0]).have.property(
|
|
'sourceFile',
|
|
middleware
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
describe('config with relative paths in params', function() {
|
|
var RELATIVE_PATH_PARAMS = ['$!./here', '$!../there'];
|
|
|
|
var absolutePathParams;
|
|
beforeEach(function resolveRelativePathParams() {
|
|
absolutePathParams = RELATIVE_PATH_PARAMS.map(function(p) {
|
|
return appdir.resolve(p.slice(2));
|
|
});
|
|
});
|
|
|
|
it('converts paths in top-level array items', function(done) {
|
|
givenMiddlewareEntrySync({params: RELATIVE_PATH_PARAMS});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expectFirstMiddlewareParams(instructions).to.eql(absolutePathParams);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('converts paths in top-level object properties', function(done) {
|
|
givenMiddlewareEntrySync({
|
|
params: {
|
|
path: RELATIVE_PATH_PARAMS[0],
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expectFirstMiddlewareParams(instructions).to.eql({
|
|
path: absolutePathParams[0],
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('converts path value when params is a string', function(done) {
|
|
givenMiddlewareEntrySync({params: RELATIVE_PATH_PARAMS[0]});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expectFirstMiddlewareParams(instructions).to.eql(
|
|
absolutePathParams[0]
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('converts paths in nested properties', function(done) {
|
|
givenMiddlewareEntrySync({
|
|
params: {
|
|
nestedObject: {
|
|
path: RELATIVE_PATH_PARAMS[0],
|
|
},
|
|
nestedArray: RELATIVE_PATH_PARAMS,
|
|
},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expectFirstMiddlewareParams(instructions).to.eql({
|
|
nestedObject: {
|
|
path: absolutePathParams[0],
|
|
},
|
|
nestedArray: absolutePathParams,
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('does not convert values not starting with `./` or `../`',
|
|
function(done) {
|
|
var PARAMS = ['$!.somerc', '$!/root', '$!hello!'];
|
|
givenMiddlewareEntrySync({params: PARAMS});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expectFirstMiddlewareParams(instructions).to.eql(PARAMS);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('for components', function() {
|
|
it('loads component configs from multiple files', function(done) {
|
|
appdir.createConfigFilesSync();
|
|
appdir.writeConfigFileSync('component-config.json', {
|
|
debug: {option: 'value'},
|
|
});
|
|
appdir.writeConfigFileSync('component-config.local.json', {
|
|
debug: {local: 'applied'},
|
|
});
|
|
|
|
var env = process.env.NODE_ENV || 'development';
|
|
appdir.writeConfigFileSync('component-config.' + env + '.json', {
|
|
debug: {env: 'applied'},
|
|
});
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
var component = instructions.components[0];
|
|
expect(component).to.eql({
|
|
sourceFile: require.resolve('debug'),
|
|
config: {
|
|
option: 'value',
|
|
local: 'applied',
|
|
env: 'applied',
|
|
},
|
|
});
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('supports `componentRootDir` option', function(done) {
|
|
var componentJson = {
|
|
debug: {
|
|
option: 'value',
|
|
},
|
|
};
|
|
var customDir = path.resolve(appdir.PATH, 'custom');
|
|
fs.mkdirsSync(customDir);
|
|
fs.writeJsonSync(
|
|
path.resolve(customDir, 'component-config.json'),
|
|
componentJson
|
|
);
|
|
|
|
boot.compile(
|
|
{
|
|
appRootDir: appdir.PATH,
|
|
componentRootDir: path.resolve(appdir.PATH, 'custom'),
|
|
},
|
|
function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
var component = instructions.components[0];
|
|
expect(component).to.eql({
|
|
sourceFile: require.resolve('debug'),
|
|
config: {
|
|
option: 'value',
|
|
},
|
|
});
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('loads component relative to appRootDir', function(done) {
|
|
appdir.writeConfigFileSync('./component-config.json', {
|
|
'./index': {},
|
|
});
|
|
var appJS = appdir.writeConfigFileSync('index.js', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.components[0]).have.property('sourceFile', appJS);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('loads component relative to node modules', function(done) {
|
|
appdir.writeConfigFileSync('component-config.json', {
|
|
mycomponent: {},
|
|
});
|
|
var js = appdir.writeConfigFileSync(
|
|
'node_modules/mycomponent/index.js',
|
|
''
|
|
);
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
expect(instructions.components[0]).have.property('sourceFile', js);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('retains backward compatibility for non-relative path in `appRootDir`',
|
|
function(done) {
|
|
appdir.writeConfigFileSync('component-config.json', {
|
|
'my-component/component.js': {},
|
|
});
|
|
appdir.writeConfigFileSync('./my-component/component.js', '');
|
|
|
|
expectCompileToThrow(
|
|
'Cannot resolve path "my-component/component.js"',
|
|
done
|
|
);
|
|
});
|
|
|
|
it('prefers coffeescript over json for relative path component',
|
|
function(done) {
|
|
appdir.writeConfigFileSync('component-config.json', {
|
|
'./component': {},
|
|
});
|
|
|
|
var coffee = appdir.writeFileSync('component.coffee', '');
|
|
appdir.writeFileSync('component.json', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.components).to.have.length(1);
|
|
expect(instructions.components[0]).have.property(
|
|
'sourceFile',
|
|
coffee
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('prefers coffeescript over json for module relative component path',
|
|
function(done) {
|
|
appdir.writeConfigFileSync('component-config.json', {
|
|
component: {},
|
|
});
|
|
|
|
var coffee = appdir.writeFileSync('node_modules/component.coffee', '');
|
|
appdir.writeFileSync('node_modules/component.json', '');
|
|
|
|
boot.compile(appdir.PATH, function(err, context) {
|
|
if (err) return done(err);
|
|
var instructions = context.instructions;
|
|
|
|
expect(instructions.components).to.have.length(1);
|
|
expect(instructions.components[0]).have.property(
|
|
'sourceFile',
|
|
coffee
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
function getNameProperty(obj) {
|
|
return obj.name;
|
|
}
|
|
|
|
function givenMiddlewareEntrySync(config) {
|
|
appdir.writeConfigFileSync('middleware.json', {
|
|
initial: {
|
|
// resolves to ./middleware.json
|
|
'./middleware': config,
|
|
},
|
|
});
|
|
}
|
|
|
|
function expectFirstMiddlewareParams(instructions) {
|
|
return expect(instructions.middleware.middleware[0].config.params);
|
|
}
|
|
|
|
function pathWithoutExtension(value) {
|
|
return path.join(
|
|
path.dirname(value),
|
|
path.basename(value, path.extname(value))
|
|
);
|
|
}
|
|
|
|
function pathWithoutIndex(filePath) {
|
|
return filePath.replace(/[\\\/]index\.[^.]+$/, '');
|
|
}
|