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

infiniteQueryObserver.test.tsx

206 lines6.3 KB

1import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
2import { InfiniteQueryObserver } from '..'
3import { createQueryClient, queryKey, sleep } from './utils'
4import type { QueryClient } from '..'
5​
6describe('InfiniteQueryObserver', () => {
7 let queryClient: QueryClient
8​
9 beforeEach(() => {
10 vi.useFakeTimers()
11 queryClient = createQueryClient()
12 queryClient.mount()
13 })
14​
15 afterEach(() => {
16 queryClient.clear()
17 vi.useRealTimers()
18 })
19​
20 test('InfiniteQueryObserver should be able to fetch an infinite query with selector', async () => {
21 const key = queryKey()
22 const observer = new InfiniteQueryObserver(queryClient, {
23 queryKey: key,
24 queryFn: () => sleep(10).then(() => 1),
25 select: (data) => ({
26 pages: data.pages.map((x) => `${x}`),
27 pageParams: data.pageParams,
28 }),
29 initialPageParam: 1,
30 getNextPageParam: () => 2,
31 })
32 let observerResult
33 const unsubscribe = observer.subscribe((result) => {
34 observerResult = result
35 })
36 await vi.advanceTimersByTimeAsync(10)
37 unsubscribe()
38 expect(observerResult).toMatchObject({
39 data: { pages: ['1'], pageParams: [1] },
40 })
41 })
42​
43 test('InfiniteQueryObserver should pass the meta option to the queryFn', async () => {
44 const meta = {
45 it: 'works',
46 }
47​
48 const key = queryKey()
49 const queryFn = vi.fn(() => sleep(10).then(() => 1))
50 const observer = new InfiniteQueryObserver(queryClient, {
51 meta,
52 queryKey: key,
53 queryFn,
54 select: (data) => ({
55 pages: data.pages.map((x) => `${x}`),
56 pageParams: data.pageParams,
57 }),
58 initialPageParam: 1,
59 getNextPageParam: () => 2,
60 })
61 let observerResult
62 const unsubscribe = observer.subscribe((result) => {
63 observerResult = result
64 })
65 await vi.advanceTimersByTimeAsync(10)
66 unsubscribe()
67 expect(observerResult).toMatchObject({
68 data: { pages: ['1'], pageParams: [1] },
69 })
70 expect(queryFn).toBeCalledWith(expect.objectContaining({ meta }))
71 })
72​
73 test('getNextPagParam and getPreviousPageParam should receive current pageParams', async () => {
74 const key = queryKey()
75 let single: Array<string> = []
76 let all: Array<string> = []
77 const observer = new InfiniteQueryObserver(queryClient, {
78 queryKey: key,
79 queryFn: ({ pageParam }) => sleep(10).then(() => String(pageParam)),
80 initialPageParam: 1,
81 getNextPageParam: (_, __, lastPageParam, allPageParams) => {
82 single.push('next' + lastPageParam)
83 all.push('next' + allPageParams.join(','))
84 return lastPageParam + 1
85 },
86 getPreviousPageParam: (_, __, firstPageParam, allPageParams) => {
87 single.push('prev' + firstPageParam)
88 all.push('prev' + allPageParams.join(','))
89 return firstPageParam - 1
90 },
91 })
92 await vi.advanceTimersByTimeAsync(10)
93​
94 observer.fetchNextPage()
95 await vi.advanceTimersByTimeAsync(10)
96 observer.fetchPreviousPage()
97 await vi.advanceTimersByTimeAsync(10)
98​
99 expect(single).toEqual(['next1', 'prev1', 'prev1', 'next1', 'prev0'])
100 expect(all).toEqual(['next1', 'prev1', 'prev1', 'next0,1', 'prev0,1'])
101​
102 single = []
103 all = []
104​
105 observer.refetch()
106 await vi.advanceTimersByTimeAsync(20)
107​
108 expect(single).toEqual(['next0', 'next1', 'prev0'])
109 expect(all).toEqual(['next0', 'next0,1', 'prev0,1'])
110 })
111​
112 test('should not invoke getNextPageParam and getPreviousPageParam on empty pages', () => {
113 const key = queryKey()
114​
115 const getNextPageParam = vi.fn()
116 const getPreviousPageParam = vi.fn()
117​
118 const observer = new InfiniteQueryObserver(queryClient, {
119 queryKey: key,
120 queryFn: ({ pageParam }) => sleep(10).then(() => String(pageParam)),
121 initialPageParam: 1,
122 getNextPageParam: getNextPageParam.mockImplementation(
123 (_, __, lastPageParam) => lastPageParam + 1,
124 ),
125 getPreviousPageParam: getPreviousPageParam.mockImplementation(
126 (_, __, firstPageParam) => firstPageParam - 1,
127 ),
128 })
129​
130 const unsubscribe = observer.subscribe(() => {})
131​
132 getNextPageParam.mockClear()
133 getPreviousPageParam.mockClear()
134​
135 queryClient.setQueryData(key, { pages: [], pageParams: [] })
136​
137 expect(getNextPageParam).toHaveBeenCalledTimes(0)
138 expect(getPreviousPageParam).toHaveBeenCalledTimes(0)
139​
140 unsubscribe()
141 })
142​
143 test('should stop refetching if undefined is returned from getNextPageParam', async () => {
144 const key = queryKey()
145 let next: number | undefined = 2
146 const queryFn = vi.fn<(...args: Array<any>) => any>(({ pageParam }) =>
147 sleep(10).then(() => String(pageParam)),
148 )
149 const observer = new InfiniteQueryObserver(queryClient, {
150 queryKey: key,
151 queryFn,
152 initialPageParam: 1,
153 getNextPageParam: () => next,
154 })
155​
156 observer.fetchNextPage()
157 await vi.advanceTimersByTimeAsync(10)
158 observer.fetchNextPage()
159 await vi.advanceTimersByTimeAsync(10)
160​
161 expect(observer.getCurrentResult().data?.pages).toEqual(['1', '2'])
162 expect(queryFn).toBeCalledTimes(2)
163 expect(observer.getCurrentResult().hasNextPage).toBe(true)
164​
165 next = undefined
166​
167 observer.refetch()
168 await vi.advanceTimersByTimeAsync(10)
169​
170 expect(observer.getCurrentResult().data?.pages).toEqual(['1'])
171 expect(queryFn).toBeCalledTimes(3)
172 expect(observer.getCurrentResult().hasNextPage).toBe(false)
173 })
174​
175 test('should stop refetching if null is returned from getNextPageParam', async () => {
176 const key = queryKey()
177 let next: number | null = 2
178 const queryFn = vi.fn<(...args: Array<any>) => any>(({ pageParam }) =>
179 sleep(10).then(() => String(pageParam)),
180 )
181 const observer = new InfiniteQueryObserver(queryClient, {
182 queryKey: key,
183 queryFn,
184 initialPageParam: 1,
185 getNextPageParam: () => next,
186 })
187​
188 observer.fetchNextPage()
189 await vi.advanceTimersByTimeAsync(10)
190 observer.fetchNextPage()
191 await vi.advanceTimersByTimeAsync(10)
192​
193 expect(observer.getCurrentResult().data?.pages).toEqual(['1', '2'])
194 expect(queryFn).toBeCalledTimes(2)
195 expect(observer.getCurrentResult().hasNextPage).toBe(true)
196​
197 next = null
198​
199 observer.refetch()
200 await vi.advanceTimersByTimeAsync(10)
201​
202 expect(observer.getCurrentResult().data?.pages).toEqual(['1'])
203 expect(queryFn).toBeCalledTimes(3)
204 expect(observer.getCurrentResult().hasNextPage).toBe(false)
205 })
206})