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

useQueries.test.tsx

1,384 lines38.6 KB

1import { createKey, sleep } from '@tanstack/query-test-utils'
2import { fireEvent, render } 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 { IsRestoringProvider, QueryCache, QueryClient, useQueries } from '..'
7import { renderWithClient } from './utils'
8import type { QueryObserverResult, UseQueryResult } from '..'
9​
10describe('useQueries', () => {
11 let queryCache: QueryCache
12 let queryClient: QueryClient
13​
14 beforeEach(() => {
15 vi.useFakeTimers()
16 queryCache = new QueryCache()
17 queryClient = new QueryClient({ queryCache })
18 })
19​
20 afterEach(() => {
21 queryClient.clear()
22 vi.useRealTimers()
23 })
24​
25 it.each([false, true])(
26 'should settle after fetched data reaches an inline selector (throws: %s)',
27 async (throws) => {
28 const queryKey = createKey()
29 const queryFn = () => sleep(10).then(() => 'fetched')
30 let renders = 0
31​
32 function Page() {
33 renders++
34 const [{ data, error }] = useQueries({
35 queries: [
36 {
37 queryKey,
38 queryFn,
39 select: (value: string) => {
40 if (throws) throw new Error(value + ' with a select error')
41 return new Set([value])
42 },
43 },
44 ],
45 })
46 return <p>{error?.message ?? (data ? [...data].join() : 'pending')}</p>
47 }
48​
49 const rendered = renderWithClient(queryClient, <Page />)
50 expect(rendered.getByText('pending')).toBeInTheDocument()
51 for (let i = 0; i < 3; i++) {
52 await vi.advanceTimersByTimeAsync(5)
53 }
54 expect(
55 rendered.getByText(throws ? 'fetched with a select error' : 'fetched'),
56 ).toBeInTheDocument()
57 const settledRenders = renders
58​
59 for (let i = 0; i < 3; i++) {
60 await vi.advanceTimersByTimeAsync(5)
61 }
62 expect(renders).toBe(settledRenders)
63 },
64 )
65​
66 it('should return the correct states', async () => {
67 const key1 = createKey()
68 const key2 = createKey()
69 const results: Array<Array<UseQueryResult>> = []
70​
71 function Page() {
72 const result = useQueries({
73 queries: [
74 {
75 queryKey: key1,
76 queryFn: () => sleep(10).then(() => 1),
77 },
78 {
79 queryKey: key2,
80 queryFn: () => sleep(200).then(() => 2),
81 },
82 ],
83 })
84 results.push(result)
85​
86 return (
87 <div>
88 <div>
89 data1: {String(result[0].data ?? 'null')}, data2:{' '}
90 {String(result[1].data ?? 'null')}
91 </div>
92 </div>
93 )
94 }
95​
96 const rendered = renderWithClient(queryClient, <Page />)
97​
98 await vi.advanceTimersByTimeAsync(201)
99 expect(rendered.getByText('data1: 1, data2: 2')).toBeInTheDocument()
100​
101 expect(results).toHaveLength(3)
102 expect(results[0]).toMatchObject([{ data: undefined }, { data: undefined }])
103 expect(results[1]).toMatchObject([{ data: 1 }, { data: undefined }])
104 expect(results[2]).toMatchObject([{ data: 1 }, { data: 2 }])
105 })
106​
107 it('should not optimistically show fetching when unsubscribed', () => {
108 const key = createKey()
109 const queryFn = vi.fn<() => Promise<string>>(() => Promise.resolve('data'))
110​
111 function Page() {
112 const [query] = useQueries({
113 queries: [{ queryKey: key, queryFn }],
114 subscribed: false,
115 })
116​
117 return (
118 <div>
119 <span>isFetching: {String(query.isFetching)}</span>
120 <span>fetchStatus: {query.fetchStatus}</span>
121 </div>
122 )
123 }
124​
125 const rendered = renderWithClient(queryClient, <Page />)
126​
127 expect(queryFn).not.toHaveBeenCalled()
128 expect(
129 queryClient.getQueryCache().find({ queryKey: key })!.observers,
130 ).toHaveLength(0)
131 rendered.getByText('isFetching: false')
132 rendered.getByText('fetchStatus: idle')
133 })
134​
135 it('should track results', async () => {
136 const key1 = createKey()
137 const results: Array<Array<UseQueryResult>> = []
138 let count = 0
139​
140 function Page() {
141 const result = useQueries({
142 queries: [
143 {
144 queryKey: key1,
145 queryFn: () =>
146 sleep(10).then(() => {
147 count++
148 return count
149 }),
150 },
151 ],
152 })
153 results.push(result)
154​
155 return (
156 <div>
157 <div>data: {String(result[0].data ?? 'null')} </div>
158 <button onClick={() => result[0].refetch()}>refetch</button>
159 </div>
160 )
161 }
162​
163 const rendered = renderWithClient(queryClient, <Page />)
164​
165 await vi.advanceTimersByTimeAsync(11)
166 expect(rendered.getByText('data: 1')).toBeInTheDocument()
167​
168 expect(results).toHaveLength(2)
169 expect(results[0]).toMatchObject([{ data: undefined }])
170 expect(results[1]).toMatchObject([{ data: 1 }])
171​
172 fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
173 await vi.advanceTimersByTimeAsync(11)
174 expect(rendered.getByText('data: 2')).toBeInTheDocument()
175​
176 // only one render for data update, no render for isFetching transition
177 expect(results).toHaveLength(3)
178​
179 expect(results[2]).toMatchObject([{ data: 2 }])
180 })
181​
182 it("should throw error if in one of queries' queryFn throws and throwOnError is in use", async () => {
183 vi.spyOn(console, 'error').mockReturnValue(undefined)
184 const key1 = createKey()
185 const key2 = createKey()
186 const key3 = createKey()
187 const key4 = createKey()
188​
189 function Page() {
190 useQueries({
191 queries: [
192 {
193 queryKey: key1,
194 queryFn: () =>
195 Promise.reject(
196 new Error(
197 'this should not throw because throwOnError is not set',
198 ),
199 ),
200 },
201 {
202 queryKey: key2,
203 queryFn: () => Promise.reject(new Error('single query error')),
204 throwOnError: true,
205 retry: false,
206 },
207 {
208 queryKey: key3,
209 queryFn: () => Promise.resolve(2),
210 },
211 {
212 queryKey: key4,
213 queryFn: () =>
214 Promise.reject(
215 new Error('this should not throw because query#2 already did'),
216 ),
217 throwOnError: true,
218 retry: false,
219 },
220 ],
221 })
222​
223 return null
224 }
225​
226 const rendered = renderWithClient(
227 queryClient,
228 <ErrorBoundary
229 fallbackRender={({ error }) => (
230 <div>
231 <div>error boundary</div>
232 <div>{error.message}</div>
233 </div>
234 )}
235 >
236 <Page />
237 </ErrorBoundary>,
238 )
239​
240 await vi.advanceTimersByTimeAsync(0)
241 expect(rendered.getByText('error boundary')).toBeInTheDocument()
242 expect(rendered.getByText('single query error')).toBeInTheDocument()
243 })
244​
245 it("should throw error if in one of queries' queryFn throws and throwOnError function resolves to true", async () => {
246 vi.spyOn(console, 'error').mockReturnValue(undefined)
247 const key1 = createKey()
248 const key2 = createKey()
249 const key3 = createKey()
250 const key4 = createKey()
251​
252 function Page() {
253 useQueries({
254 queries: [
255 {
256 queryKey: key1,
257 queryFn: () =>
258 Promise.reject(
259 new Error(
260 'this should not throw because throwOnError function resolves to false',
261 ),
262 ),
263 throwOnError: () => false,
264 retry: false,
265 },
266 {
267 queryKey: key2,
268 queryFn: () => Promise.resolve(2),
269 },
270 {
271 queryKey: key3,
272 queryFn: () => Promise.reject(new Error('single query error')),
273 throwOnError: () => true,
274 retry: false,
275 },
276 {
277 queryKey: key4,
278 queryFn: () =>
279 Promise.reject(
280 new Error('this should not throw because query#3 already did'),
281 ),
282 throwOnError: true,
283 retry: false,
284 },
285 ],
286 })
287​
288 return null
289 }
290​
291 const rendered = renderWithClient(
292 queryClient,
293 <ErrorBoundary
294 fallbackRender={({ error }) => (
295 <div>
296 <div>error boundary</div>
297 <div>{error.message}</div>
298 </div>
299 )}
300 >
301 <Page />
302 </ErrorBoundary>,
303 )
304​
305 await vi.advanceTimersByTimeAsync(0)
306 expect(rendered.getByText('error boundary')).toBeInTheDocument()
307 expect(rendered.getByText('single query error')).toBeInTheDocument()
308 })
309​
310 it("should throw error if in one of queries' queryFn rejects with a falsy error and throwOnError is in use", async () => {
311 vi.spyOn(console, 'error').mockReturnValue(undefined)
312 const key = createKey()
313​
314 function Page() {
315 useQueries({
316 queries: [
317 {
318 queryKey: key,
319 queryFn: () => Promise.reject(),
320 retry: false,
321 throwOnError: true,
322 },
323 ],
324 })
325​
326 return null
327 }
328​
329 const rendered = renderWithClient(
330 queryClient,
331 <ErrorBoundary fallbackRender={() => <div>error boundary</div>}>
332 <Page />
333 </ErrorBoundary>,
334 )
335​
336 await vi.advanceTimersByTimeAsync(0)
337 expect(rendered.getByText('error boundary')).toBeInTheDocument()
338 })
339​
340 it('should use provided custom queryClient', async () => {
341 const key = createKey()
342 const queryFn = async () => {
343 return Promise.resolve('custom client')
344 }
345​
346 function Page() {
347 const queries = useQueries(
348 {
349 queries: [
350 {
351 queryKey: key,
352 queryFn,
353 },
354 ],
355 },
356 queryClient,
357 )
358​
359 return <div>data: {queries[0].data}</div>
360 }
361​
362 const rendered = render(<Page></Page>)
363​
364 await vi.advanceTimersByTimeAsync(0)
365 expect(rendered.getByText('data: custom client')).toBeInTheDocument()
366 })
367​
368 it('should combine queries', async () => {
369 const key1 = createKey()
370 const key2 = createKey()
371​
372 function Page() {
373 const queries = useQueries(
374 {
375 queries: [
376 {
377 queryKey: key1,
378 queryFn: () => Promise.resolve('first result'),
379 },
380 {
381 queryKey: key2,
382 queryFn: () => Promise.resolve('second result'),
383 },
384 ],
385 combine: (results) => {
386 return {
387 combined: true,
388 res: results.map((res) => res.data).join(','),
389 }
390 },
391 },
392 queryClient,
393 )
394​
395 return (
396 <div>
397 <div>
398 data: {String(queries.combined)} {queries.res}
399 </div>
400 </div>
401 )
402 }
403​
404 const rendered = render(<Page />)
405​
406 await vi.advanceTimersByTimeAsync(0)
407 expect(
408 rendered.getByText('data: true first result,second result'),
409 ).toBeInTheDocument()
410 })
411​
412 it('should not return new instances when called without queries', async () => {
413 const key = createKey()
414 const ids: Array<number> = []
415 let resultChanged = 0
416​
417 function Page() {
418 const [count, setCount] = React.useState(0)
419 const result = useQueries({
420 queries: ids.map((id) => {
421 return {
422 queryKey: [key, id],
423 queryFn: () => {
424 return () => {
425 return Promise.resolve({
426 id,
427 content: { value: Math.random() },
428 })
429 }
430 },
431 }
432 }),
433 combine: () => ({ empty: 'object' }),
434 })
435​
436 React.useEffect(() => {
437 resultChanged++
438 }, [result])
439​
440 return (
441 <div>
442 <div>count: {count}</div>
443 <div>data: {JSON.stringify(result)}</div>
444 <button onClick={() => setCount((c) => c + 1)}>inc</button>
445 </div>
446 )
447 }
448​
449 const rendered = renderWithClient(queryClient, <Page />)
450​
451 await vi.advanceTimersByTimeAsync(0)
452 expect(rendered.getByText('data: {"empty":"object"}')).toBeInTheDocument()
453 expect(rendered.getByText('count: 0')).toBeInTheDocument()
454​
455 expect(resultChanged).toBe(1)
456​
457 fireEvent.click(rendered.getByRole('button', { name: /inc/i }))
458 await vi.advanceTimersByTimeAsync(0)
459 expect(rendered.getByText('count: 1')).toBeInTheDocument()
460 // there should be no further effect calls because the returned object is structurally shared
461 expect(resultChanged).toBe(1)
462 })
463​
464 it('should not have infinite render loops with empty queries (#6645)', () => {
465 let renderCount = 0
466​
467 function Page() {
468 const result = useQueries({
469 queries: [],
470 })
471​
472 React.useEffect(() => {
473 renderCount++
474 })
475​
476 return <div>data: {JSON.stringify(result)}</div>
477 }
478​
479 renderWithClient(queryClient, <Page />)
480​
481 expect(renderCount).toBe(1)
482 })
483​
484 it('should only call combine with query results', async () => {
485 const key1 = createKey()
486 const key2 = createKey()
487​
488 function Page() {
489 const result = useQueries({
490 queries: [
491 {
492 queryKey: key1,
493 queryFn: () => sleep(5).then(() => Promise.resolve('query1')),
494 },
495 {
496 queryKey: key2,
497 queryFn: () => sleep(20).then(() => Promise.resolve('query2')),
498 },
499 ],
500 combine: ([query1, query2]) => {
501 return {
502 data: { query1: query1.data, query2: query2.data },
503 }
504 },
505 })
506​
507 return <div>data: {JSON.stringify(result)}</div>
508 }
509​
510 const rendered = renderWithClient(queryClient, <Page />)
511​
512 await vi.advanceTimersByTimeAsync(21)
513 expect(
514 rendered.getByText(
515 'data: {"data":{"query1":"query1","query2":"query2"}}',
516 ),
517 ).toBeInTheDocument()
518 })
519​
520 it('should track property access through combine function', async () => {
521 const key1 = createKey()
522 const key2 = createKey()
523 let count = 0
524 const results: Array<unknown> = []
525​
526 function Page() {
527 const queries = useQueries(
528 {
529 queries: [
530 {
531 queryKey: key1,
532 queryFn: () =>
533 sleep(5).then(() => Promise.resolve('first result ' + count)),
534 },
535 {
536 queryKey: key2,
537 queryFn: () =>
538 sleep(50).then(() => Promise.resolve('second result ' + count)),
539 },
540 ],
541 combine: (queryResults) => {
542 return {
543 combined: true,
544 refetch: () => queryResults.forEach((res) => res.refetch()),
545 res: queryResults
546 .flatMap((res) => (res.data ? [res.data] : []))
547 .join(','),
548 }
549 },
550 },
551 queryClient,
552 )
553​
554 results.push(queries)
555​
556 return (
557 <div>
558 <div>
559 data: {String(queries.combined)} {queries.res}
560 </div>
561 <button onClick={() => queries.refetch()}>refetch</button>
562 </div>
563 )
564 }
565​
566 const rendered = render(<Page />)
567​
568 await vi.advanceTimersByTimeAsync(51)
569 expect(
570 rendered.getByText('data: true first result 0,second result 0'),
571 ).toBeInTheDocument()
572​
573 expect(results).toHaveLength(3)
574​
575 expect(results[0]).toStrictEqual({
576 combined: true,
577 refetch: expect.any(Function),
578 res: '',
579 })
580​
581 expect(results[1]).toStrictEqual({
582 combined: true,
583 refetch: expect.any(Function),
584 res: 'first result 0',
585 })
586​
587 expect(results[2]).toStrictEqual({
588 combined: true,
589 refetch: expect.any(Function),
590 res: 'first result 0,second result 0',
591 })
592​
593 count++
594​
595 fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
596 await vi.advanceTimersByTimeAsync(51)
597 expect(
598 rendered.getByText('data: true first result 1,second result 1'),
599 ).toBeInTheDocument()
600​
601 const length = results.length
602​
603 expect([4, 5, 6]).toContain(results.length)
604​
605 expect(results[results.length - 1]).toStrictEqual({
606 combined: true,
607 refetch: expect.any(Function),
608 res: 'first result 1,second result 1',
609 })
610​
611 fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
612 await vi.advanceTimersByTimeAsync(100)
613 // no further re-render because data didn't change
614 expect(results).toHaveLength(length)
615 })
616​
617 it('should synchronously track properties of all observer even if a property (isLoading) is only accessed on one observer (#7000)', async () => {
618 const key = createKey()
619 const ids = [1, 2]
620​
621 function Page() {
622 const { isLoading } = useQueries({
623 queries: ids.map((id) => ({
624 queryKey: [key, id],
625 queryFn: () =>
626 sleep(10).then(() => {
627 if (id === 2) throw new Error('FAILURE')
628 return { id, title: `Post ${id}` }
629 }),
630 retry: false,
631 })),
632 combine: (results) => {
633 // this tracks data on all observers
634 void results.forEach((result) => result.data)
635 return {
636 // .some aborts early, so `isLoading` might not be accessed (and thus tracked) on all observers
637 // leading to missing re-renders
638 isLoading: results.some((result) => result.isLoading),
639 }
640 },
641 })
642​
643 return (
644 <div>
645 <p>Loading Status: {isLoading ? 'Loading...' : 'Loaded'}</p>
646 </div>
647 )
648 }
649​
650 const rendered = renderWithClient(queryClient, <Page />)
651​
652 expect(rendered.getByText('Loading Status: Loading...')).toBeInTheDocument()
653 await vi.advanceTimersByTimeAsync(11)
654 expect(rendered.getByText('Loading Status: Loaded')).toBeInTheDocument()
655 })
656​
657 it('should not have stale closures with combine (#6648)', async () => {
658 const key = createKey()
659​
660 function Page() {
661 const [count, setCount] = React.useState(0)
662 const queries = useQueries(
663 {
664 queries: [
665 {
666 queryKey: key,
667 queryFn: () => Promise.resolve('result'),
668 },
669 ],
670 combine: (results) => {
671 return {
672 count,
673 res: results.map((res) => res.data).join(','),
674 }
675 },
676 },
677 queryClient,
678 )
679​
680 return (
681 <div>
682 <div>
683 data: {String(queries.count)} {queries.res}
684 </div>
685 <button onClick={() => setCount((c) => c + 1)}>inc</button>
686 </div>
687 )
688 }
689​
690 const rendered = render(<Page />)
691​
692 await vi.advanceTimersByTimeAsync(0)
693 expect(rendered.getByText('data: 0 result')).toBeInTheDocument()
694​
695 fireEvent.click(rendered.getByRole('button', { name: /inc/i }))
696 await vi.advanceTimersByTimeAsync(0)
697 expect(rendered.getByText('data: 1 result')).toBeInTheDocument()
698 })
699​
700 it('should optimize combine if it is a stable reference', async () => {
701 const key1 = createKey()
702 const key2 = createKey()
703​
704 const client = new QueryClient()
705​
706 const spy = vi.fn<(result: { combined: boolean; res: string }) => void>()
707 let value = 0
708​
709 function Page() {
710 const [state, setState] = React.useState(0)
711 const queries = useQueries(
712 {
713 queries: [
714 {
715 queryKey: key1,
716 queryFn: () => sleep(10).then(() => 'first result:' + value),
717 },
718 {
719 queryKey: key2,
720 queryFn: () => sleep(20).then(() => 'second result:' + value),
721 },
722 ],
723 combine: React.useCallback((results: Array<QueryObserverResult>) => {
724 const result = {
725 combined: true,
726 res: results.map((res) => res.data).join(','),
727 }
728 spy(result)
729 return result
730 }, []),
731 },
732 client,
733 )
734​
735 return (
736 <div>
737 <div>
738 data: {String(queries.combined)} {queries.res}
739 </div>
740 <button onClick={() => setState(state + 1)}>rerender</button>
741 </div>
742 )
743 }
744​
745 const rendered = render(<Page />)
746​
747 await vi.advanceTimersByTimeAsync(21)
748 expect(
749 rendered.getByText('data: true first result:0,second result:0'),
750 ).toBeInTheDocument()
751​
752 // both pending, one pending, both resolved
753 expect(spy).toHaveBeenCalledTimes(3)
754​
755 client.refetchQueries()
756​
757 await vi.advanceTimersByTimeAsync(21)
758 // no increase because result hasn't changed
759 expect(spy).toHaveBeenCalledTimes(3)
760​
761 fireEvent.click(rendered.getByRole('button', { name: /rerender/i }))
762​
763 // one extra call due to recomputing the combined result on rerender
764 expect(spy).toHaveBeenCalledTimes(4)
765​
766 value = 1
767​
768 client.refetchQueries()
769​
770 await vi.advanceTimersByTimeAsync(21)
771 expect(
772 rendered.getByText('data: true first result:1,second result:1'),
773 ).toBeInTheDocument()
774​
775 // refetch with new values triggers: both pending -> one pending -> both resolved
776 expect(spy).toHaveBeenCalledTimes(7)
777 })
778​
779 it('should re-run combine if the functional reference changes', async () => {
780 const key1 = createKey()
781 const key2 = createKey()
782​
783 const client = new QueryClient()
784​
785 const spy =
786 vi.fn<
787 (result: { combined: boolean; state: number; res: string }) => void
788 >()
789​
790 function Page() {
791 const [state, setState] = React.useState(0)
792 const queries = useQueries(
793 {
794 queries: [
795 {
796 queryKey: [key1],
797 queryFn: () => sleep(10).then(() => 'first result'),
798 },
799 {
800 queryKey: [key2],
801 queryFn: () => sleep(20).then(() => 'second result'),
802 },
803 ],
804 combine: React.useCallback(
805 (results: Array<QueryObserverResult>) => {
806 const result = {
807 combined: true,
808 state,
809 res: results.map((res) => res.data).join(','),
810 }
811 spy(result)
812 return result
813 },
814 [state],
815 ),
816 },
817 client,
818 )
819​
820 return (
821 <div>
822 <div>
823 data: {String(queries.state)} {queries.res}
824 </div>
825 <button onClick={() => setState(state + 1)}>rerender</button>
826 </div>
827 )
828 }
829​
830 const rendered = render(<Page />)
831​
832 await vi.advanceTimersByTimeAsync(21)
833 expect(
834 rendered.getByText('data: 0 first result,second result'),
835 ).toBeInTheDocument()
836​
837 // both pending, one pending, both resolved
838 expect(spy).toHaveBeenCalledTimes(3)
839​
840 fireEvent.click(rendered.getByRole('button', { name: /rerender/i }))
841​
842 // state changed, re-run combine
843 expect(spy).toHaveBeenCalledTimes(4)
844 })
845​
846 it('should not re-render if combine returns a stable reference', async () => {
847 const key1 = createKey()
848 const key2 = createKey()
849​
850 const client = new QueryClient()
851​
852 const queryFns: Array<string> = []
853 let renders = 0
854​
855 function Page() {
856 const data = useQueries(
857 {
858 queries: [
859 {
860 queryKey: [key1],
861 queryFn: () =>
862 sleep(10).then(() => {
863 queryFns.push('first result')
864 return 'first result'
865 }),
866 },
867 {
868 queryKey: [key2],
869 queryFn: () =>
870 sleep(20).then(() => {
871 queryFns.push('second result')
872 return 'second result'
873 }),
874 },
875 ],
876 combine: () => 'foo',
877 },
878 client,
879 )
880​
881 renders++
882​
883 return (
884 <div>
885 <div>data: {data}</div>
886 </div>
887 )
888 }
889​
890 const rendered = render(<Page />)
891​
892 await vi.advanceTimersByTimeAsync(21)
893 expect(rendered.getByText('data: foo')).toBeInTheDocument()
894​
895 expect(queryFns).toStrictEqual(['first result', 'second result'])
896​
897 expect(renders).toBe(1)
898 })
899​
900 it('should re-render once combine returns a different reference', async () => {
901 const key1 = createKey()
902 const key2 = createKey()
903 const key3 = createKey()
904​
905 const client = new QueryClient()
906​
907 let renders = 0
908​
909 function Page() {
910 const data = useQueries(
911 {
912 queries: [
913 {
914 queryKey: [key1],
915 queryFn: () => sleep(10).then(() => 'first result'),
916 },
917 {
918 queryKey: [key2],
919 queryFn: () => sleep(15).then(() => 'second result'),
920 },
921 {
922 queryKey: [key3],
923 queryFn: () => sleep(20).then(() => 'third result'),
924 },
925 ],
926 combine: (results) => {
927 const isPending = results.some((res) => res.isPending)
928​
929 return isPending ? 'pending' : 'foo'
930 },
931 },
932 client,
933 )
934​
935 renders++
936​
937 return (
938 <div>
939 <div>data: {data}</div>
940 </div>
941 )
942 }
943​
944 const rendered = render(<Page />)
945​
946 await vi.advanceTimersByTimeAsync(0)
947 expect(rendered.getByText('data: pending')).toBeInTheDocument()
948 await vi.advanceTimersByTimeAsync(21)
949 expect(rendered.getByText('data: foo')).toBeInTheDocument()
950​
951 // one with pending, one with foo
952 expect(renders).toBe(2)
953 })
954​
955 it('should track properties correctly with combine', async () => {
956 const key1 = createKey()
957 const key2 = createKey()
958 const key3 = createKey()
959​
960 const client = new QueryClient()
961​
962 function Page() {
963 const data = useQueries(
964 {
965 queries: [
966 {
967 queryKey: [key1],
968 queryFn: () => sleep(10).then(() => 'first result'),
969 },
970 {
971 queryKey: [key2],
972 queryFn: () => sleep(15).then(() => 'second result'),
973 },
974 {
975 queryKey: [key3],
976 queryFn: () => sleep(20).then(() => 'third result'),
977 },
978 ],
979 combine: (results) => {
980 if (results.find((r) => r.isPending)) {
981 return 'pending'
982 }
983 return results.map((r) => r.data).join(', ')
984 },
985 },
986 client,
987 )
988​
989 return (
990 <div>
991 <div>data: {data}</div>
992 <button
993 onClick={() => {
994 client.setQueryData([key1], 'first result updated')
995 }}
996 >
997 update
998 </button>
999 </div>
1002​
1003 const rendered = render(<Page />)
1004​
1005 await vi.advanceTimersByTimeAsync(0)
1006 expect(rendered.getByText('data: pending')).toBeInTheDocument()
1007 await vi.advanceTimersByTimeAsync(21)
1008 expect(
1009 rendered.getByText('data: first result, second result, third result'),
1010 ).toBeInTheDocument()
1011​
1012 fireEvent.click(rendered.getByRole('button', { name: /update/i }))
1013 await vi.advanceTimersByTimeAsync(21)
1014 expect(
1015 rendered.getByText(
1016 'data: first result updated, second result, third result',
1017 ),
1018 ).toBeInTheDocument()
1019 })
1020​
1021 it('should not re-run stable combine on unrelated re-render', async () => {
1022 const key1 = createKey()
1023 const key2 = createKey()
1024​
1025 const client = new QueryClient()
1026​
1027 const spy = vi.fn<(result: { combined: boolean; res: string }) => void>()
1028​
1029 function Page() {
1030 const [unrelatedState, setUnrelatedState] = React.useState(0)
1031​
1032 const queries = useQueries(
1034 queries: [
1036 queryKey: key1,
1037 queryFn: () => sleep(10).then(() => 'first result'),
1038 },
1040 queryKey: key2,
1041 queryFn: () => sleep(20).then(() => 'second result'),
1042 },
1043 ],
1044 combine: React.useCallback((results: Array<QueryObserverResult>) => {
1045 const result = {
1046 combined: true,
1047 res: results.map((res) => res.data).join(','),
1049 spy(result)
1050 return result
1051 }, []),
1052 },
1053 client,
1055​
1056 return (
1057 <div>
1058 <div>
1059 data: {String(queries.combined)} {queries.res}
1060 </div>
1061 <div>unrelated: {unrelatedState}</div>
1062 <button onClick={() => setUnrelatedState((s) => s + 1)}>
1063 increment
1064 </button>
1065 </div>
1068​
1069 const rendered = render(<Page />)
1070​
1071 await vi.advanceTimersByTimeAsync(21)
1072 expect(
1073 rendered.getByText('data: true first result,second result'),
1074 ).toBeInTheDocument()
1075​
1076 // initial renders: both pending, one pending, both resolved
1077 expect(spy).toHaveBeenCalledTimes(3)
1078​
1079 fireEvent.click(rendered.getByRole('button', { name: /increment/i }))
1080 await vi.advanceTimersByTimeAsync(0)
1081 expect(rendered.getByText('unrelated: 1')).toBeInTheDocument()
1082​
1083 // combine should NOT re-run for unrelated re-render with stable reference
1084 expect(spy).toHaveBeenCalledTimes(3)
1085​
1086 fireEvent.click(rendered.getByRole('button', { name: /increment/i }))
1087 await vi.advanceTimersByTimeAsync(0)
1088 expect(rendered.getByText('unrelated: 2')).toBeInTheDocument()
1089​
1090 // still no extra calls to combine
1091 expect(spy).toHaveBeenCalledTimes(3)
1092 })
1093​
1094 it('should not cause infinite re-renders when removing last query', async () => {
1095 let renderCount = 0
1096 const key1 = createKey()
1097 const key2 = createKey()
1098​
1099 function Page() {
1100 const [queries, setQueries] = React.useState([
1102 queryKey: key1,
1103 queryFn: () => 'data1',
1104 },
1106 queryKey: key2,
1107 queryFn: () => 'data2',
1108 },
1109 ])
1110 renderCount++
1111​
1112 const result = useQueries({ queries })
1113​
1114 return (
1115 <div>
1116 <div data-testid="render-count">renders: {renderCount}</div>
1117 <div data-testid="query-count">queries: {result.length}</div>
1118 <button
1119 onClick={() => {
1120 setQueries([
1122 queryKey: key1,
1123 queryFn: () => 'data1',
1124 },
1125 ])
1126 }}
1128 remove last
1129 </button>
1130 <button
1131 onClick={() => {
1132 setQueries([
1134 queryKey: key2,
1135 queryFn: () => 'data2',
1136 },
1137 ])
1138 }}
1140 remove first
1141 </button>
1142 </div>
1145​
1146 const rendered = renderWithClient(queryClient, <Page />)
1147​
1148 await vi.advanceTimersByTimeAsync(0)
1149 renderCount = 0
1150​
1151 fireEvent.click(rendered.getByRole('button', { name: /remove last/i }))
1152 await vi.advanceTimersByTimeAsync(100)
1153 expect(renderCount).toBeLessThan(10)
1154 expect(rendered.getByTestId('query-count').textContent).toBe('queries: 1')
1155​
1156 renderCount = 0
1157​
1158 fireEvent.click(rendered.getByRole('button', { name: /remove first/i }))
1159 await vi.advanceTimersByTimeAsync(100)
1160 expect(renderCount).toBeLessThan(10)
1161 expect(rendered.getByTestId('query-count').textContent).toBe('queries: 1')
1162 })
1163​
1164 it('should return correct results when queries count changes with stable combine reference', async () => {
1165 const combine = (results: Array<QueryObserverResult>) => results
1166 const key = createKey()
1167​
1168 const results: Array<{ n: number; length: number }> = []
1169​
1170 function Page() {
1171 const [n, setN] = React.useState(0)
1172​
1173 const queries = useQueries(
1175 queries: [...Array(n).keys()].map((i) => ({
1176 queryKey: [...key, i],
1177 queryFn: () => i,
1178 })),
1179 combine,
1180 },
1181 queryClient,
1183​
1184 results.push({ n, length: queries.length })
1185​
1186 return (
1187 <div>
1188 <span data-testid="n">{n}</span>
1189 <span data-testid="length">{queries.length}</span>
1190 <button onClick={() => setN(n + 1)}>Increase</button>
1191 </div>
1194​
1195 const rendered = render(<Page />)
1196​
1197 expect(rendered.getByTestId('n').textContent).toBe('0')
1198 expect(rendered.getByTestId('length').textContent).toBe('0')
1199​
1200 fireEvent.click(rendered.getByRole('button', { name: /increase/i }))
1201 await vi.advanceTimersByTimeAsync(0)
1202 expect(rendered.getByTestId('n').textContent).toBe('1')
1203 expect(rendered.getByTestId('length').textContent).toBe('1')
1204​
1205 fireEvent.click(rendered.getByRole('button', { name: /increase/i }))
1206 await vi.advanceTimersByTimeAsync(0)
1207 expect(rendered.getByTestId('n').textContent).toBe('2')
1208 expect(rendered.getByTestId('length').textContent).toBe('2')
1209​
1210 results.forEach((result) => {
1211 expect(result).toHaveLength(result.n)
1212 })
1213 })
1214​
1215 it('should not fetch for the duration of the restoring period when isRestoring is true', async () => {
1216 const key1 = createKey()
1217 const key2 = createKey()
1218 const queryFn1 = vi.fn<() => Promise<string>>(() =>
1219 sleep(10).then(() => 'data1'),
1221 const queryFn2 = vi.fn<() => Promise<string>>(() =>
1222 sleep(10).then(() => 'data2'),
1224​
1225 function Page() {
1226 const results = useQueries({
1227 queries: [
1228 { queryKey: key1, queryFn: queryFn1 },
1229 { queryKey: key2, queryFn: queryFn2 },
1230 ],
1231 })
1232​
1233 return (
1234 <div>
1235 <div data-testid="status1">{results[0]?.status}</div>
1236 <div data-testid="status2">{results[1]?.status}</div>
1237 <div data-testid="fetchStatus1">{results[0]?.fetchStatus}</div>
1238 <div data-testid="fetchStatus2">{results[1]?.fetchStatus}</div>
1239 <div data-testid="data1">{results[0]?.data ?? 'undefined'}</div>
1240 <div data-testid="data2">{results[1]?.data ?? 'undefined'}</div>
1241 </div>
1244​
1245 const rendered = renderWithClient(
1246 queryClient,
1247 <IsRestoringProvider value={true}>
1248 <Page />
1249 </IsRestoringProvider>,
1251​
1252 await vi.advanceTimersByTimeAsync(0)
1253 expect(rendered.getByTestId('status1')).toHaveTextContent('pending')
1254 expect(rendered.getByTestId('status2')).toHaveTextContent('pending')
1255 expect(rendered.getByTestId('fetchStatus1')).toHaveTextContent('idle')
1256 expect(rendered.getByTestId('fetchStatus2')).toHaveTextContent('idle')
1257 expect(rendered.getByTestId('data1')).toHaveTextContent('undefined')
1258 expect(rendered.getByTestId('data2')).toHaveTextContent('undefined')
1259 expect(queryFn1).toHaveBeenCalledTimes(0)
1260 expect(queryFn2).toHaveBeenCalledTimes(0)
1261 await vi.advanceTimersByTimeAsync(11)
1262 expect(rendered.getByTestId('status1')).toHaveTextContent('pending')
1263 expect(rendered.getByTestId('status2')).toHaveTextContent('pending')
1264 expect(rendered.getByTestId('fetchStatus1')).toHaveTextContent('idle')
1265 expect(rendered.getByTestId('fetchStatus2')).toHaveTextContent('idle')
1266 expect(rendered.getByTestId('data1')).toHaveTextContent('undefined')
1267 expect(rendered.getByTestId('data2')).toHaveTextContent('undefined')
1268 expect(queryFn1).toHaveBeenCalledTimes(0)
1269 expect(queryFn2).toHaveBeenCalledTimes(0)
1270 })
1271​
1272 it('should not fetch queries with different durations for the duration of the restoring period when isRestoring is true', async () => {
1273 const key1 = createKey()
1274 const key2 = createKey()
1275 const queryFn1 = vi.fn<() => Promise<string>>(() =>
1276 sleep(10).then(() => 'data1'),
1278 const queryFn2 = vi.fn<() => Promise<string>>(() =>
1279 sleep(20).then(() => 'data2'),
1281​
1282 function Page() {
1283 const results = useQueries({
1284 queries: [
1285 { queryKey: key1, queryFn: queryFn1 },
1286 { queryKey: key2, queryFn: queryFn2 },
1287 ],
1288 })
1289​
1290 return (
1291 <div>
1292 <div data-testid="status1">{results[0]?.status}</div>
1293 <div data-testid="status2">{results[1]?.status}</div>
1294 <div data-testid="fetchStatus1">{results[0]?.fetchStatus}</div>
1295 <div data-testid="fetchStatus2">{results[1]?.fetchStatus}</div>
1296 <div data-testid="data1">{results[0]?.data ?? 'undefined'}</div>
1297 <div data-testid="data2">{results[1]?.data ?? 'undefined'}</div>
1298 </div>
1301​
1302 const rendered = renderWithClient(
1303 queryClient,
1304 <IsRestoringProvider value={true}>
1305 <Page />
1306 </IsRestoringProvider>,
1308​
1309 await vi.advanceTimersByTimeAsync(0)
1310 expect(rendered.getByTestId('status1')).toHaveTextContent('pending')
1311 expect(rendered.getByTestId('status2')).toHaveTextContent('pending')
1312 expect(rendered.getByTestId('fetchStatus1')).toHaveTextContent('idle')
1313 expect(rendered.getByTestId('fetchStatus2')).toHaveTextContent('idle')
1314 expect(rendered.getByTestId('data1')).toHaveTextContent('undefined')
1315 expect(rendered.getByTestId('data2')).toHaveTextContent('undefined')
1316 expect(queryFn1).toHaveBeenCalledTimes(0)
1317 expect(queryFn2).toHaveBeenCalledTimes(0)
1318 await vi.advanceTimersByTimeAsync(11)
1319 expect(rendered.getByTestId('status1')).toHaveTextContent('pending')
1320 expect(rendered.getByTestId('status2')).toHaveTextContent('pending')
1321 expect(rendered.getByTestId('fetchStatus1')).toHaveTextContent('idle')
1322 expect(rendered.getByTestId('fetchStatus2')).toHaveTextContent('idle')
1323 expect(rendered.getByTestId('data1')).toHaveTextContent('undefined')
1324 expect(rendered.getByTestId('data2')).toHaveTextContent('undefined')
1325 expect(queryFn1).toHaveBeenCalledTimes(0)
1326 expect(queryFn2).toHaveBeenCalledTimes(0)
1327 await vi.advanceTimersByTimeAsync(10)
1328 expect(rendered.getByTestId('status1')).toHaveTextContent('pending')
1329 expect(rendered.getByTestId('status2')).toHaveTextContent('pending')
1330 expect(rendered.getByTestId('fetchStatus1')).toHaveTextContent('idle')
1331 expect(rendered.getByTestId('fetchStatus2')).toHaveTextContent('idle')
1332 expect(rendered.getByTestId('data1')).toHaveTextContent('undefined')
1333 expect(rendered.getByTestId('data2')).toHaveTextContent('undefined')
1334 expect(queryFn1).toHaveBeenCalledTimes(0)
1335 expect(queryFn2).toHaveBeenCalledTimes(0)
1336 })
1337​
1338 it('should not fetch the previous keys when a hidden Activity with changed keys is revealed', async () => {
1339 const key = createKey()
1340 const queryFn = vi.fn<(filter: string) => Promise<string>>((filter) =>
1341 sleep(10).then(() => filter),
1343​
1344 function Page({ filter }: { filter: string }) {
1345 const results = useQueries({
1346 queries: [
1348 queryKey: [...key, filter],
1349 queryFn: () => queryFn(filter),
1350 },
1351 ],
1352 })
1353​
1354 return <div>data: {results[0].data}</div>
1356​
1357 const rendered = renderWithClient(
1358 queryClient,
1359 <React.Activity mode="visible">
1360 <Page filter="a" />
1361 </React.Activity>,
1363​
1364 await vi.advanceTimersByTimeAsync(11)
1365 expect(rendered.getByText('data: a')).toBeInTheDocument()
1366​
1367 rendered.rerender(
1368 <React.Activity mode="hidden">
1369 <Page filter="b" />
1370 </React.Activity>,
1372 await vi.advanceTimersByTimeAsync(11)
1373​
1374 rendered.rerender(
1375 <React.Activity mode="visible">
1376 <Page filter="b" />
1377 </React.Activity>,
1379 await vi.advanceTimersByTimeAsync(11)
1380 expect(rendered.getByText('data: b')).toBeInTheDocument()
1381​
1382 expect(queryFn.mock.calls).toStrictEqual([['a'], ['b']])
1383 })