Open History to see the last commit
1import { waitFor, fireEvent } from '@testing-library/react'
2import { ErrorBoundary } from 'react-error-boundary'
3import React from 'react'
4β
5import { sleep, queryKey, mockConsoleError, renderWithClient } from './utils'
6import {
7 useQuery,
8 QueryClient,
9 QueryCache,
10 QueryErrorResetBoundary,
11} from '../..'
12β
13describe('QueryErrorResetBoundary', () => {
14 const queryCache = new QueryCache()
15 const queryClient = new QueryClient({ queryCache })
16β
17 it('should retry fetch if the reset error boundary has been reset', async () => {
18 const key = queryKey()
19β
20 let succeed = false
21 const consoleMock = mockConsoleError()
22β
23 function Page() {
24 const { data } = useQuery(
25 key,
26 async () => {
27 await sleep(10)
28 if (!succeed) {
29 throw new Error('Error')
30 } else {
31 return 'data'
32 }
33 },
34 {
35 retry: false,
36 useErrorBoundary: true,
37 }
38 )
39 return <div>{data}</div>
40 }
41β
42 const rendered = renderWithClient(
43 queryClient,
44 <QueryErrorResetBoundary>
45 {({ reset }) => (
46 <ErrorBoundary
47 onReset={reset}
48 fallbackRender={({ resetErrorBoundary }) => (
49 <div>
50 <div>error boundary</div>
51 <button
52 onClick={() => {
53 resetErrorBoundary()
54 }}
55 >
56 retry
57 </button>
58 </div>
59 )}
60 >
61 <Page />
62 </ErrorBoundary>
63 )}
64 </QueryErrorResetBoundary>
65 )
66β
67 await waitFor(() => rendered.getByText('error boundary'))
68 await waitFor(() => rendered.getByText('retry'))
69 succeed = true
70 fireEvent.click(rendered.getByText('retry'))
71 await waitFor(() => rendered.getByText('data'))
72β
73 consoleMock.mockRestore()
74 })
75β
76 it('should not throw error if query is disabled', async () => {
77 const key = queryKey()
78β
79 let succeed = false
80 const consoleMock = mockConsoleError()
81β
82 function Page() {
83 const { data, status } = useQuery(
84 key,
85 async () => {
86 await sleep(10)
87 if (!succeed) {
88 throw new Error('Error')
89 } else {
90 return 'data'
91 }
92 },
93 {
94 retry: false,
95 enabled: !succeed,
96 useErrorBoundary: true,
97 }
98 )
99 return (
100 <div>
101 <div>status: {status}</div>
102 <div>{data}</div>
103 </div>
104 )
105 }
106β
107 const rendered = renderWithClient(
108 queryClient,
109 <QueryErrorResetBoundary>
110 {({ reset }) => (
111 <ErrorBoundary
112 onReset={reset}
113 fallbackRender={({ resetErrorBoundary }) => (
114 <div>
115 <div>error boundary</div>
116 <button
117 onClick={() => {
118 resetErrorBoundary()
119 }}
120 >
121 retry
122 </button>
123 </div>
124 )}
125 >
126 <Page />
127 </ErrorBoundary>
128 )}
129 </QueryErrorResetBoundary>
130 )
131β
132 await waitFor(() => rendered.getByText('error boundary'))
133 await waitFor(() => rendered.getByText('retry'))
134 succeed = true
135 fireEvent.click(rendered.getByText('retry'))
136 await waitFor(() => rendered.getByText('status: error'))
137β
138 consoleMock.mockRestore()
139 })
140β
141 it('should not throw error if query is disabled, and refetch if query becomes enabled again', async () => {
142 const key = queryKey()
143β
144 let succeed = false
145 const consoleMock = mockConsoleError()
146β
147 function Page() {
148 const [enabled, setEnabled] = React.useState(false)
149 const { data } = useQuery(
150 key,
151 async () => {
152 await sleep(10)
153 if (!succeed) {
154 throw new Error('Error')
155 } else {
156 return 'data'
157 }
158 },
159 {
160 retry: false,
161 enabled,
162 useErrorBoundary: true,
163 }
164 )
165β
166 React.useEffect(() => {
167 setEnabled(true)
168 }, [])
169β
170 return <div>{data}</div>
171 }
172β
173 const rendered = renderWithClient(
174 queryClient,
175 <QueryErrorResetBoundary>
176 {({ reset }) => (
177 <ErrorBoundary
178 onReset={reset}
179 fallbackRender={({ resetErrorBoundary }) => (
180 <div>
181 <div>error boundary</div>
182 <button
183 onClick={() => {
184 resetErrorBoundary()
185 }}
186 >
187 retry
188 </button>
189 </div>
190 )}
191 >
192 <Page />
193 </ErrorBoundary>
194 )}
195 </QueryErrorResetBoundary>
196 )
197β
198 await waitFor(() => rendered.getByText('error boundary'))
199 await waitFor(() => rendered.getByText('retry'))
200 succeed = true
201 fireEvent.click(rendered.getByText('retry'))
202 await waitFor(() => rendered.getByText('data'))
203β
204 consoleMock.mockRestore()
205 })
206β
207 it('should throw error if query is disabled and manually refetched', async () => {
208 const key = queryKey()
209β
210 const consoleMock = mockConsoleError()
211β
212 function Page() {
213 const { data, refetch, status } = useQuery(
214 key,
215 async () => {
216 throw new Error('Error')
217 },
218 {
219 retry: false,
220 enabled: false,
221 useErrorBoundary: true,
222 }
223 )
224β
225 return (
226 <div>
227 <button onClick={() => refetch()}>refetch</button>
228 <div>status: {status}</div>
229 <div>{data}</div>
230 </div>
231 )
232 }
233β
234 const rendered = renderWithClient(
235 queryClient,
236 <QueryErrorResetBoundary>
237 {({ reset }) => (
238 <ErrorBoundary
239 onReset={reset}
240 fallbackRender={({ resetErrorBoundary }) => (
241 <div>
242 <div>error boundary</div>
243 <button
244 onClick={() => {
245 resetErrorBoundary()
246 }}
247 >
248 retry
249 </button>
250 </div>
251 )}
252 >
253 <Page />
254 </ErrorBoundary>
255 )}
256 </QueryErrorResetBoundary>
257 )
258β
259 await waitFor(() => rendered.getByText('status: idle'))
260 rendered.getByRole('button', { name: /refetch/i }).click()
261 await waitFor(() => rendered.getByText('error boundary'))
262β
263 consoleMock.mockRestore()
264 })
265β
266 it('should not retry fetch if the reset error boundary has not been reset', async () => {
267 const key = queryKey()
268β
269 let succeed = false
270 const consoleMock = mockConsoleError()
271β
272 function Page() {
273 const { data } = useQuery(
274 key,
275 async () => {
276 await sleep(10)
277 if (!succeed) {
278 throw new Error('Error')
279 } else {
280 return 'data'
281 }
282 },
283 {
284 retry: false,
285 useErrorBoundary: true,
286 }
287 )
288 return <div>{data}</div>
289 }
290β
291 const rendered = renderWithClient(
292 queryClient,
293 <QueryErrorResetBoundary>
294 {() => (
295 <ErrorBoundary
296 fallbackRender={({ resetErrorBoundary }) => (
297 <div>
298 <div>error boundary</div>
299 <button
300 onClick={() => {
301 resetErrorBoundary()
302 }}
303 >
304 retry
305 </button>
306 </div>
307 )}
308 >
309 <Page />
310 </ErrorBoundary>
311 )}
312 </QueryErrorResetBoundary>
313 )
314β
315 await waitFor(() => rendered.getByText('error boundary'))
316 await waitFor(() => rendered.getByText('retry'))
317 succeed = true
318 fireEvent.click(rendered.getByText('retry'))
319 await waitFor(() => rendered.getByText('error boundary'))
320β
321 consoleMock.mockRestore()
322 })
323β
324 it('should retry fetch if the reset error boundary has been reset and the query contains data from a previous fetch', async () => {
325 const key = queryKey()
326β
327 let succeed = false
328 const consoleMock = mockConsoleError()
329β
330 function Page() {
331 const { data } = useQuery(
332 key,
333 async () => {
334 await sleep(10)
335 if (!succeed) {
336 throw new Error('Error')
337 } else {
338 return 'data'
339 }
340 },
341 {
342 retry: false,
343 useErrorBoundary: true,
344 initialData: 'initial',
345 }
346 )
347 return <div>{data}</div>
348 }
349β
350 const rendered = renderWithClient(
351 queryClient,
352 <QueryErrorResetBoundary>
353 {({ reset }) => (
354 <ErrorBoundary
355 onReset={reset}
356 fallbackRender={({ resetErrorBoundary }) => (
357 <div>
358 <div>error boundary</div>
359 <button
360 onClick={() => {
361 resetErrorBoundary()
362 }}
363 >
364 retry
365 </button>
366 </div>
367 )}
368 >
369 <Page />
370 </ErrorBoundary>
371 )}
372 </QueryErrorResetBoundary>
373 )
374β
375 await waitFor(() => rendered.getByText('error boundary'))
376 await waitFor(() => rendered.getByText('retry'))
377 succeed = true
378 fireEvent.click(rendered.getByText('retry'))
379 await waitFor(() => rendered.getByText('data'))
380β
381 consoleMock.mockRestore()
382 })
383β
384 it('should not retry fetch if the reset error boundary has not been reset after a previous reset', async () => {
385 const key = queryKey()
386β
387 let succeed = false
388 let shouldReset = true
389 const consoleMock = mockConsoleError()
390β
391 function Page() {
392 const { data } = useQuery(
393 key,
394 async () => {
395 await sleep(10)
396 if (!succeed) {
397 throw new Error('Error')
398 } else {
399 return 'data'
400 }
401 },
402 {
403 retry: false,
404 useErrorBoundary: true,
405 }
406 )
407 return <div>{data}</div>
408 }
409β
410 const rendered = renderWithClient(
411 queryClient,
412 <QueryErrorResetBoundary>
413 {({ reset }) => (
414 <ErrorBoundary
415 onReset={() => {
416 if (shouldReset) {
417 reset()
418 }
419 }}
420 fallbackRender={({ resetErrorBoundary }) => (
421 <div>
422 <div>error boundary</div>
423 <button
424 onClick={() => {
425 resetErrorBoundary()
426 }}
427 >
428 retry
429 </button>
430 </div>
431 )}
432 >
433 <Page />
434 </ErrorBoundary>
435 )}
436 </QueryErrorResetBoundary>
437 )
438β
439 await waitFor(() => rendered.getByText('error boundary'))
440 await waitFor(() => rendered.getByText('retry'))
441 shouldReset = true
442 fireEvent.click(rendered.getByText('retry'))
443 await waitFor(() => rendered.getByText('error boundary'))
444 succeed = true
445 shouldReset = false
446 fireEvent.click(rendered.getByText('retry'))
447 await waitFor(() => rendered.getByText('error boundary'))
448β
449 consoleMock.mockRestore()
450 })
451β
452 it('should throw again on error after the reset error boundary has been reset', async () => {
453 const key = queryKey()
454 const consoleMock = mockConsoleError()
455 let fetchCount = 0
456β
457 function Page() {
458 const { data } = useQuery(
459 key,
460 async () => {
461 fetchCount++
462 await sleep(10)
463 throw new Error('Error')
464 },
465 {
466 retry: false,
467 useErrorBoundary: true,
468 }
469 )
470 return <div>{data}</div>
471 }
472β
473 const rendered = renderWithClient(
474 queryClient,
475 <QueryErrorResetBoundary>
476 {({ reset }) => (
477 <ErrorBoundary
478 onReset={reset}
479 fallbackRender={({ resetErrorBoundary }) => (
480 <div>
481 <div>error boundary</div>
482 <button
483 onClick={() => {
484 resetErrorBoundary()
485 }}
486 >
487 retry
488 </button>
489 </div>
490 )}
491 >
492 <Page />
493 </ErrorBoundary>
494 )}
495 </QueryErrorResetBoundary>
496 )
497β
498 await waitFor(() => rendered.getByText('error boundary'))
499 await waitFor(() => rendered.getByText('retry'))
500 fireEvent.click(rendered.getByText('retry'))
501 await waitFor(() => rendered.getByText('error boundary'))
502 await waitFor(() => rendered.getByText('retry'))
503 fireEvent.click(rendered.getByText('retry'))
504 await waitFor(() => rendered.getByText('error boundary'))
505 expect(fetchCount).toBe(3)
506β
507 consoleMock.mockRestore()
508 })
509β
510 it('should never render the component while the query is in error state', async () => {
511 const key = queryKey()
512 const consoleMock = mockConsoleError()
513 let fetchCount = 0
514 let renders = 0
515β
516 function Page() {
517 const { data } = useQuery(
518 key,
519 async () => {
520 fetchCount++
521 await sleep(10)
522 if (fetchCount > 2) {
523 return 'data'
524 } else {
525 throw new Error('Error')
526 }
527 },
528 {
529 retry: false,
530 suspense: true,
531 }
532 )
533 renders++
534 return <div>{data}</div>
535 }
536β
537 const rendered = renderWithClient(
538 queryClient,
539 <QueryErrorResetBoundary>
540 {({ reset }) => (
541 <ErrorBoundary
542 onReset={reset}
543 fallbackRender={({ resetErrorBoundary }) => (
544 <div>
545 <div>error boundary</div>
546 <button
547 onClick={() => {
548 resetErrorBoundary()
549 }}
550 >
551 retry
552 </button>
553 </div>
554 )}
555 >
556 <React.Suspense fallback={<div>loading</div>}>
557 <Page />
558 </React.Suspense>
559 </ErrorBoundary>
560 )}
561 </QueryErrorResetBoundary>
562 )
563β
564 await waitFor(() => rendered.getByText('error boundary'))
565 await waitFor(() => rendered.getByText('retry'))
566 fireEvent.click(rendered.getByText('retry'))
567 await waitFor(() => rendered.getByText('error boundary'))
568 await waitFor(() => rendered.getByText('retry'))
569 fireEvent.click(rendered.getByText('retry'))
570 await waitFor(() => rendered.getByText('data'))
571 expect(fetchCount).toBe(3)
572 expect(renders).toBe(1)
573β
574 consoleMock.mockRestore()
575 })
576β
577 it('should render children', async () => {
578 function Page() {
579 return (
580 <div>
581 <span>page</span>
582 </div>
583 )
584 }
585β
586 const rendered = renderWithClient(
587 queryClient,
588 <QueryErrorResetBoundary>
589 <Page />
590 </QueryErrorResetBoundary>
591 )
592β
593 expect(rendered.queryByText('page')).not.toBeNull()
594 })
595β
596 it('should show error boundary when using tracked queries even though we do not track the error field', async () => {
597 const key = queryKey()
598β
599 let succeed = false
600 const consoleMock = mockConsoleError()
601β
602 function Page() {
603 const { data } = useQuery(
604 key,
605 async () => {
606 await sleep(10)
607 if (!succeed) {
608 throw new Error('Error')
609 } else {
610 return 'data'
611 }
612 },
613 {
614 retry: false,
615 useErrorBoundary: true,
616 notifyOnChangeProps: 'tracked',
617 }
618 )
619 return <div>{data}</div>
620 }
621β
622 const rendered = renderWithClient(
623 queryClient,
624 <QueryErrorResetBoundary>
625 {({ reset }) => (
626 <ErrorBoundary
627 onReset={reset}
628 fallbackRender={({ resetErrorBoundary }) => (
629 <div>
630 <div>error boundary</div>
631 <button
632 onClick={() => {
633 resetErrorBoundary()
634 }}
635 >
636 retry
637 </button>
638 </div>
639 )}
640 >
641 <Page />
642 </ErrorBoundary>
643 )}
644 </QueryErrorResetBoundary>
645 )
646β
647 await waitFor(() => rendered.getByText('error boundary'))
648 await waitFor(() => rendered.getByText('retry'))
649 succeed = true
650 fireEvent.click(rendered.getByText('retry'))
651 await waitFor(() => rendered.getByText('data'))
652β
653 consoleMock.mockRestore()
654 })
655})