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

suspense.test.tsx

894 lines24.2 KB

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