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

suspense.test.tsx

231 lines6.6 KB

1import { createKey, sleep } from '@tanstack/query-test-utils'
2import { act, render } from '@testing-library/react'
3import { Suspense } from 'react'
4import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
5import { QueryClient, QueryClientProvider, useSuspenseQuery } from '..'
6import type { StaleTime } from '@tanstack/query-core'
7import type { QueryKey } from '..'
8​
9function renderWithSuspense(client: QueryClient, ui: React.ReactNode) {
10 return render(
11 <QueryClientProvider client={client}>
12 <Suspense fallback="loading">{ui}</Suspense>
13 </QueryClientProvider>,
14 )
16​
17function createTestQuery(options: {
18 fetchCount: { count: number }
19 queryKey: QueryKey
20 staleTime?: StaleTime | (() => StaleTime)
21}) {
22 return function TestComponent() {
23 const { data } = useSuspenseQuery({
24 queryKey: options.queryKey,
25 queryFn: () =>
26 sleep(10).then(() => {
27 options.fetchCount.count++
28 return 'data'
29 }),
30 staleTime: options.staleTime,
31 })
32 return <div>data: {data}</div>
33 }
35​
36describe('Suspense Timer Tests', () => {
37 let queryClient: QueryClient
38 let fetchCount: { count: number }
39​
40 beforeEach(() => {
41 vi.useFakeTimers()
42 queryClient = new QueryClient({
43 defaultOptions: {
44 queries: {
45 retry: false,
46 },
47 },
48 })
49 fetchCount = { count: 0 }
50 })
51​
52 afterEach(() => {
53 queryClient.clear()
54 vi.useRealTimers()
55 })
56​
57 it('should enforce minimum staleTime of 1000ms when using suspense with number', async () => {
58 const TestComponent = createTestQuery({
59 fetchCount,
60 queryKey: createKey(),
61 staleTime: 10,
62 })
63​
64 const rendered = renderWithSuspense(queryClient, <TestComponent />)
65​
66 expect(rendered.getByText('loading')).toBeInTheDocument()
67 await act(() => vi.advanceTimersByTimeAsync(10))
68 expect(rendered.getByText('data: data')).toBeInTheDocument()
69​
70 rendered.rerender(
71 <QueryClientProvider client={queryClient}>
72 <Suspense fallback="loading">
73 <TestComponent />
74 </Suspense>
75 </QueryClientProvider>,
76 )
77​
78 await act(() => vi.advanceTimersByTimeAsync(100))
79 expect(fetchCount.count).toBe(1)
80 })
81​
82 it('should enforce minimum staleTime of 1000ms when using suspense with function', async () => {
83 const TestComponent = createTestQuery({
84 fetchCount,
85 queryKey: createKey(),
86 staleTime: () => 10,
87 })
88​
89 const rendered = renderWithSuspense(queryClient, <TestComponent />)
90​
91 expect(rendered.getByText('loading')).toBeInTheDocument()
92 await act(() => vi.advanceTimersByTimeAsync(10))
93 expect(rendered.getByText('data: data')).toBeInTheDocument()
94​
95 rendered.rerender(
96 <QueryClientProvider client={queryClient}>
97 <Suspense fallback="loading">
98 <TestComponent />
99 </Suspense>
100 </QueryClientProvider>,
101 )
102​
103 await act(() => vi.advanceTimersByTimeAsync(100))
104 expect(fetchCount.count).toBe(1)
105 })
106​
107 it('should respect staleTime when value is greater than 1000ms', async () => {
108 const TestComponent = createTestQuery({
109 fetchCount,
110 queryKey: createKey(),
111 staleTime: 2000,
112 })
113​
114 const rendered = renderWithSuspense(queryClient, <TestComponent />)
115​
116 expect(rendered.getByText('loading')).toBeInTheDocument()
117 await act(() => vi.advanceTimersByTimeAsync(10))
118 expect(rendered.getByText('data: data')).toBeInTheDocument()
119​
120 rendered.rerender(
121 <QueryClientProvider client={queryClient}>
122 <Suspense fallback="loading">
123 <TestComponent />
124 </Suspense>
125 </QueryClientProvider>,
126 )
127​
128 await act(() => vi.advanceTimersByTimeAsync(1500))
129 expect(fetchCount.count).toBe(1)
130 })
131​
132 it('should enforce minimum staleTime when undefined is provided', async () => {
133 const TestComponent = createTestQuery({
134 fetchCount,
135 queryKey: createKey(),
136 staleTime: undefined,
137 })
138​
139 const rendered = renderWithSuspense(queryClient, <TestComponent />)
140​
141 expect(rendered.getByText('loading')).toBeInTheDocument()
142 await act(() => vi.advanceTimersByTimeAsync(10))
143 expect(rendered.getByText('data: data')).toBeInTheDocument()
144​
145 rendered.rerender(
146 <QueryClientProvider client={queryClient}>
147 <Suspense fallback="loading">
148 <TestComponent />
149 </Suspense>
150 </QueryClientProvider>,
151 )
152​
153 await act(() => vi.advanceTimersByTimeAsync(500))
154 expect(fetchCount.count).toBe(1)
155 })
156​
157 it('should preserve staleTime when value is static', async () => {
158 const TestComponent = createTestQuery({
159 fetchCount,
160 queryKey: createKey(),
161 staleTime: 'static',
162 })
163​
164 const rendered = renderWithSuspense(queryClient, <TestComponent />)
165​
166 expect(rendered.getByText('loading')).toBeInTheDocument()
167 await act(() => vi.advanceTimersByTimeAsync(10))
168 expect(rendered.getByText('data: data')).toBeInTheDocument()
169​
170 rendered.rerender(
171 <QueryClientProvider client={queryClient}>
172 <Suspense fallback="loading">
173 <TestComponent />
174 </Suspense>
175 </QueryClientProvider>,
176 )
177​
178 await act(() => vi.advanceTimersByTimeAsync(2000))
179 expect(fetchCount.count).toBe(1)
180 })
181​
182 it('should preserve staleTime when function returns static', async () => {
183 const TestComponent = createTestQuery({
184 fetchCount,
185 queryKey: createKey(),
186 staleTime: () => 'static',
187 })
188​
189 const rendered = renderWithSuspense(queryClient, <TestComponent />)
190​
191 expect(rendered.getByText('loading')).toBeInTheDocument()
192 await act(() => vi.advanceTimersByTimeAsync(10))
193 expect(rendered.getByText('data: data')).toBeInTheDocument()
194​
195 rendered.rerender(
196 <QueryClientProvider client={queryClient}>
197 <Suspense fallback="loading">
198 <TestComponent />
199 </Suspense>
200 </QueryClientProvider>,
201 )
202​
203 await act(() => vi.advanceTimersByTimeAsync(2000))
204 expect(fetchCount.count).toBe(1)
205 })
206​
207 it('should respect staleTime when function returns value greater than 1000ms', async () => {
208 const TestComponent = createTestQuery({
209 fetchCount,
210 queryKey: createKey(),
211 staleTime: () => 3000,
212 })
213​
214 const rendered = renderWithSuspense(queryClient, <TestComponent />)
215​
216 expect(rendered.getByText('loading')).toBeInTheDocument()
217 await act(() => vi.advanceTimersByTimeAsync(10))
218 expect(rendered.getByText('data: data')).toBeInTheDocument()
219​
220 rendered.rerender(
221 <QueryClientProvider client={queryClient}>
222 <Suspense fallback="loading">
223 <TestComponent />
224 </Suspense>
225 </QueryClientProvider>,
226 )
227​
228 await act(() => vi.advanceTimersByTimeAsync(2000))
229 expect(fetchCount.count).toBe(1)
230 })
231})