Testing

React Query works by means of hooks - either the ones we offer or custom ones that wrap around them.

Writing unit tests for these custom hooks can be done by means of the React Hooks Testing Library library.

Install this by running:

 npm install @testing-library/react-hooks react-test-renderer --save-dev

(The react-test-renderer library is needed as a peer dependency of @testing-library/react-hooks, and needs to correspond to the version of React that you are using.)

Our First Test

Once installed, a simple test can be written. Given the following custom hook:

1 export function useCustomHook() {
2   const { data } = useQuery('customHook', () => 'Hello');
3   return data;
4 }

We can write a test for this as follows:

1 const queryCache = new QueryCache();
2 const wrapper = ({ children }) => (
3   <ReactQueryCacheProvider queryCache={queryCache}>
4     {children}
5   </ReactQueryCacheProvider>
6 );
7 
8 const { result } = renderHook(() => useCustomHook(), { wrapper });
9 
10 expect(result.current).toEqual('Hello');

Note that we provide a custom wrapper that builds the QueryCache and ReactQueryCacheProvider. This helps to ensure that our test is completely isolated from any other tests.

It is possible to write this wrapper only once, but if so we need to ensure that the QueryCache gets cleared before every test, and that tests don't run in parallel otherwise one test will influence the results of others.

Testing Network Calls

The primary use for React Query is to cache network requests, so it's important that we can test our code is making the correct network requests in the first place.

There are plenty of ways that these can be tested, but for this example we are going to use nock.

Given the following custom hook:

1 function useFetchData() {
2   return useQuery('fetchData', () => request('/api/data'));
3 }

We can write a test for this as follows:

1 const queryCache = new QueryCache();
2 const wrapper = ({ children }) => (
3   <ReactQueryCacheProvider queryCache={queryCache}>
4     {children}
5   </ReactQueryCacheProvider>
6 );
7 
8 const expectation = nock('http://example.com')
9   .get('/api/data')
10   .reply(200, {
11     answer: 42
12   });
13 
14 const { result, waitFor } = renderHook(() => useFetchData(), { wrapper });
15 
16 await waitFor(() => {
17   return result.current.isSuccess;
18 });
19 
20 expect(result.current).toEqual({answer: 42});

Here we are making use of waitFor and waiting until our the query status indicates that the request has succeeded. This way we know that our hook has finished and should have the correct data.

Testing Load More / Infinite Scroll

First we need to mock our API response

1 function generateMockedResponse(page) {
2   return {
3     page: page,
4     items: [...]
5   }
6 }

Then, our nock configuration needs to differentiate responses based on the page, and we'll be using uri to do this. uri's value here will be something like "/?page=1 or /?page=2

1 const expectation = nock('http://example.com')
2   .persist()
3   .query(true)
4   .get('/api/data')
5   .reply(200, (uri) => {
6     const url = new URL(`http://example.com${uri}`);
7     const { page } = Object.fromEntries(url.searchParams);
8     return generateMockedResponse(page);
9   });

(Notice the .persist(), because we'll be calling from this endpoint multiple times)

Now we can safely run our tests, the trick here is to await both isFetching and then !isFetching after calling fetchMore():

1 const { result, waitFor } = renderHook(() => useInfiniteQueryCustomHook(), { wrapper });
2 
3 await waitFor(() => result.current.isSuccess);
4 
5 expect(result.current.data).toStrictEqual(generateMockedResponse(1));
6 
7 result.current.fetchMore();
8 
9 await waitFor(() => result.current.isFetching);
10 await waitFor(() => !result.current.isFetching);
11 
12 expect(result.current.data).toStrictEqual([
13   ...generateMockedResponse(1),
14   ...generateMockedResponse(2),
15 ]);
16 
17 expectation.done();