@tanstack/query-core 5.0.0-alpha.2 → 5.0.0-alpha.21

package/src/tests/mutations.test.tsx

@@ -2,6 +2,8 @@ import type { QueryClient } from '..'
 import { createQueryClient, executeMutation, queryKey, sleep } from './utils'
 import type { MutationState } from '../mutation'
 import { MutationObserver } from '../mutationObserver'
+import { vi } from 'vitest'
+import { waitFor } from '@testing-library/react'
 
 describe('mutations', () => {
   let queryClient: QueryClient
@@ -32,7 +34,7 @@ describe('mutations', () => {
 
   test('setMutationDefaults should be able to set defaults', async () => {
     const key = queryKey()
-    const fn = jest.fn()
+    const fn = vi.fn()
 
     queryClient.setMutationDefaults(key, {
       mutationFn: fn,
@@ -249,9 +251,9 @@ describe('mutations', () => {
   test('should be able to restore a mutation', async () => {
     const key = queryKey()
 
-    const onMutate = jest.fn()
-    const onSuccess = jest.fn()
-    const onSettled = jest.fn()
+    const onMutate = vi.fn()
+    const onSuccess = vi.fn()
+    const onSettled = vi.fn()
 
     queryClient.setMutationDefaults(key, {
       mutationFn: async (text: string) => text,
@@ -316,7 +318,7 @@ describe('mutations', () => {
     const observer = new MutationObserver(queryClient, {})
     const currentMutation = mutationCache.build(queryClient, {})
 
-    const fn = jest.fn()
+    const fn = vi.fn()
 
     const unsubscribe = mutationCache.subscribe((event) => {
       fn(event.type)
@@ -347,8 +349,8 @@ describe('mutations', () => {
   })
 
   test('mutate update the mutation state even without an active subscription', async () => {
-    const onSuccess = jest.fn()
-    const onSettled = jest.fn()
+    const onSuccess = vi.fn()
+    const onSettled = vi.fn()
 
     const mutation = new MutationObserver(queryClient, {
       mutationFn: async () => {
@@ -363,8 +365,8 @@ describe('mutations', () => {
   })
 
   test('mutate update the mutation state even without an active subscription', async () => {
-    const onSuccess = jest.fn()
-    const onSettled = jest.fn()
+    const onSuccess = vi.fn()
+    const onSettled = vi.fn()
 
     const mutation = new MutationObserver(queryClient, {
       mutationFn: async () => {
@@ -377,4 +379,34 @@ describe('mutations', () => {
     expect(onSuccess).not.toHaveBeenCalled()
     expect(onSettled).not.toHaveBeenCalled()
   })
+
+  test('mutation callbacks should see updated options', async () => {
+    const onSuccess = vi.fn()
+
+    const mutation = new MutationObserver(queryClient, {
+      mutationFn: async () => {
+        sleep(100)
+        return 'update'
+      },
+      onSuccess: () => {
+        onSuccess(1)
+      },
+    })
+
+    void mutation.mutate()
+
+    mutation.setOptions({
+      mutationFn: async () => {
+        sleep(100)
+        return 'update'
+      },
+      onSuccess: () => {
+        onSuccess(2)
+      },
+    })
+
+    await waitFor(() => expect(onSuccess).toHaveBeenCalledTimes(1))
+
+    expect(onSuccess).toHaveBeenCalledWith(2)
+  })
 })

package/src/tests/notifyManager.test.tsx

@@ -1,10 +1,11 @@
 import { createNotifyManager } from '../notifyManager'
 import { sleep } from './utils'
+import { vi } from 'vitest'
 
 describe('notifyManager', () => {
   it('should use default notifyFn', async () => {
     const notifyManagerTest = createNotifyManager()
-    const callbackSpy = jest.fn()
+    const callbackSpy = vi.fn()
     notifyManagerTest.schedule(callbackSpy)
     await sleep(1)
     expect(callbackSpy).toHaveBeenCalled()
@@ -12,13 +13,13 @@ describe('notifyManager', () => {
 
   it('should use default batchNotifyFn', async () => {
     const notifyManagerTest = createNotifyManager()
-    const callbackScheduleSpy = jest
+    const callbackScheduleSpy = vi
       .fn()
       .mockImplementation(async () => await sleep(20))
-    const callbackBatchLevel2Spy = jest.fn().mockImplementation(async () => {
+    const callbackBatchLevel2Spy = vi.fn().mockImplementation(async () => {
       notifyManagerTest.schedule(callbackScheduleSpy)
     })
-    const callbackBatchLevel1Spy = jest.fn().mockImplementation(async () => {
+    const callbackBatchLevel1Spy = vi.fn().mockImplementation(async () => {
       notifyManagerTest.batch(callbackBatchLevel2Spy)
     })
 
@@ -32,13 +33,13 @@ describe('notifyManager', () => {
 
   it('should notify if error is thrown', async () => {
     const notifyManagerTest = createNotifyManager()
-    const notifySpy = jest.fn()
+    const notifySpy = vi.fn()
 
     notifyManagerTest.setNotifyFunction(notifySpy)
 
     try {
       notifyManagerTest.batch(() => {
-        notifyManagerTest.schedule(jest.fn)
+        notifyManagerTest.schedule(vi.fn)
         throw new Error('Foo')
       })
     } catch {}

package/src/tests/onlineManager.test.tsx

@@ -1,5 +1,6 @@
 import { OnlineManager } from '../onlineManager'
 import { setIsServer, sleep } from './utils'
+import { vi } from 'vitest'
 
 describe('onlineManager', () => {
   let onlineManager: OnlineManager
@@ -8,7 +9,7 @@ describe('onlineManager', () => {
   })
 
   test('isOnline should return true if navigator is undefined', () => {
-    const navigatorSpy = jest.spyOn(globalThis, 'navigator', 'get')
+    const navigatorSpy = vi.spyOn(globalThis, 'navigator', 'get')
 
     // Force navigator to be undefined
     //@ts-expect-error
@@ -19,7 +20,7 @@ describe('onlineManager', () => {
   })
 
   test('isOnline should return true if navigator.onLine is true', () => {
-    const navigatorSpy = jest.spyOn(navigator, 'onLine', 'get')
+    const navigatorSpy = vi.spyOn(navigator, 'onLine', 'get')
     navigatorSpy.mockImplementation(() => true)
 
     expect(onlineManager.isOnline()).toBeTruthy()
@@ -46,8 +47,8 @@ describe('onlineManager', () => {
   })
 
   test('setEventListener should call previous remove handler when replacing an event listener', () => {
-    const remove1Spy = jest.fn()
-    const remove2Spy = jest.fn()
+    const remove1Spy = vi.fn()
+    const remove2Spy = vi.fn()
 
     onlineManager.setEventListener(() => remove1Spy)
     onlineManager.setEventListener(() => remove2Spy)
@@ -59,7 +60,7 @@ describe('onlineManager', () => {
   test('cleanup (removeEventListener) should not be called if window is not defined', async () => {
     const restoreIsServer = setIsServer(true)
 
-    const removeEventListenerSpy = jest.spyOn(globalThis, 'removeEventListener')
+    const removeEventListenerSpy = vi.spyOn(globalThis, 'removeEventListener')
 
     const unsubscribe = onlineManager.subscribe(() => undefined)
 
@@ -76,7 +77,7 @@ describe('onlineManager', () => {
     // @ts-expect-error
     globalThis.window.addEventListener = undefined
 
-    const removeEventListenerSpy = jest.spyOn(globalThis, 'removeEventListener')
+    const removeEventListenerSpy = vi.spyOn(globalThis, 'removeEventListener')
 
     const unsubscribe = onlineManager.subscribe(() => undefined)
 
@@ -88,12 +89,9 @@ describe('onlineManager', () => {
   })
 
   test('it should replace default window listener when a new event listener is set', async () => {
-    const addEventListenerSpy = jest.spyOn(
-      globalThis.window,
-      'addEventListener',
-    )
+    const addEventListenerSpy = vi.spyOn(globalThis.window, 'addEventListener')
 
-    const removeEventListenerSpy = jest.spyOn(
+    const removeEventListenerSpy = vi.spyOn(
       globalThis.window,
       'removeEventListener',
     )
@@ -116,12 +114,9 @@ describe('onlineManager', () => {
   })
 
   test('should call removeEventListener when last listener unsubscribes', () => {
-    const addEventListenerSpy = jest.spyOn(
-      globalThis.window,
-      'addEventListener',
-    )
+    const addEventListenerSpy = vi.spyOn(globalThis.window, 'addEventListener')
 
-    const removeEventListenerSpy = jest.spyOn(
+    const removeEventListenerSpy = vi.spyOn(
       globalThis.window,
       'removeEventListener',
     )
@@ -137,7 +132,7 @@ describe('onlineManager', () => {
   })
 
   test('should keep setup function even if last listener unsubscribes', () => {
-    const setupSpy = jest.fn().mockImplementation(() => () => undefined)
+    const setupSpy = vi.fn().mockImplementation(() => () => undefined)
 
     onlineManager.setEventListener(setupSpy)
 

package/src/tests/queriesObserver.test.tsx

@@ -2,6 +2,7 @@ import { waitFor } from '@testing-library/react'
 import { sleep, queryKey, createQueryClient } from './utils'
 import type { QueryClient, QueryObserverResult } from '..'
 import { QueriesObserver } from '..'
+import { vi } from 'vitest'
 
 describe('queriesObserver', () => {
   let queryClient: QueryClient
@@ -18,8 +19,8 @@ describe('queriesObserver', () => {
   test('should return an array with all query results', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -34,11 +35,11 @@ describe('queriesObserver', () => {
   })
 
   test('should still return value for undefined query key', async () => {
-    const consoleMock = jest.spyOn(console, 'error')
+    const consoleMock = vi.spyOn(console, 'error')
     consoleMock.mockImplementation(() => undefined)
     const key1 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: undefined, queryFn: queryFn2 },
@@ -61,8 +62,8 @@ describe('queriesObserver', () => {
   test('should update when a query updates', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -106,8 +107,8 @@ describe('queriesObserver', () => {
   test('should update when a query is removed', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -153,8 +154,8 @@ describe('queriesObserver', () => {
   test('should update when a query changed position', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -201,8 +202,8 @@ describe('queriesObserver', () => {
   test('should not update when nothing has changed', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -245,8 +246,8 @@ describe('queriesObserver', () => {
   test('should trigger all fetches when subscribed', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -270,8 +271,8 @@ describe('queriesObserver', () => {
       },
     ])
 
-    const subscription1Handler = jest.fn()
-    const subscription2Handler = jest.fn()
+    const subscription1Handler = vi.fn()
+    const subscription2Handler = vi.fn()
 
     const unsubscribe1 = observer.subscribe(subscription1Handler)
     const unsubscribe2 = observer.subscribe(subscription2Handler)

package/src/tests/query.test.tsx

@@ -12,6 +12,7 @@ import type {
 } from '..'
 import { QueryObserver, isCancelledError, onlineManager } from '..'
 import { waitFor } from '@testing-library/react'
+import { vi } from 'vitest'
 
 describe('query', () => {
   let queryClient: QueryClient
@@ -186,10 +187,10 @@ describe('query', () => {
   test('should provide context to queryFn', async () => {
     const key = queryKey()
 
-    const queryFn = jest
+    const queryFn = vi
       .fn<
-        Promise<'data'>,
-        [QueryFunctionContext<ReturnType<typeof queryKey>>]
+        [QueryFunctionContext<ReturnType<typeof queryKey>>],
+        Promise<'data'>
       >()
       .mockResolvedValue('data')
 
@@ -273,12 +274,12 @@ describe('query', () => {
   test('should provide an AbortSignal to the queryFn that provides info about the cancellation state', async () => {
     const key = queryKey()
 
-    const queryFn = jest.fn<
-      Promise<unknown>,
-      [QueryFunctionContext<ReturnType<typeof queryKey>>]
+    const queryFn = vi.fn<
+      [QueryFunctionContext<ReturnType<typeof queryKey>>],
+      Promise<unknown>
     >()
-    const onAbort = jest.fn()
-    const abortListener = jest.fn()
+    const onAbort = vi.fn()
+    const abortListener = vi.fn()
     let error
 
     queryFn.mockImplementation(async ({ signal }) => {
@@ -323,7 +324,7 @@ describe('query', () => {
   test('should not continue if explicitly cancelled', async () => {
     const key = queryKey()
 
-    const queryFn = jest.fn<unknown, unknown[]>()
+    const queryFn = vi.fn<unknown[], unknown>()
 
     queryFn.mockImplementation(async () => {
       await sleep(10)
@@ -355,7 +356,7 @@ describe('query', () => {
   test('should not error if reset while pending', async () => {
     const key = queryKey()
 
-    const queryFn = jest.fn<unknown, unknown[]>()
+    const queryFn = vi.fn<unknown[], unknown>()
 
     queryFn.mockImplementation(async () => {
       await sleep(10)
@@ -382,7 +383,7 @@ describe('query', () => {
   test('should be able to refetch a cancelled query', async () => {
     const key = queryKey()
 
-    const queryFn = jest.fn<unknown, unknown[]>()
+    const queryFn = vi.fn<unknown[], unknown>()
 
     queryFn.mockImplementation(async () => {
       await sleep(50)
@@ -631,7 +632,7 @@ describe('query', () => {
       it: 'works',
     }
 
-    const queryFn = jest.fn(() => 'data')
+    const queryFn = vi.fn(() => 'data')
 
     const key = queryKey()
 
@@ -652,7 +653,7 @@ describe('query', () => {
       queryFn: () => 'data',
     })
 
-    const refetchSpy = jest.spyOn(observer, 'refetch')
+    const refetchSpy = vi.spyOn(observer, 'refetch')
     const unsubscribe = observer.subscribe(() => undefined)
     queryCache.onOnline()
 
@@ -692,7 +693,7 @@ describe('query', () => {
     })
     expect(query.getObserversCount()).toEqual(0)
 
-    const notifySpy = jest.spyOn(queryCache, 'notify')
+    const notifySpy = vi.spyOn(queryCache, 'notify')
     expect(() => query.removeObserver(observer)).not.toThrow()
     expect(notifySpy).not.toHaveBeenCalled()
 
@@ -769,7 +770,7 @@ describe('query', () => {
   })
 
   test('fetch should dispatch an error if the queryFn returns undefined', async () => {
-    const consoleMock = jest.spyOn(console, 'error')
+    const consoleMock = vi.spyOn(console, 'error')
     consoleMock.mockImplementation(() => undefined)
     const key = queryKey()
 
@@ -804,7 +805,7 @@ describe('query', () => {
   test('constructor should call initialDataUpdatedAt if defined as a function', async () => {
     const key = queryKey()
 
-    const initialDataUpdatedAtSpy = jest.fn()
+    const initialDataUpdatedAtSpy = vi.fn()
 
     await queryClient.prefetchQuery({
       queryKey: key,
@@ -821,7 +822,7 @@ describe('query', () => {
 
     queryClient.setQueryDefaults(key, { gcTime: 10 })
 
-    const fn = jest.fn()
+    const fn = vi.fn()
 
     const unsubscribe = queryClient.getQueryCache().subscribe(fn)
 

package/src/tests/queryCache.test.tsx

@@ -2,6 +2,7 @@ import { sleep, queryKey, createQueryClient } from './utils'
 import { QueryClient } from '..'
 import { QueryCache, QueryObserver } from '..'
 import { waitFor } from '@testing-library/react'
+import { vi } from 'vitest'
 
 describe('queryCache', () => {
   let queryClient: QueryClient
@@ -19,7 +20,7 @@ describe('queryCache', () => {
   describe('subscribe', () => {
     test('should pass the correct query', async () => {
       const key = queryKey()
-      const subscriber = jest.fn()
+      const subscriber = vi.fn()
       const unsubscribe = queryCache.subscribe(subscriber)
       queryClient.setQueryData(key, 'foo')
       const query = queryCache.find({ queryKey: key })
@@ -30,7 +31,7 @@ describe('queryCache', () => {
 
     test('should notify listeners when new query is added', async () => {
       const key = queryKey()
-      const callback = jest.fn()
+      const callback = vi.fn()
       queryCache.subscribe(callback)
       queryClient.prefetchQuery({ queryKey: key, queryFn: () => 'data' })
       await sleep(100)
@@ -50,7 +51,7 @@ describe('queryCache', () => {
         staleTime: 10,
       })
 
-      const unsubScribeObserver = observer.subscribe(jest.fn)
+      const unsubScribeObserver = observer.subscribe(vi.fn())
 
       await waitFor(() => {
         expect(events.length).toBe(8)
@@ -73,7 +74,7 @@ describe('queryCache', () => {
 
     test('should include the queryCache and query when notifying listeners', async () => {
       const key = queryKey()
-      const callback = jest.fn()
+      const callback = vi.fn()
       queryCache.subscribe(callback)
       queryClient.prefetchQuery({ queryKey: key, queryFn: () => 'data' })
       const query = queryCache.find({ queryKey: key })
@@ -83,7 +84,7 @@ describe('queryCache', () => {
 
     test('should notify subscribers when new query with initialData is added', async () => {
       const key = queryKey()
-      const callback = jest.fn()
+      const callback = vi.fn()
       queryCache.subscribe(callback)
       queryClient.prefetchQuery({
         queryKey: key,
@@ -289,9 +290,9 @@ describe('queryCache', () => {
   describe('QueryCacheConfig error callbacks', () => {
     test('should call onError and onSettled when a query errors', async () => {
       const key = queryKey()
-      const onSuccess = jest.fn()
-      const onSettled = jest.fn()
-      const onError = jest.fn()
+      const onSuccess = vi.fn()
+      const onSettled = vi.fn()
+      const onError = vi.fn()
       const testCache = new QueryCache({ onSuccess, onError, onSettled })
       const testClient = createQueryClient({ queryCache: testCache })
       await testClient.prefetchQuery({
@@ -310,9 +311,9 @@ describe('queryCache', () => {
   describe('QueryCacheConfig success callbacks', () => {
     test('should call onSuccess and onSettled when a query is successful', async () => {
       const key = queryKey()
-      const onSuccess = jest.fn()
-      const onSettled = jest.fn()
-      const onError = jest.fn()
+      const onSuccess = vi.fn()
+      const onSettled = vi.fn()
+      const onError = vi.fn()
       const testCache = new QueryCache({ onSuccess, onError, onSettled })
       const testClient = createQueryClient({ queryCache: testCache })
       await testClient.prefetchQuery({
@@ -330,14 +331,14 @@ describe('queryCache', () => {
 
   describe('QueryCacheConfig.createStore', () => {
     test('should call createStore', async () => {
-      const createStore = jest.fn().mockImplementation(() => new Map())
+      const createStore = vi.fn().mockImplementation(() => new Map())
       new QueryCache({ createStore })
       expect(createStore).toHaveBeenCalledWith()
     })
 
     test('should use created store', async () => {
       const store = new Map()
-      const spy = jest.spyOn(store, 'get')
+      const spy = vi.spyOn(store, 'get')
 
       new QueryCache({ createStore: () => store }).get('key')