jest-mock-axios
Advanced tools
jest-mock-axios is a Jest mock for Axios, a popular HTTP client for making requests. It allows developers to mock Axios requests in their Jest tests, making it easier to test code that relies on HTTP requests without actually making those requests.
Mocking GET Requests
This feature allows you to mock GET requests made with Axios. The code sample demonstrates how to mock a GET request and test a function that fetches data using Axios.
const mockAxios = require('jest-mock-axios');
const axios = require('axios');
// Function to test
async function fetchData() {
const response = await axios.get('/data');
return response.data;
}
// Jest test
it('fetches data successfully', async () => {
const data = { name: 'John Doe' };
mockAxios.get.mockResolvedValue({ data });
const result = await fetchData();
expect(result).toEqual(data);
});Mocking POST Requests
This feature allows you to mock POST requests made with Axios. The code sample demonstrates how to mock a POST request and test a function that posts data using Axios.
const mockAxios = require('jest-mock-axios');
const axios = require('axios');
// Function to test
async function postData(data) {
const response = await axios.post('/data', data);
return response.data;
}
// Jest test
it('posts data successfully', async () => {
const data = { name: 'John Doe' };
const responseData = { success: true };
mockAxios.post.mockResolvedValue({ data: responseData });
const result = await postData(data);
expect(result).toEqual(responseData);
});Mocking Error Responses
This feature allows you to mock error responses from Axios requests. The code sample demonstrates how to mock an error response and test a function that handles errors when fetching data using Axios.
const mockAxios = require('jest-mock-axios');
const axios = require('axios');
// Function to test
async function fetchData() {
try {
const response = await axios.get('/data');
return response.data;
} catch (error) {
throw new Error('Failed to fetch data');
}
}
// Jest test
it('handles error response', async () => {
mockAxios.get.mockRejectedValue(new Error('Network Error'));
await expect(fetchData()).rejects.toThrow('Failed to fetch data');
});axios-mock-adapter is a library that allows you to easily mock requests made with Axios. It provides a more flexible and powerful way to mock requests compared to jest-mock-axios, with support for matching requests based on URL, method, headers, and more.
nock is a HTTP mocking and expectations library for Node.js. It can be used to mock HTTP requests made with any library, including Axios. nock provides a wide range of features for intercepting and mocking HTTP requests, making it a versatile choice for testing HTTP interactions.
fetch-mock is a library for mocking fetch requests. While it is designed for the Fetch API, it can be used with Axios by configuring Axios to use fetch as its HTTP client. fetch-mock provides a simple and intuitive API for mocking fetch requests and responses.
This is a light-weight, easy to use synchronous Axios mock for unit testing with Jest.
Because it works synchronously, meaning that your tests will be easier to write, read and understand.
Unfortunately out of the box this mock works only with Jest.
However, if you look at the source code, you can see that it uses Jest only to define spies (for methods post, get, put, patch, delete, create, all, head, options, request). This means that it can easily be modified to use any other testing framework - go to GitHub, clone it, modify it, play with it :)
Installation is simple - just run:
npm i --save-dev jest-mock-axios
Next you need to setup a manual Jest mock for Axios (we'll explain why a bit later):
__mocks__ directory in your project root (or whatever is configured in the roots config in jest.config.js - when using react-scripts this is <rootDir>/src, so you need to place it under src/__mocks__)axios.jsaxios.js file// ./__mocks__/axios.js
import mockAxios from 'jest-mock-axios';
export default mockAxios;
⚠️ In v4.6.0 this module is inadvertently a pure ES module (#83). Please use v4.5.0 or v4.6.1 if you encounter any problems for now.
It's because Jest expects mocks to be placed in the project root, while
packages installed via NPM get stored inside node_modules subdirectory.
Let's consider that we want to test a component which uses Axios. This component returns a promise, which will be resolved after Axios is done communicating with the server.
Here's a Jest snippet, which explains how we would test this component:
// ./test/UppercaseProxy.spec.js
import mockAxios from 'jest-mock-axios';
import UppercaseProxy from '../src/UppercaseProxy';
afterEach(() => {
// cleaning up the mess left behind the previous test
mockAxios.reset();
});
it('UppercaseProxy should get data from the server and convert it to UPPERCASE', () => {
let catchFn = jest.fn(),
thenFn = jest.fn();
// using the component, which should make a server response
let clientMessage = 'client is saying hello!';
UppercaseProxy(clientMessage)
.then(thenFn)
.catch(catchFn);
// since `post` method is a spy, we can check if the server request was correct
// a) the correct method was used (post)
// b) went to the correct web service URL ('/web-service-url/')
// c) if the payload was correct ('client is saying hello!')
expect(mockAxios.post).toHaveBeenCalledWith('/web-service-url/', {data: clientMessage });
// simulating a server response
let responseObj = { data: 'server says hello!' };
mockAxios.mockResponse(responseObj);
// checking the `then` spy has been called and if the
// response from the server was converted to upper case
expect(thenFn).toHaveBeenCalledWith('SERVER SAYS HELLO!');
// catch should not have been called
expect(catchFn).not.toHaveBeenCalled();
});
To make this example complete and easier to understand, let's have a look at a (verbose) implementation of component we are testing:
// ./src/UppercaseProxy.js
import axios from 'axios';
const UppercaseProxy = (clientMessage) => {
// requesting data from server
let axiosPromise = axios.post('/web-service-url/', { data: clientMessage });
// converting server response to upper case
axiosPromise = axiosPromise.then(serverData => serverData.data.toUpperCase());
// returning promise so that client code can attach `then` and `catch` handler
return(axiosPromise);
};
export default UppercaseProxy;
At the bottom of this page you can find additional examples.
In addition to standard Axios methods (post, get, put, patch, delete, create, all, head, options, request, axios(url)), which are exposed as spies, Axios mock has additional public methods, which are intended to facilitate mocking:
mockResponse - simulates a server (web service) responsemockError - simulates a (network/server) errorlastReqGet - returns extended info about the most recent requestgetReqMatching - returns extended info about the most recent request matching the given criteria (url, method and params)getReqByMatchUrl - returns extended info about the most recent request matching the given regexUrl.getReqByRegex - returns extended info about the most recent request matching the given keys and regexUrls.queue - returns a queue with all requests received.lastPromiseGet - returns promise created when the most recent request was madereset - resets the Axios mock object - prepare it for the next test (typically used in afterEach)Note: all is just an alias to Promise.all (as it is in axios). Thus you can use it with mockResponse, but you can still retrieve statistics for it. Mock the requests used in all instead.
After a request has been made to the server (web service), this method resolves that request by simulating a server response. Status meaning is ignored, i.e. 400 will still resolve axios promise. Use mockError for non-2xx responses.
NOTE: This method should be called after the axios call in your test for the promise to resolve properly.
responseThe first argument of this method is the a response object returned by the server, with a structure illustrated by the snippet below. All the properties are optional, meaning that if a property is ommitted it will be replaced by a default value (defaults are shown in the snippet).
response = {
data: {},
status: 200,
statusText: 'OK',
headers: {},
config: {},
}
The given response object will get passed to then even handler function.
requestInfoThe second argument enables us to pinpoint an exact server request we wish to resolve. This can be useful if we're making multiple server requests and are planing to resolve them in a different order from the one in which they were made.
We supply two different objects:
lastReqGet methodpromise object, which can be accessed by calling the lastPromiseGet methodIf ommited this argument defaults to the latest request made (internally the lastReqGet method is called).
At the end of this document you can find an example which demonstrates how this parameter can be used.
silentModeBoth mockResponse and mockError will throw an error if you're trying to respond to no request, as this usually means you're doing something wrong.
You can change this behavior by passing true as third argument, activating the so-called silentMode. With silentMode activated, the methods will just do nothing.
This behaves very similar to mockResponse, but you explicitly specify the request you want to respond to by
specifying an object containing url and/or method, or just a plain string (to match by URL only).
Example:
mockAxios.mockResponseFor({url: '/get'}, {data: "test"});
criteriaAn object or string (the url) specifying which request to match. Currently url and method are supported for the object. If both url and method are passed, it only responds to requests matching both. If multiple requests match against the criteria, the most recent one is responded to.
responseThe second argument is a response object, which works the same way as described part about the mockResponse method.
silentModeThe third argument is the silentMode flag, which works the same way as described part about the mockResponse method.
This method simulates an error while making a server request (network error, server error, etc ...). NOTE: This method should be called after the axios call in your test for the promise to resolve properly.
errError object will get passed to catch event handler function. If omitted it defaults to an empty object.
requestInfoThe second argument is a requestInfo object, which works the same way as described part about the mockResponse method.
silentModeThe third argument is the silentMode flag, which works the same way as described part about the mockResponse method.
lastReqGet method returns extended info about the most recent request. The returned value can be used to pinpoint exact server request we wish to resolve (the value is passed as the second param of mockResponse or mockError methods).
The returned info contains all the data relevant to the request. It has the following structure (an example):
let requestInfo = {
// promise created while
promise: SimplePromise,
// URL passed to the get/post/head/delete method
url: "https://github.com/",
// data which was pased to the get/post/head/delete method
data: { text: "this is payload sent to the server" },
// config which was pased to the get/post/head/delete method
config: {
... something ...
}
}
Additional examples at the end of this document illustrate how this method can be used.
NOTE: this is a sibling method to the lastPromiseGet (which returns only the promise portion of this the request object).
If no request has been made yet, returns undefined.
getReqMatching() returns the same info about a specific request as lastReqGet (see above). Instead of returning
the most recent request, it returns the most recent request matching the given criteria or undefined if no such request could be found.
criteriaAn object specifying which request to match. Currently url, method and params are supported.
getReqByUrl() returns the same info about a specific request as lastReqGet (see above). Instead of returning the
most recent request, it returns the most recent request matching the given url or undefined if no such request could be found.
urlThe url to be matched. Must match exactly the url passed to axios before.
getReqByMatchUrl() returns the same info about a specific request as lastReqGet (see above). Instead of returning the
most recent request, it returns the most recent request with a url that matches the given regexUrl or undefined if no such request could be found.
regexUrlThe regexUrl matcher. Must contain a Regex object RegExp(/.../).
const req = mockAxios.getReqByMatchUrl(/resource\/\d+\/create/)
mockAxios.mockResponse({ data: { id: 1 } }, req)
getReqByRegex() returns the same info about a specific request as getReqByMatchUrl() (see above). Instead of matching only the url against a RegexUrls, it's possible to match any keys against RegexUrls.
It returns the most recent request with key(s) that match(es) the given RegexUrl(s) or undefined if no such request could be found.
optsThe keys + regexes matchers.
Must contain pairs of keys and a Regex objects RegExp(/.../) to be tested against the requests.
{ key_a: RegExp_a, ..., key_n: RegExp_n }
url that matches /batch/const request = mockAxios.getReqByRegex({ url: /batch/ })
data that matches /employees/const request = mockAxios.getReqByRegex({ data: /employees/ })
config that matches /my_config/const request = mockAxios.getReqByRegex({ config: /my_config/ })
method that matches /delete/const request = mockAxios.getReqByRegex({ method: /delete/ })
url that matches /batch/ and data that matches /employees/multiple keys is supported ✔️
const request = mockAxios.getReqByRegex({ url: /batch/, data: /employees/ })
lastPromiseGet method returns a promise given when the most recent server request was made. The returned value can be used to pinpoint exact server request we wish to resolve (the value is passed as the second param of mockResponse or mockError methods).
The promise object returned by this function corresponds to the one returned by post, get, put, patch, delete, head, options, request or all method inside the code we wish to test.
Additional examples at the end of this document illustrate how this method can be used.
NOTE: This is a sibling method to the lastReqGet, which in addition to promise returns object containing extended info about the request.
reset method clears state of the Axios mock to initial values. It should be called after each test, so that we can start fresh with our next test (i.e. from afterEach method).
useRequestHandler method allows setting a request handler that gets invoked every time a new request comes in. The handler method is invoked with the new request item.
mockAxios.useRequestHandler((req: AxiosMockQueueItem) => {
// do something with req...
}))
Since AxiosMock is relatively simple, most of its functionality was covered in basic example at the beginning of this document. In this section we'll explore features not covered by that initial example.
lastReqGet and lastPromiseGet methodsThe following example illustrates the meaning of the values returned by lastReqGet and lastPromiseGet methods.
The first snippet shows a component which will be tested. The component makes a post request to the server and stores the promise returned by Axios.
// ./src/MyComponent.js
import axios from '../lib/index';
class MyComponent {
CallServer () {
// making a `post` request and storing the given promise
this.axiosPromise = axios.post('/web-service-url/', { data: clientMessage });
}
}
export default MyComponent;
In our spec file we will compare promise stored inside the MyComponent with values returned by lastReqGet and lastPromiseGet methods:
// ./test/MyComponent.spec.js
import MyComponent from '../src/SomeSourceFile';
let myComp = new MyComponent();
myComp.CallServer();
// getting the extended info about the most recent request
let lastReqInfo = MockAxios.lastReqGet();
// getting the promise made when the most recent request was made
let lastPromise = MockAxios.lastPromiseGet();
// the following expression will write `true` to the console
// > here we compare promise stored in the `MyComponent` to the one
// returned by the `lastPromiseGet` method
console.log(myComp.axiosPromise === lastPromise);
// the following expression will also write `true` to the console
// > here we compare promise stored in the `MyComponent`
// to the one in the request info, which was returned by the
// `lastReqGet` method
console.log(myComp.axiosPromise === lastReqInfo.promise);
// the following will also write "true" to console,
// since it't the same object
console.log(lastPromise === lastReqInfo.promise);
In the following example we'll have a look at how to resolve requests at desired order by using lastReqGet method.
In this example we'll create two consecutive requests before simulating a server response to the first one.
it('when resolving a request an appropriate handler should be called', () => {
let thenFn1 = jest.fn(),
thenFn2 = jest.fn();
// creating the FIRST server request
UppercaseProxy('client is saying hello!').then(thenFn1);
// storing the request info - we'll need it later to pinpoint the request
let firstRequestInfo = mockAxios.lastReqGet();
// creating the SECOND server request
// BEFORE the first had chance to be resolved
UppercaseProxy('client says bye bye!').then(thenFn2);
// Simulating a server response to the FIRST request
// -> we're using request info object to pinpoint the request
// ... IF the info object is ommited, the method would automatically
// resolve to the newest request from the internal queue (the SECOND one)
mockAxios.mockResponse({ data: 'server says hello!' }, firstRequestInfo);
// only the first handler should have been called
expect(thenFn1).toHaveBeenCalled();
expect(thenFn2).not.toHaveBeenCalled();
// Simulating a server response to the SECOND request
// NOTE: here we don't need to provide the request info,
// since there is only one unresolved request left
// -> `mockResponse` resolves the last request in the
// queue if request info is ommited
mockAxios.mockResponse({ data: 'server says bye bye!' });
// the first `then` handles should be called only once
expect(thenFn1).toHaveBeenCalledTimes(1);
// now the second `then` handler should be called
expect(thenFn2).toHaveBeenCalled();
});
Although this might not be the most realistic use-case of this functionality, it does illustrate how lastReqGet method can be used to alter the default behaviour of the mockResponse method.
NOTE: the identical effect can be achieved by using the lastPromiseGet method. These two methods perform a similar task, as described in the corresponding documentation.
await and asyncYou can also use this library with await and async. Given the following async function (same as above):
const UppercaseProxy = async (clientMessage) => {
const serverData = await axios.post("/web-service-url/", { data: clientMessage });
return serverData.data.toUpperCase();
};
The function can be tested like this (basically the same idea as in the first example at the top):
it("UppercaseProxy should get data from the server and convert it to UPPERCASE", async () => {
const clientMessage = "client is saying hello!";
const promise = UppercaseProxy(clientMessage);
expect(mockAxios.post).toHaveBeenCalledWith("/web-service-url/", {
data: clientMessage,
});
// simulating a server response
const responseObj = { data: "server says hello!" };
mockAxios.mockResponse(responseObj);
const result = await promise;
expect(result).toEqual("SERVER SAYS HELLO!")
});
AxiosMock offers basic support for interceptors (i.e. it does not break when interceptors are used in tested code).
jest-mock-axios has basic support for cancelling requests as in axios. Please note that you will get an error if you try to mock a response for a request after it has been cancelled. Please refer to the provided test case for further usage details.
AxiosMock covers the most popular parts of Axios API, meaning that some of the features are missing or only partially implemented (i.e. interceptors).
If you need an additional feature, you can request it by creating a new issue on project's GitHub page.
Also you are welcome to implement the missing feature yourself and make a pull request :)
The magic which enables axios mock to work synchronously is hidden away in synchronous-promise, which enables promises to be settled in synchronous manner.
This mock is loosely based on the following gist: tux4/axios-test.js
MIT License, http://www.opensource.org/licenses/MIT
[4.8.0] - 2024-11-05
FAQs
Axios mock for Jest
We found that jest-mock-axios demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 0 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
In this segment of the Risky Business podcast, Feross Aboukhadijeh and Patrick Gray discuss the challenges of tracking malware discovered in open source softare.
Research
Security News
A threat actor's playbook for exploiting the npm ecosystem was exposed on the dark web, detailing how to build a blockchain-powered botnet.
Security News
NVD’s backlog surpasses 20,000 CVEs as analysis slows and NIST announces new system updates to address ongoing delays.