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