mirror of
https://github.com/serverless/serverless.git
synced 2026-01-18 14:58:43 +00:00
1058 lines
38 KiB
JavaScript
1058 lines
38 KiB
JavaScript
'use strict';
|
|
|
|
/* eslint-disable no-unused-expressions */
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const globby = require('globby');
|
|
const sandbox = require('sinon');
|
|
const chai = require('chai');
|
|
const BbPromise = require('bluebird');
|
|
const proxyquire = require('proxyquire');
|
|
const normalizeFiles = require('../../lib/normalizeFiles');
|
|
const AwsProvider = require('../../provider/awsProvider');
|
|
const AwsDeploy = require('../index');
|
|
const Serverless = require('../../../../Serverless');
|
|
const runServerless = require('../../../../../tests/utils/run-serverless');
|
|
const fixtures = require('../../../../../tests/fixtures');
|
|
|
|
// Configure chai
|
|
chai.use(require('chai-as-promised'));
|
|
chai.use(require('sinon-chai'));
|
|
const expect = require('chai').expect;
|
|
|
|
describe('checkForChanges', () => {
|
|
let serverless;
|
|
let provider;
|
|
let awsDeploy;
|
|
let s3Key;
|
|
let cryptoStub;
|
|
|
|
beforeEach(() => {
|
|
const options = {
|
|
stage: 'dev',
|
|
region: 'us-east-1',
|
|
};
|
|
serverless = new Serverless();
|
|
serverless.config.servicePath = 'my-service';
|
|
provider = new AwsProvider(serverless, options);
|
|
serverless.setProvider('aws', provider);
|
|
serverless.service.service = 'my-service';
|
|
awsDeploy = new AwsDeploy(serverless, options);
|
|
awsDeploy.bucketName = 'deployment-bucket';
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate = {
|
|
foo: 'bar',
|
|
};
|
|
s3Key = `serverless/${serverless.service.service}/${provider.getStage()}`;
|
|
awsDeploy.serverless.cli = { log: sandbox.spy() };
|
|
cryptoStub = {
|
|
createHash() {
|
|
return this;
|
|
}, // eslint-disable-line
|
|
update() {
|
|
return this;
|
|
}, // eslint-disable-line
|
|
digest: sandbox.stub(),
|
|
};
|
|
const checkForChanges = proxyquire('./checkForChanges.js', {
|
|
crypto: cryptoStub,
|
|
});
|
|
Object.assign(awsDeploy, checkForChanges);
|
|
});
|
|
|
|
describe('#checkForChanges()', () => {
|
|
let getMostRecentObjectsStub;
|
|
let getObjectMetadataStub;
|
|
let checkIfDeploymentIsNecessaryStub;
|
|
let checkLogGroupSubscriptionFilterResourceLimitExceededStub;
|
|
|
|
beforeEach(() => {
|
|
getMostRecentObjectsStub = sandbox.stub(awsDeploy, 'getMostRecentObjects').resolves();
|
|
getObjectMetadataStub = sandbox.stub(awsDeploy, 'getObjectMetadata').resolves();
|
|
checkIfDeploymentIsNecessaryStub = sandbox
|
|
.stub(awsDeploy, 'checkIfDeploymentIsNecessary')
|
|
.resolves();
|
|
checkLogGroupSubscriptionFilterResourceLimitExceededStub = sandbox
|
|
.stub(awsDeploy, 'checkLogGroupSubscriptionFilterResourceLimitExceeded')
|
|
.resolves();
|
|
});
|
|
|
|
afterEach(() => {
|
|
awsDeploy.getMostRecentObjects.restore();
|
|
awsDeploy.getObjectMetadata.restore();
|
|
awsDeploy.checkIfDeploymentIsNecessary.restore();
|
|
awsDeploy.checkLogGroupSubscriptionFilterResourceLimitExceeded.restore();
|
|
});
|
|
|
|
it('should run promise chain in order', () =>
|
|
expect(awsDeploy.checkForChanges()).to.be.fulfilled.then(() => {
|
|
expect(getMostRecentObjectsStub).to.have.been.calledOnce;
|
|
expect(getObjectMetadataStub).to.have.been.calledAfter(getMostRecentObjectsStub);
|
|
expect(checkIfDeploymentIsNecessaryStub).to.have.been.calledAfter(getObjectMetadataStub);
|
|
expect(checkLogGroupSubscriptionFilterResourceLimitExceededStub).to.have.been.calledAfter(
|
|
checkIfDeploymentIsNecessaryStub
|
|
);
|
|
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(false);
|
|
}));
|
|
|
|
it('should resolve if the "force" option is used', () => {
|
|
awsDeploy.options.force = true;
|
|
|
|
return expect(awsDeploy.checkForChanges()).to.be.fulfilled.then(() => {
|
|
expect(getMostRecentObjectsStub).to.not.have.been.called;
|
|
expect(getObjectMetadataStub).to.not.have.been.called;
|
|
expect(checkIfDeploymentIsNecessaryStub).to.not.have.been.called;
|
|
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(false);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#getMostRecentObjects()', () => {
|
|
let listObjectsV2Stub;
|
|
|
|
beforeEach(() => {
|
|
listObjectsV2Stub = sandbox.stub(awsDeploy.provider, 'request');
|
|
});
|
|
|
|
afterEach(() => {
|
|
awsDeploy.provider.request.restore();
|
|
});
|
|
|
|
it('should resolve if no result is returned', () => {
|
|
listObjectsV2Stub.resolves();
|
|
|
|
return expect(awsDeploy.getMostRecentObjects()).to.be.fulfilled.then(result => {
|
|
expect(listObjectsV2Stub).to.have.been.calledWithExactly('S3', 'listObjectsV2', {
|
|
Bucket: awsDeploy.bucketName,
|
|
Prefix: 'serverless/my-service/dev',
|
|
});
|
|
expect(result).to.deep.equal([]);
|
|
});
|
|
});
|
|
|
|
it('should translate error if rejected due to missing bucket', () => {
|
|
listObjectsV2Stub.rejects(
|
|
new serverless.classes.Error('The specified bucket does not exist')
|
|
);
|
|
|
|
return expect(awsDeploy.getMostRecentObjects()).to.be.rejectedWith(
|
|
[
|
|
`The serverless deployment bucket "${awsDeploy.bucketName}" does not exist.`,
|
|
'Create it manually if you want to reuse the CloudFormation stack "my-service-dev",',
|
|
'or delete the stack if it is no longer required.',
|
|
].join(' ')
|
|
);
|
|
});
|
|
|
|
it('should throw original error if rejected not due to missing bucket', () => {
|
|
listObjectsV2Stub.rejects(new serverless.classes.Error('Other reason'));
|
|
return expect(awsDeploy.getMostRecentObjects()).to.be.rejectedWith('Other reason');
|
|
});
|
|
|
|
it('should resolve if result array is empty', () => {
|
|
const serviceObjects = {
|
|
Contents: [],
|
|
};
|
|
|
|
listObjectsV2Stub.resolves(serviceObjects);
|
|
|
|
return expect(awsDeploy.getMostRecentObjects()).to.be.fulfilled.then(result => {
|
|
expect(listObjectsV2Stub).to.have.been.calledWithExactly('S3', 'listObjectsV2', {
|
|
Bucket: awsDeploy.bucketName,
|
|
Prefix: 'serverless/my-service/dev',
|
|
});
|
|
expect(result).to.deep.equal([]);
|
|
});
|
|
});
|
|
|
|
it('should resolve with the most recently deployed objects', () => {
|
|
const serviceObjects = {
|
|
Contents: [
|
|
{ Key: `${s3Key}/151224711231-2016-08-18T15:43:00/artifact.zip` },
|
|
{ Key: `${s3Key}/151224711231-2016-08-18T15:43:00/cloudformation.json` },
|
|
{ Key: `${s3Key}/141264711231-2016-08-18T15:42:00/artifact.zip` },
|
|
{ Key: `${s3Key}/141264711231-2016-08-18T15:42:00/cloudformation.json` },
|
|
],
|
|
};
|
|
|
|
listObjectsV2Stub.resolves(serviceObjects);
|
|
|
|
return expect(awsDeploy.getMostRecentObjects()).to.be.fulfilled.then(result => {
|
|
expect(listObjectsV2Stub).to.have.been.calledWithExactly('S3', 'listObjectsV2', {
|
|
Bucket: awsDeploy.bucketName,
|
|
Prefix: 'serverless/my-service/dev',
|
|
});
|
|
expect(result).to.deep.equal([
|
|
{ Key: `${s3Key}/151224711231-2016-08-18T15:43:00/cloudformation.json` },
|
|
{ Key: `${s3Key}/151224711231-2016-08-18T15:43:00/artifact.zip` },
|
|
]);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#getObjectMetadata()', () => {
|
|
let headObjectStub;
|
|
|
|
beforeEach(() => {
|
|
headObjectStub = sandbox.stub(awsDeploy.provider, 'request').resolves();
|
|
});
|
|
|
|
afterEach(() => {
|
|
awsDeploy.provider.request.restore();
|
|
});
|
|
|
|
it('should resolve if no input is provided', () =>
|
|
expect(awsDeploy.getObjectMetadata()).to.be.fulfilled.then(result => {
|
|
expect(headObjectStub).to.not.have.been.called;
|
|
expect(result).to.deep.equal([]);
|
|
}));
|
|
|
|
it('should resolve if no objects are provided as input', () => {
|
|
const input = [];
|
|
|
|
return expect(awsDeploy.getObjectMetadata(input)).to.be.fulfilled.then(result => {
|
|
expect(headObjectStub).to.not.have.been.called;
|
|
expect(result).to.deep.equal([]);
|
|
});
|
|
});
|
|
|
|
it('should request the object detailed information', () => {
|
|
const input = [
|
|
{ Key: `${s3Key}/151224711231-2016-08-18T15:43:00/artifact.zip` },
|
|
{ Key: `${s3Key}/151224711231-2016-08-18T15:43:00/cloudformation.json` },
|
|
{ Key: `${s3Key}/141264711231-2016-08-18T15:42:00/artifact.zip` },
|
|
{ Key: `${s3Key}/141264711231-2016-08-18T15:42:00/cloudformation.json` },
|
|
];
|
|
|
|
return expect(awsDeploy.getObjectMetadata(input)).to.be.fulfilled.then(() => {
|
|
expect(headObjectStub.callCount).to.equal(4);
|
|
expect(headObjectStub).to.have.been.calledWithExactly('S3', 'headObject', {
|
|
Bucket: awsDeploy.bucketName,
|
|
Key: `${s3Key}/151224711231-2016-08-18T15:43:00/artifact.zip`,
|
|
});
|
|
expect(headObjectStub).to.have.been.calledWithExactly('S3', 'headObject', {
|
|
Bucket: awsDeploy.bucketName,
|
|
Key: `${s3Key}/151224711231-2016-08-18T15:43:00/cloudformation.json`,
|
|
});
|
|
expect(headObjectStub).to.have.been.calledWithExactly('S3', 'headObject', {
|
|
Bucket: awsDeploy.bucketName,
|
|
Key: `${s3Key}/141264711231-2016-08-18T15:42:00/artifact.zip`,
|
|
});
|
|
expect(headObjectStub).to.have.been.calledWithExactly('S3', 'headObject', {
|
|
Bucket: awsDeploy.bucketName,
|
|
Key: `${s3Key}/141264711231-2016-08-18T15:42:00/cloudformation.json`,
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#checkIfDeploymentIsNecessary()', () => {
|
|
let normalizeCloudFormationTemplateStub;
|
|
let globbySyncStub;
|
|
let readFileStub;
|
|
|
|
beforeEach(() => {
|
|
normalizeCloudFormationTemplateStub = sandbox
|
|
.stub(normalizeFiles, 'normalizeCloudFormationTemplate')
|
|
.returns();
|
|
globbySyncStub = sandbox.stub(globby, 'sync');
|
|
readFileStub = sandbox.stub(fs, 'readFile').yields(null, undefined);
|
|
});
|
|
|
|
afterEach(() => {
|
|
normalizeFiles.normalizeCloudFormationTemplate.restore();
|
|
globby.sync.restore();
|
|
fs.readFile.restore();
|
|
});
|
|
|
|
it('should resolve if no input is provided', () =>
|
|
expect(awsDeploy.checkIfDeploymentIsNecessary()).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.not.have.been.called;
|
|
expect(globbySyncStub).to.not.have.been.called;
|
|
expect(readFileStub).to.not.have.been.called;
|
|
expect(awsDeploy.serverless.cli.log).to.not.have.been.called;
|
|
}));
|
|
|
|
it('should resolve if no objects are provided as input', () => {
|
|
const input = [];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input)).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.not.have.been.called;
|
|
expect(globbySyncStub).to.not.have.been.called;
|
|
expect(readFileStub).to.not.have.been.called;
|
|
expect(awsDeploy.serverless.cli.log).to.not.have.been.called;
|
|
});
|
|
});
|
|
|
|
it('should resolve if objects are given, but no function last modified date', () => {
|
|
globbySyncStub.returns(['my-service.zip']);
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(0)
|
|
.returns('local-hash-cf-template');
|
|
|
|
const input = [{ Metadata: { filesha256: 'remote-hash-cf-template' } }];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input)).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledOnce;
|
|
expect(globbySyncStub).to.have.been.calledOnce;
|
|
expect(readFileStub).to.have.been.calledOnce;
|
|
expect(awsDeploy.serverless.cli.log).to.not.have.been.called;
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledWithExactly(
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate
|
|
);
|
|
expect(globbySyncStub).to.have.been.calledWithExactly(['**.zip'], {
|
|
cwd: path.join(awsDeploy.serverless.config.servicePath, '.serverless'),
|
|
dot: true,
|
|
silent: true,
|
|
});
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/my-service.zip')
|
|
);
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(undefined);
|
|
});
|
|
});
|
|
|
|
it('should not set a flag if there are more remote hashes', () => {
|
|
globbySyncStub.returns(['my-service.zip']);
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(0)
|
|
.returns('local-hash-cf-template');
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(1)
|
|
.returns('local-hash-zip-file-1');
|
|
|
|
const input = [
|
|
{ Metadata: { filesha256: 'remote-hash-cf-template' } },
|
|
{ Metadata: { filesha256: 'remote-hash-zip-file-1' } },
|
|
{
|
|
Metadata: {
|
|
/* no filesha256 available */
|
|
},
|
|
}, // will be translated to ''
|
|
];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input)).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledOnce;
|
|
expect(globbySyncStub).to.have.been.calledOnce;
|
|
expect(readFileStub).to.have.been.calledOnce;
|
|
expect(awsDeploy.serverless.cli.log).to.not.have.been.called;
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledWithExactly(
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate
|
|
);
|
|
expect(globbySyncStub).to.have.been.calledWithExactly(['**.zip'], {
|
|
cwd: path.join(awsDeploy.serverless.config.servicePath, '.serverless'),
|
|
dot: true,
|
|
silent: true,
|
|
});
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/my-service.zip')
|
|
);
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(undefined);
|
|
});
|
|
});
|
|
|
|
it('should not set a flag if remote and local hashes are different', () => {
|
|
globbySyncStub.returns(['my-service.zip']);
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(0)
|
|
.returns('local-hash-cf-template');
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(1)
|
|
.returns('local-hash-zip-file-1');
|
|
|
|
const input = [
|
|
{ Metadata: { filesha256: 'remote-hash-cf-template' } },
|
|
{ Metadata: { filesha256: 'remote-hash-zip-file-1' } },
|
|
];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input)).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledOnce;
|
|
expect(globbySyncStub).to.have.been.calledOnce;
|
|
expect(readFileStub).to.have.been.calledOnce;
|
|
expect(awsDeploy.serverless.cli.log).to.not.have.been.called;
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledWithExactly(
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate
|
|
);
|
|
expect(globbySyncStub).to.have.been.calledWithExactly(['**.zip'], {
|
|
cwd: path.join(awsDeploy.serverless.config.servicePath, '.serverless'),
|
|
dot: true,
|
|
silent: true,
|
|
});
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/my-service.zip')
|
|
);
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(undefined);
|
|
});
|
|
});
|
|
|
|
it('should not set a flag if remote and local hashes are the same but are duplicated', () => {
|
|
globbySyncStub.returns(['func1.zip', 'func2.zip']);
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(0)
|
|
.returns('remote-hash-cf-template');
|
|
// happens when package.individually is used
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(1)
|
|
.returns('remote-hash-zip-file-1');
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(2)
|
|
.returns('remote-hash-zip-file-1');
|
|
|
|
const input = [
|
|
{ Metadata: { filesha256: 'remote-hash-cf-template' } },
|
|
{ Metadata: { filesha256: 'remote-hash-zip-file-1' } },
|
|
];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input)).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledOnce;
|
|
expect(globbySyncStub).to.have.been.calledOnce;
|
|
expect(readFileStub).to.have.been.calledTwice;
|
|
expect(awsDeploy.serverless.cli.log).to.not.have.been.called;
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledWithExactly(
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate
|
|
);
|
|
expect(globbySyncStub).to.have.been.calledWithExactly(['**.zip'], {
|
|
cwd: path.join(awsDeploy.serverless.config.servicePath, '.serverless'),
|
|
dot: true,
|
|
silent: true,
|
|
});
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/func1.zip')
|
|
);
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/func2.zip')
|
|
);
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(undefined);
|
|
});
|
|
});
|
|
|
|
it('should not set a flag if the hashes are equal, but the objects were modified after their functions', () => {
|
|
globbySyncStub.returns(['my-service.zip']);
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(0)
|
|
.returns('hash-cf-template');
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(1)
|
|
.returns('hash-zip-file-1');
|
|
|
|
const now = new Date();
|
|
const inThePast = new Date(new Date().getTime() - 100000);
|
|
const inTheFuture = new Date(new Date().getTime() + 100000);
|
|
|
|
const input = [
|
|
{ Metadata: { filesha256: 'hash-cf-template' }, LastModified: inThePast },
|
|
{ Metadata: { filesha256: 'hash-zip-file-1' }, LastModified: inTheFuture },
|
|
];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input, now)).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledOnce;
|
|
expect(globbySyncStub).to.have.been.calledOnce;
|
|
expect(readFileStub).to.have.been.calledOnce;
|
|
expect(awsDeploy.serverless.cli.log).to.not.have.been.called;
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledWithExactly(
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate
|
|
);
|
|
expect(globbySyncStub).to.have.been.calledWithExactly(['**.zip'], {
|
|
cwd: path.join(awsDeploy.serverless.config.servicePath, '.serverless'),
|
|
dot: true,
|
|
silent: true,
|
|
});
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/my-service.zip')
|
|
);
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(undefined);
|
|
});
|
|
});
|
|
|
|
it('should set a flag if the remote and local hashes are equal', () => {
|
|
globbySyncStub.returns(['my-service.zip']);
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(0)
|
|
.returns('hash-cf-template');
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(1)
|
|
.returns('hash-zip-file-1');
|
|
|
|
const input = [
|
|
{ Metadata: { filesha256: 'hash-cf-template' } },
|
|
{ Metadata: { filesha256: 'hash-zip-file-1' } },
|
|
];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input)).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledOnce;
|
|
expect(globbySyncStub).to.have.been.calledOnce;
|
|
expect(readFileStub).to.have.been.calledOnce;
|
|
expect(awsDeploy.serverless.cli.log).to.have.been.calledOnce;
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledWithExactly(
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate
|
|
);
|
|
expect(globbySyncStub).to.have.been.calledWithExactly(['**.zip'], {
|
|
cwd: path.join(awsDeploy.serverless.config.servicePath, '.serverless'),
|
|
dot: true,
|
|
silent: true,
|
|
});
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/my-service.zip')
|
|
);
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(true);
|
|
});
|
|
});
|
|
|
|
it('should set a flag if the remote and local hashes are equal, and the edit times are ordered', () => {
|
|
globbySyncStub.returns(['my-service.zip']);
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(0)
|
|
.returns('hash-cf-template');
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(1)
|
|
.returns('hash-zip-file-1');
|
|
|
|
const longAgo = new Date(new Date().getTime() - 100000);
|
|
const longerAgo = new Date(new Date().getTime() - 200000);
|
|
|
|
const input = [
|
|
{ Metadata: { filesha256: 'hash-cf-template' }, LastModified: longerAgo },
|
|
{ Metadata: { filesha256: 'hash-zip-file-1' }, LastModified: longerAgo },
|
|
];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input, longAgo)).to.be.fulfilled.then(
|
|
() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledOnce;
|
|
expect(globbySyncStub).to.have.been.calledOnce;
|
|
expect(readFileStub).to.have.been.calledOnce;
|
|
expect(awsDeploy.serverless.cli.log).to.have.been.calledOnce;
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledWithExactly(
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate
|
|
);
|
|
expect(globbySyncStub).to.have.been.calledWithExactly(['**.zip'], {
|
|
cwd: path.join(awsDeploy.serverless.config.servicePath, '.serverless'),
|
|
dot: true,
|
|
silent: true,
|
|
});
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/my-service.zip')
|
|
);
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(true);
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should set a flag if the remote and local hashes are duplicated and equal', () => {
|
|
globbySyncStub.returns(['func1.zip', 'func2.zip']);
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(0)
|
|
.returns('hash-cf-template');
|
|
// happens when package.individually is used
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(1)
|
|
.returns('hash-zip-file-1');
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(2)
|
|
.returns('hash-zip-file-1');
|
|
|
|
const input = [
|
|
{ Metadata: { filesha256: 'hash-cf-template' } },
|
|
{ Metadata: { filesha256: 'hash-zip-file-1' } },
|
|
{ Metadata: { filesha256: 'hash-zip-file-1' } },
|
|
];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input)).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledOnce;
|
|
expect(globbySyncStub).to.have.been.calledOnce;
|
|
expect(readFileStub).to.have.been.calledTwice;
|
|
expect(awsDeploy.serverless.cli.log).to.have.been.calledOnce;
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledWithExactly(
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate
|
|
);
|
|
expect(globbySyncStub).to.have.been.calledWithExactly(['**.zip'], {
|
|
cwd: path.join(awsDeploy.serverless.config.servicePath, '.serverless'),
|
|
dot: true,
|
|
silent: true,
|
|
});
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/func1.zip')
|
|
);
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, '.serverless/func2.zip')
|
|
);
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(true);
|
|
});
|
|
});
|
|
|
|
it('should not set a flag if the remote and local hashes are different for package.artifact', () => {
|
|
awsDeploy.serverless.service.package = {
|
|
artifact: 'foo/bar/my-own.zip',
|
|
};
|
|
|
|
globbySyncStub.returns([]);
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(0)
|
|
.returns('hash-cf-template');
|
|
cryptoStub
|
|
.createHash()
|
|
.update()
|
|
.digest.onCall(1)
|
|
.returns('local-my-own-hash');
|
|
|
|
const input = [
|
|
{ Metadata: { filesha256: 'hash-cf-template' } },
|
|
{ Metadata: { filesha256: 'remote-my-own-hash' } },
|
|
];
|
|
|
|
return expect(awsDeploy.checkIfDeploymentIsNecessary(input)).to.be.fulfilled.then(() => {
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledOnce;
|
|
expect(globbySyncStub).to.have.been.calledOnce;
|
|
expect(readFileStub).to.have.been.calledOnce;
|
|
expect(awsDeploy.serverless.cli.log).not.to.be.called;
|
|
expect(normalizeCloudFormationTemplateStub).to.have.been.calledWithExactly(
|
|
awsDeploy.serverless.service.provider.compiledCloudFormationTemplate
|
|
);
|
|
expect(globbySyncStub).to.have.been.calledWithExactly(['**.zip'], {
|
|
cwd: path.join(awsDeploy.serverless.config.servicePath, '.serverless'),
|
|
dot: true,
|
|
silent: true,
|
|
});
|
|
expect(readFileStub).to.have.been.calledWith(
|
|
path.resolve(awsDeploy.serverless.config.servicePath, 'foo/bar/my-own.zip')
|
|
);
|
|
expect(awsDeploy.serverless.service.provider.shouldNotDeploy).to.equal(undefined);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#checkLogGroupSubscriptionFilterResourceLimitExceeded', () => {
|
|
let CloudWatchLogsStub;
|
|
let deleteSubscriptionFilterStub;
|
|
const accountId = '123456789';
|
|
const serviceName = 'my-service';
|
|
const region = 'us-east-1';
|
|
let describeSubscriptionFiltersResponse = {};
|
|
let getFunctionStub;
|
|
|
|
beforeEach(() => {
|
|
CloudWatchLogsStub = class {
|
|
constructor() {
|
|
this.deleteSubscriptionFilter = deleteSubscriptionFilterStub = sandbox.spy(() => ({
|
|
promise: () => BbPromise.resolve(),
|
|
}));
|
|
|
|
this.describeSubscriptionFilters = sandbox.spy(() => ({
|
|
promise: () => BbPromise.resolve(describeSubscriptionFiltersResponse),
|
|
}));
|
|
}
|
|
};
|
|
|
|
provider.sdk.CloudWatchLogs = CloudWatchLogsStub;
|
|
|
|
sandbox.stub(provider, 'getAccountInfo').returns(
|
|
BbPromise.resolve({
|
|
accountId,
|
|
partition: 'aws',
|
|
})
|
|
);
|
|
|
|
sandbox.stub(awsDeploy.serverless.service, 'getServiceName').returns(serviceName);
|
|
getFunctionStub = sandbox.stub(awsDeploy.provider, 'request').rejects(new Error('Error'));
|
|
|
|
sandbox.stub(awsDeploy, 'getMostRecentObjects').resolves();
|
|
sandbox.stub(awsDeploy, 'getObjectMetadata').resolves();
|
|
sandbox.stub(awsDeploy, 'checkIfDeploymentIsNecessary').resolves();
|
|
});
|
|
|
|
afterEach(() => {
|
|
awsDeploy.provider.request.restore();
|
|
sandbox.restore();
|
|
});
|
|
|
|
it('should not call checkLogGroup if deployment is not required', () => {
|
|
awsDeploy.checkIfDeploymentIsNecessary.restore();
|
|
|
|
sandbox.stub(awsDeploy, 'checkIfDeploymentIsNecessary').callsFake(
|
|
() =>
|
|
new Promise(resolve => {
|
|
awsDeploy.serverless.service.provider.shouldNotDeploy = true;
|
|
resolve();
|
|
})
|
|
);
|
|
|
|
const spy = sandbox.spy(awsDeploy, 'checkLogGroupSubscriptionFilterResourceLimitExceeded');
|
|
|
|
return awsDeploy.checkForChanges().then(() => expect(spy).to.not.have.been.called);
|
|
});
|
|
|
|
it('should work normally when there are functions without events', () => {
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {},
|
|
};
|
|
|
|
return expect(awsDeploy.checkForChanges()).to.be.fulfilled;
|
|
});
|
|
|
|
it('should work normally when there are functions events that are not cloudWwatchLog', () => {
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
events: [{ dummyEvent: 'test' }],
|
|
},
|
|
};
|
|
|
|
return expect(awsDeploy.checkForChanges()).to.be.fulfilled;
|
|
});
|
|
|
|
describe('option to force update is set', () => {
|
|
beforeEach(() => {
|
|
awsDeploy.serverless.service.provider.cloudWatchLogs = {};
|
|
});
|
|
|
|
afterEach(() => {
|
|
awsDeploy.serverless.service.provider.cloudWatchLogs = undefined;
|
|
});
|
|
|
|
it('should not call delete if there are no subscriptionFilters', () => {
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
events: [{ cloudwatchLog: '/aws/lambda/hello1' }],
|
|
},
|
|
};
|
|
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
describeSubscriptionFiltersResponse = {
|
|
subscriptionFilters: [],
|
|
};
|
|
|
|
return awsDeploy
|
|
.checkForChanges()
|
|
.then(() => expect(deleteSubscriptionFilterStub).to.not.have.been.called);
|
|
});
|
|
|
|
it('should not call delete if there is a subFilter and the ARNs/logical IDs are the same', () => {
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
events: [{ cloudwatchLog: '/aws/lambda/hello1' }],
|
|
},
|
|
};
|
|
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
describeSubscriptionFiltersResponse = {
|
|
subscriptionFilters: [
|
|
{
|
|
destinationArn: `arn:aws:lambda:${region}:${accountId}:function:${serviceName}-dev-first`,
|
|
filterName: 'stack-name-FirstLogsSubscriptionFilterCloudWatchLog1-1KAK9SAG7Y9YN',
|
|
},
|
|
],
|
|
};
|
|
|
|
return awsDeploy
|
|
.checkForChanges()
|
|
.then(() => expect(deleteSubscriptionFilterStub).to.not.have.been.called);
|
|
});
|
|
|
|
it('should call delete if there is a subFilter but the ARNs are not the same', () => {
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
events: [{ cloudwatchLog: '/aws/lambda/hello1' }],
|
|
},
|
|
};
|
|
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
describeSubscriptionFiltersResponse = {
|
|
subscriptionFilters: [
|
|
{
|
|
destinationArn: `arn:aws:lambda:${region}:${accountId}:function:${serviceName}-dev-not-first`,
|
|
filterName: 'stack-name-FirstLogsSubscriptionFilterCloudWatchLog1-1KAK9SAG7Y9YN',
|
|
},
|
|
],
|
|
};
|
|
|
|
return awsDeploy
|
|
.checkForChanges()
|
|
.then(() => expect(deleteSubscriptionFilterStub).to.have.been.called);
|
|
});
|
|
|
|
it('should call delete if there is a subFilter but the logical IDs are not the same', () => {
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
events: [{ cloudwatchLog: '/aws/lambda/hello1' }],
|
|
},
|
|
};
|
|
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
describeSubscriptionFiltersResponse = {
|
|
subscriptionFilters: [
|
|
{
|
|
destinationArn: `arn:aws:lambda:${region}:${accountId}:function:${serviceName}-dev-first`,
|
|
filterName: 'stack-name-FirstLogsSubscriptionFilterCloudWatchLog2-1KAK9SAG7Y9YN',
|
|
},
|
|
],
|
|
};
|
|
|
|
return awsDeploy
|
|
.checkForChanges()
|
|
.then(() => expect(deleteSubscriptionFilterStub).to.have.been.called);
|
|
});
|
|
|
|
it('should not call delete if there is a subFilter and the ARNs/logical IDs are the same with custom function name', () => {
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
name: 'my-test-function',
|
|
events: [{ cloudwatchLog: '/aws/lambda/hello1' }],
|
|
},
|
|
};
|
|
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
describeSubscriptionFiltersResponse = {
|
|
subscriptionFilters: [
|
|
{
|
|
destinationArn: `arn:aws:lambda:${region}:${accountId}:function:my-test-function`,
|
|
filterName: 'stack-name-FirstLogsSubscriptionFilterCloudWatchLog1-1KAK9SAG7Y9YN',
|
|
},
|
|
],
|
|
};
|
|
|
|
return awsDeploy
|
|
.checkForChanges()
|
|
.then(() => expect(deleteSubscriptionFilterStub).to.not.have.been.called);
|
|
});
|
|
|
|
it('should not call delete when ARN/logical IDs are the same accounting for non-standard partitions', () => {
|
|
provider.getAccountInfo.restore();
|
|
sandbox.stub(provider, 'getAccountInfo').returns(
|
|
BbPromise.resolve({
|
|
accountId,
|
|
partition: 'aws-us-gov',
|
|
})
|
|
);
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
name: 'my-test-function',
|
|
events: [{ cloudwatchLog: '/aws/lambda/hello1' }],
|
|
},
|
|
};
|
|
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
describeSubscriptionFiltersResponse = {
|
|
subscriptionFilters: [
|
|
{
|
|
destinationArn: `arn:aws-us-gov:lambda:${region}:${accountId}:function:my-test-function`,
|
|
filterName: 'stack-name-FirstLogsSubscriptionFilterCloudWatchLog1-1KAK9SAG7Y9YN',
|
|
},
|
|
],
|
|
};
|
|
|
|
return awsDeploy
|
|
.checkForChanges()
|
|
.then(() => expect(deleteSubscriptionFilterStub).to.not.have.been.called);
|
|
});
|
|
|
|
it('should call delete if there is a subFilter but the ARNs are not the same with custom function name', () => {
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
name: 'my-test-function',
|
|
events: [{ cloudwatchLog: '/aws/lambda/hello1' }],
|
|
},
|
|
};
|
|
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
describeSubscriptionFiltersResponse = {
|
|
subscriptionFilters: [
|
|
{
|
|
destinationArn: `arn:aws:lambda:${region}:${accountId}:function:my-other-test-function`,
|
|
filterName: 'stack-name-FirstLogsSubscriptionFilterCloudWatchLog1-1KAK9SAG7Y9YN',
|
|
},
|
|
],
|
|
};
|
|
|
|
return awsDeploy
|
|
.checkForChanges()
|
|
.then(() => expect(deleteSubscriptionFilterStub).to.have.been.called);
|
|
});
|
|
});
|
|
|
|
describe('#getFunctionsLatestLastModifiedDate', () => {
|
|
it('should return null when there are no functions', () => {
|
|
awsDeploy.serverless.service.functions = {};
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
return expect(awsDeploy.getFunctionsEarliestLastModifiedDate()).to.have.been.fulfilled.then(
|
|
ans => {
|
|
expect(getFunctionStub).to.have.not.been.called;
|
|
expect(ans).to.be.null;
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should treat rejections as epoch', () => {
|
|
awsDeploy.provider.request.restore();
|
|
|
|
getFunctionStub = sandbox.stub(awsDeploy.provider, 'request');
|
|
|
|
const now = new Date();
|
|
getFunctionStub.onCall(0).returns(BbPromise.reject());
|
|
getFunctionStub
|
|
.onCall(1)
|
|
.returns(BbPromise.resolve({ Configuration: { LastModified: now } }));
|
|
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
events: [{ someevent: 'abc' }],
|
|
},
|
|
second: {
|
|
events: [{ anothaone: '1' }],
|
|
},
|
|
};
|
|
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
return expect(awsDeploy.getFunctionsEarliestLastModifiedDate()).to.have.been.fulfilled.then(
|
|
ans => {
|
|
expect(ans.valueOf()).to.equal(new Date(0).valueOf());
|
|
expect(getFunctionStub).to.have.been.calledTwice;
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should return the earliest last modified date', () => {
|
|
awsDeploy.provider.request.restore();
|
|
|
|
getFunctionStub = sandbox.stub(awsDeploy.provider, 'request');
|
|
|
|
const now = new Date();
|
|
const longAgo = new Date(new Date().getTime() - 100000);
|
|
const longerAgo = new Date(new Date().getTime() - 100001);
|
|
|
|
getFunctionStub
|
|
.onCall(0)
|
|
.returns(BbPromise.resolve({ Configuration: { LastModified: longAgo } }));
|
|
getFunctionStub
|
|
.onCall(1)
|
|
.returns(BbPromise.resolve({ Configuration: { LastModified: longerAgo } }));
|
|
getFunctionStub
|
|
.onCall(2)
|
|
.returns(BbPromise.resolve({ Configuration: { LastModified: now } }));
|
|
|
|
awsDeploy.serverless.service.functions = {
|
|
first: {
|
|
events: [{ someevent: 'abc' }],
|
|
},
|
|
second: {
|
|
events: [{ anothaone: '1' }],
|
|
},
|
|
third: {
|
|
events: [{ thebest: 'around' }],
|
|
},
|
|
};
|
|
|
|
awsDeploy.serverless.service.setFunctionNames();
|
|
|
|
return expect(awsDeploy.getFunctionsEarliestLastModifiedDate()).to.have.been.fulfilled.then(
|
|
ans => {
|
|
expect(ans.valueOf()).to.equal(longerAgo.valueOf());
|
|
expect(getFunctionStub).to.have.been.calledThrice;
|
|
}
|
|
);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('checkForChanges #2', () => {
|
|
after(fixtures.cleanup);
|
|
it('Should recognize package.artifcat', () =>
|
|
runServerless({
|
|
cwd: fixtures.map.packageArtifact,
|
|
cliArgs: ['deploy'],
|
|
env: { AWS_CONTAINER_CREDENTIALS_FULL_URI: 'ignore' },
|
|
lastLifecycleHookName: 'aws:deploy:deploy:checkForChanges',
|
|
awsRequestStubMap: {
|
|
CloudFormation: {
|
|
describeStacks: {},
|
|
describeStackResource: {
|
|
StackResourceDetail: { PhysicalResourceId: 'deployment-bucket' },
|
|
},
|
|
},
|
|
Lambda: {
|
|
getFunction: {
|
|
Configuration: {
|
|
LastModified: '2020-05-20T15:34:16.494+0000',
|
|
},
|
|
},
|
|
},
|
|
S3: {
|
|
headObject: {
|
|
Metadata: { filesha256: 'RRYyTm4Ri8mocpvx44pvas4JKLYtdJS3Z8MOlrZrDXA=' },
|
|
},
|
|
listObjectsV2: {
|
|
Contents: [
|
|
{
|
|
Key:
|
|
'serverless/test-package-artifact/dev/1589988704359-2020-05-20T15:31:44.359Z/artifact.zip',
|
|
LastModified: new Date(),
|
|
ETag: '"5102a4cf710cae6497dba9e61b85d0a4"',
|
|
Size: 356,
|
|
StorageClass: 'STANDARD',
|
|
},
|
|
],
|
|
},
|
|
},
|
|
STS: {
|
|
getCallerIdentity: {
|
|
ResponseMetadata: { RequestId: 'ffffffff-ffff-ffff-ffff-ffffffffffff' },
|
|
UserId: 'XXXXXXXXXXXXXXXXXXXXX',
|
|
Account: '999999999999',
|
|
Arn: 'arn:aws:iam::999999999999:user/test',
|
|
},
|
|
},
|
|
},
|
|
}).then(serverless => {
|
|
expect(
|
|
serverless.service.provider.compiledCloudFormationTemplate.Resources.FooLambdaFunction.Properties.Code.S3Key.endsWith(
|
|
'/artifact.zip'
|
|
)
|
|
).to.be.true;
|
|
}));
|
|
});
|