serverless/lib/plugins/aws/dev/local-lambda/test/local-lambda.test.js

const path = require('path');
const LocalLambda = require('..');

const context = {
  functionName: 'test-lambda',
  functionVersion: '$LATEST',
  memoryLimitInMB: '1024',
  logGroupName: '/aws/lambda/test-lambda',
  logStreamName: '2024/03/27/[$LATEST]c1c2c943f42c4038a764938980b95d99',
  invokedFunctionArn: 'arn:aws:lambda:us-east-1:552750238299:function:test-lambda',
  awsRequestId: 'e70aeb5a-f349-4af5-b22e-defc21581de3',
  callbackWaitsForEmptyEventLoop: true,
};

describe('.js functions', () => {
  it('should invoke and return the response', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'js'),
      handler: 'handlers.hello',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: 'Hello',
      },
      error: null,
    });
  });

  it('should pass the event to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'js'),
      handler: 'handlers.event',
      runtime: 'nodejs20.x',
    });

    const event = {
      foo: 'bar',
    };

    const result = await localLambda.invoke(event);

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: event,
      },
      error: null,
    });
  });

  it('should pass the environment to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'js'),
      handler: 'handlers.environment',
      runtime: 'nodejs20.x',
      environment: {
        FOO: 'BAR',
      },
    });

    const result = await localLambda.invoke();

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: 'BAR',
      },
      error: null,
    });
  });

  it('should pass the context to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'js'),
      handler: 'handlers.context',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke({}, context);

    expect(result.response).toMatchObject(context);
  });

  it('should pass the callback to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'js'),
      handler: 'handlers.callback',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result.response).toEqual('Hello');
  });

  it('should not reject in case of errors', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'js'),
      handler: 'handlers.error',
      runtime: 'nodejs20.x',
    });

    await expect(localLambda.invoke()).resolves.not.toThrow();
  });

  it('should return error information', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'js'),
      handler: 'handlers.error',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result.error.name).toEqual('Error');
    expect(result.error.message).toEqual('This error should not fail the test');
    expect(result.error.stack).toBeDefined();
  });
});

describe('.cjs functions', () => {
  it('should invoke and return the response', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'cjs'),
      handler: 'handlers.hello',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: 'Hello',
      },
      error: null,
    });
  });

  it('should pass the event to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'cjs'),
      handler: 'handlers.event',
      runtime: 'nodejs20.x',
    });

    const event = {
      foo: 'bar',
    };

    const result = await localLambda.invoke(event);

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: event,
      },
      error: null,
    });
  });

  it('should pass the environment to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'cjs'),
      handler: 'handlers.environment',
      runtime: 'nodejs20.x',
      environment: {
        FOO: 'BAR',
      },
    });

    const result = await localLambda.invoke();

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: 'BAR',
      },
      error: null,
    });
  });

  it('should pass the context to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'cjs'),
      handler: 'handlers.context',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke({}, context);

    expect(result.response).toMatchObject(context);
  });

  it('should pass the callback to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'cjs'),
      handler: 'handlers.callback',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result.response).toEqual('Hello');
  });

  it('should not reject in case of errors', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'cjs'),
      handler: 'handlers.error',
      runtime: 'nodejs20.x',
    });

    await expect(localLambda.invoke()).resolves.not.toThrow();
  });

  it('should return error information', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'cjs'),
      handler: 'handlers.error',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result.error.name).toEqual('Error');
    expect(result.error.message).toEqual('This error should not fail the test');
    expect(result.error.stack).toBeDefined();
  });
});

describe('.mjs functions', () => {
  it('should invoke and return response', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'mjs'),
      handler: 'handlers.hello',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke({});

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: 'Hello',
      },
      error: null,
    });
  });

  it('should pass the event to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'mjs'),
      handler: 'handlers.event',
      runtime: 'nodejs20.x',
    });

    const event = {
      foo: 'bar',
    };

    const result = await localLambda.invoke(event);

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: event,
      },
      error: null,
    });
  });

  it('should pass the environment to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'mjs'),
      handler: 'handlers.environment',
      runtime: 'nodejs20.x',
      environment: {
        FOO: 'BAR',
      },
    });

    const result = await localLambda.invoke();

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: 'BAR',
      },
      error: null,
    });
  });

  it('should pass the context to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'mjs'),
      handler: 'handlers.context',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke({}, context);

    expect(result.response).toMatchObject(context);
  });

  it('should should not reject in case of errors', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'mjs'),
      handler: 'handlers.error',
      runtime: 'nodejs20.x',
    });

    await expect(localLambda.invoke()).resolves.not.toThrow();
  });

  it('should pass the callback to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'mjs'),
      handler: 'handlers.callback',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result.response).toEqual('Hello');
  });

  it('should return error information', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'mjs'),
      handler: 'handlers.error',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result.error.name).toEqual('Error');
    expect(result.error.message).toEqual('This error should not fail the test');
    expect(result.error.stack).toBeDefined();
  });
});

describe('.ts functions', () => {
  it('should invoke and return the response', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'ts'),
      handler: 'handlers.hello',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke({});

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: 'Hello',
      },
      error: null,
    });
  });

  it('should pass the event to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'ts'),
      handler: 'handlers.event',
      runtime: 'nodejs20.x',
    });

    const event = {
      foo: 'bar',
    };

    const result = await localLambda.invoke(event);

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: event,
      },
      error: null,
    });
  });

  it('should pass the environment to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'ts'),
      handler: 'handlers.environment',
      runtime: 'nodejs20.x',
      environment: {
        FOO: 'BAR',
      },
    });

    const result = await localLambda.invoke();

    expect(result).toEqual({
      response: {
        statusCode: 200,
        body: 'BAR',
      },
      error: null,
    });
  });

  it('should pass the context to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'ts'),
      handler: 'handlers.context',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke({}, context);

    expect(result.response).toMatchObject(context);
  });

  it('should pass the callback to the handler', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'ts'),
      handler: 'handlers.callback',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result.response).toEqual('Hello');
  });

  it('should should not reject in case of errors', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'ts'),
      handler: 'handlers.error',
      runtime: 'nodejs20.x',
    });

    await expect(localLambda.invoke()).resolves.not.toThrow();
  });

  it('should return error information', async () => {
    const localLambda = new LocalLambda({
      serviceAbsolutePath: path.resolve(__dirname, 'handlers', 'ts'),
      handler: 'handlers.error',
      runtime: 'nodejs20.x',
    });

    const result = await localLambda.invoke();

    expect(result.error.name).toEqual('Error');
    expect(result.error.message).toEqual('This error should not fail the test');
    expect(result.error.stack).toBeDefined();
  });
});