Open History to see the last commit
1import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
2import {
3 ErrorBoundary,
4 createEffect,
5 createRenderEffect,
6 createSignal,
7} from 'solid-js'
8import { fireEvent, render } from '@solidjs/testing-library'
9import { queryKey, sleep } from '@tanstack/query-test-utils'
10import {
11 MutationCache,
12 QueryCache,
13 QueryClient,
14 QueryClientProvider,
15 useMutation,
16} from '..'
17import { mockOnlineManagerIsOnline, setActTimeout } from './utils'
18import type { UseMutationResult } from '../types'
19β
20describe('useMutation', () => {
21 beforeEach(() => {
22 vi.useFakeTimers()
23 })
24β
25 afterEach(() => {
26 vi.useRealTimers()
27 })
28β
29 const queryCache = new QueryCache()
30 const mutationCache = new MutationCache()
31 const queryClient = new QueryClient({ queryCache, mutationCache })
32β
33 it('should be able to reset `data`', async () => {
34 function Page() {
35 const mutation = useMutation(() => ({
36 mutationFn: () => Promise.resolve('mutation'),
37 }))
38β
39 return (
40 <div>
41 <h1>{mutation.data ?? 'empty'}</h1>
42 <button onClick={() => mutation.reset()}>reset</button>
43 <button onClick={() => mutation.mutate()}>mutate</button>
44 </div>
45 )
46 }
47β
48 const rendered = render(() => (
49 <QueryClientProvider client={queryClient}>
50 <Page />
51 </QueryClientProvider>
52 ))
53β
54 expect(rendered.getByRole('heading').textContent).toBe('empty')
55β
56 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
57 await vi.advanceTimersByTimeAsync(0)
58 expect(rendered.getByRole('heading').textContent).toBe('mutation')
59β
60 fireEvent.click(rendered.getByRole('button', { name: /reset/i }))
61 expect(rendered.getByRole('heading').textContent).toBe('empty')
62 })
63β
64 it('should be able to reset `error`', async () => {
65 const consoleMock = vi
66 .spyOn(console, 'error')
67 .mockImplementation(() => undefined)
68β
69 function Page() {
70 const mutation = useMutation<string, Error>(() => ({
71 mutationFn: () => {
72 const err = new Error('Expected mock error. All is well!')
73 err.stack = ''
74 return Promise.reject(err)
75 },
76 }))
77β
78 return (
79 <div>
80 {mutation.error && <h1>{mutation.error.message}</h1>}
81 <button onClick={() => mutation.reset()}>reset</button>
82 <button onClick={() => mutation.mutate()}>mutate</button>
83 </div>
84 )
85 }
86β
87 const rendered = render(() => (
88 <QueryClientProvider client={queryClient}>
89 <Page />
90 </QueryClientProvider>
91 ))
92β
93 expect(rendered.queryByRole('heading')).toBeNull()
94β
95 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
96 await vi.advanceTimersByTimeAsync(0)
97 expect(rendered.getByRole('heading').textContent).toBe(
98 'Expected mock error. All is well!',
99 )
100β
101 fireEvent.click(rendered.getByRole('button', { name: /reset/i }))
102 expect(rendered.queryByRole('heading')).toBeNull()
103β
104 consoleMock.mockRestore()
105 })
106β
107 it('should be able to call `onSuccess` and `onSettled` after each successful mutate', async () => {
108 const [count, setCount] = createSignal(0)
109 const onSuccessMock = vi.fn()
110 const onSettledMock = vi.fn()
111β
112 function Page() {
113 const mutation = useMutation(() => ({
114 mutationFn: (vars: { count: number }) => Promise.resolve(vars.count),
115 onSuccess: (data) => {
116 onSuccessMock(data)
117 },
118 onSettled: (data) => {
119 onSettledMock(data)
120 },
121 }))
122β
123 return (
124 <div>
125 <h1>{count()}</h1>
126 <button
127 onClick={() => {
128 setCount((c) => c + 1)
129 return mutation.mutate({ count: count() })
130 }}
131 >
132 mutate
133 </button>
134 </div>
135 )
136 }
137β
138 const rendered = render(() => (
139 <QueryClientProvider client={queryClient}>
140 <Page />
141 </QueryClientProvider>
142 ))
143β
144 expect(rendered.getByRole('heading').textContent).toBe('0')
145β
146 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
147 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
148 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
149 await vi.advanceTimersByTimeAsync(0)
150 expect(rendered.getByRole('heading').textContent).toBe('3')
151β
152 expect(onSuccessMock).toHaveBeenCalledTimes(3)
153β
154 expect(onSuccessMock).toHaveBeenCalledWith(1)
155 expect(onSuccessMock).toHaveBeenCalledWith(2)
156 expect(onSuccessMock).toHaveBeenCalledWith(3)
157β
158 expect(onSettledMock).toHaveBeenCalledTimes(3)
159β
160 expect(onSettledMock).toHaveBeenCalledWith(1)
161 expect(onSettledMock).toHaveBeenCalledWith(2)
162 expect(onSettledMock).toHaveBeenCalledWith(3)
163 })
164β
165 it('should set correct values for `failureReason` and `failureCount` on multiple mutate calls', async () => {
166 const [count, setCount] = createSignal(0)
167 type Value = { count: number }
168β
169 const mutateFn = vi.fn<(value: Value) => Promise<Value>>()
170β
171 mutateFn.mockImplementationOnce(() =>
172 Promise.reject(new Error('Error test Jonas')),
173 )
174β
175 mutateFn.mockImplementation((value) => sleep(10).then(() => value))
176β
177 function Page() {
178 const mutation = useMutation(() => ({
179 mutationFn: mutateFn,
180 }))
181β
182 return (
183 <div>
184 <h1>Data {mutation.data?.count}</h1>
185 <h2>Status {mutation.status}</h2>
186 <h2>Failed {mutation.failureCount} times</h2>
187 <h2>Failed because {mutation.failureReason?.message ?? 'null'}</h2>
188 <button
189 onClick={() => {
190 setCount((c) => c + 1)
191 return mutation.mutate({ count: count() })
192 }}
193 >
194 mutate
195 </button>
196 </div>
197 )
198 }
199β
200 const rendered = render(() => (
201 <QueryClientProvider client={queryClient}>
202 <Page />
203 </QueryClientProvider>
204 ))
205β
206 expect(rendered.getByText('Data')).toBeInTheDocument()
207β
208 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
209 expect(rendered.getByText('Data')).toBeInTheDocument()
210 await vi.advanceTimersByTimeAsync(0)
211 expect(rendered.getByText('Status error')).toBeInTheDocument()
212 expect(rendered.getByText('Failed 1 times')).toBeInTheDocument()
213 expect(
214 rendered.getByText('Failed because Error test Jonas'),
215 ).toBeInTheDocument()
216β
217 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
218 await vi.advanceTimersByTimeAsync(0)
219 expect(rendered.getByText('Status pending')).toBeInTheDocument()
220 await vi.advanceTimersByTimeAsync(10)
221 expect(rendered.getByText('Status success')).toBeInTheDocument()
222 expect(rendered.getByText('Data 2')).toBeInTheDocument()
223 expect(rendered.getByText('Failed 0 times')).toBeInTheDocument()
224 expect(rendered.getByText('Failed because null')).toBeInTheDocument()
225 })
226β
227 it('should be able to call `onError` and `onSettled` after each failed mutate', async () => {
228 const onErrorMock = vi.fn()
229 const onSettledMock = vi.fn()
230 const [count, setCount] = createSignal(0)
231β
232 function Page() {
233 const mutation = useMutation(() => ({
234 mutationFn: (vars: { count: number }) => {
235 const error = new Error(
236 `Expected mock error. All is well! ${vars.count}`,
237 )
238 error.stack = ''
239 return Promise.reject(error)
240 },
241 onError: (error: Error) => {
242 onErrorMock(error.message)
243 },
244 onSettled: (_data, error) => {
245 onSettledMock(error?.message)
246 },
247 }))
248β
249 return (
250 <div>
251 <h1>{count()}</h1>
252 <button
253 onClick={() => {
254 setCount((c) => c + 1)
255 return mutation.mutate({ count: count() })
256 }}
257 >
258 mutate
259 </button>
260 </div>
261 )
262 }
263β
264 const rendered = render(() => (
265 <QueryClientProvider client={queryClient}>
266 <Page />
267 </QueryClientProvider>
268 ))
269β
270 expect(rendered.getByRole('heading').textContent).toBe('0')
271β
272 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
273 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
274 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
275 await vi.advanceTimersByTimeAsync(0)
276 expect(rendered.getByRole('heading').textContent).toBe('3')
277β
278 expect(onErrorMock).toHaveBeenCalledTimes(3)
279 expect(onErrorMock).toHaveBeenCalledWith(
280 'Expected mock error. All is well! 1',
281 )
282 expect(onErrorMock).toHaveBeenCalledWith(
283 'Expected mock error. All is well! 2',
284 )
285 expect(onErrorMock).toHaveBeenCalledWith(
286 'Expected mock error. All is well! 3',
287 )
288β
289 expect(onSettledMock).toHaveBeenCalledTimes(3)
290 expect(onSettledMock).toHaveBeenCalledWith(
291 'Expected mock error. All is well! 1',
292 )
293 expect(onSettledMock).toHaveBeenCalledWith(
294 'Expected mock error. All is well! 2',
295 )
296 expect(onSettledMock).toHaveBeenCalledWith(
297 'Expected mock error. All is well! 3',
298 )
299 })
300β
301 it('should be able to override the useMutation success callbacks', async () => {
302 const callbacks: Array<string> = []
303β
304 function Page() {
305 const mutation = useMutation(() => ({
306 mutationFn: (text: string) => Promise.resolve(text),
307 onSuccess: () => {
308 callbacks.push('useMutation.onSuccess')
309 },
310 onSettled: () => {
311 callbacks.push('useMutation.onSettled')
312 },
313 }))
314β
315 createEffect(() => {
316 const { mutateAsync } = mutation
317 setActTimeout(async () => {
318 try {
319 const result = await mutateAsync('todo', {
320 onSuccess: () => {
321 callbacks.push('mutateAsync.onSuccess')
322 },
323 onSettled: () => {
324 callbacks.push('mutateAsync.onSettled')
325 },
326 })
327 callbacks.push(`mutateAsync.result:${result}`)
328 } catch {}
329 }, 10)
330 })
331β
332 return null
333 }
334β
335 render(() => (
336 <QueryClientProvider client={queryClient}>
337 <Page />
338 </QueryClientProvider>
339 ))
340β
341 await vi.advanceTimersByTimeAsync(10)
342β
343 expect(callbacks).toEqual([
344 'useMutation.onSuccess',
345 'useMutation.onSettled',
346 'mutateAsync.onSuccess',
347 'mutateAsync.onSettled',
348 'mutateAsync.result:todo',
349 ])
350 })
351β
352 it('should be able to override the error callbacks when using mutateAsync', async () => {
353 const callbacks: Array<string> = []
354β
355 function Page() {
356 const mutation = useMutation(() => ({
357 mutationFn: (_text: string) => Promise.reject(new Error('oops')),
358β
359 onError: () => {
360 callbacks.push('useMutation.onError')
361 },
362 onSettled: () => {
363 callbacks.push('useMutation.onSettled')
364 },
365 }))
366β
367 createEffect(() => {
368 const { mutateAsync } = mutation
369 setActTimeout(async () => {
370 try {
371 await mutateAsync('todo', {
372 onError: () => {
373 callbacks.push('mutateAsync.onError')
374 },
375 onSettled: () => {
376 callbacks.push('mutateAsync.onSettled')
377 },
378 })
379 } catch (error) {
380 callbacks.push(`mutateAsync.error:${(error as Error).message}`)
381 }
382 }, 10)
383 })
384β
385 return null
386 }
387β
388 render(() => (
389 <QueryClientProvider client={queryClient}>
390 <Page />
391 </QueryClientProvider>
392 ))
393β
394 await vi.advanceTimersByTimeAsync(10)
395β
396 expect(callbacks).toEqual([
397 'useMutation.onError',
398 'useMutation.onSettled',
399 'mutateAsync.onError',
400 'mutateAsync.onSettled',
401 'mutateAsync.error:oops',
402 ])
403 })
404β
405 it('should be able to use mutation defaults', async () => {
406 const key = queryKey()
407β
408 queryClient.setMutationDefaults(key, {
409 mutationFn: (text: string) => sleep(10).then(() => text),
410 })
411β
412 const states: Array<UseMutationResult<any, any, any, any>> = []
413β
414 function Page() {
415 const mutation = useMutation<string, unknown, string>(() => ({
416 mutationKey: key,
417 }))
418β
419 createRenderEffect(() => {
420 states.push({ ...mutation })
421 })
422β
423 createEffect(() => {
424 const { mutate } = mutation
425 setActTimeout(() => {
426 mutate('todo')
427 }, 10)
428 })
429β
430 return null
431 }
432β
433 render(() => (
434 <QueryClientProvider client={queryClient}>
435 <Page />
436 </QueryClientProvider>
437 ))
438β
439 await vi.advanceTimersByTimeAsync(20)
440β
441 expect(states.length).toBe(3)
442 expect(states[0]).toMatchObject({ data: undefined, isPending: false })
443 expect(states[1]).toMatchObject({ data: undefined, isPending: true })
444 expect(states[2]).toMatchObject({ data: 'todo', isPending: false })
445 })
446β
447 it('should be able to retry a failed mutation', async () => {
448 let count = 0
449β
450 function Page() {
451 const mutation = useMutation(() => ({
452 mutationFn: (_text: string) => {
453 count++
454 return Promise.reject(new Error('oops'))
455 },
456 retry: 1,
457 retryDelay: 5,
458 }))
459β
460 createEffect(() => {
461 const { mutate } = mutation
462 setActTimeout(() => {
463 mutate('todo')
464 }, 10)
465 })
466β
467 return null
468 }
469β
470 render(() => (
471 <QueryClientProvider client={queryClient}>
472 <Page />
473 </QueryClientProvider>
474 ))
475β
476 await vi.advanceTimersByTimeAsync(20)
477β
478 expect(count).toBe(2)
479 })
480β
481 it('should not retry mutations while offline', async () => {
482 const onlineMock = mockOnlineManagerIsOnline(false)
483β
484 let count = 0
485β
486 function Page() {
487 const mutation = useMutation(() => ({
488 mutationFn: (_text: string) => {
489 count++
490 return Promise.reject(new Error('oops'))
491 },
492 retry: 1,
493 retryDelay: 5,
494 }))
495β
496 return (
497 <div>
498 <button onClick={() => mutation.mutate('todo')}>mutate</button>
499 <div>
500 {`error: ${
501 mutation.error instanceof Error ? mutation.error.message : 'null'
502 }, status: ${mutation.status}, isPaused: ${String(
503 mutation.isPaused,
504 )}`}
505 </div>
506 </div>
507 )
508 }
509β
510 const rendered = render(() => (
511 <QueryClientProvider client={queryClient}>
512 <Page />
513 </QueryClientProvider>
514 ))
515β
516 expect(
517 rendered.getByText('error: null, status: idle, isPaused: false'),
518 ).toBeInTheDocument()
519β
520 window.dispatchEvent(new Event('offline'))
521β
522 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
523β
524 expect(
525 rendered.getByText('error: null, status: pending, isPaused: true'),
526 ).toBeInTheDocument()
527β
528 expect(count).toBe(0)
529β
530 onlineMock.mockRestore()
531 window.dispatchEvent(new Event('online'))
532β
533 await vi.advanceTimersByTimeAsync(5)
534 expect(
535 rendered.getByText('error: oops, status: error, isPaused: false'),
536 ).toBeInTheDocument()
537β
538 expect(count).toBe(2)
539 })
540β
541 it('should call onMutate even if paused', async () => {
542 const onlineMock = mockOnlineManagerIsOnline(false)
543 const onMutate = vi.fn()
544 let count = 0
545β
546 function Page() {
547 const mutation = useMutation(() => ({
548 mutationFn: async (_text: string) => {
549 count++
550 await sleep(10)
551 return count
552 },
553 onMutate,
554 }))
555β
556 return (
557 <div>
558 <button onClick={() => mutation.mutate('todo')}>mutate</button>
559 <div>
560 data: {mutation.data ?? 'null'}, status: {mutation.status},
561 isPaused: {String(mutation.isPaused)}
562 </div>
563 </div>
564 )
565 }
566β
567 const rendered = render(() => (
568 <QueryClientProvider client={queryClient}>
569 <Page />
570 </QueryClientProvider>
571 ))
572β
573 expect(
574 rendered.getByText('data: null, status: idle, isPaused: false'),
575 ).toBeInTheDocument()
576β
577 window.dispatchEvent(new Event('offline'))
578β
579 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
580 await vi.advanceTimersByTimeAsync(0)
581 expect(
582 rendered.getByText('data: null, status: pending, isPaused: true'),
583 ).toBeInTheDocument()
584β
585 expect(onMutate).toHaveBeenCalledTimes(1)
586 expect(onMutate).toHaveBeenCalledWith('todo', {
587 client: queryClient,
588 meta: undefined,
589 mutationKey: undefined,
590 })
591β
592 onlineMock.mockRestore()
593 window.dispatchEvent(new Event('online'))
594β
595 await vi.advanceTimersByTimeAsync(10)
596 expect(
597 rendered.getByText('data: 1, status: success, isPaused: false'),
598 ).toBeInTheDocument()
599β
600 expect(onMutate).toHaveBeenCalledTimes(1)
601 expect(count).toBe(1)
602 })
603β
604 it('should optimistically go to paused state if offline', async () => {
605 const onlineMock = mockOnlineManagerIsOnline(false)
606 let count = 0
607 const states: Array<string> = []
608β
609 function Page() {
610 const mutation = useMutation(() => ({
611 mutationFn: async (_text: string) => {
612 count++
613 await sleep(10)
614 return count
615 },
616 }))
617β
618 createRenderEffect(() => {
619 states.push(`${mutation.status}, ${mutation.isPaused}`)
620 })
621β
622 return (
623 <div>
624 <button onClick={() => mutation.mutate('todo')}>mutate</button>
625 <div>
626 data: {mutation.data ?? 'null'}, status: {mutation.status},
627 isPaused: {String(mutation.isPaused)}
628 </div>
629 </div>
630 )
631 }
632β
633 const rendered = render(() => (
634 <QueryClientProvider client={queryClient}>
635 <Page />
636 </QueryClientProvider>
637 ))
638β
639 rendered.getByText('data: null, status: idle, isPaused: false')
640 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
641 expect(
642 rendered.getByText('data: null, status: pending, isPaused: true'),
643 ).toBeInTheDocument()
644β
645 // no intermediate 'pending, false' state is expected because we don't start mutating!
646 expect(states[0]).toBe('idle, false')
647 expect(states[1]).toBe('pending, true')
648β
649 onlineMock.mockReturnValue(true)
650 window.dispatchEvent(new Event('online'))
651β
652 await vi.advanceTimersByTimeAsync(10)
653 expect(
654 rendered.getByText('data: 1, status: success, isPaused: false'),
655 ).toBeInTheDocument()
656β
657 onlineMock.mockRestore()
658 })
659β
660 it('should be able to retry a mutation when online', async () => {
661 const onlineMock = mockOnlineManagerIsOnline(false)
662β
663 let count = 0
664 const states: Array<UseMutationResult<any, any, any, any>> = []
665β
666 function Page() {
667 const mutation = useMutation(() => ({
668 mutationFn: async (_text: string) => {
669 await sleep(1)
670 count++
671 return count > 1
672 ? Promise.resolve('data')
673 : Promise.reject(new Error('oops'))
674 },
675 retry: 1,
676 retryDelay: 5,
677 networkMode: 'offlineFirst',
678 }))
679β
680 createRenderEffect(() => {
681 states.push({ ...mutation })
682 })
683β
684 createEffect(() => {
685 const { mutate } = mutation
686 setActTimeout(() => {
687 window.dispatchEvent(new Event('offline'))
688 mutate('todo')
689 }, 10)
690 })
691β
692 return null
693 }
694β
695 render(() => (
696 <QueryClientProvider client={queryClient}>
697 <Page />
698 </QueryClientProvider>
699 ))
700β
701 await vi.advanceTimersByTimeAsync(16)
702β
703 expect(states.length).toBe(4)
704 expect(states[0]).toMatchObject({
705 isPending: false,
706 isPaused: false,
707 failureCount: 0,
708 failureReason: null,
709 })
710 expect(states[1]).toMatchObject({
711 isPending: true,
712 isPaused: false,
713 failureCount: 0,
714 failureReason: null,
715 })
716 expect(states[2]).toMatchObject({
717 isPending: true,
718 isPaused: false,
719 failureCount: 1,
720 failureReason: new Error('oops'),
721 })
722 expect(states[3]).toMatchObject({
723 isPending: true,
724 isPaused: true,
725 failureCount: 1,
726 failureReason: new Error('oops'),
727 })
728β
729 onlineMock.mockRestore()
730 window.dispatchEvent(new Event('online'))
731β
732 await vi.advanceTimersByTimeAsync(1)
733β
734 expect(states.length).toBe(6)
735 expect(states[4]).toMatchObject({
736 isPending: true,
737 isPaused: false,
738 failureCount: 1,
739 failureReason: new Error('oops'),
740 })
741 expect(states[5]).toMatchObject({
742 isPending: false,
743 isPaused: false,
744 failureCount: 0,
745 failureReason: null,
746 data: 'data',
747 })
748 })
749β
750 // eslint-disable-next-line vitest/expect-expect
751 it('should not change state if unmounted', () => {
752 function Mutates() {
753 const mutation = useMutation(() => ({ mutationFn: () => sleep(10) }))
754 return <button onClick={() => mutation.mutate()}>mutate</button>
755 }
756 function Page() {
757 const [mounted, setMounted] = createSignal(true)
758 return (
759 <div>
760 <button onClick={() => setMounted(false)}>unmount</button>
761 {mounted() && <Mutates />}
762 </div>
763 )
764 }
765β
766 const rendered = render(() => (
767 <QueryClientProvider client={queryClient}>
768 <Page />
769 </QueryClientProvider>
770 ))
771 fireEvent.click(rendered.getByText('mutate'))
772 fireEvent.click(rendered.getByText('unmount'))
773 })
774β
775 it('should be able to throw an error when throwOnError is set to true', async () => {
776 const consoleMock = vi
777 .spyOn(console, 'error')
778 .mockImplementation(() => undefined)
779β
780 function Page() {
781 const mutation = useMutation<string, Error>(() => ({
782 mutationFn: () => {
783 const err = new Error('Expected mock error. All is well!')
784 err.stack = ''
785 return Promise.reject(err)
786 },
787 throwOnError: true,
788 }))
789β
790 return (
791 <div>
792 <button onClick={() => mutation.mutate()}>mutate</button>
793 </div>
794 )
795 }
796β
797 const rendered = render(() => (
798 <QueryClientProvider client={queryClient}>
799 <ErrorBoundary
800 fallback={() => (
801 <div>
802 <span>error</span>
803 </div>
804 )}
805 >
806 <Page />
807 </ErrorBoundary>
808 </QueryClientProvider>
809 ))
810β
811 fireEvent.click(rendered.getByText('mutate'))
812 await vi.advanceTimersByTimeAsync(0)
813 expect(rendered.queryByText('error')).not.toBeNull()
814β
815 consoleMock.mockRestore()
816 })
817β
818 it('should be able to throw an error when throwOnError is a function that returns true', async () => {
819 const consoleMock = vi
820 .spyOn(console, 'error')
821 .mockImplementation(() => undefined)
822β
823 let boundary = false
824 function Page() {
825 const mutation = useMutation<string, Error>(() => ({
826 mutationFn: () => {
827 const err = new Error('mock error')
828 err.stack = ''
829 return Promise.reject(err)
830 },
831 throwOnError: () => {
832 boundary = !boundary
833 return !boundary
834 },
835 }))
836β
837 return (
838 <div>
839 <button onClick={() => mutation.mutate()}>mutate</button>
840 {mutation.error && mutation.error.message}
841 </div>
842 )
843 }
844β
845 const rendered = render(() => (
846 <QueryClientProvider client={queryClient}>
847 <ErrorBoundary
848 fallback={() => (
849 <div>
850 <span>error boundary</span>
851 </div>
852 )}
853 >
854 <Page />
855 </ErrorBoundary>
856 </QueryClientProvider>
857 ))
858β
859 // first error goes to component
860 fireEvent.click(rendered.getByText('mutate'))
861 await vi.advanceTimersByTimeAsync(0)
862 expect(rendered.queryByText('mock error')).not.toBeNull()
863β
864 // second error goes to boundary
865 fireEvent.click(rendered.getByText('mutate'))
866 await vi.advanceTimersByTimeAsync(0)
867 expect(rendered.queryByText('error boundary')).not.toBeNull()
868β
869 consoleMock.mockRestore()
870 })
871β
872 it('should pass meta to mutation', async () => {
873 const errorMock = vi.fn()
874 const successMock = vi.fn()
875β
876 const queryClientMutationMeta = new QueryClient({
877 mutationCache: new MutationCache({
878 onSuccess: (_, __, ___, mutation) => {
879 successMock(mutation.meta?.metaSuccessMessage)
880 },
881 onError: (_, __, ___, mutation) => {
882 errorMock(mutation.meta?.metaErrorMessage)
883 },
884 }),
885 })
886β
887 const metaSuccessMessage = 'mutation succeeded'
888 const metaErrorMessage = 'mutation failed'
889β
890 function Page() {
891 const mutationSucceed = useMutation(() => ({
892 mutationFn: () => Promise.resolve(''),
893 meta: { metaSuccessMessage },
894 }))
895 const mutationError = useMutation(() => ({
896 mutationFn: () => {
897 throw new Error('')
898 },
899 meta: { metaErrorMessage },
900 }))
901β
902 return (
903 <div>
904 <button onClick={() => mutationSucceed.mutate()}>succeed</button>
905 <button onClick={() => mutationError.mutate()}>error</button>
906 {mutationSucceed.isSuccess && <div>successTest</div>}
907 {mutationError.isError && <div>errorTest</div>}
908 </div>
909 )
910 }
911β
912 const rendered = render(() => (
913 <QueryClientProvider client={queryClientMutationMeta}>
914 <Page />
915 </QueryClientProvider>
916 ))
917β
918 fireEvent.click(rendered.getByText('succeed'))
919 fireEvent.click(rendered.getByText('error'))
920 await vi.advanceTimersByTimeAsync(0)
921 expect(rendered.queryByText('successTest')).not.toBeNull()
922 expect(rendered.queryByText('errorTest')).not.toBeNull()
923β
924 expect(successMock).toHaveBeenCalledTimes(1)
925 expect(successMock).toHaveBeenCalledWith(metaSuccessMessage)
926β
927 expect(errorMock).toHaveBeenCalledTimes(1)
928 expect(errorMock).toHaveBeenCalledWith(metaErrorMessage)
929 })
930β
931 it('should call cache callbacks when unmounted', async () => {
932 const onSuccess = vi.fn()
933 const onSuccessMutate = vi.fn()
934 const onSettled = vi.fn()
935 const onSettledMutate = vi.fn()
936 const mutationKey = queryKey()
937 let count = 0
938β
939 function Page() {
940 const [show, setShow] = createSignal(true)
941 return (
942 <div>
943 <button onClick={() => setShow(false)}>hide</button>
944 {show() && <Component />}
945 </div>
946 )
947 }
948β
949 function Component() {
950 const mutation = useMutation(() => ({
951 mutationFn: async (_text: string) => {
952 count++
953 await sleep(10)
954 return count
955 },
956 mutationKey: mutationKey,
957 gcTime: 0,
958 onSuccess,
959 onSettled,
960 }))
961β
962 return (
963 <div>
964 <button
965 onClick={() =>
966 mutation.mutate('todo', {
967 onSuccess: onSuccessMutate,
968 onSettled: onSettledMutate,
969 })
970 }
971 >
972 mutate
973 </button>
974 <div>
975 data: {mutation.data ?? 'null'}, status: {mutation.status},
976 isPaused: {String(mutation.isPaused)}
977 </div>
978 </div>
979 )
980 }
981β
982 const rendered = render(() => (
983 <QueryClientProvider client={queryClient}>
984 <Page />
985 </QueryClientProvider>
986 ))
987β
988 await rendered.findByText('data: null, status: idle, isPaused: false')
989β
990 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
991 fireEvent.click(rendered.getByRole('button', { name: /hide/i }))
992 await vi.advanceTimersByTimeAsync(10)
993 expect(
994 queryClient.getMutationCache().findAll({ mutationKey: mutationKey }),
995 ).toHaveLength(0)
996 expect(count).toBe(1)
997β
998 expect(onSuccess).toHaveBeenCalledTimes(1)
999 expect(onSettled).toHaveBeenCalledTimes(1)
1000 expect(onSuccessMutate).toHaveBeenCalledTimes(0)
1001 expect(onSettledMutate).toHaveBeenCalledTimes(0)
1002 })
1003β
1004 it('should call mutate callbacks only for the last observer', async () => {
1005 const onSuccess = vi.fn()
1006 const onSuccessMutate = vi.fn()
1007 const onSettled = vi.fn()
1008 const onSettledMutate = vi.fn()
1009 let count = 0
1010β
1011 function Page() {
1012 const mutation = useMutation(() => ({
1013 mutationFn: async (_text: string) => {
1014 count++
1015 await sleep(10)
1016 return `result${count}`
1017 },
1018 onSuccess,
1019 onSettled,
1020 }))
1021β
1022 return (
1023 <div>
1024 <button
1025 onClick={() =>
1026 mutation.mutate('todo', {
1027 onSuccess: onSuccessMutate,
1028 onSettled: onSettledMutate,
1029 })
1030 }
1031 >
1032 mutate
1033 </button>
1034 <div>
1035 data: {mutation.data ?? 'null'}, status: {mutation.status}
1036 </div>
1037 </div>
1038 )
1039 }
1040β
1041 const rendered = render(() => (
1042 <QueryClientProvider client={queryClient}>
1043 <Page />
1044 </QueryClientProvider>
1045 ))
1046β
1047 await rendered.findByText('data: null, status: idle')
1048β
1049 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
1050 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
1051β
1052 await vi.advanceTimersByTimeAsync(10)
1053 await rendered.findByText('data: result2, status: success')
1054β
1055 expect(count).toBe(2)
1056β
1057 expect(onSuccess).toHaveBeenCalledTimes(2)
1058 expect(onSettled).toHaveBeenCalledTimes(2)
1059 expect(onSuccessMutate).toHaveBeenCalledTimes(1)
1060 expect(onSuccessMutate).toHaveBeenCalledWith('result2', 'todo', undefined, {
1061 client: queryClient,
1062 meta: undefined,
1063 mutationKey: undefined,
1064 })
1065 expect(onSettledMutate).toHaveBeenCalledTimes(1)
1066 expect(onSettledMutate).toHaveBeenCalledWith(
1067 'result2',
1068 null,
1069 'todo',
1070 undefined,
1071 {
1072 client: queryClient,
1073 meta: undefined,
1074 mutationKey: undefined,
1075 },
1076 )
1077 })
1078β
1079 it('should go to error state if onSuccess callback errors', async () => {
1080 const error = new Error('error from onSuccess')
1081 const onError = vi.fn()
1082β
1083 function Page() {
1084 const mutation = useMutation(() => ({
1085 mutationFn: async (_text: string) => {
1086 await sleep(10)
1087 return 'result'
1088 },
1089 onSuccess: () => Promise.reject(error),
1090 onError,
1091 }))
1092β
1093 return (
1094 <div>
1095 <button onClick={() => mutation.mutate('todo')}>mutate</button>
1096 <div>status: {mutation.status}</div>
1097 </div>
1098 )
1099 }
1100β
1101 const rendered = render(() => (
1102 <QueryClientProvider client={queryClient}>
1103 <Page />
1104 </QueryClientProvider>
1105 ))
1106β
1107 await rendered.findByText('status: idle')
1108β
1109 rendered.getByRole('button', { name: /mutate/i }).click()
1110β
1111 await vi.advanceTimersByTimeAsync(10)
1112 await rendered.findByText('status: error')
1113β
1114 expect(onError).toHaveBeenCalledWith(error, 'todo', undefined, {
1115 client: queryClient,
1116 meta: undefined,
1117 mutationKey: undefined,
1118 })
1119 })
1120β
1121 it('should go to error state if onError callback errors', async () => {
1122 const error = new Error('error from onError')
1123 const mutateFnError = new Error('mutateFnError')
1124β
1125 function Page() {
1126 const mutation = useMutation(() => ({
1127 mutationFn: async (_text: string) => {
1128 await sleep(10)
1129 throw mutateFnError
1130 },
1131 onError: () => Promise.reject(error),
1132 }))
1133β
1134 return (
1135 <div>
1136 <button onClick={() => mutation.mutate('todo')}>mutate</button>
1137 <div>
1138 error:{' '}
1139 {mutation.error instanceof Error ? mutation.error.message : 'null'},
1140 status: {mutation.status}
1141 </div>
1142 </div>
1143 )
1144 }
1145β
1146 const rendered = render(() => (
1147 <QueryClientProvider client={queryClient}>
1148 <Page />
1149 </QueryClientProvider>
1150 ))
1151β
1152 await vi.advanceTimersByTimeAsync(10)
1153 expect(rendered.getByText('error: null, status: idle')).toBeInTheDocument()
1154β
1155 rendered.getByRole('button', { name: /mutate/i }).click()
1156 await vi.advanceTimersByTimeAsync(10)
1157 expect(
1158 rendered.getByText('error: mutateFnError, status: error'),
1159 ).toBeInTheDocument()
1160 })
1161β
1162 it('should go to error state if onSettled callback errors', async () => {
1163 const error = new Error('error from onSettled')
1164 const mutateFnError = new Error('mutateFnError')
1165 const onError = vi.fn()
1166β
1167 function Page() {
1168 const mutation = useMutation(() => ({
1169 mutationFn: async (_text: string) => {
1170 await sleep(10)
1171 throw mutateFnError
1172 },
1173 onSettled: () => Promise.reject(error),
1174 onError,
1175 }))
1176β
1177 return (
1178 <div>
1179 <button onClick={() => mutation.mutate('todo')}>mutate</button>
1180 <div>
1181 error:{' '}
1182 {mutation.error instanceof Error ? mutation.error.message : 'null'},
1183 status: {mutation.status}
1184 </div>
1185 </div>
1186 )
1187 }
1188β
1189 const rendered = render(() => (
1190 <QueryClientProvider client={queryClient}>
1191 <Page />
1192 </QueryClientProvider>
1193 ))
1194β
1195 expect(rendered.getByText('error: null, status: idle')).toBeInTheDocument()
1196β
1197 rendered.getByRole('button', { name: /mutate/i }).click()
1198 await vi.advanceTimersByTimeAsync(10)
1199 expect(
1200 rendered.getByText('error: mutateFnError, status: error'),
1201 ).toBeInTheDocument()
1202β
1203 expect(onError).toHaveBeenCalledWith(mutateFnError, 'todo', undefined, {
1204 client: queryClient,
1205 meta: undefined,
1206 mutationKey: undefined,
1207 })
1208 })
1209β
1210 it('should use provided custom queryClient', async () => {
1211 function Page() {
1212 const mutation = useMutation(
1213 () => ({
1214 mutationFn: async (text: string) => {
1215 return Promise.resolve(text)
1216 },
1217 }),
1218 () => queryClient,
1219 )
1220β
1221 return (
1222 <div>
1223 <button onClick={() => mutation.mutate('custom client')}>
1224 mutate
1225 </button>
1226 <div>
1227 data: {mutation.data ?? 'null'}, status: {mutation.status}
1228 </div>
1229 </div>
1230 )
1231 }
1232β
1233 const rendered = render(() => <Page></Page>)
1234β
1235 expect(rendered.getByText('data: null, status: idle')).toBeInTheDocument()
1236β
1237 fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
1238 await vi.advanceTimersByTimeAsync(0)
1239 expect(
1240 rendered.getByText('data: custom client, status: success'),
1241 ).toBeInTheDocument()
1242 })
1243})