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

QueryClientProvider.test.tsx

216 lines5.5 KB

1import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
2import { render } from '@solidjs/testing-library'
3import { QueryCache } from '@tanstack/query-core'
4import { createKey, 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 = createKey()
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 = createKey()
51 const key2 = createKey()
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 = createKey()
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 vi.spyOn(console, 'error').mockReturnValue(undefined)
146​
147 function Page() {
148 useQueryClient()
149 return null
150 }
151​
152 expect(() => render(() => <Page />)).toThrow(
153 'No QueryClient set, use QueryClientProvider to set one',
154 )
155 })
156 })
157​
158 it('should not throw an error if user provides custom query client', () => {
159 const consoleErrorMock = vi
160 .spyOn(console, 'error')
161 .mockReturnValue(undefined)
162​
163 function Page() {
164 const client = new QueryClient()
165 useQueryClient(client)
166 return null
167 }
168​
169 render(() => <Page />)
170​
171 expect(consoleErrorMock).not.toHaveBeenCalled()
172 })
173​
174 it('should create a query client resolver that is safe to call in reactive callbacks', () => {
175 const queryClient = new QueryClient()
176 let resolveClient!: () => QueryClient
177​
178 function Page() {
179 resolveClient = useQueryClientResolver()
180 return null
181 }
182​
183 render(() => (
184 <QueryClientProvider client={queryClient}>
185 <Page />
186 </QueryClientProvider>
187 ))
188​
189 createRoot((dispose) => {
190 const client = createMemo(() => resolveClient())
191​
192 expect(client()).toBe(queryClient)
193 dispose()
194 })
195 })
196​
197 it('should defer missing provider errors until a resolver is called', () => {
198 vi.spyOn(console, 'error').mockReturnValue(undefined)
199 let resolveClient!: () => QueryClient
200​
201 function Page() {
202 resolveClient = useQueryClientResolver()
203 return null
204 }
205​
206 expect(() => render(() => <Page />)).not.toThrow()
207​
208 expect(() =>
209 createRoot((dispose) => {
210 const client = createMemo(() => resolveClient())
211 client()
212 dispose()
213 }),
214 ).toThrow('No QueryClient set, use QueryClientProvider to set one')
215 })
216})