mirror of
https://github.com/serverless/serverless.git
synced 2025-12-08 19:46:03 +00:00
71f1aa09cb
The change ensures that when a .js file exported function is executed, the original execution context is supplied in order to maintain "this".
1019 lines
36 KiB
JavaScript
1019 lines
36 KiB
JavaScript
'use strict';
|
|
|
|
const path = require('path');
|
|
const proxyquire = require('proxyquire');
|
|
const YAML = require('js-yaml');
|
|
const expect = require('chai').expect;
|
|
const Variables = require('../../lib/classes/Variables');
|
|
const Utils = require('../../lib/classes/Utils');
|
|
const Serverless = require('../../lib/Serverless');
|
|
const sinon = require('sinon');
|
|
const testUtils = require('../../tests/utils');
|
|
const slsError = require('./Error');
|
|
const AwsProvider = require('../plugins/aws/provider/awsProvider');
|
|
const BbPromise = require('bluebird');
|
|
const os = require('os');
|
|
|
|
describe('Variables', () => {
|
|
describe('#constructor()', () => {
|
|
const serverless = new Serverless();
|
|
|
|
it('should attach serverless instance', () => {
|
|
const variablesInstance = new Variables(serverless);
|
|
expect(typeof variablesInstance.serverless.version).to.be.equal('string');
|
|
});
|
|
|
|
it('should not set variableSyntax in constructor', () => {
|
|
const variablesInstance = new Variables(serverless);
|
|
expect(variablesInstance.variableSyntax).to.be.equal(undefined);
|
|
});
|
|
});
|
|
|
|
describe('#loadVariableSyntax()', () => {
|
|
it('should set variableSyntax', () => {
|
|
const serverless = new Serverless();
|
|
|
|
serverless.service.provider.variableSyntax = '\\${{([ :a-zA-Z0-9._,\\-\\/\\(\\)]+?)}}';
|
|
|
|
serverless.variables.loadVariableSyntax();
|
|
expect(serverless.variables.variableSyntax).to.be.a('RegExp');
|
|
});
|
|
});
|
|
|
|
describe('#populateService()', () => {
|
|
it('should call populateProperty method', () => {
|
|
const serverless = new Serverless();
|
|
|
|
const populatePropertyStub = sinon
|
|
.stub(serverless.variables, 'populateObject').resolves();
|
|
|
|
return serverless.variables.populateService().then(() => {
|
|
expect(populatePropertyStub.called).to.equal(true);
|
|
serverless.variables.populateObject.restore();
|
|
});
|
|
});
|
|
|
|
it('should use variableSyntax', () => {
|
|
const serverless = new Serverless();
|
|
|
|
const variableSyntax = '\\${{([ :a-zA-Z0-9._,\\-\\/\\(\\)]+?)}}';
|
|
const fooValue = '${clientId()}';
|
|
const barValue = 'test';
|
|
|
|
serverless.service.provider.variableSyntax = variableSyntax;
|
|
|
|
serverless.service.custom = {
|
|
var: barValue,
|
|
};
|
|
|
|
serverless.service.resources = {
|
|
foo: fooValue,
|
|
bar: '${{self:custom.var}}',
|
|
};
|
|
|
|
return serverless.variables.populateService().then(() => {
|
|
expect(serverless.service.provider.variableSyntax).to.equal(variableSyntax);
|
|
expect(serverless.service.resources.foo).to.equal(fooValue);
|
|
expect(serverless.service.resources.bar).to.equal(barValue);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#populateObject()', () => {
|
|
it('should call populateProperty method', () => {
|
|
const serverless = new Serverless();
|
|
const object = {
|
|
stage: '${opt:stage}',
|
|
};
|
|
|
|
const populatePropertyStub = sinon
|
|
.stub(serverless.variables, 'populateProperty').resolves('prod');
|
|
|
|
return serverless.variables.populateObject(object).then(() => {
|
|
expect(populatePropertyStub.called).to.equal(true);
|
|
serverless.variables.populateProperty.restore();
|
|
});
|
|
});
|
|
|
|
it('should populate object and return it', () => {
|
|
const serverless = new Serverless();
|
|
const object = {
|
|
stage: '${opt:stage}',
|
|
};
|
|
const expectedPopulatedObject = {
|
|
stage: 'prod',
|
|
};
|
|
|
|
sinon.stub(serverless.variables, 'populateProperty').resolves('prod');
|
|
|
|
return serverless.variables.populateObject(object).then(populatedObject => {
|
|
expect(populatedObject).to.deep.equal(expectedPopulatedObject);
|
|
serverless.variables.populateProperty.restore();
|
|
});
|
|
});
|
|
|
|
it('should persist keys with dot notation', () => {
|
|
const serverless = new Serverless();
|
|
const object = {
|
|
stage: '${opt:stage}',
|
|
};
|
|
object['some.nested.key'] = 'hello';
|
|
const expectedPopulatedObject = {
|
|
stage: 'prod',
|
|
};
|
|
expectedPopulatedObject['some.nested.key'] = 'hello';
|
|
|
|
const populatePropertyStub = sinon.stub(serverless.variables, 'populateProperty');
|
|
populatePropertyStub.onCall(0).resolves('prod');
|
|
populatePropertyStub.onCall(1).resolves('hello');
|
|
|
|
return serverless.variables.populateObject(object).then(populatedObject => {
|
|
expect(populatedObject).to.deep.equal(expectedPopulatedObject);
|
|
serverless.variables.populateProperty.restore();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#populateProperty()', () => {
|
|
it('should call overwrite if overwrite syntax provided', () => {
|
|
const serverless = new Serverless();
|
|
const property = 'my stage is ${opt:stage, self:provider.stage}';
|
|
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
const overwriteStub = sinon
|
|
.stub(serverless.variables, 'overwrite').resolves('dev');
|
|
const populateVariableStub = sinon
|
|
.stub(serverless.variables, 'populateVariable').resolves('my stage is dev');
|
|
|
|
return serverless.variables.populateProperty(property).then(newProperty => {
|
|
expect(overwriteStub.called).to.equal(true);
|
|
expect(populateVariableStub.called).to.equal(true);
|
|
expect(newProperty).to.equal('my stage is dev');
|
|
|
|
serverless.variables.overwrite.restore();
|
|
serverless.variables.populateVariable.restore();
|
|
return BbPromise.resolve();
|
|
});
|
|
});
|
|
|
|
it('should call getValueFromSource if no overwrite syntax provided', () => {
|
|
const serverless = new Serverless();
|
|
const property = 'my stage is ${opt:stage}';
|
|
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
const getValueFromSourceStub = sinon
|
|
.stub(serverless.variables, 'getValueFromSource').resolves('prod');
|
|
const populateVariableStub = sinon
|
|
.stub(serverless.variables, 'populateVariable')
|
|
.resolves('my stage is prod');
|
|
|
|
return serverless.variables.populateProperty(property).then(newProperty => {
|
|
expect(getValueFromSourceStub.called).to.equal(true);
|
|
expect(populateVariableStub.called).to.equal(true);
|
|
expect(newProperty).to.equal('my stage is prod');
|
|
|
|
serverless.variables.getValueFromSource.restore();
|
|
serverless.variables.populateVariable.restore();
|
|
return BbPromise.resolve();
|
|
});
|
|
});
|
|
|
|
it('should call populateObject if variable value is an object', () => {
|
|
const serverless = new Serverless();
|
|
serverless.variables.options = {
|
|
stage: 'prod',
|
|
};
|
|
const property = '${opt:stage}';
|
|
const variableValue = {
|
|
stage: '${opt:stage}',
|
|
};
|
|
const variableValuePopulated = {
|
|
stage: 'prod',
|
|
};
|
|
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
const populateObjectStub = sinon
|
|
.stub(serverless.variables, 'populateObject')
|
|
.resolves(variableValuePopulated);
|
|
const getValueFromSourceStub = sinon
|
|
.stub(serverless.variables, 'getValueFromSource')
|
|
.resolves(variableValue);
|
|
const populateVariableStub = sinon
|
|
.stub(serverless.variables, 'populateVariable')
|
|
.resolves(variableValuePopulated);
|
|
|
|
return serverless.variables.populateProperty(property).then(newProperty => {
|
|
expect(populateObjectStub.called).to.equal(true);
|
|
expect(getValueFromSourceStub.called).to.equal(true);
|
|
expect(populateVariableStub.called).to.equal(true);
|
|
expect(newProperty).to.deep.equal(variableValuePopulated);
|
|
|
|
serverless.variables.populateObject.restore();
|
|
serverless.variables.getValueFromSource.restore();
|
|
serverless.variables.populateVariable.restore();
|
|
return BbPromise.resolve();
|
|
});
|
|
});
|
|
|
|
it('should run recursively if nested variables provided', () => {
|
|
const serverless = new Serverless();
|
|
const property = 'my stage is ${env:${opt.name}}';
|
|
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
const getValueFromSourceStub = sinon
|
|
.stub(serverless.variables, 'getValueFromSource');
|
|
const populateVariableStub = sinon
|
|
.stub(serverless.variables, 'populateVariable');
|
|
|
|
getValueFromSourceStub.onCall(0).resolves('stage');
|
|
getValueFromSourceStub.onCall(1).resolves('dev');
|
|
populateVariableStub.onCall(0).resolves('my stage is ${env:stage}');
|
|
populateVariableStub.onCall(1).resolves('my stage is dev');
|
|
|
|
return serverless.variables.populateProperty(property).then(newProperty => {
|
|
expect(getValueFromSourceStub.callCount).to.equal(2);
|
|
expect(populateVariableStub.callCount).to.equal(2);
|
|
expect(newProperty).to.equal('my stage is dev');
|
|
|
|
serverless.variables.getValueFromSource.restore();
|
|
serverless.variables.populateVariable.restore();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#populateVariable()', () => {
|
|
it('should populate string variables as sub string', () => {
|
|
const serverless = new Serverless();
|
|
const valueToPopulate = 'dev';
|
|
const matchedString = '${opt:stage}';
|
|
const property = 'my stage is ${opt:stage}';
|
|
|
|
return serverless.variables.populateVariable(property, matchedString, valueToPopulate)
|
|
.then(newProperty => {
|
|
expect(newProperty).to.equal('my stage is dev');
|
|
});
|
|
});
|
|
|
|
it('should populate number variables as sub string', () => {
|
|
const serverless = new Serverless();
|
|
const valueToPopulate = 5;
|
|
const matchedString = '${opt:number}';
|
|
const property = 'your account number is ${opt:number}';
|
|
|
|
return serverless.variables.populateVariable(property, matchedString, valueToPopulate)
|
|
.then(newProperty => {
|
|
expect(newProperty).to.equal('your account number is 5');
|
|
});
|
|
});
|
|
|
|
it('should populate non string variables', () => {
|
|
const serverless = new Serverless();
|
|
const valueToPopulate = 5;
|
|
const matchedString = '${opt:number}';
|
|
const property = '${opt:number}';
|
|
|
|
return serverless.variables.populateVariable(property, matchedString, valueToPopulate)
|
|
.then(newProperty => {
|
|
expect(newProperty).to.equal(5);
|
|
});
|
|
});
|
|
|
|
it('should throw error if populating non string or non number variable as sub string', () => {
|
|
const serverless = new Serverless();
|
|
const valueToPopulate = {};
|
|
const matchedString = '${opt:object}';
|
|
const property = 'your account number is ${opt:object}';
|
|
expect(() => serverless.variables
|
|
.populateVariable(property, matchedString, valueToPopulate))
|
|
.to.throw(Error);
|
|
});
|
|
});
|
|
|
|
describe('#overwrite()', () => {
|
|
it('should overwrite undefined and null values', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromSourceStub = sinon
|
|
.stub(serverless.variables, 'getValueFromSource');
|
|
|
|
getValueFromSourceStub.onCall(0).resolves(undefined);
|
|
getValueFromSourceStub.onCall(1).resolves(null);
|
|
getValueFromSourceStub.onCall(2).resolves('variableValue');
|
|
|
|
return serverless.variables.overwrite('opt:stage,env:stage,self:provider.stage')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('variableValue');
|
|
expect(getValueFromSourceStub.callCount).to.equal(3);
|
|
serverless.variables.getValueFromSource.restore();
|
|
});
|
|
});
|
|
|
|
it('should overwrite empty object values', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromSourceStub = sinon
|
|
.stub(serverless.variables, 'getValueFromSource');
|
|
|
|
getValueFromSourceStub.onCall(0).resolves({});
|
|
getValueFromSourceStub.onCall(1).resolves('variableValue');
|
|
|
|
return serverless.variables.overwrite('opt:stage,env:stage').then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('variableValue');
|
|
expect(getValueFromSourceStub.callCount).to.equal(2);
|
|
serverless.variables.getValueFromSource.restore();
|
|
});
|
|
});
|
|
|
|
it('should not overwrite 0 values', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromSourceStub = sinon
|
|
.stub(serverless.variables, 'getValueFromSource');
|
|
|
|
getValueFromSourceStub.onCall(0).resolves(0);
|
|
getValueFromSourceStub.onCall(1).resolves('variableValue');
|
|
getValueFromSourceStub.onCall(2).resolves('variableValue2');
|
|
return serverless.variables.overwrite('opt:stage,env:stage,self:provider.stage')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal(0);
|
|
serverless.variables.getValueFromSource.restore();
|
|
});
|
|
});
|
|
|
|
it('should not overwrite false values', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromSourceStub = sinon
|
|
.stub(serverless.variables, 'getValueFromSource');
|
|
|
|
getValueFromSourceStub.onCall(0).resolves(false);
|
|
getValueFromSourceStub.onCall(1).resolves('variableValue');
|
|
getValueFromSourceStub.onCall(2).resolves('variableValue2');
|
|
|
|
return serverless.variables.overwrite('opt:stage,env:stage,self:provider.stage')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal(false);
|
|
serverless.variables.getValueFromSource.restore();
|
|
});
|
|
});
|
|
|
|
it('should skip getting values once a value has been found', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromSourceStub = sinon
|
|
.stub(serverless.variables, 'getValueFromSource');
|
|
|
|
getValueFromSourceStub.onCall(0).resolves(undefined);
|
|
getValueFromSourceStub.onCall(1).resolves('variableValue');
|
|
getValueFromSourceStub.onCall(2).resolves('variableValue2');
|
|
|
|
return serverless.variables.overwrite('opt:stage,env:stage,self:provider.stage')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('variableValue');
|
|
serverless.variables.getValueFromSource.restore();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#getValueFromSource()', () => {
|
|
it('should call getValueFromEnv if referencing env var', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromEnvStub = sinon
|
|
.stub(serverless.variables, 'getValueFromEnv').resolves('variableValue');
|
|
return serverless.variables.getValueFromSource('env:TEST_VAR')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('variableValue');
|
|
expect(getValueFromEnvStub.called).to.equal(true);
|
|
expect(getValueFromEnvStub.calledWith('env:TEST_VAR')).to.equal(true);
|
|
serverless.variables.getValueFromEnv.restore();
|
|
});
|
|
});
|
|
|
|
it('should call getValueFromOptions if referencing an option', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromOptionsStub = sinon
|
|
.stub(serverless.variables, 'getValueFromOptions')
|
|
.resolves('variableValue');
|
|
|
|
return serverless.variables.getValueFromSource('opt:stage')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('variableValue');
|
|
expect(getValueFromOptionsStub.called).to.equal(true);
|
|
expect(getValueFromOptionsStub.calledWith('opt:stage')).to.equal(true);
|
|
serverless.variables.getValueFromOptions.restore();
|
|
});
|
|
});
|
|
|
|
it('should call getValueFromSelf if referencing from self', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromSelfStub = sinon
|
|
.stub(serverless.variables, 'getValueFromSelf').resolves('variableValue');
|
|
|
|
return serverless.variables.getValueFromSource('self:provider')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('variableValue');
|
|
expect(getValueFromSelfStub.called).to.equal(true);
|
|
expect(getValueFromSelfStub.calledWith('self:provider')).to.equal(true);
|
|
serverless.variables.getValueFromSelf.restore();
|
|
});
|
|
});
|
|
|
|
it('should call getValueFromFile if referencing from another file', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromFileStub = sinon
|
|
.stub(serverless.variables, 'getValueFromFile').resolves('variableValue');
|
|
|
|
return serverless.variables.getValueFromSource('file(./config.yml)')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('variableValue');
|
|
expect(getValueFromFileStub.called).to.equal(true);
|
|
expect(getValueFromFileStub.calledWith('file(./config.yml)')).to.equal(true);
|
|
serverless.variables.getValueFromFile.restore();
|
|
});
|
|
});
|
|
|
|
it('should call getValueFromCf if referencing CloudFormation Outputs', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromCfStub = sinon
|
|
.stub(serverless.variables, 'getValueFromCf').resolves('variableValue');
|
|
return serverless.variables.getValueFromSource('cf:test-stack.testOutput')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('variableValue');
|
|
expect(getValueFromCfStub.called).to.equal(true);
|
|
expect(getValueFromCfStub.calledWith('cf:test-stack.testOutput')).to.equal(true);
|
|
serverless.variables.getValueFromCf.restore();
|
|
});
|
|
});
|
|
|
|
it('should call getValueFromS3 if referencing variable in S3', () => {
|
|
const serverless = new Serverless();
|
|
const getValueFromS3Stub = sinon
|
|
.stub(serverless.variables, 'getValueFromS3').resolves('variableValue');
|
|
return serverless.variables.getValueFromSource('s3:test-bucket/path/to/key')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('variableValue');
|
|
expect(getValueFromS3Stub.called).to.equal(true);
|
|
expect(getValueFromS3Stub.calledWith('s3:test-bucket/path/to/key')).to.equal(true);
|
|
serverless.variables.getValueFromS3.restore();
|
|
});
|
|
});
|
|
|
|
it('should throw error if referencing an invalid source', () => {
|
|
const serverless = new Serverless();
|
|
expect(() => serverless.variables.getValueFromSource('weird:source'))
|
|
.to.throw(Error);
|
|
});
|
|
});
|
|
|
|
describe('#getValueFromEnv()', () => {
|
|
it('should get variable from environment variables', () => {
|
|
const serverless = new Serverless();
|
|
process.env.TEST_VAR = 'someValue';
|
|
return serverless.variables.getValueFromEnv('env:TEST_VAR').then(valueToPopulate => {
|
|
expect(valueToPopulate).to.be.equal('someValue');
|
|
delete process.env.TEST_VAR;
|
|
});
|
|
});
|
|
|
|
it('should allow top-level references to the environment variables hive', () => {
|
|
const serverless = new Serverless();
|
|
process.env.TEST_VAR = 'someValue';
|
|
return serverless.variables.getValueFromEnv('env:').then(valueToPopulate => {
|
|
expect(valueToPopulate.TEST_VAR).to.be.equal('someValue');
|
|
delete process.env.TEST_VAR;
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#getValueFromOptions()', () => {
|
|
it('should get variable from options', () => {
|
|
const serverless = new Serverless();
|
|
serverless.variables.options = {
|
|
stage: 'prod',
|
|
};
|
|
return serverless.variables.getValueFromOptions('opt:stage').then(valueToPopulate => {
|
|
expect(valueToPopulate).to.be.equal('prod');
|
|
});
|
|
});
|
|
|
|
it('should allow top-level references to the options hive', () => {
|
|
const serverless = new Serverless();
|
|
serverless.variables.options = {
|
|
stage: 'prod',
|
|
};
|
|
return serverless.variables.getValueFromOptions('opt:').then(valueToPopulate => {
|
|
expect(valueToPopulate.stage).to.be.equal('prod');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#getValueFromSelf()', () => {
|
|
it('should get variable from self serverless.yml file', () => {
|
|
const serverless = new Serverless();
|
|
serverless.variables.service = {
|
|
service: 'testService',
|
|
provider: serverless.service.provider,
|
|
};
|
|
serverless.variables.loadVariableSyntax();
|
|
return serverless.variables.getValueFromSelf('self:service').then(valueToPopulate => {
|
|
expect(valueToPopulate).to.be.equal('testService');
|
|
});
|
|
});
|
|
|
|
it('should handle self-references to the root of the serverless.yml file', () => {
|
|
const serverless = new Serverless();
|
|
serverless.variables.service = {
|
|
service: 'testService',
|
|
provider: 'testProvider',
|
|
defaults: serverless.service.defaults,
|
|
};
|
|
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
return serverless.variables.getValueFromSelf('self:').then(valueToPopulate => {
|
|
expect(valueToPopulate.provider).to.be.equal('testProvider');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#getValueFromFile()', () => {
|
|
it('should work for absolute paths with ~ ', () => {
|
|
const serverless = new Serverless();
|
|
const expectedFileName = `${os.homedir}/somedir/config.yml`;
|
|
const configYml = {
|
|
test: 1,
|
|
test2: 'test2',
|
|
testObj: {
|
|
sub: 2,
|
|
prob: 'prob',
|
|
},
|
|
};
|
|
const fileExistsStub = sinon
|
|
.stub(serverless.utils, 'fileExistsSync').returns(true);
|
|
|
|
const readFileSyncStub = sinon
|
|
.stub(serverless.utils, 'readFileSync').returns(configYml);
|
|
|
|
return serverless.variables.getValueFromFile('file(~/somedir/config.yml)')
|
|
.then(valueToPopulate => {
|
|
expect(fileExistsStub.calledWithMatch(expectedFileName));
|
|
expect(readFileSyncStub.calledWithMatch(expectedFileName));
|
|
expect(valueToPopulate).to.deep.equal(configYml);
|
|
readFileSyncStub.restore();
|
|
fileExistsStub.restore();
|
|
});
|
|
});
|
|
|
|
it('should populate an entire variable file', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
const configYml = {
|
|
test: 1,
|
|
test2: 'test2',
|
|
testObj: {
|
|
sub: 2,
|
|
prob: 'prob',
|
|
},
|
|
};
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'config.yml'),
|
|
YAML.dump(configYml));
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
|
|
return serverless.variables.getValueFromFile('file(./config.yml)').then(valueToPopulate => {
|
|
expect(valueToPopulate).to.deep.equal(configYml);
|
|
});
|
|
});
|
|
|
|
it('should get undefined if non existing file and the second argument is true', () => {
|
|
const serverless = new Serverless();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
|
|
return serverless.variables.getValueFromFile('file(./config.yml)').then(valueToPopulate => {
|
|
expect(valueToPopulate).to.be.equal(undefined);
|
|
});
|
|
});
|
|
|
|
it('should populate non json/yml files', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'someFile'),
|
|
'hello world');
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
|
|
return serverless.variables.getValueFromFile('file(./someFile)').then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('hello world');
|
|
});
|
|
});
|
|
|
|
it('should trim trailing whitespace and new line character', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'someFile'),
|
|
'hello world \n');
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
|
|
return serverless.variables.getValueFromFile('file(./someFile)').then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('hello world');
|
|
});
|
|
});
|
|
|
|
it('should populate from another file when variable is of any type', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
const configYml = {
|
|
test: 1,
|
|
test2: 'test2',
|
|
testObj: {
|
|
sub: 2,
|
|
prob: 'prob',
|
|
},
|
|
};
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'config.yml'),
|
|
YAML.dump(configYml));
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
|
|
return serverless.variables.getValueFromFile('file(./config.yml):testObj.sub')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal(2);
|
|
});
|
|
});
|
|
|
|
it('should populate from a javascript file', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
const jsData = 'module.exports.hello=function(){return "hello world";};';
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'hello.js'), jsData);
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
|
|
return serverless.variables.getValueFromFile('file(./hello.js):hello')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('hello world');
|
|
});
|
|
});
|
|
|
|
it('should populate an entire variable exported by a javascript file', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
const jsData = 'module.exports=function(){return { hello: "hello world" };};';
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'hello.js'), jsData);
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
|
|
return serverless.variables.getValueFromFile('file(./hello.js)')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate.hello).to.equal('hello world');
|
|
});
|
|
});
|
|
|
|
it('should throw if property exported by a javascript file is not a function', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
const jsData = 'module.exports={ hello: "hello world" };';
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'hello.js'), jsData);
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
|
|
expect(() => serverless.variables
|
|
.getValueFromFile('file(./hello.js)')).to.throw(Error);
|
|
});
|
|
|
|
it('should populate deep object from a javascript file', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
const jsData = `module.exports.hello=function(){
|
|
return {one:{two:{three: 'hello world'}}}
|
|
};`;
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'hello.js'), jsData);
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
return serverless.variables.getValueFromFile('file(./hello.js):hello.one.two.three')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('hello world');
|
|
});
|
|
});
|
|
|
|
it('should preserve the exported function context when executing', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
const jsData = `
|
|
module.exports.one = {two: {three: 'hello world'}}
|
|
module.exports.hello=function(){ return this; };`;
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'hello.js'), jsData);
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
return serverless.variables.getValueFromFile('file(./hello.js):hello.one.two.three')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.equal('hello world');
|
|
});
|
|
});
|
|
|
|
it('should throw error if not using ":" syntax', () => {
|
|
const serverless = new Serverless();
|
|
const SUtils = new Utils();
|
|
const tmpDirPath = testUtils.getTmpDirPath();
|
|
const configYml = {
|
|
test: 1,
|
|
test2: 'test2',
|
|
testObj: {
|
|
sub: 2,
|
|
prob: 'prob',
|
|
},
|
|
};
|
|
|
|
SUtils.writeFileSync(path.join(tmpDirPath, 'config.yml'),
|
|
YAML.dump(configYml));
|
|
|
|
serverless.config.update({ servicePath: tmpDirPath });
|
|
|
|
expect(() => serverless.variables
|
|
.getValueFromFile('file(./config.yml).testObj.sub')).to.throw(Error);
|
|
});
|
|
});
|
|
|
|
describe('#getValueFromCf()', () => {
|
|
it('should get variable from CloudFormation', () => {
|
|
const serverless = new Serverless();
|
|
const options = {
|
|
stage: 'prod',
|
|
region: 'us-west-2',
|
|
};
|
|
const awsProvider = new AwsProvider(serverless, options);
|
|
serverless.setProvider('aws', awsProvider);
|
|
serverless.variables.options = options;
|
|
const awsResponseMock = {
|
|
Stacks: [{
|
|
Outputs: [{
|
|
OutputKey: 'MockExport',
|
|
OutputValue: 'MockValue',
|
|
}],
|
|
}],
|
|
};
|
|
|
|
const cfStub = sinon.stub(serverless.getProvider('aws'), 'request')
|
|
.resolves(awsResponseMock);
|
|
return serverless.variables.getValueFromCf('cf:some-stack.MockExport')
|
|
.then(valueToPopulate => {
|
|
expect(valueToPopulate).to.be.equal('MockValue');
|
|
expect(cfStub.calledOnce).to.be.equal(true);
|
|
expect(cfStub.calledWithExactly(
|
|
'CloudFormation',
|
|
'describeStacks',
|
|
{
|
|
StackName: 'some-stack',
|
|
},
|
|
serverless.variables.options.stage,
|
|
serverless.variables.options.region
|
|
)).to.be.equal(true);
|
|
serverless.getProvider('aws').request.restore();
|
|
});
|
|
});
|
|
|
|
it('should throw an error when variable from CloudFormation does not exist', () => {
|
|
const serverless = new Serverless();
|
|
const options = {
|
|
stage: 'prod',
|
|
region: 'us-west-2',
|
|
};
|
|
const awsProvider = new AwsProvider(serverless, options);
|
|
serverless.setProvider('aws', awsProvider);
|
|
serverless.variables.options = options;
|
|
const awsResponseMock = {
|
|
Stacks: [{
|
|
Outputs: [{
|
|
OutputKey: 'MockExport',
|
|
OutputValue: 'MockValue',
|
|
}],
|
|
}],
|
|
};
|
|
|
|
const cfStub = sinon.stub(serverless.getProvider('aws'), 'request')
|
|
.resolves(awsResponseMock);
|
|
|
|
return serverless.variables.getValueFromCf('cf:some-stack.DoestNotExist')
|
|
.then()
|
|
.catch(error => {
|
|
expect(cfStub.calledOnce).to.be.equal(true);
|
|
expect(cfStub.calledWithExactly(
|
|
'CloudFormation',
|
|
'describeStacks',
|
|
{
|
|
StackName: 'some-stack',
|
|
},
|
|
serverless.variables.options.stage,
|
|
serverless.variables.options.region
|
|
)).to.be.equal(true);
|
|
serverless.getProvider('aws').request.restore();
|
|
expect(error).to.be.an.instanceof(Error);
|
|
expect(error.message).to.match(/to request a non exported variable from CloudFormation/);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#getValueFromS3()', () => {
|
|
let serverless;
|
|
let awsProvider;
|
|
|
|
beforeEach(() => {
|
|
serverless = new Serverless();
|
|
const options = {
|
|
stage: 'prod',
|
|
region: 'us-west-2',
|
|
};
|
|
awsProvider = new AwsProvider(serverless, options);
|
|
serverless.setProvider('aws', awsProvider);
|
|
serverless.variables.options = options;
|
|
});
|
|
|
|
it('should get variable from S3', () => {
|
|
const awsResponseMock = {
|
|
Body: 'MockValue',
|
|
};
|
|
const s3Stub = sinon.stub(awsProvider, 'request').resolves(awsResponseMock);
|
|
|
|
return serverless.variables.getValueFromS3('s3:some.bucket/path/to/key').then(value => {
|
|
expect(value).to.be.equal('MockValue');
|
|
expect(s3Stub.calledOnce).to.be.equal(true);
|
|
expect(s3Stub.calledWithExactly(
|
|
'S3',
|
|
'getObject',
|
|
{
|
|
Bucket: 'some.bucket',
|
|
Key: 'path/to/key',
|
|
},
|
|
serverless.variables.options.stage,
|
|
serverless.variables.options.region
|
|
)).to.be.equal(true);
|
|
});
|
|
});
|
|
|
|
it('should throw error if error getting value from S3', () => {
|
|
const error = new Error('The specified bucket is not valid');
|
|
sinon.stub(awsProvider, 'request').rejects(error);
|
|
|
|
return serverless.variables.getValueFromS3('s3:some.bucket/path/to/key').then(() => {
|
|
throw new Error('S3 value was populated for invalid S3 bucket');
|
|
}, (err) => {
|
|
expect(err.message).to.be.equal('Error getting value for s3:some.bucket/path/to/key. ' +
|
|
'The specified bucket is not valid');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#getDeepValue()', () => {
|
|
it('should get deep values', () => {
|
|
const serverless = new Serverless();
|
|
|
|
const valueToPopulateMock = {
|
|
service: 'testService',
|
|
custom: {
|
|
subProperty: {
|
|
deep: 'deepValue',
|
|
},
|
|
},
|
|
};
|
|
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
return serverless.variables.getDeepValue(['custom', 'subProperty', 'deep'],
|
|
valueToPopulateMock).then(valueToPopulate => {
|
|
expect(valueToPopulate).to.be.equal('deepValue');
|
|
});
|
|
});
|
|
|
|
it('should not throw error if referencing invalid properties', () => {
|
|
const serverless = new Serverless();
|
|
|
|
const valueToPopulateMock = {
|
|
service: 'testService',
|
|
custom: {
|
|
subProperty: 'hello',
|
|
},
|
|
};
|
|
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
return serverless.variables.getDeepValue(['custom', 'subProperty', 'deep', 'deeper'],
|
|
valueToPopulateMock).then(valueToPopulate => {
|
|
expect(valueToPopulate).to.deep.equal({});
|
|
});
|
|
});
|
|
|
|
it('should get deep values with variable references', () => {
|
|
const serverless = new Serverless();
|
|
|
|
serverless.variables.service = {
|
|
service: 'testService',
|
|
custom: {
|
|
anotherVar: '${self:custom.var}',
|
|
subProperty: {
|
|
deep: '${self:custom.anotherVar.veryDeep}',
|
|
},
|
|
var: {
|
|
veryDeep: 'someValue',
|
|
},
|
|
},
|
|
provider: serverless.service.provider,
|
|
};
|
|
|
|
serverless.variables.loadVariableSyntax();
|
|
|
|
return serverless.variables.getDeepValue(['custom', 'subProperty', 'deep'],
|
|
serverless.variables.service).then(valueToPopulate => {
|
|
expect(valueToPopulate).to.be.equal('someValue');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#warnIfNotFound()', () => {
|
|
let logWarningSpy;
|
|
let consoleLogStub;
|
|
let varProxy;
|
|
|
|
beforeEach(() => {
|
|
logWarningSpy = sinon.spy(slsError, 'logWarning');
|
|
consoleLogStub = sinon.stub(console, 'log').returns();
|
|
const ProxyQuiredVariables = proxyquire('./Variables.js', {
|
|
'./Error': logWarningSpy,
|
|
});
|
|
varProxy = new ProxyQuiredVariables(new Serverless());
|
|
});
|
|
|
|
afterEach(() => {
|
|
logWarningSpy.restore();
|
|
consoleLogStub.restore();
|
|
});
|
|
|
|
it('should do nothing if variable has valid value.', () => {
|
|
varProxy.warnIfNotFound('self:service', 'a-valid-value');
|
|
expect(logWarningSpy.calledOnce).to.be.equal(false);
|
|
});
|
|
|
|
it('should log if variable has null value.', () => {
|
|
varProxy.warnIfNotFound('self:service', null);
|
|
expect(logWarningSpy.calledOnce).to.be.equal(true);
|
|
});
|
|
|
|
it('should log if variable has undefined value.', () => {
|
|
varProxy.warnIfNotFound('self:service', undefined);
|
|
expect(logWarningSpy.calledOnce).to.be.equal(true);
|
|
});
|
|
|
|
it('should log if variable has empty object value.', () => {
|
|
varProxy.warnIfNotFound('self:service', {});
|
|
expect(logWarningSpy.calledOnce).to.be.equal(true);
|
|
});
|
|
|
|
it('should detect the "environment variable" variable type', () => {
|
|
varProxy.warnIfNotFound('env:service', null);
|
|
expect(logWarningSpy.calledOnce).to.be.equal(true);
|
|
expect(logWarningSpy.args[0][0]).to.contain('environment variable');
|
|
});
|
|
|
|
it('should detect the "option" variable type', () => {
|
|
varProxy.warnIfNotFound('opt:service', null);
|
|
expect(logWarningSpy.calledOnce).to.be.equal(true);
|
|
expect(logWarningSpy.args[0][0]).to.contain('option');
|
|
});
|
|
|
|
it('should detect the "service attribute" variable type', () => {
|
|
varProxy.warnIfNotFound('self:service', null);
|
|
expect(logWarningSpy.calledOnce).to.be.equal(true);
|
|
expect(logWarningSpy.args[0][0]).to.contain('service attribute');
|
|
});
|
|
|
|
it('should detect the "file" variable type', () => {
|
|
varProxy.warnIfNotFound('file(service)', null);
|
|
expect(logWarningSpy.calledOnce).to.be.equal(true);
|
|
expect(logWarningSpy.args[0][0]).to.contain('file');
|
|
});
|
|
});
|
|
});
|