@tanstack/query-core 5.0.0-alpha.3 → 5.0.0-alpha.32

package/src/tests/queryClient.test.tsx

@@ -1,7 +1,12 @@
 import { waitFor } from '@testing-library/react'
 import '@testing-library/jest-dom'
 
-import { sleep, queryKey, createQueryClient } from './utils'
+import {
+  sleep,
+  queryKey,
+  createQueryClient,
+  mockNavigatorOnLine,
+} from './utils'
 import type {
   QueryCache,
   QueryClient,
@@ -11,6 +16,7 @@ import type {
 import { MutationObserver, QueryObserver } from '..'
 import { focusManager, onlineManager } from '..'
 import { noop } from '../utils'
+import { vi } from 'vitest'
 
 describe('queryClient', () => {
   let queryClient: QueryClient
@@ -223,7 +229,7 @@ describe('queryClient', () => {
     test('should accept an update function', () => {
       const key = queryKey()
 
-      const updater = jest.fn((oldData) => `new data + ${oldData}`)
+      const updater = vi.fn((oldData) => `new data + ${oldData}`)
 
       queryClient.setQueryData(key, 'test data')
       queryClient.setQueryData(key, updater)
@@ -802,7 +808,7 @@ describe('queryClient', () => {
   describe('refetchQueries', () => {
     test('should not refetch if all observers are disabled', async () => {
       const key = queryKey()
-      const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+      const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
       await queryClient.fetchQuery({ queryKey: key, queryFn })
       const observer1 = new QueryObserver(queryClient, {
         queryKey: key,
@@ -816,7 +822,7 @@ describe('queryClient', () => {
     })
     test('should refetch if at least one observer is enabled', async () => {
       const key = queryKey()
-      const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+      const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
       await queryClient.fetchQuery({ queryKey: key, queryFn })
       const observer1 = new QueryObserver(queryClient, {
         queryKey: key,
@@ -838,8 +844,8 @@ describe('queryClient', () => {
     test('should refetch all queries when no arguments are given', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer1 = new QueryObserver(queryClient, {
@@ -864,8 +870,8 @@ describe('queryClient', () => {
     test('should be able to refetch all fresh queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -883,8 +889,8 @@ describe('queryClient', () => {
     test('should be able to refetch all stale queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -903,8 +909,8 @@ describe('queryClient', () => {
     test('should be able to refetch all stale and active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       queryClient.invalidateQueries({ queryKey: key1 })
@@ -925,8 +931,8 @@ describe('queryClient', () => {
     test('should be able to refetch all active and inactive queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -944,8 +950,8 @@ describe('queryClient', () => {
     test('should be able to refetch all active and inactive queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -963,8 +969,8 @@ describe('queryClient', () => {
     test('should be able to refetch only active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -982,8 +988,8 @@ describe('queryClient', () => {
     test('should be able to refetch only inactive queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1019,14 +1025,41 @@ describe('queryClient', () => {
       }
       expect(error).toEqual('error')
     })
+
+    test('should resolve Promise immediately if query is paused', async () => {
+      const key1 = queryKey()
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
+      const onlineMock = mockNavigatorOnLine(false)
+
+      await queryClient.refetchQueries({ queryKey: key1 })
+
+      // if we reach this point, the test succeeds because the Promise was resolved immediately
+      expect(queryFn1).toHaveBeenCalledTimes(1)
+      onlineMock.mockRestore()
+    })
+
+    test('should refetch if query we are offline but query networkMode is always', async () => {
+      const key1 = queryKey()
+      queryClient.setQueryDefaults(key1, { networkMode: 'always' })
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
+      const onlineMock = mockNavigatorOnLine(false)
+
+      await queryClient.refetchQueries({ queryKey: key1 })
+
+      // initial fetch + refetch (even though we are offline)
+      expect(queryFn1).toHaveBeenCalledTimes(2)
+      onlineMock.mockRestore()
+    })
   })
 
   describe('invalidateQueries', () => {
     test('should refetch active queries by default', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1044,8 +1077,8 @@ describe('queryClient', () => {
     test('should not refetch inactive queries by default', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1063,8 +1096,8 @@ describe('queryClient', () => {
     test('should not refetch active queries when "refetch" is "none"', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1085,8 +1118,8 @@ describe('queryClient', () => {
     test('should refetch inactive queries when "refetch" is "inactive"', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1109,8 +1142,8 @@ describe('queryClient', () => {
     test('should refetch active and inactive queries when "refetch" is "all"', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1129,7 +1162,7 @@ describe('queryClient', () => {
 
     test('should cancel ongoing fetches if cancelRefetch option is set (default value)', async () => {
       const key = queryKey()
-      const abortFn = jest.fn()
+      const abortFn = vi.fn()
       let fetchCount = 0
       const observer = new QueryObserver(queryClient, {
         queryKey: key,
@@ -1152,7 +1185,7 @@ describe('queryClient', () => {
 
     test('should not cancel ongoing fetches if cancelRefetch option is set to false', async () => {
       const key = queryKey()
-      const abortFn = jest.fn()
+      const abortFn = vi.fn()
       let fetchCount = 0
       const observer = new QueryObserver(queryClient, {
         queryKey: key,
@@ -1178,7 +1211,7 @@ describe('queryClient', () => {
     test('should notify listeners when a query is reset', async () => {
       const key = queryKey()
 
-      const callback = jest.fn()
+      const callback = vi.fn()
 
       await queryClient.prefetchQuery({ queryKey: key, queryFn: () => 'data' })
 
@@ -1231,8 +1264,8 @@ describe('queryClient', () => {
     test('should refetch all active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       const observer1 = new QueryObserver(queryClient, {
         queryKey: key1,
         queryFn: queryFn1,
@@ -1258,15 +1291,15 @@ describe('queryClient', () => {
       const testClient = createQueryClient()
       testClient.mount()
 
-      const queryCacheOnFocusSpy = jest.spyOn(
+      const queryCacheOnFocusSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onFocus',
       )
-      const queryCacheOnOnlineSpy = jest.spyOn(
+      const queryCacheOnOnlineSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onOnline',
       )
-      const mutationCacheResumePausedMutationsSpy = jest.spyOn(
+      const mutationCacheResumePausedMutationsSpy = vi.spyOn(
         testClient.getMutationCache(),
         'resumePausedMutations',
       )
@@ -1291,15 +1324,15 @@ describe('queryClient', () => {
       const testClient = createQueryClient()
       testClient.mount()
 
-      const queryCacheOnFocusSpy = jest.spyOn(
+      const queryCacheOnFocusSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onFocus',
       )
-      const queryCacheOnOnlineSpy = jest.spyOn(
+      const queryCacheOnOnlineSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onOnline',
       )
-      const mutationCacheResumePausedMutationsSpy = jest.spyOn(
+      const mutationCacheResumePausedMutationsSpy = vi.spyOn(
         testClient.getMutationCache(),
         'resumePausedMutations',
       )
@@ -1321,7 +1354,7 @@ describe('queryClient', () => {
     })
 
     test('should resume paused mutations when coming online', async () => {
-      const consoleMock = jest.spyOn(console, 'error')
+      const consoleMock = vi.spyOn(console, 'error')
       consoleMock.mockImplementation(() => undefined)
       onlineManager.setOnline(false)
 
@@ -1351,7 +1384,7 @@ describe('queryClient', () => {
     })
 
     test('should resume paused mutations one after the other when invoked manually at the same time', async () => {
-      const consoleMock = jest.spyOn(console, 'error')
+      const consoleMock = vi.spyOn(console, 'error')
       consoleMock.mockImplementation(() => undefined)
       onlineManager.setOnline(false)
 
@@ -1401,15 +1434,15 @@ describe('queryClient', () => {
       testClient.mount()
       testClient.unmount()
 
-      const queryCacheOnFocusSpy = jest.spyOn(
+      const queryCacheOnFocusSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onFocus',
       )
-      const queryCacheOnOnlineSpy = jest.spyOn(
+      const queryCacheOnOnlineSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onOnline',
       )
-      const mutationCacheResumePausedMutationsSpy = jest.spyOn(
+      const mutationCacheResumePausedMutationsSpy = vi.spyOn(
         testClient.getMutationCache(),
         'resumePausedMutations',
       )
@@ -1436,15 +1469,15 @@ describe('queryClient', () => {
       testClient.unmount()
       testClient.unmount()
 
-      const queryCacheOnFocusSpy = jest.spyOn(
+      const queryCacheOnFocusSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onFocus',
       )
-      const queryCacheOnOnlineSpy = jest.spyOn(
+      const queryCacheOnOnlineSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onOnline',
       )
-      const mutationCacheResumePausedMutationsSpy = jest.spyOn(
+      const mutationCacheResumePausedMutationsSpy = vi.spyOn(
         testClient.getMutationCache(),
         'resumePausedMutations',
       )

package/src/tests/queryObserver.test.tsx

@@ -1,6 +1,7 @@
 import { sleep, queryKey, expectType, createQueryClient } from './utils'
 import type { QueryClient, QueryObserverResult } from '..'
 import { QueryObserver, focusManager } from '..'
+import { vi } from 'vitest'
 
 describe('queryObserver', () => {
   let queryClient: QueryClient
@@ -16,7 +17,7 @@ describe('queryObserver', () => {
 
   test('should trigger a fetch when subscribed', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     const observer = new QueryObserver(queryClient, { queryKey: key, queryFn })
     const unsubscribe = observer.subscribe(() => undefined)
     await sleep(1)
@@ -348,7 +349,7 @@ describe('queryObserver', () => {
 
   test('should not trigger a fetch when subscribed and disabled', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
       queryFn,
@@ -362,7 +363,7 @@ describe('queryObserver', () => {
 
   test('should not trigger a fetch when not subscribed', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     new QueryObserver(queryClient, { queryKey: key, queryFn })
     await sleep(1)
     expect(queryFn).toHaveBeenCalledTimes(0)
@@ -370,8 +371,8 @@ describe('queryObserver', () => {
 
   test('should be able to watch a query without defining a query function', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
-    const callback = jest.fn()
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+    const callback = vi.fn()
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
       enabled: false,
@@ -385,7 +386,7 @@ describe('queryObserver', () => {
 
   test('should accept unresolved query config in update function', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
       enabled: false,
@@ -407,7 +408,7 @@ describe('queryObserver', () => {
 
   test('should be able to handle multiple subscribers', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     const observer = new QueryObserver<string>(queryClient, {
       queryKey: key,
       enabled: false,
@@ -567,7 +568,7 @@ describe('queryObserver', () => {
 
   test('should not refetch in background if refetchIntervalInBackground is false', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
 
     focusManager.setFocused(false)
     const observer = new QueryObserver(queryClient, {
@@ -690,6 +691,127 @@ describe('queryObserver', () => {
     expect(observer.getCurrentResult().isPlaceholderData).toBe(false)
   })
 
+  test('should pass the correct previous queryKey (from prevQuery) to placeholderData function params with select', async () => {
+    const results: QueryObserverResult[] = []
+    const keys: Array<readonly unknown[] | null> = []
+
+    const key1 = queryKey()
+    const key2 = queryKey()
+
+    const data1 = { value: 'data1' }
+    const data2 = { value: 'data2' }
+
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key1,
+      queryFn: () => data1,
+      placeholderData: (prev, prevQuery) => {
+        keys.push(prevQuery?.queryKey || null)
+        return prev
+      },
+      select: (data) => data.value,
+    })
+
+    const unsubscribe = observer.subscribe((result) => {
+      results.push(result)
+    })
+
+    await sleep(1)
+
+    observer.setOptions({
+      queryKey: key2,
+      queryFn: () => data2,
+      placeholderData: (prev, prevQuery) => {
+        keys.push(prevQuery?.queryKey || null)
+        return prev
+      },
+      select: (data) => data.value,
+    })
+
+    await sleep(1)
+    unsubscribe()
+    expect(results.length).toBe(4)
+    expect(keys.length).toBe(3)
+    expect(keys[0]).toBe(null) // First Query - status: 'pending', fetchStatus: 'idle'
+    expect(keys[1]).toBe(null) // First Query - status: 'pending', fetchStatus: 'fetching'
+    expect(keys[2]).toBe(key1) // Second Query - status: 'pending', fetchStatus: 'fetching'
+
+    expect(results[0]).toMatchObject({
+      data: undefined,
+      status: 'pending',
+      fetchStatus: 'fetching',
+    }) // Initial fetch
+    expect(results[1]).toMatchObject({
+      data: 'data1',
+      status: 'success',
+      fetchStatus: 'idle',
+    }) // Successful fetch
+    expect(results[2]).toMatchObject({
+      data: 'data1',
+      status: 'success',
+      fetchStatus: 'fetching',
+    }) // Fetch for new key, but using previous data as placeholder
+    expect(results[3]).toMatchObject({
+      data: 'data2',
+      status: 'success',
+      fetchStatus: 'idle',
+    }) // Successful fetch for new key
+  })
+
+  test('should pass the correct previous data to placeholderData function params when select function is used in conjunction', async () => {
+    const results: QueryObserverResult[] = []
+
+    const key1 = queryKey()
+    const key2 = queryKey()
+
+    const data1 = { value: 'data1' }
+    const data2 = { value: 'data2' }
+
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key1,
+      queryFn: () => data1,
+      placeholderData: (prev) => prev,
+      select: (data) => data.value,
+    })
+
+    const unsubscribe = observer.subscribe((result) => {
+      results.push(result)
+    })
+
+    await sleep(1)
+
+    observer.setOptions({
+      queryKey: key2,
+      queryFn: () => data2,
+      placeholderData: (prev) => prev,
+      select: (data) => data.value,
+    })
+
+    await sleep(1)
+    unsubscribe()
+
+    expect(results.length).toBe(4)
+    expect(results[0]).toMatchObject({
+      data: undefined,
+      status: 'pending',
+      fetchStatus: 'fetching',
+    }) // Initial fetch
+    expect(results[1]).toMatchObject({
+      data: 'data1',
+      status: 'success',
+      fetchStatus: 'idle',
+    }) // Successful fetch
+    expect(results[2]).toMatchObject({
+      data: 'data1',
+      status: 'success',
+      fetchStatus: 'fetching',
+    }) // Fetch for new key, but using previous data as placeholder
+    expect(results[3]).toMatchObject({
+      data: 'data2',
+      status: 'success',
+      fetchStatus: 'idle',
+    }) // Successful fetch for new key
+  })
+
   test('setOptions should notify cache listeners', async () => {
     const key = queryKey()
 
@@ -697,7 +819,7 @@ describe('queryObserver', () => {
       queryKey: key,
     })
 
-    const spy = jest.fn()
+    const spy = vi.fn()
     const unsubscribe = queryClient.getQueryCache().subscribe(spy)
     observer.setOptions({ enabled: false })
 

package/src/tests/utils.test.tsx

@@ -11,6 +11,7 @@ import {
 } from '../utils'
 import { Mutation } from '../mutation'
 import { createQueryClient } from './utils'
+import { vi } from 'vitest'
 
 describe('core/utils', () => {
   describe('isPlainObject', () => {
@@ -343,7 +344,7 @@ describe('core/utils', () => {
 
   describe('scheduleMicrotask', () => {
     it('should defer execution of callback', async () => {
-      const callback = jest.fn()
+      const callback = vi.fn()
 
       scheduleMicrotask(callback)
       expect(callback).not.toHaveBeenCalled()

package/src/tests/utils.ts

@@ -1,7 +1,8 @@
 import { act } from '@testing-library/react'
+import { vi } from 'vitest'
 
-import type { MutationOptions, QueryClientConfig } from '@tanstack/query-core'
-import { QueryClient } from '@tanstack/query-core'
+import type { MutationOptions, QueryClientConfig } from '..'
+import { QueryClient } from '..'
 import * as utils from '../utils'
 
 export function createQueryClient(config?: QueryClientConfig): QueryClient {
@@ -9,11 +10,11 @@ export function createQueryClient(config?: QueryClientConfig): QueryClient {
 }
 
 export function mockVisibilityState(value: DocumentVisibilityState) {
-  return jest.spyOn(document, 'visibilityState', 'get').mockReturnValue(value)
+  return vi.spyOn(document, 'visibilityState', 'get').mockReturnValue(value)
 }
 
 export function mockNavigatorOnLine(value: boolean) {
-  return jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(value)
+  return vi.spyOn(navigator, 'onLine', 'get').mockReturnValue(value)
 }
 
 let queryKeyCount = 0