How to test AWS Lambda handler locally using NodeJS?

This is what I did:

index.js

exports.handler = async (event) => {
    console.log('hello world');

    const response = {
        statusCode: 200,
        body: JSON.stringify('Hello from Lambda!')
    };

    return response;
};

package.json

// using require
"scripts": {
  "locally": "node -e \"console.log(require('./index').handler(require('./event.json')));\""
}

// or the following for ESM using import
"scripts": {
  "locally": "node --input-type=module -e \"import {handler} from './index.mjs'; console.log(await handler(JSON.parse(fs.readFileSync('./event.json'))));\""
}

event.json

{
  "Records": [
    {
      "eventVersion": "2.0",
      "eventSource": "aws:s3",
      "awsRegion": "eu-central-1",
      "eventTime": "1970-01-01T00:00:00.000Z",
      "eventName": "ObjectCreated:Put",
      "userIdentity": {
        "principalId": "AIDAJDPLRKLG7UEXAMPLE"
      },
      "requestParameters": {
        "sourceIPAddress": "127.0.0.1"
      },
      "responseElements": {
        "x-amz-request-id": "C3D13FE58DE4C810",
        "x-amz-id-2": "FMyUVURIY8/IgAtTv8xRjskZQpcIZ9KG4V5Wp6S7S/JRWeUWerMUE5JgHvANOjpD"
      },
      "s3": {
        "s3SchemaVersion": "1.0",
        "configurationId": "testConfigRule",
        "bucket": {
          "name": "my-bucket",
          "ownerIdentity": {
            "principalId": "A3NL1KOZZKExample"
          },
          "arn": "arn:aws:s3:::my-bucket"
        },
        "object": {
          "key": "HelloWorld.jpg",
          "size": 1024,
          "eTag": "d41d8cd98f00b204e9800998ecf8427e",
          "versionId": "096fKKXTRTtl3on89fVO.nfljtsv6qko"
        }
      }
    }
  ]
}

Shell

npm run locally

Output

> node -e "console.log(require('./index').handler({}));"

hello world
Promise { { statusCode: 200, body: '"Hello from Lambda!"' } }

Perhaps the simplest way to get started, after some testing (with Node 14.17.3)

let handler = require('./index.js');

handler.handler ( 
  {}, // event
  {}, // content 
  (error, result) => { 
     if (error) console.error(JSON.stringify(error, null, 2));
     else console.log(JSON.stringify(result, null, 2));
  }
);

In your index.js, just defined and exported a handler function, but no one calls it. In the Lambda environment, some AWS code will call this handler with message. In your local environment, you have to call your handler by yourself.

You could also have a look of this doc, it is a way to "simulate" Lambda in local environment.

You can check out lambda-local. It's a little fancier than the accepted answer above. For example, it supports passing environment variables and using JSON files for your payloads.

If you want just to execute it locally you can use the official sam cli tool https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-invoke.html

If you use VSCode you can also check out this extension:

https://marketplace.visualstudio.com/items?itemName=bogdan-onu.invoke

Here I am giving a solution for the general case of an synchronous call.

Function signature in your entrypoint index.js:
exports.handler = function(event, context, callback) {

1. Create a caller file, e.g. testIndex.js
2. Give it the following contents:

    /**
    This is a caller for ./index.js
    */
    const thatIndex = require('./index');

    const EVENT = {
      "somekey": {
        "somesubkey": "somevalue"
      }
    }

    thatIndex.handler (
        // event
        EVENT,
        // context
        {},
        // callback function with two arguments
        function(err, payload) {
            console.log(err);
            console.log(payload);
        }
    );

3. Go back to your node console (Docker container suggested)
4. You may use environment variables, if your index.js needs them: define each with export MYVAR1=myvalue1
5. Run your caller: node testIndex.js
6. The console should output the payload, provided your main file (entrypoint) promise call is chained-up with: (example)

    .then(() => callback(null, {
       statusCode: 301,
       headers: {'location': process.env.URL + '/' + somekey },
       body: '',
       })
    )
    .catch(err => callback(err))

Tip: you may need to clean up the cache with node clean cache if you notice that it's the previous code that's called.

Other Tip: in the AWS environment, you don't need to zip up the node_modules/aws-sdk folder, as it will be part of the standard execution context. But on your test machine you will need to. So, in development mode, simple run npm install, not npm install --omit=dev

So, before zipping the folder that contains your function, just remove node_modules folder recursively, and rebuild the dependencies with npm install --ommit=dev

Example of zipping the folder: zip -r ..\resizeImage.zip .

This is what your package.json file could contain:

  "dependencies": {
    "sharp": "^0.27.2"
  },
  "devDependencies": {
    "aws-sdk": "^2.1195.0"
  }

IMO. The best way to test a lambda is to actually just test it! What does that mean? Will simply use some testing library (like jest for example) and simply create a test on your handler function. Mock anything you need and provide some data you expect that will come into the lambda (for the event and context if needed). And that's it. You have some tests written and a quick way to test your lambda at the same time.