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

with-hydration.test.ts

331 lines9.1 KB

1import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
2import {
3 Component,
4 EnvironmentInjector,
5 PLATFORM_ID,
6 TransferState,
7 createEnvironmentInjector,
8 effect,
9 inject,
10 makeStateKey,
11 provideEnvironmentInitializer,
12} from '@angular/core'
13import { TestBed } from '@angular/core/testing'
14import { render } from '@testing-library/angular'
15import { queryKey, sleep } from '@tanstack/query-test-utils'
16import {
17 QueryClient,
18 dehydrate,
19 injectQuery,
20 noop,
21 provideTanStackQuery,
22 withHydrationKey,
23 withNoQueryHydration,
24} from '..'
25import { INTERNAL_TANSTACK_QUERY_HYDRATION_STATE_KEY } from '../hydration-state-key'
26import { provideAngularQueryChangeDetection } from './test-utils'
27import type { DehydratedState } from '@tanstack/query-core'
28​
29beforeEach(() => {
30 vi.useFakeTimers()
31})
32​
33afterEach(() => {
34 vi.restoreAllMocks()
35 vi.useRealTimers()
36})
37​
38describe('TransferState hydration (client)', () => {
39 it('browser hydrates from default key', async () => {
40 const key = queryKey()
41 const sourceClient = new QueryClient()
42 sourceClient.setQueryData(key, 'from-server')
43 const dehydrated = dehydrate(sourceClient)
44 const appClient = new QueryClient()
45​
46 @Component({
47 template: `<div>{{ state.data() ?? '' }}</div>`,
48 })
49 class Page {
50 state = injectQuery(() => ({
51 queryKey: key,
52 queryFn: () => sleep(10).then(() => 'from-client'),
53 }))
54 }
55​
56 const rendered = await render(Page, {
57 providers: [
58 provideAngularQueryChangeDetection(),
59 provideEnvironmentInitializer(() => {
60 inject(TransferState).set(
61 INTERNAL_TANSTACK_QUERY_HYDRATION_STATE_KEY,
62 dehydrated,
63 )
64 }),
65 provideTanStackQuery(() => appClient),
66 ],
67 })
68​
69 rendered.fixture.detectChanges()
70 expect(rendered.getByText('from-server')).toBeInTheDocument()
71 expect(
72 rendered.fixture.debugElement.injector
73 .get(TransferState)
74 .get(INTERNAL_TANSTACK_QUERY_HYDRATION_STATE_KEY, null),
75 ).toBeNull()
76 })
77​
78 it('browser hydrates from custom key', async () => {
79 const customKeyName = 'tanstack-test-custom-hydration'
80 const customKey = makeStateKey<DehydratedState>(customKeyName)
81 const key = queryKey()
82 const sourceClient = new QueryClient()
83 sourceClient.setQueryData(key, 'from-custom-key')
84 const dehydrated = dehydrate(sourceClient)
85 const appClient = new QueryClient()
86​
87 @Component({
88 template: `<div>{{ state.data() ?? '' }}</div>`,
89 })
90 class Page {
91 state = injectQuery(() => ({
92 queryKey: key,
93 staleTime: Infinity,
94 queryFn: () => Promise.resolve('from-client'),
95 }))
96 }
97​
98 const rendered = await render(Page, {
99 providers: [
100 provideAngularQueryChangeDetection(),
101 provideEnvironmentInitializer(() => {
102 inject(TransferState).set(customKey, dehydrated)
103 }),
104 provideTanStackQuery(() => appClient, withHydrationKey(customKeyName)),
105 ],
106 })
107​
108 rendered.fixture.detectChanges()
109 expect(rendered.getByText('from-custom-key')).toBeTruthy()
110 expect(
111 rendered.fixture.debugElement.injector
112 .get(TransferState)
113 .get(customKey, null),
114 ).toBeNull()
115 })
116​
117 it('browser does not re-fetch when hydrated state is fresh', async () => {
118 const key = queryKey()
119 const sourceClient = new QueryClient()
120 sourceClient.setQueryData(key, 'cached')
121 const dehydrated = dehydrate(sourceClient)
122 const appClient = new QueryClient()
123 let queryFnCalls = 0
124​
125 @Component({
126 template: `<div>{{ state.data() ?? '' }}</div>`,
127 })
128 class Page {
129 state = injectQuery(() => ({
130 queryKey: key,
131 staleTime: Infinity,
132 queryFn: () => {
133 queryFnCalls++
134 return sleep(10).then(() => 'should-not-run')
135 },
136 }))
137​
138 _ = effect(() => {
139 void this.state.data()
140 })
141 }
142​
143 await render(Page, {
144 providers: [
145 provideAngularQueryChangeDetection(),
146 provideEnvironmentInitializer(() => {
147 inject(TransferState).set(
148 INTERNAL_TANSTACK_QUERY_HYDRATION_STATE_KEY,
149 dehydrated,
150 )
151 }),
152 provideTanStackQuery(() => appClient),
153 ],
154 })
155​
156 await vi.advanceTimersByTimeAsync(100)
157 expect(queryFnCalls).toBe(0)
158 })
159​
160 it('withNoQueryHydration disables browser hydration', async () => {
161 const key = queryKey()
162 const sourceClient = new QueryClient()
163 sourceClient.setQueryData(key, 'from-server')
164 const dehydrated = dehydrate(sourceClient)
165 const appClient = new QueryClient()
166​
167 @Component({
168 template: `<div>{{ state.data() ?? '' }}</div>`,
169 })
170 class Page {
171 state = injectQuery(() => ({
172 queryKey: key,
173 queryFn: () => sleep(10).then(() => 'from-client'),
174 }))
175 }
176​
177 const rendered = await render(Page, {
178 providers: [
179 provideAngularQueryChangeDetection(),
180 provideEnvironmentInitializer(() => {
181 inject(TransferState).set(
182 INTERNAL_TANSTACK_QUERY_HYDRATION_STATE_KEY,
183 dehydrated,
184 )
185 }),
186 provideTanStackQuery(() => appClient, withNoQueryHydration()),
187 ],
188 })
189​
190 rendered.fixture.detectChanges()
191 await vi.advanceTimersByTimeAsync(10)
192 rendered.fixture.detectChanges()
193​
194 expect(rendered.getByText('from-client')).toBeInTheDocument()
195 expect(
196 rendered.fixture.debugElement.injector
197 .get(TransferState)
198 .get(INTERNAL_TANSTACK_QUERY_HYDRATION_STATE_KEY, null),
199 ).toEqual(dehydrated)
200 })
201})
202​
203describe('TransferState dehydration (server)', () => {
204 function createQueryInjector(
205 queryClient: QueryClient,
206 platformId: 'server' | 'browser',
207 ...features: Array<Parameters<typeof provideTanStackQuery>[1]>
208 ) {
209 TestBed.configureTestingModule({
210 providers: [
211 provideAngularQueryChangeDetection(),
212 { provide: PLATFORM_ID, useValue: platformId },
213 ],
214 })
215​
216 return createEnvironmentInjector(
217 [provideTanStackQuery(() => queryClient, ...features)],
218 TestBed.inject(EnvironmentInjector),
219 )
220 }
221​
222 it('server serializes dehydrated queries on TransferState.toJson', async () => {
223 const key = queryKey()
224 const queryClient = new QueryClient()
225 const injector = createQueryInjector(queryClient, 'server')
226​
227 void queryClient
228 .query({
229 queryKey: key,
230 queryFn: () => Promise.resolve('ssr-data'),
231 })
232 .catch(noop)
233 await vi.advanceTimersByTimeAsync(0)
234​
235 injector.get(TransferState).toJson()
236​
237 const stored = injector
238 .get(TransferState)
239 .get(INTERNAL_TANSTACK_QUERY_HYDRATION_STATE_KEY, null)
240 expect(stored).not.toBeNull()
241 if (!stored) throw new Error('expected dehydrated state')
242 expect(stored.queries.length).toBe(1)
243 expect(stored.queries[0]?.queryKey).toEqual(key)
244 })
245​
246 it('browser platform does not write server dehydration state', async () => {
247 const key = queryKey()
248 const queryClient = new QueryClient()
249 const injector = createQueryInjector(queryClient, 'browser')
250​
251 void queryClient
252 .query({
253 queryKey: key,
254 queryFn: () => Promise.resolve('data'),
255 })
256 .catch(noop)
257 await vi.advanceTimersByTimeAsync(0)
258​
259 injector.get(TransferState).toJson()
260​
261 expect(
262 injector
263 .get(TransferState)
264 .get(INTERNAL_TANSTACK_QUERY_HYDRATION_STATE_KEY, null),
265 ).toBeNull()
266 })
267​
268 it('withNoQueryHydration disables server dehydration', async () => {
269 const key = queryKey()
270 const queryClient = new QueryClient()
271 const injector = createQueryInjector(
272 queryClient,
273 'server',
274 withNoQueryHydration(),
275 )
276​
277 void queryClient
278 .query({
279 queryKey: key,
280 queryFn: () => Promise.resolve('data'),
281 })
282 .catch(noop)
283 await vi.advanceTimersByTimeAsync(0)
284​
285 injector.get(TransferState).toJson()
286​
287 expect(
288 injector
289 .get(TransferState)
290 .get(INTERNAL_TANSTACK_QUERY_HYDRATION_STATE_KEY, null),
291 ).toBeNull()
292 })
293​
294 it('multiple query clients can use distinct hydration keys', async () => {
295 const keyA = queryKey()
296 const keyB = queryKey()
297 const clientA = new QueryClient()
298 const clientB = new QueryClient()
299​
300 TestBed.configureTestingModule({
301 providers: [
302 provideAngularQueryChangeDetection(),
303 { provide: PLATFORM_ID, useValue: 'server' },
304 ],
305 })
306​
307 createEnvironmentInjector(
308 [provideTanStackQuery(() => clientA, withHydrationKey('client-a'))],
309 TestBed.inject(EnvironmentInjector),
310 )
311 createEnvironmentInjector(
312 [provideTanStackQuery(() => clientB, withHydrationKey('client-b'))],
313 TestBed.inject(EnvironmentInjector),
314 )
315​
316 clientA.setQueryData(keyA, 'a')
317 clientB.setQueryData(keyB, 'b')
318​
319 const transferState = TestBed.inject(TransferState)
320 transferState.toJson()
321​
322 expect(
323 transferState.get(makeStateKey<DehydratedState>('client-a'), null)
324 ?.queries[0]?.queryKey,
325 ).toEqual(keyA)
326 expect(
327 transferState.get(makeStateKey<DehydratedState>('client-b'), null)
328 ?.queries[0]?.queryKey,
329 ).toEqual(keyB)
330 })
331})