serverless/test/integration-basic.test.js

'use strict'

const path = require('path')
const fs = require('fs')
const fse = require('fs-extra')
const stripAnsi = require('strip-ansi')
const { expect } = require('chai')
const log = require('log').get('serverless:test')
const spawn = require('child-process-ext/spawn')
const resolveAwsEnv = require('@serverless/test/resolve-aws-env')
const hasFailed = require('@serverless/test/has-failed')
const awsRequest = require('@serverless/test/aws-request')
const CloudFormationService = require('aws-sdk').CloudFormation
const { getTmpDirPath } = require('./utils/fs')

const serverlessExec = require('./serverless-binary')

describe('Service Lifecyle Integration Test', function () {
  this.timeout(1000 * 60 * 10) // Involves time-taking deploys
  const templateName = 'aws-nodejs'
  const tmpDir = getTmpDirPath()
  const env = resolveAwsEnv()
  const spawnOptions = {
    cwd: tmpDir,
    env,
    // As in invoke we optionally read stdin, we need to ensure it's closed
    // See https://github.com/sindresorhus/get-stdin/issues/13#issuecomment-279234249
    shouldCloseStdin: true,
  }
  let serviceName
  let StackName

  before(() => {
    serviceName = `test-basic-${process.hrtime()[1]}`
    StackName = `${serviceName}-dev`
    log.notice(`Temporary path: ${tmpDir}`)
    fse.mkdirsSync(tmpDir)
  })

  // Do not continue if any of the tests failed
  beforeEach(function () {
    if (hasFailed(this.test.parent)) this.skip()
  })

  after(async () => {
    try {
      await awsRequest(CloudFormationService, 'describeStacks', { StackName })
    } catch (error) {
      if (error.message.indexOf('does not exist') > -1) return
      throw error
    }
    await spawn(serverlessExec, ['remove'], { cwd: tmpDir, env })
  })

  it('should create service in tmp directory', async () => {
    await spawn(
      serverlessExec,
      ['create', '--template', templateName, '--name', serviceName],
      spawnOptions,
    )
    expect(fs.existsSync(path.join(tmpDir, 'serverless.yml'))).to.be.equal(true)
    expect(fs.existsSync(path.join(tmpDir, 'handler.js'))).to.be.equal(true)
  })

  it('should deploy service to aws', async () => {
    await spawn(serverlessExec, ['deploy'], { cwd: tmpDir, env })

    const d = await awsRequest(CloudFormationService, 'describeStacks', {
      StackName,
    })
    expect(d.Stacks[0].StackStatus).to.be.equal('UPDATE_COMPLETE')
  })

  it('should invoke function from aws', async () => {
    const { stdoutBuffer: invoked } = await spawn(
      serverlessExec,
      ['invoke', '--function', 'hello'],
      spawnOptions,
    )
    const result = JSON.parse(invoked)
    // parse it once again because the body is stringified to be LAMBDA-PROXY ready
    const message = JSON.parse(result.body).message
    expect(message).to.be.equal(
      'Go Serverless v1.0! Your function executed successfully!',
    )
  })

  it('should deploy updated service to aws', () => {
    const newHandler = `
        'use strict';

        module.exports.hello = (event, context, cb) => cb(null,
          { message: 'Service Update Succeeded' }
        );
      `

    fs.writeFileSync(path.join(tmpDir, 'handler.js'), newHandler)
    return spawn(serverlessExec, ['deploy'], spawnOptions)
  })

  it('should invoke updated function from aws', async () => {
    const { stdoutBuffer: invoked } = await spawn(
      serverlessExec,
      ['invoke', '--function', 'hello'],
      spawnOptions,
    )
    const result = JSON.parse(invoked)
    expect(result.message).to.be.equal('Service Update Succeeded')
  })

  it('should list existing deployments and roll back to first deployment', async () => {
    let timestamp
    const { stdoutBuffer: listDeploys } = await spawn(
      serverlessExec,
      ['deploy', 'list'],
      spawnOptions,
    )
    const output = stripAnsi(listDeploys.toString())
    const match = output.match(new RegExp('Timestamp: (.+)'))
    if (match) {
      timestamp = match[1]
    }
    expect(timestamp).to.not.undefined

    await spawn(serverlessExec, ['rollback', '-t', timestamp], {
      cwd: tmpDir,
      env,
    })

    const { stdoutBuffer: invoked } = await spawn(
      serverlessExec,
      ['invoke', '--function', 'hello'],
      spawnOptions,
    )
    const result = JSON.parse(invoked)
    // parse it once again because the body is stringified to be LAMBDA-PROXY ready
    const message = JSON.parse(result.body).message
    expect(message).to.be.equal(
      'Go Serverless v1.0! Your function executed successfully!',
    )
  })

  it('should remove service from aws', async () => {
    await spawn(serverlessExec, ['remove'], { cwd: tmpDir, env })

    const d = await (async () => {
      try {
        return await awsRequest(CloudFormationService, 'describeStacks', {
          StackName,
        })
      } catch (error) {
        if (error.message.indexOf('does not exist') > -1) return null
        throw error
      }
    })()
    if (!d) return
    expect(d.Stacks[0].StackStatus).to.be.equal('DELETE_COMPLETE')
  })
})