如何测试AWS Lambda

Question

So, I have some AWS lambda code that connects to a Redis Cluster instance (using ioredis) to store data. We want to instantiate the Cluster in the lambda container for reuse, as we intend to have this lambda hit frequently enough that we would gain performance benefits from container reuse.

We have written a wrapper class (called RedisCluster) which extends the Redis Cluster to provide additional checks and functionality, as we are using this in a variety of different lambdas.

In the past, I have been able to stub out Redis Cluster instances when testing, but when I instantiate it in the container it appears that the Cluster is spun up when the lambda source code is loaded (ie before test execution). When my tests are run, I get an error indicating that the Cluster is unable to connect to node instances.

The lambda

let redisCluster = new RedisCluster([{ host: process.env.HOST, port: process.env.PORT }]);

function isKeyInCache(cacheKey) {
    logger.info(`Searching for key::${cacheKey}`);
    return redisCluster.get(cacheKey);
}

exports.handler = baseHandler((e, ctx, cb) => {
    ctx.callbackWaitsForEmptyEventLoop = false;
    const cacheKey = `${key}`;
    isKeyInCache(cacheKey).then((response) => {
        if (response) {
            logger.info('Key is registered');
            redisCluster.removeKey(cacheKey).then(() => {
                const result = { status: 'Registered' };
                cb(null, result);
            }).catch((err) => {
                logger.error(err);
                cb(err, 'Error');
            });
        } else {
            const result = { status: 'NotFound' };
            cb(null, result);
        }
    });

    redisCluster.on('error', () => {
        cb('An error has occurred with the redis cluster');
    });

Here is the wrapper class

class RedisCluster extends Redis.Cluster {
    constructor(opts) {
        super(opts);
    }

    removeKey(cacheKey) {
        return new Promise((resolve, reject) => {
            super.del(cacheKey, (err, reply) => {
                if (err) {
                    logger.error(`Failed to remove key::${cacheKey} Error response: ${err}`);
                    reject(err);
                } else {
                    logger.info(`Successfully removed key::${cacheKey} response: ${reply}`);
                    resolve();
                }
            });
        });
    }

    quitRedisCluster() {
        return new Promise((resolve, reject) => {
            if (this) {
                super.quit(() => {
                    logger.info('Quitting redis cluster connection...');
                    resolve();
                }).catch((err) => {
                    logger.error('Error closing cluster');
                    reject(err);
                });
            } else {
                logger.error('Cluster not defined');
                reject();
            }
        });
    }
}
module.exports = RedisCluster;

I am unable to properly inject any dependencies (this being a lambda) and stubbing the Redis Cluster does not seem to work as it is instantiated when the source code is loaded. However, I am able to replace the Redis Cluster before testing by adding an exported function to do so. This is ugly, and the method is only used for testing... so I imagine there has to be a better way to do this.

Here is the method I've added to the lambda to mock the Cluster. Unfortunately the initial Cluster still gets spun up when the lambda code is loaded, so I get connection errors littering my test output, although this does work when I inject a spy or stub. I do not like this because it produces code smell and is a method added ONLY to satisfy tests.

exports.injectCluster = (injectedDependency) => {
    redisCluster.disconnect();
    redisCluster = injectedDependency;
};

My tests look something like this.

import Promise from 'bluebird';
import chai from 'chai';
import chaiAsPromised from 'chai-as-promised';
import Context from 'mock-ctx';
import sinon from 'sinon';
import { handler, injectCluster } from '../src';

chai.use(chaiAsPromised);

let redisClusterConstructor;
let removeKey;
let on;
let disconnect;
let get;
const ctx = new Context();

describe('lambda', () => {
    beforeEach(() => {
        removeKey = sinon.spy(() => Promise.resolve({}));
        on = sinon.spy((e, cb) => {});
        disconnect = sinon.spy(() => {});

        redisClusterConstructor = {
            removeKey,
            on,
            disconnect
         };
    });

    it('should get key in redis if key exist', () => {
        get = sinon.spy((k) => Promise.resolve('true'));
        redisClusterConstructor['get'] = get;
        injectCluster(redisClusterConstructor);
        const promise = Promise.fromCallback(cb => handler(e, ctx, cb));
        return chai.expect(promise).to.be.fulfilled.then((response) => {
            chai.assert.isTrue(get.calledOnce);
            chai.assert.isTrue(removeKey.calledOnce);
            chai.expect(response).to.deep.equal({ status: 'Registered' });
        });
    });
});

Things I have tried:

1: Stubbing the 'class' using sinon

Won't work because javascript objects aren't really classes. I cannot seem to stub out the constructor, only the methods, so the Cluster still gets initially spun up in the constructor.

2: Rewiring the import

Won't seem to work because of the order in which things are executed in the tests. When the lambda code is loaded the RedisCluster immediately spins up. So, by the time the test actually runs the Cluster already exists and will not use the rewired import.

3: 'Dependency injection'

Works, but is ugly and likely won't pass the PR process...

4: Rewriting the wrapper class to wait to connect until the first command is executed

This is what I am trying now, I have not finished the code to know if it will work or not.

Am I on the right track?... In Java this is simple as pie, but I cannot for the life of me figure out what to do in node to cleanly mock this dependency.

Answer 1

I found a solution to my issue, and although it's not ideal it does address the shortcomings in the mock dependency injection solution I had come up with earlier.

I simply changed my instance of my wrapper RedisCluster class to be instantiated with process.env.opts instead of { host: process.env.HOST, port: process.env.PORT } , where opts is simply the map used above.

Then in my test file I included the statement process.env.opts = { mock: "stuff" } before the lambda source code was being loaded to avoid the Redis Cluster attempting to connect to an instance of a Cluster that didn't exist. Then I stubbed out the methods to the wrapper class using sinon as usual.

I hope this helps someone. It won't pass a linter as is as eslint requires import statements to be at the top. So I moved that statement to another js file and included it before I included the source file..

A bit hacky, but it works. If there is a better way someone please chime in.