serverless/test/unit/lib/plugins/aws/deploy-function.test.js

'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;
  });
});