Open History to see the last commit
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 })
1026})