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

QueryClientProvider.test.tsx

267 lines7.2 KB

1import { render, screen, waitFor } from 'solid-testing-library'
2​
3import { QueryCache, QueryClient } from '@tanstack/query-core'
4import { createContext, useContext } from 'solid-js'
5import { renderToString } from 'solid-js/web'
6import { QueryClientProvider, createQuery, useQueryClient } from '..'
7import { queryKey } from './utils'
8import { createQueryClient, sleep } from './utils'
9import type { Context } from 'solid-js'
10​
11describe('QueryClientProvider', () => {
12 it('sets a specific cache for all queries to use', async () => {
13 const key = queryKey()
14​
15 const queryCache = new QueryCache()
16 const queryClient = createQueryClient({ queryCache })
17​
18 function Page() {
19 const query = createQuery(key, async () => {
20 await sleep(10)
21 return 'test'
22 })
23​
24 return (
25 <div>
26 <h1>{query.data}</h1>
27 </div>
28 )
29 }
30​
31 render(() => (
32 <QueryClientProvider client={queryClient}>
33 <Page />
34 </QueryClientProvider>
35 ))
36​
37 await waitFor(() => {
38 return screen.getByText('test')
39 })
40​
41 expect(queryCache.find(key())).toBeDefined()
42 })
43​
44 it('allows multiple caches to be partitioned', async () => {
45 const key1 = queryKey()
46 const key2 = queryKey()
47​
48 const queryCache1 = new QueryCache()
49 const queryCache2 = new QueryCache()
50​
51 const queryClient1 = createQueryClient({ queryCache: queryCache1 })
52 const queryClient2 = createQueryClient({ queryCache: queryCache2 })
53​
54 function Page1() {
55 const query = createQuery(key1, async () => {
56 await sleep(10)
57 return 'test1'
58 })
59​
60 return (
61 <div>
62 <h1>{query.data}</h1>
63 </div>
64 )
65 }
66 function Page2() {
67 const query = createQuery(key2, async () => {
68 await sleep(10)
69 return 'test2'
70 })
71​
72 return (
73 <div>
74 <h1>{query.data}</h1>
75 </div>
76 )
77 }
78​
79 render(() => (
80 <>
81 <QueryClientProvider client={queryClient1}>
82 <Page1 />
83 </QueryClientProvider>
84 <QueryClientProvider client={queryClient2}>
85 <Page2 />
86 </QueryClientProvider>
87 </>
88 ))
89​
90 await waitFor(() => screen.getByText('test1'))
91 await waitFor(() => screen.getByText('test2'))
92​
93 expect(queryCache1.find(key1())).toBeDefined()
94 expect(queryCache1.find(key2())).not.toBeDefined()
95 expect(queryCache2.find(key1())).not.toBeDefined()
96 expect(queryCache2.find(key2())).toBeDefined()
97 })
98​
99 it("uses defaultOptions for queries when they don't provide their own config", async () => {
100 const key = queryKey()
101​
102 const queryCache = new QueryCache()
103 const queryClient = createQueryClient({
104 queryCache,
105 defaultOptions: {
106 queries: {
107 cacheTime: Infinity,
108 },
109 },
110 })
111​
112 function Page() {
113 const query = createQuery(key, async () => {
114 await sleep(10)
115 return 'test'
116 })
117​
118 return (
119 <div>
120 <h1>{query.data}</h1>
121 </div>
122 )
123 }
124​
125 render(() => (
126 <QueryClientProvider client={queryClient}>
127 <Page />
128 </QueryClientProvider>
129 ))
130​
131 await waitFor(() => screen.getByText('test'))
132​
133 expect(queryCache.find(key())).toBeDefined()
134 expect(queryCache.find(key())?.options.cacheTime).toBe(Infinity)
135 })
136​
137 describe('with custom context', () => {
138 it('uses the correct context', async () => {
139 const key = queryKey()
140​
141 const contextOuter = createContext<QueryClient | undefined>(undefined)
142 const contextInner = createContext<QueryClient | undefined>(undefined)
143​
144 const queryCacheOuter = new QueryCache()
145 const queryClientOuter = new QueryClient({ queryCache: queryCacheOuter })
146​
147 const queryCacheInner = new QueryCache()
148 const queryClientInner = new QueryClient({ queryCache: queryCacheInner })
149​
150 const queryCacheInnerInner = new QueryCache()
151 const queryClientInnerInner = new QueryClient({
152 queryCache: queryCacheInnerInner,
153 })
154​
155 function Page() {
156 const queryOuter = createQuery(key, async () => 'testOuter', {
157 context: contextOuter,
158 })
159 const queryInner = createQuery(key, async () => 'testInner', {
160 context: contextInner,
161 })
162 const queryInnerInner = createQuery(key, async () => 'testInnerInner')
163​
164 return (
165 <div>
166 <h1>
167 {queryOuter.data} {queryInner.data} {queryInnerInner.data}
168 </h1>
169 </div>
170 )
171 }
172​
173 // contextSharing should be ignored when passing a custom context.
174 const contextSharing = true
175​
176 render(() => (
177 <QueryClientProvider client={queryClientOuter} context={contextOuter}>
178 <QueryClientProvider client={queryClientInner} context={contextInner}>
179 <QueryClientProvider
180 client={queryClientInnerInner}
181 contextSharing={contextSharing}
182 >
183 <Page />
184 </QueryClientProvider>
185 </QueryClientProvider>
186 </QueryClientProvider>
187 ))
188​
189 await waitFor(() =>
190 screen.getByText('testOuter testInner testInnerInner'),
191 )
192 })
193 })
194​
195 describe('useQueryClient', () => {
196 it('should throw an error if no query client has been set', () => {
197 const consoleMock = jest
198 .spyOn(console, 'error')
199 .mockImplementation(() => undefined)
200​
201 function Page() {
202 useQueryClient()
203 return null
204 }
205​
206 expect(() => render(() => <Page />)).toThrow(
207 'No QueryClient set, use QueryClientProvider to set one',
208 )
209​
210 consoleMock.mockRestore()
211 })
212​
213 it('should use window to get the context when contextSharing is true', () => {
214 const queryCache = new QueryCache()
215 const queryClient = createQueryClient({ queryCache })
216​
217 let queryClientFromHook: QueryClient | undefined
218 let queryClientFromWindow: QueryClient | undefined
219​
220 function Page() {
221 queryClientFromHook = useQueryClient()
222 queryClientFromWindow = useContext(
223 window.SolidQueryClientContext as Context<QueryClient | undefined>,
224 )
225 return null
226 }
227​
228 render(() => (
229 <QueryClientProvider client={queryClient} contextSharing={true}>
230 <Page />
231 </QueryClientProvider>
232 ))
233​
234 expect(queryClientFromHook).toEqual(queryClient)
235 expect(queryClientFromWindow).toEqual(queryClient)
236 })
237​
238 it.skip('should not use window to get the context when contextSharing is true and window does not exist', () => {
239 const queryCache = new QueryCache()
240 const queryClient = createQueryClient({ queryCache })
241​
242 // Mock a non web browser environment
243 const windowSpy = jest
244 .spyOn(window, 'window', 'get')
245 .mockImplementation(undefined)
246​
247 let queryClientFromHook: QueryClient | undefined
248​
249 function Page() {
250 queryClientFromHook = useQueryClient()
251 return null
252 }
253​
254 // TODO(lukemurray): fails because renderToString never calls Page
255 // probably an SSR-testing issue we need to fix.
256 renderToString(() => (
257 <QueryClientProvider client={queryClient} contextSharing={true}>
258 <Page />
259 </QueryClientProvider>
260 ))
261​
262 expect(queryClientFromHook).toEqual(queryClient)
263​
264 windowSpy.mockRestore()
265 })
266 })
267})