'use strict'; /* eslint-disable no-unused-expressions */ const chai = require('chai'); const sinon = require('sinon'); const path = require('path'); const fs = require('fs'); const proxyquire = require('proxyquire'); const AwsProvider = require('../../../../../lib/plugins/aws/provider'); const Serverless = require('../../../../../lib/serverless'); const runServerless = require('../../../../utils/run-serverless'); const { getTmpDirPath } = require('../../../../utils/fs'); chai.use(require('chai-as-promised')); chai.use(require('sinon-chai')); const expect = chai.expect; const consoleLayerArn = 'arn:aws:lambda:us-east-1:321667558080:layer:sls-sdk:1'; describe('AwsDeployFunction', () => { let AwsDeployFunction; let serverless; let awsDeployFunction; let cryptoStub; beforeEach(async () => { serverless = new Serverless({ commands: ['print'], options: {}, serviceDir: null }); serverless.servicePath = true; serverless.service.environment = { vars: {}, stages: { dev: { vars: {}, regions: { 'us-east-1': { vars: {}, }, }, }, }, }; serverless.service.serviceObject = {}; serverless.service.functions = { first: { handler: true, }, }; const options = { stage: 'dev', region: 'us-east-1', function: 'first', functionObj: { name: 'first', }, }; await serverless.init(); serverless.setProvider('aws', new AwsProvider(serverless, options)); cryptoStub = { createHash() { return this; }, update() { return this; }, digest: sinon.stub(), }; AwsDeployFunction = proxyquire('../../../../../lib/plugins/aws/deploy-function', { crypto: cryptoStub, }); awsDeployFunction = new AwsDeployFunction(serverless, options); }); describe('#constructor()', () => { it('should have hooks', () => expect(awsDeployFunction.hooks).to.be.not.empty); it('should set the provider variable to an instance of AwsProvider', () => expect(awsDeployFunction.provider).to.be.instanceof(AwsProvider)); it('should set an empty options object if no options are given', () => { const awsDeployFunctionWithEmptyOptions = new AwsDeployFunction(serverless); expect(awsDeployFunctionWithEmptyOptions.options).to.deep.equal({}); }); }); describe('#checkIfFunctionExists()', () => { let getFunctionStub; beforeEach(() => { getFunctionStub = sinon .stub(awsDeployFunction.provider, 'request') .resolves({ func: { name: 'first' } }); }); afterEach(() => { awsDeployFunction.provider.request.restore(); }); it('it should throw error if function is not provided', async () => { serverless.service.functions = {}; await expect(awsDeployFunction.checkIfFunctionExists()).to.eventually.be.rejected; }); it('should check if the function is deployed and save the result', async () => { awsDeployFunction.serverless.service.functions = { first: { name: 'first', handler: 'handler.first', }, }; await awsDeployFunction.checkIfFunctionExists(); expect(getFunctionStub.calledOnce).to.be.equal(true); expect( getFunctionStub.calledWithExactly('Lambda', 'getFunction', { FunctionName: 'first', }) ).to.be.equal(true); expect(awsDeployFunction.serverless.service.provider.remoteFunctionData).to.deep.equal({ func: { name: 'first', }, }); }); }); describe('#normalizeArnRole', () => { let getAccountInfoStub; let getRoleStub; beforeEach(() => { // Ensure that memoized function will be properly stubbed awsDeployFunction.provider.getAccountInfo; getAccountInfoStub = sinon .stub(awsDeployFunction.provider, 'getAccountInfo') .resolves({ accountId: '123456789012', partition: 'aws' }); getRoleStub = sinon .stub(awsDeployFunction.provider, 'request') .resolves({ Arn: 'arn:aws:iam::123456789012:role/role_2' }); serverless.service.resources = { Resources: { MyCustomRole: { Type: 'AWS::IAM::Role', Properties: { RoleName: 'role_123', }, }, }, }; }); afterEach(() => { awsDeployFunction.provider.getAccountInfo.restore(); awsDeployFunction.provider.request.restore(); serverless.service.resources = undefined; }); it('should return unmodified ARN if ARN was provided', async () => { const arn = 'arn:aws:iam::123456789012:role/role'; const result = await awsDeployFunction.normalizeArnRole(arn); expect(getAccountInfoStub).to.not.have.been.called; expect(result).to.be.equal(arn); }); it('should return compiled ARN if role name was provided', async () => { const roleName = 'MyCustomRole'; const result = await awsDeployFunction.normalizeArnRole(roleName); expect(getAccountInfoStub).to.have.been.called; expect(result).to.be.equal('arn:aws:iam::123456789012:role/role_123'); }); it('should return compiled ARN if object role was provided', async () => { const roleObj = { 'Fn::GetAtt': ['role_2', 'Arn'], }; const result = await awsDeployFunction.normalizeArnRole(roleObj); expect(getRoleStub.calledOnce).to.be.equal(true); expect(getAccountInfoStub).to.not.have.been.called; expect(result).to.be.equal('arn:aws:iam::123456789012:role/role_2'); }); }); describe('#deployFunction()', () => { let artifactFilePath; let updateFunctionCodeStub; let statSyncStub; let readFileSyncStub; beforeEach(() => { // write a file to disc to simulate that the deployment artifact exists awsDeployFunction.packagePath = getTmpDirPath(); artifactFilePath = path.join(awsDeployFunction.packagePath, 'first.zip'); serverless.utils.writeFileSync(artifactFilePath, 'first.zip file content'); updateFunctionCodeStub = sinon.stub(awsDeployFunction.provider, 'request').resolves(); statSyncStub = sinon.stub(fs, 'statSync').returns({ size: 1024 }); readFileSyncStub = sinon.stub(fs, 'readFileSync').returns(); awsDeployFunction.serverless.service.provider.remoteFunctionData = { Configuration: { CodeSha256: 'remote-hash-zip-file', }, }; }); afterEach(() => { awsDeployFunction.provider.request.restore(); fs.statSync.restore(); fs.readFileSync.restore(); }); it('should deploy the function if the hashes are different', async () => { cryptoStub.createHash().update().digest.onCall(0).returns('local-hash-zip-file'); await awsDeployFunction.deployFunction(); const data = fs.readFileSync(artifactFilePath); expect(updateFunctionCodeStub.calledOnce).to.be.equal(true); expect(readFileSyncStub.called).to.equal(true); expect( updateFunctionCodeStub.calledWithExactly('Lambda', 'updateFunctionCode', { FunctionName: 'first', ZipFile: data, }) ).to.be.equal(true); expect(readFileSyncStub.calledWithExactly(artifactFilePath)).to.equal(true); }); it('should deploy the function if the hashes are same but the "force" option is used', async () => { awsDeployFunction.options.force = true; cryptoStub.createHash().update().digest.onCall(0).returns('remote-hash-zip-file'); await awsDeployFunction.deployFunction(); const data = fs.readFileSync(artifactFilePath); expect(updateFunctionCodeStub.calledOnce).to.be.equal(true); expect(readFileSyncStub.called).to.equal(true); expect( updateFunctionCodeStub.calledWithExactly('Lambda', 'updateFunctionCode', { FunctionName: 'first', ZipFile: data, }) ).to.be.equal(true); expect(readFileSyncStub.calledWithExactly(artifactFilePath)).to.equal(true); }); it('should resolve if the hashes are the same', async () => { cryptoStub.createHash().update().digest.onCall(0).returns('remote-hash-zip-file'); await awsDeployFunction.deployFunction(); expect(updateFunctionCodeStub.calledOnce).to.be.equal(false); expect(readFileSyncStub.calledOnce).to.equal(true); expect(readFileSyncStub.calledWithExactly(artifactFilePath)).to.equal(true); }); it('should log artifact size', async () => { // awnY7Oi280gp5kTCloXzsqJCO4J766x6hATWqQsN/uM= <-- hash of the local zip file readFileSyncStub.returns(Buffer.from('my-service.zip content')); await awsDeployFunction.deployFunction(); expect(readFileSyncStub.calledOnce).to.equal(true); expect(statSyncStub.calledOnce).to.equal(true); expect(readFileSyncStub.calledWithExactly(artifactFilePath)).to.equal(true); }); describe('when artifact is provided', () => { let getFunctionStub; const artifactZipFile = 'artifact.zip'; beforeEach(() => { getFunctionStub = sinon.stub(serverless.service, 'getFunction').returns({ handler: true, package: { artifact: artifactZipFile, }, }); }); afterEach(() => { serverless.service.getFunction.restore(); }); it('should read the provided artifact', async () => { await awsDeployFunction.deployFunction(); const data = fs.readFileSync(artifactZipFile); expect(readFileSyncStub).to.have.been.calledWithExactly(artifactZipFile); expect(statSyncStub).to.have.been.calledWithExactly(artifactZipFile); expect(getFunctionStub).to.have.been.calledWithExactly('first'); expect(updateFunctionCodeStub.calledOnce).to.equal(true); expect( updateFunctionCodeStub.calledWithExactly('Lambda', 'updateFunctionCode', { FunctionName: 'first', ZipFile: data, }) ).to.be.equal(true); }); }); }); }); describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => { const kmsKeyArn = 'arn:aws:kms:us-east-1:123456789012'; const description = 'func description'; const handler = 'funcHandler'; const functionName = 'funcName'; const memorySize = 255; const onErrorHandler = 'arn:aws:sns:us-east-1:123456789012:onerror'; const timeout = 50; const layerArn = 'arn:aws:lambda:us-east-1:123456789012:layer:layer:1'; const secondLayerArn = 'arn:aws:lambda:us-east-1:123456789012:layer:layer:2'; const role = 'arn:aws:iam::123456789012:role/Admin'; const imageSha = '6bb600b4d6e1d7cf521097177dd0c4e9ea373edb91984a505333be8ac9455d38'; const imageWithSha = `000000000000.dkr.ecr.sa-east-1.amazonaws.com/test-lambda-docker@sha256:${imageSha}`; const updateFunctionCodeStub = sinon.stub(); const updateFunctionConfigurationStub = sinon.stub(); const awsRequestStubMap = { Lambda: { getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', State: 'Active', LastUpdateStatus: 'Successful', }, }, updateFunctionCode: updateFunctionCodeStub, updateFunctionConfiguration: updateFunctionConfigurationStub, }, STS: { getCallerIdentity: { ResponseMetadata: { RequestId: 'ffffffff-ffff-ffff-ffff-ffffffffffff' }, UserId: 'XXXXXXXXXXXXXXXXXXXXX', Account: '999999999999', Arn: 'arn:aws:iam::999999999999:user/test', }, }, }; beforeEach(() => { updateFunctionCodeStub.resetHistory(); updateFunctionConfigurationStub.resetHistory(); }); // This is just a happy-path test of images support. Due to sharing code from `provider.js` // all further configurations are tested as a part of `test/unit/lib/plugins/aws/provider.test.js` it('should support deploying function that has image defined with sha', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'foo' }, awsRequestStubMap, configExt: { functions: { foo: { image: imageWithSha, }, }, }, }); expect(updateFunctionCodeStub).to.be.calledOnce; expect(updateFunctionCodeStub.args[0][0].ImageUri).to.equal(imageWithSha); }); it('should support updating function with image config', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'foo' }, awsRequestStubMap, configExt: { functions: { foo: { image: { uri: imageWithSha, workingDirectory: './workdir', entryPoint: ['executable', 'param1'], command: ['anotherexecutable'], }, }, }, }, }); expect(updateFunctionCodeStub).to.be.calledOnce; expect(updateFunctionCodeStub.args[0][0].ImageUri).to.equal(imageWithSha); expect(updateFunctionConfigurationStub).to.be.calledOnce; expect(updateFunctionConfigurationStub.args[0][0].ImageConfig).to.deep.equal({ Command: ['anotherexecutable'], EntryPoint: ['executable', 'param1'], WorkingDirectory: './workdir', }); }); it('should skip updating function configuration if image config did not change', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', CodeSha256: imageSha, State: 'Active', LastUpdateStatus: 'Successful', ImageConfigResponse: { ImageConfig: { Command: ['anotherexecutable'], EntryPoint: ['executable', 'param1'], WorkingDirectory: './workdir', }, }, }, }, }, }, configExt: { functions: { basic: { handler: null, image: { uri: imageWithSha, workingDirectory: './workdir', entryPoint: ['executable', 'param1'], command: ['anotherexecutable'], }, }, }, }, }); expect(updateFunctionConfigurationStub).not.to.be.called; }); it('should skip deployment if image sha did not change', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', CodeSha256: imageSha, State: 'Active', LastUpdateStatus: 'Successful', }, }, }, }, configExt: { functions: { basic: { image: imageWithSha, }, }, }, }); expect(updateFunctionCodeStub).not.to.be.called; }); it('should fail if function with image was previously defined with handler', async () => { await expect( runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', State: 'Active', LastUpdateStatus: 'Successful', }, }, }, }, configExt: { functions: { basic: { image: imageWithSha, }, }, }, }) ).to.be.eventually.rejected.and.have.property( 'code', 'DEPLOY_FUNCTION_CHANGE_BETWEEN_HANDLER_AND_IMAGE_ERROR' ); }); it('should fail if function with image was previously defined with handler', async () => { await expect( runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Image', State: 'Active', LastUpdateStatus: 'Successful', }, }, }, }, }) ).to.be.eventually.rejected.and.have.property( 'code', 'DEPLOY_FUNCTION_CHANGE_BETWEEN_HANDLER_AND_IMAGE_ERROR' ); }); it('should handle retry when `updateFunctionConfiguration` returns `ResourceConflictException` error', async () => { const innerUpdateFunctionConfigurationStub = sinon .stub() .onFirstCall() .throws({ providerError: { code: 'ResourceConflictException' } }) .onSecondCall() .resolves({}); await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, updateFunctionConfiguration: innerUpdateFunctionConfigurationStub, }, }, modulesCacheStub: { 'timers-ext/promise/sleep': sinon.stub().returns({}), }, configExt: { functions: { basic: { timeout: 50, }, }, }, }); expect(innerUpdateFunctionConfigurationStub.callCount).to.equal(2); }); it('should update function configuration if configuration changed', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', State: 'Active', LastUpdateStatus: 'Successful', }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, }, functions: { basic: { kmsKeyArn, description, handler, environment: { VARIABLE: 'value', }, name: functionName, memorySize, onError: onErrorHandler, role, timeout, vpc: { securityGroupIds: ['sg-111', 'sg-222'], subnetIds: ['subnet-111', 'subnet-222'], }, layers: [layerArn, secondLayerArn], }, }, }, }); expect(updateFunctionConfigurationStub).to.be.calledWithExactly({ FunctionName: functionName, KMSKeyArn: kmsKeyArn, Description: description, Handler: handler, Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', }, }, MemorySize: memorySize, Timeout: timeout, DeadLetterConfig: { TargetArn: onErrorHandler, }, Role: role, VpcConfig: { SecurityGroupIds: ['sg-111', 'sg-222'], SubnetIds: ['subnet-111', 'subnet-222'], }, Layers: [layerArn, secondLayerArn], }); }); it('should recognize layers at `provider.layers`', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', State: 'Active', LastUpdateStatus: 'Successful', }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, layers: [layerArn, secondLayerArn], }, functions: { basic: { kmsKeyArn, description, handler, environment: { VARIABLE: 'value', }, name: functionName, memorySize, onError: onErrorHandler, role, timeout, vpc: { securityGroupIds: ['sg-111', 'sg-222'], subnetIds: ['subnet-111', 'subnet-222'], }, }, }, }, }); expect(updateFunctionConfigurationStub).to.be.calledWithExactly({ FunctionName: functionName, KMSKeyArn: kmsKeyArn, Description: description, Handler: handler, Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', }, }, MemorySize: memorySize, Timeout: timeout, DeadLetterConfig: { TargetArn: onErrorHandler, }, Role: role, VpcConfig: { SecurityGroupIds: ['sg-111', 'sg-222'], SubnetIds: ['subnet-111', 'subnet-222'], }, Layers: [layerArn, secondLayerArn], }); }); it('should update function configuration if configuration changed where all arn layers were removed', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', Description: description, Handler: handler, State: 'Active', LastUpdateStatus: 'Successful', Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', }, }, FunctionName: functionName, MemorySize: memorySize, Layers: [{ Arn: secondLayerArn }, { Arn: layerArn }], }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, }, functions: { basic: { description, handler, environment: { VARIABLE: 'value', }, name: functionName, memorySize, layers: [], }, }, }, }); expect(updateFunctionConfigurationStub).to.be.calledWithExactly({ FunctionName: functionName, Layers: [], }); }); it('should update function configuration if the configuration changed and is managed by serverless console', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', Description: description, Handler: handler, State: 'Active', LastUpdateStatus: 'Successful', Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', AWS_LAMBDA_EXEC_WRAPPER: '/opt/lib/libthundra-wrapper.so', SLS_ORG_ID: '123', }, }, FunctionName: functionName, MemorySize: memorySize, Layers: [{ Arn: layerArn }, { Arn: consoleLayerArn }], }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, }, functions: { basic: { description, handler, environment: { VARIABLE: 'value', VARIABLE2: 'value2', }, name: functionName, memorySize, layers: [layerArn, secondLayerArn], }, }, }, }); expect(updateFunctionConfigurationStub).to.be.calledWithExactly({ FunctionName: functionName, Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', VARIABLE2: 'value2', AWS_LAMBDA_EXEC_WRAPPER: '/opt/lib/libthundra-wrapper.so', SLS_ORG_ID: '123', }, }, Layers: [layerArn, secondLayerArn, consoleLayerArn], }); }); it('should update function configuration and remove local arn layers if the configuration changed and is managed by serverless console', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', Description: description, Handler: handler, State: 'Active', LastUpdateStatus: 'Successful', Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', AWS_LAMBDA_EXEC_WRAPPER: '/opt/lib/libthundra-wrapper.so', SLS_ORG_ID: '123', }, }, FunctionName: functionName, MemorySize: memorySize, Layers: [{ Arn: layerArn }, { Arn: consoleLayerArn }], }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, }, functions: { basic: { description, handler, environment: {}, name: functionName, memorySize, layers: [], }, }, }, }); expect(updateFunctionConfigurationStub).to.be.calledWithExactly({ FunctionName: functionName, Environment: { Variables: { ANOTHERVAR: 'anothervalue', AWS_LAMBDA_EXEC_WRAPPER: '/opt/lib/libthundra-wrapper.so', SLS_ORG_ID: '123', }, }, Layers: [consoleLayerArn], }); }); it('should skip updating properties that contain references', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', State: 'Active', LastUpdateStatus: 'Successful', }, }, }, }, configExt: { functions: { basic: { name: functionName, role, timeout, vpc: { securityGroupIds: ['sg-111', { Ref: 'mySGRef' }], subnetIds: ['subnet-111', 'subnet-222'], }, environment: { VARIABLE: { Ref: 'SomeReference', }, }, }, }, }, }); expect(updateFunctionConfigurationStub).to.be.calledWithExactly({ FunctionName: functionName, Handler: 'basic.handler', Timeout: timeout, VpcConfig: { SubnetIds: ['subnet-111', 'subnet-222'], }, Role: role, }); }); it('should update function configuration with provider-level properties', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', State: 'Active', LastUpdateStatus: 'Successful', }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', }, memorySize, iam: { role }, timeout, vpc: { securityGroupIds: ['sg-111', 'sg-222'], subnetIds: ['subnet-111', 'subnet-222'], }, }, functions: { basic: { name: functionName, }, }, }, }); expect(updateFunctionConfigurationStub).to.be.calledWithExactly({ FunctionName: functionName, Handler: 'basic.handler', Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', }, }, MemorySize: memorySize, Timeout: timeout, Role: role, VpcConfig: { SecurityGroupIds: ['sg-111', 'sg-222'], SubnetIds: ['subnet-111', 'subnet-222'], }, }); }); it('should not update function configuration if configuration did not change', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', KMSKeyArn: kmsKeyArn, Description: description, Handler: handler, State: 'Active', LastUpdateStatus: 'Successful', Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', }, }, FunctionName: functionName, MemorySize: memorySize, DeadLetterConfig: { TargetArn: onErrorHandler, }, Timeout: timeout, Layers: [{ Arn: secondLayerArn }, { Arn: layerArn }], Role: role, VpcConfig: { VpcId: 'vpc-xxxx', SecurityGroupIds: ['sg-111', 'sg-222'], SubnetIds: ['subnet-222', 'subnet-111'], }, }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, }, functions: { basic: { kmsKeyArn, description, handler, environment: { VARIABLE: 'value', }, name: functionName, memorySize, onError: onErrorHandler, role, timeout, vpc: { securityGroupIds: ['sg-111', 'sg-222'], subnetIds: ['subnet-111', 'subnet-222'], }, layers: [layerArn, secondLayerArn], }, }, }, }); expect(updateFunctionConfigurationStub).not.to.be.called; }); it('should not update function configuration if configuration includes console managed functions', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', KMSKeyArn: kmsKeyArn, Description: description, Handler: handler, State: 'Active', LastUpdateStatus: 'Successful', Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', AWS_LAMBDA_EXEC_WRAPPER: '/opt/lib/libthundra-wrapper.so', SLS_ORG_ID: '123', }, }, FunctionName: functionName, MemorySize: memorySize, DeadLetterConfig: { TargetArn: onErrorHandler, }, Timeout: timeout, Layers: [{ Arn: secondLayerArn }, { Arn: layerArn }, { Arn: consoleLayerArn }], Role: role, VpcConfig: { VpcId: 'vpc-xxxx', SecurityGroupIds: ['sg-111', 'sg-222'], SubnetIds: ['subnet-222', 'subnet-111'], }, }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, }, functions: { basic: { kmsKeyArn, description, handler, environment: { VARIABLE: 'value', }, name: functionName, memorySize, onError: onErrorHandler, role, timeout, vpc: { securityGroupIds: ['sg-111', 'sg-222'], subnetIds: ['subnet-111', 'subnet-222'], }, layers: [layerArn, secondLayerArn], }, }, }, }); expect(updateFunctionConfigurationStub).not.to.be.called; }); it('should not update function configuration if configuration includes console managed layers locally', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', Description: description, Handler: handler, State: 'Active', LastUpdateStatus: 'Successful', Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', AWS_LAMBDA_EXEC_WRAPPER: '/opt/lib/libthundra-wrapper.so', SLS_ORG_ID: '123', }, }, FunctionName: functionName, MemorySize: memorySize, Layers: [{ Arn: secondLayerArn }, { Arn: layerArn }, { Arn: consoleLayerArn }], }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, }, functions: { basic: { description, handler, environment: { VARIABLE: 'value', AWS_LAMBDA_EXEC_WRAPPER: '/opt/lib/libthundra-wrapper.so', SLS_ORG_ID: '123', }, name: functionName, memorySize, layers: [layerArn, secondLayerArn, consoleLayerArn], }, }, }, }); expect(updateFunctionConfigurationStub).not.to.be.called; }); it('should not update function configuration if function is console managed and has reference layers', async () => { const runServerlessConfig = { fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', Description: description, Handler: handler, State: 'Active', LastUpdateStatus: 'Successful', Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', AWS_LAMBDA_EXEC_WRAPPER: '/opt/lib/libthundra-wrapper.so', SLS_ORG_ID: '123', }, }, FunctionName: functionName, MemorySize: memorySize, Layers: [{ Arn: layerArn }, { Arn: consoleLayerArn }], }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, }, functions: { basic: { description, handler, environment: { VARIABLE: 'value', }, name: functionName, memorySize, layers: [layerArn, { Ref: 'TestLambdaLayer' }], }, }, }, }; await runServerless(runServerlessConfig); expect(updateFunctionConfigurationStub).not.to.be.called; }); it('should not update function configuration if function has reference layers', async () => { const runServerlessConfig = { fixture: 'function', command: 'deploy function', options: { function: 'basic' }, awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', PackageType: 'Zip', Description: description, Handler: handler, State: 'Active', LastUpdateStatus: 'Successful', Environment: { Variables: { ANOTHERVAR: 'anothervalue', VARIABLE: 'value', }, }, FunctionName: functionName, MemorySize: memorySize, Layers: [{ Arn: layerArn }], }, }, }, }, configExt: { provider: { environment: { ANOTHERVAR: 'anothervalue', }, }, functions: { basic: { description, handler, environment: { VARIABLE: 'value', }, name: functionName, memorySize, layers: [layerArn, { Ref: 'TestLambdaLayer' }], }, }, }, }; await runServerless(runServerlessConfig); expect(updateFunctionConfigurationStub).not.to.be.called; }); it('configuration uses `provider.kmsKeyArn` if no `kmsKeyArn` provided on function level', async () => { await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, lastLifecycleHookName: 'deploy:function:deploy', awsRequestStubMap, configExt: { provider: { kmsKeyArn: 'arn:aws:kms:us-east-1:oldKey', }, functions: { basic: { handler: 'index.handler', name: 'foobar', }, }, }, }); sinon.assert.calledWith(updateFunctionConfigurationStub, { Handler: 'index.handler', FunctionName: 'foobar', KMSKeyArn: 'arn:aws:kms:us-east-1:oldKey', }); }); it("should surface request error if it's not about function not being found", async () => { await expect( runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, lastLifecycleHookName: 'deploy:function:deploy', awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: () => { throw new Error('Some side error'); }, }, }, }) ).to.be.eventually.rejectedWith('Some side error'); }); it('should surface meaningful error if function is not yet deployed', async () => { await expect( runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, lastLifecycleHookName: 'deploy:function:deploy', awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: () => { throw Object.assign(new Error('Function not found'), { providerError: { code: 'ResourceNotFoundException', }, }); }, }, }, }) ).to.be.eventually.rejected.and.have.property('code', 'FUNCTION_NOT_YET_DEPLOYED'); }); it('should handle situation where function is not immediately in desired state', async () => { const successResponse = { Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', State: 'Active', LastUpdateStatus: 'Successful', }, }; const getFunctionStub = sinon .stub() .resolves(successResponse) .onCall(1) .resolves({ Configuration: { LastModified: '2020-05-20T15:34:16.494+0000', State: 'Active', LastUpdateStatus: 'InProgress', }, }) .onCall(2) .resolves(successResponse); await runServerless({ fixture: 'function', command: 'deploy function', options: { function: 'basic' }, lastLifecycleHookName: 'deploy:function:deploy', awsRequestStubMap: { ...awsRequestStubMap, Lambda: { ...awsRequestStubMap.Lambda, getFunction: getFunctionStub, }, }, }); expect(getFunctionStub).to.have.been.calledThrice; }); });