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

QueryResetErrorBoundary.test.tsx

895 lines25.0 KB

1import { createKey, sleep } from '@tanstack/query-test-utils'
2import { act, fireEvent } from '@testing-library/react'
3import * as React from 'react'
4import { ErrorBoundary } from 'react-error-boundary'
5import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
6import {
7 QueryCache,
8 QueryClient,
9 QueryErrorResetBoundary,
10 useQueries,
11 useQuery,
12 useSuspenseQueries,
13 useSuspenseQuery,
14} from '..'
15import { renderWithClient } from './utils'
16​
17describe('QueryErrorResetBoundary', () => {
18 let queryCache: QueryCache
19 let queryClient: QueryClient
20​
21 beforeEach(() => {
22 vi.useFakeTimers()
23 queryCache = new QueryCache()
24 queryClient = new QueryClient({ queryCache })
25 })
26​
27 afterEach(() => {
28 queryClient.clear()
29 vi.useRealTimers()
30 })
31​
32 describe('useQuery', () => {
33 it('should retry fetch if the reset error boundary has been reset', async () => {
34 vi.spyOn(console, 'error').mockReturnValue(undefined)
35 const key = createKey()
36​
37 let succeed = false
38​
39 function Page() {
40 const { data } = useQuery({
41 queryKey: key,
42 queryFn: () =>
43 sleep(10).then(() => {
44 if (!succeed) throw new Error('Error')
45 return 'data'
46 }),
47 retry: false,
48 throwOnError: true,
49 })
50​
51 return <div>{data}</div>
52 }
53​
54 const rendered = renderWithClient(
55 queryClient,
56 <QueryErrorResetBoundary>
57 {({ reset }) => (
58 <ErrorBoundary
59 onReset={reset}
60 fallbackRender={({ resetErrorBoundary }) => (
61 <div>
62 <div>error boundary</div>
63 <button
64 onClick={() => {
65 resetErrorBoundary()
66 }}
67 >
68 retry
69 </button>
70 </div>
71 )}
72 >
73 <Page />
74 </ErrorBoundary>
75 )}
76 </QueryErrorResetBoundary>,
77 )
78​
79 await vi.advanceTimersByTimeAsync(11)
80 expect(rendered.getByText('error boundary')).toBeInTheDocument()
81 expect(rendered.getByText('retry')).toBeInTheDocument()
82​
83 succeed = true
84​
85 fireEvent.click(rendered.getByText('retry'))
86 await vi.advanceTimersByTimeAsync(11)
87 expect(rendered.getByText('data')).toBeInTheDocument()
88 })
89​
90 it('should not throw error if query is disabled', async () => {
91 vi.spyOn(console, 'error').mockReturnValue(undefined)
92 const key = createKey()
93​
94 let succeed = false
95​
96 function Page() {
97 const { data, status } = useQuery({
98 queryKey: key,
99 queryFn: () =>
100 sleep(10).then(() => {
101 if (!succeed) throw new Error('Error')
102 return 'data'
103 }),
104 retry: false,
105 enabled: !succeed,
106 throwOnError: true,
107 })
108​
109 return (
110 <div>
111 <div>status: {status}</div>
112 <div>{data}</div>
113 </div>
114 )
115 }
116​
117 const rendered = renderWithClient(
118 queryClient,
119 <QueryErrorResetBoundary>
120 {({ reset }) => (
121 <ErrorBoundary
122 onReset={reset}
123 fallbackRender={({ resetErrorBoundary }) => (
124 <div>
125 <div>error boundary</div>
126 <button
127 onClick={() => {
128 resetErrorBoundary()
129 }}
130 >
131 retry
132 </button>
133 </div>
134 )}
135 >
136 <Page />
137 </ErrorBoundary>
138 )}
139 </QueryErrorResetBoundary>,
140 )
141​
142 await vi.advanceTimersByTimeAsync(11)
143 expect(rendered.getByText('error boundary')).toBeInTheDocument()
144 expect(rendered.getByText('retry')).toBeInTheDocument()
145​
146 succeed = true
147​
148 fireEvent.click(rendered.getByText('retry'))
149 await vi.advanceTimersByTimeAsync(11)
150 expect(rendered.getByText('status: error')).toBeInTheDocument()
151 })
152​
153 it('should not throw error if query is disabled, and refetch if query becomes enabled again', async () => {
154 vi.spyOn(console, 'error').mockReturnValue(undefined)
155​
156 const key = createKey()
157​
158 let succeed = false
159​
160 function Page() {
161 const [enabled, setEnabled] = React.useState(false)
162 const { data } = useQuery({
163 queryKey: key,
164 queryFn: () =>
165 sleep(10).then(() => {
166 if (!succeed) throw new Error('Error')
167 return 'data'
168 }),
169 retry: false,
170 enabled,
171 throwOnError: true,
172 })
173​
174 React.useEffect(() => {
175 setEnabled(true)
176 }, [])
177​
178 return <div>{data}</div>
179 }
180​
181 const rendered = renderWithClient(
182 queryClient,
183 <QueryErrorResetBoundary>
184 {({ reset }) => (
185 <ErrorBoundary
186 onReset={reset}
187 fallbackRender={({ resetErrorBoundary }) => (
188 <div>
189 <div>error boundary</div>
190 <button
191 onClick={() => {
192 resetErrorBoundary()
193 }}
194 >
195 retry
196 </button>
197 </div>
198 )}
199 >
200 <Page />
201 </ErrorBoundary>
202 )}
203 </QueryErrorResetBoundary>,
204 )
205​
206 await vi.advanceTimersByTimeAsync(11)
207 expect(rendered.getByText('error boundary')).toBeInTheDocument()
208 expect(rendered.getByText('retry')).toBeInTheDocument()
209​
210 succeed = true
211​
212 fireEvent.click(rendered.getByText('retry'))
213 await vi.advanceTimersByTimeAsync(11)
214 expect(rendered.getByText('data')).toBeInTheDocument()
215 })
216​
217 it('should throw error if query is disabled and manually refetch', async () => {
218 vi.spyOn(console, 'error').mockReturnValue(undefined)
219​
220 const key = createKey()
221​
222 function Page() {
223 const { data, refetch, status, fetchStatus } = useQuery<string>({
224 queryKey: key,
225 queryFn: () =>
226 sleep(10).then(() => Promise.reject(new Error('Error'))),
227 retry: false,
228 enabled: false,
229 throwOnError: true,
230 })
231​
232 return (
233 <div>
234 <button onClick={() => refetch()}>refetch</button>
235 <div>
236 status: {status}, fetchStatus: {fetchStatus}
237 </div>
238 <div>{data}</div>
239 </div>
240 )
241 }
242​
243 const rendered = renderWithClient(
244 queryClient,
245 <QueryErrorResetBoundary>
246 {({ reset }) => (
247 <ErrorBoundary
248 onReset={reset}
249 fallbackRender={({ resetErrorBoundary }) => (
250 <div>
251 <div>error boundary</div>
252 <button
253 onClick={() => {
254 resetErrorBoundary()
255 }}
256 >
257 retry
258 </button>
259 </div>
260 )}
261 >
262 <Page />
263 </ErrorBoundary>
264 )}
265 </QueryErrorResetBoundary>,
266 )
267​
268 expect(
269 rendered.getByText('status: pending, fetchStatus: idle'),
270 ).toBeInTheDocument()
271 await vi.advanceTimersByTimeAsync(11)
272 expect(
273 rendered.getByText('status: pending, fetchStatus: idle'),
274 ).toBeInTheDocument()
275​
276 fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
277 await vi.advanceTimersByTimeAsync(11)
278 expect(rendered.getByText('error boundary')).toBeInTheDocument()
279 })
280​
281 it('should not retry fetch if the reset error boundary has not been reset', async () => {
282 vi.spyOn(console, 'error').mockReturnValue(undefined)
283​
284 const key = createKey()
285​
286 let succeed = false
287​
288 function Page() {
289 const { data } = useQuery({
290 queryKey: key,
291 queryFn: () =>
292 sleep(10).then(() => {
293 if (!succeed) throw new Error('Error')
294 return 'data'
295 }),
296 retry: false,
297 throwOnError: true,
298 })
299​
300 return <div>{data}</div>
301 }
302​
303 const rendered = renderWithClient(
304 queryClient,
305 <QueryErrorResetBoundary>
306 {() => (
307 <ErrorBoundary
308 fallbackRender={({ resetErrorBoundary }) => (
309 <div>
310 <div>error boundary</div>
311 <button
312 onClick={() => {
313 resetErrorBoundary()
314 }}
315 >
316 retry
317 </button>
318 </div>
319 )}
320 >
321 <Page />
322 </ErrorBoundary>
323 )}
324 </QueryErrorResetBoundary>,
325 )
326​
327 await vi.advanceTimersByTimeAsync(11)
328 expect(rendered.getByText('error boundary')).toBeInTheDocument()
329 expect(rendered.getByText('retry')).toBeInTheDocument()
330​
331 succeed = true
332​
333 fireEvent.click(rendered.getByText('retry'))
334 await vi.advanceTimersByTimeAsync(11)
335 expect(rendered.getByText('error boundary')).toBeInTheDocument()
336 })
337​
338 it('should retry fetch if the reset error boundary has been reset and the query contains data from a previous fetch', async () => {
339 vi.spyOn(console, 'error').mockReturnValue(undefined)
340​
341 const key = createKey()
342​
343 let succeed = false
344​
345 function Page() {
346 const { data } = useQuery({
347 queryKey: key,
348 queryFn: () =>
349 sleep(10).then(() => {
350 if (!succeed) throw new Error('Error')
351 return 'data'
352 }),
353 retry: false,
354 throwOnError: true,
355 initialData: 'initial',
356 })
357​
358 return <div>{data}</div>
359 }
360​
361 const rendered = renderWithClient(
362 queryClient,
363 <QueryErrorResetBoundary>
364 {({ reset }) => (
365 <ErrorBoundary
366 onReset={reset}
367 fallbackRender={({ resetErrorBoundary }) => (
368 <div>
369 <div>error boundary</div>
370 <button
371 onClick={() => {
372 resetErrorBoundary()
373 }}
374 >
375 retry
376 </button>
377 </div>
378 )}
379 >
380 <Page />
381 </ErrorBoundary>
382 )}
383 </QueryErrorResetBoundary>,
384 )
385​
386 expect(rendered.getByText('initial')).toBeInTheDocument()
387 await vi.advanceTimersByTimeAsync(11)
388 expect(rendered.getByText('error boundary')).toBeInTheDocument()
389 expect(rendered.getByText('retry')).toBeInTheDocument()
390​
391 succeed = true
392​
393 fireEvent.click(rendered.getByText('retry'))
394 await vi.advanceTimersByTimeAsync(11)
395 expect(rendered.getByText('data')).toBeInTheDocument()
396 })
397​
398 it('should not retry fetch if the reset error boundary has not been reset after a previous reset', async () => {
399 vi.spyOn(console, 'error').mockReturnValue(undefined)
400​
401 const key = createKey()
402​
403 let succeed = false
404 let shouldReset = false
405​
406 function Page() {
407 const { data } = useQuery({
408 queryKey: key,
409 queryFn: () =>
410 sleep(10).then(() => {
411 if (!succeed) throw new Error('Error')
412 return 'data'
413 }),
414 retry: false,
415 throwOnError: true,
416 })
417​
418 return <div>{data}</div>
419 }
420​
421 const rendered = renderWithClient(
422 queryClient,
423 <QueryErrorResetBoundary>
424 {({ reset }) => (
425 <ErrorBoundary
426 onReset={() => {
427 if (shouldReset) {
428 reset()
429 }
430 }}
431 fallbackRender={({ resetErrorBoundary }) => (
432 <div>
433 <div>error boundary</div>
434 <button
435 onClick={() => {
436 resetErrorBoundary()
437 }}
438 >
439 retry
440 </button>
441 </div>
442 )}
443 >
444 <Page />
445 </ErrorBoundary>
446 )}
447 </QueryErrorResetBoundary>,
448 )
449​
450 await vi.advanceTimersByTimeAsync(11)
451 expect(rendered.getByText('error boundary')).toBeInTheDocument()
452 expect(rendered.getByText('retry')).toBeInTheDocument()
453​
454 succeed = false
455 shouldReset = true
456​
457 await vi.advanceTimersByTimeAsync(11)
458 expect(rendered.getByText('error boundary')).toBeInTheDocument()
459 expect(rendered.getByText('retry')).toBeInTheDocument()
460​
461 succeed = true
462 shouldReset = false
463​
464 fireEvent.click(rendered.getByText('retry'))
465 await vi.advanceTimersByTimeAsync(11)
466 expect(rendered.getByText('error boundary')).toBeInTheDocument()
467​
468 succeed = true
469 shouldReset = true
470​
471 fireEvent.click(rendered.getByText('retry'))
472 await vi.advanceTimersByTimeAsync(11)
473 expect(rendered.getByText('data')).toBeInTheDocument()
474 })
475​
476 it('should throw again on error after the reset error boundary has been reset', async () => {
477 vi.spyOn(console, 'error').mockReturnValue(undefined)
478​
479 const key = createKey()
480 let fetchCount = 0
481​
482 function Page() {
483 const { data } = useQuery<string>({
484 queryKey: key,
485 queryFn: () =>
486 sleep(10).then(() => {
487 fetchCount++
488 throw new Error('Error')
489 }),
490 retry: false,
491 throwOnError: true,
492 })
493​
494 return <div>{data}</div>
495 }
496​
497 const rendered = renderWithClient(
498 queryClient,
499 <QueryErrorResetBoundary>
500 {({ reset }) => (
501 <ErrorBoundary
502 onReset={reset}
503 fallbackRender={({ resetErrorBoundary }) => (
504 <div>
505 <div>error boundary</div>
506 <button
507 onClick={() => {
508 resetErrorBoundary()
509 }}
510 >
511 retry
512 </button>
513 </div>
514 )}
515 >
516 <Page />
517 </ErrorBoundary>
518 )}
519 </QueryErrorResetBoundary>,
520 )
521​
522 await vi.advanceTimersByTimeAsync(11)
523 expect(rendered.getByText('error boundary')).toBeInTheDocument()
524 expect(rendered.getByText('retry')).toBeInTheDocument()
525​
526 fireEvent.click(rendered.getByText('retry'))
527 await vi.advanceTimersByTimeAsync(11)
528 expect(rendered.getByText('error boundary')).toBeInTheDocument()
529 expect(rendered.getByText('retry')).toBeInTheDocument()
530​
531 fireEvent.click(rendered.getByText('retry'))
532 await vi.advanceTimersByTimeAsync(11)
533 expect(rendered.getByText('error boundary')).toBeInTheDocument()
534​
535 expect(fetchCount).toBe(3)
536 })
537​
538 it('should never render the component while the query is in error state', async () => {
539 vi.spyOn(console, 'error').mockReturnValue(undefined)
540​
541 const key = createKey()
542 let fetchCount = 0
543 let renders = 0
544​
545 function Page() {
546 const { data } = useSuspenseQuery({
547 queryKey: key,
548 queryFn: () =>
549 sleep(10).then(() => {
550 fetchCount++
551 if (fetchCount > 2) return 'data'
552 throw new Error('Error')
553 }),
554 retry: false,
555 })
556​
557 renders++
558​
559 return <div>{data}</div>
560 }
561​
562 const rendered = renderWithClient(
563 queryClient,
564 <QueryErrorResetBoundary>
565 {({ reset }) => (
566 <ErrorBoundary
567 onReset={reset}
568 fallbackRender={({ resetErrorBoundary }) => (
569 <div>
570 <div>error boundary</div>
571 <button
572 onClick={() => {
573 resetErrorBoundary()
574 }}
575 >
576 retry
577 </button>
578 </div>
579 )}
580 >
581 <React.Suspense fallback={<div>loading</div>}>
582 <Page />
583 </React.Suspense>
584 </ErrorBoundary>
585 )}
586 </QueryErrorResetBoundary>,
587 )
588​
589 expect(rendered.getByText('loading')).toBeInTheDocument()
590 await act(() => vi.advanceTimersByTimeAsync(10))
591 expect(rendered.getByText('error boundary')).toBeInTheDocument()
592 expect(rendered.getByText('retry')).toBeInTheDocument()
593​
594 fireEvent.click(rendered.getByText('retry'))
595 expect(rendered.getByText('loading')).toBeInTheDocument()
596 await act(() => vi.advanceTimersByTimeAsync(10))
597 expect(rendered.getByText('error boundary')).toBeInTheDocument()
598 expect(rendered.getByText('retry')).toBeInTheDocument()
599​
600 fireEvent.click(rendered.getByText('retry'))
601 expect(rendered.getByText('loading')).toBeInTheDocument()
602 await act(() => vi.advanceTimersByTimeAsync(10))
603 expect(rendered.getByText('data')).toBeInTheDocument()
604​
605 expect(fetchCount).toBe(3)
606 expect(renders).toBe(1)
607 })
608​
609 it('should render children', () => {
610 vi.spyOn(console, 'error').mockReturnValue(undefined)
611​
612 function Page() {
613 return (
614 <div>
615 <span>page</span>
616 </div>
617 )
618 }
619​
620 const rendered = renderWithClient(
621 queryClient,
622 <QueryErrorResetBoundary>
623 <Page />
624 </QueryErrorResetBoundary>,
625 )
626​
627 expect(rendered.getByText('page')).toBeInTheDocument()
628 })
629​
630 it('should show error boundary when using tracked queries even though we do not track the error field', async () => {
631 vi.spyOn(console, 'error').mockReturnValue(undefined)
632​
633 const key = createKey()
634​
635 let succeed = false
636​
637 function Page() {
638 const { data } = useQuery({
639 queryKey: key,
640 queryFn: () =>
641 sleep(10).then(() => {
642 if (!succeed) throw new Error('Error')
643 return 'data'
644 }),
645 retry: false,
646 throwOnError: true,
647 })
648​
649 return <div>{data}</div>
650 }
651​
652 const rendered = renderWithClient(
653 queryClient,
654 <QueryErrorResetBoundary>
655 {({ reset }) => (
656 <ErrorBoundary
657 onReset={reset}
658 fallbackRender={({ resetErrorBoundary }) => (
659 <div>
660 <div>error boundary</div>
661 <button
662 onClick={() => {
663 resetErrorBoundary()
664 }}
665 >
666 retry
667 </button>
668 </div>
669 )}
670 >
671 <Page />
672 </ErrorBoundary>
673 )}
674 </QueryErrorResetBoundary>,
675 )
676​
677 await vi.advanceTimersByTimeAsync(11)
678 expect(rendered.getByText('error boundary')).toBeInTheDocument()
679 expect(rendered.getByText('retry')).toBeInTheDocument()
680​
681 succeed = true
682​
683 fireEvent.click(rendered.getByText('retry'))
684 await vi.advanceTimersByTimeAsync(11)
685 expect(rendered.getByText('data')).toBeInTheDocument()
686 })
687​
688 it('should refetch after error when staleTime is Infinity and previous data exists (#9728)', async () => {
689 const key = createKey()
690 const queryFn = vi.fn<() => Promise<string>>()
691 let count = 0
692​
693 queryFn.mockImplementation(async () => {
694 await sleep(10)
695 count++
696 if (count === 2) {
697 throw new Error('Error ' + count)
698 }
699 return 'Success ' + count
700 })
701​
702 function Page() {
703 const [_count, setCount] = React.useState(0)
704​
705 React.useEffect(() => {
706 setCount(1)
707 }, [])
708​
709 const { data, refetch } = useQuery({
710 queryKey: key,
711 queryFn,
712 retry: false,
713 staleTime: Infinity,
714 throwOnError: true,
715 })
716​
717 return (
718 <div>
719 <div>Data: {data}</div>
720 <button onClick={() => refetch()}>Refetch</button>
721 </div>
722 )
723 }
724​
725 const rendered = renderWithClient(
726 queryClient,
727 <React.StrictMode>
728 <QueryErrorResetBoundary>
729 {({ reset }) => (
730 <ErrorBoundary
731 onReset={reset}
732 fallbackRender={({ resetErrorBoundary }) => (
733 <div>
734 <div>Status: error</div>
735 <button onClick={resetErrorBoundary}>Retry</button>
736 </div>
737 )}
738 >
739 <Page />
740 </ErrorBoundary>
741 )}
742 </QueryErrorResetBoundary>
743 </React.StrictMode>,
744 )
745​
746 // 1. First mount -> fetching -> Success
747 await vi.advanceTimersByTimeAsync(11)
748 expect(rendered.getByText('Data: Success 1')).toBeInTheDocument()
749 expect(queryFn).toHaveBeenCalledTimes(1)
750​
751 // 2. Click Refetch -> Triggers fetch -> Fails (Error 2) -> ErrorBoundary
752 fireEvent.click(rendered.getByText('Refetch'))
753 await vi.advanceTimersByTimeAsync(11)
754 expect(rendered.getByText('Status: error')).toBeInTheDocument()
755 expect(queryFn).toHaveBeenCalledTimes(2)
756​
757 // 3. Click Retry -> Remounts
758 // Because staleTime is Infinity and we have Data from (1),
759 // AND we are in Error state.
760 fireEvent.click(rendered.getByText('Retry'))
761 await vi.advanceTimersByTimeAsync(11)
762 expect(rendered.getByText('Data: Success 3')).toBeInTheDocument()
763 expect(queryFn).toHaveBeenCalledTimes(3)
764 })
765 })
766​
767 describe('useQueries', () => {
768 it('should retry fetch if the reset error boundary has been reset', async () => {
769 vi.spyOn(console, 'error').mockReturnValue(undefined)
770 const key = createKey()
771​
772 let succeed = false
773​
774 function Page() {
775 const [{ data }] = useQueries({
776 queries: [
777 {
778 queryKey: key,
779 queryFn: () =>
780 sleep(10).then(() => {
781 if (!succeed) throw new Error('Error')
782 return 'data'
783 }),
784 retry: false,
785 throwOnError: true,
786 retryOnMount: () => true,
787 },
788 ],
789 })
790​
791 return <div>{data}</div>
792 }
793​
794 const rendered = renderWithClient(
795 queryClient,
796 <QueryErrorResetBoundary>
797 {({ reset }) => (
798 <ErrorBoundary
799 onReset={reset}
800 fallbackRender={({ resetErrorBoundary }) => (
801 <div>
802 <div>error boundary</div>
803 <button
804 onClick={() => {
805 resetErrorBoundary()
806 }}
807 >
808 retry
809 </button>
810 </div>
811 )}
812 >
813 <Page />
814 </ErrorBoundary>
815 )}
816 </QueryErrorResetBoundary>,
817 )
818​
819 await vi.advanceTimersByTimeAsync(11)
820 expect(rendered.getByText('error boundary')).toBeInTheDocument()
821 expect(rendered.getByText('retry')).toBeInTheDocument()
822​
823 succeed = true
824​
825 fireEvent.click(rendered.getByText('retry'))
826 await vi.advanceTimersByTimeAsync(11)
827 expect(rendered.getByText('data')).toBeInTheDocument()
828 })
829​
830 it('should retry fetch with suspense if the reset error boundary has been reset', async () => {
831 const key = createKey()
832 vi.spyOn(console, 'error').mockReturnValue(undefined)
833​
834 let succeed = false
835​
836 function Page() {
837 const [{ data }] = useSuspenseQueries({
838 queries: [
839 {
840 queryKey: key,
841 queryFn: () =>
842 sleep(10).then(() => {
843 if (!succeed) throw new Error('Error')
844 return 'data'
845 }),
846 retry: false,
847 retryOnMount: () => true,
848 },
849 ],
850 })
851​
852 return <div>{data}</div>
853 }
854​
855 const rendered = renderWithClient(
856 queryClient,
857 <QueryErrorResetBoundary>
858 {({ reset }) => (
859 <ErrorBoundary
860 onReset={reset}
861 fallbackRender={({ resetErrorBoundary }) => (
862 <div>
863 <div>error boundary</div>
864 <button
865 onClick={() => {
866 resetErrorBoundary()
867 }}
868 >
869 retry
870 </button>
871 </div>
872 )}
873 >
874 <React.Suspense fallback="loading">
875 <Page />
876 </React.Suspense>
877 </ErrorBoundary>
878 )}
879 </QueryErrorResetBoundary>,
880 )
881​
882 expect(rendered.getByText('loading')).toBeInTheDocument()
883 await act(() => vi.advanceTimersByTimeAsync(10))
884 expect(rendered.getByText('error boundary')).toBeInTheDocument()
885 expect(rendered.getByText('retry')).toBeInTheDocument()
886​
887 succeed = true
888​
889 fireEvent.click(rendered.getByText('retry'))
890 expect(rendered.getByText('loading')).toBeInTheDocument()
891 await act(() => vi.advanceTimersByTimeAsync(10))
892 expect(rendered.getByText('data')).toBeInTheDocument()
893 })
894 })
895})