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

useLiveQueryEffect.test.tsx

209 lines5.1 KB

1import { describe, expect, it } from 'vitest'
2import { act, renderHook } from '@testing-library/react'
3import { createCollection, eq } from '@tanstack/db'
4import { useLiveQueryEffect } from '../src/useLiveQueryEffect'
5import { mockSyncCollectionOptions } from '../../db/tests/utils'
6import type { DeltaEvent } 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(`should create effect on mount and dispose on unmount`, async () => {
33 const users = createUsersCollection()
34 const events: Array<DeltaEvent<User, number>> = []
35​
36 const { unmount } = renderHook(() => {
37 useLiveQueryEffect<User, number>(
38 {
39 query: (q) => q.from({ user: users }),
40 onEnter: (event) => {
41 events.push(event)
42 },
43 },
44 [],
45 )
46 })
47​
48 await act(async () => {
49 await flushPromises()
50 })
51​
52 // Should have received enter events for initial data
53 expect(events.length).toBe(2)
54​
55 const countBefore = events.length
56​
57 // Unmount — should dispose the effect
58 unmount()
59​
60 // Insert after unmount
61 users.utils.begin()
62 users.utils.write({
63 type: `insert`,
64 value: { id: 3, name: `Charlie`, active: true },
65 })
66 users.utils.commit()
67​
68 await act(async () => {
69 await flushPromises()
70 })
71​
72 // Should not have received new events after unmount
73 expect(events.length).toBe(countBefore)
74 })
75​
76 it(`should recreate effect when deps change`, async () => {
77 const users = createUsersCollection()
78 const effectIds: Array<string> = []
79​
80 const { rerender } = renderHook(
81 ({ dep }: { dep: number }) => {
82 useLiveQueryEffect<User, number>(
83 {
84 query: (q) => q.from({ user: users }),
85 onEnter: (_event, ctx) => {
86 if (!effectIds.includes(ctx.effectId)) {
87 effectIds.push(ctx.effectId)
88 }
89 },
90 },
91 [dep],
92 )
93 },
94 { initialProps: { dep: 1 } },
95 )
96​
97 await act(async () => {
98 await flushPromises()
99 })
100​
101 expect(effectIds.length).toBe(1)
102 const firstId = effectIds[0]
103​
104 // Change deps — should dispose old effect and create new one
105 rerender({ dep: 2 })
106​
107 await act(async () => {
108 await flushPromises()
109 })
110​
111 expect(effectIds.length).toBe(2)
112 expect(effectIds[1]).not.toBe(firstId)
113 })
114​
115 it(`should receive events from source collection changes`, async () => {
116 const users = createUsersCollection()
117 const events: Array<DeltaEvent<User, number>> = []
118​
119 renderHook(() => {
120 useLiveQueryEffect<User, number>(
121 {
122 query: (q) =>
123 q.from({ user: users }).where(({ user }) => eq(user.active, true)),
124 onBatch: (batch) => {
125 events.push(...batch)
126 },
127 skipInitial: true,
128 },
129 [],
130 )
131 })
132​
133 await act(async () => {
134 await flushPromises()
135 })
136​
137 // skipInitial — no initial events
138 expect(events.length).toBe(0)
139​
140 // Insert a new active user
141 await act(async () => {
142 users.utils.begin()
143 users.utils.write({
144 type: `insert`,
145 value: { id: 3, name: `Charlie`, active: true },
146 })
147 users.utils.commit()
148 await flushPromises()
149 })
150​
151 expect(events.length).toBe(1)
152 expect(events[0]!.type).toBe(`enter`)
153 expect(events[0]!.value.name).toBe(`Charlie`)
154​
155 // Delete a user
156 await act(async () => {
157 users.utils.begin()
158 users.utils.write({
159 type: `delete`,
160 value: { id: 1, name: `Alice`, active: true },
161 })
162 users.utils.commit()
163 await flushPromises()
164 })
165​
166 expect(events.length).toBe(2)
167 expect(events[1]!.type).toBe(`exit`)
168 expect(events[1]!.value.name).toBe(`Alice`)
169 })
170​
171 it(`should use the latest callback without recreating the effect`, async () => {
172 const users = createUsersCollection()
173 const labels: Array<string> = []
174​
175 const { rerender } = renderHook(
176 ({ label }: { label: string }) => {
177 useLiveQueryEffect<User, number>(
178 {
179 query: (q) => q.from({ user: users }),
180 skipInitial: true,
181 onEnter: (event) => {
182 labels.push(`${label}:${event.value.name}`)
183 },
184 },
185 [],
186 )
187 },
188 { initialProps: { label: `first` } },
189 )
190​
191 await act(async () => {
192 await flushPromises()
193 })
194​
195 rerender({ label: `second` })
196​
197 await act(async () => {
198 users.utils.begin()
199 users.utils.write({
200 type: `insert`,
201 value: { id: 3, name: `Charlie`, active: true },
202 })
203 users.utils.commit()
204 await flushPromises()
205 })
206​
207 expect(labels).toEqual([`second:Charlie`])
208 })
209})