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

useQuery.test.js

1,069 lines27.5 KB

1import {
2 render,
3 act,
4 waitFor,
5 fireEvent,
6 cleanup,
7} from '@testing-library/react'
8import { ErrorBoundary } from 'react-error-boundary'
9import * as React from 'react'
10​
11import {
12 useQuery,
13 useQueryCache,
14 makeQueryCache,
15 ReactQueryCacheProvider,
16} from '../index'
17import { sleep } from './utils'
18​
19describe('useQuery', () => {
20 afterEach(() => {
21 cleanup()
22 })
23​
24 // See https://github.com/tannerlinsley/react-query/issues/105
25 it('should allow to set default data value', async () => {
26 function Page() {
27 const { data = 'default' } = useQuery('test', async () => {
28 await sleep(10)
29 return 'test'
30 })
31​
32 return (
33 <div>
34 <h1>{data}</h1>
35 </div>
36 )
37 }
38​
39 const rendered = render(
40 <ReactQueryCacheProvider>
41 <Page />
42 </ReactQueryCacheProvider>
43 )
44​
45 rendered.getByText('default')
46 await waitFor(() => rendered.getByText('test'))
47 })
48​
49 // See https://github.com/tannerlinsley/react-query/issues/137
50 it('should not override initial data in dependent queries', async () => {
51 function Page() {
52 const first = useQuery(false && 'first', () => 'data', {
53 initialData: 'init',
54 })
55​
56 const second = useQuery(false && 'second', () => 'data', {
57 initialData: 'init',
58 })
59​
60 return (
61 <div>
62 <h2>First Data: {first.data}</h2>
63 <h2>Second Data: {second.data}</h2>
64 <div>First Status: {first.status}</div>
65 <div>Second Status: {second.status}</div>
66 </div>
67 )
68 }
69​
70 const rendered = render(
71 <ReactQueryCacheProvider>
72 <Page />
73 </ReactQueryCacheProvider>
74 )
75​
76 rendered.getByText('First Data: init')
77 rendered.getByText('Second Data: init')
78 rendered.getByText('First Status: success')
79 rendered.getByText('Second Status: success')
80 })
81​
82 // See https://github.com/tannerlinsley/react-query/issues/170
83 it('should start with status success if falsey query key is supplied', async () => {
84 function Page() {
85 const first = useQuery(false && 'first', () => 'data')
86 const second = useQuery('second', () => 'data')
87​
88 return (
89 <div>
90 <div>First Status: {first.status}</div>
91 <div>Second Status: {second.status}</div>
92 </div>
93 )
94 }
95​
96 const rendered = render(
97 <ReactQueryCacheProvider>
98 <Page />
99 </ReactQueryCacheProvider>
100 )
101​
102 // use "act" to wait for state update and prevent console warning
103​
104 rendered.getByText('First Status: success')
105 await waitFor(() => rendered.getByText('Second Status: loading'))
106 await waitFor(() => rendered.getByText('Second Status: success'))
107 })
108​
109 // See https://github.com/tannerlinsley/react-query/issues/217
110 it('should start with status success if a null query key is supplied', async () => {
111 function Page() {
112 const first = useQuery(null && 'first', () => 'data')
113 const second = useQuery('second', () => 'data')
114​
115 return (
116 <div>
117 <div>First Status: {first.status}</div>
118 <div>Second Status: {second.status}</div>
119 </div>
120 )
121 }
122​
123 const rendered = render(
124 <ReactQueryCacheProvider>
125 <Page />
126 </ReactQueryCacheProvider>
127 )
128​
129 rendered.getByText('First Status: success')
130 await waitFor(() => rendered.getByText('Second Status: loading'))
131 await waitFor(() => rendered.getByText('Second Status: success'))
132 })
133​
134 // See https://github.com/tannerlinsley/react-query/issues/144
135 it('should be in "loading" state by default', async () => {
136 function Page() {
137 const { status } = useQuery('test', async () => {
138 await sleep(10)
139 return 'test'
140 })
141​
142 return (
143 <div>
144 <h1 data-testid="status">{status}</h1>
145 </div>
146 )
147 }
148​
149 const { getByTestId } = render(
150 <ReactQueryCacheProvider>
151 <Page />
152 </ReactQueryCacheProvider>
153 )
154​
155 await waitFor(() => getByTestId('status'))
156 act(() => {
157 expect(getByTestId('status').textContent).toBe('loading')
158 })
159 })
160​
161 // See https://github.com/tannerlinsley/react-query/issues/144
162 it('should be in "success" state by default in manual mode', async () => {
163 function Page() {
164 const { status } = useQuery(
165 'test',
166 async () => {
167 await sleep(10)
168 return 'test'
169 },
170 {
171 manual: true,
172 }
173 )
174​
175 return (
176 <div>
177 <h1>{status}</h1>
178 </div>
179 )
180 }
181​
182 const { findByText } = render(
183 <ReactQueryCacheProvider>
184 <Page />
185 </ReactQueryCacheProvider>
186 )
187​
188 await findByText('success')
189 })
190​
191 // See https://github.com/tannerlinsley/react-query/issues/147
192 it('should not pass stringified variables to query function', async () => {
193 const queryFn = jest.fn()
194 queryFn.mockImplementation(() => sleep(10))
195​
196 const variables = { number: 5, boolean: false, object: {}, array: [] }
197​
198 function Page() {
199 useQuery(['test', variables], queryFn)
200​
201 return null
202 }
203​
204 render(
205 <ReactQueryCacheProvider>
206 <Page />
207 </ReactQueryCacheProvider>
208 )
209​
210 expect(queryFn).toHaveBeenCalledWith('test', variables)
211 })
212​
213 // See https://github.com/tannerlinsley/react-query/issues/161
214 it('should not fetch query when `manual` is set to `true`', async () => {
215 const queryFn = jest.fn()
216​
217 function Page() {
218 const { data = 'default' } = useQuery('test', queryFn, { manual: true })
219​
220 return (
221 <div>
222 <h1>{data}</h1>
223 </div>
224 )
225 }
226​
227 const rendered = render(
228 <ReactQueryCacheProvider>
229 <Page />
230 </ReactQueryCacheProvider>
231 )
232 await waitFor(() => rendered.getByText('default'))
233 expect(queryFn).not.toHaveBeenCalled()
234 })
235​
236 it('should not refetch query on focus when `manual` is set to `true`', async () => {
237 const queryFn = jest.fn()
238​
239 function Page() {
240 const { data = 'default' } = useQuery('test', queryFn, { manual: true })
241​
242 return (
243 <div>
244 <h1>{data}</h1>
245 </div>
246 )
247 }
248​
249 const rendered = render(
250 <ReactQueryCacheProvider>
251 <Page />
252 </ReactQueryCacheProvider>
253 )
254 await waitFor(() => rendered.getByText('default'))
255​
256 act(() => {
257 window.dispatchEvent(new FocusEvent('focus'))
258 })
259​
260 expect(queryFn).not.toHaveBeenCalled()
261 })
262​
263 it('should set status to error if queryFn throws', async () => {
264 function Page() {
265 const { status, error } = useQuery(
266 'test',
267 () => {
268 return Promise.reject('Error test')
269 },
270 { retry: false }
271 )
272​
273 return (
274 <div>
275 <h1>{status}</h1>
276 <h2>{error}</h2>
277 </div>
278 )
279 }
280​
281 const rendered = render(
282 <ReactQueryCacheProvider>
283 <Page />
284 </ReactQueryCacheProvider>
285 )
286​
287 await waitFor(() => rendered.getByText('error'))
288 await waitFor(() => rendered.getByText('Error test'))
289 })
290​
291 it('should retry specified number of times', async () => {
292 const queryFn = jest.fn()
293 queryFn.mockImplementation(() => {
294 return Promise.reject('Error test')
295 })
296​
297 function Page() {
298 const { status, failureCount } = useQuery('test', queryFn, {
299 retry: 1,
300 retryDelay: 1,
301 })
302​
303 return (
304 <div>
305 <h1>{status}</h1>
306 <h2>Failed {failureCount} times</h2>
307 </div>
308 )
309 }
310​
311 const rendered = render(
312 <ReactQueryCacheProvider>
313 <Page />
314 </ReactQueryCacheProvider>
315 )
316​
317 await waitFor(() => rendered.getByText('loading'))
318 await waitFor(() => rendered.getByText('error'))
319​
320 // query should fail `retry + 1` times, since first time isn't a "retry"
321 await waitFor(() => rendered.getByText('Failed 2 times'))
322​
323 expect(queryFn).toHaveBeenCalledTimes(2)
324 })
325​
326 it('should not retry if retry function `false`', async () => {
327 const queryFn = jest.fn()
328​
329 queryFn.mockImplementationOnce(() => {
330 return Promise.reject('Error test')
331 })
332​
333 queryFn.mockImplementation(() => {
334 return Promise.reject('NoRetry')
335 })
336​
337 function Page() {
338 const { status, failureCount, error } = useQuery('test', queryFn, {
339 retryDelay: 1,
340 retry: (failureCount, error) => error !== 'NoRetry',
341 })
342​
343 return (
344 <div>
345 <h1>{status}</h1>
346 <h2>Failed {failureCount} times</h2>
347 <h2>{error}</h2>
348 </div>
349 )
350 }
351​
352 const rendered = render(
353 <ReactQueryCacheProvider>
354 <Page />
355 </ReactQueryCacheProvider>
356 )
357​
358 await waitFor(() => rendered.getByText('loading'))
359 await waitFor(() => rendered.getByText('error'))
360​
361 await waitFor(() => rendered.getByText('Failed 2 times'))
362 await waitFor(() => rendered.getByText('NoRetry'))
363​
364 expect(queryFn).toHaveBeenCalledTimes(2)
365 })
366​
367 it('should garbage collect queries without data immediately', async () => {
368 const queryCache = makeQueryCache()
369 function Page() {
370 const [filter, setFilter] = React.useState('')
371 const { data } = useQuery(
372 ['todos', { filter }],
373 async (key, { filter } = {}) => {
374 await sleep(10)
375 return `todo ${filter}`
376 }
377 )
378​
379 return (
380 <div>
381 <div>{data}</div>
382 <button onClick={() => setFilter(filter + 'a')}>update</button>
383 </div>
384 )
385 }
386​
387 const rendered = render(
388 <ReactQueryCacheProvider queryCache={queryCache}>
389 <Page />
390 </ReactQueryCacheProvider>
391 )
392​
393 await waitFor(() => rendered.getByText('update'))
394​
395 fireEvent.click(rendered.getByText('update'))
396 fireEvent.click(rendered.getByText('update'))
397 fireEvent.click(rendered.getByText('update'))
398 fireEvent.click(rendered.getByText('update'))
399​
400 expect(Object.keys(queryCache.queries).length).toEqual(5)
401​
402 await waitFor(() => rendered.getByText('todo aaaa'))
403​
404 expect(Object.keys(queryCache.queries).length).toEqual(1)
405 })
406​
407 // See https://github.com/tannerlinsley/react-query/issues/160
408 it('should continue retry after focus regain', async () => {
409 const originalVisibilityState = document.visibilityState
410​
411 function mockVisibilityState(value) {
412 Object.defineProperty(document, 'visibilityState', {
413 value,
414 configurable: true,
415 })
416 }
417​
418 // make page unfocused
419 mockVisibilityState('hidden')
420​
421 function Page() {
422 const query = useQuery('test', () => Promise.reject('fetching error'), {
423 retry: 3,
424 retryDelay: 1,
425 })
426​
427 return (
428 <div>
429 <div>status {query.status}</div>
430 <div>failureCount {query.failureCount}</div>
431 </div>
432 )
433 }
434​
435 const rendered = render(
436 <ReactQueryCacheProvider>
437 <Page />
438 </ReactQueryCacheProvider>
439 )
440​
441 await waitFor(() => rendered.getByText('failureCount 1'))
442 await waitFor(() => rendered.getByText('status loading'))
443​
444 act(() => {
445 // reset visibilityState to original value
446 mockVisibilityState(originalVisibilityState)
447 window.dispatchEvent(new FocusEvent('focus'))
448 })
449​
450 await waitFor(() => rendered.getByText('failureCount 4'))
451 await waitFor(() => rendered.getByText('status error'))
452 })
453​
454 // See https://github.com/tannerlinsley/react-query/issues/195
455 it('should not refetch immediately after a prefetch', async () => {
456 const queryCache = makeQueryCache()
457 const queryFn = jest.fn()
458 queryFn.mockImplementation(() => sleep(10))
459​
460 const prefetchQueryFn = jest.fn()
461 prefetchQueryFn.mockImplementation(() => sleep(10))
462​
463 function Page() {
464 const query = useQuery('test', queryFn)
465​
466 return (
467 <div>
468 <div>status {query.status}</div>
469 </div>
470 )
471 }
472​
473 await queryCache.prefetchQuery('test', prefetchQueryFn)
474 await queryCache.prefetchQuery('test', prefetchQueryFn)
475​
476 const rendered = render(
477 <ReactQueryCacheProvider queryCache={queryCache}>
478 <Page />
479 </ReactQueryCacheProvider>
480 )
481​
482 await waitFor(() => rendered.getByText('status success'))
483​
484 expect(prefetchQueryFn).toHaveBeenCalledTimes(1)
485 expect(queryFn).toHaveBeenCalledTimes(0)
486 })
487​
488 // See https://github.com/tannerlinsley/react-query/issues/190
489 it('should reset failureCount on successful fetch', async () => {
490 function Page() {
491 let counter = 0
492 const query = useQuery(
493 'test',
494 async () => {
495 if (counter === 0) {
496 counter++
497 throw new Error('error')
498 } else {
499 return 'data'
500 }
501 },
502 { retryDelay: 50 }
503 )
504​
505 return (
506 <div>
507 <div>failureCount {query.failureCount}</div>
508 </div>
509 )
510 }
511​
512 const rendered = render(
513 <ReactQueryCacheProvider>
514 <Page />
515 </ReactQueryCacheProvider>
516 )
517​
518 await waitFor(() => rendered.getByText('failureCount 1'))
519 await waitFor(() => rendered.getByText('failureCount 0'))
520 })
521​
522 // See https://github.com/tannerlinsley/react-query/issues/199
523 it('should use prefetched data for dependent query', async () => {
524 function Page() {
525 const queryCache = useQueryCache()
526 const [key, setKey] = React.useState(false)
527 const [isPrefetched, setPrefetched] = React.useState(false)
528​
529 const query = useQuery(key, () => {})
530​
531 React.useEffect(() => {
532 async function prefetch() {
533 await queryCache.prefetchQuery('key', () =>
534 Promise.resolve('prefetched data')
535 )
536 setPrefetched(true)
537 }
538 prefetch()
539 }, [queryCache])
540​
541 return (
542 <div>
543 {isPrefetched && <div>isPrefetched</div>}
544 <button onClick={() => setKey('key')}>setKey</button>
545 <div>{query.data}</div>
546 </div>
547 )
548 }
549​
550 const rendered = render(
551 <ReactQueryCacheProvider>
552 <Page />
553 </ReactQueryCacheProvider>
554 )
555 await waitFor(() => rendered.getByText('isPrefetched'))
556​
557 fireEvent.click(rendered.getByText('setKey'))
558 await waitFor(() => rendered.getByText('prefetched data'))
559 })
560​
561 it('should support a function that resolves a query key', async () => {
562 function Page() {
563 const { status, data, query } = useQuery(
564 () => 'key',
565 () => 'data'
566 )
567​
568 return (
569 <div>
570 <div>Status: {status}</div>
571 <div>Data: {data}</div>
572 <div>Key: {query.queryKey}</div>
573 </div>
574 )
575 }
576​
577 const rendered = render(
578 <ReactQueryCacheProvider>
579 <Page />
580 </ReactQueryCacheProvider>
581 )
582​
583 rendered.getByText('Status: loading')
584 await waitFor(() => rendered.getByText('Status: success'))
585 rendered.getByText('Data: data')
586 rendered.getByText('Key: key')
587 })
588​
589 it('should support dependent query keys via returng falsy in a query key function', async () => {
590 function Page() {
591 const [shouldFetch, setShouldFetch] = React.useState(false)
592​
593 const query = useQuery(
594 () => shouldFetch && 'key',
595 () => 'data'
596 )
597​
598 return (
599 <div>
600 <div>Status: {query.status}</div>
601 <h2>Data: {query.data || 'no data'}</h2>
602 {query.isStale ? (
603 <button onClick={() => setShouldFetch(true)}>fetch</button>
604 ) : null}
605 </div>
606 )
607 }
608​
609 const rendered = render(
610 <ReactQueryCacheProvider>
611 <Page />
612 </ReactQueryCacheProvider>
613 )
614​
615 rendered.getByText('Status: success')
616 rendered.getByText('Data: no data')
617​
618 fireEvent.click(rendered.getByText('fetch'))
619​
620 await waitFor(() => rendered.getByText('Status: loading'))
621 await waitFor(() => [
622 rendered.getByText('Status: success'),
623 rendered.getByText('Data: data'),
624 ])
625 })
626​
627 it('should support dependent query keys via throwing in a query key function', async () => {
628 function Page() {
629 const [shouldFetch, setShouldFetch] = React.useState()
630​
631 const query = useQuery(
632 () => shouldFetch.on && 'key',
633 () => 'data'
634 )
635​
636 return (
637 <div>
638 <div>Status: {query.status}</div>
639 <h2>Data: {query.data || 'no data'}</h2>
640 {query.isStale ? (
641 <button onClick={() => setShouldFetch({ on: true })}>fetch</button>
642 ) : null}
643 </div>
644 )
645 }
646​
647 const rendered = render(
648 <ReactQueryCacheProvider>
649 <Page />
650 </ReactQueryCacheProvider>
651 )
652​
653 rendered.getByText('Status: success')
654 rendered.getByText('Data: no data')
655​
656 fireEvent.click(rendered.getByText('fetch'))
657​
658 await waitFor(() => rendered.getByText('Status: loading'))
659 await waitFor(() => [
660 rendered.getByText('Status: success'),
661 rendered.getByText('Data: data'),
662 ])
663 })
664​
665 it('should not mark query as fetching, when using initialData', async () => {
666 function Page() {
667 const query = useQuery('key', () => {}, { initialData: 'data' })
668​
669 return (
670 <div>
671 <div>{query.data}</div>
672 <div data-testid="isFetching">{`${query.isFetching}`}</div>
673 </div>
674 )
675 }
676​
677 const rendered = render(
678 <ReactQueryCacheProvider>
679 <Page />
680 </ReactQueryCacheProvider>
681 )
682​
683 rendered.getByText('data')
684 expect(rendered.getByTestId('isFetching').textContent).toBe('false')
685 })
686​
687 it('should initialize state properly, when initialData is falsy', async () => {
688 function Page() {
689 const query = useQuery('key', () => {}, { initialData: 0 })
690​
691 return (
692 <div>
693 <div>{query.data}</div>
694 <div data-testid="isFetching">{`${query.isFetching}`}</div>
695 <div data-testid="status">{query.status}</div>
696 </div>
697 )
698 }
699​
700 const rendered = render(
701 <ReactQueryCacheProvider>
702 <Page />
703 </ReactQueryCacheProvider>
704 )
705​
706 rendered.getByText('0')
707 expect(rendered.getByTestId('isFetching').textContent).toBe('false')
708 expect(rendered.getByTestId('status').textContent).toBe('success')
709 })
710​
711 // See https://github.com/tannerlinsley/react-query/issues/214
712 it('should not cause infinite loop after query key is changed to falsy', async () => {
713 const callback = jest.fn()
714​
715 function Page() {
716 const [shouldFetch, setShouldFetch] = React.useState(true)
717 const query = useQuery(shouldFetch && 'key', () => 'fetched data', {
718 initialData: shouldFetch ? 'initial' : 'initial falsy',
719 })
720​
721 const { data } = query
722​
723 React.useEffect(() => {
724 callback()
725 }, [query])
726​
727 return (
728 <div>
729 <div>{data}</div>
730 <button onClick={() => setShouldFetch(false)}>
731 setShouldFetch(false)
732 </button>
733 </div>
734 )
735 }
736​
737 const rendered = render(
738 <ReactQueryCacheProvider>
739 <Page />
740 </ReactQueryCacheProvider>
741 )
742​
743 await waitFor(() => rendered.getByText('initial'))
744 fireEvent.click(rendered.getByText('setShouldFetch(false)'))
745 rendered.getByText('initial falsy')
746 // wait for infinite loop to call mock function a bit
747 await sleep(200)
748 expect(callback.mock.calls.length).toBeLessThan(5)
749 })
750 it('it should support falsy queryKey in query object syntax', async () => {
751 const queryFn = jest.fn()
752 queryFn.mockImplementation(() => 'data')
753 const queryCache = makeQueryCache()
754​
755 function Page() {
756 useQuery({
757 queryKey: false && 'key',
758 queryFn,
759 })
760 return null
761 }
762 render(
763 <ReactQueryCacheProvider>
764 <Page />
765 </ReactQueryCacheProvider>
766 )
767​
768 const cachedQueries = Object.keys(queryCache.queries).length
769 expect(queryFn).not.toHaveBeenCalled()
770 expect(cachedQueries).toEqual(0)
771 })
772 it('it should throw when using query syntax and missing required keys', async () => {
773 // mock console.error to avoid the wall of red text,
774 // you could also do this on beforeEach/afterEach
775 jest.spyOn(console, 'error')
776 console.error.mockImplementation(() => {})
777​
778 function Page() {
779 useQuery({})
780 return null
781 }
782 expect(() =>
783 render(
784 <ReactQueryCacheProvider>
785 <Page />
786 </ReactQueryCacheProvider>
787 )
788 ).toThrowError(/queryKey|queryFn/)
789​
790 console.error.mockRestore()
791 })
792​
793 test('should schedule stale timeout by default', async () => {
794 function Page() {
795 const query = useQuery('test', () => 'fetched data')
796​
797 return (
798 <div>
799 <div>{query.data}</div>
800 <div data-testid="isStale">{`${query.isStale}`}</div>
801 <div data-testid="staleTimeout">{`${query.query.staleTimeout}`}</div>
802 </div>
803 )
804 }
805​
806 const rendered = render(
807 <ReactQueryCacheProvider>
808 <Page />
809 </ReactQueryCacheProvider>
810 )
811​
812 await waitFor(() => rendered.getByText('fetched data'))
813 await waitFor(() => {
814 expect(rendered.getByTestId('isStale').textContent).toBe('true')
815 })
816 expect(rendered.getByTestId('staleTimeout').textContent).not.toBe(
817 'undefined'
818 )
819 })
820​
821 test('should not schedule stale timeout, if staleTime is set to `Infinity`', async () => {
822 function Page() {
823 const query = useQuery('test', () => 'fetched data', {
824 staleTime: Infinity,
825 })
826​
827 return (
828 <div>
829 <div>{query.data}</div>
830 <div data-testid="isStale">{`${query.isStale}`}</div>
831 <div data-testid="staleTimeout">{`${query.query.staleTimeout}`}</div>
832 </div>
833 )
834 }
835​
836 const rendered = render(
837 <ReactQueryCacheProvider>
838 <Page />
839 </ReactQueryCacheProvider>
840 )
841​
842 await waitFor(() => rendered.getByText('fetched data'))
843 expect(rendered.getByTestId('isStale').textContent).toBe('false')
844 expect(rendered.getByTestId('staleTimeout').textContent).toBe('undefined')
845 })
846​
847 // See https://github.com/tannerlinsley/react-query/issues/360
848 test('should not init to `isFetching === true` when falsey query key is supplied', async () => {
849 function Page() {
850 const query = useQuery(false, () => {})
851​
852 return (
853 <div>
854 <div>isFetching === {query.isFetching.toString()}</div>
855 </div>
856 )
857 }
858​
859 const rendered = render(
860 <ReactQueryCacheProvider>
861 <Page />
862 </ReactQueryCacheProvider>
863 )
864​
865 await waitFor(() => rendered.getByText('isFetching === false'))
866 })
867​
868 test('should not schedule garbage collection, if cacheTimeout is set to `Infinity`', async () => {
869 function Page() {
870 const query = useQuery('test', () => 'fetched data', {
871 cacheTime: Infinity,
872 })
873 return <div>{query.data}</div>
874 }
875​
876 const queryCache = makeQueryCache()
877​
878 const rendered = render(
879 <ReactQueryCacheProvider queryCache={queryCache}>
880 <Page />
881 </ReactQueryCacheProvider>
882 )
883​
884 await waitFor(() => rendered.getByText('fetched data'))
885​
886 rendered.unmount()
887​
888 const query = queryCache.getQuery('test')
889 expect(query.cacheTimeout).toBe(undefined)
890 })
891​
892 it('should not cause memo churn when data does not change', async () => {
893 const queryFn = jest.fn()
894 const memoFn = jest.fn()
895 const originalVisibilityState = document.visibilityState
896​
897 function mockVisibilityState(value) {
898 Object.defineProperty(document, 'visibilityState', {
899 value,
900 configurable: true,
901 })
902 }
903​
904 // make page unfocused
905 mockVisibilityState('hidden')
906​
907 function Page() {
908 const query = useQuery(
909 'test',
910 () =>
911 queryFn() || {
912 data: {
913 nested: true,
914 },
915 }
916 )
917​
918 React.useMemo(() => {
919 memoFn()
920 return query.data
921 }, [query.data])
922​
923 return (
924 <div>
925 <div>status {query.status}</div>
926 <div>isFetching {query.isFetching ? 'true' : 'false'}</div>
927 </div>
928 )
929 }
930​
931 const rendered = render(
932 <ReactQueryCacheProvider>
933 <Page />
934 </ReactQueryCacheProvider>
935 )
936​
937 await waitFor(() => rendered.getByText('status loading'))
938 await waitFor(() => rendered.getByText('status success'))
939​
940 act(() => {
941 // reset visibilityState to original value
942 mockVisibilityState(originalVisibilityState)
943 window.dispatchEvent(new FocusEvent('focus'))
944 })
945​
946 await waitFor(() => rendered.getByText('isFetching true'))
947 await waitFor(() => rendered.getByText('isFetching false'))
948 expect(queryFn).toHaveBeenCalledTimes(2)
949 expect(memoFn).toHaveBeenCalledTimes(2)
950 })
951​
952 // https://github.com/tannerlinsley/react-query/issues/468
953 it('should reset error state if new component instances are mounted', async () => {
954 let succeed = false
955 jest.spyOn(console, 'error')
956 console.error.mockImplementation(() => {})
957​
958 function Page() {
959 useQuery(
960 'test',
961 async () => {
962 await sleep(10)
963​
964 if (!succeed) {
965 throw new Error()
966 } else {
967 return 'data'
968 }
969 },
970 {
971 retryDelay: 10,
972 suspense: true,
973 }
974 )
975​
976 return <div>rendered</div>
977 }
978​
979 const rendered = render(
980 <ErrorBoundary
981 fallbackRender={({ resetErrorBoundary }) => (
982 <div>
983 <div>error boundary</div>
984 <button
985 onClick={() => {
986 succeed = true
987 resetErrorBoundary()
988 }}
989 >
990 retry
991 </button>
992 </div>
993 )}
994 >
995 <React.Suspense fallback={'Loading...'}>
996 <Page />
997 </React.Suspense>
998 </ErrorBoundary>
999 )
1000​
1001 await waitFor(() => rendered.getByText('error boundary'))
1002​
1003 console.error.mockRestore()
1004​
1005 fireEvent.click(rendered.getByText('retry'))
1006​
1007 // Workaround for bug with jsdom re-rendering twice before timeout fires: utils.js > handleSuspense > setTimeout
1008 // Timeout behavior works fine in browser but shouldn't be relied upon
1009 await sleep(25)
1010 if (rendered.queryByText("retry")) {
1011 fireEvent.click(rendered.getByText('retry'))
1013​
1014 await waitFor(() => rendered.getByText('rendered'))
1015 })
1016​
1017 it('should update data upon interval changes', async () => {
1018 let count = 0
1019 function Page() {
1020 const [int, setInt] = React.useState(200)
1021 const { data } = useQuery('/api', () => count++, {
1022 refetchInterval: int,
1023 })
1024 return (
1025 <div onClick={() => setInt(num => (num < 400 ? num + 100 : 0))}>
1026 count: {data}
1027 </div>
1030 const { container } = render(<Page />)
1031 expect(container.firstChild.textContent).toEqual('count: ')
1032 await waitFor(() => {
1033 expect(container.firstChild.textContent).toEqual('count: 0')
1034 })
1035 await sleep(210);
1036 expect(container.firstChild.textContent).toEqual('count: 1')
1037 await sleep(50);
1038 expect(container.firstChild.textContent).toEqual('count: 1')
1039 await sleep(150);
1040 expect(container.firstChild.textContent).toEqual('count: 2')
1041 act(() => {
1042 fireEvent.click(container.firstElementChild)
1043 // it will clear 200ms timer and setup a new 300ms timer
1044 })
1045 await sleep(200);
1046 expect(container.firstChild.textContent).toEqual('count: 2')
1047 await sleep(110);
1048 expect(container.firstChild.textContent).toEqual('count: 3')
1049 // wait for new 300ms timer
1050 await sleep(310);
1051 expect(container.firstChild.textContent).toEqual('count: 4')
1052 act(() => {
1053 fireEvent.click(container.firstElementChild)
1054 // it will clear 300ms timer and setup a new 400ms timer
1055 })
1056 await sleep(300);
1057 expect(container.firstChild.textContent).toEqual('count: 4')
1058 await sleep(110);
1059 expect(container.firstChild.textContent).toEqual('count: 5')
1060 act(() => {
1061 fireEvent.click(container.firstElementChild)
1062 // it will clear 400ms timer and stop
1063 })
1064 await sleep(110);
1065 expect(container.firstChild.textContent).toEqual('count: 5')
1066 await sleep(110);
1067 expect(container.firstChild.textContent).toEqual('count: 5')
1068 })