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