serverless/test/unit/scripts/serverless.test.js

'use strict'

const { expect } = require('chai')

const path = require('path')
const fsp = require('fs').promises
const spawn = require('child-process-ext/spawn')
const stripAnsi = require('strip-ansi')
const { version } = require('../../../package')
const programmaticFixturesEngine = require('../../fixtures/programmatic')

const serverlessBinPath = path.resolve(__dirname, '../../../bin/serverless.js')
const serverlessPath = path.resolve(__dirname, '../../../scripts/serverless.js')
const programmaticFixturesPath = path.resolve(
  __dirname,
  '../../fixtures/programmatic',
)
const cliFixturesPath = path.resolve(__dirname, '../../fixtures/cli')

describe('test/unit/scripts/serverless.test.js', () => {
  it('should display version when "--version" option', async () => {
    const output = String(
      (await spawn('node', [serverlessPath, '-v'])).stdoutBuffer,
    )
    expect(output).to.include(`Framework Core: ${version}`)
  })

  it('should not prevent help output with invalid service configuration', async () => {
    const output = String(
      (
        await spawn('node', [serverlessPath, '--help'], {
          cwd: path.resolve(cliFixturesPath, 'config-syntax-error'),
        })
      ).stdoutBuffer,
    )
    expect(output).to.include('serverless <command> <options>')
  })

  it('should report with an error invalid configuration', async () => {
    try {
      await spawn('node', [serverlessPath, 'print'], {
        cwd: path.resolve(cliFixturesPath, 'config-syntax-error'),
      })
      throw new Error('Unexpected')
    } catch (error) {
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include('Cannot parse')
    }
  })

  it('should handle exceptions', async () => {
    try {
      await spawn('node', [serverlessPath, 'print'], {
        cwd: path.resolve(programmaticFixturesPath, 'exception'),
      })
      throw new Error('Unexpected')
    } catch (error) {
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include('Error: Stop')
    }
  })

  it('should handle uncaught exceptions', async () => {
    try {
      await spawn('node', [serverlessPath, 'print'], {
        cwd: path.resolve(cliFixturesPath, 'uncaught-exception'),
      })
      throw new Error('Unexpected')
    } catch (error) {
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include('Error: Stop')
    }
  })

  it('should handle local serverless installation', async () => {
    const output = String(
      (
        await spawn('node', [serverlessBinPath, '--help'], {
          cwd: (
            await programmaticFixturesEngine.setup(
              'locally-installed-serverless',
            )
          ).servicePath,
        })
      ).stderrBuffer,
    )
    expect(output).to.include('Running "serverless" from node_modules')
  })

  it('should handle no service related commands', async () => {
    const output = String(
      (
        await spawn('node', [serverlessPath, 'plugin', 'list'], {
          cwd: path.resolve(cliFixturesPath, 'config-syntax-error'),
        })
      ).stdoutBuffer,
    )
    expect(output).to.include('Install a plugin by running')
  })

  it('should resolve variables', async () => {
    expect(
      String(
        (
          await spawn('node', [serverlessPath, 'print'], {
            cwd: path.resolve(cliFixturesPath, 'variables'),
          })
        ).stdoutBuffer,
      ),
    ).to.include('nestedInPrototype: bar-in-prototype')
  })

  it('should support multi service project', async () => {
    expect(
      String(
        (
          await spawn('node', [serverlessPath, 'print'], {
            cwd: path.resolve(
              programmaticFixturesPath,
              'multi-service/service-a',
            ),
          })
        ).stdoutBuffer,
      ),
    ).to.include('self: bar')
  })

  it('should support "-c" flag', async () => {
    expect(
      String(
        (
          await spawn(
            'node',
            [serverlessPath, 'print', '-c', 'serverless.custom.yml'],
            {
              cwd: path.resolve(
                programmaticFixturesPath,
                'custom-config-filename',
              ),
            },
          )
        ).stdoutBuffer,
      ),
    ).to.include('looks: good')
  })

  it('should support "-c" flag for "aws-service" commands', async () => {
    try {
      await spawn(
        'node',
        [serverlessPath, 'info', '-c', 'serverless.custom.yml'],
        {
          cwd: path.resolve(programmaticFixturesPath, 'custom-config-filename'),
        },
      )
      throw new Error('Unexpected')
    } catch (error) {
      // The way to validate it is to check if command errors out with missing credentials
      // at this point we know the configuration was resolved properly
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include(
        'AWS provider credentials not found',
      )
    }
  })

  it('should rejected unresolved "provider" section', async () => {
    try {
      await spawn('node', [serverlessPath, 'print'], {
        cwd: (
          await programmaticFixturesEngine.setup('aws', {
            configExt: { provider: '${foo:bar}' },
          })
        ).servicePath,
      })
      throw new Error('Unexpected')
    } catch (error) {
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include(
        '"provider.stage" property is not accessible',
      )
    }
  })

  it('should rejected unresolved "provider.stage" property', async () => {
    try {
      await spawn('node', [serverlessPath, 'print'], {
        cwd: (
          await programmaticFixturesEngine.setup('aws', {
            configExt: { provider: { stage: '${foo:bar}' } },
          })
        ).servicePath,
      })
      throw new Error('Unexpected')
    } catch (error) {
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include(
        '"provider.stage" property is not accessible',
      )
    }
  })

  it('should load env variables from dotenv files', async () => {
    const { servicePath: serviceDir } = await programmaticFixturesEngine.setup(
      'aws',
      {
        configExt: {
          useDotenv: true,
          custom: {
            fromDefaultEnv: '${env:DEFAULT_ENV_VARIABLE}',
          },
        },
      },
    )
    await fsp.writeFile(
      path.resolve(serviceDir, '.env'),
      'DEFAULT_ENV_VARIABLE=valuefromdefault',
    )
    expect(
      String(
        (await spawn('node', [serverlessPath, 'print'], { cwd: serviceDir }))
          .stdoutBuffer,
      ),
    ).to.include('fromDefaultEnv: valuefromdefault')
  })

  it('should allow not defined environment variables in provider.stage`', async () => {
    const { servicePath: serviceDir } = await programmaticFixturesEngine.setup(
      'aws',
      {
        configExt: {
          useDotenv: true,
          provider: {
            stage: "${env:FOO, 'dev'}",
          },
          custom: {
            fromDefaultEnv: '${env:DEFAULT_ENV_VARIABLE}',
          },
        },
      },
    )
    await fsp.writeFile(
      path.resolve(serviceDir, '.env'),
      'DEFAULT_ENV_VARIABLE=valuefromdefault',
    )
    const printOut = String(
      (await spawn('node', [serverlessPath, 'print'], { cwd: serviceDir }))
        .stdoutBuffer,
    )
    expect(printOut).to.include('fromDefaultEnv: valuefromdefault')
    expect(printOut).to.include('stage: dev')
  })

  it('should report "env" variables resolution conflicts with exception', async () => {
    const { servicePath: serviceDir } = await programmaticFixturesEngine.setup(
      'aws',
      {
        configExt: {
          useDotenv: true,
          provider: {
            stage: "${env:FOO, 'dev'}",
          },
        },
      },
    )
    await fsp.writeFile(path.resolve(serviceDir, '.env'), 'FOO=test')
    try {
      await spawn('node', [serverlessPath, 'print'], { cwd: serviceDir })
      throw new Error('Unexpected')
    } catch (error) {
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include(
        'Environment variable "FOO" which',
      )
    }
  })

  it('should support custom variable soruces', async () => {
    const { servicePath: serviceDir } = await programmaticFixturesEngine.setup(
      'plugin',
      {
        configExt: {
          custom: {
            otherVar: '${other:addressValue}',
          },
          plugins: ['./custom-variable-source'],
        },
      },
    )
    expect(
      String(
        (await spawn('node', [serverlessPath, 'print'], { cwd: serviceDir }))
          .stdoutBuffer,
      ),
    ).to.include('otherVar: Resolving variable addressValue')
  })

  it('should reject unresolved "plugins" property', async () => {
    try {
      await spawn('node', [serverlessPath, 'print'], {
        cwd: (
          await programmaticFixturesEngine.setup('aws', {
            configExt: { plugins: '${foo:bar}' },
          })
        ).servicePath,
      })
      throw new Error('Unexpected')
    } catch (error) {
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include(
        '"plugins" property is not accessible',
      )
    }
  })

  it('should throw meaningful error on unrecognized command for custom provider', async () => {
    try {
      await spawn('node', [serverlessPath, 'foo'], {
        cwd: (await programmaticFixturesEngine.setup('custom-provider'))
          .servicePath,
      })
      throw new Error('Unexpected')
    } catch (error) {
      if (!error.code) throw error
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include('command "foo" not found')
    }
  })

  it('should show help when requested and in context of invalid service configuration', async () => {
    const output = String(
      (
        await spawn('node', [serverlessPath, '--help'], {
          cwd: path.resolve(programmaticFixturesPath, 'config-invalid'),
        })
      ).stdoutBuffer,
    )
    expect(output).to.include('serverless <command> <options>')
  })

  it('should print general --help to stdout', async () => {
    const output = String(
      (await spawn('node', [serverlessPath, '--help'])).stdoutBuffer,
    )
    expect(output).to.include('serverless <command> <options>')
  })

  it('should print command --help to stdout', async () => {
    const output = String(
      (await spawn('node', [serverlessPath, 'deploy', '--help'])).stdoutBuffer,
    )
    expect(output).to.include('deploy')
    expect(output).to.include('stage')
  })

  it('should print not integrated command --help to stdout', async () => {
    const output = String(
      (await spawn('node', [serverlessPath, 'plugin', 'install', '--help']))
        .stdoutBuffer,
    )
    expect(output).to.include('plugin install')
    expect(output).to.include('stage')
  })

  it('should print interactive setup help to stdout', async () => {
    const output = String(
      (await spawn('node', [serverlessPath, '--help-interactive']))
        .stdoutBuffer,
    )
    expect(output).to.include('Interactive CLI')
    expect(output).to.not.include('Main commands')
  })

  it('should show help when running container command', async () => {
    // Note: Arbitrarily picked "plugin" command for testing
    const output = stripAnsi(
      String((await spawn('node', [serverlessPath, 'plugin'])).stdoutBuffer),
    )
    expect(output).to.include('plugin install')
  })

  it('should crash in required option is missing', async () => {
    try {
      await spawn('node', [
        serverlessPath,
        'config',
        'credentials',
        '-k',
        'foo',
        '-s',
        'bar',
      ])
      throw new Error('Unexpected')
    } catch (error) {
      expect(error.code).to.equal(1)
      expect(String(error.stdoutBuffer)).to.include(
        'command "config credentials" requires',
      )
    }
  })
})