Skip to content
Source
Sign inSign up
TanStack/query
Open History to see the last commit

QueryClientProvider.test.tsx

275 lines7.1 KB

1import * as React from 'react'
2import { render, waitFor } from '@testing-library/react'
3import { renderToString } from 'react-dom/server'
4​
5import {
6 QueryCache,
7 QueryClient,
8 QueryClientProvider,
9 useQuery,
10 useQueryClient,
11} from '..'
12import { createQueryClient, queryKey, sleep } from './utils'
13​
14describe('QueryClientProvider', () => {
15 test('sets a specific cache for all queries to use', async () => {
16 const key = queryKey()
17​
18 const queryCache = new QueryCache()
19 const queryClient = createQueryClient({ queryCache })
20​
21 function Page() {
22 const { data } = useQuery(key, async () => {
23 await sleep(10)
24 return 'test'
25 })
26​
27 return (
28 <div>
29 <h1>{data}</h1>
30 </div>
31 )
32 }
33​
34 const rendered = render(
35 <QueryClientProvider client={queryClient}>
36 <Page />
37 </QueryClientProvider>,
38 )
39​
40 await waitFor(() => rendered.getByText('test'))
41​
42 expect(queryCache.find(key)).toBeDefined()
43 })
44​
45 test('allows multiple caches to be partitioned', async () => {
46 const key1 = queryKey()
47 const key2 = queryKey()
48​
49 const queryCache1 = new QueryCache()
50 const queryCache2 = new QueryCache()
51​
52 const queryClient1 = createQueryClient({ queryCache: queryCache1 })
53 const queryClient2 = createQueryClient({ queryCache: queryCache2 })
54​
55 function Page1() {
56 const { data } = useQuery(key1, async () => {
57 await sleep(10)
58 return 'test1'
59 })
60​
61 return (
62 <div>
63 <h1>{data}</h1>
64 </div>
65 )
66 }
67 function Page2() {
68 const { data } = useQuery(key2, async () => {
69 await sleep(10)
70 return 'test2'
71 })
72​
73 return (
74 <div>
75 <h1>{data}</h1>
76 </div>
77 )
78 }
79​
80 const rendered = render(
81 <>
82 <QueryClientProvider client={queryClient1}>
83 <Page1 />
84 </QueryClientProvider>
85 <QueryClientProvider client={queryClient2}>
86 <Page2 />
87 </QueryClientProvider>
88 </>,
89 )
90​
91 await waitFor(() => rendered.getByText('test1'))
92 await waitFor(() => rendered.getByText('test2'))
93​
94 expect(queryCache1.find(key1)).toBeDefined()
95 expect(queryCache1.find(key2)).not.toBeDefined()
96 expect(queryCache2.find(key1)).not.toBeDefined()
97 expect(queryCache2.find(key2)).toBeDefined()
98 })
99​
100 test("uses defaultOptions for queries when they don't provide their own config", async () => {
101 const key = queryKey()
102​
103 const queryCache = new QueryCache()
104 const queryClient = createQueryClient({
105 queryCache,
106 defaultOptions: {
107 queries: {
108 cacheTime: Infinity,
109 },
110 },
111 })
112​
113 function Page() {
114 const { data } = useQuery(key, async () => {
115 await sleep(10)
116 return 'test'
117 })
118​
119 return (
120 <div>
121 <h1>{data}</h1>
122 </div>
123 )
124 }
125​
126 const rendered = render(
127 <QueryClientProvider client={queryClient}>
128 <Page />
129 </QueryClientProvider>,
130 )
131​
132 await waitFor(() => rendered.getByText('test'))
133​
134 expect(queryCache.find(key)).toBeDefined()
135 expect(queryCache.find(key)?.options.cacheTime).toBe(Infinity)
136 })
137​
138 describe('with custom context', () => {
139 it('uses the correct context', async () => {
140 const key = queryKey()
141​
142 const contextOuter = React.createContext<QueryClient | undefined>(
143 undefined,
144 )
145 const contextInner = React.createContext<QueryClient | undefined>(
146 undefined,
147 )
148​
149 const queryCacheOuter = new QueryCache()
150 const queryClientOuter = new QueryClient({ queryCache: queryCacheOuter })
151​
152 const queryCacheInner = new QueryCache()
153 const queryClientInner = new QueryClient({ queryCache: queryCacheInner })
154​
155 const queryCacheInnerInner = new QueryCache()
156 const queryClientInnerInner = new QueryClient({
157 queryCache: queryCacheInnerInner,
158 })
159​
160 function Page() {
161 const { data: testOuter } = useQuery(key, async () => 'testOuter', {
162 context: contextOuter,
163 })
164 const { data: testInner } = useQuery(key, async () => 'testInner', {
165 context: contextInner,
166 })
167 const { data: testInnerInner } = useQuery(
168 key,
169 async () => 'testInnerInner',
170 )
171​
172 return (
173 <div>
174 <h1>
175 {testOuter} {testInner} {testInnerInner}
176 </h1>
177 </div>
178 )
179 }
180​
181 // contextSharing should be ignored when passing a custom context.
182 const contextSharing = true
183​
184 const rendered = render(
185 <QueryClientProvider client={queryClientOuter} context={contextOuter}>
186 <QueryClientProvider client={queryClientInner} context={contextInner}>
187 <QueryClientProvider
188 client={queryClientInnerInner}
189 contextSharing={contextSharing}
190 >
191 <Page />
192 </QueryClientProvider>
193 </QueryClientProvider>
194 </QueryClientProvider>,
195 )
196​
197 await waitFor(() =>
198 rendered.getByText('testOuter testInner testInnerInner'),
199 )
200 })
201 })
202​
203 describe('useQueryClient', () => {
204 test('should throw an error if no query client has been set', () => {
205 const consoleMock = jest
206 .spyOn(console, 'error')
207 .mockImplementation(() => undefined)
208​
209 function Page() {
210 useQueryClient()
211 return null
212 }
213​
214 expect(() => render(<Page />)).toThrow(
215 'No QueryClient set, use QueryClientProvider to set one',
216 )
217​
218 consoleMock.mockRestore()
219 })
220​
221 test('should use window to get the context when contextSharing is true', () => {
222 const queryCache = new QueryCache()
223 const queryClient = createQueryClient({ queryCache })
224​
225 let queryClientFromHook: QueryClient | undefined
226 let queryClientFromWindow: QueryClient | undefined
227​
228 function Page() {
229 queryClientFromHook = useQueryClient()
230 queryClientFromWindow = React.useContext(
231 window.ReactQueryClientContext as React.Context<
232 QueryClient | undefined
233 >,
234 )
235 return null
236 }
237​
238 render(
239 <QueryClientProvider client={queryClient} contextSharing={true}>
240 <Page />
241 </QueryClientProvider>,
242 )
243​
244 expect(queryClientFromHook).toEqual(queryClient)
245 expect(queryClientFromWindow).toEqual(queryClient)
246 })
247​
248 test('should not use window to get the context when contextSharing is true and window does not exist', () => {
249 const queryCache = new QueryCache()
250 const queryClient = createQueryClient({ queryCache })
251​
252 // Mock a non web browser environment
253 const windowSpy = jest
254 .spyOn(window, 'window', 'get')
255 .mockImplementation(undefined)
256​
257 let queryClientFromHook: QueryClient | undefined
258​
259 function Page() {
260 queryClientFromHook = useQueryClient()
261 return null
262 }
263​
264 renderToString(
265 <QueryClientProvider client={queryClient} contextSharing={true}>
266 <Page />
267 </QueryClientProvider>,
268 )
269​
270 expect(queryClientFromHook).toEqual(queryClient)
271​
272 windowSpy.mockRestore()
273 })
274 })
275})