Open History to see the last commit
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})