Mocking calls made to S3 in an AWS Lambda function using Jest - node.js

Question

I'm trying to mock a call for putObject in a local Node.JS AWS Lambda function using Jest but for some reason I keep getting 0 number of calls in my expect.
Here is my main func(index.js):
const S3 = require("aws-sdk/clients/s3");
const s3 = new S3();
exports.handler = async (event) => {
putFunction = async (params, callback) => {
await s3.putObject(params, callback).promise();
};
const params = {
Bucket: "some value",
Key: "some key value",
ContentType: "application/json",
Body: "some body value",
};
const callback = {
function(err, data) {
console.log(JSON.stringify(err) + " " + JSON.stringify(data));
},
};
putFunction(params, callback);
}
I've tried adding async to my test function as I thought it was an asynchronous issue but that I still seem to be receiving the same error. Here is my test code(index.test.js):
let myHandler = require("../../src/lambda/index");
const mockedPutObject = jest.fn();
jest.mock("aws-sdk/clients/s3", () => {
return class S3 {
putObject(params, cb) {
mockedPutObject(params, cb);
}
};
});
it("has to mock s3#putObject", () => {
const params = {
Bucket: "test1",
Key: "test2",
ContentType: "application/json",
Body: "test3",
};
const callback = {
function(err, data) {
console.log(JSON.stringify(err) + " " + JSON.stringify(data));
},
};
const putFunc = myHandler.handler.putFunction;
putFunc;
expect(mockedPutObject).toHaveBeenCalledWith(params, callback);
});
Any help would be great.

Answer 1

This is a Jest/Node only answer for those that don't wish to pull in any third-party mocking libraries like aws-sdk-mock.
The problem (without seeing the error itself in your answer) is very likely to be related to the .promise() in your implementation code.
You have added this in the implementation to tell the SDK to return you a promise for whatever operation was called.
await s3.putObject(params, callback).promise();
That returned promise will either reject with an error or resolve with the data.
This means in the promise-based approach you can omit the callback completely.
await s3.putObject(params).promise();
(taken from this AWS blog post)
Fixing the handler...
You can either:
Put that callback logic in subsequent promise chain blocks:
.then((data) => {
// ... do stuff
})
.catch((err) => {
// ... handle error
}
or better still (as it looks like you're already embracing) the
more modern ES6 approach of
Awaiting the putObject promise within in a try-catch block:
try {
const data = await s3.putObject(params).promise()
// ... do things with data on successful response
} catch (err) {
// ... handle error
}
Putting those together
Your handler should look something like this:
const { S3 } = require("aws-sdk");
const s3 = new S3();
exports.handler = async (event) => {
const params = {
Bucket: "some value",
Key: "some key value",
ContentType: "application/json",
Body: "some body value",
};
try {
const data = await s3.putObject(params).promise();
// ... do stuff with data
return {
statusCode: 200,
body: JSON.stringify(data),
// ... etc.
}
} catch (err) {
// ... handle error
return {
statusCode: 400, // or any 4XX, 5XX
body: '...', // whatever you wish to return on error
// ... etc.
}
}
}
Fixing the tests...
Bearing in mind that you can omit the callback, the test code needs to reflect the extra .promise() in the call chain of the putObject in the handler.
In the test file, the SDK mock needs to be configured to:
a) return the top-level S3 constructor
b) have this S3 constructor itself return an object containing the putObject function
c) have this putObject itself return an object containing the promise function
So that it can be invoked as the real SDK would:
const { S3 } = require("aws-sdk"); // require("aws-sdk") returns { S3 }
const s3 = new S3() // returns { putObject }
await s3.putObject(params) // returns { promise }
.promise(); // returns ...your_mock_response
// You need to return the { promise } here even if you don't care about
// mock calls beyond the putObject, because the handler itself calls .promise()
// and will throw "TypeError: Cannot read property 'promise' of undefined"
const putObjectMock = jest.fn(() => ({
promise: jest.fn()
}));
jest.mock('aws-sdk', () => ({
S3: jest.fn(() => ({
putObject: putObjectMock,
})),
}));
// S3 must have jest.fn(...) over an ordinary function otherwise
// the new S3() in the handler will fail.
// Jest does its magic with the function you provide to make it callable as a constructor
const myHandler = require("../../src/lambda/index");
// Don't forget to add the "async" before the "it" callback as your handler is async
it("has to mock s3#putObject", async () => {
const params = {
Bucket: "test1",
Key: "test2",
ContentType: "application/json",
Body: "test3",
};
await handler(); // Call the handler to then assert against the mock params
expect(putObjectMock).toHaveBeenCalledWith(params);
});
Final note - add your handler import after the mock setup to prevent a "Cannot access 'putObject' before initialization" error (caused by the handler's require of the SDK).
Hope this helps!