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

useLiveInfiniteQuery.test.tsx

523 lines15.2 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 },
240 )
241 },
242 { initialProps: { category: `tech` } },
243 )
244​
245 await waitFor(() => {
246 expect(result.current.isReady).toBe(true)
247 })
248​
249 await act(async () => {
250 await result.current.fetchNextPage()
251 })
252​
253 await waitFor(() => {
254 expect(result.current.pages).toHaveLength(2)
255 })
256​
257 act(() => {
258 rerender({ category: `life` })
259 })
260​
261 await waitFor(() => {
262 expect(result.current.pages).toHaveLength(1)
263 })
264​
265 result.current.pages[0]!.forEach((post) => {
266 expect(post.category).toBe(`life`)
267 })
268 })
269​
270 it(`uses structural queryKey identity without rerunning a stable query`, async () => {
271 const source = createCollection(
272 mockSyncCollectionOptions<Post>({
273 autoIndex: `eager`,
274 id: `infinite-query-key-identity`,
275 getKey: (post) => post.id,
276 initialData: createMockPosts(20),
277 }),
278 )
279 let queryExecutions = 0
280​
281 const { result, rerender } = renderHook(
282 ({ filter }: { filter: { category: string } }) =>
283 useLiveInfiniteQuery(
284 (q) => {
285 queryExecutions += 1
286 return q
287 .from({ post: source })
288 .where(({ post }) => eq(post.category, filter.category))
289 .orderBy(({ post }) => post.createdAt, `desc`)
290 },
291 {
292 pageSize: 2,
293 queryKey: [source.id, `category`, filter],
294 },
295 ),
296 { initialProps: { filter: { category: `tech` } } },
297 )
298​
299 await waitFor(() => expect(result.current.isReady).toBe(true))
300 const firstCollection = result.current.collection
301 expect(queryExecutions).toBe(1)
302​
303 rerender({ filter: { category: `tech` } })
304​
305 expect(result.current.collection).toBe(firstCollection)
306 expect(queryExecutions).toBe(1)
307​
308 rerender({ filter: { category: `life` } })
309​
310 await waitFor(() => {
311 expect(result.current.collection).not.toBe(firstCollection)
312 expect(
313 result.current.data.every((post) => post.category === `life`),
314 ).toBe(true)
315 })
316 expect(queryExecutions).toBe(2)
317 })
318​
319 it(`uses queryKey to make captured values in opaque queries reactive`, async () => {
320 const source = createCollection(
321 mockSyncCollectionOptions<Post>({
322 id: `infinite-opaque-query-key`,
323 getKey: (post) => post.id,
324 initialData: createMockPosts(20),
325 }),
326 )
327 const { result, rerender } = renderHook(
328 ({ category }: { category: string }) =>
329 useLiveInfiniteQuery(
330 (q) =>
331 q
332 .from({ post: source })
333 .fn.where(({ post }) => post.category === category)
334 .orderBy(({ post }) => post.createdAt, `desc`),
335 {
336 pageSize: 2,
337 queryKey: [source.id, `category-fn`, category],
338 },
339 ),
340 { initialProps: { category: `tech` } },
341 )
342​
343 await waitFor(() => {
344 expect(result.current.data.length).toBeGreaterThan(0)
345 expect(
346 result.current.data.every((post) => post.category === `tech`),
347 ).toBe(true)
348 })
349 const firstCollection = result.current.collection
350​
351 rerender({ category: `life` })
352​
353 await waitFor(() => {
354 expect(result.current.collection).not.toBe(firstCollection)
355 expect(result.current.data.length).toBeGreaterThan(0)
356 expect(
357 result.current.data.every((post) => post.category === `life`),
358 ).toBe(true)
359 })
360 })
361​
362 it(`compares dependencies by identity instead of serialization`, async () => {
363 const source = createCollection(
364 mockSyncCollectionOptions<Post>({
365 id: `infinite-query-map-deps`,
366 getKey: (post) => post.id,
367 initialData: createMockPosts(10),
368 }),
369 )
370 const { result, rerender } = renderHook(
371 ({ filter }: { filter: Map<string, string> }) =>
372 useLiveInfiniteQuery(
373 (q) =>
374 q
375 .from({ post: source })
376 .where(({ post }) => eq(post.category, filter.get(`category`)))
377 .orderBy(({ post }) => post.createdAt, `desc`),
378 { pageSize: 3 },
379 [filter],
380 ),
381 {
382 initialProps: {
383 filter: new Map([[`category`, `tech`]]),
384 },
385 },
386 )
387​
388 await waitFor(() => {
389 expect(result.current.isReady).toBe(true)
390 expect(result.current.data.length).toBeGreaterThan(0)
391 expect(
392 result.current.data.every((post) => post.category === `tech`),
393 ).toBe(true)
394 })
395​
396 rerender({ filter: new Map([[`category`, `life`]]) })
397​
398 await waitFor(() => {
399 expect(result.current.data.length).toBeGreaterThan(0)
400 expect(
401 result.current.data.every((post) => post.category === `life`),
402 ).toBe(true)
403 })
404 })
405​
406 it(`preserves loaded pages when dependencies are structurally unchanged`, async () => {
407 const source = createCollection(
408 mockSyncCollectionOptions<Post>({
409 id: `infinite-query-structurally-equal-deps`,
410 getKey: (post) => post.id,
411 initialData: createMockPosts(20),
412 }),
413 )
414 const { result, rerender } = renderHook(
415 ({ filter }: { filter: { category: string } }) =>
416 useLiveInfiniteQuery(
417 (q) =>
418 q
419 .from({ post: source })
420 .where(({ post }) => eq(post.category, filter.category))
421 .orderBy(({ post }) => post.createdAt, `desc`),
422 { pageSize: 2 },
423 [filter],
424 ),
425 { initialProps: { filter: { category: `tech` } } },
426 )
427​
428 await waitFor(() => expect(result.current.isReady).toBe(true))
429 await act(async () => {
430 await result.current.fetchNextPage()
431 })
432 await waitFor(() => expect(result.current.pages).toHaveLength(2))
433 const firstCollection = result.current.collection
434​
435 rerender({ filter: { category: `tech` } })
436​
437 await waitFor(() => {
438 expect(result.current.collection).not.toBe(firstCollection)
439 expect(result.current.isReady).toBe(true)
440 })
441 expect(result.current.pages).toHaveLength(2)
442 })
443​
444 it(`releases a replaced controller through the external-store unsubscribe`, async () => {
445 const source = createCollection(
446 mockSyncCollectionOptions<Post>({
447 id: `infinite-query-controller-replacement`,
448 getKey: (post) => post.id,
449 initialData: createMockPosts(20),
450 }),
451 )
452 const query = createLiveQueryCollection({
453 query: (q) =>
454 q.from({ post: source }).orderBy(({ post }) => post.createdAt, `desc`),
455 })
456 const { result, rerender, unmount } = renderHook(
457 ({ pageSize }) => useLiveInfiniteQuery(query, { pageSize }),
458 { initialProps: { pageSize: 2 } },
459 )
460​
461 await waitFor(() => expect(result.current.isReady).toBe(true))
462 expect(query.subscriberCount).toBe(1)
463​
464 rerender({ pageSize: 3 })
465 await waitFor(() => expect(result.current.pages[0]).toHaveLength(3))
466 expect(query.subscriberCount).toBe(1)
467​
468 unmount()
469 expect(query.subscriberCount).toBe(0)
470 })
471​
472 it(`binds fetchNextPage to the controller that returned it`, async () => {
473 const sourceA = createCollection(
474 mockSyncCollectionOptions<Post>({
475 id: `infinite-query-generation-a`,
476 getKey: (post) => post.id,
477 initialData: createMockPosts(10),
478 }),
479 )
480 const sourceB = createCollection(
481 mockSyncCollectionOptions<Post>({
482 id: `infinite-query-generation-b`,
483 getKey: (post) => post.id,
484 initialData: createMockPosts(10),
485 }),
486 )
487 const queryA = createLiveQueryCollection({
488 query: (q) =>
489 q.from({ post: sourceA }).orderBy(({ post }) => post.createdAt, `desc`),
490 })
491 const queryB = createLiveQueryCollection({
492 query: (q) =>
493 q.from({ post: sourceB }).orderBy(({ post }) => post.createdAt, `desc`),
494 })
495 const { result, rerender } = renderHook(
496 ({ query }) => useLiveInfiniteQuery(query, { pageSize: 2 }),
497 { initialProps: { query: queryA } },
498 )
499​
500 await waitFor(() => expect(result.current.isReady).toBe(true))
501 const fetchFromA = result.current.fetchNextPage
502​
503 rerender({ query: queryB })
504 await waitFor(() => {
505 expect(result.current.collection).toBe(queryB)
506 expect(result.current.isReady).toBe(true)
507 expect(result.current.pages).toHaveLength(1)
508 })
509​
510 act(() => {
511 void fetchFromA()
512 })
513 await act(async () => {
514 await new Promise((resolve) => setTimeout(resolve, 0))
515 })
516 expect(result.current.pages).toHaveLength(1)
517​
518 act(() => {
519 void result.current.fetchNextPage()
520 })
521 await waitFor(() => expect(result.current.pages).toHaveLength(2))
522 })
523})