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

useLiveQueryEffect.test.tsx

280 lines7.2 KB

1import { describe, expect, it, vi } from 'vitest'
2import { act, renderHook } from '@testing-library/react'
3import { Query, collectionOptions, createCollection, eq } from '@tanstack/db'
4import { useLiveQueryEffect } from '../src/useLiveQueryEffect'
5import { mockSyncCollectionOptions } from '../../db/tests/utils'
6import type { DeltaEvent, EffectConfig } from '@tanstack/db'
7​
8type User = {
9 id: number
10 name: string
11 active: boolean
13​
14const initialUsers: Array<User> = [
15 { id: 1, name: `Alice`, active: true },
16 { id: 2, name: `Bob`, active: true },
18​
19const flushPromises = () => new Promise((resolve) => setTimeout(resolve, 0))
20​
21function createUsersCollection(initialData = initialUsers) {
22 return createCollection(
23 mockSyncCollectionOptions<User>({
24 id: `test-users-hook`,
25 getKey: (user) => user.id,
26 initialData,
27 }),
28 )
30​
31describe(`useLiveQueryEffect`, () => {
32 it(`explains the provider needed by an unbound descriptor query`, () => {
33 const descriptor = collectionOptions(`effect-provider-hint`, () => ({
34 id: `effect-provider-hint`,
35 getKey: (row: { id: number }) => row.id,
36 sync: { sync: ({ markReady }) => markReady() },
37 }))
38 const query = new Query().from({ item: descriptor })
39​
40 expect(() =>
41 renderHook(() => useLiveQueryEffect({ query, onBatch: () => {} })),
42 ).toThrow(/requires a DbClient.*DbProvider/)
43 })
44​
45 it(`reports a source release failure when unmount disposes the Effect`, async () => {
46 const failure = new Error(`source release failed`)
47 let unloadCalls = 0
48 const source = createCollection<{ id: number }>({
49 id: `effect-unmount-release-failure`,
50 getKey: (row) => row.id,
51 syncMode: `on-demand`,
52 sync: {
53 sync: ({ markReady }) => {
54 markReady()
55 return {
56 loadSubset: () => true,
57 unloadSubset: () => {
58 unloadCalls++
59 throw failure
60 },
61 }
62 },
63 },
64 })
65 const reported = vi.spyOn(console, `error`).mockImplementation(() => {})
66 try {
67 const mounted = renderHook(() =>
68 useLiveQueryEffect({
69 query: (q) => q.from({ source }),
70 onBatch: () => {},
71 }),
72 )
73 expect(source.subscriberCount).toBe(1)
74​
75 mounted.unmount()
76 await act(async () => {
77 await flushPromises()
78 })
79​
80 expect(unloadCalls).toBe(1)
81 expect(source.subscriberCount).toBe(0)
82 expect(reported).toHaveBeenCalledWith(
83 expect.stringContaining(`failed to dispose`),
84 failure,
85 )
86 } finally {
87 reported.mockRestore()
88 await source.cleanup()
89 }
90 })
91​
92 it(`reports an invalid query function result`, () => {
93 const query = (() => undefined) as unknown as EffectConfig<
94 User,
95 number
96 >[`query`]
97​
98 expect(() => renderHook(() => useLiveQueryEffect({ query }))).toThrow(
99 /query must resolve to a QueryBuilder/i,
100 )
101 })
102​
103 it(`should create effect on mount and dispose on unmount`, async () => {
104 const users = createUsersCollection()
105 const events: Array<DeltaEvent<User, number>> = []
106​
107 const { unmount } = renderHook(() => {
108 useLiveQueryEffect<User, number>(
109 {
110 query: (q) => q.from({ user: users }),
111 onEnter: (event) => {
112 events.push(event)
113 },
114 },
115 [],
116 )
117 })
118​
119 await act(async () => {
120 await flushPromises()
121 })
122​
123 // Should have received enter events for initial data
124 expect(events.length).toBe(2)
125​
126 const countBefore = events.length
127​
128 // Unmount — should dispose the effect
129 unmount()
130​
131 // Insert after unmount
132 users.utils.begin()
133 users.utils.write({
134 type: `insert`,
135 value: { id: 3, name: `Charlie`, active: true },
136 })
137 users.utils.commit()
138​
139 await act(async () => {
140 await flushPromises()
141 })
142​
143 // Should not have received new events after unmount
144 expect(events.length).toBe(countBefore)
145 })
146​
147 it(`should recreate effect when deps change`, async () => {
148 const users = createUsersCollection()
149 const effectIds: Array<string> = []
150​
151 const { rerender } = renderHook(
152 ({ dep }: { dep: number }) => {
153 useLiveQueryEffect<User, number>(
154 {
155 query: (q) => q.from({ user: users }),
156 onEnter: (_event, ctx) => {
157 if (!effectIds.includes(ctx.effectId)) {
158 effectIds.push(ctx.effectId)
159 }
160 },
161 },
162 [dep],
163 )
164 },
165 { initialProps: { dep: 1 } },
166 )
167​
168 await act(async () => {
169 await flushPromises()
170 })
171​
172 expect(effectIds.length).toBe(1)
173 const firstId = effectIds[0]
174​
175 // Change deps — should dispose old effect and create new one
176 rerender({ dep: 2 })
177​
178 await act(async () => {
179 await flushPromises()
180 })
181​
182 expect(effectIds.length).toBe(2)
183 expect(effectIds[1]).not.toBe(firstId)
184 })
185​
186 it(`should receive events from source collection changes`, async () => {
187 const users = createUsersCollection()
188 const events: Array<DeltaEvent<User, number>> = []
189​
190 renderHook(() => {
191 useLiveQueryEffect<User, number>(
192 {
193 query: (q) =>
194 q.from({ user: users }).where(({ user }) => eq(user.active, true)),
195 onBatch: (batch) => {
196 events.push(...batch)
197 },
198 skipInitial: true,
199 },
200 [],
201 )
202 })
203​
204 await act(async () => {
205 await flushPromises()
206 })
207​
208 // skipInitial — no initial events
209 expect(events.length).toBe(0)
210​
211 // Insert a new active user
212 await act(async () => {
213 users.utils.begin()
214 users.utils.write({
215 type: `insert`,
216 value: { id: 3, name: `Charlie`, active: true },
217 })
218 users.utils.commit()
219 await flushPromises()
220 })
221​
222 expect(events.length).toBe(1)
223 expect(events[0]!.type).toBe(`enter`)
224 expect(events[0]!.value.name).toBe(`Charlie`)
225​
226 // Delete a user
227 await act(async () => {
228 users.utils.begin()
229 users.utils.write({
230 type: `delete`,
231 value: { id: 1, name: `Alice`, active: true },
232 })
233 users.utils.commit()
234 await flushPromises()
235 })
236​
237 expect(events.length).toBe(2)
238 expect(events[1]!.type).toBe(`exit`)
239 expect(events[1]!.value.name).toBe(`Alice`)
240 })
241​
242 it(`should use the latest callback without recreating the effect`, async () => {
243 const users = createUsersCollection()
244 const labels: Array<string> = []
245​
246 const { rerender } = renderHook(
247 ({ label }: { label: string }) => {
248 useLiveQueryEffect<User, number>(
249 {
250 query: (q) => q.from({ user: users }),
251 skipInitial: true,
252 onEnter: (event) => {
253 labels.push(`${label}:${event.value.name}`)
254 },
255 },
256 [],
257 )
258 },
259 { initialProps: { label: `first` } },
260 )
261​
262 await act(async () => {
263 await flushPromises()
264 })
265​
266 rerender({ label: `second` })
267​
268 await act(async () => {
269 users.utils.begin()
270 users.utils.write({
271 type: `insert`,
272 value: { id: 3, name: `Charlie`, active: true },
273 })
274 users.utils.commit()
275 await flushPromises()
276 })
277​
278 expect(labels).toEqual([`second:Charlie`])
279 })
280})