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

QueryClientProvider.test.tsx

226 lines5.7 KB

1import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
2import { render } from '@solidjs/testing-library'
3import { QueryCache } from '@tanstack/query-core'
4import { queryKey, sleep } from '@tanstack/query-test-utils'
5import { createMemo, createRoot } from 'solid-js'
6import { QueryClient, QueryClientProvider, useQuery, useQueryClient } from '..'
7import { useQueryClientResolver } from '../QueryClientProvider'
8​
9describe('QueryClientProvider', () => {
10 beforeEach(() => {
11 vi.useFakeTimers()
12 })
13​
14 afterEach(() => {
15 vi.useRealTimers()
16 })
17​
18 it('should set a specific cache for all queries to use', async () => {
19 const key = queryKey()
20​
21 const queryCache = new QueryCache()
22 const queryClient = new QueryClient({ queryCache })
23​
24 function Page() {
25 const query = useQuery(() => ({
26 queryKey: key,
27 queryFn: () => sleep(10).then(() => 'test'),
28 }))
29​
30 return (
31 <div>
32 <h1>{query.data}</h1>
33 </div>
34 )
35 }
36​
37 const rendered = render(() => (
38 <QueryClientProvider client={queryClient}>
39 <Page />
40 </QueryClientProvider>
41 ))
42​
43 await vi.advanceTimersByTimeAsync(10)
44 expect(rendered.getByText('test')).toBeInTheDocument()
45​
46 expect(queryCache.find({ queryKey: key })?.state.data).toBe('test')
47 })
48​
49 it('should allow multiple caches to be partitioned', async () => {
50 const key1 = queryKey()
51 const key2 = queryKey()
52​
53 const queryCache1 = new QueryCache()
54 const queryCache2 = new QueryCache()
55​
56 const queryClient1 = new QueryClient({ queryCache: queryCache1 })
57 const queryClient2 = new QueryClient({ queryCache: queryCache2 })
58​
59 function Page1() {
60 const query = useQuery(() => ({
61 queryKey: key1,
62 queryFn: () => sleep(10).then(() => 'test1'),
63 }))
64​
65 return (
66 <div>
67 <h1>{query.data}</h1>
68 </div>
69 )
70 }
71 function Page2() {
72 const query = useQuery(() => ({
73 queryKey: key2,
74 queryFn: () => sleep(10).then(() => 'test2'),
75 }))
76​
77 return (
78 <div>
79 <h1>{query.data}</h1>
80 </div>
81 )
82 }
83​
84 const rendered = render(() => (
85 <>
86 <QueryClientProvider client={queryClient1}>
87 <Page1 />
88 </QueryClientProvider>
89 <QueryClientProvider client={queryClient2}>
90 <Page2 />
91 </QueryClientProvider>
92 </>
93 ))
94​
95 await vi.advanceTimersByTimeAsync(10)
96 expect(rendered.getByText('test1')).toBeInTheDocument()
97 expect(rendered.getByText('test2')).toBeInTheDocument()
98​
99 expect(queryCache1.find({ queryKey: key1 })?.state.data).toBe('test1')
100 expect(queryCache1.find({ queryKey: key2 })).toBeUndefined()
101 expect(queryCache2.find({ queryKey: key1 })).toBeUndefined()
102 expect(queryCache2.find({ queryKey: key2 })?.state.data).toBe('test2')
103 })
104​
105 it("should use defaultOptions for queries when they don't provide their own config", async () => {
106 const key = queryKey()
107​
108 const queryCache = new QueryCache()
109 const queryClient = new QueryClient({
110 queryCache,
111 defaultOptions: {
112 queries: {
113 gcTime: Infinity,
114 },
115 },
116 })
117​
118 function Page() {
119 const query = useQuery(() => ({
120 queryKey: key,
121 queryFn: () => sleep(10).then(() => 'test'),
122 }))
123​
124 return (
125 <div>
126 <h1>{query.data}</h1>
127 </div>
128 )
129 }
130​
131 const rendered = render(() => (
132 <QueryClientProvider client={queryClient}>
133 <Page />
134 </QueryClientProvider>
135 ))
136​
137 await vi.advanceTimersByTimeAsync(10)
138 expect(rendered.getByText('test')).toBeInTheDocument()
139​
140 expect(queryCache.find({ queryKey: key })?.options.gcTime).toBe(Infinity)
141 })
142​
143 describe('useQueryClient', () => {
144 it('should throw an error if no query client has been set', () => {
145 const consoleErrorMock = vi
146 .spyOn(console, 'error')
147 .mockImplementation(() => undefined)
148​
149 function Page() {
150 useQueryClient()
151 return null
152 }
153​
154 expect(() => render(() => <Page />)).toThrow(
155 'No QueryClient set, use QueryClientProvider to set one',
156 )
157​
158 consoleErrorMock.mockRestore()
159 })
160 })
161​
162 it('should not throw an error if user provides custom query client', () => {
163 const consoleErrorMock = vi
164 .spyOn(console, 'error')
165 .mockImplementation(() => undefined)
166​
167 function Page() {
168 const client = new QueryClient()
169 useQueryClient(client)
170 return null
171 }
172​
173 render(() => <Page />)
174​
175 expect(consoleErrorMock).not.toHaveBeenCalled()
176​
177 consoleErrorMock.mockRestore()
178 })
179​
180 it('should create a query client resolver that is safe to call in reactive callbacks', () => {
181 const queryClient = new QueryClient()
182 let resolveClient!: () => QueryClient
183​
184 function Page() {
185 resolveClient = useQueryClientResolver()
186 return null
187 }
188​
189 render(() => (
190 <QueryClientProvider client={queryClient}>
191 <Page />
192 </QueryClientProvider>
193 ))
194​
195 createRoot((dispose) => {
196 const client = createMemo(() => resolveClient())
197​
198 expect(client()).toBe(queryClient)
199 dispose()
200 })
201 })
202​
203 it('should defer missing provider errors until a resolver is called', () => {
204 const consoleErrorMock = vi
205 .spyOn(console, 'error')
206 .mockImplementation(() => undefined)
207 let resolveClient!: () => QueryClient
208​
209 function Page() {
210 resolveClient = useQueryClientResolver()
211 return null
212 }
213​
214 expect(() => render(() => <Page />)).not.toThrow()
215​
216 expect(() =>
217 createRoot((dispose) => {
218 const client = createMemo(() => resolveClient())
219 client()
220 dispose()
221 }),
222 ).toThrow('No QueryClient set, use QueryClientProvider to set one')
223​
224 consoleErrorMock.mockRestore()
225 })
226})