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

suspense.test.tsx

1,026 lines27.2 KB

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