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

useLiveInfiniteQuery.test.tsx

525 lines15.3 KB

1import { describe, expect, it, vi } from 'vitest'
2import { act, render, renderHook, waitFor } from '@testing-library/react'
3import { Suspense } from 'react'
4import {
5 createCollection,
6 createLiveQueryCollection,
7 eq,
8 gt,
9} from '@tanstack/db'
10import { useLiveInfiniteQuery } from '../src/useLiveInfiniteQuery'
11import { mockSyncCollectionOptions } from '../../db/tests/utils'
12import type { ReactNode } from 'react'
13​
14type Post = {
15 id: string
16 title: string
17 content: string
18 createdAt: number
19 category: string
21​
22function createMockPosts(count: number): Array<Post> {
23 const posts: Array<Post> = []
24 for (let i = 1; i <= count; i++) {
25 posts.push({
26 id: `${i}`,
27 title: `Post ${i}`,
28 content: `Content ${i}`,
29 createdAt: 1000000 - i * 1000, // Descending order
30 category: i % 2 === 0 ? `tech` : `life`,
31 })
32 }
33 return posts
35​
36describe(`useLiveInfiniteQuery`, () => {
37 it(`does not activate a query-function collection for an abandoned render`, async () => {
38 const source = createCollection(
39 mockSyncCollectionOptions<Post>({
40 id: `abandoned-infinite-query`,
41 getKey: (post) => post.id,
42 initialData: createMockPosts(10),
43 }),
44 )
45 const never = new Promise<void>(() => {})
46​
47 function AbandonedQuery(): ReactNode {
48 useLiveInfiniteQuery(
49 (q) =>
50 q
51 .from({ post: source })
52 .orderBy(({ post }) => post.createdAt, `desc`),
53 { pageSize: 3 },
54 )
55 throw never
56 }
57​
58 const rendered = render(
59 <Suspense fallback={null}>
60 <AbandonedQuery />
61 </Suspense>,
62 )
63 await new Promise((resolve) => setTimeout(resolve, 0))
64​
65 expect(source.subscriberCount).toBe(0)
66 rendered.unmount()
67 })
68​
69 it(`does not activate a supplied collection for an abandoned render`, async () => {
70 const source = createCollection(
71 mockSyncCollectionOptions<Post>({
72 id: `abandoned-supplied-infinite-query`,
73 getKey: (post) => post.id,
74 initialData: createMockPosts(10),
75 }),
76 )
77 const liveQuery = createLiveQueryCollection({
78 query: (q) =>
79 q.from({ post: source }).orderBy(({ post }) => post.createdAt, `desc`),
80 })
81 const never = new Promise<void>(() => {})
82​
83 function AbandonedQuery(): ReactNode {
84 useLiveInfiniteQuery(liveQuery, { pageSize: 3 })
85 throw never
86 }
87​
88 const rendered = render(
89 <Suspense fallback={null}>
90 <AbandonedQuery />
91 </Suspense>,
92 )
93 await new Promise((resolve) => setTimeout(resolve, 0))
94​
95 expect(source.subscriberCount).toBe(0)
96 rendered.unmount()
97 })
98​
99 it(`preserves committed pages across an abandoned dependency update`, async () => {
100 const source = createCollection(
101 mockSyncCollectionOptions<Post>({
102 autoIndex: `eager`,
103 id: `abandoned-infinite-query-update`,
104 getKey: (post) => post.id,
105 initialData: createMockPosts(20),
106 }),
107 )
108 const never = new Promise<void>(() => {})
109 let shouldSuspend = false
110 let current:
111 | {
112 isReady: boolean
113 pages: Array<Array<unknown>>
114 fetchNextPage: () => Promise<void>
115 }
116 | undefined
117​
118 function Query({ minimum }: { minimum: number }): ReactNode {
119 current = useLiveInfiniteQuery(
120 (q) =>
121 q
122 .from({ post: source })
123 .where(({ post }) => gt(post.createdAt, minimum))
124 .orderBy(({ post }) => post.createdAt, `desc`),
125 { pageSize: 3 },
126 [minimum],
127 )
128 if (shouldSuspend) throw never
129 return null
130 }
131​
132 function App({ minimum }: { minimum: number }): ReactNode {
133 return (
134 <Suspense fallback={null}>
135 <Query minimum={minimum} />
136 </Suspense>
137 )
138 }
139​
140 const rendered = render(<App minimum={0} />)
141 await waitFor(() => expect(current?.isReady).toBe(true))
142 await act(async () => {
143 await current!.fetchNextPage()
144 await current!.fetchNextPage()
145 })
146 expect(current?.pages.map((page) => page.length)).toEqual([3, 3, 3])
147​
148 shouldSuspend = true
149 rendered.rerender(<App minimum={5} />)
150 await Promise.resolve()
151​
152 shouldSuspend = false
153 rendered.rerender(<App minimum={0} />)
154 await waitFor(() => expect(current?.isReady).toBe(true))
155 expect(current?.pages.map((page) => page.length)).toEqual([3, 3, 3])
156 rendered.unmount()
157 })
158​
159 it(`recognizes a structurally valid collection from another realm`, () => {
160 const foreignCollection = {
161 id: `foreign-live-query`,
162 subscribeChanges: () => () => {},
163 startSyncImmediate: () => {},
164 utils: {
165 setWindow: () => true as const,
166 getWindow: () => undefined,
167 },
168 }
169​
170 expect(() =>
171 renderHook(() =>
172 useLiveInfiniteQuery(foreignCollection as any, { pageSize: 3 }),
173 ),
174 ).toThrow(/orderBy/)
175 })
176​
177 it(`resolves the fetch promise and exposes pagination failures in state`, async () => {
178 const source = createCollection(
179 mockSyncCollectionOptions<Post>({
180 id: `infinite-query-pagination-failure`,
181 getKey: (post) => post.id,
182 initialData: createMockPosts(10),
183 }),
184 )
185 const query = createLiveQueryCollection({
186 query: (q) =>
187 q.from({ post: source }).orderBy(({ post }) => post.createdAt, `desc`),
188 })
189 const { result } = renderHook(() =>
190 useLiveInfiniteQuery(query, { pageSize: 2 }),
191 )
192​
193 await waitFor(() => {
194 expect(result.current.isReady).toBe(true)
195 expect(result.current.hasNextPage).toBe(true)
196 })
197​
198 const failure = new Error(`window load failed`)
199 vi.spyOn(query.utils, `setWindow`).mockRejectedValueOnce(failure)
200​
201 let request!: Promise<void>
202 act(() => {
203 request = result.current.fetchNextPage()
204 })
205 await act(async () => {
206 await expect(request).resolves.toBeUndefined()
207 })
208​
209 await waitFor(() => {
210 expect(result.current.isError).toBe(true)
211 expect(result.current.error).toBe(failure)
212 expect(result.current.isFetchingNextPage).toBe(false)
213 })
214 expect(result.current.pages).toHaveLength(1)
215 expect(result.current.hasNextPage).toBe(true)
216 })
217​
218 it(`should derive query identity from structured captured values`, async () => {
219 const posts = createMockPosts(50)
220 const collection = createCollection(
221 mockSyncCollectionOptions<Post>({
222 autoIndex: `eager`,
223 id: `derived-identity-change-test`,
224 getKey: (post: Post) => post.id,
225 initialData: posts,
226 }),
227 )
228​
229 const { result, rerender } = renderHook(
230 ({ category }: { category: string }) => {
231 return useLiveInfiniteQuery(
232 (q) =>
233 q
234 .from({ posts: collection })
235 .where(({ posts: p }) => eq(p.category, category))
236 .orderBy(({ posts: p }) => p.createdAt, `desc`),
237 {
238 pageSize: 5,
239 getNextPageParam: (lastPage) =>
240 lastPage.length === 5 ? lastPage.length : undefined,
241 },
242 )
243 },
244 { initialProps: { category: `tech` } },
245 )
246​
247 await waitFor(() => {
248 expect(result.current.isReady).toBe(true)
249 })
250​
251 await act(async () => {
252 await result.current.fetchNextPage()
253 })
254​
255 await waitFor(() => {
256 expect(result.current.pages).toHaveLength(2)
257 })
258​
259 act(() => {
260 rerender({ category: `life` })
261 })
262​
263 await waitFor(() => {
264 expect(result.current.pages).toHaveLength(1)
265 })
266​
267 result.current.pages[0]!.forEach((post) => {
268 expect(post.category).toBe(`life`)
269 })
270 })
271​
272 it(`uses structural queryKey identity without rerunning a stable query`, async () => {
273 const source = createCollection(
274 mockSyncCollectionOptions<Post>({
275 autoIndex: `eager`,
276 id: `infinite-query-key-identity`,
277 getKey: (post) => post.id,
278 initialData: createMockPosts(20),
279 }),
280 )
281 let queryExecutions = 0
282​
283 const { result, rerender } = renderHook(
284 ({ filter }: { filter: { category: string } }) =>
285 useLiveInfiniteQuery(
286 (q) => {
287 queryExecutions += 1
288 return q
289 .from({ post: source })
290 .where(({ post }) => eq(post.category, filter.category))
291 .orderBy(({ post }) => post.createdAt, `desc`)
292 },
293 {
294 pageSize: 2,
295 queryKey: [source.id, `category`, filter],
296 },
297 ),
298 { initialProps: { filter: { category: `tech` } } },
299 )
300​
301 await waitFor(() => expect(result.current.isReady).toBe(true))
302 const firstCollection = result.current.collection
303 expect(queryExecutions).toBe(1)
304​
305 rerender({ filter: { category: `tech` } })
306​
307 expect(result.current.collection).toBe(firstCollection)
308 expect(queryExecutions).toBe(1)
309​
310 rerender({ filter: { category: `life` } })
311​
312 await waitFor(() => {
313 expect(result.current.collection).not.toBe(firstCollection)
314 expect(
315 result.current.data.every((post) => post.category === `life`),
316 ).toBe(true)
317 })
318 expect(queryExecutions).toBe(2)
319 })
320​
321 it(`uses queryKey to make captured values in opaque queries reactive`, async () => {
322 const source = createCollection(
323 mockSyncCollectionOptions<Post>({
324 id: `infinite-opaque-query-key`,
325 getKey: (post) => post.id,
326 initialData: createMockPosts(20),
327 }),
328 )
329 const { result, rerender } = renderHook(
330 ({ category }: { category: string }) =>
331 useLiveInfiniteQuery(
332 (q) =>
333 q
334 .from({ post: source })
335 .fn.where(({ post }) => post.category === category)
336 .orderBy(({ post }) => post.createdAt, `desc`),
337 {
338 pageSize: 2,
339 queryKey: [source.id, `category-fn`, category],
340 },
341 ),
342 { initialProps: { category: `tech` } },
343 )
344​
345 await waitFor(() => {
346 expect(result.current.data.length).toBeGreaterThan(0)
347 expect(
348 result.current.data.every((post) => post.category === `tech`),
349 ).toBe(true)
350 })
351 const firstCollection = result.current.collection
352​
353 rerender({ category: `life` })
354​
355 await waitFor(() => {
356 expect(result.current.collection).not.toBe(firstCollection)
357 expect(result.current.data.length).toBeGreaterThan(0)
358 expect(
359 result.current.data.every((post) => post.category === `life`),
360 ).toBe(true)
361 })
362 })
363​
364 it(`compares dependencies by identity instead of serialization`, async () => {
365 const source = createCollection(
366 mockSyncCollectionOptions<Post>({
367 id: `infinite-query-map-deps`,
368 getKey: (post) => post.id,
369 initialData: createMockPosts(10),
370 }),
371 )
372 const { result, rerender } = renderHook(
373 ({ filter }: { filter: Map<string, string> }) =>
374 useLiveInfiniteQuery(
375 (q) =>
376 q
377 .from({ post: source })
378 .where(({ post }) => eq(post.category, filter.get(`category`)))
379 .orderBy(({ post }) => post.createdAt, `desc`),
380 { pageSize: 3 },
381 [filter],
382 ),
383 {
384 initialProps: {
385 filter: new Map([[`category`, `tech`]]),
386 },
387 },
388 )
389​
390 await waitFor(() => {
391 expect(result.current.isReady).toBe(true)
392 expect(result.current.data.length).toBeGreaterThan(0)
393 expect(
394 result.current.data.every((post) => post.category === `tech`),
395 ).toBe(true)
396 })
397​
398 rerender({ filter: new Map([[`category`, `life`]]) })
399​
400 await waitFor(() => {
401 expect(result.current.data.length).toBeGreaterThan(0)
402 expect(
403 result.current.data.every((post) => post.category === `life`),
404 ).toBe(true)
405 })
406 })
407​
408 it(`preserves loaded pages when dependencies are structurally unchanged`, async () => {
409 const source = createCollection(
410 mockSyncCollectionOptions<Post>({
411 id: `infinite-query-structurally-equal-deps`,
412 getKey: (post) => post.id,
413 initialData: createMockPosts(20),
414 }),
415 )
416 const { result, rerender } = renderHook(
417 ({ filter }: { filter: { category: string } }) =>
418 useLiveInfiniteQuery(
419 (q) =>
420 q
421 .from({ post: source })
422 .where(({ post }) => eq(post.category, filter.category))
423 .orderBy(({ post }) => post.createdAt, `desc`),
424 { pageSize: 2 },
425 [filter],
426 ),
427 { initialProps: { filter: { category: `tech` } } },
428 )
429​
430 await waitFor(() => expect(result.current.isReady).toBe(true))
431 await act(async () => {
432 await result.current.fetchNextPage()
433 })
434 await waitFor(() => expect(result.current.pages).toHaveLength(2))
435 const firstCollection = result.current.collection
436​
437 rerender({ filter: { category: `tech` } })
438​
439 await waitFor(() => {
440 expect(result.current.collection).not.toBe(firstCollection)
441 expect(result.current.isReady).toBe(true)
442 })
443 expect(result.current.pages).toHaveLength(2)
444 })
445​
446 it(`releases a replaced controller through the external-store unsubscribe`, async () => {
447 const source = createCollection(
448 mockSyncCollectionOptions<Post>({
449 id: `infinite-query-controller-replacement`,
450 getKey: (post) => post.id,
451 initialData: createMockPosts(20),
452 }),
453 )
454 const query = createLiveQueryCollection({
455 query: (q) =>
456 q.from({ post: source }).orderBy(({ post }) => post.createdAt, `desc`),
457 })
458 const { result, rerender, unmount } = renderHook(
459 ({ pageSize }) => useLiveInfiniteQuery(query, { pageSize }),
460 { initialProps: { pageSize: 2 } },
461 )
462​
463 await waitFor(() => expect(result.current.isReady).toBe(true))
464 expect(query.subscriberCount).toBe(1)
465​
466 rerender({ pageSize: 3 })
467 await waitFor(() => expect(result.current.pages[0]).toHaveLength(3))
468 expect(query.subscriberCount).toBe(1)
469​
470 unmount()
471 expect(query.subscriberCount).toBe(0)
472 })
473​
474 it(`binds fetchNextPage to the controller that returned it`, async () => {
475 const sourceA = createCollection(
476 mockSyncCollectionOptions<Post>({
477 id: `infinite-query-generation-a`,
478 getKey: (post) => post.id,
479 initialData: createMockPosts(10),
480 }),
481 )
482 const sourceB = createCollection(
483 mockSyncCollectionOptions<Post>({
484 id: `infinite-query-generation-b`,
485 getKey: (post) => post.id,
486 initialData: createMockPosts(10),
487 }),
488 )
489 const queryA = createLiveQueryCollection({
490 query: (q) =>
491 q.from({ post: sourceA }).orderBy(({ post }) => post.createdAt, `desc`),
492 })
493 const queryB = createLiveQueryCollection({
494 query: (q) =>
495 q.from({ post: sourceB }).orderBy(({ post }) => post.createdAt, `desc`),
496 })
497 const { result, rerender } = renderHook(
498 ({ query }) => useLiveInfiniteQuery(query, { pageSize: 2 }),
499 { initialProps: { query: queryA } },
500 )
501​
502 await waitFor(() => expect(result.current.isReady).toBe(true))
503 const fetchFromA = result.current.fetchNextPage
504​
505 rerender({ query: queryB })
506 await waitFor(() => {
507 expect(result.current.collection).toBe(queryB)
508 expect(result.current.isReady).toBe(true)
509 expect(result.current.pages).toHaveLength(1)
510 })
511​
512 act(() => {
513 void fetchFromA()
514 })
515 await act(async () => {
516 await new Promise((resolve) => setTimeout(resolve, 0))
517 })
518 expect(result.current.pages).toHaveLength(1)
519​
520 act(() => {
521 void result.current.fetchNextPage()
522 })
523 await waitFor(() => expect(result.current.pages).toHaveLength(2))
524 })
525})