Unit Testing AWS Lambda Functions in Node.js
Tags: aws, node, javascript, testing
Published: 2018-12-09 15:18:12

---
title: Unit Testing AWS Lambda Functions in Node.js
published: true
description: 
tags: AWS, Node, Javascript, Testing
---

Writing backend code - like web services or anything else really - with  AWS Lambda functions is amazingly easy, in particular when you choose Node.js as your weapon of choice. The amount of code required to get going is so sparse, it's almost magical. However, as you build out your Lambda, complexity will quickly rear its head, and you'll soon feel the need to add some tests.

Unit testing is a part of any good developer's workflow, but I feel it's especially important when dealing with dynamically typed languages, like vanilla Javascript. Its loosely-typed nature makes development fast, but also makes for a certain degree of uncertainty when making changes, or while refactoring. Good test coverage can make up for this, and it can allow you to work faster. If you're able to mock your Lambda's dependencies, you'll be pretty confident that your successful unit test is representative of the eventual production code.

## Dependency Injection

"Dependency Injection" is the somewhat intidimidating term used in software engineering to describe something quite simple:

> Dependency injection is a programming technique that makes a class independent of its dependencies. It achieves that by decoupling the usage of an object from its creation.

It's most useful when applied in the context of unit testing because it enables you to mock dependencies that shouldn't be active during tests.

In Node.js Lambda functions, dependencies are imported using the require() function. It creates a constant in the function's scope, pointing to some outside code. By default, you'll do this at the top level of your Node.js file, effectively making the dependency globally accessible to said file. Consider this snippet, where we're importing the AWS SDK, and creating a new instance of the DynamoDB DocumentClient:

```javascript
const AWS = require('aws-sdk')
const documentClient = new AWS.DynamoDB.DocumentClient()
```

**What happens when you unit test code that imports the above dependency?** In this case, your test will establish a live connection to DynamoDB and potentially start reading and writing data to it! While you could argue this is a test in and of itself, this situation is far from ideal. Each unit test invocation will

* potentially incur costs
* write data to a live database, possibly messing up its consistency
* be slow

Richard Hyatt's [Medium post from 2016](https://medium.com/vandium-software/unit-testing-aws-lambda-functions-in-node-js-7ad6c8f5000) is still relevant today, as it describes how we can make dependency loading asynchronous and injectable by using the exports object to store and reference dependencies.

```javascript
exports.deps = () => {
  const AWS = require('aws-sdk')
  const documentClient = new AWS.DynamoDB.DocumentClient()

  return Promise.resolve({
    dynamoBatchWrite: params => documentClient.batchWrite(params).promise()
  })
}
```

The actual dependency import is enclosed into the deps function scope, and is made asynchronous by wrapping the result dictionary in a Promise. This asynchronicity allows us to overwrite the deps function during tests, while leaving it as-is in production.

The production code will just await the dependencies at the top, after which you'll be able to access the fully constructed dependencies:

```javascript
exports.handler = async event => {
  const deps = await exports.deps()
  ...
}
```

Now, for the test:

```javascript
require('chai').should()
const lambda = require('../index')
const sinon = require('sinon')

describe('importOPML', () => {
  beforeEach('mock dependencies', () => {
    const mockWriter = sinon.mock()
    mockWriter.resolves({ UnprocessedItems: [] })

    lambda.deps = () => Promise.resolve({
      dynamoBatchWrite: mockWriter
    })
  })

  it('should succeed with empty opml', async () => {
    // Using lambda here, will call the version that uses the mocked DynamoDB writer.
  }
})
```

This happens to be a Chai test that uses Sinon for mocking, but the premise is the same. Before each test block is run, the beforeEach block is executed, which preps the lambda with the mock dependencies.

That's it. You're off to the races!