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