Using Sinon stub to Replace External Service Calls in Tests

When writing tests for a service you’ll often find that there are other dependent services that may need to be called in some way or another. You won’t want to actually invoke the real service during test, but rather ‘stub’ out the dependent service call function. Sinon stub provides an easy and customisable way to replace these external service calls for your tests.

Practical Example: AWS SQS sendMessage Sinon Stub

Let’s say you have an AWS Lambda function that drops a message onto an SQS queue. To test this function handler, your test should invoke the handler and verify that the message was sent.

This simple case already involves an external service call – the SQS sendMessage action that will drop the message onto the queue.

Here is a simple NodeJS module that wraps the SQS sendMessage call.

// sqs.ts

import AWS = require("aws-sdk");
import { AWSError } from "aws-sdk";
import { SendMessageRequest, SendMessageResult } from "aws-sdk/clients/sqs";
import { PromiseResult } from "aws-sdk/lib/request";

const sqs = new AWS.SQS({apiVersion: '2012-11-05'});

export function sendMessage(messageBody: string, queueUrl: string) : Promise<PromiseResult<SendMessageResult, AWSError>> {

  var params = {
    QueueUrl: queueUrl,
    MessageBody: messageBody,
  } as SendMessageRequest;

  return sqs
    .then(res => res)
    .catch((err) => { throw err; });

The actual Lambda Handler code that uses the sqs.ts module above looks like this:

// index.ts

import { sendMessage } from './sqs';
import { Context } from 'aws-lambda';

export const handler = async (event: any, context?: Context) => {

    try {
        const queueUrl = process.env.SQS_QUEUE_URL || "";
        const sendMessageResult = await sendMessage(JSON.stringify({foo: "bar"}), queueUrl);
        return `Sent message with ID: ${sendMessageResult.MessageId}`;
    } catch (err) {
        console.log("Error", err);
        throw err;

Next you’ll create a Sinon stub to ‘stub out’ the sendMessage function of this module (the actual code that the real AWS Lambda function would call).

Setup an empty test case that calls the Lambda handler function to test the result.

// handler.spec.ts

import * as chai from 'chai';
import * as sinon from "sinon";
import { assert } from "sinon";

import * as sqs from '../src/sqs';
import { handler } from '../src/index';
import sinonChai from "sinon-chai";
import { PromiseResult } from 'aws-sdk/lib/request';
import { SendMessageResult } from 'aws-sdk/clients/SQS';
import { Response } from 'aws-sdk';
import { AWSError } from 'aws-sdk';

const expect = chai.expect;

const event = {
  test: "test"

describe("lambda-example-sqs-handler", () => {
  describe("handler", () => {

    it("should send an sqs message and return the message ID", async () => {

      // WHEN

      process.env.SQS_QUEUE_URL = "";
      const result = await handler(event);
      // THEN

      expect(result).to.eql(`Sent message with ID: 123`);

Right now running this test will fail due to the test code trying to call the sqs.ts module’s code that in turn calls the real SQS service’s sendMessage.

Here is where Sinon stub will come in handy. You can replace this specific call that sqs.ts makes with a test stub.

In the describe handler section, add the following just before the ‘it‘ section.

const sendMessageStub = sinon.stub(sqs, "sendMessage");

let stubResponse : PromiseResult<SendMessageResult, AWSError> = {
  $response: new Response<SendMessageResult, AWSError>(),
  MD5OfMessageBody: '828bcef8763c1bc616e25a06be4b90ff',
  MessageId: '123',


The code above calls sinon.stub() and passes in the sqs module object, as well as a string (“sendMessage” in this case) identifying the specific method in the module that should be stubbed.

An optional promise result can be passed in to resolves() to get the stub to return data for the test. In this case, we’re having it return an object that matches the real SQS sendMessage return result. Among other things, this contains a message ID which the Lambda function includes in it’s response.

Add a test to verify that the stub method call.


If you run the test again it should now pass. The stub replaces the real service call. Nice!

sinon stub test result


Replacing dependent service function calls with stubs can be helpful in many ways. For example:

  • Preventing wasteful, real service calls, which could result in unwanted test data, logs, costs, etc…
  • Faster test runs that don’t rely on network calls.
  • Exercising only the relevant code you’re interested in testing.

Sinon provides a testing framework agnostic set of tools such as test spies, stubs and mocks for JavaScript. In this case, you’ve seen how it can be leveraged to make testing interconnected AWS services a breeze with a Lambda function that calls SQS sendMessage to drop a message onto a queue.

Feel free to Download the source code for this post’s example.

Benchmarking – Corsair Reactor R60 SSD vs conventional HDs

So the other day was my first venture into the world of Solid State Storage. I purchased a Corsair Reactor R60. Not the best of SSDs, in fact it is more on the budget side when it comes to SSD storage. It uses a JMicron JMF612 controller and support TRIM provided your OS such as Windows 7 does. The drive was however good value for money in terms of size and performance. Here is a rundown of some of the features straight from Corsair’s site.

  • Maximum sequential read speed 250MB/s
  • Maximum sequential write speed 170MB/s
  • Latest generation JMicron JMF612 controller and MLC NAND flash for fast performance.
  • 128MB DRAM cache for stutter-free performance
  • Internal SATA II connectivity
  • USB 2.0 connectivity for disk cloning or for use as external drive
  • TRIM support (O/S support required)
  • No moving parts for increased durability and reliability and quieter operations over standard hard disk drives
  • Decreased power usage for increased notebook or netbook battery life

I had a clean installation of Windows on my previous OS drive, so I decided it would be a good time to benchmark the SSD against this. I also got hold of some results using the exact same benchmark and scenario but using 8 x Velociraptor 300GB SATA Drives in RAID 60 on a dedicated Areca RAID card. Here are the results. I have used IOmeter for the benchmarking, using a Transfer Request size of 4KB. The results are taken from the Command Queue Depth of 4 results in each instance.

I must say that I am extremely impressed with this SSD. Even for budget / mid range drive, it is phenomenally fast when comparing it to conventional HD storage. Windows loads much quicker and so do the games that I have installed on it. Everything snaps open as the drive is able to access any area of storage almost instantly. File copying performance is also extremely impressive. Even when comparing to a high end RAID controller with multiple high speed Velociraptor drives spinning at 15000rpm in RAID, this drive pulls ahead in all benchmarks. As a dedicated OS / Application drive, I would definitely recommend one.

Next up, I think I am going to try this drive out as dedicated VM storage drive and see how VMDKs perform on it!