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

useSuspenseQuery.test.tsx

1,107 lines30.2 KB

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