level_0
int64 0
10k
| index
int64 0
0
| repo_id
stringlengths 22
152
| file_path
stringlengths 41
203
| content
stringlengths 11
11.5M
|
|---|---|---|---|---|
3,881 | 0 | petrpan-code/TanStack/query/packages/query-core/src | petrpan-code/TanStack/query/packages/query-core/src/tests/queryClient.test.tsx | import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
import { waitFor } from '@testing-library/react'
import {
MutationObserver,
QueryObserver,
focusManager,
onlineManager,
} from '..'
import { noop } from '../utils'
import {
createQueryClient,
mockOnlineManagerIsOnline,
queryKey,
sleep,
} from './utils'
import type {
QueryCache,
QueryClient,
QueryFunction,
QueryObserverOptions,
} from '..'
describe('queryClient', () => {
let queryClient: QueryClient
let queryCache: QueryCache
beforeEach(() => {
queryClient = createQueryClient()
queryCache = queryClient.getQueryCache()
queryClient.mount()
})
afterEach(() => {
queryClient.clear()
queryClient.unmount()
})
describe('defaultOptions', () => {
test('should merge defaultOptions', async () => {
const key = queryKey()
const queryFn = () => 'data'
const testClient = createQueryClient({
defaultOptions: { queries: { queryFn } },
})
expect(() => testClient.prefetchQuery({ queryKey: key })).not.toThrow()
})
test('should merge defaultOptions when query is added to cache', async () => {
const key = queryKey()
const testClient = createQueryClient({
defaultOptions: {
queries: { gcTime: Infinity },
},
})
const fetchData = () => Promise.resolve('data')
await testClient.prefetchQuery({ queryKey: key, queryFn: fetchData })
const newQuery = testClient.getQueryCache().find({ queryKey: key })
expect(newQuery?.options.gcTime).toBe(Infinity)
})
test('should get defaultOptions', async () => {
const queryFn = () => 'data'
const defaultOptions = { queries: { queryFn } }
const testClient = createQueryClient({
defaultOptions,
})
expect(testClient.getDefaultOptions()).toMatchObject(defaultOptions)
})
})
describe('setQueryDefaults', () => {
test('should not trigger a fetch', async () => {
const key = queryKey()
queryClient.setQueryDefaults(key, { queryFn: () => 'data' })
await sleep(1)
const data = queryClient.getQueryData(key)
expect(data).toBeUndefined()
})
test('should be able to override defaults', async () => {
const key = queryKey()
queryClient.setQueryDefaults(key, { queryFn: () => 'data' })
const observer = new QueryObserver(queryClient, { queryKey: key })
const { data } = await observer.refetch()
expect(data).toBe('data')
})
test('should match the query key partially', async () => {
const key = queryKey()
queryClient.setQueryDefaults([key], { queryFn: () => 'data' })
const observer = new QueryObserver(queryClient, {
queryKey: [key, 'a'],
})
const { data } = await observer.refetch()
expect(data).toBe('data')
})
test('should not match if the query key is a subset', async () => {
const key = queryKey()
queryClient.setQueryDefaults([key, 'a'], {
queryFn: () => 'data',
})
const observer = new QueryObserver(queryClient, {
queryKey: [key],
retry: false,
enabled: false,
})
const { status } = await observer.refetch()
expect(status).toBe('error')
})
test('should also set defaults for observers', async () => {
const key = queryKey()
queryClient.setQueryDefaults(key, {
queryFn: () => 'data',
enabled: false,
})
const observer = new QueryObserver(queryClient, {
queryKey: [key],
})
expect(observer.getCurrentResult().status).toBe('pending')
expect(observer.getCurrentResult().fetchStatus).toBe('idle')
})
test('should update existing query defaults', async () => {
const key = queryKey()
const queryOptions1 = { queryFn: () => 'data' }
const queryOptions2 = { retry: false }
queryClient.setQueryDefaults(key, { ...queryOptions1 })
queryClient.setQueryDefaults(key, { ...queryOptions2 })
expect(queryClient.getQueryDefaults(key)).toMatchObject(queryOptions2)
})
test('should merge defaultOptions', async () => {
const key = queryKey()
queryClient.setQueryDefaults([...key, 'todo'], { suspense: true })
queryClient.setQueryDefaults([...key, 'todo', 'detail'], {
staleTime: 5000,
})
expect(
queryClient.getQueryDefaults([...key, 'todo', 'detail']),
).toMatchObject({ suspense: true, staleTime: 5000 })
})
})
describe('defaultQueryOptions', () => {
test('should default networkMode when persister is present', async () => {
expect(
createQueryClient({
defaultOptions: {
queries: {
persister: 'ignore' as any,
},
},
}).defaultQueryOptions({ queryKey: queryKey() }).networkMode,
).toBe('offlineFirst')
})
test('should not default networkMode without persister', async () => {
expect(
createQueryClient({
defaultOptions: {
queries: {
staleTime: 1000,
},
},
}).defaultQueryOptions({ queryKey: queryKey() }).networkMode,
).toBe(undefined)
})
test('should not default networkMode when already present', async () => {
expect(
createQueryClient({
defaultOptions: {
queries: {
persister: 'ignore' as any,
networkMode: 'always',
},
},
}).defaultQueryOptions({ queryKey: queryKey() }).networkMode,
).toBe('always')
})
})
describe('setQueryData', () => {
test('should not crash if query could not be found', () => {
const key = queryKey()
const user = { userId: 1 }
expect(() => {
queryClient.setQueryData([key, user], (prevUser?: typeof user) => ({
...prevUser!,
name: 'Edvin',
}))
}).not.toThrow()
})
test('should not crash when variable is null', () => {
const key = queryKey()
queryClient.setQueryData([key, { userId: null }], 'Old Data')
expect(() => {
queryClient.setQueryData([key, { userId: null }], 'New Data')
}).not.toThrow()
})
test('should use default options', () => {
const key = queryKey()
const testClient = createQueryClient({
defaultOptions: { queries: { queryKeyHashFn: () => 'someKey' } },
})
const testCache = testClient.getQueryCache()
testClient.setQueryData(key, 'data')
expect(testClient.getQueryData(key)).toBe('data')
expect(testCache.find({ queryKey: key })).toBe(testCache.get('someKey'))
})
test('should create a new query if query was not found', () => {
const key = queryKey()
queryClient.setQueryData(key, 'bar')
expect(queryClient.getQueryData(key)).toBe('bar')
})
test('should create a new query if query was not found', () => {
const key = queryKey()
queryClient.setQueryData(key, 'qux')
expect(queryClient.getQueryData(key)).toBe('qux')
})
test('should not create a new query if query was not found and data is undefined', () => {
const key = queryKey()
expect(queryClient.getQueryCache().find({ queryKey: key })).toBe(
undefined,
)
queryClient.setQueryData(key, undefined)
expect(queryClient.getQueryCache().find({ queryKey: key })).toBe(
undefined,
)
})
test('should not create a new query if query was not found and updater returns undefined', () => {
const key = queryKey()
expect(queryClient.getQueryCache().find({ queryKey: key })).toBe(
undefined,
)
queryClient.setQueryData(key, () => undefined)
expect(queryClient.getQueryCache().find({ queryKey: key })).toBe(
undefined,
)
})
test('should not update query data if data is undefined', () => {
const key = queryKey()
queryClient.setQueryData(key, 'qux')
queryClient.setQueryData(key, undefined)
expect(queryClient.getQueryData(key)).toBe('qux')
})
test('should not update query data if updater returns undefined', () => {
const key = queryKey()
queryClient.setQueryData<string>(key, 'qux')
queryClient.setQueryData<string>(key, () => undefined)
expect(queryClient.getQueryData(key)).toBe('qux')
})
test('should accept an update function', () => {
const key = queryKey()
const updater = vi.fn((oldData) => `new data + ${oldData}`)
queryClient.setQueryData(key, 'test data')
queryClient.setQueryData(key, updater)
expect(updater).toHaveBeenCalled()
expect(queryCache.find({ queryKey: key })!.state.data).toEqual(
'new data + test data',
)
})
test('should set the new data without comparison if structuralSharing is set to false', () => {
const key = queryKey()
queryClient.setDefaultOptions({
queries: {
structuralSharing: false,
},
})
const oldData = { value: true }
const newData = { value: true }
queryClient.setQueryData(key, oldData)
queryClient.setQueryData(key, newData)
expect(queryCache.find({ queryKey: key })!.state.data).toBe(newData)
})
test('should apply a custom structuralSharing function when provided', () => {
const key = queryKey()
const queryObserverOptions = {
structuralSharing: (
prevData: { value: Date } | undefined,
newData: { value: Date },
) => {
if (!prevData) {
return newData
}
return newData.value.getTime() === prevData.value.getTime()
? prevData
: newData
},
} as QueryObserverOptions
queryClient.setDefaultOptions({ queries: queryObserverOptions })
const oldData = { value: new Date(2022, 6, 19) }
const newData = { value: new Date(2022, 6, 19) }
queryClient.setQueryData(key, oldData)
queryClient.setQueryData(key, newData)
expect(queryCache.find({ queryKey: key })!.state.data).toBe(oldData)
const distinctData = { value: new Date(2021, 11, 25) }
queryClient.setQueryData(key, distinctData)
expect(queryCache.find({ queryKey: key })!.state.data).toBe(distinctData)
})
test('should not set isFetching to false', async () => {
const key = queryKey()
queryClient.prefetchQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 23
},
})
expect(queryClient.getQueryState(key)).toMatchObject({
data: undefined,
fetchStatus: 'fetching',
})
queryClient.setQueryData(key, 42)
expect(queryClient.getQueryState(key)).toMatchObject({
data: 42,
fetchStatus: 'fetching',
})
await waitFor(() =>
expect(queryClient.getQueryState(key)).toMatchObject({
data: 23,
fetchStatus: 'idle',
}),
)
})
})
describe('setQueriesData', () => {
test('should update all existing, matching queries', () => {
queryClient.setQueryData(['key', 1], 1)
queryClient.setQueryData(['key', 2], 2)
const result = queryClient.setQueriesData<number>(
{ queryKey: ['key'] },
(old) => (old ? old + 5 : undefined),
)
expect(result).toEqual([
[['key', 1], 6],
[['key', 2], 7],
])
expect(queryClient.getQueryData(['key', 1])).toBe(6)
expect(queryClient.getQueryData(['key', 2])).toBe(7)
})
test('should accept queryFilters', () => {
queryClient.setQueryData(['key', 1], 1)
queryClient.setQueryData(['key', 2], 2)
const query1 = queryCache.find({ queryKey: ['key', 1] })!
const result = queryClient.setQueriesData<number>(
{ predicate: (query) => query === query1 },
(old) => old! + 5,
)
expect(result).toEqual([[['key', 1], 6]])
expect(queryClient.getQueryData(['key', 1])).toBe(6)
expect(queryClient.getQueryData(['key', 2])).toBe(2)
})
test('should not update non existing queries', () => {
const result = queryClient.setQueriesData<string>(
{ queryKey: ['key'] },
'data',
)
expect(result).toEqual([])
expect(queryClient.getQueryData(['key'])).toBe(undefined)
})
})
describe('getQueryData', () => {
test('should return the query data if the query is found', () => {
const key = queryKey()
queryClient.setQueryData([key, 'id'], 'bar')
expect(queryClient.getQueryData([key, 'id'])).toBe('bar')
})
test('should return undefined if the query is not found', () => {
const key = queryKey()
expect(queryClient.getQueryData(key)).toBeUndefined()
})
test('should match exact by default', () => {
const key = queryKey()
queryClient.setQueryData([key, 'id'], 'bar')
expect(queryClient.getQueryData([key])).toBeUndefined()
})
})
describe('ensureQueryData', () => {
test('should return the cached query data if the query is found', async () => {
const key = queryKey()
const queryFn = () => Promise.resolve('data')
queryClient.setQueryData([key, 'id'], 'bar')
await expect(
queryClient.ensureQueryData({ queryKey: [key, 'id'], queryFn }),
).resolves.toEqual('bar')
})
test('should return the cached query data if the query is found and cached query data is falsey', async () => {
const key = queryKey()
const queryFn = () => Promise.resolve(0)
queryClient.setQueryData([key, 'id'], null)
await expect(
queryClient.ensureQueryData({ queryKey: [key, 'id'], queryFn }),
).resolves.toEqual(null)
})
test('should call fetchQuery and return its results if the query is not found', async () => {
const key = queryKey()
const queryFn = () => Promise.resolve('data')
await expect(
queryClient.ensureQueryData({ queryKey: [key], queryFn }),
).resolves.toEqual('data')
})
})
describe('getQueriesData', () => {
test('should return the query data for all matched queries', () => {
const key1 = queryKey()
const key2 = queryKey()
queryClient.setQueryData([key1, 1], 1)
queryClient.setQueryData([key1, 2], 2)
queryClient.setQueryData([key2, 2], 2)
expect(queryClient.getQueriesData({ queryKey: [key1] })).toEqual([
[[key1, 1], 1],
[[key1, 2], 2],
])
})
test('should return empty array if queries are not found', () => {
const key = queryKey()
expect(queryClient.getQueriesData({ queryKey: key })).toEqual([])
})
test('should accept query filters', () => {
queryClient.setQueryData(['key', 1], 1)
queryClient.setQueryData(['key', 2], 2)
const query1 = queryCache.find({ queryKey: ['key', 1] })!
const result = queryClient.getQueriesData({
predicate: (query) => query === query1,
})
expect(result).toEqual([[['key', 1], 1]])
})
})
describe('fetchQuery', () => {
test('should not type-error with strict query key', async () => {
type StrictData = 'data'
type StrictQueryKey = ['strict', ...ReturnType<typeof queryKey>]
const key: StrictQueryKey = ['strict', ...queryKey()]
const fetchFn: QueryFunction<StrictData, StrictQueryKey> = () =>
Promise.resolve('data')
await expect(
queryClient.fetchQuery<StrictData, any, StrictData, StrictQueryKey>({
queryKey: key,
queryFn: fetchFn,
}),
).resolves.toEqual('data')
})
// https://github.com/tannerlinsley/react-query/issues/652
test('should not retry by default', async () => {
const key = queryKey()
await expect(
queryClient.fetchQuery({
queryKey: key,
queryFn: async (): Promise<unknown> => {
throw new Error('error')
},
}),
).rejects.toEqual(new Error('error'))
})
test('should return the cached data on cache hit', async () => {
const key = queryKey()
const fetchFn = () => Promise.resolve('data')
const first = await queryClient.fetchQuery({
queryKey: key,
queryFn: fetchFn,
})
const second = await queryClient.fetchQuery({
queryKey: key,
queryFn: fetchFn,
})
expect(second).toBe(first)
})
test('should be able to fetch when garbage collection time is set to 0 and then be removed', async () => {
const key1 = queryKey()
const result = await queryClient.fetchQuery({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 1
},
gcTime: 0,
})
expect(result).toEqual(1)
await waitFor(() =>
expect(queryClient.getQueryData(key1)).toEqual(undefined),
)
})
test('should keep a query in cache if garbage collection time is Infinity', async () => {
const key1 = queryKey()
const result = await queryClient.fetchQuery({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 1
},
gcTime: Infinity,
})
const result2 = queryClient.getQueryData(key1)
expect(result).toEqual(1)
expect(result2).toEqual(1)
})
test('should not force fetch', async () => {
const key = queryKey()
queryClient.setQueryData(key, 'og')
const fetchFn = () => Promise.resolve('new')
const first = await queryClient.fetchQuery({
queryKey: key,
queryFn: fetchFn,
initialData: 'initial',
staleTime: 100,
})
expect(first).toBe('og')
})
test('should only fetch if the data is older then the given stale time', async () => {
const key = queryKey()
let count = 0
const fetchFn = () => ++count
queryClient.setQueryData(key, count)
const first = await queryClient.fetchQuery({
queryKey: key,
queryFn: fetchFn,
staleTime: 100,
})
await sleep(11)
const second = await queryClient.fetchQuery({
queryKey: key,
queryFn: fetchFn,
staleTime: 10,
})
const third = await queryClient.fetchQuery({
queryKey: key,
queryFn: fetchFn,
staleTime: 10,
})
await sleep(11)
const fourth = await queryClient.fetchQuery({
queryKey: key,
queryFn: fetchFn,
staleTime: 10,
})
expect(first).toBe(0)
expect(second).toBe(1)
expect(third).toBe(1)
expect(fourth).toBe(2)
})
})
describe('fetchInfiniteQuery', () => {
test('should not type-error with strict query key', async () => {
type StrictData = string
type StrictQueryKey = ['strict', ...ReturnType<typeof queryKey>]
const key: StrictQueryKey = ['strict', ...queryKey()]
const data = {
pages: ['data'],
pageParams: [0],
} as const
const fetchFn: QueryFunction<StrictData, StrictQueryKey, number> = () =>
Promise.resolve(data.pages[0])
await expect(
queryClient.fetchInfiniteQuery<
StrictData,
any,
StrictData,
StrictQueryKey,
number
>({ queryKey: key, queryFn: fetchFn, initialPageParam: 0 }),
).resolves.toEqual(data)
})
test('should return infinite query data', async () => {
const key = queryKey()
const result = await queryClient.fetchInfiniteQuery({
queryKey: key,
initialPageParam: 10,
queryFn: ({ pageParam }) => Number(pageParam),
})
const result2 = queryClient.getQueryData(key)
const expected = {
pages: [10],
pageParams: [10],
}
expect(result).toEqual(expected)
expect(result2).toEqual(expected)
})
})
describe('prefetchInfiniteQuery', () => {
test('should not type-error with strict query key', async () => {
type StrictData = 'data'
type StrictQueryKey = ['strict', ...ReturnType<typeof queryKey>]
const key: StrictQueryKey = ['strict', ...queryKey()]
const fetchFn: QueryFunction<StrictData, StrictQueryKey, number> = () =>
Promise.resolve('data')
await queryClient.prefetchInfiniteQuery<
StrictData,
any,
StrictData,
StrictQueryKey,
number
>({ queryKey: key, queryFn: fetchFn, initialPageParam: 0 })
const result = queryClient.getQueryData(key)
expect(result).toEqual({
pages: ['data'],
pageParams: [0],
})
})
test('should return infinite query data', async () => {
const key = queryKey()
await queryClient.prefetchInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }) => Number(pageParam),
initialPageParam: 10,
})
const result = queryClient.getQueryData(key)
expect(result).toEqual({
pages: [10],
pageParams: [10],
})
})
test('should prefetch multiple pages', async () => {
const key = queryKey()
await queryClient.prefetchInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }) => String(pageParam),
getNextPageParam: (_lastPage, _pages, lastPageParam) =>
lastPageParam + 5,
initialPageParam: 10,
pages: 3,
})
const result = queryClient.getQueryData(key)
expect(result).toEqual({
pages: ['10', '15', '20'],
pageParams: [10, 15, 20],
})
})
test('should stop prefetching if getNextPageParam returns undefined', async () => {
const key = queryKey()
await queryClient.prefetchInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }) => String(pageParam),
getNextPageParam: (_lastPage, _pages, lastPageParam) =>
lastPageParam >= 20 ? undefined : lastPageParam + 5,
initialPageParam: 10,
pages: 5,
})
const result = queryClient.getQueryData(key)
expect(result).toEqual({
pages: ['10', '15', '20'],
pageParams: [10, 15, 20],
})
})
})
describe('prefetchQuery', () => {
test('should not type-error with strict query key', async () => {
type StrictData = 'data'
type StrictQueryKey = ['strict', ...ReturnType<typeof queryKey>]
const key: StrictQueryKey = ['strict', ...queryKey()]
const fetchFn: QueryFunction<StrictData, StrictQueryKey> = () =>
Promise.resolve('data')
await queryClient.prefetchQuery<
StrictData,
any,
StrictData,
StrictQueryKey
>({ queryKey: key, queryFn: fetchFn })
const result = queryClient.getQueryData(key)
expect(result).toEqual('data')
})
test('should return undefined when an error is thrown', async () => {
const key = queryKey()
const result = await queryClient.prefetchQuery({
queryKey: key,
queryFn: async (): Promise<unknown> => {
throw new Error('error')
},
retry: false,
})
expect(result).toBeUndefined()
})
test('should be garbage collected after gcTime if unused', async () => {
const key = queryKey()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: async () => {
return 'data'
},
gcTime: 10,
})
expect(queryCache.find({ queryKey: key })).toBeDefined()
await sleep(15)
expect(queryCache.find({ queryKey: key })).not.toBeDefined()
})
})
describe('removeQueries', () => {
test('should not crash when exact is provided', async () => {
const key = queryKey()
const fetchFn = () => Promise.resolve('data')
// check the query was added to the cache
await queryClient.prefetchQuery({ queryKey: key, queryFn: fetchFn })
expect(queryCache.find({ queryKey: key })).toBeTruthy()
// check the error doesn't occur
expect(() =>
queryClient.removeQueries({ queryKey: key, exact: true }),
).not.toThrow()
// check query was successful removed
expect(queryCache.find({ queryKey: key })).toBeFalsy()
})
})
describe('cancelQueries', () => {
test('should revert queries to their previous state', async () => {
const key1 = queryKey()
const key2 = queryKey()
const key3 = queryKey()
await queryClient.fetchQuery({
queryKey: key1,
queryFn: async () => {
return 'data'
},
})
try {
await queryClient.fetchQuery({
queryKey: key2,
queryFn: async () => {
return Promise.reject<unknown>('err')
},
})
} catch {}
queryClient.fetchQuery({
queryKey: key1,
queryFn: async () => {
await sleep(1000)
return 'data2'
},
})
try {
queryClient.fetchQuery({
queryKey: key2,
queryFn: async () => {
await sleep(1000)
return Promise.reject<unknown>('err2')
},
})
} catch {}
queryClient.fetchQuery({
queryKey: key3,
queryFn: async () => {
await sleep(1000)
return 'data3'
},
})
await sleep(10)
await queryClient.cancelQueries()
const state1 = queryClient.getQueryState(key1)
const state2 = queryClient.getQueryState(key2)
const state3 = queryClient.getQueryState(key3)
expect(state1).toMatchObject({
data: 'data',
status: 'success',
})
expect(state2).toMatchObject({
data: undefined,
error: 'err',
status: 'error',
})
expect(state3).toMatchObject({
data: undefined,
status: 'pending',
fetchStatus: 'idle',
})
})
test('should not revert if revert option is set to false', async () => {
const key1 = queryKey()
await queryClient.fetchQuery({
queryKey: key1,
queryFn: async () => {
return 'data'
},
})
queryClient.fetchQuery({
queryKey: key1,
queryFn: async () => {
await sleep(1000)
return 'data2'
},
})
await sleep(10)
await queryClient.cancelQueries({ queryKey: key1 }, { revert: false })
const state1 = queryClient.getQueryState(key1)
expect(state1).toMatchObject({
status: 'error',
})
})
})
describe('refetchQueries', () => {
test('should not refetch if all observers are disabled', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
await queryClient.fetchQuery({ queryKey: key, queryFn })
const observer1 = new QueryObserver(queryClient, {
queryKey: key,
queryFn,
enabled: false,
})
observer1.subscribe(() => undefined)
await queryClient.refetchQueries()
observer1.destroy()
expect(queryFn).toHaveBeenCalledTimes(1)
})
test('should refetch if at least one observer is enabled', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
await queryClient.fetchQuery({ queryKey: key, queryFn })
const observer1 = new QueryObserver(queryClient, {
queryKey: key,
queryFn,
enabled: false,
})
const observer2 = new QueryObserver(queryClient, {
queryKey: key,
queryFn,
refetchOnMount: false,
})
observer1.subscribe(() => undefined)
observer2.subscribe(() => undefined)
await queryClient.refetchQueries()
observer1.destroy()
observer2.destroy()
expect(queryFn).toHaveBeenCalledTimes(2)
})
test('should refetch all queries when no arguments are given', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer1 = new QueryObserver(queryClient, {
queryKey: key1,
staleTime: Infinity,
initialData: 'initial',
})
const observer2 = new QueryObserver(queryClient, {
queryKey: key1,
staleTime: Infinity,
initialData: 'initial',
})
observer1.subscribe(() => undefined)
observer2.subscribe(() => undefined)
await queryClient.refetchQueries()
observer1.destroy()
observer2.destroy()
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(2)
})
test('should be able to refetch all fresh queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
staleTime: Infinity,
})
const unsubscribe = observer.subscribe(() => undefined)
await queryClient.refetchQueries({ type: 'active', stale: false })
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(1)
})
test('should be able to refetch all stale queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
})
const unsubscribe = observer.subscribe(() => undefined)
queryClient.invalidateQueries({ queryKey: key1 })
await queryClient.refetchQueries({ stale: true })
unsubscribe()
// fetchQuery, observer mount, invalidation (cancels observer mount) and refetch
expect(queryFn1).toHaveBeenCalledTimes(4)
expect(queryFn2).toHaveBeenCalledTimes(1)
})
test('should be able to refetch all stale and active queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
queryClient.invalidateQueries({ queryKey: key1 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
})
const unsubscribe = observer.subscribe(() => undefined)
await queryClient.refetchQueries(
{ type: 'active', stale: true },
{ cancelRefetch: false },
)
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(1)
})
test('should be able to refetch all active and inactive queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
staleTime: Infinity,
})
const unsubscribe = observer.subscribe(() => undefined)
await queryClient.refetchQueries()
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(2)
})
test('should be able to refetch all active and inactive queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
staleTime: Infinity,
})
const unsubscribe = observer.subscribe(() => undefined)
await queryClient.refetchQueries({ type: 'all' })
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(2)
})
test('should be able to refetch only active queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
staleTime: Infinity,
})
const unsubscribe = observer.subscribe(() => undefined)
await queryClient.refetchQueries({ type: 'active' })
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(1)
})
test('should be able to refetch only inactive queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
staleTime: Infinity,
})
const unsubscribe = observer.subscribe(() => undefined)
await queryClient.refetchQueries({ type: 'inactive' })
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(1)
expect(queryFn2).toHaveBeenCalledTimes(2)
})
test('should throw an error if throwOnError option is set to true', async () => {
const key1 = queryKey()
const queryFnError = () => Promise.reject<unknown>('error')
try {
await queryClient.fetchQuery({
queryKey: key1,
queryFn: queryFnError,
retry: false,
})
} catch {}
let error: any
try {
await queryClient.refetchQueries(
{ queryKey: key1 },
{ throwOnError: true },
)
} catch (err) {
error = err
}
expect(error).toEqual('error')
})
test('should resolve Promise immediately if query is paused', async () => {
const key1 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
const onlineMock = mockOnlineManagerIsOnline(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<Array<unknown>, string>().mockReturnValue('data1')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
const onlineMock = mockOnlineManagerIsOnline(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 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
staleTime: Infinity,
})
const unsubscribe = observer.subscribe(() => undefined)
queryClient.invalidateQueries({ queryKey: key1 })
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(1)
})
test('should not refetch inactive queries by default', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
enabled: false,
staleTime: Infinity,
})
const unsubscribe = observer.subscribe(() => undefined)
queryClient.invalidateQueries({ queryKey: key1 })
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(1)
expect(queryFn2).toHaveBeenCalledTimes(1)
})
test('should not refetch active queries when "refetch" is "none"', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
staleTime: Infinity,
})
const unsubscribe = observer.subscribe(() => undefined)
queryClient.invalidateQueries({
queryKey: key1,
refetchType: 'none',
})
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(1)
expect(queryFn2).toHaveBeenCalledTimes(1)
})
test('should refetch inactive queries when "refetch" is "inactive"', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
staleTime: Infinity,
refetchOnMount: false,
})
const unsubscribe = observer.subscribe(() => undefined)
unsubscribe()
await queryClient.invalidateQueries({
queryKey: key1,
refetchType: 'inactive',
})
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(1)
})
test('should refetch active and inactive queries when "refetch" is "all"', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
staleTime: Infinity,
})
const unsubscribe = observer.subscribe(() => undefined)
queryClient.invalidateQueries({
refetchType: 'all',
})
unsubscribe()
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(2)
})
test('should cancel ongoing fetches if cancelRefetch option is set (default value)', async () => {
const key = queryKey()
const abortFn = vi.fn()
let fetchCount = 0
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: ({ signal }) => {
return new Promise((resolve) => {
fetchCount++
setTimeout(() => resolve(5), 10)
signal.addEventListener('abort', abortFn)
})
},
initialData: 1,
})
observer.subscribe(() => undefined)
await queryClient.refetchQueries()
observer.destroy()
expect(abortFn).toHaveBeenCalledTimes(1)
expect(fetchCount).toBe(2)
})
test('should not cancel ongoing fetches if cancelRefetch option is set to false', async () => {
const key = queryKey()
const abortFn = vi.fn()
let fetchCount = 0
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: ({ signal }) => {
return new Promise((resolve) => {
fetchCount++
setTimeout(() => resolve(5), 10)
signal.addEventListener('abort', abortFn)
})
},
initialData: 1,
})
observer.subscribe(() => undefined)
await queryClient.refetchQueries(undefined, { cancelRefetch: false })
observer.destroy()
expect(abortFn).toHaveBeenCalledTimes(0)
expect(fetchCount).toBe(1)
})
})
describe('resetQueries', () => {
test('should notify listeners when a query is reset', async () => {
const key = queryKey()
const callback = vi.fn()
await queryClient.prefetchQuery({ queryKey: key, queryFn: () => 'data' })
queryCache.subscribe(callback)
queryClient.resetQueries({ queryKey: key })
expect(callback).toHaveBeenCalled()
})
test('should reset query', async () => {
const key = queryKey()
await queryClient.prefetchQuery({ queryKey: key, queryFn: () => 'data' })
let state = queryClient.getQueryState(key)
expect(state?.data).toEqual('data')
expect(state?.status).toEqual('success')
queryClient.resetQueries({ queryKey: key })
state = queryClient.getQueryState(key)
expect(state).toBeTruthy()
expect(state?.data).toBeUndefined()
expect(state?.status).toEqual('pending')
expect(state?.fetchStatus).toEqual('idle')
})
test('should reset query data to initial data if set', async () => {
const key = queryKey()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => 'data',
initialData: 'initial',
})
let state = queryClient.getQueryState(key)
expect(state?.data).toEqual('data')
queryClient.resetQueries({ queryKey: key })
state = queryClient.getQueryState(key)
expect(state).toBeTruthy()
expect(state?.data).toEqual('initial')
})
test('should refetch all active queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
const observer1 = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: queryFn1,
enabled: true,
})
const observer2 = new QueryObserver(queryClient, {
queryKey: key2,
queryFn: queryFn2,
enabled: false,
})
observer1.subscribe(() => undefined)
observer2.subscribe(() => undefined)
await queryClient.resetQueries()
observer2.destroy()
observer1.destroy()
expect(queryFn1).toHaveBeenCalledTimes(2)
expect(queryFn2).toHaveBeenCalledTimes(0)
})
})
describe('focusManager and onlineManager', () => {
test('should notify queryCache and mutationCache if focused', async () => {
const testClient = createQueryClient()
testClient.mount()
const queryCacheOnFocusSpy = vi.spyOn(
testClient.getQueryCache(),
'onFocus',
)
const queryCacheOnOnlineSpy = vi.spyOn(
testClient.getQueryCache(),
'onOnline',
)
const mutationCacheResumePausedMutationsSpy = vi.spyOn(
testClient.getMutationCache(),
'resumePausedMutations',
)
focusManager.setFocused(false)
expect(queryCacheOnFocusSpy).not.toHaveBeenCalled()
expect(mutationCacheResumePausedMutationsSpy).not.toHaveBeenCalled()
focusManager.setFocused(true)
expect(queryCacheOnFocusSpy).toHaveBeenCalledTimes(1)
expect(mutationCacheResumePausedMutationsSpy).toHaveBeenCalledTimes(1)
expect(queryCacheOnOnlineSpy).not.toHaveBeenCalled()
queryCacheOnFocusSpy.mockRestore()
mutationCacheResumePausedMutationsSpy.mockRestore()
queryCacheOnOnlineSpy.mockRestore()
focusManager.setFocused(undefined)
})
test('should notify queryCache and mutationCache if online', async () => {
const testClient = createQueryClient()
testClient.mount()
const queryCacheOnFocusSpy = vi.spyOn(
testClient.getQueryCache(),
'onFocus',
)
const queryCacheOnOnlineSpy = vi.spyOn(
testClient.getQueryCache(),
'onOnline',
)
const mutationCacheResumePausedMutationsSpy = vi.spyOn(
testClient.getMutationCache(),
'resumePausedMutations',
)
onlineManager.setOnline(false)
expect(queryCacheOnOnlineSpy).not.toHaveBeenCalled()
expect(mutationCacheResumePausedMutationsSpy).not.toHaveBeenCalled()
onlineManager.setOnline(true)
expect(queryCacheOnOnlineSpy).toHaveBeenCalledTimes(1)
expect(mutationCacheResumePausedMutationsSpy).toHaveBeenCalledTimes(1)
expect(queryCacheOnFocusSpy).not.toHaveBeenCalled()
queryCacheOnFocusSpy.mockRestore()
queryCacheOnOnlineSpy.mockRestore()
mutationCacheResumePausedMutationsSpy.mockRestore()
onlineManager.setOnline(true)
})
test('should resume paused mutations when coming online', async () => {
const consoleMock = vi.spyOn(console, 'error')
consoleMock.mockImplementation(() => undefined)
onlineManager.setOnline(false)
const observer1 = new MutationObserver(queryClient, {
mutationFn: async () => 1,
})
const observer2 = new MutationObserver(queryClient, {
mutationFn: async () => 2,
})
void observer1.mutate().catch(noop)
void observer2.mutate().catch(noop)
await waitFor(() => {
expect(observer1.getCurrentResult().isPaused).toBeTruthy()
expect(observer2.getCurrentResult().isPaused).toBeTruthy()
})
onlineManager.setOnline(true)
await waitFor(() => {
expect(observer1.getCurrentResult().status).toBe('success')
expect(observer1.getCurrentResult().status).toBe('success')
})
onlineManager.setOnline(true)
})
test('should resume paused mutations one after the other when invoked manually at the same time', async () => {
const consoleMock = vi.spyOn(console, 'error')
consoleMock.mockImplementation(() => undefined)
onlineManager.setOnline(false)
const orders: Array<string> = []
const observer1 = new MutationObserver(queryClient, {
mutationFn: async () => {
orders.push('1start')
await sleep(50)
orders.push('1end')
return 1
},
})
const observer2 = new MutationObserver(queryClient, {
mutationFn: async () => {
orders.push('2start')
await sleep(20)
orders.push('2end')
return 2
},
})
void observer1.mutate().catch(noop)
void observer2.mutate().catch(noop)
await waitFor(() => {
expect(observer1.getCurrentResult().isPaused).toBeTruthy()
expect(observer2.getCurrentResult().isPaused).toBeTruthy()
})
onlineManager.setOnline(true)
void queryClient.resumePausedMutations()
await sleep(5)
await queryClient.resumePausedMutations()
await waitFor(() => {
expect(observer1.getCurrentResult().status).toBe('success')
expect(observer2.getCurrentResult().status).toBe('success')
})
expect(orders).toEqual(['1start', '1end', '2start', '2end'])
})
test('should notify queryCache and mutationCache after multiple mounts and single unmount', async () => {
const testClient = createQueryClient()
testClient.mount()
testClient.mount()
testClient.unmount()
const queryCacheOnFocusSpy = vi.spyOn(
testClient.getQueryCache(),
'onFocus',
)
const queryCacheOnOnlineSpy = vi.spyOn(
testClient.getQueryCache(),
'onOnline',
)
const mutationCacheResumePausedMutationsSpy = vi.spyOn(
testClient.getMutationCache(),
'resumePausedMutations',
)
onlineManager.setOnline(false)
onlineManager.setOnline(true)
expect(queryCacheOnOnlineSpy).toHaveBeenCalledTimes(1)
expect(mutationCacheResumePausedMutationsSpy).toHaveBeenCalledTimes(1)
focusManager.setFocused(true)
expect(queryCacheOnFocusSpy).toHaveBeenCalledTimes(1)
expect(mutationCacheResumePausedMutationsSpy).toHaveBeenCalledTimes(2)
queryCacheOnFocusSpy.mockRestore()
queryCacheOnOnlineSpy.mockRestore()
mutationCacheResumePausedMutationsSpy.mockRestore()
focusManager.setFocused(undefined)
onlineManager.setOnline(true)
})
test('should not notify queryCache and mutationCache after multiple mounts/unmounts', async () => {
const testClient = createQueryClient()
testClient.mount()
testClient.mount()
testClient.unmount()
testClient.unmount()
const queryCacheOnFocusSpy = vi.spyOn(
testClient.getQueryCache(),
'onFocus',
)
const queryCacheOnOnlineSpy = vi.spyOn(
testClient.getQueryCache(),
'onOnline',
)
const mutationCacheResumePausedMutationsSpy = vi.spyOn(
testClient.getMutationCache(),
'resumePausedMutations',
)
onlineManager.setOnline(true)
expect(queryCacheOnOnlineSpy).not.toHaveBeenCalled()
expect(mutationCacheResumePausedMutationsSpy).not.toHaveBeenCalled()
focusManager.setFocused(true)
expect(queryCacheOnFocusSpy).not.toHaveBeenCalled()
expect(mutationCacheResumePausedMutationsSpy).not.toHaveBeenCalled()
queryCacheOnFocusSpy.mockRestore()
queryCacheOnOnlineSpy.mockRestore()
mutationCacheResumePausedMutationsSpy.mockRestore()
focusManager.setFocused(undefined)
onlineManager.setOnline(true)
})
})
describe('setMutationDefaults', () => {
test('should update existing mutation defaults', () => {
const key = queryKey()
const mutationOptions1 = { mutationFn: async () => 'data' }
const mutationOptions2 = { retry: false }
queryClient.setMutationDefaults(key, mutationOptions1)
queryClient.setMutationDefaults(key, mutationOptions2)
expect(queryClient.getMutationDefaults(key)).toMatchObject(
mutationOptions2,
)
})
})
})
|
3,882 | 0 | petrpan-code/TanStack/query/packages/query-core/src | petrpan-code/TanStack/query/packages/query-core/src/tests/queryClient.types.test.tsx | import { describe, it } from 'vitest'
import { QueryClient } from '../queryClient'
import { doNotExecute } from './utils'
import type { Equal, Expect } from './utils'
import type { DataTag, InfiniteData } from '../types'
describe('getQueryData', () => {
it('should be typed if key is tagged', () => {
doNotExecute(() => {
const queryKey = ['key'] as DataTag<Array<string>, number>
const queryClient = new QueryClient()
const data = queryClient.getQueryData(queryKey)
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should infer unknown if key is not tagged', () => {
doNotExecute(() => {
const queryKey = ['key'] as const
const queryClient = new QueryClient()
const data = queryClient.getQueryData(queryKey)
const result: Expect<Equal<typeof data, unknown>> = true
return result
})
})
it('should infer passed generic if passed', () => {
doNotExecute(() => {
const queryKey = ['key'] as const
const queryClient = new QueryClient()
const data = queryClient.getQueryData<number>(queryKey)
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should only allow Arrays to be passed', () => {
doNotExecute(() => {
const queryKey = 'key' as const
const queryClient = new QueryClient()
// @ts-expect-error TS2345: Argument of type 'string' is not assignable to parameter of type 'QueryKey'
return queryClient.getQueryData(queryKey)
})
})
})
describe('setQueryData', () => {
it('updater should be typed if key is tagged', () => {
doNotExecute(() => {
const queryKey = ['key'] as DataTag<Array<string>, number>
const queryClient = new QueryClient()
const data = queryClient.setQueryData(queryKey, (prev) => {
const result: Expect<Equal<typeof prev, number | undefined>> = true
return result ? prev : 1
})
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('value should be typed if key is tagged', () => {
doNotExecute(() => {
const queryKey = ['key'] as DataTag<Array<string>, number>
const queryClient = new QueryClient()
// @ts-expect-error value should be a number
queryClient.setQueryData(queryKey, '1')
// @ts-expect-error value should be a number
queryClient.setQueryData(queryKey, () => '1')
const data = queryClient.setQueryData(queryKey, 1)
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should infer unknown for updater if key is not tagged', () => {
doNotExecute(() => {
const queryKey = ['key'] as const
const queryClient = new QueryClient()
const data = queryClient.setQueryData(queryKey, (prev) => {
const result: Expect<Equal<typeof prev, unknown>> = true
return result ? prev : 1
})
const result: Expect<Equal<typeof data, unknown>> = true
return result
})
})
it('should infer unknown for value if key is not tagged', () => {
doNotExecute(() => {
const queryKey = ['key'] as const
const queryClient = new QueryClient()
const data = queryClient.setQueryData(queryKey, 'foo')
const result: Expect<Equal<typeof data, unknown>> = true
return result
})
})
it('should infer passed generic if passed', () => {
doNotExecute(() => {
const queryKey = ['key'] as const
const queryClient = new QueryClient()
const data = queryClient.setQueryData<string>(queryKey, (prev) => {
const result: Expect<Equal<typeof prev, string | undefined>> = true
return result ? prev : '1'
})
const result: Expect<Equal<typeof data, string | undefined>> = true
return result
})
})
it('should infer passed generic for value', () => {
doNotExecute(() => {
const queryKey = ['key'] as const
const queryClient = new QueryClient()
const data = queryClient.setQueryData<string>(queryKey, 'foo')
const result: Expect<Equal<typeof data, string | undefined>> = true
return result
})
})
})
describe('fetchInfiniteQuery', () => {
it('should allow passing pages', () => {
doNotExecute(async () => {
const data = await new QueryClient().fetchInfiniteQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve('string'),
getNextPageParam: () => 1,
initialPageParam: 1,
pages: 5,
})
const result: Expect<Equal<typeof data, InfiniteData<string, number>>> =
true
return result
})
})
it('should not allow passing getNextPageParam without pages', () => {
doNotExecute(async () => {
return new QueryClient().fetchInfiniteQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve('string'),
initialPageParam: 1,
getNextPageParam: () => 1,
})
})
})
it('should not allow passing pages without getNextPageParam', () => {
doNotExecute(async () => {
// @ts-expect-error Property 'getNextPageParam' is missing
return new QueryClient().fetchInfiniteQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve('string'),
initialPageParam: 1,
pages: 5,
})
})
})
})
|
3,883 | 0 | petrpan-code/TanStack/query/packages/query-core/src | petrpan-code/TanStack/query/packages/query-core/src/tests/queryObserver.test.tsx | import {
afterEach,
beforeEach,
describe,
expect,
expectTypeOf,
test,
vi,
} from 'vitest'
import { waitFor } from '@testing-library/react'
import { QueryObserver, focusManager } from '..'
import { createQueryClient, queryKey, sleep } from './utils'
import type { QueryClient, QueryObserverResult } from '..'
describe('queryObserver', () => {
let queryClient: QueryClient
beforeEach(() => {
queryClient = createQueryClient()
queryClient.mount()
})
afterEach(() => {
queryClient.clear()
})
test('should trigger a fetch when subscribed', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
const observer = new QueryObserver(queryClient, { queryKey: key, queryFn })
const unsubscribe = observer.subscribe(() => undefined)
await sleep(1)
unsubscribe()
expect(queryFn).toHaveBeenCalledTimes(1)
})
test('should be able to read latest data after subscribing', async () => {
const key = queryKey()
queryClient.setQueryData(key, 'data')
const observer = new QueryObserver(queryClient, {
queryKey: key,
enabled: false,
})
const unsubscribe = observer.subscribe(vi.fn())
expect(observer.getCurrentResult()).toMatchObject({
status: 'success',
data: 'data',
})
unsubscribe()
})
test('should be able to read latest data when re-subscribing (but not re-fetching)', async () => {
const key = queryKey()
let count = 0
const observer = new QueryObserver(queryClient, {
queryKey: key,
staleTime: Infinity,
queryFn: async () => {
await sleep(10)
count++
return 'data'
},
})
let unsubscribe = observer.subscribe(vi.fn())
// unsubscribe before data comes in
unsubscribe()
expect(count).toBe(0)
expect(observer.getCurrentResult()).toMatchObject({
status: 'pending',
fetchStatus: 'fetching',
data: undefined,
})
await waitFor(() => expect(count).toBe(1))
// re-subscribe after data comes in
unsubscribe = observer.subscribe(vi.fn())
expect(observer.getCurrentResult()).toMatchObject({
status: 'success',
data: 'data',
})
unsubscribe()
})
test('should notify when switching query', async () => {
const key1 = queryKey()
const key2 = queryKey()
const results: Array<QueryObserverResult> = []
const observer = new QueryObserver(queryClient, {
queryKey: key1,
queryFn: () => 1,
})
const unsubscribe = observer.subscribe((result) => {
results.push(result)
})
await sleep(1)
observer.setOptions({ queryKey: key2, queryFn: () => 2 })
await sleep(1)
unsubscribe()
expect(results.length).toBe(4)
expect(results[0]).toMatchObject({ data: undefined, status: 'pending' })
expect(results[1]).toMatchObject({ data: 1, status: 'success' })
expect(results[2]).toMatchObject({ data: undefined, status: 'pending' })
expect(results[3]).toMatchObject({ data: 2, status: 'success' })
})
test('should be able to fetch with a selector', async () => {
const key = queryKey()
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => ({ count: 1 }),
select: (data) => ({ myCount: data.count }),
})
let observerResult
const unsubscribe = observer.subscribe((result) => {
expectTypeOf<QueryObserverResult<{ myCount: number }>>(result)
observerResult = result
})
await sleep(1)
unsubscribe()
expect(observerResult).toMatchObject({ data: { myCount: 1 } })
})
test('should be able to fetch with a selector using the fetch method', async () => {
const key = queryKey()
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => ({ count: 1 }),
select: (data) => ({ myCount: data.count }),
})
const observerResult = await observer.refetch()
expectTypeOf<{ myCount: number } | undefined>(observerResult.data)
expect(observerResult.data).toMatchObject({ myCount: 1 })
})
test('should be able to fetch with a selector and object syntax', async () => {
const key = queryKey()
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => ({ count: 1 }),
select: (data) => ({ myCount: data.count }),
})
let observerResult
const unsubscribe = observer.subscribe((result) => {
observerResult = result
})
await sleep(1)
unsubscribe()
expect(observerResult).toMatchObject({ data: { myCount: 1 } })
})
test('should run the selector again if the data changed', async () => {
const key = queryKey()
let count = 0
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => ({ count }),
select: (data) => {
count++
return { myCount: data.count }
},
})
const observerResult1 = await observer.refetch()
const observerResult2 = await observer.refetch()
expect(count).toBe(2)
expect(observerResult1.data).toMatchObject({ myCount: 0 })
expect(observerResult2.data).toMatchObject({ myCount: 1 })
})
test('should run the selector again if the selector changed', async () => {
const key = queryKey()
let count = 0
const results: Array<QueryObserverResult> = []
const queryFn = () => ({ count: 1 })
const select1 = (data: ReturnType<typeof queryFn>) => {
count++
return { myCount: data.count }
}
const select2 = (_data: ReturnType<typeof queryFn>) => {
count++
return { myCount: 99 }
}
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn,
select: select1,
})
const unsubscribe = observer.subscribe((result) => {
results.push(result)
})
await sleep(1)
observer.setOptions({
queryKey: key,
queryFn,
select: select2,
})
await sleep(1)
await observer.refetch()
unsubscribe()
expect(count).toBe(2)
expect(results.length).toBe(5)
expect(results[0]).toMatchObject({
status: 'pending',
isFetching: true,
data: undefined,
})
expect(results[1]).toMatchObject({
status: 'success',
isFetching: false,
data: { myCount: 1 },
})
expect(results[2]).toMatchObject({
status: 'success',
isFetching: false,
data: { myCount: 99 },
})
expect(results[3]).toMatchObject({
status: 'success',
isFetching: true,
data: { myCount: 99 },
})
expect(results[4]).toMatchObject({
status: 'success',
isFetching: false,
data: { myCount: 99 },
})
})
test('should not run the selector again if the data and selector did not change', async () => {
const key = queryKey()
let count = 0
const results: Array<QueryObserverResult> = []
const queryFn = () => ({ count: 1 })
const select = (data: ReturnType<typeof queryFn>) => {
count++
return { myCount: data.count }
}
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn,
select,
})
const unsubscribe = observer.subscribe((result) => {
results.push(result)
})
await sleep(1)
observer.setOptions({
queryKey: key,
queryFn,
select,
})
await sleep(1)
await observer.refetch()
unsubscribe()
expect(count).toBe(1)
expect(results.length).toBe(4)
expect(results[0]).toMatchObject({
status: 'pending',
isFetching: true,
data: undefined,
})
expect(results[1]).toMatchObject({
status: 'success',
isFetching: false,
data: { myCount: 1 },
})
expect(results[2]).toMatchObject({
status: 'success',
isFetching: true,
data: { myCount: 1 },
})
expect(results[3]).toMatchObject({
status: 'success',
isFetching: false,
data: { myCount: 1 },
})
})
test('should not run the selector again if the data did not change', async () => {
const key = queryKey()
let count = 0
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => ({ count: 1 }),
select: (data) => {
count++
return { myCount: data.count }
},
})
const observerResult1 = await observer.refetch()
const observerResult2 = await observer.refetch()
expect(count).toBe(1)
expect(observerResult1.data).toMatchObject({ myCount: 1 })
expect(observerResult2.data).toMatchObject({ myCount: 1 })
})
test('should always run the selector again if selector throws an error and selector is not referentially stable', async () => {
const key = queryKey()
const results: Array<QueryObserverResult> = []
const queryFn = async () => {
await sleep(10)
return { count: 1 }
}
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn,
select: () => {
throw new Error('selector error')
},
})
const unsubscribe = observer.subscribe((result) => {
results.push(result)
})
await sleep(50)
await observer.refetch()
unsubscribe()
expect(results[0]).toMatchObject({
status: 'pending',
isFetching: true,
data: undefined,
})
expect(results[1]).toMatchObject({
status: 'error',
isFetching: false,
data: undefined,
})
expect(results[2]).toMatchObject({
status: 'error',
isFetching: true,
data: undefined,
})
expect(results[3]).toMatchObject({
status: 'error',
isFetching: false,
data: undefined,
})
})
test('should return stale data if selector throws an error', async () => {
const key = queryKey()
const results: Array<QueryObserverResult> = []
let shouldError = false
const error = new Error('select error')
const observer = new QueryObserver(queryClient, {
queryKey: key,
retry: 0,
queryFn: async () => {
await sleep(10)
return shouldError ? 2 : 1
},
select: (num) => {
if (shouldError) {
throw error
}
shouldError = true
return String(num)
},
})
const unsubscribe = observer.subscribe((result) => {
results.push(result)
})
await sleep(50)
await observer.refetch()
unsubscribe()
expect(results[0]).toMatchObject({
status: 'pending',
isFetching: true,
data: undefined,
error: null,
})
expect(results[1]).toMatchObject({
status: 'success',
isFetching: false,
data: '1',
error: null,
})
expect(results[2]).toMatchObject({
status: 'success',
isFetching: true,
data: '1',
error: null,
})
expect(results[3]).toMatchObject({
status: 'error',
isFetching: false,
data: '1',
error,
})
})
test('should structurally share the selector', async () => {
const key = queryKey()
let count = 0
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => ({ count: ++count }),
select: () => ({ myCount: 1 }),
})
const observerResult1 = await observer.refetch()
const observerResult2 = await observer.refetch()
expect(count).toBe(2)
expect(observerResult1.data).toBe(observerResult2.data)
})
test('should not trigger a fetch when subscribed and disabled', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn,
enabled: false,
})
const unsubscribe = observer.subscribe(() => undefined)
await sleep(1)
unsubscribe()
expect(queryFn).toHaveBeenCalledTimes(0)
})
test('should not trigger a fetch when not subscribed', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
new QueryObserver(queryClient, { queryKey: key, queryFn })
await sleep(1)
expect(queryFn).toHaveBeenCalledTimes(0)
})
test('should be able to watch a query without defining a query function', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
const callback = vi.fn()
const observer = new QueryObserver(queryClient, {
queryKey: key,
enabled: false,
})
const unsubscribe = observer.subscribe(callback)
await queryClient.fetchQuery({ queryKey: key, queryFn })
unsubscribe()
expect(queryFn).toHaveBeenCalledTimes(1)
expect(callback).toHaveBeenCalledTimes(2)
})
test('should accept unresolved query config in update function', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
const observer = new QueryObserver(queryClient, {
queryKey: key,
enabled: false,
})
const results: Array<QueryObserverResult<unknown>> = []
const unsubscribe = observer.subscribe((x) => {
results.push(x)
})
observer.setOptions({ enabled: false, staleTime: 10 })
await queryClient.fetchQuery({ queryKey: key, queryFn })
await sleep(100)
unsubscribe()
expect(queryFn).toHaveBeenCalledTimes(1)
expect(results.length).toBe(3)
expect(results[0]).toMatchObject({ isStale: true })
expect(results[1]).toMatchObject({ isStale: false })
expect(results[2]).toMatchObject({ isStale: true })
})
test('should be able to handle multiple subscribers', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
const observer = new QueryObserver<string>(queryClient, {
queryKey: key,
enabled: false,
})
const results1: Array<QueryObserverResult<string>> = []
const results2: Array<QueryObserverResult<string>> = []
const unsubscribe1 = observer.subscribe((x) => {
results1.push(x)
})
const unsubscribe2 = observer.subscribe((x) => {
results2.push(x)
})
await queryClient.fetchQuery({ queryKey: key, queryFn })
await sleep(50)
unsubscribe1()
unsubscribe2()
expect(queryFn).toHaveBeenCalledTimes(1)
expect(results1.length).toBe(2)
expect(results2.length).toBe(2)
expect(results1[0]).toMatchObject({ data: undefined })
expect(results1[1]).toMatchObject({ data: 'data' })
expect(results2[0]).toMatchObject({ data: undefined })
expect(results2[1]).toMatchObject({ data: 'data' })
})
test('should stop retry when unsubscribing', async () => {
const key = queryKey()
let count = 0
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => {
count++
return Promise.reject<unknown>('reject')
},
retry: 10,
retryDelay: 50,
})
const unsubscribe = observer.subscribe(() => undefined)
await sleep(70)
unsubscribe()
await sleep(200)
expect(count).toBe(2)
})
test('should clear interval when unsubscribing to a refetchInterval query', async () => {
const key = queryKey()
let count = 0
const fetchData = () => {
count++
return Promise.resolve('data')
}
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: fetchData,
gcTime: 0,
refetchInterval: 10,
})
const unsubscribe = observer.subscribe(() => undefined)
expect(count).toBe(1)
await sleep(15)
expect(count).toBe(2)
unsubscribe()
await sleep(10)
expect(queryClient.getQueryCache().find({ queryKey: key })).toBeUndefined()
expect(count).toBe(2)
})
test('uses placeholderData as non-cache data when pending a query with no data', async () => {
const key = queryKey()
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => 'data',
placeholderData: 'placeholder',
})
expect(observer.getCurrentResult()).toMatchObject({
status: 'success',
data: 'placeholder',
})
const results: Array<QueryObserverResult<unknown>> = []
const unsubscribe = observer.subscribe((x) => {
results.push(x)
})
await sleep(10)
unsubscribe()
expect(results.length).toBe(2)
expect(results[0]).toMatchObject({ status: 'success', data: 'placeholder' })
expect(results[1]).toMatchObject({ status: 'success', data: 'data' })
})
test('should structurally share placeholder data', async () => {
const key = queryKey()
const observer = new QueryObserver(queryClient, {
queryKey: key,
enabled: false,
queryFn: () => 'data',
placeholderData: {},
})
const firstData = observer.getCurrentResult().data
observer.setOptions({ placeholderData: {} })
const secondData = observer.getCurrentResult().data
expect(firstData).toBe(secondData)
})
test('should throw an error if enabled option type is not valid', async () => {
const key = queryKey()
expect(
() =>
new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => 'data',
//@ts-expect-error
enabled: null,
}),
).toThrowError('Expected enabled to be a boolean')
})
test('getCurrentQuery should return the current query', async () => {
const key = queryKey()
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => 'data',
})
expect(observer.getCurrentQuery().queryKey).toEqual(key)
})
test('should throw an error if throwOnError option is true', async () => {
const key = queryKey()
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => Promise.reject<unknown>('error'),
retry: false,
})
let error: string | null = null
try {
await observer.refetch({ throwOnError: true })
} catch (err) {
error = err as string
}
expect(error).toEqual('error')
})
test('should not refetch in background if refetchIntervalInBackground is false', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
focusManager.setFocused(false)
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn,
refetchIntervalInBackground: false,
refetchInterval: 10,
})
const unsubscribe = observer.subscribe(() => undefined)
await sleep(30)
expect(queryFn).toHaveBeenCalledTimes(1)
// Clean-up
unsubscribe()
focusManager.setFocused(true)
})
test('should not use replaceEqualDeep for select value when structuralSharing option is true', async () => {
const key = queryKey()
const data = { value: 'data' }
const selectedData = { value: 'data' }
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => data,
select: () => data,
})
const unsubscribe = observer.subscribe(() => undefined)
await sleep(10)
expect(observer.getCurrentResult().data).toBe(data)
observer.setOptions({
queryKey: key,
queryFn: () => data,
structuralSharing: false,
select: () => selectedData,
})
await observer.refetch()
expect(observer.getCurrentResult().data).toBe(selectedData)
unsubscribe()
})
test('should not use replaceEqualDeep for select value when structuralSharing option is true and placeholderdata is defined', () => {
const key = queryKey()
const data = { value: 'data' }
const selectedData1 = { value: 'data' }
const selectedData2 = { value: 'data' }
const placeholderData1 = { value: 'data' }
const placeholderData2 = { value: 'data' }
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => data,
select: () => data,
})
observer.setOptions({
queryKey: key,
queryFn: () => data,
select: () => {
return selectedData1
},
placeholderData: placeholderData1,
})
observer.setOptions({
queryKey: key,
queryFn: () => data,
select: () => {
return selectedData2
},
placeholderData: placeholderData2,
structuralSharing: false,
})
expect(observer.getCurrentResult().data).toBe(selectedData2)
})
test('should not use an undefined value returned by select as placeholderdata', () => {
const key = queryKey()
const data = { value: 'data' }
const selectedData = { value: 'data' }
const placeholderData1 = { value: 'data' }
const placeholderData2 = { value: 'data' }
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: () => data,
select: () => data,
})
observer.setOptions({
queryKey: key,
queryFn: () => data,
select: () => {
return selectedData
},
placeholderData: placeholderData1,
})
expect(observer.getCurrentResult().isPlaceholderData).toBe(true)
observer.setOptions({
queryKey: key,
queryFn: () => data,
//@ts-expect-error
select: () => undefined,
placeholderData: placeholderData2,
})
expect(observer.getCurrentResult().isPlaceholderData).toBe(false)
})
test('should pass the correct previous queryKey (from prevQuery) to placeholderData function params with select', async () => {
const results: Array<QueryObserverResult> = []
const keys: Array<ReadonlyArray<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: Array<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()
const observer = new QueryObserver(queryClient, {
queryKey: key,
})
const spy = vi.fn()
const unsubscribe = queryClient.getQueryCache().subscribe(spy)
observer.setOptions({ enabled: false })
expect(spy).toHaveBeenCalledTimes(1)
expect(spy).toHaveBeenCalledWith(
expect.objectContaining({ type: 'observerOptionsUpdated' }),
)
unsubscribe()
})
})
|
3,884 | 0 | petrpan-code/TanStack/query/packages/query-core/src | petrpan-code/TanStack/query/packages/query-core/src/tests/queryObserver.types.test.tsx | import { describe, it } from 'vitest'
import { QueryObserver } from '..'
import { createQueryClient, doNotExecute } from './utils'
import type { Equal, Expect } from './utils'
describe('placeholderData', () => {
describe('placeholderData function', () => {
it('previousQuery should have typed queryKey', () => {
doNotExecute(() => {
const queryKey = ['SomeQuery', 42, { foo: 'bar' }] as const
type QueryKey = typeof queryKey
new QueryObserver(createQueryClient(), {
queryKey,
placeholderData: (_, previousQuery) => {
const previousQueryKey = previousQuery?.queryKey
const result: Expect<
Equal<typeof previousQueryKey, QueryKey | undefined>
> = true
return result
},
})
})
})
it('previousQuery should have typed error', () => {
doNotExecute(() => {
class CustomError extends Error {
name = 'CustomError' as const
}
new QueryObserver<boolean, CustomError>(createQueryClient(), {
placeholderData: (_, previousQuery) => {
const error = previousQuery?.state.error
const result: Expect<
Equal<typeof error, CustomError | null | undefined>
> = true
return result
},
})
})
})
it('previousData should have the same type as query data', () => {
doNotExecute(() => {
const queryData = { foo: 'bar' } as const
type QueryData = typeof queryData
new QueryObserver(createQueryClient(), {
queryFn: () => queryData,
select: (data) => data.foo,
placeholderData: (previousData) => {
const result: Expect<
Equal<typeof previousData, QueryData | undefined>
> = true
return result ? previousData : undefined
},
})
})
})
})
})
|
3,885 | 0 | petrpan-code/TanStack/query/packages/query-core/src | petrpan-code/TanStack/query/packages/query-core/src/tests/utils.test.tsx | import { describe, expect, it, vi } from 'vitest'
import {
addToEnd,
addToStart,
isPlainArray,
isPlainObject,
matchMutation,
partialMatchKey,
replaceEqualDeep,
scheduleMicrotask,
sleep,
} from '../utils'
import { Mutation } from '../mutation'
import { createQueryClient } from './utils'
describe('core/utils', () => {
describe('isPlainObject', () => {
it('should return `true` for a plain object', () => {
expect(isPlainObject({})).toEqual(true)
})
it('should return `false` for an array', () => {
expect(isPlainObject([])).toEqual(false)
})
it('should return `false` for null', () => {
expect(isPlainObject(null)).toEqual(false)
})
it('should return `false` for undefined', () => {
expect(isPlainObject(undefined)).toEqual(false)
})
it('should return `true` for object with an undefined constructor', () => {
expect(isPlainObject(Object.create(null))).toBeTruthy()
})
it('should return `false` if constructor does not have an Object-specific method', () => {
class Foo {
abc: any
constructor() {
this.abc = {}
}
}
expect(isPlainObject(new Foo())).toBeFalsy()
})
it('should return `false` if the object has a modified prototype', () => {
function Graph(this: any) {
this.vertices = []
this.edges = []
}
Graph.prototype.addVertex = function (v: any) {
this.vertices.push(v)
}
expect(isPlainObject(Object.create(Graph))).toBeFalsy()
})
})
describe('isPlainArray', () => {
it('should return `true` for plain arrays', () => {
expect(isPlainArray([1, 2])).toEqual(true)
})
it('should return `false` for non plain arrays', () => {
expect(isPlainArray(Object.assign([1, 2], { a: 'b' }))).toEqual(false)
})
})
describe('partialMatchKey', () => {
it('should return `true` if a includes b', () => {
const a = [{ a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }]
const b = [{ a: { b: 'b' }, c: 'c', d: [] }]
expect(partialMatchKey(a, b)).toEqual(true)
})
it('should return `false` if a does not include b', () => {
const a = [{ a: { b: 'b' }, c: 'c', d: [] }]
const b = [{ a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }]
expect(partialMatchKey(a, b)).toEqual(false)
})
it('should return `true` if array a includes array b', () => {
const a = [1, 2, 3]
const b = [1, 2]
expect(partialMatchKey(a, b)).toEqual(true)
})
it('should return `false` if a is null and b is not', () => {
const a = [null]
const b = [{ a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }]
expect(partialMatchKey(a, b)).toEqual(false)
})
it('should return `false` if a contains null and b is not', () => {
const a = [{ a: null, c: 'c', d: [] }]
const b = [{ a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }]
expect(partialMatchKey(a, b)).toEqual(false)
})
it('should return `false` if b is null and a is not', () => {
const a = [{ a: { b: 'b' }, c: 'c', d: [] }]
const b = [null]
expect(partialMatchKey(a, b)).toEqual(false)
})
it('should return `false` if b contains null and a is not', () => {
const a = [{ a: { b: 'b' }, c: 'c', d: [] }]
const b = [{ a: null, c: 'c', d: [{ d: 'd ' }] }]
expect(partialMatchKey(a, b)).toEqual(false)
})
})
describe('replaceEqualDeep', () => {
it('should return the previous value when the next value is an equal primitive', () => {
expect(replaceEqualDeep(1, 1)).toBe(1)
expect(replaceEqualDeep('1', '1')).toBe('1')
expect(replaceEqualDeep(true, true)).toBe(true)
expect(replaceEqualDeep(false, false)).toBe(false)
expect(replaceEqualDeep(null, null)).toBe(null)
expect(replaceEqualDeep(undefined, undefined)).toBe(undefined)
})
it('should return the next value when the previous value is a different value', () => {
const date1 = new Date()
const date2 = new Date()
expect(replaceEqualDeep(1, 0)).toBe(0)
expect(replaceEqualDeep(1, 2)).toBe(2)
expect(replaceEqualDeep('1', '2')).toBe('2')
expect(replaceEqualDeep(true, false)).toBe(false)
expect(replaceEqualDeep(false, true)).toBe(true)
expect(replaceEqualDeep(date1, date2)).toBe(date2)
})
it('should return the next value when the previous value is a different type', () => {
const array = [1]
const object = { a: 'a' }
expect(replaceEqualDeep(0, undefined)).toBe(undefined)
expect(replaceEqualDeep(undefined, 0)).toBe(0)
expect(replaceEqualDeep(2, undefined)).toBe(undefined)
expect(replaceEqualDeep(undefined, 2)).toBe(2)
expect(replaceEqualDeep(undefined, null)).toBe(null)
expect(replaceEqualDeep(null, undefined)).toBe(undefined)
expect(replaceEqualDeep({}, undefined)).toBe(undefined)
expect(replaceEqualDeep([], undefined)).toBe(undefined)
expect(replaceEqualDeep(array, object)).toBe(object)
expect(replaceEqualDeep(object, array)).toBe(array)
})
it('should return the previous value when the next value is an equal array', () => {
const prev = [1, 2]
const next = [1, 2]
expect(replaceEqualDeep(prev, next)).toBe(prev)
})
it('should return a copy when the previous value is a different array subset', () => {
const prev = [1, 2]
const next = [1, 2, 3]
const result = replaceEqualDeep(prev, next)
expect(result).toEqual(next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
})
it('should return a copy when the previous value is a different array superset', () => {
const prev = [1, 2, 3]
const next = [1, 2]
const result = replaceEqualDeep(prev, next)
expect(result).toEqual(next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
})
it('should return the previous value when the next value is an equal empty array', () => {
const prev: Array<any> = []
const next: Array<any> = []
expect(replaceEqualDeep(prev, next)).toBe(prev)
})
it('should return the previous value when the next value is an equal empty object', () => {
const prev = {}
const next = {}
expect(replaceEqualDeep(prev, next)).toBe(prev)
})
it('should return the previous value when the next value is an equal object', () => {
const prev = { a: 'a' }
const next = { a: 'a' }
expect(replaceEqualDeep(prev, next)).toBe(prev)
})
it('should replace different values in objects', () => {
const prev = { a: { b: 'b' }, c: 'c' }
const next = { a: { b: 'b' }, c: 'd' }
const result = replaceEqualDeep(prev, next)
expect(result).toEqual(next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
expect(result.a).toBe(prev.a)
expect(result.c).toBe(next.c)
})
it('should replace different values in arrays', () => {
const prev = [1, { a: 'a' }, { b: { b: 'b' } }, [1]] as const
const next = [1, { a: 'a' }, { b: { b: 'c' } }, [1]] as const
const result = replaceEqualDeep(prev, next)
expect(result).toEqual(next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
expect(result[0]).toBe(prev[0])
expect(result[1]).toBe(prev[1])
expect(result[2]).not.toBe(next[2])
expect(result[2].b.b).toBe(next[2].b.b)
expect(result[3]).toBe(prev[3])
})
it('should replace different values in arrays when the next value is a subset', () => {
const prev = [{ a: 'a' }, { b: 'b' }, { c: 'c' }]
const next = [{ a: 'a' }, { b: 'b' }]
const result = replaceEqualDeep(prev, next)
expect(result).toEqual(next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
expect(result[0]).toBe(prev[0])
expect(result[1]).toBe(prev[1])
expect(result[2]).toBeUndefined()
})
it('should replace different values in arrays when the next value is a superset', () => {
const prev = [{ a: 'a' }, { b: 'b' }]
const next = [{ a: 'a' }, { b: 'b' }, { c: 'c' }]
const result = replaceEqualDeep(prev, next)
expect(result).toEqual(next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
expect(result[0]).toBe(prev[0])
expect(result[1]).toBe(prev[1])
expect(result[2]).toBe(next[2])
})
it('should copy objects which are not arrays or objects', () => {
const prev = [{ a: 'a' }, { b: 'b' }, { c: 'c' }, 1]
const next = [{ a: 'a' }, new Map(), { c: 'c' }, 2]
const result = replaceEqualDeep(prev, next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
expect(result[0]).toBe(prev[0])
expect(result[1]).toBe(next[1])
expect(result[2]).toBe(prev[2])
expect(result[3]).toBe(next[3])
})
it('should support equal objects which are not arrays or objects', () => {
const map = new Map()
const prev = [map, [1]]
const next = [map, [1]]
const result = replaceEqualDeep(prev, next)
expect(result).toBe(prev)
})
it('should support non equal objects which are not arrays or objects', () => {
const map1 = new Map()
const map2 = new Map()
const prev = [map1, [1]]
const next = [map2, [1]]
const result = replaceEqualDeep(prev, next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
expect(result[0]).toBe(next[0])
expect(result[1]).toBe(prev[1])
})
it('should support objects which are not plain arrays', () => {
const prev = Object.assign([1, 2], { a: { b: 'b' }, c: 'c' })
const next = Object.assign([1, 2], { a: { b: 'b' }, c: 'c' })
const result = replaceEqualDeep(prev, next)
expect(result).toBe(next)
})
it('should replace all parent objects if some nested value changes', () => {
const prev = {
todo: { id: '1', meta: { createdAt: 0 }, state: { done: false } },
otherTodo: { id: '2', meta: { createdAt: 0 }, state: { done: true } },
}
const next = {
todo: { id: '1', meta: { createdAt: 0 }, state: { done: true } },
otherTodo: { id: '2', meta: { createdAt: 0 }, state: { done: true } },
}
const result = replaceEqualDeep(prev, next)
expect(result).toEqual(next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
expect(result.todo).not.toBe(prev.todo)
expect(result.todo).not.toBe(next.todo)
expect(result.todo.id).toBe(next.todo.id)
expect(result.todo.meta).toBe(prev.todo.meta)
expect(result.todo.state).not.toBe(next.todo.state)
expect(result.todo.state.done).toBe(next.todo.state.done)
expect(result.otherTodo).toBe(prev.otherTodo)
})
it('should replace all parent arrays if some nested value changes', () => {
const prev = {
todos: [
{ id: '1', meta: { createdAt: 0 }, state: { done: false } },
{ id: '2', meta: { createdAt: 0 }, state: { done: true } },
],
}
const next = {
todos: [
{ id: '1', meta: { createdAt: 0 }, state: { done: true } },
{ id: '2', meta: { createdAt: 0 }, state: { done: true } },
],
}
const result = replaceEqualDeep(prev, next)
expect(result).toEqual(next)
expect(result).not.toBe(prev)
expect(result).not.toBe(next)
expect(result.todos).not.toBe(prev.todos)
expect(result.todos).not.toBe(next.todos)
expect(result.todos[0]).not.toBe(prev.todos[0])
expect(result.todos[0]).not.toBe(next.todos[0])
expect(result.todos[0]?.id).toBe(next.todos[0]?.id)
expect(result.todos[0]?.meta).toBe(prev.todos[0]?.meta)
expect(result.todos[0]?.state).not.toBe(next.todos[0]?.state)
expect(result.todos[0]?.state.done).toBe(next.todos[0]?.state.done)
expect(result.todos[1]).toBe(prev.todos[1])
})
})
describe('matchMutation', () => {
it('should return false if mutationKey options is undefined', () => {
const filters = { mutationKey: ['key1'] }
const queryClient = createQueryClient()
const mutation = new Mutation({
mutationId: 1,
mutationCache: queryClient.getMutationCache(),
options: {},
})
expect(matchMutation(filters, mutation)).toBeFalsy()
})
})
describe('scheduleMicrotask', () => {
it('should defer execution of callback', async () => {
const callback = vi.fn()
scheduleMicrotask(callback)
expect(callback).not.toHaveBeenCalled()
await sleep(0)
expect(callback).toHaveBeenCalledTimes(1)
})
})
describe('addToEnd', () => {
it('should add item to the end of the array', () => {
const items = [1, 2, 3]
const newItems = addToEnd(items, 4)
expect(newItems).toEqual([1, 2, 3, 4])
})
it('should not exceed max if provided', () => {
const items = [1, 2, 3]
const newItems = addToEnd(items, 4, 3)
expect(newItems).toEqual([2, 3, 4])
})
it('should add item to the end of the array when max = 0', () => {
const items = [1, 2, 3]
const item = 4
const max = 0
expect(addToEnd(items, item, max)).toEqual([1, 2, 3, 4])
})
it('should add item to the end of the array when max is undefined', () => {
const items = [1, 2, 3]
const item = 4
const max = undefined
expect(addToEnd(items, item, max)).toEqual([1, 2, 3, 4])
})
})
describe('addToStart', () => {
it('should add an item to the start of the array', () => {
const items = [1, 2, 3]
const item = 4
const newItems = addToStart(items, item)
expect(newItems).toEqual([4, 1, 2, 3])
})
it('should respect the max argument', () => {
const items = [1, 2, 3]
const item = 4
const max = 2
const newItems = addToStart(items, item, max)
expect(newItems).toEqual([4, 1, 2])
})
it('should not remove any items if max = 0', () => {
const items = [1, 2, 3]
const item = 4
const max = 0
const newItems = addToStart(items, item, max)
expect(newItems).toEqual([4, 1, 2, 3])
})
it('should not remove any items if max is undefined', () => {
const items = [1, 2, 3]
const item = 4
const max = 0
const newItems = addToStart(items, item, max)
expect(newItems).toEqual([4, 1, 2, 3])
})
})
})
|
3,899 | 0 | petrpan-code/TanStack/query/packages/query-devtools/src | petrpan-code/TanStack/query/packages/query-devtools/src/__tests__/devtools.test.tsx | import { describe, expect, it } from 'vitest'
describe('ReactQueryDevtools', () => {
it('should be able to open and close devtools', async () => {
expect(1).toBe(1)
})
})
|
3,900 | 0 | petrpan-code/TanStack/query/packages/query-devtools/src | petrpan-code/TanStack/query/packages/query-devtools/src/__tests__/utils.test.ts | import { describe, expect, it } from 'vitest'
import { deleteNestedDataByPath, updateNestedDataByPath } from '../utils'
describe('Utils tests', () => {
describe('updatedNestedDataByPath', () => {
describe('array', () => {
it('should update data correctly', async () => {
const oldData = ['one', 'two', 'three']
const newData = updateNestedDataByPath(oldData, ['1'], 'new')
expect(newData).not.toBe(oldData) // should not be the same reference
expect(oldData).toMatchInlineSnapshot(`
[
"one",
"two",
"three",
]
`)
expect(newData).toMatchInlineSnapshot(`
[
"one",
"new",
"three",
]
`)
})
})
describe('object', () => {
it('should update data correctly', async () => {
const oldData = { title: 'Hello world', id: 1, createdAt: '2021-01-01' }
const newData = updateNestedDataByPath(
oldData,
['title'],
'Brave new world',
)
expect(newData).not.toBe(oldData) // should not be the same reference
expect(oldData).toMatchInlineSnapshot(`
{
"createdAt": "2021-01-01",
"id": 1,
"title": "Hello world",
}
`)
expect(newData).toMatchInlineSnapshot(`
{
"createdAt": "2021-01-01",
"id": 1,
"title": "Brave new world",
}
`)
})
})
describe('set', () => {
it('should update data correctly', async () => {
const oldData = new Set([123, 321, 'hello', 'world'])
const newData = updateNestedDataByPath(oldData, ['2'], 'hi')
expect(newData).not.toBe(oldData) // should not be the same reference
expect(oldData).toMatchInlineSnapshot(`
Set {
123,
321,
"hello",
"world",
}
`)
expect(newData).toMatchInlineSnapshot(`
Set {
123,
321,
"hi",
"world",
}
`)
})
})
describe('map', () => {
it('should update data correctly', async () => {
const oldData = new Map([
['en', 'hello'],
['fr', 'bonjour'],
])
const newData = updateNestedDataByPath(oldData, ['fr'], 'salut')
expect(newData).not.toBe(oldData) // should not be the same reference
expect(oldData).toMatchInlineSnapshot(`
Map {
"en" => "hello",
"fr" => "bonjour",
}
`)
expect(newData).toMatchInlineSnapshot(`
Map {
"en" => "hello",
"fr" => "salut",
}
`)
})
})
describe('nested data', () => {
it('should update data correctly', async () => {
const oldData = new Map([
[
'pumpkin-pie',
{
id: 1,
title: 'Pumpkin pie',
ingredients: new Set(['pumpkin', 'sugar', 'spices']),
steps: ['mix', 'bake', 'eat'],
translations: new Map([
['en', 'Pumpkin pie'],
['fr', 'Tarte à la citrouille'],
]),
},
],
[
'spaghetti-bolonese',
{
id: 2,
title: 'Spaghetti bolonese',
ingredients: new Set([
'spaghetti',
'tomato sauce',
'minced meat',
]),
steps: ['cook', 'eat'],
translations: new Map([
['en', 'Spaghetti bolonese'],
['fr', 'Spaghetti bolonaise'],
]),
},
],
])
const updatedObject = updateNestedDataByPath(
oldData,
['pumpkin-pie', 'title'],
'Pumpkin pie with whipped cream',
)
const updatedArray = updateNestedDataByPath(
oldData,
['spaghetti-bolonese', 'steps', '0'],
'prepare',
)
const updatedSet = updateNestedDataByPath(
oldData,
['pumpkin-pie', 'ingredients', '1'],
'honey',
)
const updatedMap = updateNestedDataByPath(
oldData,
['pumpkin-pie', 'translations', 'en'],
'Best pie ever',
)
expect(oldData).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"sugar",
"spices",
},
"steps": [
"mix",
"bake",
"eat",
],
"title": "Pumpkin pie",
"translations": Map {
"en" => "Pumpkin pie",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"spaghetti",
"tomato sauce",
"minced meat",
},
"steps": [
"cook",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
"fr" => "Spaghetti bolonaise",
},
},
}
`)
expect(updatedObject).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"sugar",
"spices",
},
"steps": [
"mix",
"bake",
"eat",
],
"title": "Pumpkin pie with whipped cream",
"translations": Map {
"en" => "Pumpkin pie",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"spaghetti",
"tomato sauce",
"minced meat",
},
"steps": [
"cook",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
"fr" => "Spaghetti bolonaise",
},
},
}
`)
expect(updatedArray).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"sugar",
"spices",
},
"steps": [
"mix",
"bake",
"eat",
],
"title": "Pumpkin pie",
"translations": Map {
"en" => "Pumpkin pie",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"spaghetti",
"tomato sauce",
"minced meat",
},
"steps": [
"prepare",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
"fr" => "Spaghetti bolonaise",
},
},
}
`)
expect(updatedSet).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"honey",
"spices",
},
"steps": [
"mix",
"bake",
"eat",
],
"title": "Pumpkin pie",
"translations": Map {
"en" => "Pumpkin pie",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"spaghetti",
"tomato sauce",
"minced meat",
},
"steps": [
"cook",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
"fr" => "Spaghetti bolonaise",
},
},
}
`)
expect(updatedMap).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"sugar",
"spices",
},
"steps": [
"mix",
"bake",
"eat",
],
"title": "Pumpkin pie",
"translations": Map {
"en" => "Best pie ever",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"spaghetti",
"tomato sauce",
"minced meat",
},
"steps": [
"cook",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
"fr" => "Spaghetti bolonaise",
},
},
}
`)
})
})
})
describe('deleteNestedDataByPath', () => {
it('should delete item from array correctly', async () => {
const oldData = ['one', 'two', 'three']
const newData = deleteNestedDataByPath(oldData, ['1'])
expect(newData).not.toBe(oldData) // should not be the same reference
expect(oldData).toMatchInlineSnapshot(`
[
"one",
"two",
"three",
]
`)
expect(newData).toMatchInlineSnapshot(`
[
"one",
"three",
]
`)
})
it('should delete item from object correctly', async () => {
const oldData = { title: 'Hello world', id: 1, createdAt: '2021-01-01' }
const newData = deleteNestedDataByPath(oldData, ['createdAt'])
expect(newData).not.toBe(oldData) // should not be the same reference
expect(oldData).toMatchInlineSnapshot(`
{
"createdAt": "2021-01-01",
"id": 1,
"title": "Hello world",
}
`)
expect(newData).toMatchInlineSnapshot(`
{
"id": 1,
"title": "Hello world",
}
`)
})
it('should delete item from set', () => {
const oldData = new Set([123, 321, false, true])
const newData = deleteNestedDataByPath(oldData, ['1'])
expect(newData).not.toBe(oldData) // should not be the same reference
expect(oldData).toMatchInlineSnapshot(`
Set {
123,
321,
false,
true,
}
`)
expect(newData).toMatchInlineSnapshot(`
Set {
123,
false,
true,
}
`)
})
it('should delete item from map', () => {
const oldData = new Map([
['123', 'one'],
['hello', 'two'],
['world', 'three'],
])
const newData = deleteNestedDataByPath(oldData, ['world'])
expect(newData).not.toBe(oldData) // should not be the same reference
expect(oldData).toMatchInlineSnapshot(`
Map {
"123" => "one",
"hello" => "two",
"world" => "three",
}
`)
expect(newData).toMatchInlineSnapshot(`
Map {
"123" => "one",
"hello" => "two",
}
`)
})
describe('nested data', () => {
it('should delete nested items correctly', async () => {
const oldData = new Map([
[
'pumpkin-pie',
{
id: 1,
title: 'Pumpkin pie',
ingredients: new Set(['pumpkin', 'sugar', 'spices']),
steps: ['mix', 'bake', 'eat'],
translations: new Map([
['en', 'Pumpkin pie'],
['fr', 'Tarte à la citrouille'],
]),
},
],
[
'spaghetti-bolonese',
{
id: 2,
title: 'Spaghetti bolonese',
ingredients: new Set([
'spaghetti',
'tomato sauce',
'minced meat',
]),
steps: ['cook', 'eat'],
translations: new Map([
['en', 'Spaghetti bolonese'],
['fr', 'Spaghetti bolonaise'],
]),
},
],
])
const deletedFromSet = deleteNestedDataByPath(oldData, [
'spaghetti-bolonese',
'ingredients',
'0',
])
const deletedFromArray = deleteNestedDataByPath(oldData, [
'pumpkin-pie',
'steps',
'1',
])
const deletedFromObject = deleteNestedDataByPath(oldData, [
'pumpkin-pie',
'title',
])
const deletedFromMap = deleteNestedDataByPath(oldData, [
'spaghetti-bolonese',
'translations',
'fr',
])
expect(oldData).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"sugar",
"spices",
},
"steps": [
"mix",
"bake",
"eat",
],
"title": "Pumpkin pie",
"translations": Map {
"en" => "Pumpkin pie",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"spaghetti",
"tomato sauce",
"minced meat",
},
"steps": [
"cook",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
"fr" => "Spaghetti bolonaise",
},
},
}
`)
expect(deletedFromSet).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"sugar",
"spices",
},
"steps": [
"mix",
"bake",
"eat",
],
"title": "Pumpkin pie",
"translations": Map {
"en" => "Pumpkin pie",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"tomato sauce",
"minced meat",
},
"steps": [
"cook",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
"fr" => "Spaghetti bolonaise",
},
},
}
`)
expect(deletedFromArray).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"sugar",
"spices",
},
"steps": [
"mix",
"eat",
],
"title": "Pumpkin pie",
"translations": Map {
"en" => "Pumpkin pie",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"spaghetti",
"tomato sauce",
"minced meat",
},
"steps": [
"cook",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
"fr" => "Spaghetti bolonaise",
},
},
}
`)
expect(deletedFromObject).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"sugar",
"spices",
},
"steps": [
"mix",
"bake",
"eat",
],
"translations": Map {
"en" => "Pumpkin pie",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"spaghetti",
"tomato sauce",
"minced meat",
},
"steps": [
"cook",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
"fr" => "Spaghetti bolonaise",
},
},
}
`)
expect(deletedFromMap).toMatchInlineSnapshot(`
Map {
"pumpkin-pie" => {
"id": 1,
"ingredients": Set {
"pumpkin",
"sugar",
"spices",
},
"steps": [
"mix",
"bake",
"eat",
],
"title": "Pumpkin pie",
"translations": Map {
"en" => "Pumpkin pie",
"fr" => "Tarte à la citrouille",
},
},
"spaghetti-bolonese" => {
"id": 2,
"ingredients": Set {
"spaghetti",
"tomato sauce",
"minced meat",
},
"steps": [
"cook",
"eat",
],
"title": "Spaghetti bolonese",
"translations": Map {
"en" => "Spaghetti bolonese",
},
},
}
`)
})
})
})
})
|
3,911 | 0 | petrpan-code/TanStack/query/packages/query-persist-client-core/src | petrpan-code/TanStack/query/packages/query-persist-client-core/src/__tests__/createPersister.test.ts | import { describe, expect, test, vi } from 'vitest'
import { Query, QueryCache, hashKey } from '@tanstack/query-core'
import {
PERSISTER_KEY_PREFIX,
experimental_createPersister,
} from '../createPersister'
import { sleep } from './utils'
import type { StoragePersisterOptions } from '../createPersister'
import type { QueryKey } from '@tanstack/query-core'
function getFreshStorage() {
const storage = new Map()
return {
getItem: (key: string) => Promise.resolve(storage.get(key)),
setItem: async (key: string, value: unknown) => {
storage.set(key, value)
},
removeItem: async (key: string) => {
storage.delete(key)
},
}
}
function setupPersister(
queryKey: QueryKey,
persisterOptions: StoragePersisterOptions,
) {
const context = {
meta: { foo: 'bar' },
queryKey,
// @ts-ignore
signal: undefined as AbortSignal,
}
const queryHash = hashKey(queryKey)
const storageKey = `${PERSISTER_KEY_PREFIX}-${queryHash}`
const queryFn = vi.fn()
const persisterFn = experimental_createPersister(persisterOptions)
const query = new Query({
cache: new QueryCache(),
queryHash,
queryKey,
})
return {
context,
persisterFn,
query,
queryFn,
queryHash,
queryKey,
storageKey,
}
}
describe('createPersister', () => {
test('should fetch if storage is not provided', async () => {
const { context, persisterFn, query, queryFn } = setupPersister(['foo'], {
storage: undefined,
})
await persisterFn(queryFn, context, query)
expect(queryFn).toHaveBeenCalledOnce()
expect(queryFn).toHaveBeenCalledWith(context)
})
test('should fetch if there is no stored data', async () => {
const storage = getFreshStorage()
const { context, persisterFn, query, queryFn } = setupPersister(['foo'], {
storage,
})
await persisterFn(queryFn, context, query)
expect(queryFn).toHaveBeenCalledOnce()
expect(queryFn).toHaveBeenCalledWith(context)
})
test('should fetch if query already has data', async () => {
const storage = getFreshStorage()
const { context, persisterFn, query, queryFn } = setupPersister(['foo'], {
storage,
})
query.state.data = 'baz'
await persisterFn(queryFn, context, query)
expect(queryFn).toHaveBeenCalledOnce()
expect(queryFn).toHaveBeenCalledWith(context)
})
test('should fetch if deserialization fails', async () => {
const storage = getFreshStorage()
const { context, persisterFn, query, queryFn, storageKey } = setupPersister(
['foo'],
{
storage,
},
)
await storage.setItem(storageKey, '{invalid[item')
await persisterFn(queryFn, context, query)
expect(await storage.getItem(storageKey)).toBeUndefined()
expect(queryFn).toHaveBeenCalledOnce()
expect(queryFn).toHaveBeenCalledWith(context)
})
test('should remove stored item if `dataUpdatedAt` is empty', async () => {
const storage = getFreshStorage()
const { context, persisterFn, query, queryFn, storageKey } = setupPersister(
['foo'],
{
storage,
},
)
await storage.setItem(
storageKey,
JSON.stringify({
buster: '',
state: { dataUpdatedAt: undefined },
}),
)
await persisterFn(queryFn, context, query)
expect(await storage.getItem(storageKey)).toBeUndefined()
expect(queryFn).toHaveBeenCalledOnce()
expect(queryFn).toHaveBeenCalledWith(context)
})
test('should remove stored item if its expired', async () => {
const storage = getFreshStorage()
const { context, persisterFn, query, queryFn, storageKey } = setupPersister(
['foo'],
{
storage,
maxAge: 100,
},
)
await storage.setItem(
storageKey,
JSON.stringify({
buster: '',
state: { dataUpdatedAt: Date.now() - 200 },
}),
)
await persisterFn(queryFn, context, query)
expect(await storage.getItem(storageKey)).toBeUndefined()
expect(queryFn).toHaveBeenCalledOnce()
expect(queryFn).toHaveBeenCalledWith(context)
})
test('should remove stored item if its busted', async () => {
const storage = getFreshStorage()
const { context, persisterFn, query, queryFn, storageKey } = setupPersister(
['foo'],
{
storage,
},
)
await storage.setItem(
storageKey,
JSON.stringify({
buster: 'bust',
state: { dataUpdatedAt: Date.now() },
}),
)
await persisterFn(queryFn, context, query)
expect(await storage.getItem(storageKey)).toBeUndefined()
expect(queryFn).toHaveBeenCalledOnce()
expect(queryFn).toHaveBeenCalledWith(context)
})
test('should restore item from the storage and set proper `updatedAt` values', async () => {
const storage = getFreshStorage()
const { context, persisterFn, query, queryFn, storageKey } = setupPersister(
['foo'],
{
storage,
},
)
const dataUpdatedAt = Date.now()
await storage.setItem(
storageKey,
JSON.stringify({
buster: '',
state: { dataUpdatedAt },
}),
)
await persisterFn(queryFn, context, query)
query.state.dataUpdatedAt = 0
query.fetch = vi.fn()
expect(query.state.dataUpdatedAt).toEqual(0)
await sleep(0)
expect(queryFn).toHaveBeenCalledTimes(0)
expect(query.fetch).toHaveBeenCalledTimes(0)
expect(query.state.dataUpdatedAt).toEqual(dataUpdatedAt)
})
test('should restore item from the storage and refetch when `stale`', async () => {
const storage = getFreshStorage()
const { context, persisterFn, query, queryFn, storageKey } = setupPersister(
['foo'],
{
storage,
},
)
await storage.setItem(
storageKey,
JSON.stringify({
buster: '',
state: { dataUpdatedAt: Date.now() },
}),
)
await persisterFn(queryFn, context, query)
query.state.isInvalidated = true
query.fetch = vi.fn()
await sleep(0)
expect(queryFn).toHaveBeenCalledTimes(0)
expect(query.fetch).toHaveBeenCalledTimes(1)
})
test('should store item after successfull fetch', async () => {
const storage = getFreshStorage()
const {
context,
persisterFn,
query,
queryFn,
queryHash,
queryKey,
storageKey,
} = setupPersister(['foo'], {
storage,
})
await persisterFn(queryFn, context, query)
query.setData('baz')
await sleep(0)
expect(queryFn).toHaveBeenCalledOnce()
expect(queryFn).toHaveBeenCalledWith(context)
expect(JSON.parse(await storage.getItem(storageKey))).toMatchObject({
buster: '',
queryHash,
queryKey,
state: {
data: 'baz',
},
})
})
test('should skip stored item if not matched by filters', async () => {
const storage = getFreshStorage()
const { context, persisterFn, query, queryFn, storageKey } = setupPersister(
['foo'],
{
storage,
filters: {
predicate: () => {
return false
},
},
},
)
const dataUpdatedAt = Date.now()
await storage.setItem(
storageKey,
JSON.stringify({
buster: '',
state: { dataUpdatedAt },
}),
)
await persisterFn(queryFn, context, query)
query.fetch = vi.fn()
await sleep(0)
expect(queryFn).toHaveBeenCalledTimes(1)
expect(query.fetch).toHaveBeenCalledTimes(0)
})
})
|
3,912 | 0 | petrpan-code/TanStack/query/packages/query-persist-client-core/src | petrpan-code/TanStack/query/packages/query-persist-client-core/src/__tests__/persist.test.ts | import { describe, expect, test, vi } from 'vitest'
import { QueriesObserver } from '@tanstack/query-core'
import { persistQueryClientSubscribe } from '../persist'
import {
createMockPersister,
createQueryClient,
createSpyablePersister,
} from './utils'
describe('persistQueryClientSubscribe', () => {
test('should persist mutations', async () => {
const queryClient = createQueryClient()
const persister = createMockPersister()
const unsubscribe = persistQueryClientSubscribe({
queryClient,
persister,
dehydrateOptions: { shouldDehydrateMutation: () => true },
})
queryClient.getMutationCache().build(queryClient, {
mutationFn: async (text: string) => text,
})
const result = await persister.restoreClient()
expect(result?.clientState.mutations).toHaveLength(1)
unsubscribe()
})
})
describe('persistQueryClientSave', () => {
test('should not be triggered on observer type events', async () => {
const queryClient = createQueryClient()
const persister = createSpyablePersister()
const unsubscribe = persistQueryClientSubscribe({
queryClient,
persister,
})
const queryKey = ['test']
const queryFn = vi.fn().mockReturnValue(1)
const observer = new QueriesObserver(queryClient, [{ queryKey, queryFn }])
const unsubscribeObserver = observer.subscribe(vi.fn())
observer.getObservers()[0]?.setOptions({ refetchOnWindowFocus: false })
unsubscribeObserver()
queryClient.setQueryData(queryKey, 2)
// persistClient should be called 3 times:
// 1. When query is added
// 2. When queryFn is resolved
// 3. When setQueryData is called
// All events fired by manipulating observers are ignored
expect(persister.persistClient).toHaveBeenCalledTimes(3)
unsubscribe()
})
})
|
3,920 | 0 | petrpan-code/TanStack/query/packages/query-sync-storage-persister/src | petrpan-code/TanStack/query/packages/query-sync-storage-persister/src/__tests__/storageIsFull.test.ts | import { describe, expect, test } from 'vitest'
import {
MutationCache,
QueryCache,
QueryClient,
dehydrate,
} from '@tanstack/query-core'
import { removeOldestQuery } from '@tanstack/query-persist-client-core'
import { createSyncStoragePersister } from '../index'
import { sleep } from './utils'
function getMockStorage(limitSize?: number) {
const dataSet = new Map<string, string>()
return {
getItem(key: string): string | null {
const value = dataSet.get(key)
return value === undefined ? null : value
},
setItem(key: string, value: string) {
if (typeof limitSize !== 'undefined') {
const currentSize = Array.from(dataSet.entries()).reduce(
(n, d) => d[0].length + d[1].length + n,
0,
)
if (
currentSize - (dataSet.get(key)?.length || 0) + value.length >
limitSize
) {
throw Error(
`Failed to execute 'setItem' on 'Storage': Setting the value of '${key}' exceeded the quota.`,
)
}
}
return dataSet.set(key, value)
},
removeItem(key: string) {
return dataSet.delete(key)
},
} as any as Storage
}
describe('createpersister ', () => {
test('basic store and recover', async () => {
const queryCache = new QueryCache()
const mutationCache = new MutationCache()
const queryClient = new QueryClient({ queryCache, mutationCache })
const storage = getMockStorage()
const persister = createSyncStoragePersister({
throttleTime: 0,
storage,
})
await queryClient.prefetchQuery({
queryKey: ['string'],
queryFn: () => Promise.resolve('string'),
})
await queryClient.prefetchQuery({
queryKey: ['number'],
queryFn: () => Promise.resolve(1),
})
await queryClient.prefetchQuery({
queryKey: ['boolean'],
queryFn: () => Promise.resolve(true),
})
await queryClient.prefetchQuery({
queryKey: ['null'],
queryFn: () => Promise.resolve(null),
})
await queryClient.prefetchQuery({
queryKey: ['array'],
queryFn: () => Promise.resolve(['string', 0]),
})
const persistClient = {
buster: 'test-buster',
timestamp: Date.now(),
clientState: dehydrate(queryClient),
}
persister.persistClient(persistClient)
await sleep(1)
const restoredClient = await persister.restoreClient()
expect(restoredClient).toEqual(persistClient)
})
test('should clean the old queries when storage full', async () => {
const queryCache = new QueryCache()
const mutationCache = new MutationCache()
const queryClient = new QueryClient({ queryCache, mutationCache })
const N = 2000
const storage = getMockStorage(N * 5) // can save 4 items;
const persister = createSyncStoragePersister({
throttleTime: 0,
storage,
retry: removeOldestQuery,
})
await queryClient.prefetchQuery({
queryKey: ['A'],
queryFn: () => Promise.resolve('A'.repeat(N)),
})
await sleep(1)
await queryClient.prefetchQuery({
queryKey: ['B'],
queryFn: () => Promise.resolve('B'.repeat(N)),
})
await sleep(1)
await queryClient.prefetchQuery({
queryKey: ['C'],
queryFn: () => Promise.resolve('C'.repeat(N)),
})
await sleep(1)
await queryClient.prefetchQuery({
queryKey: ['D'],
queryFn: () => Promise.resolve('D'.repeat(N)),
})
await sleep(1)
await queryClient.prefetchQuery({
queryKey: ['E'],
queryFn: () => Promise.resolve('E'.repeat(N)),
})
const persistClient = {
buster: 'test-limit',
timestamp: Date.now(),
clientState: dehydrate(queryClient),
}
persister.persistClient(persistClient)
await sleep(10)
const restoredClient = await persister.restoreClient()
expect(restoredClient?.clientState.queries.length).toEqual(4)
expect(
restoredClient?.clientState.queries.find((q) => q.queryKey[0] === 'A'),
).toBeUndefined()
expect(
restoredClient?.clientState.queries.find((q) => q.queryKey[0] === 'B'),
).not.toBeUndefined()
// update query Data
await queryClient.prefetchQuery({
queryKey: ['A'],
queryFn: () => Promise.resolve('a'.repeat(N)),
})
const updatedPersistClient = {
buster: 'test-limit',
timestamp: Date.now(),
clientState: dehydrate(queryClient),
}
persister.persistClient(updatedPersistClient)
await sleep(10)
const restoredClient2 = await persister.restoreClient()
expect(restoredClient2?.clientState.queries.length).toEqual(4)
expect(
restoredClient2?.clientState.queries.find((q) => q.queryKey[0] === 'A'),
).toHaveProperty('state.data', 'a'.repeat(N))
expect(
restoredClient2?.clientState.queries.find((q) => q.queryKey[0] === 'B'),
).toBeUndefined()
})
test('should clear storage as default error handling', async () => {
const queryCache = new QueryCache()
const mutationCache = new MutationCache()
const queryClient = new QueryClient({ queryCache, mutationCache })
const N = 2000
const storage = getMockStorage(0)
const persister = createSyncStoragePersister({
throttleTime: 0,
storage,
retry: removeOldestQuery,
})
await queryClient.prefetchQuery({
queryKey: ['A'],
queryFn: () => Promise.resolve('A'.repeat(N)),
})
await sleep(1)
const persistClient = {
buster: 'test-limit',
timestamp: Date.now(),
clientState: dehydrate(queryClient),
}
persister.persistClient(persistClient)
await sleep(10)
const restoredClient = await persister.restoreClient()
expect(restoredClient).toEqual(undefined)
})
})
|
3,931 | 0 | petrpan-code/TanStack/query/packages/react-query-devtools/src | petrpan-code/TanStack/query/packages/react-query-devtools/src/__tests__/devtools.test.tsx | import { describe, expect, it } from 'vitest'
describe('ReactQueryDevtools', () => {
it('should be able to open and close devtools', async () => {
expect(1).toBe(1)
})
})
|
3,950 | 0 | petrpan-code/TanStack/query/packages/react-query-persist-client/src | petrpan-code/TanStack/query/packages/react-query-persist-client/src/__tests__/PersistQueryClientProvider.test.tsx | import { describe, expect, test, vi } from 'vitest'
import * as React from 'react'
import { fireEvent, render, waitFor } from '@testing-library/react'
import { QueryClient, useQueries, useQuery } from '@tanstack/react-query'
import { persistQueryClientSave } from '@tanstack/query-persist-client-core'
import { PersistQueryClientProvider } from '../PersistQueryClientProvider'
import { createQueryClient, queryKey, sleep } from './utils'
import type {
PersistedClient,
Persister,
} from '@tanstack/query-persist-client-core'
import type {
DefinedUseQueryResult,
UseQueryResult,
} from '@tanstack/react-query'
const createMockPersister = (): Persister => {
let storedState: PersistedClient | undefined
return {
async persistClient(persistClient: PersistedClient) {
storedState = persistClient
},
async restoreClient() {
await sleep(10)
return storedState
},
removeClient() {
storedState = undefined
},
}
}
const createMockErrorPersister = (
removeClient: Persister['removeClient'],
): [Error, Persister] => {
const error = new Error('restore failed')
return [
error,
{
async persistClient() {
// noop
},
async restoreClient() {
await sleep(10)
throw error
},
removeClient,
},
]
}
describe('PersistQueryClientProvider', () => {
test('restores cache from persister', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
})
states.push(state)
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
const rendered = render(
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>,
)
await waitFor(() => rendered.getByText('fetchStatus: idle'))
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
expect(states).toHaveLength(4)
expect(states[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[2]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[3]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'fetched',
})
})
test('should subscribe correctly in StrictMode', async () => {
const key = queryKey()
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
})
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
<button
onClick={() => {
queryClient.setQueryData(key, 'updated')
}}
>
update
</button>
</div>
)
}
const rendered = render(
<React.StrictMode>
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>
,
</React.StrictMode>,
)
await waitFor(() => rendered.getByText('fetchStatus: idle'))
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
fireEvent.click(rendered.getByRole('button', { name: /update/i }))
await waitFor(() => rendered.getByText('updated'))
const state = await persister.restoreClient()
expect(state?.clientState.queries[0]?.state.data).toBe('updated')
})
test('should also put useQueries into idle state', async () => {
const key = queryKey()
const states: Array<UseQueryResult> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const [state] = useQueries({
queries: [
{
queryKey: key,
queryFn: async (): Promise<string> => {
await sleep(10)
return 'fetched'
},
},
],
})
states.push(state)
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
const rendered = render(
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>,
)
await waitFor(() => rendered.getByText('fetchStatus: idle'))
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
expect(states).toHaveLength(4)
expect(states[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[2]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[3]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'fetched',
})
})
test('should show initialData while restoring', async () => {
const key = queryKey()
const states: Array<DefinedUseQueryResult<string>> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
initialData: 'initial',
// make sure that initial data is older than the hydration data
// otherwise initialData would be newer and takes precedence
initialDataUpdatedAt: 1,
})
states.push(state)
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
const rendered = render(
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>,
)
await waitFor(() => rendered.getByText('initial'))
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
expect(states).toHaveLength(4)
expect(states[0]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'initial',
})
expect(states[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[2]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[3]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'fetched',
})
})
test('should not refetch after restoring when data is fresh', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
let fetched = false
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
fetched = true
await sleep(10)
return 'fetched'
},
staleTime: Infinity,
})
states.push(state)
return (
<div>
<h1>data: {state.data ?? 'null'}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
const rendered = render(
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>,
)
await waitFor(() => rendered.getByText('data: null'))
await waitFor(() => rendered.getByText('data: hydrated'))
expect(states).toHaveLength(2)
expect(fetched).toBe(false)
expect(states[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states[1]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'hydrated',
})
})
test('should call onSuccess after successful restoring', async () => {
const key = queryKey()
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
})
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
const onSuccess = vi.fn()
const rendered = render(
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
onSuccess={onSuccess}
>
<Page />
</PersistQueryClientProvider>,
)
expect(onSuccess).toHaveBeenCalledTimes(0)
await waitFor(() => rendered.getByText('hydrated'))
expect(onSuccess).toHaveBeenCalledTimes(1)
await waitFor(() => rendered.getByText('fetched'))
})
test('should await onSuccess after successful restoring', async () => {
const key = queryKey()
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
const states: Array<string> = []
function Page() {
const { data, fetchStatus } = useQuery({
queryKey: key,
queryFn: async () => {
states.push('fetching')
await sleep(10)
states.push('fetched')
return 'fetched'
},
})
return (
<div>
<h1>{data}</h1>
<h2>fetchStatus: {fetchStatus}</h2>
</div>
)
}
const rendered = render(
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
onSuccess={async () => {
states.push('onSuccess')
await sleep(20)
states.push('onSuccess done')
}}
>
<Page />
</PersistQueryClientProvider>,
)
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
expect(states).toEqual([
'onSuccess',
'onSuccess done',
'fetching',
'fetched',
])
})
test('should remove cache after non-successful restoring', async () => {
const key = queryKey()
const consoleMock = vi.spyOn(console, 'error')
const consoleWarn = vi
.spyOn(console, 'warn')
.mockImplementation(() => undefined)
consoleMock.mockImplementation(() => undefined)
const queryClient = createQueryClient()
const removeClient = vi.fn()
const [error, persister] = createMockErrorPersister(removeClient)
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
})
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
const rendered = render(
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>,
)
await waitFor(() => rendered.getByText('fetched'))
expect(removeClient).toHaveBeenCalledTimes(1)
expect(consoleMock).toHaveBeenCalledTimes(1)
expect(consoleMock).toHaveBeenNthCalledWith(1, error)
consoleMock.mockRestore()
consoleWarn.mockRestore()
})
test('should be able to persist into multiple clients', async () => {
const key = queryKey()
const states: Array<UseQueryResult> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
const onSuccess = vi.fn()
const queryFn1 = vi.fn().mockImplementation(async () => {
await sleep(10)
return 'queryFn1'
})
const queryFn2 = vi.fn().mockImplementation(async () => {
await sleep(10)
return 'queryFn2'
})
function App() {
const [client, setClient] = React.useState(
() =>
new QueryClient({
defaultOptions: {
queries: {
queryFn: queryFn1,
},
},
}),
)
React.useEffect(() => {
setClient(
new QueryClient({
defaultOptions: {
queries: {
queryFn: queryFn2,
},
},
}),
)
}, [])
return (
<PersistQueryClientProvider
client={client}
persistOptions={{ persister }}
onSuccess={onSuccess}
>
<Page />
</PersistQueryClientProvider>
)
}
function Page() {
const state = useQuery({ queryKey: key })
states.push(state)
return (
<div>
<h1>{String(state.data)}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
const rendered = render(<App />)
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('queryFn2'))
expect(queryFn1).toHaveBeenCalledTimes(0)
expect(queryFn2).toHaveBeenCalledTimes(1)
expect(onSuccess).toHaveBeenCalledTimes(1)
expect(states).toHaveLength(5)
expect(states[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states[1]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states[2]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[3]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[4]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'queryFn2',
})
})
test('should only restore once in StrictMode', async () => {
let restoreCount = 0
const createPersister = (): Persister => {
let storedState: PersistedClient | undefined
return {
async persistClient(persistClient) {
storedState = persistClient
},
async restoreClient() {
restoreCount++
await sleep(10)
return storedState
},
removeClient() {
storedState = undefined
},
}
}
const key = queryKey()
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createPersister()
const onSuccess = vi.fn()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
})
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
const rendered = render(
<React.StrictMode>
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
onSuccess={onSuccess}
>
<Page />
</PersistQueryClientProvider>
</React.StrictMode>,
)
await waitFor(() => rendered.getByText('fetchStatus: idle'))
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
expect(onSuccess).toHaveBeenCalledTimes(1)
expect(restoreCount).toBe(1)
})
})
|
3,980 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/HydrationBoundary.test.tsx | import { beforeAll, describe, expect, test } from 'vitest'
import * as React from 'react'
import { render } from '@testing-library/react'
import * as coreModule from '@tanstack/query-core'
import { vi } from 'vitest'
import {
HydrationBoundary,
QueryCache,
QueryClient,
QueryClientProvider,
dehydrate,
useQuery,
} from '..'
import { createQueryClient, sleep } from './utils'
describe('React hydration', () => {
const fetchData: (value: string) => Promise<string> = (value) =>
new Promise((res) => setTimeout(() => res(value), 10))
const dataQuery: (key: [string]) => Promise<string> = (key) =>
fetchData(key[0])
let stringifiedState: string
beforeAll(async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
await queryClient.prefetchQuery({
queryKey: ['string'],
queryFn: () => dataQuery(['stringCached']),
})
const dehydrated = dehydrate(queryClient)
stringifiedState = JSON.stringify(dehydrated)
queryClient.clear()
})
test('should hydrate queries to the cache on context', async () => {
const dehydratedState = JSON.parse(stringifiedState)
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
function Page() {
const { data } = useQuery({
queryKey: ['string'],
queryFn: () => dataQuery(['string']),
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = render(
<QueryClientProvider client={queryClient}>
<HydrationBoundary state={dehydratedState}>
<Page />
</HydrationBoundary>
</QueryClientProvider>,
)
await rendered.findByText('stringCached')
await rendered.findByText('string')
queryClient.clear()
})
test('should hydrate queries to the cache on custom context', async () => {
const queryCacheOuter = new QueryCache()
const queryCacheInner = new QueryCache()
const queryClientInner = new QueryClient({ queryCache: queryCacheInner })
const queryClientOuter = new QueryClient({ queryCache: queryCacheOuter })
const dehydratedState = JSON.parse(stringifiedState)
function Page() {
const { data } = useQuery({
queryKey: ['string'],
queryFn: () => dataQuery(['string']),
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = render(
<QueryClientProvider client={queryClientOuter}>
<QueryClientProvider client={queryClientInner}>
<HydrationBoundary state={dehydratedState}>
<Page />
</HydrationBoundary>
</QueryClientProvider>
</QueryClientProvider>,
)
await rendered.findByText('stringCached')
await rendered.findByText('string')
queryClientInner.clear()
queryClientOuter.clear()
})
describe('ReactQueryCacheProvider with hydration support', () => {
test('should hydrate new queries if queries change', async () => {
const dehydratedState = JSON.parse(stringifiedState)
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
function Page({ queryKey }: { queryKey: [string] }) {
const { data } = useQuery({
queryKey,
queryFn: () => dataQuery(queryKey),
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = render(
<QueryClientProvider client={queryClient}>
<HydrationBoundary state={dehydratedState}>
<Page queryKey={['string']} />
</HydrationBoundary>
</QueryClientProvider>,
)
await rendered.findByText('string')
const intermediateCache = new QueryCache()
const intermediateClient = createQueryClient({
queryCache: intermediateCache,
})
await intermediateClient.prefetchQuery({
queryKey: ['string'],
queryFn: () => dataQuery(['should change']),
})
await intermediateClient.prefetchQuery({
queryKey: ['added'],
queryFn: () => dataQuery(['added']),
})
const dehydrated = dehydrate(intermediateClient)
intermediateClient.clear()
rendered.rerender(
<QueryClientProvider client={queryClient}>
<HydrationBoundary state={dehydrated}>
<Page queryKey={['string']} />
<Page queryKey={['added']} />
</HydrationBoundary>
</QueryClientProvider>,
)
// Existing observer should not have updated at this point,
// as that would indicate a side effect in the render phase
rendered.getByText('string')
// New query data should be available immediately
rendered.getByText('added')
await sleep(10)
// After effects phase has had time to run, the observer should have updated
expect(rendered.queryByText('string')).toBeNull()
rendered.getByText('should change')
queryClient.clear()
})
// When we hydrate in transitions that are later aborted, it could be
// confusing to both developers and users if we suddenly updated existing
// state on the screen (why did this update when it was not stale, nothing
// remounted, I didn't change tabs etc?).
// Any queries that does not exist in the cache yet can still be hydrated
// since they don't have any observers on the current page that would update.
test('should hydrate new but not existing queries if transition is aborted', async () => {
const initialDehydratedState = JSON.parse(stringifiedState)
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
function Page({ queryKey }: { queryKey: [string] }) {
const { data } = useQuery({
queryKey,
queryFn: () => dataQuery(queryKey),
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = render(
<QueryClientProvider client={queryClient}>
<HydrationBoundary state={initialDehydratedState}>
<Page queryKey={['string']} />
</HydrationBoundary>
</QueryClientProvider>,
)
await rendered.findByText('string')
const intermediateCache = new QueryCache()
const intermediateClient = createQueryClient({
queryCache: intermediateCache,
})
await intermediateClient.prefetchQuery({
queryKey: ['string'],
queryFn: () => dataQuery(['should not change']),
})
await intermediateClient.prefetchQuery({
queryKey: ['added'],
queryFn: () => dataQuery(['added']),
})
const newDehydratedState = dehydrate(intermediateClient)
intermediateClient.clear()
function Thrower() {
throw new Promise(() => {
// Never resolve
})
// @ts-ignore
return null
}
React.startTransition(() => {
rendered.rerender(
<React.Suspense fallback="loading">
<QueryClientProvider client={queryClient}>
<HydrationBoundary state={newDehydratedState}>
<Page queryKey={['string']} />
<Page queryKey={['added']} />
<Thrower />
</HydrationBoundary>
</QueryClientProvider>
</React.Suspense>,
)
rendered.getByText('loading')
})
React.startTransition(() => {
rendered.rerender(
<QueryClientProvider client={queryClient}>
<HydrationBoundary state={initialDehydratedState}>
<Page queryKey={['string']} />
<Page queryKey={['added']} />
</HydrationBoundary>
</QueryClientProvider>,
)
// This query existed before the transition so it should stay the same
rendered.getByText('string')
expect(rendered.queryByText('should not change')).toBeNull()
// New query data should be available immediately because it was
// hydrated in the previous transition, even though the new dehydrated
// state did not contain it
rendered.getByText('added')
})
await sleep(10)
// It should stay the same even after effects have had a chance to run
rendered.getByText('string')
expect(rendered.queryByText('should not change')).toBeNull()
queryClient.clear()
})
test('should hydrate queries to new cache if cache changes', async () => {
const dehydratedState = JSON.parse(stringifiedState)
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
function Page() {
const { data } = useQuery({
queryKey: ['string'],
queryFn: () => dataQuery(['string']),
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = render(
<QueryClientProvider client={queryClient}>
<HydrationBoundary state={dehydratedState}>
<Page />
</HydrationBoundary>
</QueryClientProvider>,
)
await rendered.findByText('string')
const newClientQueryCache = new QueryCache()
const newClientQueryClient = createQueryClient({
queryCache: newClientQueryCache,
})
rendered.rerender(
<QueryClientProvider client={newClientQueryClient}>
<HydrationBoundary state={dehydratedState}>
<Page />
</HydrationBoundary>
</QueryClientProvider>,
)
await sleep(10)
rendered.getByText('string')
queryClient.clear()
newClientQueryClient.clear()
})
})
test('should not hydrate queries if state is null', async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const hydrateSpy = vi.spyOn(coreModule, 'hydrate')
function Page() {
return null
}
render(
<QueryClientProvider client={queryClient}>
<HydrationBoundary state={null}>
<Page />
</HydrationBoundary>
</QueryClientProvider>,
)
expect(hydrateSpy).toHaveBeenCalledTimes(0)
hydrateSpy.mockRestore()
queryClient.clear()
})
test('should not hydrate queries if state is undefined', async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const hydrateSpy = vi.spyOn(coreModule, 'hydrate')
function Page() {
return null
}
render(
<QueryClientProvider client={queryClient}>
<HydrationBoundary state={undefined}>
<Page />
</HydrationBoundary>
</QueryClientProvider>,
)
expect(hydrateSpy).toHaveBeenCalledTimes(0)
hydrateSpy.mockRestore()
queryClient.clear()
})
})
|
3,981 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/QueryClientProvider.test.tsx | import { describe, expect, test } from 'vitest'
import * as React from 'react'
import { render, waitFor } from '@testing-library/react'
import { vi } from 'vitest'
import { QueryCache, QueryClientProvider, useQuery, useQueryClient } from '..'
import { createQueryClient, queryKey, sleep } from './utils'
describe('QueryClientProvider', () => {
test('sets a specific cache for all queries to use', async () => {
const key = queryKey()
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
function Page() {
const { data } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = render(
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>,
)
await waitFor(() => rendered.getByText('test'))
expect(queryCache.find({ queryKey: key })).toBeDefined()
})
test('allows multiple caches to be partitioned', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryCache1 = new QueryCache()
const queryCache2 = new QueryCache()
const queryClient1 = createQueryClient({ queryCache: queryCache1 })
const queryClient2 = createQueryClient({ queryCache: queryCache2 })
function Page1() {
const { data } = useQuery({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 'test1'
},
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
function Page2() {
const { data } = useQuery({
queryKey: key2,
queryFn: async () => {
await sleep(10)
return 'test2'
},
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = render(
<>
<QueryClientProvider client={queryClient1}>
<Page1 />
</QueryClientProvider>
<QueryClientProvider client={queryClient2}>
<Page2 />
</QueryClientProvider>
</>,
)
await waitFor(() => rendered.getByText('test1'))
await waitFor(() => rendered.getByText('test2'))
expect(queryCache1.find({ queryKey: key1 })).toBeDefined()
expect(queryCache1.find({ queryKey: key2 })).not.toBeDefined()
expect(queryCache2.find({ queryKey: key1 })).not.toBeDefined()
expect(queryCache2.find({ queryKey: key2 })).toBeDefined()
})
test("uses defaultOptions for queries when they don't provide their own config", async () => {
const key = queryKey()
const queryCache = new QueryCache()
const queryClient = createQueryClient({
queryCache,
defaultOptions: {
queries: {
gcTime: Infinity,
},
},
})
function Page() {
const { data } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = render(
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>,
)
await waitFor(() => rendered.getByText('test'))
expect(queryCache.find({ queryKey: key })).toBeDefined()
expect(queryCache.find({ queryKey: key })?.options.gcTime).toBe(Infinity)
})
describe('useQueryClient', () => {
test('should throw an error if no query client has been set', () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
useQueryClient()
return null
}
expect(() => render(<Page />)).toThrow(
'No QueryClient set, use QueryClientProvider to set one',
)
consoleMock.mockRestore()
})
})
})
|
3,982 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/QueryResetErrorBoundary.test.tsx | import { describe, expect, it } from 'vitest'
import { fireEvent, waitFor } from '@testing-library/react'
import { ErrorBoundary } from 'react-error-boundary'
import * as React from 'react'
import { vi } from 'vitest'
import {
QueryCache,
QueryErrorResetBoundary,
useQueries,
useQuery,
useSuspenseQueries,
useSuspenseQuery,
} from '..'
import { createQueryClient, queryKey, renderWithClient, sleep } from './utils'
// TODO: This should be removed with the types for react-error-boundary get updated.
declare module 'react-error-boundary' {
interface ErrorBoundaryPropsWithFallback {
children: any
}
}
describe('QueryErrorResetBoundary', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
describe('useQuery', () => {
it('should retry fetch if the reset error boundary has been reset', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
const { data } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Error')
} else {
return 'data'
}
},
retry: false,
throwOnError: true,
})
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('data'))
consoleMock.mockRestore()
})
it('should not throw error if query is disabled', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
const { data, status } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Error')
} else {
return 'data'
}
},
retry: false,
enabled: !succeed,
throwOnError: true,
})
return (
<div>
<div>status: {status}</div>
<div>{data}</div>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('status: error'))
consoleMock.mockRestore()
})
it('should not throw error if query is disabled, and refetch if query becomes enabled again', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
const [enabled, setEnabled] = React.useState(false)
const { data } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Error')
} else {
return 'data'
}
},
retry: false,
enabled,
throwOnError: true,
})
React.useEffect(() => {
setEnabled(true)
}, [])
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('data'))
consoleMock.mockRestore()
})
it('should throw error if query is disabled and manually refetched', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
function Page() {
const { data, refetch, status, fetchStatus } = useQuery<string>({
queryKey: key,
queryFn: async () => {
throw new Error('Error')
},
retry: false,
enabled: false,
throwOnError: true,
})
return (
<div>
<button onClick={() => refetch()}>refetch</button>
<div>
status: {status}, fetchStatus: {fetchStatus}
</div>
<div>{data}</div>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() =>
rendered.getByText('status: pending, fetchStatus: idle'),
)
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() => rendered.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should not retry fetch if the reset error boundary has not been reset', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
const { data } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Error')
} else {
return 'data'
}
},
retry: false,
throwOnError: true,
})
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{() => (
<ErrorBoundary
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should retry fetch if the reset error boundary has been reset and the query contains data from a previous fetch', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
const { data } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Error')
} else {
return 'data'
}
},
retry: false,
throwOnError: true,
initialData: 'initial',
})
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('data'))
consoleMock.mockRestore()
})
it('should not retry fetch if the reset error boundary has not been reset after a previous reset', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
let shouldReset = true
function Page() {
const { data } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Error')
} else {
return 'data'
}
},
retry: false,
throwOnError: true,
})
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={() => {
if (shouldReset) {
reset()
}
}}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
shouldReset = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('error boundary'))
succeed = true
shouldReset = false
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should throw again on error after the reset error boundary has been reset', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let fetchCount = 0
function Page() {
const { data } = useQuery<string>({
queryKey: key,
queryFn: async () => {
fetchCount++
await sleep(10)
throw new Error('Error')
},
retry: false,
throwOnError: true,
})
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('error boundary'))
expect(fetchCount).toBe(3)
consoleMock.mockRestore()
})
it('should never render the component while the query is in error state', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let fetchCount = 0
let renders = 0
function Page() {
const { data } = useSuspenseQuery({
queryKey: key,
queryFn: async () => {
fetchCount++
await sleep(10)
if (fetchCount > 2) {
return 'data'
} else {
throw new Error('Error')
}
},
retry: false,
})
renders++
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<React.Suspense fallback={<div>loading</div>}>
<Page />
</React.Suspense>
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('data'))
expect(fetchCount).toBe(3)
expect(renders).toBe(1)
consoleMock.mockRestore()
})
it('should render children', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
return (
<div>
<span>page</span>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
<Page />
</QueryErrorResetBoundary>,
)
expect(rendered.queryByText('page')).not.toBeNull()
consoleMock.mockRestore()
})
it('should show error boundary when using tracked queries even though we do not track the error field', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
const { data } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Error')
} else {
return 'data'
}
},
retry: false,
throwOnError: true,
})
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('data'))
consoleMock.mockRestore()
})
})
describe('useQueries', () => {
it('should retry fetch if the reset error boundary has been reset', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
const [{ data }] = useQueries({
queries: [
{
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Error')
} else {
return 'data'
}
},
retry: false,
throwOnError: true,
retryOnMount: true,
},
],
})
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<Page />
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('data'))
consoleMock.mockRestore()
})
it('with suspense should retry fetch if the reset error boundary has been reset', async () => {
const key = queryKey()
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
let succeed = false
function Page() {
const [{ data }] = useSuspenseQueries({
queries: [
{
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Error')
} else {
return 'data'
}
},
retry: false,
retryOnMount: true,
},
],
})
return <div>{data}</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<React.Suspense fallback="Loader">
<Page />
</React.Suspense>
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('data'))
consoleMock.mockRestore()
})
})
})
|
3,983 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/fine-grained-persister.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { waitFor } from '@testing-library/react'
import * as React from 'react'
import { QueryCache, hashKey } from '@tanstack/query-core'
import { useQuery } from '..'
import {
PERSISTER_KEY_PREFIX,
experimental_createPersister,
} from '../../../query-persist-client-core/src'
import { createQueryClient, queryKey, renderWithClient, sleep } from './utils'
describe('fine grained persister', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should restore query state from persister and not refetch', async () => {
const key = queryKey()
const hash = hashKey(key)
const spy = vi.fn(() => Promise.resolve('Works from queryFn'))
const mapStorage = new Map()
const storage = {
getItem: (itemKey: string) => Promise.resolve(mapStorage.get(itemKey)),
setItem: async (itemKey: string, value: unknown) => {
mapStorage.set(itemKey, value)
},
removeItem: async (itemKey: string) => {
mapStorage.delete(itemKey)
},
}
await storage.setItem(
`${PERSISTER_KEY_PREFIX}-${hash}`,
JSON.stringify({
buster: '',
queryHash: hash,
queryKey: key,
state: {
dataUpdatedAt: Date.now(),
data: 'Works from persister',
},
}),
)
function Test() {
const [_, setRef] = React.useState<HTMLDivElement | null>()
const { data } = useQuery({
queryKey: key,
queryFn: spy,
persister: experimental_createPersister({
storage,
}),
staleTime: 5000,
})
return <div ref={(value) => setRef(value)}>{data}</div>
}
const rendered = renderWithClient(queryClient, <Test />)
await waitFor(() => rendered.getByText('Works from persister'))
expect(spy).not.toHaveBeenCalled()
})
it('should restore query state from persister and refetch', async () => {
const key = queryKey()
const hash = hashKey(key)
const spy = vi.fn(async () => {
await sleep(5)
return 'Works from queryFn'
})
const mapStorage = new Map()
const storage = {
getItem: (itemKey: string) => Promise.resolve(mapStorage.get(itemKey)),
setItem: async (itemKey: string, value: unknown) => {
mapStorage.set(itemKey, value)
},
removeItem: async (itemKey: string) => {
mapStorage.delete(itemKey)
},
}
await storage.setItem(
`${PERSISTER_KEY_PREFIX}-${hash}`,
JSON.stringify({
buster: '',
queryHash: hash,
queryKey: key,
state: {
dataUpdatedAt: Date.now(),
data: 'Works from persister',
},
}),
)
function Test() {
const [_, setRef] = React.useState<HTMLDivElement | null>()
const { data } = useQuery({
queryKey: key,
queryFn: spy,
persister: experimental_createPersister({
storage,
}),
})
return <div ref={(value) => setRef(value)}>{data}</div>
}
const rendered = renderWithClient(queryClient, <Test />)
await waitFor(() => rendered.getByText('Works from persister'))
await waitFor(() => rendered.getByText('Works from queryFn'))
expect(spy).toHaveBeenCalledTimes(1)
})
it('should store query state to persister after fetch', async () => {
const key = queryKey()
const hash = hashKey(key)
const spy = vi.fn(() => Promise.resolve('Works from queryFn'))
const mapStorage = new Map()
const storage = {
getItem: (itemKey: string) => Promise.resolve(mapStorage.get(itemKey)),
setItem: async (itemKey: string, value: unknown) => {
mapStorage.set(itemKey, value)
},
removeItem: async (itemKey: string) => {
mapStorage.delete(itemKey)
},
}
function Test() {
const [_, setRef] = React.useState<HTMLDivElement | null>()
const { data } = useQuery({
queryKey: key,
queryFn: spy,
persister: experimental_createPersister({
storage,
}),
})
return <div ref={(value) => setRef(value)}>{data}</div>
}
const rendered = renderWithClient(queryClient, <Test />)
await waitFor(() => rendered.getByText('Works from queryFn'))
expect(spy).toHaveBeenCalledTimes(1)
const storedItem = await storage.getItem(`${PERSISTER_KEY_PREFIX}-${hash}`)
expect(JSON.parse(storedItem)).toMatchObject({
state: {
data: 'Works from queryFn',
},
})
})
})
|
3,984 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/infiniteQueryOptions.types.test.tsx | import { describe, it } from 'vitest'
import { QueryClient } from '@tanstack/query-core'
import { infiniteQueryOptions } from '../infiniteQueryOptions'
import { useInfiniteQuery } from '../useInfiniteQuery'
import { useSuspenseInfiniteQuery } from '../useSuspenseInfiniteQuery'
import { doNotExecute } from './utils'
import type { InfiniteData, dataTagSymbol } from '@tanstack/query-core'
import type { Equal, Expect } from './utils'
describe('queryOptions', () => {
it('should not allow excess properties', () => {
doNotExecute(() => {
return infiniteQueryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve('data'),
getNextPageParam: () => 1,
initialPageParam: 1,
// @ts-expect-error this is a good error, because stallTime does not exist!
stallTime: 1000,
})
})
})
it('should infer types for callbacks', () => {
doNotExecute(() => {
return infiniteQueryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve('data'),
staleTime: 1000,
getNextPageParam: () => 1,
initialPageParam: 1,
select: (data) => {
const result: Expect<
Equal<InfiniteData<string, number>, typeof data>
> = true
return result
},
})
})
})
it('should work when passed to useInfiniteQuery', () => {
doNotExecute(() => {
const options = infiniteQueryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve('string'),
getNextPageParam: () => 1,
initialPageParam: 1,
})
const { data } = useInfiniteQuery(options)
// known issue: type of pageParams is unknown when returned from useInfiniteQuery
const result: Expect<
Equal<typeof data, InfiniteData<string, unknown> | undefined>
> = true
return result
})
})
it('should work when passed to useSuspenseInfiniteQuery', () => {
doNotExecute(() => {
const options = infiniteQueryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve('string'),
getNextPageParam: () => 1,
initialPageParam: 1,
})
const { data } = useSuspenseInfiniteQuery(options)
const result: Expect<Equal<typeof data, InfiniteData<string, unknown>>> =
true
return result
})
})
it('should work when passed to fetchInfiniteQuery', () => {
doNotExecute(async () => {
const options = infiniteQueryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve('string'),
getNextPageParam: () => 1,
initialPageParam: 1,
})
const data = await new QueryClient().fetchInfiniteQuery(options)
const result: Expect<Equal<typeof data, InfiniteData<string, number>>> =
true
return result
})
})
it('should tag the queryKey with the result type of the QueryFn', () => {
doNotExecute(() => {
const { queryKey } = infiniteQueryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve('string'),
getNextPageParam: () => 1,
initialPageParam: 1,
})
const result: Expect<
Equal<(typeof queryKey)[typeof dataTagSymbol], InfiniteData<string>>
> = true
return result
})
it('should tag the queryKey even if no promise is returned', () => {
doNotExecute(() => {
const { queryKey } = infiniteQueryOptions({
queryKey: ['key'],
queryFn: () => 'string',
getNextPageParam: () => 1,
initialPageParam: 1,
})
const result: Expect<
Equal<(typeof queryKey)[typeof dataTagSymbol], InfiniteData<string>>
> = true
return result
})
})
it('should return the proper type when passed to getQueryData', () => {
doNotExecute(() => {
const { queryKey } = infiniteQueryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve('string'),
getNextPageParam: () => 1,
initialPageParam: 1,
})
const queryClient = new QueryClient()
const data = queryClient.getQueryData(queryKey)
const result: Expect<
Equal<typeof data, InfiniteData<string, unknown> | undefined>
> = true
return result
})
})
it('should properly type when passed to setQueryData', () => {
doNotExecute(() => {
const { queryKey } = infiniteQueryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve('string'),
getNextPageParam: () => 1,
initialPageParam: 1,
})
const queryClient = new QueryClient()
const data = queryClient.setQueryData(queryKey, (prev) => {
const result: Expect<
Equal<typeof prev, InfiniteData<string, unknown> | undefined>
> = true
return result ? prev : { pages: ['foo'], pageParams: [1] }
})
const result: Expect<
Equal<typeof data, InfiniteData<string, unknown> | undefined>
> = true
return result
})
})
})
})
|
3,985 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/queryOptions.types.test.tsx | import { describe, it } from 'vitest'
import { QueryClient } from '@tanstack/query-core'
import { queryOptions } from '../queryOptions'
import { useQuery } from '../useQuery'
import { useQueries } from '../useQueries'
import { useSuspenseQuery } from '../useSuspenseQuery'
import { doNotExecute } from './utils'
import type { dataTagSymbol } from '@tanstack/query-core'
import type { Equal, Expect } from './utils'
describe('queryOptions', () => {
it('should not allow excess properties', () => {
doNotExecute(() => {
return queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
// @ts-expect-error this is a good error, because stallTime does not exist!
stallTime: 1000,
})
})
})
it('should infer types for callbacks', () => {
doNotExecute(() => {
return queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
staleTime: 1000,
select: (data) => {
const result: Expect<Equal<number, typeof data>> = true
return result
},
})
})
})
it('should work when passed to useQuery', () => {
doNotExecute(() => {
const options = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const { data } = useQuery(options)
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should work when passed to useSuspenseQuery', () => {
doNotExecute(() => {
const options = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const { data } = useSuspenseQuery(options)
const result: Expect<Equal<typeof data, number>> = true
return result
})
})
it('should work when passed to fetchQuery', () => {
doNotExecute(async () => {
const options = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const data = await new QueryClient().fetchQuery(options)
const result: Expect<Equal<typeof data, number>> = true
return result
})
})
it('should work when passed to useQueries', () => {
doNotExecute(() => {
const options = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const [{ data }] = useQueries({
queries: [options],
})
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should tag the queryKey with the result type of the QueryFn', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const result: Expect<
Equal<(typeof queryKey)[typeof dataTagSymbol], number>
> = true
return result
})
it('should tag the queryKey even if no promise is returned', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => 5,
})
const result: Expect<
Equal<(typeof queryKey)[typeof dataTagSymbol], number>
> = true
return result
})
})
it('should tag the queryKey with unknown if there is no queryFn', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
})
const result: Expect<
Equal<(typeof queryKey)[typeof dataTagSymbol], unknown>
> = true
return result
})
})
it('should return the proper type when passed to getQueryData', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const queryClient = new QueryClient()
const data = queryClient.getQueryData(queryKey)
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should properly type updaterFn when passed to setQueryData', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const queryClient = new QueryClient()
const data = queryClient.setQueryData(queryKey, (prev) => {
const result: Expect<Equal<typeof prev, number | undefined>> = true
return result ? prev : 1
})
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should properly type value when passed to setQueryData', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const queryClient = new QueryClient()
// @ts-expect-error value should be a number
queryClient.setQueryData(queryKey, '5')
// @ts-expect-error value should be a number
queryClient.setQueryData(queryKey, () => '5')
const data = queryClient.setQueryData(queryKey, 5)
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
})
})
|
3,986 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/ssr-hydration.test.tsx | import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
import * as React from 'react'
import ReactDOM from 'react-dom'
import * as ReactDOMTestUtils from 'react-dom/test-utils'
import * as ReactDOMServer from 'react-dom/server'
import {
QueryCache,
QueryClientProvider,
dehydrate,
hydrate,
useQuery,
} from '..'
import { createQueryClient, setIsServer, sleep } from './utils'
const ReactHydrate = (element: React.ReactElement, container: Element) => {
let root: any
ReactDOMTestUtils.act(() => {
// @ts-expect-error
root = ReactDOM.hydrateRoot(container, element)
})
return () => {
root.unmount()
}
}
async function fetchData<TData>(value: TData, ms?: number): Promise<TData> {
await sleep(ms || 1)
return value
}
function PrintStateComponent({ componentName, result }: any): any {
return `${componentName} - status:${result.status} fetching:${result.isFetching} data:${result.data}`
}
describe('Server side rendering with de/rehydration', () => {
let previousIsReactActEnvironment: unknown
beforeAll(() => {
// @ts-expect-error we expect IS_REACT_ACT_ENVIRONMENT to exist
previousIsReactActEnvironment = globalThis.IS_REACT_ACT_ENVIRONMENT = true
})
afterAll(() => {
// @ts-expect-error we expect IS_REACT_ACT_ENVIRONMENT to exist
globalThis.IS_REACT_ACT_ENVIRONMENT = previousIsReactActEnvironment
})
it('should not mismatch on success', async () => {
const consoleMock = vi.spyOn(console, 'error')
consoleMock.mockImplementation(() => undefined)
const fetchDataSuccess = vi.fn<
Parameters<typeof fetchData>,
ReturnType<typeof fetchData>
>(fetchData)
// -- Shared part --
function SuccessComponent() {
const result = useQuery({
queryKey: ['success'],
queryFn: () => fetchDataSuccess('success!'),
})
return (
<PrintStateComponent componentName="SuccessComponent" result={result} />
)
}
// -- Server part --
setIsServer(true)
const prefetchCache = new QueryCache()
const prefetchClient = createQueryClient({
queryCache: prefetchCache,
})
await prefetchClient.prefetchQuery({
queryKey: ['success'],
queryFn: () => fetchDataSuccess('success'),
})
const dehydratedStateServer = dehydrate(prefetchClient)
const renderCache = new QueryCache()
const renderClient = createQueryClient({
queryCache: renderCache,
})
hydrate(renderClient, dehydratedStateServer)
const markup = ReactDOMServer.renderToString(
<QueryClientProvider client={renderClient}>
<SuccessComponent />
</QueryClientProvider>,
)
const stringifiedState = JSON.stringify(dehydratedStateServer)
renderClient.clear()
setIsServer(false)
const expectedMarkup =
'SuccessComponent - status:success fetching:true data:success'
expect(markup).toBe(expectedMarkup)
expect(fetchDataSuccess).toHaveBeenCalledTimes(1)
// -- Client part --
const el = document.createElement('div')
el.innerHTML = markup
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
hydrate(queryClient, JSON.parse(stringifiedState))
const unmount = ReactHydrate(
<QueryClientProvider client={queryClient}>
<SuccessComponent />
</QueryClientProvider>,
el,
)
// Check that we have no React hydration mismatches
// this should be zero calls and can be changed once we drop react17 support
expect(consoleMock).toHaveBeenNthCalledWith(
1,
'Warning: You are importing hydrateRoot from "react-dom" which is not supported. You should instead import it from "react-dom/client".',
)
expect(fetchDataSuccess).toHaveBeenCalledTimes(2)
expect(el.innerHTML).toBe(expectedMarkup)
unmount()
queryClient.clear()
consoleMock.mockRestore()
})
it('should not mismatch on error', async () => {
const consoleMock = vi.spyOn(console, 'error')
consoleMock.mockImplementation(() => undefined)
const fetchDataError = vi.fn(() => {
throw new Error('fetchDataError')
})
// -- Shared part --
function ErrorComponent() {
const result = useQuery({
queryKey: ['error'],
queryFn: () => fetchDataError(),
retry: false,
})
return (
<PrintStateComponent componentName="ErrorComponent" result={result} />
)
}
// -- Server part --
setIsServer(true)
const prefetchCache = new QueryCache()
const prefetchClient = createQueryClient({
queryCache: prefetchCache,
})
await prefetchClient.prefetchQuery({
queryKey: ['error'],
queryFn: () => fetchDataError(),
})
const dehydratedStateServer = dehydrate(prefetchClient)
const renderCache = new QueryCache()
const renderClient = createQueryClient({
queryCache: renderCache,
})
hydrate(renderClient, dehydratedStateServer)
const markup = ReactDOMServer.renderToString(
<QueryClientProvider client={renderClient}>
<ErrorComponent />
</QueryClientProvider>,
)
const stringifiedState = JSON.stringify(dehydratedStateServer)
renderClient.clear()
setIsServer(false)
const expectedMarkup =
'ErrorComponent - status:pending fetching:true data:undefined'
expect(markup).toBe(expectedMarkup)
// -- Client part --
const el = document.createElement('div')
el.innerHTML = markup
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
hydrate(queryClient, JSON.parse(stringifiedState))
const unmount = ReactHydrate(
<QueryClientProvider client={queryClient}>
<ErrorComponent />
</QueryClientProvider>,
el,
)
// We expect exactly one console.error here, which is from the
expect(consoleMock).toHaveBeenCalledTimes(1)
expect(fetchDataError).toHaveBeenCalledTimes(2)
expect(el.innerHTML).toBe(expectedMarkup)
await sleep(50)
expect(fetchDataError).toHaveBeenCalledTimes(2)
expect(el.innerHTML).toBe(
'ErrorComponent - status:error fetching:false data:undefined',
)
unmount()
queryClient.clear()
consoleMock.mockRestore()
})
it('should not mismatch on queries that were not prefetched', async () => {
const consoleMock = vi.spyOn(console, 'error')
consoleMock.mockImplementation(() => undefined)
const fetchDataSuccess = vi.fn<
Parameters<typeof fetchData>,
ReturnType<typeof fetchData>
>(fetchData)
// -- Shared part --
function SuccessComponent() {
const result = useQuery({
queryKey: ['success'],
queryFn: () => fetchDataSuccess('success!'),
})
return (
<PrintStateComponent componentName="SuccessComponent" result={result} />
)
}
// -- Server part --
setIsServer(true)
const prefetchClient = createQueryClient()
const dehydratedStateServer = dehydrate(prefetchClient)
const renderClient = createQueryClient()
hydrate(renderClient, dehydratedStateServer)
const markup = ReactDOMServer.renderToString(
<QueryClientProvider client={renderClient}>
<SuccessComponent />
</QueryClientProvider>,
)
const stringifiedState = JSON.stringify(dehydratedStateServer)
renderClient.clear()
setIsServer(false)
const expectedMarkup =
'SuccessComponent - status:pending fetching:true data:undefined'
expect(markup).toBe(expectedMarkup)
// -- Client part --
const el = document.createElement('div')
el.innerHTML = markup
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
hydrate(queryClient, JSON.parse(stringifiedState))
const unmount = ReactHydrate(
<QueryClientProvider client={queryClient}>
<SuccessComponent />
</QueryClientProvider>,
el,
)
// Check that we have no React hydration mismatches
// this should be zero calls and can be changed once we drop react17 support
expect(consoleMock).toHaveBeenNthCalledWith(
1,
'Warning: You are importing hydrateRoot from "react-dom" which is not supported. You should instead import it from "react-dom/client".',
)
expect(fetchDataSuccess).toHaveBeenCalledTimes(1)
expect(el.innerHTML).toBe(expectedMarkup)
await sleep(50)
expect(fetchDataSuccess).toHaveBeenCalledTimes(1)
expect(el.innerHTML).toBe(
'SuccessComponent - status:success fetching:false data:success!',
)
unmount()
queryClient.clear()
consoleMock.mockRestore()
})
})
|
3,987 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/ssr.test.tsx | import { describe, expect, it, vi } from 'vitest'
import * as React from 'react'
// @ts-ignore
import { renderToString } from 'react-dom/server'
import { QueryCache, QueryClientProvider, useInfiniteQuery, useQuery } from '..'
import { createQueryClient, queryKey, sleep } from './utils'
describe('Server Side Rendering', () => {
it('should not trigger fetch', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const key = queryKey()
const queryFn = vi.fn().mockReturnValue('data')
function Page() {
const query = useQuery({ queryKey: key, queryFn })
const content = `status ${query.status}`
return (
<div>
<div>{content}</div>
</div>
)
}
const markup = renderToString(
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>,
)
expect(markup).toContain('status pending')
expect(queryFn).toHaveBeenCalledTimes(0)
queryCache.clear()
})
it('should add prefetched data to cache', async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const key = queryKey()
const fetchFn = () => Promise.resolve('data')
const data = await queryClient.fetchQuery({
queryKey: key,
queryFn: fetchFn,
})
expect(data).toBe('data')
expect(queryCache.find({ queryKey: key })?.state.data).toBe('data')
queryCache.clear()
})
it('should return existing data from the cache', async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const key = queryKey()
const queryFn = vi.fn(() => {
sleep(10)
return 'data'
})
function Page() {
const query = useQuery({ queryKey: key, queryFn })
const content = `status ${query.status}`
return (
<div>
<div>{content}</div>
</div>
)
}
await queryClient.prefetchQuery({ queryKey: key, queryFn })
const markup = renderToString(
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>,
)
expect(markup).toContain('status success')
expect(queryFn).toHaveBeenCalledTimes(1)
queryCache.clear()
})
it('should add initialData to the cache', () => {
const key = queryKey()
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
function Page() {
const [page, setPage] = React.useState(1)
const { data } = useQuery({
queryKey: [key, page],
queryFn: async () => page,
initialData: 1,
})
return (
<div>
<h1 data-testid="title">{data}</h1>
<button onClick={() => setPage(page + 1)}>next</button>
</div>
)
}
renderToString(
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>,
)
const keys = queryCache.getAll().map((query) => query.queryKey)
expect(keys).toEqual([[key, 1]])
queryCache.clear()
})
it('useInfiniteQuery should return the correct state', async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const key = queryKey()
const queryFn = vi.fn(async () => {
await sleep(5)
return 'page 1'
})
function Page() {
const query = useInfiniteQuery({
queryKey: key,
queryFn,
getNextPageParam: () => undefined,
initialPageParam: 0,
})
return (
<ul>{query.data?.pages.map((page) => <li key={page}>{page}</li>)}</ul>
)
}
await queryClient.prefetchInfiniteQuery({
queryKey: key,
queryFn,
initialPageParam: 0,
})
const markup = renderToString(
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>,
)
expect(markup).toContain('page 1')
expect(queryFn).toHaveBeenCalledTimes(1)
queryCache.clear()
})
})
|
3,988 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/suspense.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { fireEvent, waitFor } from '@testing-library/react'
import * as React from 'react'
import { ErrorBoundary } from 'react-error-boundary'
import {
QueryCache,
QueryErrorResetBoundary,
useQueryErrorResetBoundary,
useSuspenseInfiniteQuery,
useSuspenseQueries,
useSuspenseQuery,
} from '..'
import { createQueryClient, queryKey, renderWithClient, sleep } from './utils'
import type {
InfiniteData,
UseSuspenseInfiniteQueryResult,
UseSuspenseQueryResult,
} from '..'
describe('useSuspenseQuery', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should render the correct amount of times in Suspense mode', async () => {
const key = queryKey()
const states: Array<UseSuspenseQueryResult<number>> = []
let count = 0
let renders = 0
function Page() {
renders++
const [stateKey, setStateKey] = React.useState(key)
const state = useSuspenseQuery({
queryKey: stateKey,
queryFn: async () => {
count++
await sleep(10)
return count
},
})
states.push(state)
return (
<div>
<button aria-label="toggle" onClick={() => setStateKey(queryKey())} />
data: {String(state.data)}
</div>
)
}
const rendered = renderWithClient(
queryClient,
<React.Suspense fallback="loading">
<Page />
</React.Suspense>,
)
await waitFor(() => rendered.getByText('data: 1'))
fireEvent.click(rendered.getByLabelText('toggle'))
await waitFor(() => rendered.getByText('data: 2'))
expect(renders).toBe(4)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: 1, status: 'success' })
expect(states[1]).toMatchObject({ data: 2, status: 'success' })
})
it('should return the correct states for a successful infinite query', async () => {
const key = queryKey()
const states: Array<UseSuspenseInfiniteQueryResult<InfiniteData<number>>> =
[]
function Page() {
const [multiplier, setMultiplier] = React.useState(1)
const state = useSuspenseInfiniteQuery({
queryKey: [`${key}_${multiplier}`],
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam * multiplier)
},
initialPageParam: 1,
getNextPageParam: (lastPage) => lastPage + 1,
})
states.push(state)
return (
<div>
<button onClick={() => setMultiplier(2)}>next</button>
data: {state.data?.pages.join(',')}
</div>
)
}
const rendered = renderWithClient(
queryClient,
<React.Suspense fallback="loading">
<Page />
</React.Suspense>,
)
await waitFor(() => rendered.getByText('data: 1'))
expect(states.length).toBe(1)
expect(states[0]).toMatchObject({
data: { pages: [1], pageParams: [1] },
status: 'success',
})
fireEvent.click(rendered.getByText('next'))
await waitFor(() => rendered.getByText('data: 2'))
expect(states.length).toBe(2)
expect(states[1]).toMatchObject({
data: { pages: [2], pageParams: [1] },
status: 'success',
})
})
it('should not call the queryFn twice when used in Suspense mode', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>()
queryFn.mockImplementation(() => {
sleep(10)
return 'data'
})
function Page() {
useSuspenseQuery({ queryKey: [key], queryFn })
return <>rendered</>
}
const rendered = renderWithClient(
queryClient,
<React.Suspense fallback="loading">
<Page />
</React.Suspense>,
)
await waitFor(() => rendered.getByText('rendered'))
expect(queryFn).toHaveBeenCalledTimes(1)
})
it('should remove query instance when component unmounted', async () => {
const key = queryKey()
function Page() {
useSuspenseQuery({
queryKey: key,
queryFn: () => {
sleep(10)
return 'data'
},
})
return <>rendered</>
}
function App() {
const [show, setShow] = React.useState(false)
return (
<>
<React.Suspense fallback="loading">{show && <Page />}</React.Suspense>
<button
aria-label="toggle"
onClick={() => setShow((prev) => !prev)}
/>
</>
)
}
const rendered = renderWithClient(queryClient, <App />)
expect(rendered.queryByText('rendered')).toBeNull()
expect(queryCache.find({ queryKey: key })).toBeFalsy()
fireEvent.click(rendered.getByLabelText('toggle'))
await waitFor(() => rendered.getByText('rendered'))
expect(queryCache.find({ queryKey: key })?.getObserversCount()).toBe(1)
fireEvent.click(rendered.getByLabelText('toggle'))
expect(rendered.queryByText('rendered')).toBeNull()
expect(queryCache.find({ queryKey: key })?.getObserversCount()).toBe(0)
})
// https://github.com/tannerlinsley/react-query/issues/468
it('should reset error state if new component instances are mounted', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
useSuspenseQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return 'data'
}
},
retryDelay: 10,
})
return <div>rendered</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
succeed = true
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<React.Suspense fallback={'Loading...'}>
<Page />
</React.Suspense>
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('Loading...'))
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('rendered'))
expect(consoleMock).toHaveBeenCalledWith(
expect.objectContaining(new Error('Suspense Error Bingo')),
)
consoleMock.mockRestore()
})
it('should retry fetch if the reset error boundary has been reset', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
useSuspenseQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return 'data'
}
},
retry: false,
})
return <div>rendered</div>
}
const rendered = renderWithClient(
queryClient,
<QueryErrorResetBoundary>
{({ reset }) => (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<React.Suspense fallback="Loading...">
<Page />
</React.Suspense>
</ErrorBoundary>
)}
</QueryErrorResetBoundary>,
)
await waitFor(() => rendered.getByText('Loading...'))
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('rendered'))
consoleMock.mockRestore()
})
it('should refetch when re-mounting', async () => {
const key = queryKey()
let count = 0
function Component() {
const result = useSuspenseQuery({
queryKey: key,
queryFn: async () => {
await sleep(100)
count++
return count
},
retry: false,
staleTime: 0,
})
return (
<div>
<span>data: {result.data}</span>
<span>fetching: {result.isFetching ? 'true' : 'false'}</span>
</div>
)
}
function Page() {
const [show, setShow] = React.useState(true)
return (
<div>
<button
onClick={() => {
setShow(!show)
}}
>
{show ? 'hide' : 'show'}
</button>
<React.Suspense fallback="Loading...">
{show && <Component />}
</React.Suspense>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Loading...'))
await waitFor(() => rendered.getByText('data: 1'))
await waitFor(() => rendered.getByText('fetching: false'))
await waitFor(() => rendered.getByText('hide'))
fireEvent.click(rendered.getByText('hide'))
await waitFor(() => rendered.getByText('show'))
fireEvent.click(rendered.getByText('show'))
await waitFor(() => rendered.getByText('fetching: true'))
await waitFor(() => rendered.getByText('data: 2'))
await waitFor(() => rendered.getByText('fetching: false'))
})
it('should suspend when switching to a new query', async () => {
const key1 = queryKey()
const key2 = queryKey()
function Component(props: { queryKey: Array<string> }) {
const result = useSuspenseQuery({
queryKey: props.queryKey,
queryFn: async () => {
await sleep(100)
return props.queryKey
},
retry: false,
})
return <div>data: {result.data}</div>
}
function Page() {
const [key, setKey] = React.useState(key1)
return (
<div>
<button
onClick={() => {
setKey(key2)
}}
>
switch
</button>
<React.Suspense fallback="Loading...">
<Component queryKey={key} />
</React.Suspense>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Loading...'))
await waitFor(() => rendered.getByText(`data: ${key1}`))
fireEvent.click(rendered.getByText('switch'))
await waitFor(() => rendered.getByText('Loading...'))
await waitFor(() => rendered.getByText(`data: ${key2}`))
})
it('should retry fetch if the reset error boundary has been reset with global hook', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = false
function Page() {
useSuspenseQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return 'data'
}
},
retry: false,
})
return <div>rendered</div>
}
function App() {
const { reset } = useQueryErrorResetBoundary()
return (
<ErrorBoundary
onReset={reset}
fallbackRender={({ resetErrorBoundary }) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetErrorBoundary()
}}
>
retry
</button>
</div>
)}
>
<React.Suspense fallback="Loading...">
<Page />
</React.Suspense>
</ErrorBoundary>
)
}
const rendered = renderWithClient(queryClient, <App />)
await waitFor(() => rendered.getByText('Loading...'))
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('retry'))
succeed = true
fireEvent.click(rendered.getByText('retry'))
await waitFor(() => rendered.getByText('rendered'))
consoleMock.mockRestore()
})
it('should throw errors to the error boundary by default', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
function Page() {
useSuspenseQuery({
queryKey: key,
queryFn: async (): Promise<unknown> => {
await sleep(10)
throw new Error('Suspense Error a1x')
},
retry: false,
})
return <div>rendered</div>
}
function App() {
return (
<ErrorBoundary
fallbackRender={() => (
<div>
<div>error boundary</div>
</div>
)}
>
<React.Suspense fallback="Loading...">
<Page />
</React.Suspense>
</ErrorBoundary>
)
}
const rendered = renderWithClient(queryClient, <App />)
await waitFor(() => rendered.getByText('Loading...'))
await waitFor(() => rendered.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should error catched in error boundary without infinite loop', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
let succeed = true
function Page() {
const [nonce] = React.useState(0)
const queryKeys = [`${key}-${succeed}`]
const result = useSuspenseQuery({
queryKey: queryKeys,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return nonce
}
},
retry: false,
})
return (
<div>
<span>rendered</span> <span>{result.data}</span>
<button
aria-label="fail"
onClick={async () => {
await queryClient.resetQueries()
}}
>
fail
</button>
</div>
)
}
function App() {
const { reset } = useQueryErrorResetBoundary()
return (
<ErrorBoundary
onReset={reset}
fallbackRender={() => <div>error boundary</div>}
>
<React.Suspense fallback="Loading...">
<Page />
</React.Suspense>
</ErrorBoundary>
)
}
const rendered = renderWithClient(queryClient, <App />)
// render suspense fallback (Loading...)
await waitFor(() => rendered.getByText('Loading...'))
// resolve promise -> render Page (rendered)
await waitFor(() => rendered.getByText('rendered'))
// change query key
succeed = false
// reset query -> and throw error
fireEvent.click(rendered.getByLabelText('fail'))
// render error boundary fallback (error boundary)
await waitFor(() => rendered.getByText('error boundary'))
expect(consoleMock).toHaveBeenCalledWith(
expect.objectContaining(new Error('Suspense Error Bingo')),
)
consoleMock.mockRestore()
})
it('should error catched in error boundary without infinite loop when query keys changed', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
let succeed = true
function Page() {
const [key, rerender] = React.useReducer((x) => x + 1, 0)
const queryKeys = [key, succeed]
const result = useSuspenseQuery({
queryKey: queryKeys,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return 'data'
}
},
retry: false,
})
if (result.error) {
throw result.error
}
return (
<div>
<span>rendered</span> <span>{result.data}</span>
<button aria-label="fail" onClick={rerender}>
fail
</button>
</div>
)
}
function App() {
const { reset } = useQueryErrorResetBoundary()
return (
<ErrorBoundary
onReset={reset}
fallbackRender={() => <div>error boundary</div>}
>
<React.Suspense fallback="Loading...">
<Page />
</React.Suspense>
</ErrorBoundary>
)
}
const rendered = renderWithClient(queryClient, <App />)
// render suspense fallback (Loading...)
await waitFor(() => rendered.getByText('Loading...'))
// resolve promise -> render Page (rendered)
await waitFor(() => rendered.getByText('rendered'))
// change promise result to error
succeed = false
// change query key
fireEvent.click(rendered.getByLabelText('fail'))
// render error boundary fallback (error boundary)
await waitFor(() => rendered.getByText('error boundary'))
expect(consoleMock).toHaveBeenCalledWith(
expect.objectContaining(new Error('Suspense Error Bingo')),
)
consoleMock.mockRestore()
})
it('should render the correct amount of times in Suspense mode when gcTime is set to 0', async () => {
const key = queryKey()
let state: UseSuspenseQueryResult<number> | null = null
let count = 0
let renders = 0
function Page() {
renders++
state = useSuspenseQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return count
},
gcTime: 0,
})
return (
<div>
<span>rendered</span>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<React.Suspense fallback="loading">
<Page />
</React.Suspense>,
)
await waitFor(() =>
expect(state).toMatchObject({
data: 1,
status: 'success',
}),
)
expect(renders).toBe(2)
expect(rendered.queryByText('rendered')).not.toBeNull()
})
it('should not throw background errors to the error boundary', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
let succeed = true
const key = queryKey()
function Page() {
const result = useSuspenseQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return 'data'
}
},
retry: false,
})
return (
<div>
<span>
rendered {result.data} {result.status}
</span>
<button onClick={() => result.refetch()}>refetch</button>
</div>
)
}
function App() {
const { reset } = useQueryErrorResetBoundary()
return (
<ErrorBoundary
onReset={reset}
fallbackRender={() => <div>error boundary</div>}
>
<React.Suspense fallback="Loading...">
<Page />
</React.Suspense>
</ErrorBoundary>
)
}
const rendered = renderWithClient(queryClient, <App />)
// render suspense fallback (Loading...)
await waitFor(() => rendered.getByText('Loading...'))
// resolve promise -> render Page (rendered)
await waitFor(() => rendered.getByText('rendered data success'))
// change promise result to error
succeed = false
// refetch
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
// we are now in error state but still have data to show
await waitFor(() => rendered.getByText('rendered data error'))
consoleMock.mockRestore()
})
})
describe('useSuspenseQueries', () => {
const queryClient = createQueryClient()
it('should suspend all queries in parallel', async () => {
const key1 = queryKey()
const key2 = queryKey()
const results: Array<string> = []
function Fallback() {
results.push('loading')
return <div>loading</div>
}
function Page() {
const result = useSuspenseQueries({
queries: [
{
queryKey: key1,
queryFn: async () => {
results.push('1')
await sleep(10)
return '1'
},
},
{
queryKey: key2,
queryFn: async () => {
results.push('2')
await sleep(20)
return '2'
},
},
],
})
return (
<div>
<h1>data: {result.map((item) => item.data ?? 'null').join(',')}</h1>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<React.Suspense fallback={<Fallback />}>
<Page />
</React.Suspense>,
)
await waitFor(() => rendered.getByText('loading'))
await waitFor(() => rendered.getByText('data: 1,2'))
expect(results).toEqual(['1', '2', 'loading'])
})
it("shouldn't unmount before all promises fetched", async () => {
const key1 = queryKey()
const key2 = queryKey()
const results: Array<string> = []
const refs: Array<number> = []
function Fallback() {
results.push('loading')
return <div>loading</div>
}
function Page() {
const ref = React.useRef(Math.random())
const result = useSuspenseQueries({
queries: [
{
queryKey: key1,
queryFn: async () => {
refs.push(ref.current)
results.push('1')
await sleep(10)
return '1'
},
},
{
queryKey: key2,
queryFn: async () => {
refs.push(ref.current)
results.push('2')
await sleep(20)
return '2'
},
},
],
})
return (
<div>
<h1>data: {result.map((item) => item.data ?? 'null').join(',')}</h1>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<React.Suspense fallback={<Fallback />}>
<Page />
</React.Suspense>,
)
await waitFor(() => rendered.getByText('loading'))
expect(refs.length).toBe(2)
await waitFor(() => rendered.getByText('data: 1,2'))
expect(refs[0]).toBe(refs[1])
})
// this addresses the following issue:
// https://github.com/TanStack/query/issues/6344
it('should suspend on offline when query changes, and data should not be undefined', async () => {
function Page() {
const [id, setId] = React.useState(0)
const { data } = useSuspenseQuery({
queryKey: [id],
queryFn: () => Promise.resolve(`Data ${id}`),
})
// defensive guard here
if (data === undefined) {
throw new Error('data cannot be undefined')
}
return (
<>
<div>{data}</div>
<button onClick={() => setId(id + 1)}>fetch</button>
</>
)
}
const rendered = renderWithClient(
queryClient,
<React.Suspense fallback={<div>loading</div>}>
<Page />
</React.Suspense>,
)
await waitFor(() => rendered.getByText('loading'))
await waitFor(() => rendered.getByText('Data 0'))
// go offline
document.dispatchEvent(new CustomEvent('offline'))
fireEvent.click(rendered.getByText('fetch'))
await waitFor(() => rendered.getByText('Data 0'))
// go back online
document.dispatchEvent(new CustomEvent('online'))
fireEvent.click(rendered.getByText('fetch'))
// query should resume
await waitFor(() => rendered.getByText('Data 1'))
})
})
|
3,989 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/suspense.types.test.tsx | import { describe, it } from 'vitest'
import { useSuspenseQuery } from '../useSuspenseQuery'
import { useSuspenseInfiniteQuery } from '../useSuspenseInfiniteQuery'
import { doNotExecute } from './utils'
import type { InfiniteData } from '@tanstack/query-core'
import type { Equal, Expect } from './utils'
describe('useSuspenseQuery', () => {
it('should always have data defined', () => {
doNotExecute(() => {
const { data } = useSuspenseQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const result: Expect<Equal<typeof data, number>> = true
return result
})
})
it('should not have pending status', () => {
doNotExecute(() => {
const { status } = useSuspenseQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const result: Expect<Equal<typeof status, 'error' | 'success'>> = true
return result
})
})
it('should not allow placeholderData, enabled or throwOnError props', () => {
doNotExecute(() => {
useSuspenseQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
// @ts-expect-error TS2345
placeholderData: 5,
enabled: true,
})
useSuspenseQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
// @ts-expect-error TS2345
enabled: true,
})
useSuspenseQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
// @ts-expect-error TS2345
throwOnError: true,
})
})
})
it('should not return isPlaceholderData', () => {
doNotExecute(() => {
const query = useSuspenseQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
// @ts-expect-error TS2339
void query.isPlaceholderData
})
})
})
describe('useSuspenseInfiniteQuery', () => {
it('should always have data defined', () => {
doNotExecute(() => {
const { data } = useSuspenseInfiniteQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
initialPageParam: 1,
getNextPageParam: () => 1,
})
const result: Expect<Equal<typeof data, InfiniteData<number, unknown>>> =
true
return result
})
})
it('should not have pending status', () => {
doNotExecute(() => {
const { status } = useSuspenseInfiniteQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
initialPageParam: 1,
getNextPageParam: () => 1,
})
const result: Expect<Equal<typeof status, 'error' | 'success'>> = true
return result
})
})
it('should not allow placeholderData, enabled or throwOnError props', () => {
doNotExecute(() => {
useSuspenseInfiniteQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
initialPageParam: 1,
getNextPageParam: () => 1,
// @ts-expect-error TS2345
placeholderData: 5,
enabled: true,
})
useSuspenseInfiniteQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
initialPageParam: 1,
getNextPageParam: () => 1,
// @ts-expect-error TS2345
enabled: true,
})
useSuspenseInfiniteQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
initialPageParam: 1,
getNextPageParam: () => 1,
// @ts-expect-error TS2345
throwOnError: true,
})
})
})
it('should not return isPlaceholderData', () => {
doNotExecute(() => {
const query = useSuspenseInfiniteQuery({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
initialPageParam: 1,
getNextPageParam: () => 1,
})
// @ts-expect-error TS2339
void query.isPlaceholderData
})
})
})
|
3,990 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/useInfiniteQuery.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { fireEvent, render, waitFor } from '@testing-library/react'
import * as React from 'react'
import { QueryCache, keepPreviousData, useInfiniteQuery } from '..'
import {
createQueryClient,
queryKey,
renderWithClient,
setActTimeout,
sleep,
} from './utils'
import type {
InfiniteData,
QueryFunctionContext,
UseInfiniteQueryResult,
} from '..'
import type { Mock } from 'vitest'
interface Result {
items: Array<number>
nextId?: number
prevId?: number
ts: number
}
const pageSize = 10
const fetchItems = async (
page: number,
ts: number,
noNext?: boolean,
noPrev?: boolean,
): Promise<Result> => {
await sleep(10)
return {
items: [...new Array(10)].fill(null).map((_, d) => page * pageSize + d),
nextId: noNext ? undefined : page + 1,
prevId: noPrev ? undefined : page - 1,
ts,
}
}
describe('useInfiniteQuery', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should return the correct states for a successful query', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }) => Number(pageParam),
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: 0,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
fetchNextPage: expect.any(Function),
fetchPreviousPage: expect.any(Function),
hasNextPage: false,
hasPreviousPage: false,
isError: false,
isFetched: false,
isFetchedAfterMount: false,
isFetching: true,
isPaused: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isLoading: true,
isPending: true,
isInitialLoading: true,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'pending',
fetchStatus: 'fetching',
})
expect(states[1]).toEqual({
data: { pages: [0], pageParams: [0] },
dataUpdatedAt: expect.any(Number),
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
fetchNextPage: expect.any(Function),
fetchPreviousPage: expect.any(Function),
hasNextPage: true,
hasPreviousPage: false,
isError: false,
isFetched: true,
isFetchedAfterMount: true,
isFetching: false,
isPaused: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isLoading: false,
isPending: false,
isInitialLoading: false,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: true,
refetch: expect.any(Function),
status: 'success',
fetchStatus: 'idle',
})
})
it('should not throw when fetchNextPage returns an error', async () => {
const key = queryKey()
let noThrow: boolean
function Page() {
const start = 1
const state = useInfiniteQuery({
queryKey: key,
queryFn: async ({ pageParam }) => {
if (pageParam === 2) {
throw new Error('error')
}
return Number(pageParam)
},
retry: 1,
retryDelay: 10,
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: start,
})
const { fetchNextPage } = state
React.useEffect(() => {
setActTimeout(() => {
fetchNextPage()
.then(() => {
noThrow = true
})
.catch(() => undefined)
}, 20)
}, [fetchNextPage])
return null
}
renderWithClient(queryClient, <Page />)
await waitFor(() => expect(noThrow).toBe(true))
})
it('should keep the previous data when placeholderData is set', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<string>>> = []
function Page() {
const [order, setOrder] = React.useState('desc')
const state = useInfiniteQuery({
queryKey: [key, order],
queryFn: async ({ pageParam }) => {
await sleep(10)
return `${pageParam}-${order}`
},
getNextPageParam: () => 1,
initialPageParam: 0,
placeholderData: keepPreviousData,
notifyOnChangeProps: 'all',
})
states.push(state)
return (
<div>
<button onClick={() => state.fetchNextPage()}>fetchNextPage</button>
<button onClick={() => setOrder('asc')}>order</button>
<div>data: {state.data?.pages.join(',') ?? 'null'}</div>
<div>isFetching: {String(state.isFetching)}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 0-desc'))
fireEvent.click(rendered.getByRole('button', { name: /fetchNextPage/i }))
await waitFor(() => rendered.getByText('data: 0-desc,1-desc'))
fireEvent.click(rendered.getByRole('button', { name: /order/i }))
await waitFor(() => rendered.getByText('data: 0-asc'))
await waitFor(() => rendered.getByText('isFetching: false'))
await waitFor(() => expect(states.length).toBe(6))
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
isPlaceholderData: false,
})
expect(states[1]).toMatchObject({
data: { pages: ['0-desc'] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
isPlaceholderData: false,
})
expect(states[2]).toMatchObject({
data: { pages: ['0-desc'] },
isFetching: true,
isFetchingNextPage: true,
isSuccess: true,
isPlaceholderData: false,
})
expect(states[3]).toMatchObject({
data: { pages: ['0-desc', '1-desc'] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[4]).toMatchObject({
data: { pages: ['0-desc', '1-desc'] },
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
isPlaceholderData: true,
})
expect(states[5]).toMatchObject({
data: { pages: ['0-asc'] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should be able to select a part of the data', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<string>>> = []
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: () => ({ count: 1 }),
select: (data) => ({
pages: data.pages.map((x) => `count: ${x.count}`),
pageParams: data.pageParams,
}),
getNextPageParam: () => undefined,
initialPageParam: 0,
})
states.push(state)
return <div>{state.data?.pages.join(',')}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('count: 1')
})
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: ['count: 1'] },
isSuccess: true,
})
})
it('should be able to select a new result and not cause infinite renders', async () => {
const key = queryKey()
const states: Array<
UseInfiniteQueryResult<InfiniteData<{ count: number; id: number }>>
> = []
let selectCalled = 0
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: () => ({ count: 1 }),
select: React.useCallback((data: InfiniteData<{ count: number }>) => {
selectCalled++
return {
pages: data.pages.map((x) => ({ ...x, id: Math.random() })),
pageParams: data.pageParams,
}
}, []),
getNextPageParam: () => undefined,
initialPageParam: 0,
})
states.push(state)
return (
<div>
{state.data?.pages.map((page) => (
<div key={page.id}>count: {page.count}</div>
))}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('count: 1')
})
expect(states.length).toBe(2)
expect(selectCalled).toBe(1)
expect(states[0]).toMatchObject({
data: undefined,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: [{ count: 1 }] },
isSuccess: true,
})
})
it('should be able to reverse the data', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam)
},
select: (data) => ({
pages: [...data.pages].reverse(),
pageParams: [...data.pageParams].reverse(),
}),
notifyOnChangeProps: 'all',
getNextPageParam: () => 1,
initialPageParam: 0,
})
states.push(state)
return (
<div>
<button onClick={() => state.fetchNextPage()}>fetchNextPage</button>
<div>data: {state.data?.pages.join(',') ?? 'null'}</div>
<div>isFetching: {state.isFetching}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 0'))
fireEvent.click(rendered.getByRole('button', { name: /fetchNextPage/i }))
await waitFor(() => rendered.getByText('data: 1,0'))
await waitFor(() => expect(states.length).toBe(4))
expect(states[0]).toMatchObject({
data: undefined,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: [0] },
isSuccess: true,
})
expect(states[2]).toMatchObject({
data: { pages: [0] },
isSuccess: true,
})
expect(states[3]).toMatchObject({
data: { pages: [1, 0] },
isSuccess: true,
})
})
it('should be able to fetch a previous page', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const start = 10
const state = useInfiniteQuery({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam)
},
initialPageParam: start,
getNextPageParam: (lastPage) => lastPage + 1,
getPreviousPageParam: (firstPage) => firstPage - 1,
notifyOnChangeProps: 'all',
})
states.push(state)
return (
<div>
<div>data: {state.data?.pages.join(',') ?? null}</div>
<button onClick={() => state.fetchPreviousPage()}>
fetch previous page
</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('data: 10')
})
fireEvent.click(
rendered.getByRole('button', { name: /fetch previous page/i }),
)
await waitFor(() => {
rendered.getByText('data: 9,10')
})
expect(states.length).toBe(4)
expect(states[0]).toMatchObject({
data: undefined,
hasNextPage: false,
hasPreviousPage: false,
isFetching: true,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: [10] },
hasNextPage: true,
hasPreviousPage: true,
isFetching: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isSuccess: true,
})
expect(states[2]).toMatchObject({
data: { pages: [10] },
hasNextPage: true,
hasPreviousPage: true,
isFetching: true,
isFetchingNextPage: false,
isFetchingPreviousPage: true,
isSuccess: true,
})
expect(states[3]).toMatchObject({
data: { pages: [9, 10] },
hasNextPage: true,
hasPreviousPage: true,
isFetching: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isSuccess: true,
})
})
it('should be able to refetch when providing page params automatically', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam)
},
initialPageParam: 10,
getPreviousPageParam: (firstPage) => firstPage - 1,
getNextPageParam: (lastPage) => lastPage + 1,
notifyOnChangeProps: 'all',
})
states.push(state)
return (
<div>
<button onClick={() => state.fetchNextPage()}>fetchNextPage</button>
<button onClick={() => state.fetchPreviousPage()}>
fetchPreviousPage
</button>
<button onClick={() => state.refetch()}>refetch</button>
<div>data: {state.data?.pages.join(',') ?? 'null'}</div>
<div>isFetching: {String(state.isFetching)}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 10'))
fireEvent.click(rendered.getByRole('button', { name: /fetchNextPage/i }))
await waitFor(() => rendered.getByText('data: 10,11'))
fireEvent.click(
rendered.getByRole('button', { name: /fetchPreviousPage/i }),
)
await waitFor(() => rendered.getByText('data: 9,10,11'))
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() => rendered.getByText('isFetching: false'))
await waitFor(() => expect(states.length).toBe(8))
// Initial fetch
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isFetchingNextPage: false,
isRefetching: false,
})
// Initial fetch done
expect(states[1]).toMatchObject({
data: { pages: [10] },
isFetching: false,
isFetchingNextPage: false,
isRefetching: false,
})
// Fetch next page
expect(states[2]).toMatchObject({
data: { pages: [10] },
isFetching: true,
isFetchingNextPage: true,
isRefetching: false,
})
// Fetch next page done
expect(states[3]).toMatchObject({
data: { pages: [10, 11] },
isFetching: false,
isFetchingNextPage: false,
isRefetching: false,
})
// Fetch previous page
expect(states[4]).toMatchObject({
data: { pages: [10, 11] },
isFetching: true,
isFetchingNextPage: false,
isFetchingPreviousPage: true,
isRefetching: false,
})
// Fetch previous page done
expect(states[5]).toMatchObject({
data: { pages: [9, 10, 11] },
isFetching: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isRefetching: false,
})
// Refetch
expect(states[6]).toMatchObject({
data: { pages: [9, 10, 11] },
isFetching: true,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isRefetching: true,
})
// Refetch done
expect(states[7]).toMatchObject({
data: { pages: [9, 10, 11] },
isFetching: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isRefetching: false,
})
})
it('should silently cancel any ongoing fetch when fetching more', async () => {
const key = queryKey()
function Page() {
const start = 10
const { data, fetchNextPage, refetch, status, fetchStatus } =
useInfiniteQuery({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(50)
return Number(pageParam)
},
initialPageParam: start,
getNextPageParam: (lastPage) => lastPage + 1,
})
return (
<div>
<button onClick={() => fetchNextPage()}>fetchNextPage</button>
<button onClick={() => refetch()}>refetch</button>
<div>data: {JSON.stringify(data)}</div>
<div>
status: {status}, {fetchStatus}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('status: success, idle'))
await waitFor(() =>
rendered.getByText('data: {"pages":[10],"pageParams":[10]}'),
)
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() => rendered.getByText('status: success, fetching'))
fireEvent.click(rendered.getByRole('button', { name: /fetchNextPage/i }))
await waitFor(() => rendered.getByText('status: success, idle'))
await waitFor(() =>
rendered.getByText('data: {"pages":[10,11],"pageParams":[10,11]}'),
)
})
it('should silently cancel an ongoing fetchNextPage request when another fetchNextPage is invoked', async () => {
const key = queryKey()
const start = 10
const onAborts: Array<Mock<any, any>> = []
const abortListeners: Array<Mock<any, any>> = []
const fetchPage = vi.fn<
[QueryFunctionContext<typeof key, number>],
Promise<number>
>(async ({ pageParam, signal }) => {
const onAbort = vi.fn()
const abortListener = vi.fn()
onAborts.push(onAbort)
abortListeners.push(abortListener)
signal.onabort = onAbort
signal.addEventListener('abort', abortListener)
await sleep(50)
return Number(pageParam)
})
function Page() {
const { fetchNextPage } = useInfiniteQuery({
queryKey: key,
queryFn: fetchPage,
initialPageParam: start,
getNextPageParam: (lastPage) => lastPage + 1,
})
React.useEffect(() => {
setActTimeout(() => {
fetchNextPage()
}, 100)
setActTimeout(() => {
fetchNextPage()
}, 110)
}, [fetchNextPage])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(300)
const expectedCallCount = 3
expect(fetchPage).toBeCalledTimes(expectedCallCount)
expect(onAborts).toHaveLength(expectedCallCount)
expect(abortListeners).toHaveLength(expectedCallCount)
let callIndex = 0
const firstCtx = fetchPage.mock.calls[callIndex]![0]
expect(firstCtx.pageParam).toEqual(start)
expect(firstCtx.queryKey).toEqual(key)
expect(firstCtx.signal).toBeInstanceOf(AbortSignal)
expect(firstCtx.signal.aborted).toBe(false)
expect(onAborts[callIndex]).not.toHaveBeenCalled()
expect(abortListeners[callIndex]).not.toHaveBeenCalled()
callIndex = 1
const secondCtx = fetchPage.mock.calls[callIndex]![0]
expect(secondCtx.pageParam).toBe(11)
expect(secondCtx.queryKey).toEqual(key)
expect(secondCtx.signal).toBeInstanceOf(AbortSignal)
expect(secondCtx.signal.aborted).toBe(true)
expect(onAborts[callIndex]).toHaveBeenCalledTimes(1)
expect(abortListeners[callIndex]).toHaveBeenCalledTimes(1)
callIndex = 2
const thirdCtx = fetchPage.mock.calls[callIndex]![0]
expect(thirdCtx.pageParam).toBe(11)
expect(thirdCtx.queryKey).toEqual(key)
expect(thirdCtx.signal).toBeInstanceOf(AbortSignal)
expect(thirdCtx.signal.aborted).toBe(false)
expect(onAborts[callIndex]).not.toHaveBeenCalled()
expect(abortListeners[callIndex]).not.toHaveBeenCalled()
})
it('should not cancel an ongoing fetchNextPage request when another fetchNextPage is invoked if `cancelRefetch: false` is used ', async () => {
const key = queryKey()
const start = 10
const onAborts: Array<Mock<any, any>> = []
const abortListeners: Array<Mock<any, any>> = []
const fetchPage = vi.fn<
[QueryFunctionContext<typeof key, number>],
Promise<number>
>(async ({ pageParam, signal }) => {
const onAbort = vi.fn()
const abortListener = vi.fn()
onAborts.push(onAbort)
abortListeners.push(abortListener)
signal.onabort = onAbort
signal.addEventListener('abort', abortListener)
await sleep(50)
return Number(pageParam)
})
function Page() {
const { fetchNextPage } = useInfiniteQuery({
queryKey: key,
queryFn: fetchPage,
initialPageParam: start,
getNextPageParam: (lastPage) => lastPage + 1,
})
React.useEffect(() => {
setActTimeout(() => {
fetchNextPage()
}, 100)
setActTimeout(() => {
fetchNextPage({ cancelRefetch: false })
}, 110)
}, [fetchNextPage])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(300)
const expectedCallCount = 2
expect(fetchPage).toBeCalledTimes(expectedCallCount)
expect(onAborts).toHaveLength(expectedCallCount)
expect(abortListeners).toHaveLength(expectedCallCount)
let callIndex = 0
const firstCtx = fetchPage.mock.calls[callIndex]![0]
expect(firstCtx.pageParam).toEqual(start)
expect(firstCtx.queryKey).toEqual(key)
expect(firstCtx.signal).toBeInstanceOf(AbortSignal)
expect(firstCtx.signal.aborted).toBe(false)
expect(onAborts[callIndex]).not.toHaveBeenCalled()
expect(abortListeners[callIndex]).not.toHaveBeenCalled()
callIndex = 1
const secondCtx = fetchPage.mock.calls[callIndex]![0]
expect(secondCtx.pageParam).toBe(11)
expect(secondCtx.queryKey).toEqual(key)
expect(secondCtx.signal).toBeInstanceOf(AbortSignal)
expect(secondCtx.signal.aborted).toBe(false)
expect(onAborts[callIndex]).not.toHaveBeenCalled()
expect(abortListeners[callIndex]).not.toHaveBeenCalled()
})
it('should keep fetching first page when not loaded yet and triggering fetch more', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const start = 10
const state = useInfiniteQuery({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(50)
return Number(pageParam)
},
initialPageParam: start,
getNextPageParam: (lastPage) => lastPage + 1,
notifyOnChangeProps: 'all',
})
states.push(state)
const { fetchNextPage } = state
React.useEffect(() => {
setActTimeout(() => {
fetchNextPage()
}, 10)
}, [fetchNextPage])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
hasNextPage: false,
data: undefined,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
})
expect(states[1]).toMatchObject({
hasNextPage: true,
data: { pages: [10] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should stop fetching additional pages when the component is unmounted and AbortSignal is consumed', async () => {
const key = queryKey()
let fetches = 0
const initialData = { pages: [1, 2, 3, 4], pageParams: [0, 1, 2, 3] }
function List() {
useInfiniteQuery({
queryKey: key,
queryFn: async ({ pageParam, signal: _ }) => {
fetches++
await sleep(50)
return Number(pageParam) * 10
},
initialData,
initialPageParam: 0,
getNextPageParam: (_, allPages) => {
return allPages.length === 4 ? undefined : allPages.length
},
})
return null
}
function Page() {
const [show, setShow] = React.useState(true)
React.useEffect(() => {
setActTimeout(() => {
setShow(false)
}, 75)
}, [])
return show ? <List /> : null
}
renderWithClient(queryClient, <Page />)
await sleep(300)
expect(fetches).toBe(2)
expect(queryClient.getQueryState(key)).toMatchObject({
data: initialData,
status: 'success',
error: null,
})
})
it('should be able to set new pages with the query client', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const [firstPage, setFirstPage] = React.useState(0)
const state = useInfiniteQuery({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam)
},
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: firstPage,
notifyOnChangeProps: 'all',
})
states.push(state)
const { refetch } = state
React.useEffect(() => {
setActTimeout(() => {
queryClient.setQueryData(key, { pages: [7, 8], pageParams: [7, 8] })
setFirstPage(7)
}, 20)
setActTimeout(() => {
refetch()
}, 50)
}, [refetch])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(5)
expect(states[0]).toMatchObject({
hasNextPage: false,
data: undefined,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
})
// After first fetch
expect(states[1]).toMatchObject({
hasNextPage: true,
data: { pages: [0] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
// Set state
expect(states[2]).toMatchObject({
hasNextPage: true,
data: { pages: [7, 8] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
// Refetch
expect(states[3]).toMatchObject({
hasNextPage: true,
data: { pages: [7, 8] },
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
})
// Refetch done
expect(states[4]).toMatchObject({
hasNextPage: true,
data: { pages: [7, 8] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should only refetch the first page when initialData is provided', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: async ({ pageParam }): Promise<number> => {
await sleep(10)
return pageParam
},
initialData: { pages: [1], pageParams: [1] },
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: 0,
notifyOnChangeProps: 'all',
})
states.push(state)
const { fetchNextPage } = state
React.useEffect(() => {
setActTimeout(() => {
fetchNextPage()
}, 20)
}, [fetchNextPage])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(4)
expect(states[0]).toMatchObject({
data: { pages: [1] },
hasNextPage: true,
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[1]).toMatchObject({
data: { pages: [1] },
hasNextPage: true,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[2]).toMatchObject({
data: { pages: [1] },
hasNextPage: true,
isFetching: true,
isFetchingNextPage: true,
isSuccess: true,
})
expect(states[3]).toMatchObject({
data: { pages: [1, 2] },
hasNextPage: true,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should set hasNextPage to false if getNextPageParam returns undefined', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }) => Number(pageParam),
getNextPageParam: () => undefined,
initialPageParam: 1,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
hasNextPage: false,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: [1] },
hasNextPage: false,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should compute hasNextPage correctly using initialData', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }): number => pageParam,
initialData: { pages: [10], pageParams: [10] },
getNextPageParam: (lastPage) => (lastPage === 10 ? 11 : undefined),
initialPageParam: 10,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: { pages: [10] },
hasNextPage: true,
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[1]).toMatchObject({
data: { pages: [10] },
hasNextPage: true,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should compute hasNextPage correctly for falsy getFetchMore return value using initialData', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }): number => pageParam,
initialPageParam: 10,
initialData: { pages: [10], pageParams: [10] },
getNextPageParam: () => undefined,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: { pages: [10] },
hasNextPage: false,
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[1]).toMatchObject({
data: { pages: [10] },
hasNextPage: false,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should not use selected data when computing hasNextPage', async () => {
const key = queryKey()
const states: Array<UseInfiniteQueryResult<InfiniteData<string>>> = []
function Page() {
const state = useInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }) => Number(pageParam),
getNextPageParam: (lastPage) => (lastPage === 1 ? 2 : undefined),
select: (data) => ({
pages: data.pages.map((x) => x.toString()),
pageParams: data.pageParams,
}),
initialPageParam: 1,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
hasNextPage: false,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: ['1'] },
hasNextPage: true,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should build fresh cursors on refetch', async () => {
const key = queryKey()
const genItems = (size: number) =>
[...new Array(size)].fill(null).map((_, d) => d)
const items = genItems(15)
const limit = 3
const fetchItemsWithLimit = async (cursor = 0, ts: number) => {
await sleep(10)
return {
nextId: cursor + limit,
items: items.slice(cursor, cursor + limit),
ts,
}
}
function Page() {
const fetchCountRef = React.useRef(0)
const {
status,
data,
error,
isFetchingNextPage,
fetchNextPage,
hasNextPage,
refetch,
} = useInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }) =>
fetchItemsWithLimit(pageParam, fetchCountRef.current++),
initialPageParam: 0,
getNextPageParam: (lastPage) => lastPage.nextId,
})
return (
<div>
<h1>Pagination</h1>
{status === 'pending' ? (
'Loading...'
) : status === 'error' ? (
<span>Error: {error.message}</span>
) : (
<>
<div>Data:</div>
{data.pages.map((page, i) => (
<div key={i}>
<div>
Page {i}: {page.ts}
</div>
<div key={i}>
{page.items.map((item) => (
<p key={item}>Item: {item}</p>
))}
</div>
</div>
))}
<div>
<button
onClick={() => fetchNextPage()}
disabled={!hasNextPage || isFetchingNextPage}
>
{isFetchingNextPage
? 'Loading more...'
: hasNextPage
? 'Load More'
: 'Nothing more to load'}
</button>
<button onClick={() => refetch()}>Refetch</button>
<button
onClick={() => {
// Imagine that this mutation happens somewhere else
// makes an actual network request
// and calls invalidateQueries in an onSuccess
items.splice(4, 1)
queryClient.invalidateQueries({ queryKey: key })
}}
>
Remove item
</button>
</div>
<div>{!isFetchingNextPage ? 'Background Updating...' : null}</div>
</>
)}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
rendered.getByText('Loading...')
await waitFor(() => rendered.getByText('Item: 2'))
await waitFor(() => rendered.getByText('Page 0: 0'))
fireEvent.click(rendered.getByText('Load More'))
await waitFor(() => rendered.getByText('Loading more...'))
await waitFor(() => rendered.getByText('Item: 5'))
await waitFor(() => rendered.getByText('Page 0: 0'))
await waitFor(() => rendered.getByText('Page 1: 1'))
fireEvent.click(rendered.getByText('Load More'))
await waitFor(() => rendered.getByText('Loading more...'))
await waitFor(() => rendered.getByText('Item: 8'))
await waitFor(() => rendered.getByText('Page 0: 0'))
await waitFor(() => rendered.getByText('Page 1: 1'))
await waitFor(() => rendered.getByText('Page 2: 2'))
fireEvent.click(rendered.getByText('Refetch'))
await waitFor(() => rendered.getByText('Background Updating...'))
await waitFor(() => rendered.getByText('Item: 8'))
await waitFor(() => rendered.getByText('Page 0: 3'))
await waitFor(() => rendered.getByText('Page 1: 4'))
await waitFor(() => rendered.getByText('Page 2: 5'))
// ensure that Item: 4 is rendered before removing it
expect(rendered.queryAllByText('Item: 4')).toHaveLength(1)
// remove Item: 4
fireEvent.click(rendered.getByText('Remove item'))
await waitFor(() => rendered.getByText('Background Updating...'))
// ensure that an additional item is rendered (it means that cursors were properly rebuilt)
await waitFor(() => rendered.getByText('Item: 9'))
await waitFor(() => rendered.getByText('Page 0: 6'))
await waitFor(() => rendered.getByText('Page 1: 7'))
await waitFor(() => rendered.getByText('Page 2: 8'))
// ensure that Item: 4 is no longer rendered
expect(rendered.queryAllByText('Item: 4')).toHaveLength(0)
})
it('should compute hasNextPage correctly for falsy getFetchMore return value on refetching', async () => {
const key = queryKey()
const MAX = 2
function Page() {
const fetchCountRef = React.useRef(0)
const [isRemovedLastPage, setIsRemovedLastPage] =
React.useState<boolean>(false)
const {
status,
data,
error,
isFetching,
isFetchingNextPage,
fetchNextPage,
hasNextPage,
refetch,
} = useInfiniteQuery({
queryKey: key,
queryFn: ({ pageParam }) =>
fetchItems(
pageParam,
fetchCountRef.current++,
pageParam === MAX || (pageParam === MAX - 1 && isRemovedLastPage),
),
getNextPageParam: (lastPage) => lastPage.nextId,
initialPageParam: 0,
})
return (
<div>
<h1>Pagination</h1>
{status === 'pending' ? (
'Loading...'
) : status === 'error' ? (
<span>Error: {error.message}</span>
) : (
<>
<div>Data:</div>
{data.pages.map((page, i) => (
<div key={i}>
<div>
Page {i}: {page.ts}
</div>
<div key={i}>
{page.items.map((item) => (
<p key={item}>Item: {item}</p>
))}
</div>
</div>
))}
<div>
<button
onClick={() => fetchNextPage()}
disabled={!hasNextPage || isFetchingNextPage}
>
{isFetchingNextPage
? 'Loading more...'
: hasNextPage
? 'Load More'
: 'Nothing more to load'}
</button>
<button onClick={() => refetch()}>Refetch</button>
<button onClick={() => setIsRemovedLastPage(true)}>
Remove Last Page
</button>
</div>
<div>
{isFetching && !isFetchingNextPage
? 'Background Updating...'
: null}
</div>
</>
)}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
rendered.getByText('Loading...')
await waitFor(() => {
rendered.getByText('Item: 9')
rendered.getByText('Page 0: 0')
})
fireEvent.click(rendered.getByText('Load More'))
await waitFor(() => rendered.getByText('Loading more...'))
await waitFor(() => {
rendered.getByText('Item: 19')
rendered.getByText('Page 0: 0')
rendered.getByText('Page 1: 1')
})
fireEvent.click(rendered.getByText('Load More'))
await waitFor(() => rendered.getByText('Loading more...'))
await waitFor(() => {
rendered.getByText('Item: 29')
rendered.getByText('Page 0: 0')
rendered.getByText('Page 1: 1')
rendered.getByText('Page 2: 2')
})
rendered.getByText('Nothing more to load')
fireEvent.click(rendered.getByText('Remove Last Page'))
await sleep(10)
fireEvent.click(rendered.getByText('Refetch'))
await waitFor(() => rendered.getByText('Background Updating...'))
await waitFor(() => {
rendered.getByText('Page 0: 3')
rendered.getByText('Page 1: 4')
})
expect(rendered.queryByText('Item: 29')).toBeNull()
expect(rendered.queryByText('Page 2: 5')).toBeNull()
rendered.getByText('Nothing more to load')
})
it('should cancel the query function when there are no more subscriptions', async () => {
const key = queryKey()
let cancelFn: Mock = vi.fn()
const queryFn = ({ signal }: { signal?: AbortSignal }) => {
const promise = new Promise<string>((resolve, reject) => {
cancelFn = vi.fn(() => reject('Cancelled'))
signal?.addEventListener('abort', cancelFn)
sleep(1000).then(() => resolve('OK'))
})
return promise
}
function Inner() {
const state = useInfiniteQuery({
queryKey: key,
queryFn,
getNextPageParam: () => undefined,
initialPageParam: 0,
})
return (
<div>
<h1>Status: {state.status}</h1>
</div>
)
}
function Page() {
const [isVisible, setIsVisible] = React.useState(true)
return (
<>
<button onClick={() => setIsVisible(false)}>hide</button>
{isVisible && <Inner />}
<div>{isVisible ? 'visible' : 'hidden'}</div>
</>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('visible'))
fireEvent.click(rendered.getByRole('button', { name: 'hide' }))
await waitFor(() => rendered.getByText('hidden'))
expect(cancelFn).toHaveBeenCalled()
})
it('should use provided custom queryClient', async () => {
const key = queryKey()
const queryFn = async () => {
return Promise.resolve('custom client')
}
function Page() {
const { data } = useInfiniteQuery(
{
queryKey: key,
queryFn,
getNextPageParam: () => undefined,
initialPageParam: 0,
},
queryClient,
)
return <div>data: {data?.pages[0]}</div>
}
const rendered = render(<Page></Page>)
await waitFor(() => rendered.getByText('data: custom client'))
})
})
|
3,991 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/useInfiniteQuery.type.test.tsx | import { describe, it } from 'vitest'
import { QueryClient } from '@tanstack/query-core'
import { useInfiniteQuery } from '../useInfiniteQuery'
import { useQuery } from '../useQuery'
import { doNotExecute } from './utils'
import type { Equal, Expect } from './utils'
import type { InfiniteData } from '@tanstack/query-core'
describe('pageParam', () => {
it('initialPageParam should define type of param passed to queryFunctionContext', () => {
doNotExecute(() => {
useInfiniteQuery({
queryKey: ['key'],
queryFn: ({ pageParam }) => {
const result: Expect<Equal<number, typeof pageParam>> = true
return result
},
initialPageParam: 1,
getNextPageParam: () => undefined,
})
})
})
it('direction should be passed to queryFn of useInfiniteQuery', () => {
doNotExecute(() => {
useInfiniteQuery({
queryKey: ['key'],
queryFn: ({ direction }) => {
const result: Expect<
Equal<'forward' | 'backward', typeof direction>
> = true
return result
},
initialPageParam: 1,
getNextPageParam: () => undefined,
})
})
})
it('there should be no pageParam passed to the queryFn of useQuery', () => {
doNotExecute(() => {
useQuery({
queryKey: ['key'],
// @ts-expect-error there should be no pageParam passed to queryFn of useQuery
queryFn: ({ pageParam }) => {
return String(pageParam)
},
})
})
})
it('there should be no direction passed to the queryFn of useQuery', () => {
doNotExecute(() => {
useQuery({
queryKey: ['key'],
// @ts-expect-error there should be no pageParam passed to queryFn of useQuery
queryFn: ({ direction }) => {
return String(direction)
},
})
})
})
it('initialPageParam should define type of param passed to queryFunctionContext for fetchInfiniteQuery', () => {
doNotExecute(() => {
const queryClient = new QueryClient()
queryClient.fetchInfiniteQuery({
queryKey: ['key'],
queryFn: ({ pageParam }) => {
const result: Expect<Equal<number, typeof pageParam>> = true
return result
},
initialPageParam: 1,
})
})
})
it('initialPageParam should define type of param passed to queryFunctionContext for prefetchInfiniteQuery', () => {
doNotExecute(() => {
const queryClient = new QueryClient()
queryClient.prefetchInfiniteQuery({
queryKey: ['key'],
queryFn: ({ pageParam }) => {
const result: Expect<Equal<number, typeof pageParam>> = true
return result
},
initialPageParam: 1,
})
})
})
})
describe('select', () => {
it('should still return paginated data if no select result', () => {
doNotExecute(() => {
const infiniteQuery = useInfiniteQuery({
queryKey: ['key'],
queryFn: ({ pageParam }) => {
return pageParam * 5
},
initialPageParam: 1,
getNextPageParam: () => undefined,
})
// TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
const result: Expect<
Equal<
InfiniteData<number, unknown> | undefined,
(typeof infiniteQuery)['data']
>
> = true
return result
})
})
it('should be able to transform data to arbitrary result', () => {
doNotExecute(() => {
const infiniteQuery = useInfiniteQuery({
queryKey: ['key'],
queryFn: ({ pageParam }) => {
return pageParam * 5
},
initialPageParam: 1,
getNextPageParam: () => undefined,
select: (data) => {
const result: Expect<
Equal<InfiniteData<number, number>, typeof data>
> = true
return result
},
})
const result: Expect<
Equal<true | undefined, (typeof infiniteQuery)['data']>
> = true
return result
})
})
})
describe('getNextPageParam / getPreviousPageParam', () => {
it('should get typed params', () => {
doNotExecute(() => {
const infiniteQuery = useInfiniteQuery({
queryKey: ['key'],
queryFn: ({ pageParam }) => {
return String(pageParam)
},
initialPageParam: 1,
getNextPageParam: (
lastPage,
allPages,
lastPageParam,
allPageParams,
) => {
doNotExecute(() => {
const lastPageResult: Expect<Equal<string, typeof lastPage>> = true
return lastPageResult
})
doNotExecute(() => {
const allPagesResult: Expect<
Equal<Array<string>, typeof allPages>
> = true
return allPagesResult
})
doNotExecute(() => {
const lastPageParamResult: Expect<
Equal<number, typeof lastPageParam>
> = true
return lastPageParamResult
})
doNotExecute(() => {
const allPageParamsResult: Expect<
Equal<Array<number>, typeof allPageParams>
> = true
return allPageParamsResult
})
return undefined
},
getPreviousPageParam: (
firstPage,
allPages,
firstPageParam,
allPageParams,
) => {
doNotExecute(() => {
const firstPageResult: Expect<Equal<string, typeof firstPage>> =
true
return firstPageResult
})
doNotExecute(() => {
const allPagesResult: Expect<
Equal<Array<string>, typeof allPages>
> = true
return allPagesResult
})
doNotExecute(() => {
const firstPageParamResult: Expect<
Equal<number, typeof firstPageParam>
> = true
return firstPageParamResult
})
doNotExecute(() => {
const allPageParamsResult: Expect<
Equal<Array<number>, typeof allPageParams>
> = true
return allPageParamsResult
})
return undefined
},
})
// TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
const result: Expect<
Equal<
InfiniteData<string, unknown> | undefined,
(typeof infiniteQuery)['data']
>
> = true
return result
})
})
})
|
3,992 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/useIsFetching.test.tsx | import { describe, expect, it } from 'vitest'
import { fireEvent, render, waitFor } from '@testing-library/react'
import * as React from 'react'
import { QueryCache, useIsFetching, useQuery } from '..'
import {
createQueryClient,
queryKey,
renderWithClient,
setActTimeout,
sleep,
} from './utils'
describe('useIsFetching', () => {
// See https://github.com/tannerlinsley/react-query/issues/105
it('should update as queries start and stop fetching', async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const key = queryKey()
function IsFetching() {
const isFetching = useIsFetching()
return <div>isFetching: {isFetching}</div>
}
function Query() {
const [ready, setReady] = React.useState(false)
useQuery({
queryKey: key,
queryFn: async () => {
await sleep(50)
return 'test'
},
enabled: ready,
})
return <button onClick={() => setReady(true)}>setReady</button>
}
function Page() {
return (
<div>
<IsFetching />
<Query />
</div>
)
}
const { findByText, getByRole } = renderWithClient(queryClient, <Page />)
await findByText('isFetching: 0')
fireEvent.click(getByRole('button', { name: /setReady/i }))
await findByText('isFetching: 1')
await findByText('isFetching: 0')
})
it('should not update state while rendering', async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const key1 = queryKey()
const key2 = queryKey()
const isFetchings: Array<number> = []
function IsFetching() {
const isFetching = useIsFetching()
isFetchings.push(isFetching)
return null
}
function FirstQuery() {
useQuery({
queryKey: key1,
queryFn: async () => {
await sleep(100)
return 'data'
},
})
return null
}
function SecondQuery() {
useQuery({
queryKey: key2,
queryFn: async () => {
await sleep(100)
return 'data'
},
})
return null
}
function Page() {
const [renderSecond, setRenderSecond] = React.useState(false)
React.useEffect(() => {
setActTimeout(() => {
setRenderSecond(true)
}, 50)
}, [])
return (
<>
<IsFetching />
<FirstQuery />
{renderSecond && <SecondQuery />}
</>
)
}
renderWithClient(queryClient, <Page />)
await waitFor(() => expect(isFetchings).toEqual([0, 1, 1, 2, 1, 0]))
})
it('should be able to filter', async () => {
const queryClient = createQueryClient()
const key1 = queryKey()
const key2 = queryKey()
const isFetchings: Array<number> = []
function One() {
useQuery({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 'test'
},
})
return null
}
function Two() {
useQuery({
queryKey: key2,
queryFn: async () => {
await sleep(20)
return 'test'
},
})
return null
}
function Page() {
const [started, setStarted] = React.useState(false)
const isFetching = useIsFetching({ queryKey: key1 })
isFetchings.push(isFetching)
return (
<div>
<button onClick={() => setStarted(true)}>setStarted</button>
<div>isFetching: {isFetching}</div>
{started ? (
<>
<One />
<Two />
</>
) : null}
</div>
)
}
const { findByText, getByRole } = renderWithClient(queryClient, <Page />)
await findByText('isFetching: 0')
fireEvent.click(getByRole('button', { name: /setStarted/i }))
await findByText('isFetching: 1')
await findByText('isFetching: 0')
// at no point should we have isFetching: 2
expect(isFetchings).toEqual(expect.not.arrayContaining([2]))
})
it('should show the correct fetching state when mounted after a query', async () => {
const queryClient = createQueryClient()
const key = queryKey()
function Page() {
useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
})
const isFetching = useIsFetching()
return (
<div>
<div>isFetching: {isFetching}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('isFetching: 1')
await rendered.findByText('isFetching: 0')
})
it('should use provided custom queryClient', async () => {
const queryClient = createQueryClient()
const key = queryKey()
function Page() {
useQuery(
{
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
},
queryClient,
)
const isFetching = useIsFetching({}, queryClient)
return (
<div>
<div>isFetching: {isFetching}</div>
</div>
)
}
const rendered = render(<Page></Page>)
await waitFor(() => rendered.getByText('isFetching: 1'))
})
})
|
3,993 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/useMutation.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { fireEvent, render, waitFor } from '@testing-library/react'
import * as React from 'react'
import { ErrorBoundary } from 'react-error-boundary'
import { MutationCache, QueryCache, useMutation } from '..'
import {
createQueryClient,
mockOnlineManagerIsOnline,
queryKey,
renderWithClient,
setActTimeout,
sleep,
} from './utils'
import type { UseMutationResult } from '../types'
describe('useMutation', () => {
const queryCache = new QueryCache()
const mutationCache = new MutationCache()
const queryClient = createQueryClient({ queryCache, mutationCache })
it('should be able to reset `data`', async () => {
function Page() {
const {
mutate,
data = 'empty',
reset,
} = useMutation({ mutationFn: () => Promise.resolve('mutation') })
return (
<div>
<h1>{data}</h1>
<button onClick={() => reset()}>reset</button>
<button onClick={() => mutate()}>mutate</button>
</div>
)
}
const { getByRole } = renderWithClient(queryClient, <Page />)
expect(getByRole('heading').textContent).toBe('empty')
fireEvent.click(getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(getByRole('heading').textContent).toBe('mutation')
})
fireEvent.click(getByRole('button', { name: /reset/i }))
await waitFor(() => {
expect(getByRole('heading').textContent).toBe('empty')
})
})
it('should be able to reset `error`', async () => {
function Page() {
const { mutate, error, reset } = useMutation<string, Error>({
mutationFn: () => {
const err = new Error('Expected mock error. All is well!')
err.stack = ''
return Promise.reject(err)
},
})
return (
<div>
{error && <h1>{error.message}</h1>}
<button onClick={() => reset()}>reset</button>
<button onClick={() => mutate()}>mutate</button>
</div>
)
}
const { getByRole, queryByRole } = renderWithClient(queryClient, <Page />)
await waitFor(() => {
expect(queryByRole('heading')).toBeNull()
})
fireEvent.click(getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(getByRole('heading').textContent).toBe(
'Expected mock error. All is well!',
)
})
fireEvent.click(getByRole('button', { name: /reset/i }))
await waitFor(() => {
expect(queryByRole('heading')).toBeNull()
})
})
it('should be able to call `onSuccess` and `onSettled` after each successful mutate', async () => {
let count = 0
const onSuccessMock = vi.fn()
const onSettledMock = vi.fn()
function Page() {
const { mutate } = useMutation({
mutationFn: (vars: { count: number }) => Promise.resolve(vars.count),
onSuccess: (data) => {
onSuccessMock(data)
},
onSettled: (data) => {
onSettledMock(data)
},
})
return (
<div>
<h1>{count}</h1>
<button onClick={() => mutate({ count: ++count })}>mutate</button>
</div>
)
}
const { getByRole } = renderWithClient(queryClient, <Page />)
expect(getByRole('heading').textContent).toBe('0')
fireEvent.click(getByRole('button', { name: /mutate/i }))
fireEvent.click(getByRole('button', { name: /mutate/i }))
fireEvent.click(getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(getByRole('heading').textContent).toBe('3')
})
await waitFor(() => {
expect(onSuccessMock).toHaveBeenCalledTimes(3)
})
expect(onSuccessMock).toHaveBeenCalledWith(1)
expect(onSuccessMock).toHaveBeenCalledWith(2)
expect(onSuccessMock).toHaveBeenCalledWith(3)
await waitFor(() => {
expect(onSettledMock).toHaveBeenCalledTimes(3)
})
expect(onSettledMock).toHaveBeenCalledWith(1)
expect(onSettledMock).toHaveBeenCalledWith(2)
expect(onSettledMock).toHaveBeenCalledWith(3)
})
it('should set correct values for `failureReason` and `failureCount` on multiple mutate calls', async () => {
let count = 0
type Value = { count: number }
const mutateFn = vi.fn<[value: Value], Promise<Value>>()
mutateFn.mockImplementationOnce(() => {
return Promise.reject(new Error('Error test Jonas'))
})
mutateFn.mockImplementation(async (value) => {
await sleep(10)
return Promise.resolve(value)
})
function Page() {
const { mutate, failureCount, failureReason, data, status } = useMutation(
{ mutationFn: mutateFn },
)
return (
<div>
<h1>Data {data?.count}</h1>
<h2>Status {status}</h2>
<h2>Failed {failureCount} times</h2>
<h2>Failed because {failureReason?.message ?? 'null'}</h2>
<button onClick={() => mutate({ count: ++count })}>mutate</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Data'))
fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
await waitFor(() => rendered.getByText('Data'))
await waitFor(() => rendered.getByText('Status error'))
await waitFor(() => rendered.getByText('Failed 1 times'))
await waitFor(() => rendered.getByText('Failed because Error test Jonas'))
fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
await waitFor(() => rendered.getByText('Status pending'))
await waitFor(() => rendered.getByText('Status success'))
await waitFor(() => rendered.getByText('Data 2'))
await waitFor(() => rendered.getByText('Failed 0 times'))
await waitFor(() => rendered.getByText('Failed because null'))
})
it('should be able to call `onError` and `onSettled` after each failed mutate', async () => {
const onErrorMock = vi.fn()
const onSettledMock = vi.fn()
let count = 0
function Page() {
const { mutate } = useMutation({
mutationFn: (vars: { count: number }) => {
const error = new Error(
`Expected mock error. All is well! ${vars.count}`,
)
error.stack = ''
return Promise.reject(error)
},
onError: (error: Error) => {
onErrorMock(error.message)
},
onSettled: (_data, error) => {
onSettledMock(error?.message)
},
})
return (
<div>
<h1>{count}</h1>
<button onClick={() => mutate({ count: ++count })}>mutate</button>
</div>
)
}
const { getByRole } = renderWithClient(queryClient, <Page />)
expect(getByRole('heading').textContent).toBe('0')
fireEvent.click(getByRole('button', { name: /mutate/i }))
fireEvent.click(getByRole('button', { name: /mutate/i }))
fireEvent.click(getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(getByRole('heading').textContent).toBe('3')
})
await waitFor(() => {
expect(onErrorMock).toHaveBeenCalledTimes(3)
})
expect(onErrorMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 1',
)
expect(onErrorMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 2',
)
expect(onErrorMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 3',
)
await waitFor(() => {
expect(onSettledMock).toHaveBeenCalledTimes(3)
})
expect(onSettledMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 1',
)
expect(onSettledMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 2',
)
expect(onSettledMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 3',
)
})
it('should be able to override the useMutation success callbacks', async () => {
const callbacks: Array<string> = []
function Page() {
const { mutateAsync } = useMutation({
mutationFn: async (text: string) => text,
onSuccess: async () => {
callbacks.push('useMutation.onSuccess')
},
onSettled: async () => {
callbacks.push('useMutation.onSettled')
},
})
React.useEffect(() => {
setActTimeout(async () => {
try {
const result = await mutateAsync('todo', {
onSuccess: async () => {
callbacks.push('mutateAsync.onSuccess')
},
onSettled: async () => {
callbacks.push('mutateAsync.onSettled')
},
})
callbacks.push(`mutateAsync.result:${result}`)
} catch {}
}, 10)
}, [mutateAsync])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(callbacks).toEqual([
'useMutation.onSuccess',
'useMutation.onSettled',
'mutateAsync.onSuccess',
'mutateAsync.onSettled',
'mutateAsync.result:todo',
])
})
it('should be able to override the error callbacks when using mutateAsync', async () => {
const callbacks: Array<string> = []
function Page() {
const { mutateAsync } = useMutation({
mutationFn: async (_text: string) => Promise.reject(new Error('oops')),
onError: async () => {
callbacks.push('useMutation.onError')
},
onSettled: async () => {
callbacks.push('useMutation.onSettled')
},
})
React.useEffect(() => {
setActTimeout(async () => {
try {
await mutateAsync('todo', {
onError: async () => {
callbacks.push('mutateAsync.onError')
},
onSettled: async () => {
callbacks.push('mutateAsync.onSettled')
},
})
} catch (error) {
callbacks.push(`mutateAsync.error:${(error as Error).message}`)
}
}, 10)
}, [mutateAsync])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(callbacks).toEqual([
'useMutation.onError',
'useMutation.onSettled',
'mutateAsync.onError',
'mutateAsync.onSettled',
'mutateAsync.error:oops',
])
})
it('should be able to use mutation defaults', async () => {
const key = queryKey()
queryClient.setMutationDefaults(key, {
mutationFn: async (text: string) => {
await sleep(10)
return text
},
})
const states: Array<UseMutationResult<any, any, any, any>> = []
function Page() {
const state = useMutation<string, unknown, string>({ mutationKey: key })
states.push(state)
const { mutate } = state
React.useEffect(() => {
setActTimeout(() => {
mutate('todo')
}, 10)
}, [mutate])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(3)
expect(states[0]).toMatchObject({ data: undefined, isPending: false })
expect(states[1]).toMatchObject({ data: undefined, isPending: true })
expect(states[2]).toMatchObject({ data: 'todo', isPending: false })
})
it('should be able to retry a failed mutation', async () => {
let count = 0
function Page() {
const { mutate } = useMutation({
mutationFn: (_text: string) => {
count++
return Promise.reject(new Error('oops'))
},
retry: 1,
retryDelay: 5,
})
React.useEffect(() => {
setActTimeout(() => {
mutate('todo')
}, 10)
}, [mutate])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(count).toBe(2)
})
it('should not retry mutations while offline', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
let count = 0
function Page() {
const mutation = useMutation({
mutationFn: (_text: string) => {
count++
return Promise.reject(new Error('oops'))
},
retry: 1,
retryDelay: 5,
})
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
error:{' '}
{mutation.error instanceof Error ? mutation.error.message : 'null'},
status: {mutation.status}, isPaused: {String(mutation.isPaused)}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
window.dispatchEvent(new Event('offline'))
await waitFor(() => {
expect(
rendered.getByText('error: null, status: idle, isPaused: false'),
).toBeInTheDocument()
})
fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(
rendered.getByText('error: null, status: pending, isPaused: true'),
).toBeInTheDocument()
})
expect(count).toBe(0)
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await sleep(100)
await waitFor(() => {
expect(
rendered.getByText('error: oops, status: error, isPaused: false'),
).toBeInTheDocument()
})
expect(count).toBe(2)
})
it('should call onMutate even if paused', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const onMutate = vi.fn()
let count = 0
function Page() {
const mutation = useMutation({
mutationFn: async (_text: string) => {
count++
await sleep(10)
return count
},
onMutate,
})
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status},
isPaused: {String(mutation.isPaused)}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('data: null, status: idle, isPaused: false')
window.dispatchEvent(new Event('offline'))
fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
await rendered.findByText('data: null, status: pending, isPaused: true')
expect(onMutate).toHaveBeenCalledTimes(1)
expect(onMutate).toHaveBeenCalledWith('todo')
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await rendered.findByText('data: 1, status: success, isPaused: false')
expect(onMutate).toHaveBeenCalledTimes(1)
expect(count).toBe(1)
})
it('should optimistically go to paused state if offline', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
let count = 0
const states: Array<string> = []
function Page() {
const mutation = useMutation({
mutationFn: async (_text: string) => {
count++
await sleep(10)
return count
},
})
states.push(`${mutation.status}, ${mutation.isPaused}`)
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status},
isPaused: {String(mutation.isPaused)}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('data: null, status: idle, isPaused: false')
window.dispatchEvent(new Event('offline'))
fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
await rendered.findByText('data: null, status: pending, isPaused: true')
// no intermediate 'pending, false' state is expected because we don't start mutating!
expect(states[0]).toBe('idle, false')
expect(states[1]).toBe('pending, true')
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await rendered.findByText('data: 1, status: success, isPaused: false')
})
it('should be able to retry a mutation when online', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
let count = 0
const states: Array<UseMutationResult<any, any, any, any>> = []
function Page() {
const state = useMutation({
mutationFn: async (_text: string) => {
await sleep(1)
count++
return count > 1
? Promise.resolve('data')
: Promise.reject(new Error('oops'))
},
retry: 1,
retryDelay: 5,
networkMode: 'offlineFirst',
})
states.push(state)
const { mutate } = state
React.useEffect(() => {
setActTimeout(() => {
window.dispatchEvent(new Event('offline'))
mutate('todo')
}, 10)
}, [mutate])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(50)
expect(states.length).toBe(4)
expect(states[0]).toMatchObject({
isPending: false,
isPaused: false,
failureCount: 0,
failureReason: null,
})
expect(states[1]).toMatchObject({
isPending: true,
isPaused: false,
failureCount: 0,
failureReason: null,
})
expect(states[2]).toMatchObject({
isPending: true,
isPaused: false,
failureCount: 1,
failureReason: new Error('oops'),
})
expect(states[3]).toMatchObject({
isPending: true,
isPaused: true,
failureCount: 1,
failureReason: new Error('oops'),
})
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await sleep(50)
expect(states.length).toBe(6)
expect(states[4]).toMatchObject({
isPending: true,
isPaused: false,
failureCount: 1,
failureReason: new Error('oops'),
})
expect(states[5]).toMatchObject({
isPending: false,
isPaused: false,
failureCount: 0,
failureReason: null,
data: 'data',
})
})
it('should not change state if unmounted', async () => {
function Mutates() {
const { mutate } = useMutation({ mutationFn: () => sleep(10) })
return <button onClick={() => mutate()}>mutate</button>
}
function Page() {
const [mounted, setMounted] = React.useState(true)
return (
<div>
<button onClick={() => setMounted(false)}>unmount</button>
{mounted && <Mutates />}
</div>
)
}
const { getByText } = renderWithClient(queryClient, <Page />)
fireEvent.click(getByText('mutate'))
fireEvent.click(getByText('unmount'))
})
it('should be able to throw an error when throwOnError is set to true', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const { mutate } = useMutation<string, Error>({
mutationFn: () => {
const err = new Error('Expected mock error. All is well!')
err.stack = ''
return Promise.reject(err)
},
throwOnError: true,
})
return (
<div>
<button onClick={() => mutate()}>mutate</button>
</div>
)
}
const { getByText, queryByText } = renderWithClient(
queryClient,
<ErrorBoundary
fallbackRender={() => (
<div>
<span>error</span>
</div>
)}
>
<Page />
</ErrorBoundary>,
)
fireEvent.click(getByText('mutate'))
await waitFor(() => {
expect(queryByText('error')).not.toBeNull()
})
expect(consoleMock).toHaveBeenCalledWith(
expect.objectContaining(new Error('Expected mock error. All is well!')),
)
consoleMock.mockRestore()
})
it('should be able to throw an error when throwOnError is a function that returns true', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
let boundary = false
function Page() {
const { mutate, error } = useMutation<string, Error>({
mutationFn: () => {
const err = new Error('mock error')
err.stack = ''
return Promise.reject(err)
},
throwOnError: () => {
boundary = !boundary
return !boundary
},
})
return (
<div>
<button onClick={() => mutate()}>mutate</button>
{error && error.message}
</div>
)
}
const { getByText, queryByText } = renderWithClient(
queryClient,
<ErrorBoundary
fallbackRender={() => (
<div>
<span>error boundary</span>
</div>
)}
>
<Page />
</ErrorBoundary>,
)
// first error goes to component
fireEvent.click(getByText('mutate'))
await waitFor(() => {
expect(queryByText('mock error')).not.toBeNull()
})
// second error goes to boundary
fireEvent.click(getByText('mutate'))
await waitFor(() => {
expect(queryByText('error boundary')).not.toBeNull()
})
consoleMock.mockRestore()
})
it('should pass meta to mutation', async () => {
const errorMock = vi.fn()
const successMock = vi.fn()
const queryClientMutationMeta = createQueryClient({
mutationCache: new MutationCache({
onSuccess: (_, __, ___, mutation) => {
successMock(mutation.meta?.metaSuccessMessage)
},
onError: (_, __, ___, mutation) => {
errorMock(mutation.meta?.metaErrorMessage)
},
}),
})
const metaSuccessMessage = 'mutation succeeded'
const metaErrorMessage = 'mutation failed'
function Page() {
const { mutate: succeed, isSuccess } = useMutation({
mutationFn: async () => '',
meta: { metaSuccessMessage },
})
const { mutate: error, isError } = useMutation({
mutationFn: async () => {
throw new Error('')
},
meta: { metaErrorMessage },
})
return (
<div>
<button onClick={() => succeed()}>succeed</button>
<button onClick={() => error()}>error</button>
{isSuccess && <div>successTest</div>}
{isError && <div>errorTest</div>}
</div>
)
}
const { getByText, queryByText } = renderWithClient(
queryClientMutationMeta,
<Page />,
)
fireEvent.click(getByText('succeed'))
fireEvent.click(getByText('error'))
await waitFor(() => {
expect(queryByText('successTest')).not.toBeNull()
expect(queryByText('errorTest')).not.toBeNull()
})
expect(successMock).toHaveBeenCalledTimes(1)
expect(successMock).toHaveBeenCalledWith(metaSuccessMessage)
expect(errorMock).toHaveBeenCalledTimes(1)
expect(errorMock).toHaveBeenCalledWith(metaErrorMessage)
})
it('should call cache callbacks when unmounted', async () => {
const onSuccess = vi.fn()
const onSuccessMutate = vi.fn()
const onSettled = vi.fn()
const onSettledMutate = vi.fn()
const mutationKey = queryKey()
let count = 0
function Page() {
const [show, setShow] = React.useState(true)
return (
<div>
<button onClick={() => setShow(false)}>hide</button>
{show && <Component />}
</div>
)
}
function Component() {
const mutation = useMutation({
mutationFn: async (_text: string) => {
count++
await sleep(10)
return count
},
mutationKey,
gcTime: 0,
onSuccess,
onSettled,
})
return (
<div>
<button
onClick={() =>
mutation.mutate('todo', {
onSuccess: onSuccessMutate,
onSettled: onSettledMutate,
})
}
>
mutate
</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status},
isPaused: {String(mutation.isPaused)}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('data: null, status: idle, isPaused: false')
fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
fireEvent.click(rendered.getByRole('button', { name: /hide/i }))
await waitFor(() => {
expect(
queryClient.getMutationCache().findAll({ mutationKey }),
).toHaveLength(0)
})
expect(count).toBe(1)
expect(onSuccess).toHaveBeenCalledTimes(1)
expect(onSettled).toHaveBeenCalledTimes(1)
expect(onSuccessMutate).toHaveBeenCalledTimes(0)
expect(onSettledMutate).toHaveBeenCalledTimes(0)
})
it('should call mutate callbacks only for the last observer', async () => {
const onSuccess = vi.fn()
const onSuccessMutate = vi.fn()
const onSettled = vi.fn()
const onSettledMutate = vi.fn()
let count = 0
function Page() {
const mutation = useMutation({
mutationFn: async (text: string) => {
count++
const result = `result-${text}`
await sleep(10)
return result
},
onSuccess,
onSettled,
})
return (
<div>
<button
onClick={() =>
mutation.mutate('todo1', {
onSuccess: onSuccessMutate,
onSettled: onSettledMutate,
})
}
>
mutate1
</button>
<button
onClick={() =>
mutation.mutate('todo2', {
onSuccess: onSuccessMutate,
onSettled: onSettledMutate,
})
}
>
mutate2
</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('data: null, status: idle')
fireEvent.click(rendered.getByRole('button', { name: /mutate1/i }))
fireEvent.click(rendered.getByRole('button', { name: /mutate2/i }))
await rendered.findByText('data: result-todo2, status: success')
expect(count).toBe(2)
expect(onSuccess).toHaveBeenCalledTimes(2)
expect(onSuccess).toHaveBeenNthCalledWith(
1,
'result-todo1',
'todo1',
undefined,
)
expect(onSuccess).toHaveBeenNthCalledWith(
2,
'result-todo2',
'todo2',
undefined,
)
expect(onSettled).toHaveBeenCalledTimes(2)
expect(onSuccessMutate).toHaveBeenCalledTimes(1)
expect(onSuccessMutate).toHaveBeenCalledWith(
'result-todo2',
'todo2',
undefined,
)
expect(onSettledMutate).toHaveBeenCalledTimes(1)
expect(onSettledMutate).toHaveBeenCalledWith(
'result-todo2',
null,
'todo2',
undefined,
)
})
it('should go to error state if onSuccess callback errors', async () => {
const error = new Error('error from onSuccess')
const onError = vi.fn()
function Page() {
const mutation = useMutation({
mutationFn: async (_text: string) => {
await sleep(10)
return 'result'
},
onSuccess: () => Promise.reject(error),
onError,
})
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>status: {mutation.status}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('status: idle')
rendered.getByRole('button', { name: /mutate/i }).click()
await rendered.findByText('status: error')
expect(onError).toHaveBeenCalledWith(error, 'todo', undefined)
})
it('should go to error state if onError callback errors', async () => {
const error = new Error('error from onError')
const mutateFnError = new Error('mutateFnError')
function Page() {
const mutation = useMutation({
mutationFn: async (_text: string) => {
await sleep(10)
throw mutateFnError
},
onError: () => Promise.reject(error),
})
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
error:{' '}
{mutation.error instanceof Error ? mutation.error.message : 'null'},
status: {mutation.status}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('error: null, status: idle')
rendered.getByRole('button', { name: /mutate/i }).click()
await rendered.findByText('error: mutateFnError, status: error')
})
it('should go to error state if onSettled callback errors', async () => {
const error = new Error('error from onSettled')
const mutateFnError = new Error('mutateFnError')
const onError = vi.fn()
function Page() {
const mutation = useMutation({
mutationFn: async (_text: string) => {
await sleep(10)
throw mutateFnError
},
onSettled: () => Promise.reject(error),
onError,
})
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
error:{' '}
{mutation.error instanceof Error ? mutation.error.message : 'null'},
status: {mutation.status}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('error: null, status: idle')
rendered.getByRole('button', { name: /mutate/i }).click()
await rendered.findByText('error: mutateFnError, status: error')
expect(onError).toHaveBeenCalledWith(mutateFnError, 'todo', undefined)
})
it('should use provided custom queryClient', async () => {
function Page() {
const mutation = useMutation(
{
mutationFn: async (text: string) => {
return Promise.resolve(text)
},
},
queryClient,
)
return (
<div>
<button onClick={() => mutation.mutate('custom client')}>
mutate
</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status}
</div>
</div>
)
}
const rendered = render(<Page></Page>)
await rendered.findByText('data: null, status: idle')
fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
await rendered.findByText('data: custom client, status: success')
})
})
|
3,994 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/useMutationState.test.tsx | import { describe, expect, expectTypeOf, it } from 'vitest'
import { fireEvent, render, waitFor } from '@testing-library/react'
import * as React from 'react'
import { useIsMutating, useMutationState } from '../useMutationState'
import { useMutation } from '../useMutation'
import {
createQueryClient,
doNotExecute,
renderWithClient,
setActTimeout,
sleep,
} from './utils'
import type { MutationState, MutationStatus } from '@tanstack/query-core'
describe('useIsMutating', () => {
it('should return the number of fetching mutations', async () => {
const isMutatings: Array<number> = []
const queryClient = createQueryClient()
function IsMutating() {
const isMutating = useIsMutating()
isMutatings.push(isMutating)
return null
}
function Mutations() {
const { mutate: mutate1 } = useMutation({
mutationKey: ['mutation1'],
mutationFn: async () => {
await sleep(150)
return 'data'
},
})
const { mutate: mutate2 } = useMutation({
mutationKey: ['mutation2'],
mutationFn: async () => {
await sleep(50)
return 'data'
},
})
React.useEffect(() => {
mutate1()
setActTimeout(() => {
mutate2()
}, 50)
}, [mutate1, mutate2])
return null
}
function Page() {
return (
<div>
<IsMutating />
<Mutations />
</div>
)
}
renderWithClient(queryClient, <Page />)
await waitFor(() => expect(isMutatings).toEqual([0, 1, 2, 1, 0]))
})
it('should filter correctly by mutationKey', async () => {
const isMutatings: Array<number> = []
const queryClient = createQueryClient()
function IsMutating() {
const isMutating = useIsMutating({ mutationKey: ['mutation1'] })
isMutatings.push(isMutating)
return null
}
function Page() {
const { mutate: mutate1 } = useMutation({
mutationKey: ['mutation1'],
mutationFn: async () => {
await sleep(100)
return 'data'
},
})
const { mutate: mutate2 } = useMutation({
mutationKey: ['mutation2'],
mutationFn: async () => {
await sleep(100)
return 'data'
},
})
React.useEffect(() => {
mutate1()
mutate2()
}, [mutate1, mutate2])
return <IsMutating />
}
renderWithClient(queryClient, <Page />)
await waitFor(() => expect(isMutatings).toEqual([0, 1, 0]))
})
it('should filter correctly by predicate', async () => {
const isMutatings: Array<number> = []
const queryClient = createQueryClient()
function IsMutating() {
const isMutating = useIsMutating({
predicate: (mutation) =>
mutation.options.mutationKey?.[0] === 'mutation1',
})
isMutatings.push(isMutating)
return null
}
function Page() {
const { mutate: mutate1 } = useMutation({
mutationKey: ['mutation1'],
mutationFn: async () => {
await sleep(100)
return 'data'
},
})
const { mutate: mutate2 } = useMutation({
mutationKey: ['mutation2'],
mutationFn: async () => {
await sleep(100)
return 'data'
},
})
React.useEffect(() => {
mutate1()
mutate2()
}, [mutate1, mutate2])
return <IsMutating />
}
renderWithClient(queryClient, <Page />)
await waitFor(() => expect(isMutatings).toEqual([0, 1, 0]))
})
it('should use provided custom queryClient', async () => {
const queryClient = createQueryClient()
function Page() {
const isMutating = useIsMutating({}, queryClient)
const { mutate } = useMutation(
{
mutationKey: ['mutation1'],
mutationFn: async () => {
await sleep(10)
return 'data'
},
},
queryClient,
)
React.useEffect(() => {
mutate()
}, [mutate])
return (
<div>
<div>mutating: {isMutating}</div>
</div>
)
}
const rendered = render(<Page></Page>)
await waitFor(() => rendered.getByText('mutating: 1'))
})
})
describe('useMutationState', () => {
describe('types', () => {
it('should default to QueryState', () => {
doNotExecute(() => {
const result = useMutationState({
filters: { status: 'pending' },
})
expectTypeOf(result).toEqualTypeOf<Array<MutationState>>()
})
})
it('should infer with select', () => {
doNotExecute(() => {
const result = useMutationState({
filters: { status: 'pending' },
select: (mutation) => mutation.state.status,
})
expectTypeOf(result).toEqualTypeOf<Array<MutationStatus>>()
})
})
})
it('should return variables after calling mutate', async () => {
const queryClient = createQueryClient()
const variables: Array<Array<unknown>> = []
const mutationKey = ['mutation']
function Variables() {
variables.push(
useMutationState({
filters: { mutationKey, status: 'pending' },
select: (mutation) => mutation.state.variables,
}),
)
return null
}
function Mutate() {
const { mutate, data } = useMutation({
mutationKey,
mutationFn: async (input: number) => {
await sleep(150)
return 'data' + input
},
})
return (
<div>
data: {data ?? 'null'}
<button onClick={() => mutate(1)}>mutate</button>
</div>
)
}
function Page() {
return (
<div>
<Variables />
<Mutate />
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: null'))
fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
await waitFor(() => rendered.getByText('data: data1'))
expect(variables).toEqual([[], [1], []])
})
})
|
3,995 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/useQueries.test.tsx | import { describe, expect, expectTypeOf, it, vi } from 'vitest'
import { fireEvent, render, waitFor } from '@testing-library/react'
import * as React from 'react'
import { ErrorBoundary } from 'react-error-boundary'
import { QueryCache, useQueries } from '..'
import {
createQueryClient,
expectTypeNotAny,
queryKey,
renderWithClient,
sleep,
} from './utils'
import type {
QueryFunction,
QueryKey,
QueryObserverResult,
UseQueryOptions,
UseQueryResult,
} from '..'
import type { QueryFunctionContext } from '@tanstack/query-core'
describe('useQueries', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should return the correct states', async () => {
const key1 = queryKey()
const key2 = queryKey()
const results: Array<Array<UseQueryResult>> = []
function Page() {
const result = useQueries({
queries: [
{
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 1
},
},
{
queryKey: key2,
queryFn: async () => {
await sleep(200)
return 2
},
},
],
})
results.push(result)
return (
<div>
<div>
data1: {String(result[0].data ?? 'null')}, data2:{' '}
{String(result[1].data ?? 'null')}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data1: 1, data2: 2'))
expect(results.length).toBe(3)
expect(results[0]).toMatchObject([{ data: undefined }, { data: undefined }])
expect(results[1]).toMatchObject([{ data: 1 }, { data: undefined }])
expect(results[2]).toMatchObject([{ data: 1 }, { data: 2 }])
})
it('should track results', async () => {
const key1 = queryKey()
const results: Array<Array<UseQueryResult>> = []
let count = 0
function Page() {
const result = useQueries({
queries: [
{
queryKey: key1,
queryFn: async () => {
await sleep(10)
count++
return count
},
},
],
})
results.push(result)
return (
<div>
<div>data: {String(result[0].data ?? 'null')} </div>
<button onClick={() => result[0].refetch()}>refetch</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 1'))
expect(results.length).toBe(2)
expect(results[0]).toMatchObject([{ data: undefined }])
expect(results[1]).toMatchObject([{ data: 1 }])
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() => rendered.getByText('data: 2'))
// only one render for data update, no render for isFetching transition
expect(results.length).toBe(3)
expect(results[2]).toMatchObject([{ data: 2 }])
})
it('handles type parameter - tuple of tuples', async () => {
const key1 = queryKey()
const key2 = queryKey()
const key3 = queryKey()
// @ts-expect-error (Page component is not rendered)
// eslint-disable-next-line
function Page() {
const result1 = useQueries<
[[number], [string], [Array<string>, boolean]]
>({
queries: [
{
queryKey: key1,
queryFn: () => 1,
},
{
queryKey: key2,
queryFn: () => 'string',
},
{
queryKey: key3,
queryFn: () => ['string[]'],
},
],
})
expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
expectTypeOf<number | undefined>(result1[0].data)
expectTypeOf<string | undefined>(result1[1].data)
expectTypeOf<Array<string> | undefined>(result1[2].data)
expectTypeOf<boolean | null>(result1[2].error)
// TData (3rd element) takes precedence over TQueryFnData (1st element)
const result2 = useQueries<
[[string, unknown, string], [string, unknown, number]]
>({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return a.toLowerCase()
},
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return parseInt(a)
},
},
],
})
expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
expectTypeOf<string | undefined>(result2[0].data)
expectTypeOf<number | undefined>(result2[1].data)
// types should be enforced
useQueries<[[string, unknown, string], [string, boolean, number]]>({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return a.toLowerCase()
},
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return parseInt(a)
},
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
],
})
// field names should be enforced
useQueries<[[string]]>({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
// @ts-expect-error (invalidField)
someInvalidField: [],
},
],
})
}
})
it('handles type parameter - tuple of objects', async () => {
const key1 = queryKey()
const key2 = queryKey()
const key3 = queryKey()
// @ts-expect-error (Page component is not rendered)
// eslint-disable-next-line
function Page() {
const result1 = useQueries<
[
{ queryFnData: number },
{ queryFnData: string },
{ queryFnData: Array<string>; error: boolean },
]
>({
queries: [
{
queryKey: key1,
queryFn: () => 1,
},
{
queryKey: key2,
queryFn: () => 'string',
},
{
queryKey: key3,
queryFn: () => ['string[]'],
},
],
})
expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
expectTypeOf<number | undefined>(result1[0].data)
expectTypeOf<string | undefined>(result1[1].data)
expectTypeOf<Array<string> | undefined>(result1[2].data)
expectTypeOf<boolean | null>(result1[2].error)
// TData (data prop) takes precedence over TQueryFnData (queryFnData prop)
const result2 = useQueries<
[
{ queryFnData: string; data: string },
{ queryFnData: string; data: number },
]
>({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return a.toLowerCase()
},
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return parseInt(a)
},
},
],
})
expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
expectTypeOf<string | undefined>(result2[0].data)
expectTypeOf<number | undefined>(result2[1].data)
// can pass only TData (data prop) although TQueryFnData will be left unknown
const result3 = useQueries<[{ data: string }, { data: number }]>({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<unknown>(a)
expectTypeNotAny(a)
return a as string
},
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<unknown>(a)
expectTypeNotAny(a)
return a as number
},
},
],
})
expectTypeOf<QueryObserverResult<string, unknown>>(result3[0])
expectTypeOf<QueryObserverResult<number, unknown>>(result3[1])
expectTypeOf<string | undefined>(result3[0].data)
expectTypeOf<number | undefined>(result3[1].data)
// types should be enforced
useQueries<
[
{ queryFnData: string; data: string },
{ queryFnData: string; data: number; error: boolean },
]
>({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return a.toLowerCase()
},
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return parseInt(a)
},
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
],
})
// field names should be enforced
useQueries<[{ queryFnData: string }]>({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
// @ts-expect-error (invalidField)
someInvalidField: [],
},
],
})
}
})
it('handles array literal without type parameter to infer result type', async () => {
const key1 = queryKey()
const key2 = queryKey()
const key3 = queryKey()
const key4 = queryKey()
const key5 = queryKey()
type BizError = { code: number }
const throwOnError = (_error: BizError) => true
// @ts-expect-error (Page component is not rendered)
// eslint-disable-next-line
function Page() {
// Array.map preserves TQueryFnData
const result1 = useQueries({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
})),
})
expectTypeOf<Array<QueryObserverResult<number, unknown>>>(result1)
expectTypeOf<number | undefined>(result1[0]?.data)
// Array.map preserves TError
const result1_err = useQueries({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
throwOnError,
})),
})
expectTypeOf<Array<QueryObserverResult<number, unknown>>>(result1_err)
expectTypeOf<number | undefined>(result1_err[0]?.data)
expectTypeOf<BizError | null | undefined>(result1_err[0]?.error)
// Array.map preserves TData
const result2 = useQueries({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
select: (data: number) => data.toString(),
})),
})
expectTypeOf<Array<QueryObserverResult<string, unknown>>>(result2)
const result2_err = useQueries({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
select: (data: number) => data.toString(),
throwOnError,
})),
})
expectTypeOf<Array<QueryObserverResult<string, BizError>>>(result2_err)
const result3 = useQueries({
queries: [
{
queryKey: key1,
queryFn: () => 1,
},
{
queryKey: key2,
queryFn: () => 'string',
},
{
queryKey: key3,
queryFn: () => ['string[]'],
select: () => 123,
},
{
queryKey: key5,
queryFn: () => 'string',
throwOnError,
},
],
})
expectTypeOf<QueryObserverResult<number, unknown>>(result3[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result3[1])
expectTypeOf<QueryObserverResult<number, unknown>>(result3[2])
expectTypeOf<number | undefined>(result3[0].data)
expectTypeOf<string | undefined>(result3[1].data)
expectTypeOf<string | undefined>(result3[3].data)
// select takes precedence over queryFn
expectTypeOf<number | undefined>(result3[2].data)
// infer TError from throwOnError
expectTypeOf<BizError | null | undefined>(result3[3].error)
// initialData/placeholderData are enforced
useQueries({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
{
queryKey: key2,
queryFn: () => 123,
// @ts-expect-error (placeholderData: number)
placeholderData: 'string',
initialData: 123,
},
],
})
// select and throwOnError params are "indirectly" enforced
useQueries({
queries: [
// unfortunately TS will not suggest the type for you
{
queryKey: key1,
queryFn: () => 'string',
},
// however you can add a type to the callback
{
queryKey: key2,
queryFn: () => 'string',
},
// the type you do pass is enforced
{
queryKey: key3,
queryFn: () => 'string',
},
{
queryKey: key4,
queryFn: () => 'string',
select: (a: string) => parseInt(a),
},
{
queryKey: key5,
queryFn: () => 'string',
throwOnError,
},
],
})
// callbacks are also indirectly enforced with Array.map
useQueries({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
select: (data: number) => data.toString(),
})),
})
useQueries({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
select: (data: number) => data.toString(),
})),
})
// results inference works when all the handlers are defined
const result4 = useQueries({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
},
{
queryKey: key2,
queryFn: () => 'string',
},
{
queryKey: key4,
queryFn: () => 'string',
select: (a: string) => parseInt(a),
},
{
queryKey: key5,
queryFn: () => 'string',
select: (a: string) => parseInt(a),
throwOnError,
},
],
})
expectTypeOf<QueryObserverResult<string, unknown>>(result4[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result4[1])
expectTypeOf<QueryObserverResult<number, unknown>>(result4[2])
expectTypeOf<QueryObserverResult<number, BizError>>(result4[3])
// handles when queryFn returns a Promise
const result5 = useQueries({
queries: [
{
queryKey: key1,
queryFn: () => Promise.resolve('string'),
},
],
})
expectTypeOf<QueryObserverResult<string, unknown>>(result5[0])
// Array as const does not throw error
const result6 = useQueries({
queries: [
{
queryKey: ['key1'],
queryFn: () => 'string',
},
{
queryKey: ['key1'],
queryFn: () => 123,
},
{
queryKey: key5,
queryFn: () => 'string',
throwOnError,
},
],
} as const)
expectTypeOf<QueryObserverResult<string, unknown>>(result6[0])
expectTypeOf<QueryObserverResult<number, unknown>>(result6[1])
expectTypeOf<QueryObserverResult<string, BizError>>(result6[2])
// field names should be enforced - array literal
useQueries({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
// @ts-expect-error (invalidField)
someInvalidField: [],
},
],
})
// field names should be enforced - Array.map() result
useQueries({
// @ts-expect-error (invalidField)
queries: Array(10).map(() => ({
someInvalidField: '',
})),
})
// field names should be enforced - array literal
useQueries({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
// @ts-expect-error (invalidField)
someInvalidField: [],
},
],
})
// supports queryFn using fetch() to return Promise<any> - Array.map() result
useQueries({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () =>
fetch('return Promise<any>').then((resp) => resp.json()),
})),
})
// supports queryFn using fetch() to return Promise<any> - array literal
useQueries({
queries: [
{
queryKey: key1,
queryFn: () =>
fetch('return Promise<any>').then((resp) => resp.json()),
},
],
})
}
})
it('handles strongly typed queryFn factories and useQueries wrappers', () => {
// QueryKey + queryFn factory
type QueryKeyA = ['queryA']
const getQueryKeyA = (): QueryKeyA => ['queryA']
type GetQueryFunctionA = () => QueryFunction<number, QueryKeyA>
const getQueryFunctionA: GetQueryFunctionA = () => async () => {
return 1
}
type SelectorA = (data: number) => [number, string]
const getSelectorA = (): SelectorA => (data) => [data, data.toString()]
type QueryKeyB = ['queryB', string]
const getQueryKeyB = (id: string): QueryKeyB => ['queryB', id]
type GetQueryFunctionB = () => QueryFunction<string, QueryKeyB>
const getQueryFunctionB: GetQueryFunctionB = () => async () => {
return '1'
}
type SelectorB = (data: string) => [string, number]
const getSelectorB = (): SelectorB => (data) => [data, +data]
// Wrapper with strongly typed array-parameter
function useWrappedQueries<
TQueryFnData,
TError,
TData,
TQueryKey extends QueryKey,
>(queries: Array<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>>) {
return useQueries({
queries: queries.map(
// no need to type the mapped query
(query) => {
const { queryFn: fn, queryKey: key } = query
expectTypeOf<QueryFunction<TQueryFnData, TQueryKey> | undefined>(fn)
return {
queryKey: key,
queryFn: fn
? (ctx: QueryFunctionContext<TQueryKey>) => {
expectTypeOf<TQueryKey>(ctx.queryKey)
return fn.call({}, ctx)
}
: undefined,
}
},
),
})
}
// @ts-expect-error (Page component is not rendered)
// eslint-disable-next-line
function Page() {
const result = useQueries({
queries: [
{
queryKey: getQueryKeyA(),
queryFn: getQueryFunctionA(),
},
{
queryKey: getQueryKeyB('id'),
queryFn: getQueryFunctionB(),
},
],
})
expectTypeOf<QueryObserverResult<number, unknown>>(result[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result[1])
const withSelector = useQueries({
queries: [
{
queryKey: getQueryKeyA(),
queryFn: getQueryFunctionA(),
select: getSelectorA(),
},
{
queryKey: getQueryKeyB('id'),
queryFn: getQueryFunctionB(),
select: getSelectorB(),
},
],
})
expectTypeOf<QueryObserverResult<[number, string], unknown>>(
withSelector[0],
)
expectTypeOf<QueryObserverResult<[string, number], unknown>>(
withSelector[1],
)
const withWrappedQueries = useWrappedQueries(
Array(10).map(() => ({
queryKey: getQueryKeyA(),
queryFn: getQueryFunctionA(),
select: getSelectorA(),
})),
)
expectTypeOf<Array<QueryObserverResult<number | undefined, unknown>>>(
withWrappedQueries,
)
}
})
it("should throw error if in one of queries' queryFn throws and throwOnError is in use", async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key1 = queryKey()
const key2 = queryKey()
const key3 = queryKey()
const key4 = queryKey()
function Page() {
useQueries({
queries: [
{
queryKey: key1,
queryFn: () =>
Promise.reject(
new Error(
'this should not throw because throwOnError is not set',
),
),
},
{
queryKey: key2,
queryFn: () => Promise.reject(new Error('single query error')),
throwOnError: true,
retry: false,
},
{
queryKey: key3,
queryFn: async () => 2,
},
{
queryKey: key4,
queryFn: async () =>
Promise.reject(
new Error('this should not throw because query#2 already did'),
),
throwOnError: true,
retry: false,
},
],
})
return null
}
const rendered = renderWithClient(
queryClient,
<ErrorBoundary
fallbackRender={({ error }) => (
<div>
<div>error boundary</div>
<div>{error.message}</div>
</div>
)}
>
<Page />
</ErrorBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('single query error'))
consoleMock.mockRestore()
})
it("should throw error if in one of queries' queryFn throws and throwOnError function resolves to true", async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key1 = queryKey()
const key2 = queryKey()
const key3 = queryKey()
const key4 = queryKey()
function Page() {
useQueries({
queries: [
{
queryKey: key1,
queryFn: () =>
Promise.reject(
new Error(
'this should not throw because throwOnError function resolves to false',
),
),
throwOnError: () => false,
retry: false,
},
{
queryKey: key2,
queryFn: async () => 2,
},
{
queryKey: key3,
queryFn: () => Promise.reject(new Error('single query error')),
throwOnError: () => true,
retry: false,
},
{
queryKey: key4,
queryFn: async () =>
Promise.reject(
new Error('this should not throw because query#3 already did'),
),
throwOnError: true,
retry: false,
},
],
})
return null
}
const rendered = renderWithClient(
queryClient,
<ErrorBoundary
fallbackRender={({ error }) => (
<div>
<div>error boundary</div>
<div>{error.message}</div>
</div>
)}
>
<Page />
</ErrorBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('single query error'))
consoleMock.mockRestore()
})
it('should use provided custom queryClient', async () => {
const key = queryKey()
const queryFn = async () => {
return Promise.resolve('custom client')
}
function Page() {
const queries = useQueries(
{
queries: [
{
queryKey: key,
queryFn,
},
],
},
queryClient,
)
return <div>data: {queries[0].data}</div>
}
const rendered = render(<Page></Page>)
await waitFor(() => rendered.getByText('data: custom client'))
})
it('should combine queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
function Page() {
const queries = useQueries(
{
queries: [
{
queryKey: key1,
queryFn: () => Promise.resolve('first result'),
},
{
queryKey: key2,
queryFn: () => Promise.resolve('second result'),
},
],
combine: (results) => {
return {
combined: true,
res: results.map((res) => res.data).join(','),
}
},
},
queryClient,
)
return (
<div>
<div>
data: {String(queries.combined)} {queries.res}
</div>
</div>
)
}
const rendered = render(<Page />)
await waitFor(() =>
rendered.getByText('data: true first result,second result'),
)
})
it('should track property access through combine function', async () => {
const key1 = queryKey()
const key2 = queryKey()
let count = 0
const results: Array<unknown> = []
function Page() {
const queries = useQueries(
{
queries: [
{
queryKey: key1,
queryFn: async () => {
await sleep(5)
return Promise.resolve('first result ' + count)
},
},
{
queryKey: key2,
queryFn: async () => {
await sleep(50)
return Promise.resolve('second result ' + count)
},
},
],
combine: (queryResults) => {
return {
combined: true,
refetch: () => queryResults.forEach((res) => res.refetch()),
res: queryResults
.flatMap((res) => (res.data ? [res.data] : []))
.join(','),
}
},
},
queryClient,
)
results.push(queries)
return (
<div>
<div>
data: {String(queries.combined)} {queries.res}
</div>
<button onClick={() => queries.refetch()}>refetch</button>
</div>
)
}
const rendered = render(<Page />)
await waitFor(() =>
rendered.getByText('data: true first result 0,second result 0'),
)
expect(results.length).toBe(3)
expect(results[0]).toStrictEqual({
combined: true,
refetch: expect.any(Function),
res: '',
})
expect(results[1]).toStrictEqual({
combined: true,
refetch: expect.any(Function),
res: 'first result 0',
})
expect(results[2]).toStrictEqual({
combined: true,
refetch: expect.any(Function),
res: 'first result 0,second result 0',
})
count++
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() =>
rendered.getByText('data: true first result 1,second result 1'),
)
expect(results.length).toBe(5)
expect(results[3]).toStrictEqual({
combined: true,
refetch: expect.any(Function),
res: 'first result 1,second result 0',
})
expect(results[4]).toStrictEqual({
combined: true,
refetch: expect.any(Function),
res: 'first result 1,second result 1',
})
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await sleep(100)
// no further re-render because data didn't change
expect(results.length).toBe(5)
})
})
|
3,996 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/useQuery.test.tsx | import { describe, expect, expectTypeOf, it, test, vi } from 'vitest'
import { act, fireEvent, render, waitFor } from '@testing-library/react'
import * as React from 'react'
import { ErrorBoundary } from 'react-error-boundary'
import { QueryCache, keepPreviousData, useQuery } from '..'
import {
Blink,
createQueryClient,
mockOnlineManagerIsOnline,
mockVisibilityState,
queryKey,
renderWithClient,
setActTimeout,
sleep,
} from './utils'
import type {
DefinedUseQueryResult,
QueryFunction,
UseQueryOptions,
UseQueryResult,
} from '..'
import type { Mock } from 'vitest'
describe('useQuery', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should return the correct types', () => {
const key = queryKey()
// @ts-ignore
// eslint-disable-next-line
function Page() {
// unspecified query function should default to unknown
const noQueryFn = useQuery({ queryKey: key })
expectTypeOf<unknown>(noQueryFn.data)
expectTypeOf<unknown>(noQueryFn.error)
// it should infer the result type from the query function
const fromQueryFn = useQuery({ queryKey: key, queryFn: () => 'test' })
expectTypeOf<string | undefined>(fromQueryFn.data)
expectTypeOf<unknown>(fromQueryFn.error)
// it should be possible to specify the result type
const withResult = useQuery<string>({
queryKey: key,
queryFn: () => 'test',
})
expectTypeOf<string | undefined>(withResult.data)
expectTypeOf<unknown | null>(withResult.error)
// it should be possible to specify the error type
const withError = useQuery<string, Error>({
queryKey: key,
queryFn: () => 'test',
})
expectTypeOf<string | undefined>(withError.data)
expectTypeOf<Error | null>(withError.error)
// it should provide the result type in the configuration
useQuery({
queryKey: [key],
queryFn: async () => true,
})
// it should be possible to specify a union type as result type
const unionTypeSync = useQuery({
queryKey: key,
queryFn: () => (Math.random() > 0.5 ? 'a' : 'b'),
})
expectTypeOf<'a' | 'b' | undefined>(unionTypeSync.data)
const unionTypeAsync = useQuery<'a' | 'b'>({
queryKey: key,
queryFn: () => Promise.resolve(Math.random() > 0.5 ? 'a' : 'b'),
})
expectTypeOf<'a' | 'b' | undefined>(unionTypeAsync.data)
// should error when the query function result does not match with the specified type
// @ts-expect-error
useQuery<number>({ queryKey: key, queryFn: () => 'test' })
// it should infer the result type from a generic query function
function queryFn<T = string>(): Promise<T> {
return Promise.resolve({} as T)
}
const fromGenericQueryFn = useQuery({
queryKey: key,
queryFn: () => queryFn(),
})
expectTypeOf<string | undefined>(fromGenericQueryFn.data)
expectTypeOf<unknown>(fromGenericQueryFn.error)
const fromGenericOptionsQueryFn = useQuery({
queryKey: key,
queryFn: () => queryFn(),
})
expectTypeOf<string | undefined>(fromGenericOptionsQueryFn.data)
expectTypeOf<unknown>(fromGenericOptionsQueryFn.error)
type MyData = number
type MyQueryKey = readonly ['my-data', number]
const getMyDataArrayKey: QueryFunction<MyData, MyQueryKey> = async ({
queryKey: [, n],
}) => {
return n + 42
}
useQuery({
queryKey: ['my-data', 100],
queryFn: getMyDataArrayKey,
})
const getMyDataStringKey: QueryFunction<MyData, ['1']> = async (
context,
) => {
expectTypeOf<['1']>(context.queryKey)
return Number(context.queryKey[0]) + 42
}
useQuery({
queryKey: ['1'],
queryFn: getMyDataStringKey,
})
// it should handle query-functions that return Promise<any>
useQuery({
queryKey: key,
queryFn: () => fetch('return Promise<any>').then((resp) => resp.json()),
})
// handles wrapped queries with custom fetcher passed as inline queryFn
const useWrappedQuery = <
TQueryKey extends [string, Record<string, unknown>?],
TQueryFnData,
TError,
TData = TQueryFnData,
>(
qk: TQueryKey,
fetcher: (
obj: TQueryKey[1],
token: string,
// return type must be wrapped with TQueryFnReturn
) => Promise<TQueryFnData>,
options?: Omit<
UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
'queryKey' | 'queryFn' | 'initialData'
>,
) =>
useQuery({
queryKey: qk,
queryFn: () => fetcher(qk[1], 'token'),
...options,
})
const testQuery = useWrappedQuery([''], async () => '1')
expectTypeOf<string | undefined>(testQuery.data)
// handles wrapped queries with custom fetcher passed directly to useQuery
const useWrappedFuncStyleQuery = <
TQueryKey extends [string, Record<string, unknown>?],
TQueryFnData,
TError,
TData = TQueryFnData,
>(
qk: TQueryKey,
fetcher: () => Promise<TQueryFnData>,
options?: Omit<
UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
'queryKey' | 'queryFn' | 'initialData'
>,
) => useQuery({ queryKey: qk, queryFn: fetcher, ...options })
const testFuncStyle = useWrappedFuncStyleQuery([''], async () => true)
expectTypeOf<boolean | undefined>(testFuncStyle.data)
}
})
// See https://github.com/tannerlinsley/react-query/issues/105
it('should allow to set default data value', async () => {
const key = queryKey()
function Page() {
const { data = 'default' } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
rendered.getByText('default')
await waitFor(() => rendered.getByText('test'))
})
it('should return the correct states for a successful query', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery<string, Error>({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
})
states.push(state)
if (state.isPending) {
expectTypeOf<undefined>(state.data)
expectTypeOf<null>(state.error)
return <span>pending</span>
}
if (state.isLoadingError) {
expectTypeOf<undefined>(state.data)
expectTypeOf<Error>(state.error)
return <span>{state.error.message}</span>
}
expectTypeOf<string>(state.data)
expectTypeOf<Error | null>(state.error)
return <span>{state.data}</span>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('test'))
expect(states.length).toEqual(2)
expect(states[0]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
isError: false,
isFetched: false,
isFetchedAfterMount: false,
isFetching: true,
isPaused: false,
isPending: true,
isInitialLoading: true,
isLoading: true,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'pending',
fetchStatus: 'fetching',
})
expect(states[1]).toEqual({
data: 'test',
dataUpdatedAt: expect.any(Number),
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
isError: false,
isFetched: true,
isFetchedAfterMount: true,
isFetching: false,
isPaused: false,
isPending: false,
isInitialLoading: false,
isLoading: false,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: true,
refetch: expect.any(Function),
status: 'success',
fetchStatus: 'idle',
})
})
it('should return the correct states for an unsuccessful query', async () => {
const key = queryKey()
const states: Array<UseQueryResult> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => Promise.reject(new Error('rejected')),
retry: 1,
retryDelay: 1,
})
states.push(state)
return (
<div>
<h1>Status: {state.status}</h1>
<div>Failure Count: {state.failureCount}</div>
<div>Failure Reason: {state.failureReason?.message}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Status: error'))
expect(states[0]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
isError: false,
isFetched: false,
isFetchedAfterMount: false,
isFetching: true,
isPaused: false,
isPending: true,
isInitialLoading: true,
isLoading: true,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'pending',
fetchStatus: 'fetching',
})
expect(states[1]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: null,
errorUpdatedAt: 0,
failureCount: 1,
failureReason: new Error('rejected'),
errorUpdateCount: 0,
isError: false,
isFetched: false,
isFetchedAfterMount: false,
isFetching: true,
isPaused: false,
isPending: true,
isInitialLoading: true,
isLoading: true,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'pending',
fetchStatus: 'fetching',
})
expect(states[2]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: new Error('rejected'),
errorUpdatedAt: expect.any(Number),
failureCount: 2,
failureReason: new Error('rejected'),
errorUpdateCount: 1,
isError: true,
isFetched: true,
isFetchedAfterMount: true,
isFetching: false,
isPaused: false,
isPending: false,
isInitialLoading: false,
isLoading: false,
isLoadingError: true,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'error',
fetchStatus: 'idle',
})
})
it('should set isFetchedAfterMount to true after a query has been fetched', async () => {
const key = queryKey()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => 'prefetched',
})
function Page() {
const result = useQuery({ queryKey: key, queryFn: () => 'new data' })
return (
<>
<div>data: {result.data}</div>
<div>isFetched: {result.isFetched ? 'true' : 'false'}</div>
<div>
isFetchedAfterMount: {result.isFetchedAfterMount ? 'true' : 'false'}
</div>
</>
)
}
const rendered = renderWithClient(queryClient, <Page />)
rendered.getByText('data: prefetched')
rendered.getByText('isFetched: true')
rendered.getByText('isFetchedAfterMount: false')
await waitFor(() => {
rendered.getByText('data: new data')
rendered.getByText('isFetched: true')
rendered.getByText('isFetchedAfterMount: true')
})
})
it('should not cancel an ongoing fetch when refetch is called with cancelRefetch=false if we have data already', async () => {
const key = queryKey()
let fetchCount = 0
function Page() {
const { refetch } = useQuery({
queryKey: key,
queryFn: async () => {
fetchCount++
await sleep(10)
return 'data'
},
enabled: false,
initialData: 'initialData',
})
React.useEffect(() => {
setActTimeout(() => {
refetch()
}, 5)
setActTimeout(() => {
refetch({ cancelRefetch: false })
}, 5)
}, [refetch])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(20)
// first refetch only, second refetch is ignored
expect(fetchCount).toBe(1)
})
it('should cancel an ongoing fetch when refetch is called (cancelRefetch=true) if we have data already', async () => {
const key = queryKey()
let fetchCount = 0
function Page() {
const { refetch } = useQuery({
queryKey: key,
queryFn: async () => {
fetchCount++
await sleep(10)
return 'data'
},
enabled: false,
initialData: 'initialData',
})
React.useEffect(() => {
setActTimeout(() => {
refetch()
}, 5)
setActTimeout(() => {
refetch()
}, 5)
}, [refetch])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(20)
// first refetch (gets cancelled) and second refetch
expect(fetchCount).toBe(2)
})
it('should not cancel an ongoing fetch when refetch is called (cancelRefetch=true) if we do not have data yet', async () => {
const key = queryKey()
let fetchCount = 0
function Page() {
const { refetch } = useQuery({
queryKey: key,
queryFn: async () => {
fetchCount++
await sleep(10)
return 'data'
},
enabled: false,
})
React.useEffect(() => {
setActTimeout(() => {
refetch()
}, 5)
setActTimeout(() => {
refetch()
}, 5)
}, [refetch])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(20)
// first refetch will not get cancelled, second one gets skipped
expect(fetchCount).toBe(1)
})
it('should be able to watch a query without providing a query function', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
queryClient.setQueryDefaults(key, { queryFn: () => 'data' })
function Page() {
const state = useQuery<string>({ queryKey: key })
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'data' })
})
it('should pick up a query when re-mounting with gcTime 0', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const [toggle, setToggle] = React.useState(false)
return (
<div>
<button onClick={() => setToggle(true)}>toggle</button>
{toggle ? (
<Component key="2" value="2" />
) : (
<Component key="1" value="1" />
)}
</div>
)
}
function Component({ value }: { value: string }) {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'data: ' + value
},
gcTime: 0,
notifyOnChangeProps: 'all',
})
states.push(state)
return (
<div>
<div>{state.data}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('data: 1')
fireEvent.click(rendered.getByRole('button', { name: /toggle/i }))
await rendered.findByText('data: 2')
expect(states.length).toBe(4)
// First load
expect(states[0]).toMatchObject({
isPending: true,
isSuccess: false,
isFetching: true,
})
// First success
expect(states[1]).toMatchObject({
isPending: false,
isSuccess: true,
isFetching: false,
})
// Switch, goes to fetching
expect(states[2]).toMatchObject({
isPending: false,
isSuccess: true,
isFetching: true,
})
// Second success
expect(states[3]).toMatchObject({
isPending: false,
isSuccess: true,
isFetching: false,
})
})
it('should not get into an infinite loop when removing a query with gcTime 0 and rerendering', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const [, rerender] = React.useState({})
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(5)
return 'data'
},
gcTime: 0,
notifyOnChangeProps: 'all',
})
states.push(state)
return (
<>
<div>{state.data}</div>
<button
onClick={() => {
queryClient.removeQueries({ queryKey: key })
rerender({})
}}
>
remove
</button>
</>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('data')
})
fireEvent.click(rendered.getByRole('button', { name: 'remove' }))
await waitFor(() => {
rendered.getByText('data')
})
// required to make sure no additional renders are happening after data is successfully fetched for the second time
await sleep(100)
expect(states.length).toBe(4)
// First load
expect(states[0]).toMatchObject({ isPending: true, isSuccess: false })
// First success
expect(states[1]).toMatchObject({ isPending: false, isSuccess: true })
// Remove
expect(states[2]).toMatchObject({ isPending: true, isSuccess: false })
// Second success
expect(states[3]).toMatchObject({ isPending: false, isSuccess: true })
})
it('should fetch when refetchOnMount is false and nothing has been fetched yet', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'test',
refetchOnMount: false,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should not fetch when refetchOnMount is false and data has been fetched already', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
queryClient.setQueryData(key, 'prefetched')
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'test',
refetchOnMount: false,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
expect(states.length).toBe(1)
expect(states[0]).toMatchObject({ data: 'prefetched' })
})
it('should be able to select a part of the data with select', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => ({ name: 'test' }),
select: (data) => data.name,
})
states.push(state)
return <div>{state.data}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('test')
})
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should be able to select a part of the data with select in object syntax', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => ({ name: 'test' }),
select: (data) => data.name,
})
states.push(state)
return <div>{state.data}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('test')
})
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should throw an error when a selector throws', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
const error = new Error('Select Error')
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => ({ name: 'test' }),
select: () => {
throw error
},
})
states.push(state)
return <div>{state.status}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('error')
})
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ status: 'pending', data: undefined })
expect(states[1]).toMatchObject({ status: 'error', error })
})
it('should not re-run a stable select when it re-renders if selector throws an error', async () => {
const key = queryKey()
const error = new Error('Select Error')
let runs = 0
function Page() {
const [, rerender] = React.useReducer(() => ({}), {})
const state = useQuery<string, Error>({
queryKey: key,
queryFn: () => (runs === 0 ? 'test' : 'test2'),
select: React.useCallback(() => {
runs++
throw error
}, []),
})
return (
<div>
<div>error: {state.error?.message}</div>
<button onClick={rerender}>rerender</button>
<button onClick={() => state.refetch()}>refetch</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('error: Select Error'))
expect(runs).toEqual(1)
fireEvent.click(rendered.getByRole('button', { name: 'rerender' }))
await sleep(10)
expect(runs).toEqual(1)
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
await sleep(10)
expect(runs).toEqual(2)
})
it('should track properties and only re-render when a tracked property changes', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
})
states.push(state)
const { refetch, data } = state
React.useEffect(() => {
setActTimeout(() => {
if (data) {
refetch()
}
}, 20)
}, [refetch, data])
return (
<div>
<h1>{data ?? null}</h1>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('test'))
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should always re-render if we are tracking props but not using any', async () => {
const key = queryKey()
let renderCount = 0
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({ queryKey: key, queryFn: () => 'test' })
states.push(state)
React.useEffect(() => {
renderCount++
}, [state])
return (
<div>
<h1>hello</h1>
</div>
)
}
renderWithClient(queryClient, <Page />)
await waitFor(() => {
expect(renderCount).toBe(2)
})
// give it a bit more time to make sure no additional renders are triggered
await sleep(20)
expect(renderCount).toBe(2)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should be able to remove a query', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const [, rerender] = React.useState({})
const state = useQuery({
queryKey: key,
queryFn: () => ++count,
notifyOnChangeProps: 'all',
})
states.push(state)
return (
<div>
<button onClick={() => queryClient.removeQueries({ queryKey: key })}>
remove
</button>
<button onClick={() => rerender({})}>rerender</button>
data: {state.data ?? 'null'}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 1'))
fireEvent.click(rendered.getByRole('button', { name: /remove/i }))
await sleep(20)
fireEvent.click(rendered.getByRole('button', { name: /rerender/i }))
await waitFor(() => rendered.getByText('data: 2'))
expect(states.length).toBe(4)
// Initial
expect(states[0]).toMatchObject({ status: 'pending', data: undefined })
// Fetched
expect(states[1]).toMatchObject({ status: 'success', data: 1 })
// Remove + Hook state update, batched
expect(states[2]).toMatchObject({ status: 'pending', data: undefined })
// Fetched
expect(states[3]).toMatchObject({ status: 'success', data: 2 })
})
it('should create a new query when refetching a removed query', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return ++count
},
notifyOnChangeProps: 'all',
})
states.push(state)
const { refetch } = state
return (
<div>
<button onClick={() => queryClient.removeQueries({ queryKey: key })}>
remove
</button>
<button onClick={() => refetch()}>refetch</button>
data: {state.data ?? 'null'}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 1'))
fireEvent.click(rendered.getByRole('button', { name: /remove/i }))
await sleep(50)
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() => rendered.getByText('data: 2'))
expect(states.length).toBe(4)
// Initial
expect(states[0]).toMatchObject({ data: undefined, dataUpdatedAt: 0 })
// Fetched
expect(states[1]).toMatchObject({ data: 1 })
// Switch
expect(states[2]).toMatchObject({ data: undefined, dataUpdatedAt: 0 })
// Fetched
expect(states[3]).toMatchObject({ data: 2 })
})
it('should share equal data structures between query results', async () => {
const key = queryKey()
const result1 = [
{ id: '1', done: false },
{ id: '2', done: false },
]
const result2 = [
{ id: '1', done: false },
{ id: '2', done: true },
]
const states: Array<UseQueryResult<typeof result1>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count === 1 ? result1 : result2
},
notifyOnChangeProps: 'all',
})
states.push(state)
const { refetch } = state
return (
<div>
<button onClick={() => refetch()}>refetch</button>
data: {String(state.data?.[1]?.done)}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: false'))
await sleep(20)
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() => rendered.getByText('data: true'))
await waitFor(() => expect(states.length).toBe(4))
const todos = states[2]?.data
const todo1 = todos?.[0]
const todo2 = todos?.[1]
const newTodos = states[3]?.data
const newTodo1 = newTodos?.[0]
const newTodo2 = newTodos?.[1]
expect(todos).toEqual(result1)
expect(newTodos).toEqual(result2)
expect(newTodos).not.toBe(todos)
expect(newTodo1).toBe(todo1)
expect(newTodo2).not.toBe(todo2)
return null
})
it('should use query function from hook when the existing query does not have a query function', async () => {
const key = queryKey()
const results: Array<DefinedUseQueryResult<string>> = []
queryClient.setQueryData(key, 'set')
function Page() {
const result = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
initialData: 'initial',
staleTime: Infinity,
})
results.push(result)
return (
<div>
<div>isFetching: {result.isFetching}</div>
<button onClick={() => queryClient.refetchQueries({ queryKey: key })}>
refetch
</button>
data: {result.data}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: set'))
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() => rendered.getByText('data: fetched'))
await waitFor(() => expect(results.length).toBe(3))
expect(results[0]).toMatchObject({ data: 'set', isFetching: false })
expect(results[1]).toMatchObject({ data: 'set', isFetching: true })
expect(results[2]).toMatchObject({ data: 'fetched', isFetching: false })
})
it('should update query stale state and refetch when invalidated with invalidateQueries', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
staleTime: Infinity,
})
return (
<div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
data: {state.data}, isStale: {String(state.isStale)}, isFetching:{' '}
{String(state.isFetching)}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() =>
rendered.getByText('data: 1, isStale: false, isFetching: false'),
)
fireEvent.click(rendered.getByRole('button', { name: /invalidate/i }))
await waitFor(() =>
rendered.getByText('data: 1, isStale: true, isFetching: true'),
)
await waitFor(() =>
rendered.getByText('data: 2, isStale: false, isFetching: false'),
)
})
it('should not update disabled query when refetched with refetchQueries', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
enabled: false,
})
states.push(state)
React.useEffect(() => {
setActTimeout(() => {
queryClient.refetchQueries({ queryKey: key })
}, 20)
}, [])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(50)
expect(states.length).toBe(1)
expect(states[0]).toMatchObject({
data: undefined,
isFetching: false,
isSuccess: false,
isStale: true,
})
})
it('should not refetch disabled query when invalidated with invalidateQueries', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
enabled: false,
})
states.push(state)
React.useEffect(() => {
setActTimeout(() => {
queryClient.invalidateQueries({ queryKey: key })
}, 20)
}, [])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(1)
expect(states[0]).toMatchObject({
data: undefined,
isFetching: false,
isSuccess: false,
isStale: true,
})
})
it('should not fetch when switching to a disabled query', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
queryKey: [key, count],
queryFn: async () => {
await sleep(5)
return count
},
enabled: count === 0,
})
states.push(state)
return (
<div>
<button onClick={() => setCount(1)}>increment</button>
<div>data: {state.data ?? 'undefined'}</div>
<div>count: {count}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 0'))
fireEvent.click(rendered.getByRole('button', { name: /increment/i }))
await waitFor(() => {
rendered.getByText('count: 1')
rendered.getByText('data: undefined')
})
// making sure no additional fetches are triggered
await sleep(50)
expect(states.length).toBe(3)
// Fetch query
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isSuccess: false,
})
// Fetched query
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
})
// Switch to disabled query
expect(states[2]).toMatchObject({
data: undefined,
isFetching: false,
isSuccess: false,
})
})
it('should keep the previous data when placeholderData is set', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
queryKey: [key, count],
queryFn: async () => {
await sleep(10)
return count
},
placeholderData: keepPreviousData,
})
states.push(state)
return (
<div>
<div>data: {state.data}</div>
<button onClick={() => setCount(1)}>setCount</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 0'))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
await waitFor(() => rendered.getByText('data: 1'))
// Initial
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isSuccess: false,
isPlaceholderData: false,
})
// Fetched
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[2]).toMatchObject({
data: 0,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// New data
expect(states[3]).toMatchObject({
data: 1,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should keep the previous data when placeholderData is set and select fn transform is used', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
queryKey: [key, count],
queryFn: async () => {
await sleep(10)
return {
count,
}
},
select(data) {
return data.count
},
placeholderData: keepPreviousData,
})
states.push(state)
return (
<div>
<div>data: {state.data}</div>
<button onClick={() => setCount(1)}>setCount</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 0'))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
await waitFor(() => rendered.getByText('data: 1'))
// Initial
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isSuccess: false,
isPlaceholderData: false,
})
// Fetched
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[2]).toMatchObject({
data: 0,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// New data
expect(states[3]).toMatchObject({
data: 1,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should keep the previous queryKey (from prevQuery) between multiple pending queries when placeholderData is set and select fn transform is used', async () => {
const keys: Array<ReadonlyArray<unknown> | null> = []
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
queryKey: [key, count],
queryFn: async () => {
await sleep(10)
return {
count,
}
},
select(data) {
return data.count
},
placeholderData: (prevData, prevQuery) => {
if (prevQuery) {
keys.push(prevQuery.queryKey)
}
return prevData
},
})
states.push(state)
return (
<div>
<div>data: {state.data}</div>
<button onClick={() => setCount((prev) => prev + 1)}>setCount</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 0'))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
await waitFor(() => rendered.getByText('data: 3'))
const allPreviousKeysAreTheFirstQueryKey = keys.every(
(k) => JSON.stringify(k) === JSON.stringify([key, 0]),
)
expect(allPreviousKeysAreTheFirstQueryKey).toBe(true)
})
it('should show placeholderData between multiple pending queries when select fn transform is used', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
queryKey: [key, count],
queryFn: async () => {
await sleep(10)
return {
count,
}
},
select(data) {
return data.count
},
placeholderData: keepPreviousData,
})
states.push(state)
return (
<div>
<div>data: {state.data}</div>
<button onClick={() => setCount((prev) => prev + 1)}>setCount</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 0'))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
await waitFor(() => rendered.getByText('data: 3'))
// Initial
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isSuccess: false,
isPlaceholderData: false,
})
// Fetched
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state -> count = 1
expect(states[2]).toMatchObject({
data: 0,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// Set state -> count = 2
expect(states[3]).toMatchObject({
data: 0,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// Set state -> count = 3
expect(states[4]).toMatchObject({
data: 0,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// New data
expect(states[5]).toMatchObject({
data: 3,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should transition to error state when placeholderData is set', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
function Page({ count }: { count: number }) {
const state = useQuery<number, Error>({
queryKey: [key, count],
queryFn: async () => {
await sleep(10)
if (count === 2) {
throw new Error('Error test')
}
return Promise.resolve(count)
},
retry: false,
placeholderData: keepPreviousData,
})
states.push(state)
return (
<div>
<h1>data: {state.data}</h1>
<h2>error: {state.error?.message}</h2>
<p>placeholder data: {state.isPlaceholderData}</p>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page count={0} />)
await waitFor(() => rendered.getByText('data: 0'))
act(() => rendered.rerender(<Page count={1} />))
await waitFor(() => rendered.getByText('data: 1'))
act(() => rendered.rerender(<Page count={2} />))
await waitFor(() => rendered.getByText('error: Error test'))
await waitFor(() => expect(states.length).toBe(6))
// Initial
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
status: 'pending',
error: null,
isPlaceholderData: false,
})
// Fetched
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
status: 'success',
error: null,
isPlaceholderData: false,
})
// rerender Page 1
expect(states[2]).toMatchObject({
data: 0,
isFetching: true,
status: 'success',
error: null,
isPlaceholderData: true,
})
// New data
expect(states[3]).toMatchObject({
data: 1,
isFetching: false,
status: 'success',
error: null,
isPlaceholderData: false,
})
// rerender Page 2
expect(states[4]).toMatchObject({
data: 1,
isFetching: true,
status: 'success',
error: null,
isPlaceholderData: true,
})
// Error
expect(states[5]).toMatchObject({
data: undefined,
isFetching: false,
status: 'error',
isPlaceholderData: false,
})
expect(states[5]!.error).toHaveProperty('message', 'Error test')
})
it('should not show initial data from next query if placeholderData is set', async () => {
const key = queryKey()
const states: Array<DefinedUseQueryResult<number>> = []
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
queryKey: [key, count],
queryFn: async () => {
await sleep(10)
return count
},
initialData: 99,
placeholderData: keepPreviousData,
})
states.push(state)
return (
<div>
<h1>
data: {state.data}, count: {count}, isFetching:{' '}
{String(state.isFetching)}
</h1>
<button onClick={() => setCount(1)}>inc</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() =>
rendered.getByText('data: 0, count: 0, isFetching: false'),
)
fireEvent.click(rendered.getByRole('button', { name: 'inc' }))
await waitFor(() =>
rendered.getByText('data: 1, count: 1, isFetching: false'),
)
expect(states.length).toBe(4)
// Initial
expect(states[0]).toMatchObject({
data: 99,
isFetching: true,
isSuccess: true,
isPlaceholderData: false,
})
// Fetched
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[2]).toMatchObject({
data: 99,
isFetching: true,
isSuccess: true,
isPlaceholderData: false,
})
// New data
expect(states[3]).toMatchObject({
data: 1,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should keep the previous data on disabled query when placeholderData is set', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
queryKey: [key, count],
queryFn: async () => {
await sleep(10)
return count
},
enabled: false,
placeholderData: keepPreviousData,
notifyOnChangeProps: 'all',
})
states.push(state)
return (
<div>
<button onClick={() => state.refetch()}>refetch</button>
<button onClick={() => setCount(1)}>setCount</button>
<div>data: {state.data ?? 'undefined'}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('data: undefined')
})
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
await waitFor(() => {
rendered.getByText('data: 0')
})
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
await waitFor(() => {
rendered.getByText('data: 0')
})
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
await waitFor(() => {
rendered.getByText('data: 1')
})
// making sure no additional renders are triggered
await sleep(20)
expect(states.length).toBe(6)
// Disabled query
expect(states[0]).toMatchObject({
data: undefined,
isFetching: false,
isSuccess: false,
isPlaceholderData: false,
})
// Fetching query
expect(states[1]).toMatchObject({
data: undefined,
isFetching: true,
isSuccess: false,
isPlaceholderData: false,
})
// Fetched query
expect(states[2]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[3]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: true,
})
// Fetching new query
expect(states[4]).toMatchObject({
data: 0,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// Fetched new query
expect(states[5]).toMatchObject({
data: 1,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should keep the previous data on disabled query when placeholderData is set and switching query key multiple times', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
queryClient.setQueryData([key, 10], 10)
await sleep(10)
function Page() {
const [count, setCount] = React.useState(10)
const state = useQuery({
queryKey: [key, count],
queryFn: async () => {
await sleep(10)
return count
},
enabled: false,
placeholderData: keepPreviousData,
notifyOnChangeProps: 'all',
})
states.push(state)
const { refetch } = state
React.useEffect(() => {
setActTimeout(() => {
setCount(11)
}, 20)
setActTimeout(() => {
setCount(12)
}, 30)
setActTimeout(() => {
refetch()
}, 40)
}, [refetch])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(5)
// Disabled query
expect(states[0]).toMatchObject({
data: 10,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[1]).toMatchObject({
data: 10,
isFetching: false,
isSuccess: true,
isPlaceholderData: true,
})
// State update
expect(states[2]).toMatchObject({
data: 10,
isFetching: false,
isSuccess: true,
isPlaceholderData: true,
})
// Refetch
expect(states[3]).toMatchObject({
data: 10,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// Refetch done
expect(states[4]).toMatchObject({
data: 12,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should use the correct query function when components use different configurations', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
function FirstComponent() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 1
},
notifyOnChangeProps: 'all',
})
const refetch = state.refetch
states.push(state)
return (
<div>
<button onClick={() => refetch()}>refetch</button>
data: {state.data}
</div>
)
}
function SecondComponent() {
useQuery({ queryKey: key, queryFn: () => 2, notifyOnChangeProps: 'all' })
return null
}
function Page() {
return (
<>
<FirstComponent />
<SecondComponent />
</>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 1'))
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() => expect(states.length).toBe(4))
expect(states[0]).toMatchObject({
data: undefined,
})
expect(states[1]).toMatchObject({
data: 1,
})
expect(states[2]).toMatchObject({
data: 1,
})
// This state should be 1 instead of 2
expect(states[3]).toMatchObject({
data: 1,
})
})
it('should be able to set different stale times for a query', async () => {
const key = queryKey()
const states1: Array<UseQueryResult<string>> = []
const states2: Array<UseQueryResult<string>> = []
await queryClient.prefetchQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'prefetch'
},
})
await sleep(20)
function FirstComponent() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'one'
},
staleTime: 100,
})
states1.push(state)
return null
}
function SecondComponent() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'two'
},
staleTime: 10,
})
states2.push(state)
return null
}
function Page() {
return (
<>
<FirstComponent />
<SecondComponent />
</>
)
}
renderWithClient(queryClient, <Page />)
await sleep(200)
expect(states1.length).toBe(4)
expect(states2.length).toBe(3)
expect(states1).toMatchObject([
// First render
{
data: 'prefetch',
isStale: false,
},
// Second useQuery started fetching
{
data: 'prefetch',
isStale: false,
},
// Second useQuery data came in
{
data: 'two',
isStale: false,
},
// Data became stale after 100ms
{
data: 'two',
isStale: true,
},
])
expect(states2).toMatchObject([
// First render, data is stale and starts fetching
{
data: 'prefetch',
isStale: true,
},
// Second useQuery data came in
{
data: 'two',
isStale: false,
},
// Data became stale after 5ms
{
data: 'two',
isStale: true,
},
])
})
it('should re-render when a query becomes stale', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'test',
staleTime: 50,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(3)
expect(states[0]).toMatchObject({ isStale: true })
expect(states[1]).toMatchObject({ isStale: false })
expect(states[2]).toMatchObject({ isStale: true })
})
describe('notifyOnChangeProps', () => {
it('should not re-render when it should only re-render only data change and the selected data did not change', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => ({ name: 'test' }),
select: (data) => data.name,
notifyOnChangeProps: ['data'],
})
states.push(state)
return (
<div>
<div>{state.data}</div>
<button onClick={() => state.refetch()}>refetch</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('test')
})
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
await waitFor(() => {
rendered.getByText('test')
})
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
// make sure no additional renders happen
await sleep(50)
expect(states.length).toBe(2)
})
it('should not re-render when it should only re-render on data changes and the data did not change', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(5)
return 'test'
},
notifyOnChangeProps: ['data'],
})
states.push(state)
return (
<>
<button
onClick={async () => {
await state.refetch()
}}
>
refetch
</button>
<div>{state.data}</div>
</>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('test')
})
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
// sleep is required to make sure no additional renders happen after click
await sleep(20)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
status: 'pending',
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'test',
status: 'success',
isFetching: false,
})
})
// See https://github.com/TanStack/query/discussions/5588
describe('function', () => {
it('should not re-render when it should only re-render on data changes and the data did not change', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(5)
return 'test'
},
notifyOnChangeProps: () => ['data'],
})
states.push(state)
return (
<>
<button
onClick={async () => {
await state.refetch()
}}
>
refetch
</button>
<div>{state.data}</div>
</>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('test')
})
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
// sleep is required to make sure no additional renders happen after click
await sleep(20)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
status: 'pending',
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'test',
status: 'success',
isFetching: false,
})
})
it('should not re-render when change props are not actively being tracked', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const fetchCounterRef = React.useRef(0)
const trackChangesRef = React.useRef(true)
const notifyOnChangeProps = React.useCallback(() => {
return trackChangesRef.current ? 'all' : []
}, [])
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(5)
fetchCounterRef.current++
return `fetch counter: ${fetchCounterRef.current}`
},
notifyOnChangeProps,
})
states.push(state)
return (
<>
<button
onClick={async () => {
await state.refetch()
}}
>
refetch
</button>
<button
onClick={() => {
trackChangesRef.current = true
}}
>
enableTracking
</button>
<button
onClick={() => {
trackChangesRef.current = false
}}
>
disableTracking
</button>
<div>{state.data}</div>
</>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('fetch counter: 1')
})
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
status: 'pending',
})
expect(states[1]).toMatchObject({
data: 'fetch counter: 1',
status: 'success',
isFetching: false,
})
// disable tracking and refetch to check for re-renders
fireEvent.click(
rendered.getByRole('button', { name: 'disableTracking' }),
)
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
// sleep is required to make sure no additional renders happen after click
await sleep(20)
// still expect to only have two re-renders from the initial fetch
expect(states.length).toBe(2)
// enable tracking and refetch to check for re-renders
fireEvent.click(
rendered.getByRole('button', { name: 'enableTracking' }),
)
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
await waitFor(() => {
rendered.getByText('fetch counter: 3')
})
// sleep is required to make sure no additional renders happen after click
await sleep(20)
expect(states.length).toBe(4)
expect(states[2]).toMatchObject({
data: 'fetch counter: 2',
status: 'success',
isFetching: true,
})
expect(states[3]).toMatchObject({
data: 'fetch counter: 3',
status: 'success',
isFetching: false,
})
})
})
})
// See https://github.com/tannerlinsley/react-query/issues/137
it('should not override initial data in dependent queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
function Page() {
const first = useQuery({
queryKey: key1,
queryFn: () => 'data',
enabled: false,
initialData: 'init',
})
const second = useQuery({
queryKey: key2,
queryFn: () => 'data',
enabled: false,
initialData: 'init',
})
return (
<div>
<h2>First Data: {first.data}</h2>
<h2>Second Data: {second.data}</h2>
<div>First Status: {first.status}</div>
<div>Second Status: {second.status}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
rendered.getByText('First Data: init')
rendered.getByText('Second Data: init')
rendered.getByText('First Status: success')
rendered.getByText('Second Status: success')
})
it('should not override query configuration on render', async () => {
const key = queryKey()
const queryFn1 = async () => {
await sleep(10)
return 'data1'
}
const queryFn2 = async () => {
await sleep(10)
return 'data2'
}
function Page() {
useQuery({ queryKey: key, queryFn: queryFn1 })
useQuery({ queryKey: key, queryFn: queryFn2 })
return null
}
renderWithClient(queryClient, <Page />)
expect(queryCache.find({ queryKey: key })!.options.queryFn).toBe(queryFn1)
})
it('should batch re-renders', async () => {
const key = queryKey()
let renders = 0
const queryFn = async () => {
await sleep(15)
return 'data'
}
function Page() {
const query1 = useQuery({ queryKey: key, queryFn })
const query2 = useQuery({ queryKey: key, queryFn })
renders++
return (
<div>
{query1.data} {query2.data}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('data data')
})
// Should be 2 instead of 3
expect(renders).toBe(2)
})
it('should render latest data even if react has discarded certain renders', async () => {
const key = queryKey()
function Page() {
const [, setNewState] = React.useState('state')
const state = useQuery({ queryKey: key, queryFn: () => 'data' })
React.useEffect(() => {
setActTimeout(() => {
queryClient.setQueryData(key, 'new')
// Update with same state to make react discard the next render
setNewState('state')
}, 10)
}, [])
return <div>{state.data}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('new'))
})
// See https://github.com/tannerlinsley/react-query/issues/170
it('should start with status pending, fetchStatus idle if enabled is false', async () => {
const key1 = queryKey()
const key2 = queryKey()
function Page() {
const first = useQuery({
queryKey: key1,
queryFn: () => 'data',
enabled: false,
})
const second = useQuery({ queryKey: key2, queryFn: () => 'data' })
return (
<div>
<div>
First Status: {first.status}, {first.fetchStatus}
</div>
<div>
Second Status: {second.status}, {second.fetchStatus}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
// use "act" to wait for state update and prevent console warning
rendered.getByText('First Status: pending, idle')
await waitFor(() => rendered.getByText('Second Status: pending, fetching'))
await waitFor(() => rendered.getByText('Second Status: success, idle'))
})
// See https://github.com/tannerlinsley/react-query/issues/144
it('should be in "pending" state by default', async () => {
const key = queryKey()
function Page() {
const { status } = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
})
return <div>status: {status}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
rendered.getByText('status: pending')
})
it('should not refetch query on focus when `enabled` is set to `false`', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
function Page() {
const { data = 'default' } = useQuery({
queryKey: key,
queryFn,
enabled: false,
})
return (
<div>
<h1>{data}</h1>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('default'))
act(() => {
window.dispatchEvent(new Event('visibilitychange'))
})
expect(queryFn).not.toHaveBeenCalled()
})
it('should not refetch stale query on focus when `refetchOnWindowFocus` is set to `false`', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => count++,
staleTime: 0,
refetchOnWindowFocus: false,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
act(() => {
window.dispatchEvent(new Event('visibilitychange'))
})
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined, isFetching: true })
expect(states[1]).toMatchObject({ data: 0, isFetching: false })
})
it('should not refetch stale query on focus when `refetchOnWindowFocus` is set to a function that returns `false`', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => count++,
staleTime: 0,
refetchOnWindowFocus: () => false,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
act(() => {
window.dispatchEvent(new Event('visibilitychange'))
})
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined, isFetching: true })
expect(states[1]).toMatchObject({ data: 0, isFetching: false })
})
it('should not refetch fresh query on focus when `refetchOnWindowFocus` is set to `true`', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => count++,
staleTime: Infinity,
refetchOnWindowFocus: true,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
act(() => {
window.dispatchEvent(new Event('visibilitychange'))
})
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined, isFetching: true })
expect(states[1]).toMatchObject({ data: 0, isFetching: false })
})
it('should refetch fresh query on focus when `refetchOnWindowFocus` is set to `always`', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return count++
},
staleTime: Infinity,
refetchOnWindowFocus: 'always',
})
states.push(state)
return (
<div>
<div>
data: {state.data}, isFetching: {String(state.isFetching)}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 0, isFetching: false'))
act(() => {
window.dispatchEvent(new Event('visibilitychange'))
})
await waitFor(() => rendered.getByText('data: 1, isFetching: false'))
})
it('should calculate focus behaviour for `refetchOnWindowFocus` depending on function', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return count++
},
staleTime: 0,
retry: 0,
refetchOnWindowFocus: (query) => (query.state.data || 0) < 1,
})
states.push(state)
return <div>data: {String(state.data)}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await rendered.findByText('data: 0')
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined, isFetching: true })
expect(states[1]).toMatchObject({ data: 0, isFetching: false })
act(() => {
window.dispatchEvent(new Event('visibilitychange'))
})
await rendered.findByText('data: 1')
// refetch should happen
expect(states.length).toBe(4)
expect(states[2]).toMatchObject({ data: 0, isFetching: true })
expect(states[3]).toMatchObject({ data: 1, isFetching: false })
act(() => {
window.dispatchEvent(new Event('visibilitychange'))
})
await sleep(20)
// no more refetch now
expect(states.length).toBe(4)
})
it('should refetch fresh query when refetchOnMount is set to always', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => 'prefetched',
})
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'data',
refetchOnMount: 'always',
staleTime: Infinity,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'prefetched',
isStale: false,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: false,
isFetching: false,
})
})
it('should refetch stale query when refetchOnMount is set to true', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => 'prefetched',
})
await sleep(10)
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'data',
refetchOnMount: true,
staleTime: 0,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'prefetched',
isStale: true,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: true,
isFetching: false,
})
})
it('should set status to error if queryFn throws', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
function Page() {
const { status, error } = useQuery({
queryKey: key,
queryFn: () => {
return Promise.reject(new Error('Error test jaylen'))
},
retry: false,
})
return (
<div>
<h1>{status}</h1>
<h2>{error?.message}</h2>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('error'))
await waitFor(() => rendered.getByText('Error test jaylen'))
consoleMock.mockRestore()
})
it('should throw error if queryFn throws and throwOnError is in use', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
function Page() {
const { status, error } = useQuery<unknown, string>({
queryKey: key,
queryFn: () => Promise.reject(new Error('Error test jaylen')),
retry: false,
throwOnError: true,
})
return (
<div>
<h1>{status}</h1>
<h2>{error}</h2>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<ErrorBoundary fallbackRender={() => <div>error boundary</div>}>
<Page />
</ErrorBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should update with data if we observe no properties and throwOnError', async () => {
const key = queryKey()
let result: UseQueryResult<string> | undefined
function Page() {
const query = useQuery({
queryKey: key,
queryFn: () => Promise.resolve('data'),
throwOnError: true,
})
React.useEffect(() => {
result = query
})
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
await waitFor(() => expect(queryClient.isFetching()).toBe(0))
expect(result?.data).toBe('data')
})
it('should set status to error instead of throwing when error should not be thrown', async () => {
const key = queryKey()
function Page() {
const { status, error } = useQuery({
queryKey: key,
queryFn: () => Promise.reject(new Error('Local Error')),
retry: false,
throwOnError: (err) => err.message !== 'Local Error',
})
return (
<div>
<h1>{status}</h1>
<h2>{error?.message}</h2>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<ErrorBoundary fallbackRender={() => <div>error boundary</div>}>
<Page />
</ErrorBoundary>,
)
await waitFor(() => rendered.getByText('error'))
await waitFor(() => rendered.getByText('Local Error'))
})
it('should throw error instead of setting status when error should be thrown', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
function Page() {
const { status, error } = useQuery<unknown, Error>({
queryKey: key,
queryFn: () => Promise.reject(new Error('Remote Error')),
retry: false,
throwOnError: (err) => err.message !== 'Local Error',
})
return (
<div>
<h1>{status}</h1>
<h2>{error?.message ?? ''}</h2>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<ErrorBoundary
fallbackRender={({ error }) => (
<div>
<div>error boundary</div>
{/* eslint-disable-next-line @typescript-eslint/no-unnecessary-condition */}
<div>{error?.message}</div>
</div>
)}
>
<Page />
</ErrorBoundary>,
)
await waitFor(() => rendered.getByText('error boundary'))
await waitFor(() => rendered.getByText('Remote Error'))
consoleMock.mockRestore()
})
it('should continue retries when observers unmount and remount while waiting for a retry (#3031)', async () => {
const key = queryKey()
let count = 0
function Page() {
const result = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return Promise.reject(new Error('some error'))
},
retry: 2,
retryDelay: 100,
})
return (
<div>
<div>error: {result.error?.message ?? 'null'}</div>
<div>failureCount: {result.failureCount}</div>
<div>failureReason: {result.failureReason?.message}</div>
</div>
)
}
function App() {
const [show, toggle] = React.useReducer((x) => !x, true)
return (
<div>
<button onClick={toggle}>{show ? 'hide' : 'show'}</button>
{show && <Page />}
</div>
)
}
const rendered = renderWithClient(queryClient, <App />)
await waitFor(() => rendered.getByText('failureCount: 1'))
await waitFor(() => rendered.getByText('failureReason: some error'))
fireEvent.click(rendered.getByRole('button', { name: /hide/i }))
await waitFor(() => rendered.getByRole('button', { name: /show/i }))
fireEvent.click(rendered.getByRole('button', { name: /show/i }))
await waitFor(() => rendered.getByText('error: some error'))
expect(count).toBe(3)
})
it('should restart when observers unmount and remount while waiting for a retry when query was cancelled in between (#3031)', async () => {
const key = queryKey()
let count = 0
function Page() {
const result = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return Promise.reject(new Error('some error'))
},
retry: 2,
retryDelay: 100,
})
return (
<div>
<div>error: {result.error?.message ?? 'null'}</div>
<div>failureCount: {result.failureCount}</div>
<div>failureReason: {result.failureReason?.message}</div>
</div>
)
}
function App() {
const [show, toggle] = React.useReducer((x) => !x, true)
return (
<div>
<button onClick={toggle}>{show ? 'hide' : 'show'}</button>
<button onClick={() => queryClient.cancelQueries({ queryKey: key })}>
cancel
</button>
{show && <Page />}
</div>
)
}
const rendered = renderWithClient(queryClient, <App />)
await waitFor(() => rendered.getByText('failureCount: 1'))
await waitFor(() => rendered.getByText('failureReason: some error'))
fireEvent.click(rendered.getByRole('button', { name: /hide/i }))
fireEvent.click(rendered.getByRole('button', { name: /cancel/i }))
await waitFor(() => rendered.getByRole('button', { name: /show/i }))
fireEvent.click(rendered.getByRole('button', { name: /show/i }))
await waitFor(() => rendered.getByText('error: some error'))
// initial fetch (1), which will be cancelled, followed by new mount(2) + 2 retries = 4
expect(count).toBe(4)
})
it('should always fetch if refetchOnMount is set to always', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => 'prefetched',
})
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'data',
refetchOnMount: 'always',
staleTime: 50,
})
states.push(state)
return (
<div>
<div>data: {state.data ?? 'null'}</div>
<div>isFetching: {state.isFetching}</div>
<div>isStale: {state.isStale}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: data'))
await waitFor(() => expect(states.length).toBe(3))
expect(states[0]).toMatchObject({
data: 'prefetched',
isStale: false,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: false,
isFetching: false,
})
expect(states[2]).toMatchObject({
data: 'data',
isStale: true,
isFetching: false,
})
})
it('should fetch if initial data is set', async () => {
const key = queryKey()
const states: Array<DefinedUseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'data',
initialData: 'initial',
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(50)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'initial',
isStale: true,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: true,
isFetching: false,
})
})
it('should not fetch if initial data is set with a stale time', async () => {
const key = queryKey()
const states: Array<DefinedUseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'data',
staleTime: 50,
initialData: 'initial',
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'initial',
isStale: false,
isFetching: false,
})
expect(states[1]).toMatchObject({
data: 'initial',
isStale: true,
isFetching: false,
})
})
it('should fetch if initial data updated at is older than stale time', async () => {
const key = queryKey()
const states: Array<DefinedUseQueryResult<string>> = []
const oneSecondAgo = Date.now() - 1000
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'data',
staleTime: 50,
initialData: 'initial',
initialDataUpdatedAt: oneSecondAgo,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(3)
expect(states[0]).toMatchObject({
data: 'initial',
isStale: true,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: false,
isFetching: false,
})
expect(states[2]).toMatchObject({
data: 'data',
isStale: true,
isFetching: false,
})
})
it('should fetch if "initial data updated at" is exactly 0', async () => {
const key = queryKey()
const states: Array<DefinedUseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: () => 'data',
staleTime: 10 * 1000, // 10 seconds
initialData: 'initial',
initialDataUpdatedAt: 0,
})
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'initial',
isStale: true,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: false,
isFetching: false,
})
})
it('should keep initial data when the query key changes', async () => {
const key = queryKey()
const states: Array<DefinedUseQueryResult<{ count: number }>> = []
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
queryKey: [key, count],
queryFn: () => ({ count: 10 }),
staleTime: Infinity,
initialData: () => ({ count }),
})
states.push(state)
React.useEffect(() => {
setActTimeout(() => {
setCount(1)
}, 10)
}, [])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(2)
// Initial
expect(states[0]).toMatchObject({ data: { count: 0 } })
// Set state
expect(states[1]).toMatchObject({ data: { count: 1 } })
})
it('should retry specified number of times', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, unknown>()
queryFn.mockImplementation(() => {
return Promise.reject(new Error('Error test Barrett'))
})
function Page() {
const { status, failureCount, failureReason } = useQuery({
queryKey: key,
queryFn,
retry: 1,
retryDelay: 1,
})
return (
<div>
<h1>{status}</h1>
<h2>Failed {failureCount} times</h2>
<h2>Failed because {failureReason?.message}</h2>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('pending'))
await waitFor(() => rendered.getByText('error'))
// query should fail `retry + 1` times, since first time isn't a "retry"
await waitFor(() => rendered.getByText('Failed 2 times'))
await waitFor(() => rendered.getByText('Failed because Error test Barrett'))
expect(queryFn).toHaveBeenCalledTimes(2)
})
it('should not retry if retry function `false`', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, unknown>()
queryFn.mockImplementationOnce(() => {
return Promise.reject(new Error('Error test Tanner'))
})
queryFn.mockImplementation(() => {
return Promise.reject(new Error('NoRetry'))
})
function Page() {
const { status, failureCount, failureReason, error } = useQuery({
queryKey: key,
queryFn,
retryDelay: 1,
retry: (_failureCount, err) => err.message !== 'NoRetry',
})
return (
<div>
<h1>{status}</h1>
<h2>Failed {failureCount} times</h2>
<h2>Failed because {failureReason?.message}</h2>
<h2>{error?.message}</h2>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('pending'))
await waitFor(() => rendered.getByText('error'))
await waitFor(() => rendered.getByText('Failed 2 times'))
await waitFor(() => rendered.getByText('Failed because NoRetry'))
await waitFor(() => rendered.getByText('NoRetry'))
expect(queryFn).toHaveBeenCalledTimes(2)
})
it('should extract retryDelay from error', async () => {
const key = queryKey()
type DelayError = { delay: number }
const queryFn = vi.fn<Array<unknown>, unknown>()
queryFn.mockImplementation(() => {
return Promise.reject({ delay: 50 })
})
function Page() {
const { status, failureCount, failureReason } = useQuery({
queryKey: key,
queryFn,
retry: 1,
retryDelay: (_, error: DelayError) => error.delay,
})
return (
<div>
<h1>{status}</h1>
<h2>Failed {failureCount} times</h2>
<h2>Failed because DelayError: {failureReason?.delay}ms</h2>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await sleep(10)
expect(queryFn).toHaveBeenCalledTimes(1)
await waitFor(() => rendered.getByText('Failed because DelayError: 50ms'))
await waitFor(() => rendered.getByText('Failed 2 times'))
expect(queryFn).toHaveBeenCalledTimes(2)
})
// See https://github.com/tannerlinsley/react-query/issues/160
it('should continue retry after focus regain', async () => {
const key = queryKey()
// make page unfocused
const visibilityMock = mockVisibilityState('hidden')
let count = 0
function Page() {
const query = useQuery<unknown, string>({
queryKey: key,
queryFn: () => {
count++
return Promise.reject<unknown>(`fetching error ${count}`)
},
retry: 3,
retryDelay: 1,
})
return (
<div>
<div>error {String(query.error)}</div>
<div>status {query.status}</div>
<div>failureCount {query.failureCount}</div>
<div>failureReason {query.failureReason}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
// The query should display the first error result
await waitFor(() => rendered.getByText('failureCount 1'))
await waitFor(() => rendered.getByText('failureReason fetching error 1'))
await waitFor(() => rendered.getByText('status pending'))
await waitFor(() => rendered.getByText('error null'))
// Check if the query really paused
await sleep(10)
await waitFor(() => rendered.getByText('failureCount 1'))
await waitFor(() => rendered.getByText('failureReason fetching error 1'))
act(() => {
// reset visibilityState to original value
visibilityMock.mockRestore()
window.dispatchEvent(new Event('visibilitychange'))
})
// Wait for the final result
await waitFor(() => rendered.getByText('failureCount 4'))
await waitFor(() => rendered.getByText('failureReason fetching error 4'))
await waitFor(() => rendered.getByText('status error'))
await waitFor(() => rendered.getByText('error fetching error 4'))
// Check if the query really stopped
await sleep(10)
await waitFor(() => rendered.getByText('failureCount 4'))
await waitFor(() => rendered.getByText('failureReason fetching error 4'))
})
it('should fetch on mount when a query was already created with setQueryData', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
queryClient.setQueryData(key, 'prefetched')
function Page() {
const state = useQuery({ queryKey: key, queryFn: () => 'data' })
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
expect(states.length).toBe(2)
expect(states).toMatchObject([
{
data: 'prefetched',
isFetching: true,
isStale: true,
},
{
data: 'data',
isFetching: false,
isStale: true,
},
])
})
it('should refetch after focus regain', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
// make page unfocused
const visibilityMock = mockVisibilityState('hidden')
// set data in cache to check if the hook query fn is actually called
queryClient.setQueryData(key, 'prefetched')
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'data'
},
})
states.push(state)
return (
<div>
{state.data}, {state.isStale}, {state.isFetching}
</div>
)
}
renderWithClient(queryClient, <Page />)
await waitFor(() => expect(states.length).toBe(2))
act(() => {
// reset visibilityState to original value
visibilityMock.mockRestore()
window.dispatchEvent(new Event('visibilitychange'))
})
await waitFor(() => expect(states.length).toBe(4))
expect(states).toMatchObject([
{
data: 'prefetched',
isFetching: true,
isStale: true,
},
{
data: 'data',
isFetching: false,
isStale: true,
},
{
data: 'data',
isFetching: true,
isStale: true,
},
{
data: 'data',
isFetching: false,
isStale: true,
},
])
})
// See https://github.com/tannerlinsley/react-query/issues/195
it('should refetch if stale after a prefetch', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
const queryFn = vi.fn<Array<unknown>, string>()
queryFn.mockImplementation(() => 'data')
const prefetchQueryFn = vi.fn<Array<unknown>, string>()
prefetchQueryFn.mockImplementation(() => 'not yet...')
await queryClient.prefetchQuery({
queryKey: key,
queryFn: prefetchQueryFn,
staleTime: 10,
})
await sleep(11)
function Page() {
const state = useQuery({ queryKey: key, queryFn })
states.push(state)
return null
}
renderWithClient(queryClient, <Page />)
await waitFor(() => expect(states.length).toBe(2))
expect(prefetchQueryFn).toHaveBeenCalledTimes(1)
expect(queryFn).toHaveBeenCalledTimes(1)
})
it('should not refetch if not stale after a prefetch', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>()
queryFn.mockImplementation(() => 'data')
const prefetchQueryFn = vi.fn<Array<unknown>, Promise<string>>()
prefetchQueryFn.mockImplementation(async () => {
await sleep(10)
return 'not yet...'
})
await queryClient.prefetchQuery({
queryKey: key,
queryFn: prefetchQueryFn,
staleTime: 1000,
})
await sleep(0)
function Page() {
useQuery({ queryKey: key, queryFn, staleTime: 1000 })
return null
}
renderWithClient(queryClient, <Page />)
await sleep(0)
expect(prefetchQueryFn).toHaveBeenCalledTimes(1)
expect(queryFn).toHaveBeenCalledTimes(0)
})
// See https://github.com/tannerlinsley/react-query/issues/190
it('should reset failureCount on successful fetch', async () => {
const key = queryKey()
function Page() {
let counter = 0
const query = useQuery<string, Error>({
queryKey: key,
queryFn: async () => {
if (counter < 2) {
counter++
throw new Error('error')
} else {
return 'data'
}
},
retryDelay: 10,
})
return (
<div>
<div>failureCount {query.failureCount}</div>
<div>failureReason {query.failureReason?.message ?? 'null'}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('failureCount 2'))
await waitFor(() => rendered.getByText('failureReason error'))
await waitFor(() => rendered.getByText('failureCount 0'))
await waitFor(() => rendered.getByText('failureReason null'))
})
// See https://github.com/tannerlinsley/react-query/issues/199
it('should use prefetched data for dependent query', async () => {
const key = queryKey()
let count = 0
function Page() {
const [enabled, setEnabled] = React.useState(false)
const [isPrefetched, setPrefetched] = React.useState(false)
const query = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return count
},
enabled,
})
React.useEffect(() => {
async function prefetch() {
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('prefetched data'),
})
act(() => setPrefetched(true))
}
prefetch()
}, [])
return (
<div>
{isPrefetched && <div>isPrefetched</div>}
<button onClick={() => setEnabled(true)}>setKey</button>
<div>data: {query.data}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('isPrefetched'))
fireEvent.click(rendered.getByText('setKey'))
await waitFor(() => rendered.getByText('data: prefetched data'))
await waitFor(() => rendered.getByText('data: 1'))
expect(count).toBe(1)
})
it('should support dependent queries via the enable config option', async () => {
const key = queryKey()
function Page() {
const [shouldFetch, setShouldFetch] = React.useState(false)
const query = useQuery({
queryKey: key,
queryFn: () => 'data',
enabled: shouldFetch,
})
return (
<div>
<div>FetchStatus: {query.fetchStatus}</div>
<h2>Data: {query.data || 'no data'}</h2>
{query.isStale ? (
<button onClick={() => setShouldFetch(true)}>fetch</button>
) : null}
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
rendered.getByText('FetchStatus: idle')
rendered.getByText('Data: no data')
fireEvent.click(rendered.getByText('fetch'))
await waitFor(() => rendered.getByText('FetchStatus: fetching'))
await waitFor(() => [
rendered.getByText('FetchStatus: idle'),
rendered.getByText('Data: data'),
])
})
it('should mark query as fetching, when using initialData', async () => {
const key = queryKey()
const results: Array<DefinedUseQueryResult<string>> = []
function Page() {
const result = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'serverData'
},
initialData: 'initialData',
})
results.push(result)
return <div>data: {result.data}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: initialData'))
await waitFor(() => rendered.getByText('data: serverData'))
expect(results.length).toBe(2)
expect(results[0]).toMatchObject({ data: 'initialData', isFetching: true })
expect(results[1]).toMatchObject({ data: 'serverData', isFetching: false })
})
it('should initialize state properly, when initialData is falsy', async () => {
const key = queryKey()
const results: Array<DefinedUseQueryResult<number>> = []
function Page() {
const result = useQuery({
queryKey: key,
queryFn: () => 1,
initialData: 0,
})
results.push(result)
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
expect(results.length).toBe(2)
expect(results[0]).toMatchObject({ data: 0, isFetching: true })
expect(results[1]).toMatchObject({ data: 1, isFetching: false })
})
it('should show the correct data when switching keys with initialData, placeholderData & staleTime', async () => {
const key = queryKey()
const ALL_TODOS = [
{ name: 'todo A', priority: 'high' },
{ name: 'todo B', priority: 'medium' },
]
const initialTodos = ALL_TODOS
function Page() {
const [filter, setFilter] = React.useState('')
const { data: todos } = useQuery({
queryKey: [...key, filter],
queryFn: async () => {
return ALL_TODOS.filter((todo) =>
filter ? todo.priority === filter : true,
)
},
initialData() {
return filter === '' ? initialTodos : undefined
},
placeholderData: keepPreviousData,
staleTime: 5000,
})
return (
<div>
Current Todos, filter: {filter || 'all'}
<hr />
<button onClick={() => setFilter('')}>All</button>
<button onClick={() => setFilter('high')}>High</button>
<ul>
{(todos ?? []).map((todo) => (
<li key={todo.name}>
{todo.name} - {todo.priority}
</li>
))}
</ul>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Current Todos, filter: all'))
fireEvent.click(rendered.getByRole('button', { name: /high/i }))
await waitFor(() => rendered.getByText('Current Todos, filter: high'))
fireEvent.click(rendered.getByRole('button', { name: /all/i }))
await waitFor(() => rendered.getByText('todo B - medium'))
})
// // See https://github.com/tannerlinsley/react-query/issues/214
it('data should persist when enabled is changed to false', async () => {
const key = queryKey()
const results: Array<DefinedUseQueryResult<string>> = []
function Page() {
const [shouldFetch, setShouldFetch] = React.useState(true)
const result = useQuery({
queryKey: key,
queryFn: () => 'fetched data',
enabled: shouldFetch,
initialData: shouldFetch ? 'initial' : 'initial falsy',
})
results.push(result)
return (
<div>
<div>{result.data}</div>
<div>{shouldFetch ? 'enabled' : 'disabled'}</div>
<button
onClick={() => {
setShouldFetch(false)
}}
>
enable
</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => {
rendered.getByText('fetched data')
rendered.getByText('enabled')
})
fireEvent.click(rendered.getByRole('button', { name: /enable/i }))
await waitFor(() => {
rendered.getByText('fetched data')
rendered.getByText('disabled')
})
expect(results.length).toBe(3)
expect(results[0]).toMatchObject({ data: 'initial', isStale: true })
expect(results[1]).toMatchObject({ data: 'fetched data', isStale: true })
expect(results[2]).toMatchObject({ data: 'fetched data', isStale: true })
})
it('it should support enabled:false in query object syntax', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>()
queryFn.mockImplementation(() => 'data')
function Page() {
const { fetchStatus } = useQuery({
queryKey: key,
queryFn,
enabled: false,
})
return <div>fetchStatus: {fetchStatus}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
expect(queryFn).not.toHaveBeenCalled()
expect(queryCache.find({ queryKey: key })).not.toBeUndefined()
rendered.getByText('fetchStatus: idle')
})
// See https://github.com/tannerlinsley/react-query/issues/360
test('should init to status:pending, fetchStatus:idle when enabled is false', async () => {
const key = queryKey()
function Page() {
const query = useQuery({
queryKey: key,
queryFn: () => 'data',
enabled: false,
})
return (
<div>
<div>
status: {query.status}, {query.fetchStatus}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('status: pending, idle'))
})
test('should not schedule garbage collection, if gcTimeout is set to `Infinity`', async () => {
const key = queryKey()
function Page() {
const query = useQuery({
queryKey: key,
queryFn: () => 'fetched data',
gcTime: Infinity,
})
return <div>{query.data}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('fetched data'))
const setTimeoutSpy = vi.spyOn(globalThis.window, 'setTimeout')
rendered.unmount()
expect(setTimeoutSpy).not.toHaveBeenCalled()
})
test('should schedule garbage collection, if gcTimeout is not set to infinity', async () => {
const key = queryKey()
function Page() {
const query = useQuery({
queryKey: key,
queryFn: () => 'fetched data',
gcTime: 1000 * 60 * 10, //10 Minutes
})
return <div>{query.data}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('fetched data'))
const setTimeoutSpy = vi.spyOn(globalThis.window, 'setTimeout')
rendered.unmount()
expect(setTimeoutSpy).toHaveBeenLastCalledWith(
expect.any(Function),
1000 * 60 * 10,
)
})
it('should not cause memo churn when data does not change', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
const memoFn = vi.fn()
function Page() {
const result = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return (
queryFn() || {
data: {
nested: true,
},
}
)
},
})
React.useMemo(() => {
memoFn()
return result.data
}, [result.data])
return (
<div>
<div>status {result.status}</div>
<div>isFetching {result.isFetching ? 'true' : 'false'}</div>
<button onClick={() => result.refetch()}>refetch</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('status pending'))
await waitFor(() => rendered.getByText('status success'))
fireEvent.click(rendered.getByText('refetch'))
await waitFor(() => rendered.getByText('isFetching true'))
await waitFor(() => rendered.getByText('isFetching false'))
expect(queryFn).toHaveBeenCalledTimes(2)
expect(memoFn).toHaveBeenCalledTimes(2)
})
it('should update data upon interval changes', async () => {
const key = queryKey()
let count = 0
function Page() {
const [int, setInt] = React.useState(200)
const { data } = useQuery({
queryKey: key,
queryFn: () => count++,
refetchInterval: int,
})
React.useEffect(() => {
if (data === 2) {
setInt(0)
}
}, [data])
return <div>count: {data}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
// mount
await waitFor(() => rendered.getByText('count: 0'))
await waitFor(() => rendered.getByText('count: 1'))
await waitFor(() => rendered.getByText('count: 2'))
})
it('should refetch in an interval depending on function result', async () => {
const key = queryKey()
let count = 0
const states: Array<UseQueryResult<number>> = []
function Page() {
const queryInfo = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return count++
},
refetchInterval: ({ state: { data = 0 } }) => (data < 2 ? 10 : false),
})
states.push(queryInfo)
return (
<div>
<h1>count: {queryInfo.data}</h1>
<h2>status: {queryInfo.status}</h2>
<h2>data: {queryInfo.data}</h2>
<h2>refetch: {queryInfo.isRefetching}</h2>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('count: 2'))
expect(states.length).toEqual(6)
expect(states).toMatchObject([
{
status: 'pending',
isFetching: true,
data: undefined,
},
{
status: 'success',
isFetching: false,
data: 0,
},
{
status: 'success',
isFetching: true,
data: 0,
},
{
status: 'success',
isFetching: false,
data: 1,
},
{
status: 'success',
isFetching: true,
data: 1,
},
{
status: 'success',
isFetching: false,
data: 2,
},
])
})
it('should not interval fetch with a refetchInterval of 0', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
function Page() {
const queryInfo = useQuery({
queryKey: key,
queryFn: () => 1,
refetchInterval: 0,
})
states.push(queryInfo)
return <div>count: {queryInfo.data}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('count: 1'))
await sleep(10) //extra sleep to make sure we're not re-fetching
expect(states.length).toEqual(2)
expect(states).toMatchObject([
{
status: 'pending',
isFetching: true,
data: undefined,
},
{
status: 'success',
isFetching: false,
data: 1,
},
])
})
it('should accept an empty string as query key', async () => {
function Page() {
const result = useQuery({
queryKey: [''],
queryFn: (ctx) => ctx.queryKey,
})
return <>{JSON.stringify(result.data)}</>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText(''))
})
it('should accept an object as query key', async () => {
function Page() {
const result = useQuery({
queryKey: [{ a: 'a' }],
queryFn: (ctx) => ctx.queryKey,
})
return <>{JSON.stringify(result.data)}</>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('[{"a":"a"}]'))
})
it('should refetch if any query instance becomes enabled', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
function Disabled() {
useQuery({ queryKey: key, queryFn, enabled: false })
return null
}
function Page() {
const [enabled, setEnabled] = React.useState(false)
const result = useQuery({ queryKey: key, queryFn, enabled })
return (
<>
<Disabled />
<div>{result.data}</div>
<button onClick={() => setEnabled(true)}>enable</button>
</>
)
}
const rendered = renderWithClient(queryClient, <Page />)
expect(queryFn).toHaveBeenCalledTimes(0)
fireEvent.click(rendered.getByText('enable'))
await waitFor(() => rendered.getByText('data'))
expect(queryFn).toHaveBeenCalledTimes(1)
})
it('should use placeholder data while the query loads', async () => {
const key1 = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key1,
queryFn: () => 'data',
placeholderData: 'placeholder',
})
states.push(state)
return (
<div>
<h2>Data: {state.data}</h2>
<div>Status: {state.status}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Data: data'))
expect(states).toMatchObject([
{
isSuccess: true,
isPlaceholderData: true,
data: 'placeholder',
},
{
isSuccess: true,
isPlaceholderData: false,
data: 'data',
},
])
})
it('should use placeholder data even for disabled queries', async () => {
const key1 = queryKey()
const states: Array<{ state: UseQueryResult<string>; count: number }> = []
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
queryKey: key1,
queryFn: () => 'data',
placeholderData: 'placeholder',
enabled: count === 0,
})
states.push({ state, count })
React.useEffect(() => {
setCount(1)
}, [])
return (
<div>
<h2>Data: {state.data}</h2>
<div>Status: {state.status}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Data: data'))
expect(states).toMatchObject([
{
state: {
isSuccess: true,
isPlaceholderData: true,
data: 'placeholder',
},
count: 0,
},
{
state: {
isSuccess: true,
isPlaceholderData: true,
data: 'placeholder',
},
count: 1,
},
{
state: {
isSuccess: true,
isPlaceholderData: false,
data: 'data',
},
count: 1,
},
])
})
it('placeholder data should run through select', async () => {
const key1 = queryKey()
const states: Array<UseQueryResult<string>> = []
function Page() {
const state = useQuery({
queryKey: key1,
queryFn: () => 1,
placeholderData: 23,
select: (data) => String(data * 2),
})
states.push(state)
return (
<div>
<h2>Data: {state.data}</h2>
<div>Status: {state.status}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Data: 2'))
expect(states).toMatchObject([
{
isSuccess: true,
isPlaceholderData: true,
data: '46',
},
{
isSuccess: true,
isPlaceholderData: false,
data: '2',
},
])
})
it('placeholder data function result should run through select', async () => {
const key1 = queryKey()
const states: Array<UseQueryResult<string>> = []
let placeholderFunctionRunCount = 0
function Page() {
const state = useQuery({
queryKey: key1,
queryFn: () => 1,
placeholderData: () => {
placeholderFunctionRunCount++
return 23
},
select: (data) => String(data * 2),
})
states.push(state)
return (
<div>
<h2>Data: {state.data}</h2>
<div>Status: {state.status}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Data: 2'))
rendered.rerender(<Page />)
expect(states).toMatchObject([
{
isSuccess: true,
isPlaceholderData: true,
data: '46',
},
{
isSuccess: true,
isPlaceholderData: false,
data: '2',
},
{
isSuccess: true,
isPlaceholderData: false,
data: '2',
},
])
expect(placeholderFunctionRunCount).toEqual(1)
})
it('select should only run when dependencies change if memoized', async () => {
const key1 = queryKey()
let selectRun = 0
function Page() {
const [count, inc] = React.useReducer((prev) => prev + 1, 2)
const state = useQuery({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 0
},
select: React.useCallback(
(data: number) => {
selectRun++
return `selected ${data + count}`
},
[count],
),
placeholderData: 99,
})
return (
<div>
<h2>Data: {state.data}</h2>
<button onClick={inc}>inc: {count}</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Data: selected 101')) // 99 + 2
expect(selectRun).toBe(1)
await waitFor(() => rendered.getByText('Data: selected 2')) // 0 + 2
expect(selectRun).toBe(2)
fireEvent.click(rendered.getByRole('button', { name: /inc/i }))
await waitFor(() => rendered.getByText('Data: selected 3')) // 0 + 3
expect(selectRun).toBe(3)
})
it('select should always return the correct state', async () => {
const key1 = queryKey()
function Page() {
const [count, inc] = React.useReducer((prev) => prev + 1, 2)
const [forceValue, forceUpdate] = React.useReducer((prev) => prev + 1, 1)
const state = useQuery({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 0
},
select: React.useCallback(
(data: number) => {
return `selected ${data + count}`
},
[count],
),
placeholderData: 99,
})
return (
<div>
<h2>Data: {state.data}</h2>
<h2>forceValue: {forceValue}</h2>
<button onClick={inc}>inc: {count}</button>
<button onClick={forceUpdate}>forceUpdate</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Data: selected 101')) // 99 + 2
await waitFor(() => rendered.getByText('Data: selected 2')) // 0 + 2
fireEvent.click(rendered.getByRole('button', { name: /inc/i }))
await waitFor(() => rendered.getByText('Data: selected 3')) // 0 + 3
fireEvent.click(rendered.getByRole('button', { name: /forceUpdate/i }))
await waitFor(() => rendered.getByText('forceValue: 2'))
// data should still be 3 after an independent re-render
await waitFor(() => rendered.getByText('Data: selected 3'))
})
it('select should structurally share data', async () => {
const key1 = queryKey()
const states: Array<Array<number>> = []
function Page() {
const [forceValue, forceUpdate] = React.useReducer((prev) => prev + 1, 1)
const state = useQuery({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return [1, 2]
},
select: (res) => res.map((x) => x + 1),
})
React.useEffect(() => {
if (state.data) {
states.push(state.data)
}
}, [state.data])
return (
<div>
<h2>Data: {JSON.stringify(state.data)}</h2>
<h2>forceValue: {forceValue}</h2>
<button onClick={forceUpdate}>forceUpdate</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('Data: [2,3]'))
expect(states).toHaveLength(1)
fireEvent.click(rendered.getByRole('button', { name: /forceUpdate/i }))
await waitFor(() => rendered.getByText('forceValue: 2'))
await waitFor(() => rendered.getByText('Data: [2,3]'))
// effect should not be triggered again due to structural sharing
expect(states).toHaveLength(1)
})
it('should cancel the query function when there are no more subscriptions', async () => {
const key = queryKey()
let cancelFn: Mock = vi.fn()
const queryFn = ({ signal }: { signal?: AbortSignal }) => {
const promise = new Promise<string>((resolve, reject) => {
cancelFn = vi.fn(() => reject('Cancelled'))
signal?.addEventListener('abort', cancelFn)
sleep(20).then(() => resolve('OK'))
})
return promise
}
function Page() {
const state = useQuery({ queryKey: key, queryFn })
return (
<div>
<h1>Status: {state.status}</h1>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<Blink duration={5}>
<Page />
</Blink>,
)
await waitFor(() => rendered.getByText('off'))
expect(cancelFn).toHaveBeenCalled()
})
it('should cancel the query if the signal was consumed and there are no more subscriptions', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
const queryFn: QueryFunction<string, [typeof key, number]> = async (
ctx,
) => {
const [, limit] = ctx.queryKey
// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
const value = limit % 2 && ctx.signal ? 'abort' : `data ${limit}`
await sleep(25)
return value
}
function Page(props: { limit: number }) {
const state = useQuery({ queryKey: [key, props.limit], queryFn })
states[props.limit] = state
return (
<div>
<h1>Status: {state.status}</h1>
<h1>data: {state.data}</h1>
</div>
)
}
const rendered = renderWithClient(
queryClient,
<Blink duration={5}>
<Page limit={0} />
<Page limit={1} />
<Page limit={2} />
<Page limit={3} />
</Blink>,
)
await waitFor(() => rendered.getByText('off'))
await sleep(20)
await waitFor(() => expect(states).toHaveLength(4))
expect(queryCache.find({ queryKey: [key, 0] })?.state).toMatchObject({
data: 'data 0',
status: 'success',
dataUpdateCount: 1,
})
expect(queryCache.find({ queryKey: [key, 1] })?.state).toMatchObject({
data: undefined,
status: 'pending',
fetchStatus: 'idle',
})
expect(queryCache.find({ queryKey: [key, 2] })?.state).toMatchObject({
data: 'data 2',
status: 'success',
dataUpdateCount: 1,
})
expect(queryCache.find({ queryKey: [key, 3] })?.state).toMatchObject({
data: undefined,
status: 'pending',
fetchStatus: 'idle',
})
})
it('should refetch when quickly switching to a failed query', async () => {
const key = queryKey()
const states: Array<UseQueryResult<string>> = []
const queryFn = async () => {
await sleep(50)
return 'OK'
}
function Page() {
const [id, setId] = React.useState(1)
const [hasChanged, setHasChanged] = React.useState(false)
const state = useQuery({ queryKey: [key, id], queryFn })
states.push(state)
React.useEffect(() => {
setId((prevId) => (prevId === 1 ? 2 : 1))
setHasChanged(true)
}, [hasChanged])
return null
}
renderWithClient(queryClient, <Page />)
await sleep(100)
expect(states.length).toBe(4)
// Load query 1
expect(states[0]).toMatchObject({
status: 'pending',
error: null,
})
// Load query 2
expect(states[1]).toMatchObject({
status: 'pending',
error: null,
})
// Load query 1
expect(states[2]).toMatchObject({
status: 'pending',
error: null,
})
// Loaded query 1
expect(states[3]).toMatchObject({
status: 'success',
error: null,
})
})
it('should update query state and refetch when reset with resetQueries', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
staleTime: Infinity,
})
states.push(state)
return (
<div>
<button onClick={() => queryClient.resetQueries({ queryKey: key })}>
reset
</button>
<div>data: {state.data ?? 'null'}</div>
<div>isFetching: {state.isFetching}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 1'))
fireEvent.click(rendered.getByRole('button', { name: /reset/i }))
await waitFor(() => expect(states.length).toBe(4))
await waitFor(() => rendered.getByText('data: 2'))
expect(count).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
isPending: true,
isFetching: true,
isSuccess: false,
isStale: true,
})
expect(states[1]).toMatchObject({
data: 1,
isPending: false,
isFetching: false,
isSuccess: true,
isStale: false,
})
expect(states[2]).toMatchObject({
data: undefined,
isPending: true,
isFetching: true,
isSuccess: false,
isStale: true,
})
expect(states[3]).toMatchObject({
data: 2,
isPending: false,
isFetching: false,
isSuccess: true,
isStale: false,
})
})
it('should update query state and not refetch when resetting a disabled query with resetQueries', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
staleTime: Infinity,
enabled: false,
notifyOnChangeProps: 'all',
})
states.push(state)
const { refetch } = state
return (
<div>
<button onClick={() => refetch()}>refetch</button>
<button onClick={() => queryClient.resetQueries({ queryKey: key })}>
reset
</button>
<div>data: {state.data ?? 'null'}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: null'))
fireEvent.click(rendered.getByRole('button', { name: /refetch/i }))
await waitFor(() => rendered.getByText('data: 1'))
fireEvent.click(rendered.getByRole('button', { name: /reset/i }))
await waitFor(() => rendered.getByText('data: null'))
await waitFor(() => expect(states.length).toBe(4))
expect(count).toBe(1)
expect(states[0]).toMatchObject({
data: undefined,
isPending: true,
isFetching: false,
isSuccess: false,
isStale: true,
})
expect(states[1]).toMatchObject({
data: undefined,
isPending: true,
isFetching: true,
isSuccess: false,
isStale: true,
})
expect(states[2]).toMatchObject({
data: 1,
isPending: false,
isFetching: false,
isSuccess: true,
isStale: false,
})
expect(states[3]).toMatchObject({
data: undefined,
isPending: true,
isFetching: false,
isSuccess: false,
isStale: true,
})
})
it('should only call the query hash function once each render', async () => {
const key = queryKey()
let hashes = 0
let renders = 0
function queryKeyHashFn(x: any) {
hashes++
return JSON.stringify(x)
}
function Page() {
React.useEffect(() => {
renders++
})
useQuery({ queryKey: key, queryFn: () => 'test', queryKeyHashFn })
return null
}
renderWithClient(queryClient, <Page />)
await sleep(10)
expect(renders).toBe(hashes)
})
it('should refetch when changed enabled to true in error state', async () => {
const queryFn = vi.fn<Array<unknown>, unknown>()
queryFn.mockImplementation(async () => {
await sleep(10)
return Promise.reject(new Error('Suspense Error Bingo'))
})
function Page({ enabled }: { enabled: boolean }) {
const { error, isPending } = useQuery({
queryKey: ['key'],
queryFn,
enabled,
retry: false,
retryOnMount: false,
refetchOnMount: false,
refetchOnWindowFocus: false,
})
if (isPending) {
return <div>status: pending</div>
}
if (error instanceof Error) {
return <div>error</div>
}
return <div>rendered</div>
}
function App() {
const [enabled, toggle] = React.useReducer((x) => !x, true)
return (
<div>
<Page enabled={enabled} />
<button aria-label="retry" onClick={toggle}>
retry {enabled}
</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <App />)
// initial state check
rendered.getByText('status: pending')
// // render error state component
await waitFor(() => rendered.getByText('error'))
expect(queryFn).toBeCalledTimes(1)
// change to enabled to false
fireEvent.click(rendered.getByLabelText('retry'))
await waitFor(() => rendered.getByText('error'))
expect(queryFn).toBeCalledTimes(1)
// // change to enabled to true
fireEvent.click(rendered.getByLabelText('retry'))
expect(queryFn).toBeCalledTimes(2)
})
it('should refetch when query key changed when previous status is error', async () => {
function Page({ id }: { id: number }) {
const { error, isPending } = useQuery({
queryKey: [id],
queryFn: async () => {
await sleep(10)
if (id % 2 === 1) {
return Promise.reject(new Error('Error'))
} else {
return 'data'
}
},
retry: false,
retryOnMount: false,
refetchOnMount: false,
refetchOnWindowFocus: false,
})
if (isPending) {
return <div>status: pending</div>
}
if (error instanceof Error) {
return <div>error</div>
}
return <div>rendered</div>
}
function App() {
const [id, changeId] = React.useReducer((x) => x + 1, 1)
return (
<div>
<Page id={id} />
<button aria-label="change" onClick={changeId}>
change {id}
</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <App />)
// initial state check
rendered.getByText('status: pending')
// render error state component
await waitFor(() => rendered.getByText('error'))
// change to unmount query
fireEvent.click(rendered.getByLabelText('change'))
await waitFor(() => rendered.getByText('rendered'))
// change to mount new query
fireEvent.click(rendered.getByLabelText('change'))
await waitFor(() => rendered.getByText('error'))
})
it('should refetch when query key changed when switching between erroneous queries', async () => {
function Page({ id }: { id: boolean }) {
const { error, isFetching } = useQuery({
queryKey: [id],
queryFn: async () => {
await sleep(10)
return Promise.reject<unknown>(new Error('Error'))
},
retry: false,
retryOnMount: false,
refetchOnMount: false,
refetchOnWindowFocus: false,
})
if (isFetching) {
return <div>status: fetching</div>
}
if (error instanceof Error) {
return <div>error</div>
}
return <div>rendered</div>
}
function App() {
const [value, toggle] = React.useReducer((x) => !x, true)
return (
<div>
<Page id={value} />
<button aria-label="change" onClick={toggle}>
change {value}
</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <App />)
// initial state check
rendered.getByText('status: fetching')
// render error state component
await waitFor(() => rendered.getByText('error'))
// change to mount second query
fireEvent.click(rendered.getByLabelText('change'))
await waitFor(() => rendered.getByText('status: fetching'))
await waitFor(() => rendered.getByText('error'))
// change to mount first query again
fireEvent.click(rendered.getByLabelText('change'))
await waitFor(() => rendered.getByText('status: fetching'))
await waitFor(() => rendered.getByText('error'))
})
it('should have no error in pending state when refetching after error occurred', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number>> = []
const error = new Error('oops')
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (count === 0) {
count++
throw error
}
return 5
},
retry: false,
})
states.push(state)
if (state.isPending) {
return <div>status: pending</div>
}
if (state.error instanceof Error) {
return (
<div>
<div>error</div>
<button onClick={() => state.refetch()}>refetch</button>
</div>
)
}
return <div>data: {state.data}</div>
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('error'))
fireEvent.click(rendered.getByRole('button', { name: 'refetch' }))
await waitFor(() => rendered.getByText('data: 5'))
await waitFor(() => expect(states.length).toBe(4))
expect(states[0]).toMatchObject({
status: 'pending',
data: undefined,
error: null,
})
expect(states[1]).toMatchObject({
status: 'error',
data: undefined,
error,
})
expect(states[2]).toMatchObject({
status: 'pending',
data: undefined,
error: null,
})
expect(states[3]).toMatchObject({
status: 'success',
data: 5,
error: null,
})
})
describe('networkMode online', () => {
it('online queries should not start fetching if you are offline', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const key = queryKey()
const states: Array<any> = []
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'data'
},
})
React.useEffect(() => {
states.push(state.fetchStatus)
})
return (
<div>
<div>
status: {state.status}, isPaused: {String(state.isPaused)}
</div>
<div>data: {state.data}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
window.dispatchEvent(new Event('offline'))
await waitFor(() => rendered.getByText('status: pending, isPaused: true'))
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await waitFor(() =>
rendered.getByText('status: success, isPaused: false'),
)
await waitFor(() => {
expect(rendered.getByText('data: data')).toBeInTheDocument()
})
expect(states).toEqual(['paused', 'fetching', 'idle'])
})
it('online queries should not refetch if you are offline', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = useQuery<string, string>({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
})
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus},
failureCount: {state.failureCount}
</div>
<div>failureReason: {state.failureReason ?? 'null'}</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: data1'))
const onlineMock = mockOnlineManagerIsOnline(false)
window.dispatchEvent(new Event('offline'))
fireEvent.click(rendered.getByRole('button', { name: /invalidate/i }))
await waitFor(() =>
rendered.getByText(
'status: success, fetchStatus: paused, failureCount: 0',
),
)
await waitFor(() => rendered.getByText('failureReason: null'))
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await waitFor(() =>
rendered.getByText(
'status: success, fetchStatus: fetching, failureCount: 0',
),
)
await waitFor(() => rendered.getByText('failureReason: null'))
await waitFor(() =>
rendered.getByText(
'status: success, fetchStatus: idle, failureCount: 0',
),
)
await waitFor(() => rendered.getByText('failureReason: null'))
await waitFor(() => {
expect(rendered.getByText('data: data2')).toBeInTheDocument()
})
})
it('online queries should not refetch if you are offline and refocus', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
})
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: data1'))
const onlineMock = mockOnlineManagerIsOnline(false)
fireEvent.click(rendered.getByRole('button', { name: /invalidate/i }))
await waitFor(() =>
rendered.getByText('status: success, fetchStatus: paused'),
)
window.dispatchEvent(new Event('visibilitychange'))
await sleep(15)
await waitFor(() =>
expect(rendered.queryByText('data: data2')).not.toBeInTheDocument(),
)
expect(count).toBe(1)
onlineMock.mockRestore()
})
it('online queries should not refetch while already paused', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
})
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() =>
rendered.getByText('status: pending, fetchStatus: paused'),
)
fireEvent.click(rendered.getByRole('button', { name: /invalidate/i }))
await sleep(15)
// invalidation should not trigger a refetch
await waitFor(() =>
rendered.getByText('status: pending, fetchStatus: paused'),
)
expect(count).toBe(0)
onlineMock.mockRestore()
})
it('online queries should not refetch while already paused if data is in the cache', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
initialData: 'initial',
})
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() =>
rendered.getByText('status: success, fetchStatus: paused'),
)
await waitFor(() => {
expect(rendered.getByText('data: initial')).toBeInTheDocument()
})
fireEvent.click(rendered.getByRole('button', { name: /invalidate/i }))
await sleep(15)
// invalidation should not trigger a refetch
await waitFor(() =>
rendered.getByText('status: success, fetchStatus: paused'),
)
expect(count).toBe(0)
onlineMock.mockRestore()
})
it('online queries should not get stuck in fetching state when pausing multiple times', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
initialData: 'initial',
})
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
const rendered = renderWithClient(queryClient, <Page />)
window.dispatchEvent(new Event('offline'))
await waitFor(() =>
rendered.getByText('status: success, fetchStatus: paused'),
)
await waitFor(() => {
expect(rendered.getByText('data: initial')).toBeInTheDocument()
})
// triggers one pause
fireEvent.click(rendered.getByRole('button', { name: /invalidate/i }))
await sleep(15)
await waitFor(() =>
rendered.getByText('status: success, fetchStatus: paused'),
)
// triggers a second pause
act(() => {
window.dispatchEvent(new Event('visibilitychange'))
})
onlineMock.mockRestore()
act(() => {
window.dispatchEvent(new Event('online'))
})
await waitFor(() =>
rendered.getByText('status: success, fetchStatus: idle'),
)
await waitFor(() => {
expect(rendered.getByText('data: data1')).toBeInTheDocument()
})
expect(count).toBe(1)
})
it('online queries should pause retries if you are offline', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = useQuery<unknown, Error>({
queryKey: key,
queryFn: async (): Promise<unknown> => {
count++
await sleep(10)
throw new Error('failed' + count)
},
retry: 2,
retryDelay: 10,
})
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus},
failureCount: {state.failureCount}
</div>
<div>failureReason: {state.failureReason?.message ?? 'null'}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() =>
rendered.getByText(/status: pending, fetchStatus: fetching/i),
)
const onlineMock = mockOnlineManagerIsOnline(false)
window.dispatchEvent(new Event('offline'))
await sleep(20)
await waitFor(() =>
rendered.getByText(
'status: pending, fetchStatus: paused, failureCount: 1',
),
)
await waitFor(() => rendered.getByText('failureReason: failed1'))
expect(count).toBe(1)
onlineMock.mockReturnValue(true)
window.dispatchEvent(new Event('online'))
await waitFor(() =>
rendered.getByText('status: error, fetchStatus: idle, failureCount: 3'),
)
await waitFor(() => rendered.getByText('failureReason: failed3'))
expect(count).toBe(3)
onlineMock.mockRestore()
})
it('online queries should fetch if paused and we go online even if already unmounted (because not cancelled)', async () => {
const key = queryKey()
let count = 0
function Component() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
})
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
</div>
)
}
function Page() {
const [show, setShow] = React.useState(true)
return (
<div>
{show && <Component />}
<button onClick={() => setShow(false)}>hide</button>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
const rendered = renderWithClient(queryClient, <Page />)
window.dispatchEvent(new Event('offline'))
await waitFor(() =>
rendered.getByText('status: pending, fetchStatus: paused'),
)
fireEvent.click(rendered.getByRole('button', { name: /hide/i }))
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await waitFor(() => {
expect(queryClient.getQueryState(key)).toMatchObject({
fetchStatus: 'idle',
status: 'success',
})
})
// give it a bit more time to make sure queryFn is not called again
await sleep(15)
expect(count).toBe(1)
})
it('online queries should not fetch if paused and we go online when cancelled and no refetchOnReconnect', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
refetchOnReconnect: false,
})
return (
<div>
<button
onClick={() => queryClient.cancelQueries({ queryKey: key })}
>
cancel
</button>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() =>
rendered.getByText('status: pending, fetchStatus: paused'),
)
fireEvent.click(rendered.getByRole('button', { name: /cancel/i }))
await waitFor(() =>
rendered.getByText('status: pending, fetchStatus: idle'),
)
expect(count).toBe(0)
onlineMock.mockReturnValue(true)
window.dispatchEvent(new Event('online'))
await sleep(15)
await waitFor(() =>
rendered.getByText('status: pending, fetchStatus: idle'),
)
expect(count).toBe(0)
onlineMock.mockRestore()
})
it('online queries should not fetch if paused and we go online if already unmounted when signal consumed', async () => {
const key = queryKey()
let count = 0
function Component() {
const state = useQuery({
queryKey: key,
queryFn: async ({ signal: _signal }) => {
count++
await sleep(10)
return `signal${count}`
},
})
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
</div>
)
}
function Page() {
const [show, setShow] = React.useState(true)
return (
<div>
{show && <Component />}
<button onClick={() => setShow(false)}>hide</button>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() =>
rendered.getByText('status: success, fetchStatus: idle'),
)
const onlineMock = mockOnlineManagerIsOnline(false)
fireEvent.click(rendered.getByRole('button', { name: /invalidate/i }))
await waitFor(() =>
rendered.getByText('status: success, fetchStatus: paused'),
)
fireEvent.click(rendered.getByRole('button', { name: /hide/i }))
await sleep(15)
onlineMock.mockReturnValue(true)
window.dispatchEvent(new Event('online'))
await sleep(15)
expect(queryClient.getQueryState(key)).toMatchObject({
fetchStatus: 'idle',
status: 'success',
})
expect(count).toBe(1)
onlineMock.mockRestore()
})
})
describe('networkMode always', () => {
it('always queries should start fetching even if you are offline', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const key = queryKey()
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data ' + count
},
networkMode: 'always',
})
return (
<div>
<div>
status: {state.status}, isPaused: {String(state.isPaused)}
</div>
<div>data: {state.data}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() =>
rendered.getByText('status: success, isPaused: false'),
)
await waitFor(() => {
expect(rendered.getByText('data: data 1')).toBeInTheDocument()
})
onlineMock.mockRestore()
})
it('always queries should not pause retries', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const key = queryKey()
let count = 0
function Page() {
const state = useQuery({
queryKey: key,
queryFn: async (): Promise<unknown> => {
count++
await sleep(10)
throw new Error('error ' + count)
},
networkMode: 'always',
retry: 1,
retryDelay: 5,
})
return (
<div>
<div>
status: {state.status}, isPaused: {String(state.isPaused)}
</div>
<div>
error: {state.error instanceof Error && state.error.message}
</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('status: error, isPaused: false'))
await waitFor(() => {
expect(rendered.getByText('error: error 2')).toBeInTheDocument()
})
expect(count).toBe(2)
onlineMock.mockRestore()
})
})
describe('networkMode offlineFirst', () => {
it('offlineFirst queries should start fetching if you are offline, but pause retries', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const key = queryKey()
let count = 0
function Page() {
const state = useQuery<unknown, Error>({
queryKey: key,
queryFn: async (): Promise<unknown> => {
count++
await sleep(10)
throw new Error('failed' + count)
},
retry: 2,
retryDelay: 1,
networkMode: 'offlineFirst',
})
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus},
failureCount: {state.failureCount}
</div>
<div>failureReason: {state.failureReason?.message ?? 'null'}</div>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
window.dispatchEvent(new Event('offline'))
await waitFor(() =>
rendered.getByText(
'status: pending, fetchStatus: paused, failureCount: 1',
),
)
await waitFor(() => rendered.getByText('failureReason: failed1'))
expect(count).toBe(1)
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await waitFor(() =>
rendered.getByText('status: error, fetchStatus: idle, failureCount: 3'),
)
await waitFor(() => rendered.getByText('failureReason: failed3'))
expect(count).toBe(3)
})
})
it('it should have status=error on mount when a query has failed', async () => {
const key = queryKey()
const states: Array<UseQueryResult<unknown>> = []
const error = new Error('oops')
const queryFn = async (): Promise<unknown> => {
throw error
}
function Page() {
const state = useQuery({
queryKey: key,
queryFn,
retry: false,
retryOnMount: false,
})
states.push(state)
return <></>
}
await queryClient.prefetchQuery({ queryKey: key, queryFn })
renderWithClient(queryClient, <Page />)
await waitFor(() => expect(states).toHaveLength(1))
expect(states[0]).toMatchObject({
status: 'error',
error,
})
})
it('setQueryData - should respect updatedAt', async () => {
const key = queryKey()
function Page() {
const state = useQuery({ queryKey: key, queryFn: () => 'data' })
return (
<div>
<div>data: {state.data}</div>
<div>dataUpdatedAt: {state.dataUpdatedAt}</div>
<button
onClick={() => {
queryClient.setQueryData(key, 'newData', {
updatedAt: 100,
})
}}
>
setQueryData
</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: data'))
fireEvent.click(rendered.getByRole('button', { name: /setQueryData/i }))
await waitFor(() => rendered.getByText('data: newData'))
await waitFor(() => {
expect(rendered.getByText('dataUpdatedAt: 100')).toBeInTheDocument()
})
})
it('errorUpdateCount should increased on each fetch failure', async () => {
const key = queryKey()
const error = new Error('oops')
function Page() {
const { refetch, errorUpdateCount } = useQuery({
queryKey: key,
queryFn: async (): Promise<unknown> => {
throw error
},
retry: false,
})
return (
<div>
<button onClick={() => refetch()}>refetch</button>
<span>data: {errorUpdateCount}</span>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
const fetchBtn = rendered.getByRole('button', { name: 'refetch' })
await waitFor(() => rendered.getByText('data: 1'))
fireEvent.click(fetchBtn)
await waitFor(() => rendered.getByText('data: 2'))
fireEvent.click(fetchBtn)
await waitFor(() => rendered.getByText('data: 3'))
})
it('should use provided custom queryClient', async () => {
const key = queryKey()
const queryFn = async () => {
return Promise.resolve('custom client')
}
function Page() {
const { data } = useQuery(
{
queryKey: key,
queryFn,
},
queryClient,
)
return <div>data: {data}</div>
}
const rendered = render(<Page></Page>)
await waitFor(() => rendered.getByText('data: custom client'))
})
it('should be notified of updates between create and subscribe', async () => {
const key = queryKey()
function Page() {
const mounted = React.useRef<boolean>(false)
const { data, status } = useQuery({
enabled: false,
queryKey: key,
queryFn: async () => {
await sleep(10)
return 5
},
})
// this simulates a synchronous update between the time the query is created
// and the time it is subscribed to that could be missed otherwise
if (!mounted.current) {
mounted.current = true
queryClient.setQueryData(key, 1)
}
return (
<div>
<span>status: {status}</span>
<span>data: {data}</span>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('status: success'))
await waitFor(() => rendered.getByText('data: 1'))
})
it('should reuse same data object reference when queryKey changes back to some cached data', async () => {
const key = queryKey()
const spy = vi.fn()
async function fetchNumber(id: number) {
await sleep(5)
return { numbers: { current: { id } } }
}
function Test() {
const [id, setId] = React.useState(1)
const { data } = useQuery({
select: selector,
queryKey: [key, 'user', id],
queryFn: () => fetchNumber(id),
})
React.useEffect(() => {
spy(data)
}, [data])
return (
<div>
<button name="1" onClick={() => setId(1)}>
1
</button>
<button name="2" onClick={() => setId(2)}>
2
</button>
<span>Rendered Id: {data?.id}</span>
</div>
)
}
function selector(data: any) {
return data.numbers.current
}
const rendered = renderWithClient(queryClient, <Test />)
expect(spy).toHaveBeenCalledTimes(1)
spy.mockClear()
await waitFor(() => rendered.getByText('Rendered Id: 1'))
expect(spy).toHaveBeenCalledTimes(1)
spy.mockClear()
fireEvent.click(rendered.getByRole('button', { name: /2/ }))
await waitFor(() => rendered.getByText('Rendered Id: 2'))
expect(spy).toHaveBeenCalledTimes(2) // called with undefined because id changed
spy.mockClear()
fireEvent.click(rendered.getByRole('button', { name: /1/ }))
await waitFor(() => rendered.getByText('Rendered Id: 1'))
expect(spy).toHaveBeenCalledTimes(1)
spy.mockClear()
fireEvent.click(rendered.getByRole('button', { name: /2/ }))
await waitFor(() => rendered.getByText('Rendered Id: 2'))
expect(spy).toHaveBeenCalledTimes(1)
})
it('should reuse same data object reference when queryKey changes and placeholderData is present', async () => {
const key = queryKey()
const spy = vi.fn()
async function fetchNumber(id: number) {
await sleep(5)
return { numbers: { current: { id } } }
}
function Test() {
const [id, setId] = React.useState(1)
const { data } = useQuery({
select: selector,
queryKey: [key, 'user', id],
queryFn: () => fetchNumber(id),
placeholderData: { numbers: { current: { id: 99 } } },
})
React.useEffect(() => {
spy(data)
}, [data])
return (
<div>
<button name="1" onClick={() => setId(1)}>
1
</button>
<button name="2" onClick={() => setId(2)}>
2
</button>
<span>Rendered Id: {data?.id}</span>
</div>
)
}
function selector(data: any) {
return data.numbers.current
}
const rendered = renderWithClient(queryClient, <Test />)
expect(spy).toHaveBeenCalledTimes(1)
spy.mockClear()
await waitFor(() => rendered.getByText('Rendered Id: 99'))
await waitFor(() => rendered.getByText('Rendered Id: 1'))
expect(spy).toHaveBeenCalledTimes(1)
spy.mockClear()
fireEvent.click(rendered.getByRole('button', { name: /2/ }))
await waitFor(() => rendered.getByText('Rendered Id: 99'))
await waitFor(() => rendered.getByText('Rendered Id: 2'))
expect(spy).toHaveBeenCalledTimes(2) // called with undefined because id changed
spy.mockClear()
fireEvent.click(rendered.getByRole('button', { name: /1/ }))
await waitFor(() => rendered.getByText('Rendered Id: 1'))
expect(spy).toHaveBeenCalledTimes(1)
spy.mockClear()
fireEvent.click(rendered.getByRole('button', { name: /2/ }))
await waitFor(() => rendered.getByText('Rendered Id: 2'))
expect(spy).toHaveBeenCalledTimes(1)
})
it('should not cause an infinite render loop when using unstable callback ref', async () => {
const key = queryKey()
function Test() {
const [_, setRef] = React.useState<HTMLDivElement | null>()
const { data } = useQuery({
queryKey: [key],
queryFn: async () => {
await sleep(5)
return 'Works'
},
})
return <div ref={(value) => setRef(value)}>{data}</div>
}
const rendered = renderWithClient(queryClient, <Test />)
await waitFor(() => rendered.getByText('Works'))
})
it('should keep the previous data when placeholderData is set and cache is used', async () => {
const key = queryKey()
const states: Array<UseQueryResult<number | undefined>> = []
const steps = [0, 1, 0, 2]
function Page() {
const [count, setCount] = React.useState(0)
const state = useQuery({
staleTime: Infinity,
queryKey: [key, steps[count]],
queryFn: async () => {
await sleep(10)
return steps[count]
},
placeholderData: keepPreviousData,
})
states.push(state)
return (
<div>
<div>data: {state.data}</div>
<button onClick={() => setCount((c) => c + 1)}>setCount</button>
</div>
)
}
const rendered = renderWithClient(queryClient, <Page />)
await waitFor(() => rendered.getByText('data: 0'))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
await waitFor(() => rendered.getByText('data: 1'))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
await waitFor(() => rendered.getByText('data: 0'))
fireEvent.click(rendered.getByRole('button', { name: 'setCount' }))
await waitFor(() => rendered.getByText('data: 2'))
// Initial
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isSuccess: false,
isPlaceholderData: false,
})
// Fetched
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[2]).toMatchObject({
data: 0,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// New data
expect(states[3]).toMatchObject({
data: 1,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state with existing data
expect(states[4]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state where the placeholder value should come from cache request
expect(states[5]).toMatchObject({
data: 0,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// New data
expect(states[6]).toMatchObject({
data: 2,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
// For Project without TS, when migrating from v4 to v5, make sure invalid calls due to bad parameters are tracked.
it('should throw in case of bad arguments to enhance DevX', async () => {
// Mock console error to avoid noise when test is run
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const key = queryKey()
const queryFn = () => 'data'
function Page() {
// Invalid call on purpose
// @ts-expect-error
useQuery(key, { queryFn })
return <div>Does not matter</div>
}
expect(() => render(<Page />)).toThrow('Bad argument type')
consoleMock.mockRestore()
})
})
|
3,997 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/useQuery.types.test.tsx | import { describe, it } from 'vitest'
import { useQuery } from '../useQuery'
import { queryOptions } from '../queryOptions'
import { doNotExecute } from './utils'
import type { UseQueryOptions } from '../types'
import type { Equal, Expect } from './utils'
describe('initialData', () => {
describe('Config object overload', () => {
it('TData should always be defined when initialData is provided as an object', () => {
doNotExecute(() => {
const { data } = useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: {
wow: true,
},
})
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('TData should be defined when passed through queryOptions', () => {
doNotExecute(() => {
const options = queryOptions({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: {
wow: true,
},
})
const { data } = useQuery(options)
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('it should be possible to define a different TData than TQueryFnData using select with queryOptions spread into useQuery', () => {
doNotExecute(() => {
const options = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(1),
})
const query = useQuery({
...options,
select: (data) => data > 1,
})
const result: Expect<
Equal<boolean | undefined, (typeof query)['data']>
> = true
return result
})
})
it('TData should always be defined when initialData is provided as a function which ALWAYS returns the data', () => {
doNotExecute(() => {
const { data } = useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: () => ({
wow: true,
}),
})
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('TData should have undefined in the union when initialData is NOT provided', () => {
doNotExecute(() => {
const { data } = useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
})
const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
true
return result
})
})
it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
doNotExecute(() => {
const { data } = useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: () => undefined as { wow: boolean } | undefined,
})
const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
true
return result
})
})
it('TData should be narrowed after an isSuccess check when initialData is provided as a function which can return undefined', () => {
doNotExecute(() => {
const { data, isSuccess } = useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: () => undefined as { wow: boolean } | undefined,
})
if (isSuccess) {
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
}
return false
})
})
})
describe('custom hook', () => {
it('should allow custom hooks using UseQueryOptions', () => {
doNotExecute(() => {
type Data = string
const useCustomQuery = (
options?: Omit<UseQueryOptions<Data>, 'queryKey' | 'queryFn'>,
) => {
return useQuery({
...options,
queryKey: ['todos-key'],
queryFn: () => Promise.resolve('data'),
})
}
const { data } = useCustomQuery()
const result: Expect<Equal<Data | undefined, typeof data>> = true
return result
})
})
})
describe('structuralSharing', () => {
it('should restrict to same types', () => {
doNotExecute(() => {
useQuery({
queryKey: ['key'],
queryFn: () => 5,
structuralSharing: (_oldData, newData) => {
return newData
},
})
})
})
})
})
|
3,998 | 0 | petrpan-code/TanStack/query/packages/react-query/src | petrpan-code/TanStack/query/packages/react-query/src/__tests__/useSuspenseQueries.test.tsx | import {
afterAll,
afterEach,
beforeAll,
describe,
expect,
it,
vi,
} from 'vitest'
import { act, render } from '@testing-library/react'
import React from 'react'
import { useSuspenseQueries } from '..'
import { createQueryClient, sleep } from './utils'
import type { UseSuspenseQueryOptions } from '..'
type NumberQueryOptions = UseSuspenseQueryOptions<number>
const QUERY_DURATION = 1000
const createQuery: (id: number) => NumberQueryOptions = (id) => ({
queryKey: [id],
queryFn: async () => {
await sleep(QUERY_DURATION)
return id
},
})
const resolveQueries = () => vi.advanceTimersByTimeAsync(QUERY_DURATION)
const queryClient = createQueryClient()
describe('useSuspenseQueries', () => {
const onSuspend = vi.fn()
const onQueriesResolution = vi.fn()
beforeAll(() => {
vi.useFakeTimers()
})
afterAll(() => {
vi.useRealTimers()
})
afterEach(() => {
queryClient.clear()
onSuspend.mockClear()
onQueriesResolution.mockClear()
})
function SuspenseFallback() {
React.useEffect(() => {
onSuspend()
}, [])
return null
}
const withSuspenseWrapper = <T extends object>(Component: React.FC<T>) => {
function SuspendedComponent(props: T) {
return (
<React.Suspense fallback={<SuspenseFallback />}>
<Component {...props} />
</React.Suspense>
)
}
return SuspendedComponent
}
function QueriesContainer({
queries,
}: {
queries: Array<NumberQueryOptions>
}) {
const queriesResults = useSuspenseQueries(
{ queries, combine: (results) => results.map((r) => r.data) },
queryClient,
)
React.useEffect(() => {
onQueriesResolution(queriesResults)
}, [queriesResults])
return null
}
const TestComponent = withSuspenseWrapper(QueriesContainer)
it('should suspend on mount', () => {
render(<TestComponent queries={[1, 2].map(createQuery)} />)
expect(onSuspend).toHaveBeenCalledOnce()
})
it('should resolve queries', async () => {
render(<TestComponent queries={[1, 2].map(createQuery)} />)
await act(resolveQueries)
expect(onQueriesResolution).toHaveBeenCalledTimes(1)
expect(onQueriesResolution).toHaveBeenLastCalledWith([1, 2])
})
it('should not suspend on mount if query has been already fetched', () => {
const query = createQuery(1)
queryClient.setQueryData(query.queryKey, query.queryFn)
render(<TestComponent queries={[query]} />)
expect(onSuspend).not.toHaveBeenCalled()
})
it('should not break suspense when queries change without resolving', async () => {
const initQueries = [1, 2].map(createQuery)
const nextQueries = [3, 4, 5, 6].map(createQuery)
const { rerender } = render(<TestComponent queries={initQueries} />)
rerender(<TestComponent queries={nextQueries} />)
await act(resolveQueries)
expect(onSuspend).toHaveBeenCalledTimes(1)
expect(onQueriesResolution).toHaveBeenCalledTimes(1)
expect(onQueriesResolution).toHaveBeenLastCalledWith([3, 4, 5, 6])
})
it('should suspend only once per queries change', async () => {
const initQueries = [1, 2].map(createQuery)
const nextQueries = [3, 4, 5, 6].map(createQuery)
const { rerender } = render(<TestComponent queries={initQueries} />)
await act(resolveQueries)
rerender(<TestComponent queries={nextQueries} />)
await act(resolveQueries)
expect(onSuspend).toHaveBeenCalledTimes(2)
expect(onQueriesResolution).toHaveBeenCalledTimes(2)
expect(onQueriesResolution).toHaveBeenLastCalledWith([3, 4, 5, 6])
})
})
|
4,016 | 0 | petrpan-code/TanStack/query/packages/solid-query-persist-client/src | petrpan-code/TanStack/query/packages/solid-query-persist-client/src/__tests__/PersistQueryClientProvider.test.tsx | import { describe, expect, test, vi } from 'vitest'
import { render, screen, waitFor } from '@solidjs/testing-library'
import { QueryClient, createQueries, createQuery } from '@tanstack/solid-query'
import { persistQueryClientSave } from '@tanstack/query-persist-client-core'
import { createEffect, createSignal, onMount } from 'solid-js'
import { PersistQueryClientProvider } from '../PersistQueryClientProvider'
import { createQueryClient, queryKey, sleep } from './utils'
import type {
PersistedClient,
Persister,
} from '@tanstack/query-persist-client-core'
const createMockPersister = (): Persister => {
let storedState: PersistedClient | undefined
return {
async persistClient(persistClient: PersistedClient) {
storedState = persistClient
},
async restoreClient() {
await sleep(10)
return storedState
},
removeClient() {
storedState = undefined
},
}
}
const createMockErrorPersister = (
removeClient: Persister['removeClient'],
): [Error, Persister] => {
const error = new Error('restore failed')
return [
error,
{
async persistClient() {
// noop
},
async restoreClient() {
await sleep(10)
throw error
},
removeClient,
},
]
}
describe('PersistQueryClientProvider', () => {
test('restores cache from persister', async () => {
const key = queryKey()
const states: Array<{
status: string
fetchStatus: string
data: string | undefined
}> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
}))
createEffect(() =>
states.push({
status: state.status,
fetchStatus: state.fetchStatus,
data: state.data,
}),
)
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
render(() => (
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>
))
await waitFor(() => screen.getByText('fetchStatus: idle'))
await waitFor(() => screen.getByText('hydrated'))
await waitFor(() => screen.getByText('fetched'))
expect(states).toHaveLength(3)
expect(states[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[2]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'fetched',
})
})
test('should also put useQueries into idle state', async () => {
const key = queryKey()
const states: Array<{
status: string
fetchStatus: string
data: string | undefined
}> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const [state] = createQueries(() => ({
queries: [
{
queryKey: key,
queryFn: async (): Promise<string> => {
await sleep(10)
return 'fetched'
},
},
] as const,
}))
createEffect(() =>
states.push({
status: state.status,
fetchStatus: state.fetchStatus,
data: state.data,
}),
)
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
render(() => (
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>
))
await waitFor(() => screen.getByText('fetchStatus: idle'))
await waitFor(() => screen.getByText('hydrated'))
await waitFor(() => screen.getByText('fetched'))
expect(states).toHaveLength(3)
expect(states[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[2]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'fetched',
})
})
test('should show initialData while restoring', async () => {
const key = queryKey()
const states: Array<{
status: string
fetchStatus: string
data: string | undefined
}> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
initialData: 'initial',
// make sure that initial data is older than the hydration data
// otherwise initialData would be newer and takes precedence
initialDataUpdatedAt: 1,
}))
createEffect(() =>
states.push({
status: state.status,
fetchStatus: state.fetchStatus,
data: state.data,
}),
)
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
render(() => (
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>
))
await waitFor(() => screen.getByText('initial'))
await waitFor(() => screen.getByText('hydrated'))
await waitFor(() => screen.getByText('fetched'))
expect(states).toHaveLength(3)
expect(states[0]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'initial',
})
expect(states[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[2]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'fetched',
})
})
test('should not refetch after restoring when data is fresh', async () => {
const key = queryKey()
const states: Array<{
status: string
fetchStatus: string
data: string | undefined
}> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
let fetched = false
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
fetched = true
await sleep(10)
return 'fetched'
},
staleTime: Infinity,
}))
createEffect(
() =>
states.push({
status: state.status,
fetchStatus: state.fetchStatus,
data: state.data,
}),
console.log(state.data),
)
return (
<div>
<h1>data: {state.data ?? 'null'}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
render(() => (
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>
))
await waitFor(() => screen.getByText('data: null'))
await waitFor(() => screen.getByText('data: hydrated'))
expect(states).toHaveLength(2)
expect(fetched).toBe(false)
expect(states[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states[1]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'hydrated',
})
})
test('should call onSuccess after successful restoring', async () => {
const key = queryKey()
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
}))
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
const onSuccess = vi.fn()
render(() => (
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
onSuccess={onSuccess}
>
<Page />
</PersistQueryClientProvider>
))
expect(onSuccess).toHaveBeenCalledTimes(0)
await waitFor(() => screen.getByText('hydrated'))
expect(onSuccess).toHaveBeenCalledTimes(1)
await waitFor(() => screen.getByText('fetched'))
})
test('should remove cache after non-successful restoring', async () => {
const key = queryKey()
const onErrorMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
const queryClient = createQueryClient()
const removeClient = vi.fn()
const [error, persister] = createMockErrorPersister(removeClient)
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
}))
return (
<div>
<h1>{state.data}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
render(() => (
<PersistQueryClientProvider
client={queryClient}
persistOptions={{ persister }}
>
<Page />
</PersistQueryClientProvider>
))
await waitFor(() => screen.getByText('fetched'))
expect(removeClient).toHaveBeenCalledTimes(1)
expect(onErrorMock).toHaveBeenCalledTimes(1)
expect(onErrorMock).toHaveBeenNthCalledWith(1, error)
onErrorMock.mockRestore()
})
test('should be able to persist into multiple clients', async () => {
const key = queryKey()
const states: Array<{
status: string
fetchStatus: string
data: string | undefined
}> = []
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
const onSuccess = vi.fn()
const queryFn1 = vi.fn().mockImplementation(async () => {
await sleep(10)
return 'queryFn1'
})
const queryFn2 = vi.fn().mockImplementation(async () => {
await sleep(10)
return 'queryFn2'
})
function App() {
const [client, setClient] = createSignal(
new QueryClient({
defaultOptions: {
queries: {
queryFn: queryFn1,
},
},
}),
)
onMount(() => {
setClient(
new QueryClient({
defaultOptions: {
queries: {
queryFn: queryFn2,
},
},
}),
)
})
return (
<PersistQueryClientProvider
client={client()}
persistOptions={{ persister }}
onSuccess={onSuccess}
>
<Page />
</PersistQueryClientProvider>
)
}
function Page() {
const state = createQuery(() => ({ queryKey: key }))
createEffect(() =>
states.push({
status: state.status,
fetchStatus: state.fetchStatus,
data: state.data as string | undefined,
}),
)
return (
<div>
<h1>{String(state.data)}</h1>
<h2>fetchStatus: {state.fetchStatus}</h2>
</div>
)
}
render(() => <App />)
await waitFor(() => screen.getByText('hydrated'))
await waitFor(() => screen.getByText('queryFn2'))
expect(queryFn1).toHaveBeenCalledTimes(0)
expect(queryFn2).toHaveBeenCalledTimes(1)
expect(onSuccess).toHaveBeenCalledTimes(1)
expect(states).toHaveLength(3)
expect(states[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states[2]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'queryFn2',
})
})
})
|
4,039 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/QueryClientProvider.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { render, screen, waitFor } from '@solidjs/testing-library'
import { QueryCache } from '@tanstack/query-core'
import { QueryClientProvider, createQuery, useQueryClient } from '..'
import { createQueryClient, queryKey, sleep } from './utils'
describe('QueryClientProvider', () => {
it('sets a specific cache for all queries to use', async () => {
const key = queryKey()
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
function Page() {
const query = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
}))
return (
<div>
<h1>{query.data}</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => {
return screen.getByText('test')
})
expect(queryCache.find({ queryKey: key })).toBeDefined()
})
it('allows multiple caches to be partitioned', async () => {
const key1 = queryKey()
const key2 = queryKey()
const queryCache1 = new QueryCache()
const queryCache2 = new QueryCache()
const queryClient1 = createQueryClient({ queryCache: queryCache1 })
const queryClient2 = createQueryClient({ queryCache: queryCache2 })
function Page1() {
const query = createQuery(() => ({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 'test1'
},
}))
return (
<div>
<h1>{query.data}</h1>
</div>
)
}
function Page2() {
const query = createQuery(() => ({
queryKey: key2,
queryFn: async () => {
await sleep(10)
return 'test2'
},
}))
return (
<div>
<h1>{query.data}</h1>
</div>
)
}
render(() => (
<>
<QueryClientProvider client={queryClient1}>
<Page1 />
</QueryClientProvider>
<QueryClientProvider client={queryClient2}>
<Page2 />
</QueryClientProvider>
</>
))
await waitFor(() => screen.getByText('test1'))
await waitFor(() => screen.getByText('test2'))
expect(queryCache1.find({ queryKey: key1 })).toBeDefined()
expect(queryCache1.find({ queryKey: key2 })).not.toBeDefined()
expect(queryCache2.find({ queryKey: key1 })).not.toBeDefined()
expect(queryCache2.find({ queryKey: key2 })).toBeDefined()
})
it("uses defaultOptions for queries when they don't provide their own config", async () => {
const key = queryKey()
const queryCache = new QueryCache()
const queryClient = createQueryClient({
queryCache,
defaultOptions: {
queries: {
gcTime: Infinity,
},
},
})
function Page() {
const query = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
}))
return (
<div>
<h1>{query.data}</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('test'))
expect(queryCache.find({ queryKey: key })).toBeDefined()
expect(queryCache.find({ queryKey: key })?.options.gcTime).toBe(Infinity)
})
describe('useQueryClient', () => {
it('should throw an error if no query client has been set', () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
useQueryClient()
return null
}
expect(() => render(() => <Page />)).toThrow(
'No QueryClient set, use QueryClientProvider to set one',
)
consoleMock.mockRestore()
})
})
it('should not throw an error if user provides custom query client', () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const client = createQueryClient()
useQueryClient(client)
return null
}
render(() => <Page />)
expect(consoleMock).not.toHaveBeenCalled()
consoleMock.mockRestore()
})
})
|
4,040 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/createInfiniteQuery.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library'
import {
For,
Index,
Match,
Switch,
createEffect,
createRenderEffect,
createSignal,
on,
} from 'solid-js'
import {
QueryCache,
QueryClientProvider,
createInfiniteQuery,
keepPreviousData,
} from '..'
import {
Blink,
createQueryClient,
queryKey,
setActTimeout,
sleep,
} from './utils'
import type {
CreateInfiniteQueryResult,
InfiniteData,
QueryFunctionContext,
} from '..'
import type { Mock } from 'vitest'
interface Result {
items: Array<number>
nextId?: number
prevId?: number
ts: number
}
const pageSize = 10
const fetchItems = async (
page: number,
ts: number,
noNext?: boolean,
noPrev?: boolean,
): Promise<Result> => {
await sleep(10)
return {
items: [...new Array(10)].fill(null).map((_, d) => page * pageSize + d),
nextId: noNext ? undefined : page + 1,
prevId: noPrev ? undefined : page - 1,
ts,
}
}
describe('useInfiniteQuery', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should return the correct states for a successful query', async () => {
const key = queryKey()
const states: Array<CreateInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: ({ pageParam }) => Number(pageParam),
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: 0,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
fetchNextPage: expect.any(Function),
fetchPreviousPage: expect.any(Function),
hasNextPage: false,
hasPreviousPage: false,
isError: false,
isFetched: false,
isFetchedAfterMount: false,
isFetching: true,
isPaused: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isPending: true,
isLoading: true,
isInitialLoading: true,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'pending',
fetchStatus: 'fetching',
})
expect(states[1]).toEqual({
data: { pages: [0], pageParams: [0] },
dataUpdatedAt: expect.any(Number),
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
fetchNextPage: expect.any(Function),
fetchPreviousPage: expect.any(Function),
hasNextPage: true,
hasPreviousPage: false,
isError: false,
isFetched: true,
isFetchedAfterMount: true,
isFetching: false,
isPaused: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isPending: false,
isLoading: false,
isInitialLoading: false,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: true,
refetch: expect.any(Function),
status: 'success',
fetchStatus: 'idle',
})
})
it('should not throw when fetchNextPage returns an error', async () => {
const key = queryKey()
let noThrow: boolean
function Page() {
const start = 1
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: async ({ pageParam }) => {
if (pageParam === 2) {
throw new Error('error')
}
return Number(pageParam)
},
retry: 1,
retryDelay: 10,
initialPageParam: start,
getNextPageParam: (lastPage) => lastPage + 1,
}))
createEffect(() => {
const fetchNextPage = state.fetchNextPage
setActTimeout(() => {
fetchNextPage()
.then(() => {
noThrow = true
})
.catch(() => undefined)
}, 20)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => expect(noThrow).toBe(true))
})
it('should keep the previous data when placeholderData is set', async () => {
const key = queryKey()
const states: Array<
Partial<CreateInfiniteQueryResult<InfiniteData<string>>>
> = []
function Page() {
const [order, setOrder] = createSignal('desc')
const state = createInfiniteQuery(() => ({
queryKey: [key, order()],
queryFn: async ({ pageParam }) => {
await sleep(10)
return `${pageParam}-${order()}`
},
getNextPageParam: () => 1,
initialPageParam: 0,
placeholderData: keepPreviousData,
notifyOnChangeProps: 'all',
}))
createRenderEffect(() => {
states.push({
data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
hasNextPage: state.hasNextPage,
hasPreviousPage: state.hasPreviousPage,
isFetching: state.isFetching,
isFetchingNextPage: state.isFetchingNextPage,
isFetchingPreviousPage: state.isFetchingPreviousPage,
isSuccess: state.isSuccess,
isPlaceholderData: state.isPlaceholderData,
})
})
return (
<div>
<button onClick={() => state.fetchNextPage()}>fetchNextPage</button>
<button onClick={() => setOrder('asc')}>order</button>
<div>data: {state.data?.pages.join(',') ?? 'null'}</div>
<div>isFetching: {String(state.isFetching)}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: 0-desc'))
fireEvent.click(screen.getByRole('button', { name: /fetchNextPage/i }))
await waitFor(() => screen.getByText('data: 0-desc,1-desc'))
fireEvent.click(screen.getByRole('button', { name: /order/i }))
await waitFor(() => screen.getByText('data: 0-asc'))
await waitFor(() => screen.getByText('isFetching: false'))
await waitFor(() => expect(states.length).toBe(6))
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
isPlaceholderData: false,
})
expect(states[1]).toMatchObject({
data: { pages: ['0-desc'] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
isPlaceholderData: false,
})
expect(states[2]).toMatchObject({
data: { pages: ['0-desc'] },
isFetching: true,
isFetchingNextPage: true,
isSuccess: true,
isPlaceholderData: false,
})
expect(states[3]).toMatchObject({
data: { pages: ['0-desc', '1-desc'] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[4]).toMatchObject({
data: { pages: ['0-desc', '1-desc'] },
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
isPlaceholderData: true,
})
expect(states[5]).toMatchObject({
data: { pages: ['0-asc'] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should be able to select a part of the data', async () => {
const key = queryKey()
const states: Array<CreateInfiniteQueryResult<InfiniteData<string>>> = []
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: () => ({ count: 1 }),
select: (data) => ({
pages: data.pages.map((x) => `count: ${x.count}`),
pageParams: data.pageParams,
}),
getNextPageParam: () => undefined,
initialPageParam: 0,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: ['count: 1'] },
isSuccess: true,
})
})
it('should be able to select a new result and not cause infinite renders', async () => {
const key = queryKey()
const states: Array<
CreateInfiniteQueryResult<InfiniteData<{ count: number; id: number }>>
> = []
let selectCalled = 0
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: () => ({ count: 1 }),
select: (data: InfiniteData<{ count: number }>) => {
selectCalled++
return {
pages: data.pages.map((x) => ({ ...x, id: Math.random() })),
pageParams: data.pageParams,
}
},
getNextPageParam: () => undefined,
initialPageParam: 0,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(20)
expect(states.length).toBe(2)
expect(selectCalled).toBe(1)
expect(states[0]).toMatchObject({
data: undefined,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: [{ count: 1 }] },
isSuccess: true,
})
})
it('should be able to reverse the data', async () => {
const key = queryKey()
const states: Array<
Partial<CreateInfiniteQueryResult<InfiniteData<number>>>
> = []
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam)
},
select: (data) => ({
pages: [...data.pages].reverse(),
pageParams: [...data.pageParams].reverse(),
}),
notifyOnChangeProps: 'all',
getNextPageParam: () => 1,
initialPageParam: 0,
}))
createRenderEffect(
on(
() => ({ ...state }),
() => {
states.push({
data: state.data
? JSON.parse(JSON.stringify(state.data))
: undefined,
isSuccess: state.isSuccess,
})
},
),
)
return (
<div>
<button onClick={() => state.fetchNextPage()}>fetchNextPage</button>
<div>data: {state.data?.pages.join(',') ?? 'null'}</div>
<div>isFetching: {state.isFetching}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: 0'))
fireEvent.click(screen.getByRole('button', { name: /fetchNextPage/i }))
await waitFor(() => screen.getByText('data: 1,0'))
await waitFor(() => expect(states.length).toBe(4))
expect(states[0]).toMatchObject({
data: undefined,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: [0] },
isSuccess: true,
})
expect(states[2]).toMatchObject({
data: { pages: [0] },
isSuccess: true,
})
expect(states[3]).toMatchObject({
data: { pages: [1, 0] },
isSuccess: true,
})
})
it('should be able to fetch a previous page', async () => {
const key = queryKey()
const states: Array<
Partial<CreateInfiniteQueryResult<InfiniteData<number>>>
> = []
function Page() {
const start = 10
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam)
},
getNextPageParam: (lastPage) => lastPage + 1,
getPreviousPageParam: (firstPage) => firstPage - 1,
initialPageParam: start,
notifyOnChangeProps: 'all',
}))
createRenderEffect(() => {
states.push({
data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
hasNextPage: state.hasNextPage,
hasPreviousPage: state.hasPreviousPage,
isFetching: state.isFetching,
isFetchingNextPage: state.isFetchingNextPage,
isFetchingPreviousPage: state.isFetchingPreviousPage,
isSuccess: state.isSuccess,
})
})
createEffect(() => {
const fetchPreviousPage = state.fetchPreviousPage
setActTimeout(() => {
fetchPreviousPage()
}, 20)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(4)
expect(states[0]).toMatchObject({
data: undefined,
hasNextPage: false,
hasPreviousPage: false,
isFetching: true,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: [10] },
hasNextPage: true,
hasPreviousPage: true,
isFetching: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isSuccess: true,
})
expect(states[2]).toMatchObject({
data: { pages: [10] },
hasNextPage: true,
hasPreviousPage: true,
isFetching: true,
isFetchingNextPage: false,
isFetchingPreviousPage: true,
isSuccess: true,
})
expect(states[3]).toMatchObject({
data: { pages: [9, 10] },
hasNextPage: true,
hasPreviousPage: true,
isFetching: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isSuccess: true,
})
})
it('should be able to refetch when providing page params automatically', async () => {
const key = queryKey()
const states: Array<
Partial<CreateInfiniteQueryResult<InfiniteData<number>>>
> = []
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam)
},
getPreviousPageParam: (firstPage) => firstPage - 1,
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: 10,
notifyOnChangeProps: 'all',
}))
createRenderEffect(() => {
states.push({
data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
isFetching: state.isFetching,
isFetchingNextPage: state.isFetchingNextPage,
isRefetching: state.isRefetching,
isFetchingPreviousPage: state.isFetchingPreviousPage,
})
})
return (
<div>
<button onClick={() => state.fetchNextPage()}>fetchNextPage</button>
<button onClick={() => state.fetchPreviousPage()}>
fetchPreviousPage
</button>
<button onClick={() => state.refetch()}>refetch</button>
<div>data: {state.data?.pages.join(',') ?? 'null'}</div>
<div>isFetching: {String(state.isFetching)}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: 10'))
fireEvent.click(screen.getByRole('button', { name: /fetchNextPage/i }))
await waitFor(() => screen.getByText('data: 10,11'))
fireEvent.click(screen.getByRole('button', { name: /fetchPreviousPage/i }))
await waitFor(() => screen.getByText('data: 9,10,11'))
fireEvent.click(screen.getByRole('button', { name: /refetch/i }))
await waitFor(() => screen.getByText('isFetching: false'))
await waitFor(() => expect(states.length).toBe(8))
// Initial fetch
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isFetchingNextPage: false,
isRefetching: false,
})
// Initial fetch done
expect(states[1]).toMatchObject({
data: { pages: [10] },
isFetching: false,
isFetchingNextPage: false,
isRefetching: false,
})
// Fetch next page
expect(states[2]).toMatchObject({
data: { pages: [10] },
isFetching: true,
isFetchingNextPage: true,
isRefetching: false,
})
// Fetch next page done
expect(states[3]).toMatchObject({
data: { pages: [10, 11] },
isFetching: false,
isFetchingNextPage: false,
isRefetching: false,
})
// Fetch previous page
expect(states[4]).toMatchObject({
data: { pages: [10, 11] },
isFetching: true,
isFetchingNextPage: false,
isFetchingPreviousPage: true,
isRefetching: false,
})
// Fetch previous page done
expect(states[5]).toMatchObject({
data: { pages: [9, 10, 11] },
isFetching: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isRefetching: false,
})
// Refetch
expect(states[6]).toMatchObject({
data: { pages: [9, 10, 11] },
isFetching: true,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isRefetching: true,
})
// Refetch done
expect(states[7]).toMatchObject({
data: { pages: [9, 10, 11] },
isFetching: false,
isFetchingNextPage: false,
isFetchingPreviousPage: false,
isRefetching: false,
})
})
it('should silently cancel any ongoing fetch when fetching more', async () => {
const key = queryKey()
const states: Array<
Partial<CreateInfiniteQueryResult<InfiniteData<number>>>
> = []
function Page() {
const start = 10
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(50)
return Number(pageParam)
},
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: start,
notifyOnChangeProps: 'all',
}))
createRenderEffect(() => {
states.push({
hasNextPage: state.hasNextPage,
data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
isFetching: state.isFetching,
isFetchingNextPage: state.isFetchingNextPage,
isSuccess: state.isSuccess,
})
})
createEffect(() => {
const { refetch, fetchNextPage } = state
setActTimeout(() => {
refetch()
}, 100)
setActTimeout(() => {
fetchNextPage()
}, 110)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(300)
expect(states.length).toBe(5)
expect(states[0]).toMatchObject({
hasNextPage: false,
data: undefined,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
})
expect(states[1]).toMatchObject({
hasNextPage: true,
data: { pages: [10] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[2]).toMatchObject({
hasNextPage: true,
data: { pages: [10] },
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[3]).toMatchObject({
hasNextPage: true,
data: { pages: [10] },
isFetching: true,
isFetchingNextPage: true,
isSuccess: true,
})
expect(states[4]).toMatchObject({
hasNextPage: true,
data: { pages: [10, 11] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should silently cancel an ongoing fetchNextPage request when another fetchNextPage is invoked', async () => {
const key = queryKey()
const start = 10
const onAborts: Array<Mock<any, any>> = []
const abortListeners: Array<Mock<any, any>> = []
const fetchPage = vi.fn<
[QueryFunctionContext<typeof key, number>],
Promise<number>
>(async ({ pageParam, signal }) => {
const onAbort = vi.fn()
const abortListener = vi.fn()
onAborts.push(onAbort)
abortListeners.push(abortListener)
signal.onabort = onAbort
signal.addEventListener('abort', abortListener)
await sleep(50)
return Number(pageParam)
})
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: fetchPage,
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: start,
}))
createEffect(() => {
const { fetchNextPage } = state
setActTimeout(() => {
fetchNextPage()
}, 100)
setActTimeout(() => {
fetchNextPage()
}, 110)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(300)
const expectedCallCount = 3
expect(fetchPage).toBeCalledTimes(expectedCallCount)
expect(onAborts).toHaveLength(expectedCallCount)
expect(abortListeners).toHaveLength(expectedCallCount)
let callIndex = 0
const firstCtx = fetchPage.mock.calls[callIndex]![0]
expect(firstCtx.pageParam).toEqual(start)
expect(firstCtx.queryKey).toEqual(key)
expect(firstCtx.signal).toBeInstanceOf(AbortSignal)
expect(firstCtx.signal.aborted).toBe(false)
expect(onAborts[callIndex]).not.toHaveBeenCalled()
expect(abortListeners[callIndex]).not.toHaveBeenCalled()
callIndex = 1
const secondCtx = fetchPage.mock.calls[callIndex]![0]
expect(secondCtx.pageParam).toBe(11)
expect(secondCtx.queryKey).toEqual(key)
expect(secondCtx.signal).toBeInstanceOf(AbortSignal)
expect(secondCtx.signal.aborted).toBe(true)
expect(onAborts[callIndex]).toHaveBeenCalledTimes(1)
expect(abortListeners[callIndex]).toHaveBeenCalledTimes(1)
callIndex = 2
const thirdCtx = fetchPage.mock.calls[callIndex]![0]
expect(thirdCtx.pageParam).toBe(11)
expect(thirdCtx.queryKey).toEqual(key)
expect(thirdCtx.signal).toBeInstanceOf(AbortSignal)
expect(thirdCtx.signal.aborted).toBe(false)
expect(onAborts[callIndex]).not.toHaveBeenCalled()
expect(abortListeners[callIndex]).not.toHaveBeenCalled()
})
it('should not cancel an ongoing fetchNextPage request when another fetchNextPage is invoked if `cancelRefetch: false` is used ', async () => {
const key = queryKey()
const start = 10
const onAborts: Array<Mock<any, any>> = []
const abortListeners: Array<Mock<any, any>> = []
const fetchPage = vi.fn<
[QueryFunctionContext<typeof key, number>],
Promise<number>
>(async ({ pageParam, signal }) => {
const onAbort = vi.fn()
const abortListener = vi.fn()
onAborts.push(onAbort)
abortListeners.push(abortListener)
signal.onabort = onAbort
signal.addEventListener('abort', abortListener)
await sleep(50)
return Number(pageParam)
})
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: fetchPage,
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: start,
}))
createEffect(() => {
const { fetchNextPage } = state
setActTimeout(() => {
fetchNextPage()
}, 100)
setActTimeout(() => {
fetchNextPage({ cancelRefetch: false })
}, 110)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(300)
const expectedCallCount = 2
expect(fetchPage).toBeCalledTimes(expectedCallCount)
expect(onAborts).toHaveLength(expectedCallCount)
expect(abortListeners).toHaveLength(expectedCallCount)
let callIndex = 0
const firstCtx = fetchPage.mock.calls[callIndex]![0]
expect(firstCtx.pageParam).toEqual(start)
expect(firstCtx.queryKey).toEqual(key)
expect(firstCtx.signal).toBeInstanceOf(AbortSignal)
expect(firstCtx.signal.aborted).toBe(false)
expect(onAborts[callIndex]).not.toHaveBeenCalled()
expect(abortListeners[callIndex]).not.toHaveBeenCalled()
callIndex = 1
const secondCtx = fetchPage.mock.calls[callIndex]![0]
expect(secondCtx.pageParam).toBe(11)
expect(secondCtx.queryKey).toEqual(key)
expect(secondCtx.signal).toBeInstanceOf(AbortSignal)
expect(secondCtx.signal.aborted).toBe(false)
expect(onAborts[callIndex]).not.toHaveBeenCalled()
expect(abortListeners[callIndex]).not.toHaveBeenCalled()
})
it('should keep fetching first page when not loaded yet and triggering fetch more', async () => {
const key = queryKey()
const states: Array<CreateInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const start = 10
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(50)
return Number(pageParam)
},
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: start,
notifyOnChangeProps: 'all',
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(() => {
const { fetchNextPage } = state
setActTimeout(() => {
fetchNextPage()
}, 10)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
hasNextPage: false,
data: undefined,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
})
expect(states[1]).toMatchObject({
hasNextPage: true,
data: { pages: [10] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should stop fetching additional pages when the component is unmounted and AbortSignal is consumed', async () => {
const key = queryKey()
let fetches = 0
const initialData = { pages: [1, 2, 3, 4], pageParams: [0, 1, 2, 3] }
function List() {
createInfiniteQuery(() => ({
queryKey: key,
queryFn: async ({ pageParam, signal: _ }) => {
fetches++
await sleep(50)
return Number(pageParam) * 10
},
initialData,
getNextPageParam: (_, allPages) => {
return allPages.length === 4 ? undefined : allPages.length
},
initialPageParam: 0,
}))
return null
}
function Page() {
const [show, setShow] = createSignal(true)
createEffect(() => {
setActTimeout(() => {
setShow(false)
}, 75)
})
return <>{show() ? <List /> : null}</>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(300)
expect(fetches).toBe(2)
expect(queryClient.getQueryState(key)).toMatchObject({
data: initialData,
status: 'success',
error: null,
})
})
it('should be able to set new pages with the query client', async () => {
const key = queryKey()
const states: Array<
Partial<CreateInfiniteQueryResult<InfiniteData<number>>>
> = []
function Page() {
const [firstPage, setFirstPage] = createSignal(0)
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam)
},
getNextPageParam: (lastPage) => lastPage + 1,
notifyOnChangeProps: 'all',
initialPageParam: firstPage(),
}))
createRenderEffect(() => {
states.push({
hasNextPage: state.hasNextPage,
data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
isFetching: state.isFetching,
isFetchingNextPage: state.isFetchingNextPage,
isSuccess: state.isSuccess,
})
})
createEffect(() => {
const { refetch } = state
setActTimeout(() => {
queryClient.setQueryData(key, { pages: [7, 8], pageParams: [7, 8] })
setFirstPage(7)
}, 20)
setActTimeout(() => {
refetch()
}, 50)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(5)
expect(states[0]).toMatchObject({
hasNextPage: false,
data: undefined,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
})
// After first fetch
expect(states[1]).toMatchObject({
hasNextPage: true,
data: { pages: [0] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
// Set state
expect(states[2]).toMatchObject({
hasNextPage: true,
data: { pages: [7, 8] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
// Refetch
expect(states[3]).toMatchObject({
hasNextPage: true,
data: { pages: [7, 8] },
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
})
// Refetch done
expect(states[4]).toMatchObject({
hasNextPage: true,
data: { pages: [7, 8] },
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should only refetch the first page when initialData is provided', async () => {
const key = queryKey()
const states: Array<
Partial<CreateInfiniteQueryResult<InfiniteData<number>>>
> = []
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: async ({ pageParam }): Promise<number> => {
await sleep(10)
return pageParam
},
initialData: { pages: [1], pageParams: [1] },
getNextPageParam: (lastPage) => lastPage + 1,
initialPageParam: 0,
notifyOnChangeProps: 'all',
}))
createRenderEffect(() => {
states.push({
data: JSON.parse(JSON.stringify(state.data)),
hasNextPage: state.hasNextPage,
isFetching: state.isFetching,
isFetchingNextPage: state.isFetchingNextPage,
isSuccess: state.isSuccess,
})
})
createEffect(() => {
const { fetchNextPage } = state
setActTimeout(() => {
fetchNextPage()
}, 20)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(4)
expect(states[0]).toMatchObject({
data: { pages: [1] },
hasNextPage: true,
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[1]).toMatchObject({
data: { pages: [1] },
hasNextPage: true,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[2]).toMatchObject({
data: { pages: [1] },
hasNextPage: true,
isFetching: true,
isFetchingNextPage: true,
isSuccess: true,
})
expect(states[3]).toMatchObject({
data: { pages: [1, 2] },
hasNextPage: true,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should set hasNextPage to false if getNextPageParam returns undefined', async () => {
const key = queryKey()
const states: Array<CreateInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: ({ pageParam }) => Number(pageParam),
initialPageParam: 1,
getNextPageParam: () => undefined,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
hasNextPage: false,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: [1] },
hasNextPage: false,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should compute hasNextPage correctly using initialData', async () => {
const key = queryKey()
const states: Array<CreateInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: ({ pageParam }): number => pageParam,
initialPageParam: 10,
initialData: { pages: [10], pageParams: [10] },
getNextPageParam: (lastPage) => (lastPage === 10 ? 11 : undefined),
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: { pages: [10] },
hasNextPage: true,
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[1]).toMatchObject({
data: { pages: [10] },
hasNextPage: true,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should compute hasNextPage correctly for falsy getFetchMore return value using initialData', async () => {
const key = queryKey()
const states: Array<CreateInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: ({ pageParam }): number => pageParam,
initialPageParam: 10,
initialData: { pages: [10], pageParams: [10] },
getNextPageParam: () => undefined,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: { pages: [10] },
hasNextPage: false,
isFetching: true,
isFetchingNextPage: false,
isSuccess: true,
})
expect(states[1]).toMatchObject({
data: { pages: [10] },
hasNextPage: false,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should not use selected data when computing hasNextPage', async () => {
const key = queryKey()
const states: Array<CreateInfiniteQueryResult<InfiniteData<string>>> = []
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: ({ pageParam }) => Number(pageParam),
initialPageParam: 1,
getNextPageParam: (lastPage) => (lastPage === 1 ? 2 : undefined),
select: (data) => ({
pages: data.pages.map((x) => x.toString()),
pageParams: data.pageParams,
}),
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
hasNextPage: false,
isFetching: true,
isFetchingNextPage: false,
isSuccess: false,
})
expect(states[1]).toMatchObject({
data: { pages: ['1'] },
hasNextPage: true,
isFetching: false,
isFetchingNextPage: false,
isSuccess: true,
})
})
it('should build fresh cursors on refetch', async () => {
const key = queryKey()
const genItems = (size: number) =>
[...new Array(size)].fill(null).map((_, d) => d)
const items = genItems(15)
const limit = 3
const fetchItemsWithLimit = async (cursor = 0, ts: number) => {
await sleep(10)
return {
nextId: cursor + limit,
items: items.slice(cursor, cursor + limit),
ts,
}
}
function Page() {
let fetchCountRef = 0
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: ({ pageParam }) =>
fetchItemsWithLimit(pageParam, fetchCountRef++),
initialPageParam: 0,
getNextPageParam: (lastPage) => lastPage.nextId,
}))
return (
<div>
<h1>Pagination</h1>
<Switch
fallback={
<>
<div>Data:</div>
<For each={state.data?.pages ?? []}>
{(page, i) => (
<div>
<div>
Page {i()}: {page.ts}
</div>
<div>
<Index each={page.items}>
{(item) => <p>Item: {item()}</p>}
</Index>
</div>
</div>
)}
</For>
<div>
<button
onClick={() => state.fetchNextPage()}
disabled={
!state.hasNextPage || Boolean(state.isFetchingNextPage)
}
>
<Switch fallback={<>Nothing more to load</>}>
<Match when={state.isFetchingNextPage}>
Loading more...
</Match>
<Match when={state.hasNextPage}>Load More</Match>
</Switch>
</button>
<button onClick={() => state.refetch()}>Refetch</button>
<button
onClick={() => {
// Imagine that this mutation happens somewhere else
// makes an actual network request
// and calls invalidateQueries in an onSuccess
items.splice(4, 1)
queryClient.invalidateQueries({ queryKey: key })
}}
>
Remove item
</button>
</div>
<div>
{!state.isFetchingNextPage ? 'Background Updating...' : null}
</div>
</>
}
>
<Match when={state.status === 'pending'}>Loading...</Match>
<Match when={state.status === 'error'}>
<span>Error: {state.error?.message}</span>
</Match>
</Switch>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
screen.getByText('Loading...')
await waitFor(() => screen.getByText('Item: 2'))
await waitFor(() => screen.getByText('Page 0: 0'))
fireEvent.click(screen.getByText('Load More'))
await waitFor(() => screen.getByText('Loading more...'))
await waitFor(() => screen.getByText('Item: 5'))
await waitFor(() => screen.getByText('Page 0: 0'))
await waitFor(() => screen.getByText('Page 1: 1'))
fireEvent.click(screen.getByText('Load More'))
await waitFor(() => screen.getByText('Loading more...'))
await waitFor(() => screen.getByText('Item: 8'))
await waitFor(() => screen.getByText('Page 0: 0'))
await waitFor(() => screen.getByText('Page 1: 1'))
await waitFor(() => screen.getByText('Page 2: 2'))
fireEvent.click(screen.getByText('Refetch'))
await waitFor(() => screen.getByText('Background Updating...'))
await waitFor(() => screen.getByText('Item: 8'))
await waitFor(() => screen.getByText('Page 0: 3'))
await waitFor(() => screen.getByText('Page 1: 4'))
await waitFor(() => screen.getByText('Page 2: 5'))
// ensure that Item: 4 is rendered before removing it
expect(screen.queryAllByText('Item: 4')).toHaveLength(1)
// remove Item: 4
fireEvent.click(screen.getByText('Remove item'))
await waitFor(() => screen.getByText('Background Updating...'))
// ensure that an additional item is rendered (it means that cursors were properly rebuilt)
await waitFor(() => screen.getByText('Item: 9'))
await waitFor(() => screen.getByText('Page 0: 6'))
await waitFor(() => screen.getByText('Page 1: 7'))
await waitFor(() => screen.getByText('Page 2: 8'))
// ensure that Item: 4 is no longer rendered
expect(screen.queryAllByText('Item: 4')).toHaveLength(0)
})
it('should compute hasNextPage correctly for falsy getFetchMore return value on refetching', async () => {
const key = queryKey()
const MAX = 2
function Page() {
let fetchCountRef = 0
const [isRemovedLastPage, setIsRemovedLastPage] =
createSignal<boolean>(false)
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn: ({ pageParam }) =>
fetchItems(
pageParam,
fetchCountRef++,
pageParam === MAX || (pageParam === MAX - 1 && isRemovedLastPage()),
),
initialPageParam: 0,
getNextPageParam: (lastPage) => lastPage.nextId,
}))
return (
<div>
<h1>Pagination</h1>
<Switch
fallback={
<>
<div>Data:</div>
<For each={state.data!.pages}>
{(page, i) => (
<div>
<div>
Page {i()}: {page.ts}
</div>
<div>
<Index each={page.items}>
{(item) => <p>Item: {item()}</p>}
</Index>
</div>
</div>
)}
</For>
<div>
<button
onClick={() => state.fetchNextPage()}
disabled={
!state.hasNextPage || Boolean(state.isFetchingNextPage)
}
>
{state.isFetchingNextPage
? 'Loading more...'
: state.hasNextPage
? 'Load More'
: 'Nothing more to load'}
</button>
<button onClick={() => state.refetch()}>Refetch</button>
<button onClick={() => setIsRemovedLastPage(true)}>
Remove Last Page
</button>
</div>
<div>
{state.isFetching && !state.isFetchingNextPage
? 'Background Updating...'
: null}
</div>
</>
}
>
<Match when={state.status === 'pending'}>Loading...</Match>
<Match when={state.status === 'error'}>
<span>Error: {state.error?.message}</span>
</Match>
</Switch>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
screen.getByText('Loading...')
await waitFor(() => {
screen.getByText('Item: 9')
screen.getByText('Page 0: 0')
})
fireEvent.click(screen.getByText('Load More'))
await waitFor(() => screen.getByText('Loading more...'))
await waitFor(() => {
screen.getByText('Item: 19')
screen.getByText('Page 0: 0')
screen.getByText('Page 1: 1')
})
fireEvent.click(screen.getByText('Load More'))
await waitFor(() => screen.getByText('Loading more...'))
await waitFor(() => {
screen.getByText('Item: 29')
screen.getByText('Page 0: 0')
screen.getByText('Page 1: 1')
screen.getByText('Page 2: 2')
})
screen.getByText('Nothing more to load')
fireEvent.click(screen.getByText('Remove Last Page'))
await sleep(10)
fireEvent.click(screen.getByText('Refetch'))
await waitFor(() => screen.getByText('Background Updating...'))
await waitFor(() => {
screen.getByText('Page 0: 3')
screen.getByText('Page 1: 4')
})
expect(screen.queryByText('Item: 29')).toBeNull()
expect(screen.queryByText('Page 2: 5')).toBeNull()
screen.getByText('Nothing more to load')
})
it('should cancel the query function when there are no more subscriptions', async () => {
const key = queryKey()
let cancelFn: Mock = vi.fn()
const queryFn = ({ signal }: { signal?: AbortSignal }) => {
const promise = new Promise<string>((resolve, reject) => {
cancelFn = vi.fn(() => reject('Cancelled'))
signal?.addEventListener('abort', cancelFn)
sleep(20).then(() => resolve('OK'))
})
return promise
}
function Page() {
const state = createInfiniteQuery(() => ({
queryKey: key,
queryFn,
getNextPageParam: () => undefined,
initialPageParam: 0,
}))
return (
<div>
<h1>Status: {state.status}</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Blink duration={5}>
<Page />
</Blink>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('off'))
expect(cancelFn).toHaveBeenCalled()
})
it('should use provided custom queryClient', async () => {
const key = queryKey()
const queryFn = () => {
return Promise.resolve('custom client')
}
function Page() {
const state = createInfiniteQuery(
() => ({
queryKey: key,
queryFn,
getNextPageParam: () => undefined,
initialPageParam: 0,
}),
() => queryClient,
)
return (
<div>
<h1>Status: {state.data?.pages[0]}</h1>
</div>
)
}
render(() => <Page />)
await waitFor(() => screen.getByText('Status: custom client'))
})
})
|
4,041 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/createMutation.test.tsx | import { describe, expect, it, vi } from 'vitest'
import {
ErrorBoundary,
createEffect,
createRenderEffect,
createSignal,
} from 'solid-js'
import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library'
import {
MutationCache,
QueryCache,
QueryClientProvider,
createMutation,
} from '..'
import {
createQueryClient,
mockOnlineManagerIsOnline,
queryKey,
setActTimeout,
sleep,
} from './utils'
import type { CreateMutationResult } from '../types'
describe('createMutation', () => {
const queryCache = new QueryCache()
const mutationCache = new MutationCache()
const queryClient = createQueryClient({ queryCache, mutationCache })
it('should be able to reset `data`', async () => {
function Page() {
const mutation = createMutation(() => ({
mutationFn: () => Promise.resolve('mutation'),
}))
return (
<div>
<h1>{mutation.data ?? 'empty'}</h1>
<button onClick={() => mutation.reset()}>reset</button>
<button onClick={() => mutation.mutate()}>mutate</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
expect(screen.getByRole('heading').textContent).toBe('empty')
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(screen.getByRole('heading').textContent).toBe('mutation')
})
fireEvent.click(screen.getByRole('button', { name: /reset/i }))
await waitFor(() => {
expect(screen.getByRole('heading').textContent).toBe('empty')
})
})
it('should be able to reset `error`', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const mutation = createMutation<string, Error>(() => ({
mutationFn: () => {
const err = new Error('Expected mock error. All is well!')
err.stack = ''
return Promise.reject(err)
},
}))
return (
<div>
{mutation.error && <h1>{mutation.error.message}</h1>}
<button onClick={() => mutation.reset()}>reset</button>
<button onClick={() => mutation.mutate()}>mutate</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => {
expect(screen.queryByRole('heading')).toBeNull()
})
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(screen.getByRole('heading').textContent).toBe(
'Expected mock error. All is well!',
)
})
fireEvent.click(screen.getByRole('button', { name: /reset/i }))
await waitFor(() => {
expect(screen.queryByRole('heading')).toBeNull()
})
consoleMock.mockRestore()
})
it('should be able to call `onSuccess` and `onSettled` after each successful mutate', async () => {
const [count, setCount] = createSignal(0)
const onSuccessMock = vi.fn()
const onSettledMock = vi.fn()
function Page() {
const mutation = createMutation(() => ({
mutationFn: (vars: { count: number }) => Promise.resolve(vars.count),
onSuccess: (data) => {
onSuccessMock(data)
},
onSettled: (data) => {
onSettledMock(data)
},
}))
return (
<div>
<h1>{count()}</h1>
<button
onClick={() => {
setCount((c) => c + 1)
return mutation.mutate({ count: count() })
}}
>
mutate
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
expect(screen.getByRole('heading').textContent).toBe('0')
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(screen.getByRole('heading').textContent).toBe('3')
})
await waitFor(() => {
expect(onSuccessMock).toHaveBeenCalledTimes(3)
})
expect(onSuccessMock).toHaveBeenCalledWith(1)
expect(onSuccessMock).toHaveBeenCalledWith(2)
expect(onSuccessMock).toHaveBeenCalledWith(3)
await waitFor(() => {
expect(onSettledMock).toHaveBeenCalledTimes(3)
})
expect(onSettledMock).toHaveBeenCalledWith(1)
expect(onSettledMock).toHaveBeenCalledWith(2)
expect(onSettledMock).toHaveBeenCalledWith(3)
})
it('should set correct values for `failureReason` and `failureCount` on multiple mutate calls', async () => {
const [count, setCount] = createSignal(0)
type Value = { count: number }
const mutateFn = vi.fn<[value: Value], Promise<Value>>()
mutateFn.mockImplementationOnce(() => {
return Promise.reject(new Error('Error test Jonas'))
})
mutateFn.mockImplementation(async (value) => {
await sleep(10)
return Promise.resolve(value)
})
function Page() {
const mutation = createMutation(() => ({
mutationFn: mutateFn,
}))
return (
<div>
<h1>Data {mutation.data?.count}</h1>
<h2>Status {mutation.status}</h2>
<h2>Failed {mutation.failureCount} times</h2>
<h2>Failed because {mutation.failureReason?.message ?? 'null'}</h2>
<button
onClick={() => {
setCount((c) => c + 1)
return mutation.mutate({ count: count() })
}}
>
mutate
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Data'))
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await waitFor(() => screen.getByText('Data'))
await waitFor(() => screen.getByText('Status error'))
await waitFor(() => screen.getByText('Failed 1 times'))
await waitFor(() => screen.getByText('Failed because Error test Jonas'))
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await waitFor(() => screen.getByText('Status pending'))
await waitFor(() => screen.getByText('Status success'))
await waitFor(() => screen.getByText('Data 2'))
await waitFor(() => screen.getByText('Failed 0 times'))
await waitFor(() => screen.getByText('Failed because null'))
})
it('should be able to call `onError` and `onSettled` after each failed mutate', async () => {
const onErrorMock = vi.fn()
const onSettledMock = vi.fn()
const [count, setCount] = createSignal(0)
function Page() {
const mutation = createMutation(() => ({
mutationFn: (vars: { count: number }) => {
const error = new Error(
`Expected mock error. All is well! ${vars.count}`,
)
error.stack = ''
return Promise.reject(error)
},
onError: (error: Error) => {
onErrorMock(error.message)
},
onSettled: (_data, error) => {
onSettledMock(error?.message)
},
}))
return (
<div>
<h1>{count()}</h1>
<button
onClick={() => {
setCount((c) => c + 1)
return mutation.mutate({ count: count() })
}}
>
mutate
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
expect(screen.getByRole('heading').textContent).toBe('0')
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(screen.getByRole('heading').textContent).toBe('3')
})
await waitFor(() => {
expect(onErrorMock).toHaveBeenCalledTimes(3)
})
expect(onErrorMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 1',
)
expect(onErrorMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 2',
)
expect(onErrorMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 3',
)
await waitFor(() => {
expect(onSettledMock).toHaveBeenCalledTimes(3)
})
expect(onSettledMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 1',
)
expect(onSettledMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 2',
)
expect(onSettledMock).toHaveBeenCalledWith(
'Expected mock error. All is well! 3',
)
})
it('should be able to override the useMutation success callbacks', async () => {
const callbacks: Array<string> = []
function Page() {
const mutation = createMutation(() => ({
mutationFn: async (text: string) => text,
onSuccess: async () => {
callbacks.push('useMutation.onSuccess')
},
onSettled: async () => {
callbacks.push('useMutation.onSettled')
},
}))
createEffect(() => {
const { mutateAsync } = mutation
setActTimeout(async () => {
try {
const result = await mutateAsync('todo', {
onSuccess: async () => {
callbacks.push('mutateAsync.onSuccess')
},
onSettled: async () => {
callbacks.push('mutateAsync.onSettled')
},
})
callbacks.push(`mutateAsync.result:${result}`)
} catch {}
}, 10)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(callbacks).toEqual([
'useMutation.onSuccess',
'useMutation.onSettled',
'mutateAsync.onSuccess',
'mutateAsync.onSettled',
'mutateAsync.result:todo',
])
})
it('should be able to override the error callbacks when using mutateAsync', async () => {
const callbacks: Array<string> = []
function Page() {
const mutation = createMutation(() => ({
mutationFn: async (_text: string) => Promise.reject(new Error('oops')),
onError: async () => {
callbacks.push('useMutation.onError')
},
onSettled: async () => {
callbacks.push('useMutation.onSettled')
},
}))
createEffect(() => {
const { mutateAsync } = mutation
setActTimeout(async () => {
try {
await mutateAsync('todo', {
onError: async () => {
callbacks.push('mutateAsync.onError')
},
onSettled: async () => {
callbacks.push('mutateAsync.onSettled')
},
})
} catch (error) {
callbacks.push(`mutateAsync.error:${(error as Error).message}`)
}
}, 10)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(callbacks).toEqual([
'useMutation.onError',
'useMutation.onSettled',
'mutateAsync.onError',
'mutateAsync.onSettled',
'mutateAsync.error:oops',
])
})
it('should be able to use mutation defaults', async () => {
const key = queryKey()
queryClient.setMutationDefaults(key, {
mutationFn: async (text: string) => {
await sleep(10)
return text
},
})
const states: Array<CreateMutationResult<any, any, any, any>> = []
function Page() {
const mutation = createMutation<string, unknown, string>(() => ({
mutationKey: key,
}))
createRenderEffect(() => {
states.push({ ...mutation })
})
createEffect(() => {
const { mutate } = mutation
setActTimeout(() => {
mutate('todo')
}, 10)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(3)
expect(states[0]).toMatchObject({ data: undefined, isPending: false })
expect(states[1]).toMatchObject({ data: undefined, isPending: true })
expect(states[2]).toMatchObject({ data: 'todo', isPending: false })
})
it('should be able to retry a failed mutation', async () => {
let count = 0
function Page() {
const mutation = createMutation(() => ({
mutationFn: (_text: string) => {
count++
return Promise.reject(new Error('oops'))
},
retry: 1,
retryDelay: 5,
}))
createEffect(() => {
const { mutate } = mutation
setActTimeout(() => {
mutate('todo')
}, 10)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(count).toBe(2)
})
it('should not retry mutations while offline', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
let count = 0
function Page() {
const mutation = createMutation(() => ({
mutationFn: (_text: string) => {
count++
return Promise.reject(new Error('oops'))
},
retry: 1,
retryDelay: 5,
}))
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
{`error: ${
mutation.error instanceof Error ? mutation.error.message : 'null'
}, status: ${mutation.status}, isPaused: ${String(
mutation.isPaused,
)}`}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => {
expect(
screen.getByText('error: null, status: idle, isPaused: false'),
).toBeInTheDocument()
})
window.dispatchEvent(new Event('offline'))
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await waitFor(() => {
expect(
screen.getByText('error: null, status: pending, isPaused: true'),
).toBeInTheDocument()
})
expect(count).toBe(0)
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await sleep(100)
await waitFor(() => {
expect(
screen.getByText('error: oops, status: error, isPaused: false'),
).toBeInTheDocument()
})
expect(count).toBe(2)
})
it('should call onMutate even if paused', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const onMutate = vi.fn()
let count = 0
function Page() {
const mutation = createMutation(() => ({
mutationFn: async (_text: string) => {
count++
await sleep(10)
return count
},
onMutate,
}))
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status},
isPaused: {String(mutation.isPaused)}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('data: null, status: idle, isPaused: false')
window.dispatchEvent(new Event('offline'))
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await screen.findByText('data: null, status: pending, isPaused: true')
expect(onMutate).toHaveBeenCalledTimes(1)
expect(onMutate).toHaveBeenCalledWith('todo')
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await screen.findByText('data: 1, status: success, isPaused: false')
expect(onMutate).toHaveBeenCalledTimes(1)
expect(count).toBe(1)
})
it('should optimistically go to paused state if offline', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
let count = 0
const states: Array<string> = []
function Page() {
const mutation = createMutation(() => ({
mutationFn: async (_text: string) => {
count++
await sleep(10)
return count
},
}))
createRenderEffect(() => {
states.push(`${mutation.status}, ${mutation.isPaused}`)
})
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status},
isPaused: {String(mutation.isPaused)}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('data: null, status: idle, isPaused: false')
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await screen.findByText('data: null, status: pending, isPaused: true')
// no intermediate 'pending, false' state is expected because we don't start mutating!
expect(states[0]).toBe('idle, false')
expect(states[1]).toBe('pending, true')
onlineMock.mockReturnValue(true)
window.dispatchEvent(new Event('online'))
await screen.findByText('data: 1, status: success, isPaused: false')
onlineMock.mockRestore()
})
it('should be able to retry a mutation when online', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
let count = 0
const states: Array<CreateMutationResult<any, any, any, any>> = []
function Page() {
const mutation = createMutation(() => ({
mutationFn: async (_text: string) => {
await sleep(1)
count++
return count > 1
? Promise.resolve('data')
: Promise.reject(new Error('oops'))
},
retry: 1,
retryDelay: 5,
networkMode: 'offlineFirst',
}))
createRenderEffect(() => {
states.push({ ...mutation })
})
createEffect(() => {
const { mutate } = mutation
setActTimeout(() => {
window.dispatchEvent(new Event('offline'))
mutate('todo')
}, 10)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(50)
expect(states.length).toBe(4)
expect(states[0]).toMatchObject({
isPending: false,
isPaused: false,
failureCount: 0,
failureReason: null,
})
expect(states[1]).toMatchObject({
isPending: true,
isPaused: false,
failureCount: 0,
failureReason: null,
})
expect(states[2]).toMatchObject({
isPending: true,
isPaused: false,
failureCount: 1,
failureReason: new Error('oops'),
})
expect(states[3]).toMatchObject({
isPending: true,
isPaused: true,
failureCount: 1,
failureReason: new Error('oops'),
})
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await sleep(50)
expect(states.length).toBe(6)
expect(states[4]).toMatchObject({
isPending: true,
isPaused: false,
failureCount: 1,
failureReason: new Error('oops'),
})
expect(states[5]).toMatchObject({
isPending: false,
isPaused: false,
failureCount: 0,
failureReason: null,
data: 'data',
})
})
it('should not change state if unmounted', async () => {
function Mutates() {
const mutation = createMutation(() => ({ mutationFn: () => sleep(10) }))
return <button onClick={() => mutation.mutate()}>mutate</button>
}
function Page() {
const [mounted, setMounted] = createSignal(true)
return (
<div>
<button onClick={() => setMounted(false)}>unmount</button>
{mounted() && <Mutates />}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
fireEvent.click(screen.getByText('mutate'))
fireEvent.click(screen.getByText('unmount'))
})
it('should be able to throw an error when throwOnError is set to true', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const mutation = createMutation<string, Error>(() => ({
mutationFn: () => {
const err = new Error('Expected mock error. All is well!')
err.stack = ''
return Promise.reject(err)
},
throwOnError: true,
}))
return (
<div>
<button onClick={() => mutation.mutate()}>mutate</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<ErrorBoundary
fallback={() => (
<div>
<span>error</span>
</div>
)}
>
<Page />
</ErrorBoundary>
</QueryClientProvider>
))
fireEvent.click(screen.getByText('mutate'))
await waitFor(() => {
expect(screen.queryByText('error')).not.toBeNull()
})
consoleMock.mockRestore()
})
it('should be able to throw an error when throwOnError is a function that returns true', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
let boundary = false
function Page() {
const mutation = createMutation<string, Error>(() => ({
mutationFn: () => {
const err = new Error('mock error')
err.stack = ''
return Promise.reject(err)
},
throwOnError: () => {
boundary = !boundary
return !boundary
},
}))
return (
<div>
<button onClick={() => mutation.mutate()}>mutate</button>
{mutation.error && mutation.error.message}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<ErrorBoundary
fallback={() => (
<div>
<span>error boundary</span>
</div>
)}
>
<Page />
</ErrorBoundary>
</QueryClientProvider>
))
// first error goes to component
fireEvent.click(screen.getByText('mutate'))
await waitFor(() => {
expect(screen.queryByText('mock error')).not.toBeNull()
})
// second error goes to boundary
fireEvent.click(screen.getByText('mutate'))
await waitFor(() => {
expect(screen.queryByText('error boundary')).not.toBeNull()
})
consoleMock.mockRestore()
})
it('should pass meta to mutation', async () => {
const errorMock = vi.fn()
const successMock = vi.fn()
const queryClientMutationMeta = createQueryClient({
mutationCache: new MutationCache({
onSuccess: (_, __, ___, mutation) => {
successMock(mutation.meta?.metaSuccessMessage)
},
onError: (_, __, ___, mutation) => {
errorMock(mutation.meta?.metaErrorMessage)
},
}),
})
const metaSuccessMessage = 'mutation succeeded'
const metaErrorMessage = 'mutation failed'
function Page() {
const mutationSucceed = createMutation(() => ({
mutationFn: async () => '',
meta: { metaSuccessMessage },
}))
const mutationError = createMutation(() => ({
mutationFn: async () => {
throw new Error('')
},
meta: { metaErrorMessage },
}))
return (
<div>
<button onClick={() => mutationSucceed.mutate()}>succeed</button>
<button onClick={() => mutationError.mutate()}>error</button>
{mutationSucceed.isSuccess && <div>successTest</div>}
{mutationError.isError && <div>errorTest</div>}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClientMutationMeta}>
<Page />
</QueryClientProvider>
))
fireEvent.click(screen.getByText('succeed'))
fireEvent.click(screen.getByText('error'))
await waitFor(() => {
expect(screen.queryByText('successTest')).not.toBeNull()
expect(screen.queryByText('errorTest')).not.toBeNull()
})
expect(successMock).toHaveBeenCalledTimes(1)
expect(successMock).toHaveBeenCalledWith(metaSuccessMessage)
expect(errorMock).toHaveBeenCalledTimes(1)
expect(errorMock).toHaveBeenCalledWith(metaErrorMessage)
})
it('should call cache callbacks when unmounted', async () => {
const onSuccess = vi.fn()
const onSuccessMutate = vi.fn()
const onSettled = vi.fn()
const onSettledMutate = vi.fn()
const mutationKey = queryKey()
let count = 0
function Page() {
const [show, setShow] = createSignal(true)
return (
<div>
<button onClick={() => setShow(false)}>hide</button>
{show() && <Component />}
</div>
)
}
function Component() {
const mutation = createMutation(() => ({
mutationFn: async (_text: string) => {
count++
await sleep(10)
return count
},
mutationKey: mutationKey,
gcTime: 0,
onSuccess,
onSettled,
}))
return (
<div>
<button
onClick={() =>
mutation.mutate('todo', {
onSuccess: onSuccessMutate,
onSettled: onSettledMutate,
})
}
>
mutate
</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status},
isPaused: {String(mutation.isPaused)}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('data: null, status: idle, isPaused: false')
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
fireEvent.click(screen.getByRole('button', { name: /hide/i }))
await waitFor(() => {
expect(
queryClient.getMutationCache().findAll({ mutationKey: mutationKey }),
).toHaveLength(0)
})
expect(count).toBe(1)
expect(onSuccess).toHaveBeenCalledTimes(1)
expect(onSettled).toHaveBeenCalledTimes(1)
expect(onSuccessMutate).toHaveBeenCalledTimes(0)
expect(onSettledMutate).toHaveBeenCalledTimes(0)
})
it('should call mutate callbacks only for the last observer', async () => {
const onSuccess = vi.fn()
const onSuccessMutate = vi.fn()
const onSettled = vi.fn()
const onSettledMutate = vi.fn()
let count = 0
function Page() {
const mutation = createMutation(() => ({
mutationFn: async (_text: string) => {
count++
await sleep(10)
return `result${count}`
},
onSuccess,
onSettled,
}))
return (
<div>
<button
onClick={() =>
mutation.mutate('todo', {
onSuccess: onSuccessMutate,
onSettled: onSettledMutate,
})
}
>
mutate
</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('data: null, status: idle')
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await screen.findByText('data: result2, status: success')
expect(count).toBe(2)
expect(onSuccess).toHaveBeenCalledTimes(2)
expect(onSettled).toHaveBeenCalledTimes(2)
expect(onSuccessMutate).toHaveBeenCalledTimes(1)
expect(onSuccessMutate).toHaveBeenCalledWith('result2', 'todo', undefined)
expect(onSettledMutate).toHaveBeenCalledTimes(1)
expect(onSettledMutate).toHaveBeenCalledWith(
'result2',
null,
'todo',
undefined,
)
})
it('should go to error state if onSuccess callback errors', async () => {
const error = new Error('error from onSuccess')
const onError = vi.fn()
function Page() {
const mutation = createMutation(() => ({
mutationFn: async (_text: string) => {
await sleep(10)
return 'result'
},
onSuccess: () => Promise.reject(error),
onError,
}))
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>status: {mutation.status}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('status: idle')
screen.getByRole('button', { name: /mutate/i }).click()
await screen.findByText('status: error')
expect(onError).toHaveBeenCalledWith(error, 'todo', undefined)
})
it('should go to error state if onError callback errors', async () => {
const error = new Error('error from onError')
const mutateFnError = new Error('mutateFnError')
function Page() {
const mutation = createMutation(() => ({
mutationFn: async (_text: string) => {
await sleep(10)
throw mutateFnError
},
onError: () => Promise.reject(error),
}))
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
error:{' '}
{mutation.error instanceof Error ? mutation.error.message : 'null'},
status: {mutation.status}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('error: null, status: idle')
screen.getByRole('button', { name: /mutate/i }).click()
await screen.findByText('error: mutateFnError, status: error')
})
it('should go to error state if onSettled callback errors', async () => {
const error = new Error('error from onSettled')
const mutateFnError = new Error('mutateFnError')
const onError = vi.fn()
function Page() {
const mutation = createMutation(() => ({
mutationFn: async (_text: string) => {
await sleep(10)
throw mutateFnError
},
onSettled: () => Promise.reject(error),
onError,
}))
return (
<div>
<button onClick={() => mutation.mutate('todo')}>mutate</button>
<div>
error:{' '}
{mutation.error instanceof Error ? mutation.error.message : 'null'},
status: {mutation.status}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('error: null, status: idle')
screen.getByRole('button', { name: /mutate/i }).click()
await screen.findByText('error: mutateFnError, status: error')
expect(onError).toHaveBeenCalledWith(mutateFnError, 'todo', undefined)
})
it('should use provided custom queryClient', async () => {
function Page() {
const mutation = createMutation(
() => ({
mutationFn: async (text: string) => {
return Promise.resolve(text)
},
}),
() => queryClient,
)
return (
<div>
<button onClick={() => mutation.mutate('custom client')}>
mutate
</button>
<div>
data: {mutation.data ?? 'null'}, status: {mutation.status}
</div>
</div>
)
}
render(() => <Page></Page>)
await screen.findByText('data: null, status: idle')
fireEvent.click(screen.getByRole('button', { name: /mutate/i }))
await screen.findByText('data: custom client, status: success')
})
})
|
4,042 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/createQueries.test.tsx | import { describe, expect, expectTypeOf, it, vi } from 'vitest'
import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library'
import * as QueryCore from '@tanstack/query-core'
import { createRenderEffect, createSignal } from 'solid-js'
import {
QueriesObserver,
QueryCache,
QueryClientProvider,
createQueries,
} from '..'
import { createQueryClient, expectTypeNotAny, queryKey, sleep } from './utils'
import type { QueryFunctionContext, QueryKey } from '@tanstack/query-core'
import type {
CreateQueryResult,
QueryFunction,
QueryObserverResult,
SolidQueryOptions,
} from '..'
describe('useQueries', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should return the correct states', async () => {
const key1 = queryKey()
const key2 = queryKey()
const results: Array<Array<CreateQueryResult>> = []
function Page() {
const result = createQueries(() => ({
queries: [
{
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 1
},
},
{
queryKey: key2,
queryFn: async () => {
await sleep(100)
return 2
},
},
],
}))
createRenderEffect(() => {
results.push([{ ...result[0] }, { ...result[1] }])
})
return (
<div>
<div>
data1: {String(result[0].data ?? 'null')}, data2:{' '}
{String(result[1].data ?? 'null')}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data1: 1, data2: 2'))
expect(results.length).toBe(3)
expect(results[0]).toMatchObject([{ data: undefined }, { data: undefined }])
expect(results[1]).toMatchObject([{ data: 1 }, { data: undefined }])
expect(results[2]).toMatchObject([{ data: 1 }, { data: 2 }])
})
it('handles type parameter - tuple of tuples', async () => {
const key1 = queryKey()
const key2 = queryKey()
const key3 = queryKey()
// @ts-expect-error (Page component is not rendered)
// eslint-disable-next-line
function Page() {
const result1 = createQueries<
[[number], [string], [Array<string>, boolean]]
>(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 1,
},
{
queryKey: key2,
queryFn: () => 'string',
},
{
queryKey: key3,
queryFn: () => ['string[]'],
},
],
}))
expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
expectTypeOf<number | undefined>(result1[0].data)
expectTypeOf<string | undefined>(result1[1].data)
expectTypeOf<Array<string> | undefined>(result1[2].data)
expectTypeOf<boolean | null>(result1[2].error)
// TData (3rd element) takes precedence over TQueryFnData (1st element)
const result2 = createQueries<
[[string, unknown, string], [string, unknown, number]]
>(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return a.toLowerCase()
},
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return parseInt(a)
},
},
],
}))
expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
expectTypeOf<string | undefined>(result2[0].data)
expectTypeOf<number | undefined>(result2[1].data)
// types should be enforced
createQueries<[[string, unknown, string], [string, boolean, number]]>(
() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return a.toLowerCase()
},
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return parseInt(a)
},
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
],
}),
)
// field names should be enforced
createQueries<[[string]]>(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
},
],
}))
}
})
it('handles type parameter - tuple of objects', async () => {
const key1 = queryKey()
const key2 = queryKey()
const key3 = queryKey()
// @ts-expect-error (Page component is not rendered)
// eslint-disable-next-line
function Page() {
const result1 = createQueries<
[
{ queryFnData: number },
{ queryFnData: string },
{ queryFnData: Array<string>; error: boolean },
]
>(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 1,
},
{
queryKey: key2,
queryFn: () => 'string',
},
{
queryKey: key3,
queryFn: () => ['string[]'],
},
],
}))
expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
expectTypeOf<number | undefined>(result1[0].data)
expectTypeOf<string | undefined>(result1[1].data)
expectTypeOf<Array<string> | undefined>(result1[2].data)
expectTypeOf<boolean | null>(result1[2].error)
// TData (data prop) takes precedence over TQueryFnData (queryFnData prop)
const result2 = createQueries<
[
{ queryFnData: string; data: string },
{ queryFnData: string; data: number },
]
>(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return a.toLowerCase()
},
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return parseInt(a)
},
},
],
}))
expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
expectTypeOf<string | undefined>(result2[0].data)
expectTypeOf<number | undefined>(result2[1].data)
// can pass only TData (data prop) although TQueryFnData will be left unknown
const result3 = createQueries<[{ data: string }, { data: number }]>(
() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<unknown>(a)
expectTypeNotAny(a)
return a as string
},
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<unknown>(a)
expectTypeNotAny(a)
return a as number
},
},
],
}),
)
expectTypeOf<QueryObserverResult<string, unknown>>(result3[0])
expectTypeOf<QueryObserverResult<number, unknown>>(result3[1])
expectTypeOf<string | undefined>(result3[0].data)
expectTypeOf<number | undefined>(result3[1].data)
// types should be enforced
createQueries<
[
{ queryFnData: string; data: string },
{ queryFnData: string; data: number; error: boolean },
]
>(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return a.toLowerCase()
},
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
{
queryKey: key2,
queryFn: () => 'string',
select: (a) => {
expectTypeOf<string>(a)
expectTypeNotAny(a)
return parseInt(a)
},
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
],
}))
// field names should be enforced
createQueries<[{ queryFnData: string }]>(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
},
],
}))
}
})
it('handles array literal without type parameter to infer result type', async () => {
const key1 = queryKey()
const key2 = queryKey()
const key3 = queryKey()
const key4 = queryKey()
// @ts-expect-error (Page component is not rendered)
// eslint-disable-next-line
function Page() {
// Array.map preserves TQueryFnData
const result1 = createQueries(() => ({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
})),
}))
expectTypeOf<Array<QueryObserverResult<number, unknown>>>(result1)
expectTypeOf<number | undefined>(result1[0]?.data)
// Array.map preserves TData
const result2 = createQueries(() => ({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
select: (data: number) => data.toString(),
})),
}))
expectTypeOf<Array<QueryObserverResult<string, unknown>>>(result2)
const result3 = createQueries(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 1,
},
{
queryKey: key2,
queryFn: () => 'string',
},
{
queryKey: key3,
queryFn: () => ['string[]'],
select: () => 123,
},
],
}))
expectTypeOf<QueryObserverResult<number, unknown>>(result3[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result3[1])
expectTypeOf<QueryObserverResult<number, unknown>>(result3[2])
expectTypeOf<number | undefined>(result3[0].data)
expectTypeOf<string | undefined>(result3[1].data)
// select takes precedence over queryFn
expectTypeOf<number | undefined>(result3[2].data)
// initialData/placeholderData are enforced
createQueries(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
placeholderData: 'string',
// @ts-expect-error (initialData: string)
initialData: 123,
},
{
queryKey: key2,
queryFn: () => 123,
// @ts-expect-error (placeholderData: number)
placeholderData: 'string',
initialData: 123,
},
],
}))
// select params are "indirectly" enforced
createQueries(() => ({
queries: [
// unfortunately TS will not suggest the type for you
{
queryKey: key1,
queryFn: () => 'string',
},
// however you can add a type to the callback
{
queryKey: key2,
queryFn: () => 'string',
},
// the type you do pass is enforced
{
queryKey: key3,
queryFn: () => 'string',
},
{
queryKey: key4,
queryFn: () => 'string',
select: (a: string) => parseInt(a),
},
],
}))
// callbacks are also indirectly enforced with Array.map
createQueries(() => ({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
select: (data: number) => data.toString(),
})),
}))
createQueries(() => ({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () => i + 10,
select: (data: number) => data.toString(),
})),
}))
// results inference works when all the handlers are defined
const result4 = createQueries(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
},
{
queryKey: key2,
queryFn: () => 'string',
},
{
queryKey: key4,
queryFn: () => 'string',
select: (a: string) => parseInt(a),
},
],
}))
expectTypeOf<QueryObserverResult<string, unknown>>(result4[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result4[1])
expectTypeOf<QueryObserverResult<number, unknown>>(result4[2])
// handles when queryFn returns a Promise
const result5 = createQueries(() => ({
queries: [
{
queryKey: key1,
queryFn: () => Promise.resolve('string'),
},
],
}))
expectTypeOf<QueryObserverResult<string, unknown>>(result5[0])
// Array as const does not throw error
const result6 = createQueries(
() =>
({
queries: [
{
queryKey: ['key1'],
queryFn: () => 'string',
},
{
queryKey: ['key1'],
queryFn: () => 123,
},
],
}) as const,
)
expectTypeOf<QueryObserverResult<string, unknown>>(result6[0])
expectTypeOf<QueryObserverResult<number, unknown>>(result6[1])
// field names should be enforced - array literal
createQueries(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
},
],
}))
// field names should be enforced - Array.map() result
createQueries(() => ({
// @ts-expect-error (invalidField)
queries: Array(10).map(() => ({
someInvalidField: '',
})),
}))
// field names should be enforced - array literal
createQueries(() => ({
queries: [
{
queryKey: key1,
queryFn: () => 'string',
},
],
}))
// supports queryFn using fetch() to return Promise<any> - Array.map() result
createQueries(() => ({
queries: Array(50).map((_, i) => ({
queryKey: ['key', i] as const,
queryFn: () =>
fetch('return Promise<any>').then((resp) => resp.json()),
})),
}))
// supports queryFn using fetch() to return Promise<any> - array literal
createQueries(() => ({
queries: [
{
queryKey: key1,
queryFn: () =>
fetch('return Promise<any>').then((resp) => resp.json()),
},
],
}))
}
})
it('handles strongly typed queryFn factories and useQueries wrappers', () => {
// QueryKey + queryFn factory
type QueryKeyA = ['queryA']
const getQueryKeyA = (): QueryKeyA => ['queryA']
type GetQueryFunctionA = () => QueryFunction<number, QueryKeyA>
const getQueryFunctionA: GetQueryFunctionA = () => async () => {
return 1
}
type SelectorA = (data: number) => [number, string]
const getSelectorA = (): SelectorA => (data) => [data, data.toString()]
type QueryKeyB = ['queryB', string]
const getQueryKeyB = (id: string): QueryKeyB => ['queryB', id]
type GetQueryFunctionB = () => QueryFunction<string, QueryKeyB>
const getQueryFunctionB: GetQueryFunctionB = () => async () => {
return '1'
}
type SelectorB = (data: string) => [string, number]
const getSelectorB = (): SelectorB => (data) => [data, +data]
// Wrapper with strongly typed array-parameter
function useWrappedQueries<
TQueryFnData,
TError,
TData,
TQueryKey extends QueryKey,
>(
queries: Array<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>,
) {
return createQueries(() => ({
queries: queries.map(
// no need to type the mapped query
(query) => {
const { queryFn: fn, queryKey: key } = query
expectTypeOf<QueryFunction<TQueryFnData, TQueryKey> | undefined>(fn)
return {
queryKey: key,
queryFn: fn
? (ctx: QueryFunctionContext<TQueryKey>) => {
expectTypeOf<TQueryKey>(ctx.queryKey)
return fn.call({}, ctx)
}
: undefined,
}
},
),
}))
}
// @ts-expect-error (Page component is not rendered)
// eslint-disable-next-line
function Page() {
const result = createQueries(() => ({
queries: [
{
queryKey: getQueryKeyA(),
queryFn: getQueryFunctionA(),
},
{
queryKey: getQueryKeyB('id'),
queryFn: getQueryFunctionB(),
},
],
}))
expectTypeOf<QueryObserverResult<number, unknown>>(result[0])
expectTypeOf<QueryObserverResult<string, unknown>>(result[1])
const withSelector = createQueries(() => ({
queries: [
{
queryKey: getQueryKeyA(),
queryFn: getQueryFunctionA(),
select: getSelectorA(),
},
{
queryKey: getQueryKeyB('id'),
queryFn: getQueryFunctionB(),
select: getSelectorB(),
},
],
}))
expectTypeOf<QueryObserverResult<[number, string], unknown>>(
withSelector[0],
)
expectTypeOf<QueryObserverResult<[string, number], unknown>>(
withSelector[1],
)
const withWrappedQueries = useWrappedQueries(
Array(10).map(() => ({
queryKey: getQueryKeyA(),
queryFn: getQueryFunctionA(),
select: getSelectorA(),
})),
)
expectTypeOf<Array<QueryObserverResult<number | undefined, unknown>>>(
withWrappedQueries,
)
}
})
it('should not change state if unmounted', async () => {
const key1 = queryKey()
// We have to mock the QueriesObserver to not unsubscribe
// the listener when the component is unmounted
class QueriesObserverMock extends QueriesObserver {
subscribe(listener: any) {
super.subscribe(listener)
return () => void 0
}
}
const QueriesObserverSpy = vi
.spyOn(QueryCore, 'QueriesObserver')
.mockImplementation((fn) => {
return new QueriesObserverMock(fn, [])
})
function Queries() {
createQueries(() => ({
queries: [
{
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 1
},
},
],
}))
return (
<div>
<span>queries</span>
</div>
)
}
function Page() {
const [mounted, setMounted] = createSignal(true)
return (
<div>
<button onClick={() => setMounted(false)}>unmount</button>
{mounted() && <Queries />}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
fireEvent.click(screen.getByText('unmount'))
// Should not display the console error
// "Warning: Can't perform a React state update on an unmounted component"
await sleep(20)
QueriesObserverSpy.mockRestore()
})
})
|
4,043 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/createQuery.test.tsx | import { describe, expect, expectTypeOf, it, vi } from 'vitest'
import {
ErrorBoundary,
Match,
Switch,
createEffect,
createMemo,
createRenderEffect,
createSignal,
on,
} from 'solid-js'
import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library'
import { reconcile } from 'solid-js/store'
import {
QueryCache,
QueryClientProvider,
createQuery,
keepPreviousData,
} from '..'
import {
Blink,
createQueryClient,
mockOnlineManagerIsOnline,
mockVisibilityState,
queryKey,
setActTimeout,
sleep,
} from './utils'
import type {
CreateQueryOptions,
CreateQueryResult,
DefinedCreateQueryResult,
QueryFunction,
} from '..'
import type { Mock } from 'vitest'
import type { JSX } from 'solid-js'
describe('createQuery', () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should return the correct types', () => {
const key = queryKey()
// @ts-ignore
// eslint-disable-next-line
function Page() {
// unspecified query function should default to unknown
const noQueryFn = createQuery(() => ({ queryKey: key }))
expectTypeOf<unknown>(noQueryFn.data)
expectTypeOf<unknown>(noQueryFn.error)
// it should infer the result type from the query function
const fromQueryFn = createQuery(() => ({
queryKey: key,
queryFn: () => 'test',
}))
expectTypeOf<string | undefined>(fromQueryFn.data)
expectTypeOf<unknown>(fromQueryFn.error)
// it should be possible to specify the result type
const withResult = createQuery<string>(() => ({
queryKey: key,
queryFn: () => 'test',
}))
expectTypeOf<string | undefined>(withResult.data)
expectTypeOf<unknown | null>(withResult.error)
// it should be possible to specify the error type
const withError = createQuery<string, Error>(() => ({
queryKey: key,
queryFn: () => 'test',
}))
expectTypeOf<string | undefined>(withError.data)
expectTypeOf<Error | null>(withError.error)
// it should provide the result type in the configuration
createQuery(() => ({
queryKey: [key],
queryFn: async () => true,
}))
// it should be possible to specify a union type as result type
const unionTypeSync = createQuery(() => ({
queryKey: key,
queryFn: () => (Math.random() > 0.5 ? 'a' : 'b'),
}))
expectTypeOf<'a' | 'b' | undefined>(unionTypeSync.data)
const unionTypeAsync = createQuery<'a' | 'b'>(() => ({
queryKey: key,
queryFn: () => Promise.resolve(Math.random() > 0.5 ? 'a' : 'b'),
}))
expectTypeOf<'a' | 'b' | undefined>(unionTypeAsync.data)
// should error when the query function result does not match with the specified type
// @ts-expect-error
createQuery<number>(() => ({ queryKey: key, queryFn: () => 'test' }))
// it should infer the result type from a generic query function
function queryFn<T = string>(): Promise<T> {
return Promise.resolve({} as T)
}
const fromGenericQueryFn = createQuery(() => ({
queryKey: key,
queryFn: () => queryFn(),
}))
expectTypeOf<string | undefined>(fromGenericQueryFn.data)
expectTypeOf<unknown>(fromGenericQueryFn.error)
const fromGenericOptionsQueryFn = createQuery(() => ({
queryKey: key,
queryFn: () => queryFn(),
}))
expectTypeOf<string | undefined>(fromGenericOptionsQueryFn.data)
expectTypeOf<unknown>(fromGenericOptionsQueryFn.error)
type MyData = number
type MyQueryKey = readonly ['my-data', number]
const getMyDataArrayKey: QueryFunction<MyData, MyQueryKey> = async ({
queryKey: [, n],
}) => {
return n + 42
}
createQuery(() => ({
queryKey: ['my-data', 100] as const,
queryFn: getMyDataArrayKey,
}))
const getMyDataStringKey: QueryFunction<MyData, ['1']> = async (
context,
) => {
expectTypeOf<['1']>(context.queryKey)
return Number(context.queryKey[0]) + 42
}
createQuery(() => ({
queryKey: ['1'] as ['1'],
queryFn: getMyDataStringKey,
}))
// it should handle query-functions that return Promise<any>
createQuery(() => ({
queryKey: key,
queryFn: () => fetch('return Promise<any>').then((resp) => resp.json()),
}))
// handles wrapped queries with custom fetcher passed as inline queryFn
const useWrappedQuery = <
TQueryKey extends [string, Record<string, unknown>?],
TQueryFnData,
TError,
TData = TQueryFnData,
>(
qk: TQueryKey,
fetcher: (
obj: TQueryKey[1],
token: string,
// return type must be wrapped with TQueryFnReturn
) => Promise<TQueryFnData>,
options?: Omit<
CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
'queryKey' | 'queryFn' | 'initialData'
>,
) =>
createQuery(() => ({
queryKey: qk,
queryFn: () => fetcher(qk[1], 'token'),
...options,
}))
const test = useWrappedQuery([''], async () => '1')
expectTypeOf<string | undefined>(test.data)
// handles wrapped queries with custom fetcher passed directly to createQuery
const useWrappedFuncStyleQuery = <
TQueryKey extends [string, Record<string, unknown>?],
TQueryFnData,
TError,
TData = TQueryFnData,
>(
qk: TQueryKey,
fetcher: () => Promise<TQueryFnData>,
options?: Omit<
CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
'queryKey' | 'queryFn' | 'initialData'
>,
) => createQuery(() => ({ queryKey: qk, queryFn: fetcher, ...options }))
const testFuncStyle = useWrappedFuncStyleQuery([''], async () => true)
expectTypeOf<boolean | undefined>(testFuncStyle.data)
}
})
// See https://github.com/tannerlinsley/react-query/issues/105
it('should allow to set default data value', async () => {
const key = queryKey()
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
}))
return (
<div>
<h1>{state.data ?? 'default'}</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
screen.getByText('default')
await waitFor(() => screen.getByText('test'))
})
it('should return the correct states for a successful query', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page(): JSX.Element {
const state = createQuery<string, Error>(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
}))
createRenderEffect(() => {
states.push({ ...state })
})
if (state.isPending) {
expectTypeOf<undefined>(state.data)
expectTypeOf<null>(state.error)
} else if (state.isLoadingError) {
expectTypeOf<undefined>(state.data)
expectTypeOf<Error>(state.error)
} else {
expectTypeOf<string>(state.data)
expectTypeOf<Error | null>(state.error)
}
return (
<Switch fallback={<span>{state.data}</span>}>
<Match when={state.isPending}>
<span>pending</span>
</Match>
<Match when={state.isLoadingError}>
<span>{state.error!.message}</span>
</Match>
</Switch>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('test'))
expect(states.length).toEqual(2)
expect(states[0]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
isError: false,
isFetched: false,
isFetchedAfterMount: false,
isFetching: true,
isPaused: false,
isPending: true,
isInitialLoading: true,
isLoading: true,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'pending',
fetchStatus: 'fetching',
})
expect(states[1]).toEqual({
data: 'test',
dataUpdatedAt: expect.any(Number),
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
isError: false,
isFetched: true,
isFetchedAfterMount: true,
isFetching: false,
isPaused: false,
isPending: false,
isInitialLoading: false,
isLoading: false,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: true,
refetch: expect.any(Function),
status: 'success',
fetchStatus: 'idle',
})
})
it('should return the correct states for an unsuccessful query', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<unknown, Error>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => Promise.reject(new Error('rejected')),
retry: 1,
retryDelay: 1,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<h1>Status: {state.status}</h1>
<div>Failure Count: {state.failureCount}</div>
<div>Failure Reason: {state.failureReason?.message}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Status: error'))
expect(states[0]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: null,
errorUpdatedAt: 0,
failureCount: 0,
failureReason: null,
errorUpdateCount: 0,
isError: false,
isFetched: false,
isFetchedAfterMount: false,
isFetching: true,
isPaused: false,
isPending: true,
isInitialLoading: true,
isLoading: true,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'pending',
fetchStatus: 'fetching',
})
expect(states[1]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: null,
errorUpdatedAt: 0,
failureCount: 1,
failureReason: new Error('rejected'),
errorUpdateCount: 0,
isError: false,
isFetched: false,
isFetchedAfterMount: false,
isFetching: true,
isPaused: false,
isPending: true,
isInitialLoading: true,
isLoading: true,
isLoadingError: false,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'pending',
fetchStatus: 'fetching',
})
expect(states[2]).toEqual({
data: undefined,
dataUpdatedAt: 0,
error: new Error('rejected'),
errorUpdatedAt: expect.any(Number),
failureCount: 2,
failureReason: new Error('rejected'),
errorUpdateCount: 1,
isError: true,
isFetched: true,
isFetchedAfterMount: true,
isFetching: false,
isPaused: false,
isPending: false,
isInitialLoading: false,
isLoading: false,
isLoadingError: true,
isPlaceholderData: false,
isRefetchError: false,
isRefetching: false,
isStale: true,
isSuccess: false,
refetch: expect.any(Function),
status: 'error',
fetchStatus: 'idle',
})
})
it('should set isFetchedAfterMount to true after a query has been fetched', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => 'prefetched',
})
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'prefetched',
isFetched: true,
isFetchedAfterMount: false,
})
expect(states[1]).toMatchObject({
data: 'data',
isFetched: true,
isFetchedAfterMount: true,
})
})
it('should not cancel an ongoing fetch when refetch is called with cancelRefetch=false if we have data already', async () => {
const key = queryKey()
let fetchCount = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
fetchCount++
await sleep(10)
return 'data'
},
enabled: false,
initialData: 'initialData',
}))
createEffect(() => {
setActTimeout(() => {
state.refetch()
}, 5)
setActTimeout(() => {
state.refetch({ cancelRefetch: false })
}, 5)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(20)
// first refetch only, second refetch is ignored
expect(fetchCount).toBe(1)
})
it('should cancel an ongoing fetch when refetch is called (cancelRefetch=true) if we have data already', async () => {
const key = queryKey()
let fetchCount = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
fetchCount++
await sleep(10)
return 'data'
},
enabled: false,
initialData: 'initialData',
}))
createEffect(() => {
setActTimeout(() => {
state.refetch()
}, 5)
setActTimeout(() => {
state.refetch()
}, 5)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(20)
// first refetch (gets cancelled) and second refetch
expect(fetchCount).toBe(2)
})
it('should not cancel an ongoing fetch when refetch is called (cancelRefetch=true) if we do not have data yet', async () => {
const key = queryKey()
let fetchCount = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
fetchCount++
await sleep(10)
return 'data'
},
enabled: false,
}))
createEffect(() => {
setActTimeout(() => {
state.refetch()
}, 5)
setActTimeout(() => {
state.refetch()
}, 5)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(20)
// first refetch will not get cancelled, second one gets skipped
expect(fetchCount).toBe(1)
})
it('should be able to watch a query without providing a query function', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
queryClient.setQueryDefaults(key, { queryFn: () => 'data' })
function Page() {
const state = createQuery<string>(() => ({ queryKey: key }))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'data' })
})
it('should pick up a query when re-mounting with gcTime 0', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const [toggle, setToggle] = createSignal(false)
return (
<div>
<button onClick={() => setToggle(true)}>toggle</button>
<Switch>
<Match when={toggle()}>
<Component value="2" />
</Match>
<Match when={!toggle()}>
<Component value="1" />
</Match>
</Switch>
</div>
)
}
function Component({ value }: { value: string }) {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'data: ' + value
},
gcTime: 0,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<div>{state.data}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('data: 1')
fireEvent.click(screen.getByRole('button', { name: /toggle/i }))
await screen.findByText('data: 2')
expect(states.length).toBe(4)
// First load
expect(states[0]).toMatchObject({
isPending: true,
isSuccess: false,
isFetching: true,
})
// First success
expect(states[1]).toMatchObject({
isPending: false,
isSuccess: true,
isFetching: false,
})
// Switch, goes to fetching
expect(states[2]).toMatchObject({
isPending: false,
isSuccess: true,
isFetching: true,
})
// Second success
expect(states[3]).toMatchObject({
isPending: false,
isSuccess: true,
isFetching: false,
})
})
it('should fetch when refetchOnMount is false and nothing has been fetched yet', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'test',
refetchOnMount: false,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should not fetch when refetchOnMount is false and data has been fetched already', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
queryClient.setQueryData(key, 'prefetched')
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'test',
refetchOnMount: false,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(1)
expect(states[0]).toMatchObject({ data: 'prefetched' })
})
it('should be able to select a part of the data with select', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => ({ name: 'test' }),
select: (data) => data.name,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should be able to select a part of the data with select in object syntax', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => ({ name: 'test' }),
select: (data) => data.name,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should be able to select a part of the data with select in object syntax', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => ({ name: 'test' }),
select: (data) => data.name,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should not re-render when it should only re-render only data change and the selected data did not change', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return { name: 'test' }
},
select: (data) => data.name,
notifyOnChangeProps: ['data'],
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
data: {state.data}
<button onClick={() => state.refetch()}>refetch</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: test'))
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should throw an error when a selector throws', async () => {
const key = queryKey()
const states: Array<{ status: string; data?: unknown; error?: Error }> = []
const error = new Error('Select Error')
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => ({ name: 'test' }),
select: () => {
throw error
},
}))
createRenderEffect(() => {
if (state.status === 'pending')
states.push({ status: 'pending', data: undefined })
else if (state.status === 'error')
states.push({ status: 'error', error: state.error })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ status: 'pending', data: undefined })
expect(states[1]).toMatchObject({ status: 'error', error })
})
it('should track properties and only re-render when a tracked property changes', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(() => {
const data = state.data
const refetch = state.refetch
setActTimeout(() => {
if (data) {
refetch()
}
}, 20)
})
return (
<div>
<h1>{state.data ?? null}</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('test'))
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should always re-render if we are tracking props but not using any', async () => {
const key = queryKey()
let renderCount = 0
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'test',
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(
on(
() => ({ ...state }),
() => {
renderCount++
},
),
)
return (
<div>
<h1>hello</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(renderCount).toBe(2)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined })
expect(states[1]).toMatchObject({ data: 'test' })
})
it('should share equal data structures between query results', async () => {
const key = queryKey()
const result1 = [
{ id: '1', done: false },
{ id: '2', done: false },
]
const result2 = [
{ id: '1', done: false },
{ id: '2', done: true },
]
const states: Array<CreateQueryResult<typeof result1>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count === 1 ? result1 : result2
},
reconcile: 'id',
}))
createRenderEffect(() => {
states.push({ ...state })
})
const { refetch } = state
return (
<div>
<button onClick={() => refetch()}>refetch</button>
data: {String(state.data?.[1]?.done)}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: false'))
await sleep(20)
fireEvent.click(screen.getByRole('button', { name: /refetch/i }))
await waitFor(() => screen.getByText('data: true'))
await waitFor(() => expect(states.length).toBe(4))
const todos = states[2]?.data
const todo1 = todos?.[0]
const todo2 = todos?.[1]
const newTodos = states[3]?.data
const newTodo1 = newTodos?.[0]
const newTodo2 = newTodos?.[1]
expect(todos).toEqual(result1)
expect(newTodos).toEqual(result2)
expect(newTodo1).toBe(todo1)
expect(newTodo2).toBe(todo2)
return null
})
it('should use query function from hook when the existing query does not have a query function', async () => {
const key = queryKey()
const results: Array<CreateQueryResult<string>> = []
queryClient.setQueryData(key, 'set')
function Page() {
const result = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'fetched'
},
initialData: 'initial',
staleTime: Infinity,
}))
createRenderEffect(() => {
results.push({ ...result })
})
return (
<div>
<div>isFetching: {result.isFetching}</div>
<button onClick={() => queryClient.refetchQueries({ queryKey: key })}>
refetch
</button>
data: {result.data}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: set'))
fireEvent.click(screen.getByRole('button', { name: /refetch/i }))
await waitFor(() => screen.getByText('data: fetched'))
await waitFor(() => expect(results.length).toBe(3))
expect(results[0]).toMatchObject({ data: 'set', isFetching: false })
expect(results[1]).toMatchObject({ data: 'set', isFetching: true })
expect(results[2]).toMatchObject({ data: 'fetched', isFetching: false })
})
it('should update query stale state and refetch when invalidated with invalidateQueries', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
staleTime: Infinity,
}))
createEffect(() => {
states.push({ ...state })
})
return (
<div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
data: {state.data}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: 1'))
fireEvent.click(screen.getByRole('button', { name: /invalidate/i }))
await waitFor(() => screen.getByText('data: 2'))
await waitFor(() => expect(states.length).toBe(4))
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isRefetching: false,
isSuccess: false,
isStale: true,
})
expect(states[1]).toMatchObject({
data: 1,
isFetching: false,
isRefetching: false,
isSuccess: true,
isStale: false,
})
expect(states[2]).toMatchObject({
data: 1,
isFetching: true,
isRefetching: true,
isSuccess: true,
isStale: true,
})
expect(states[3]).toMatchObject({
data: 2,
isFetching: false,
isRefetching: false,
isSuccess: true,
isStale: false,
})
})
it('should not update disabled query when refetched with refetchQueries', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
enabled: false,
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(() => {
setActTimeout(() => {
queryClient.refetchQueries({ queryKey: key })
}, 20)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(50)
expect(states.length).toBe(1)
expect(states[0]).toMatchObject({
data: undefined,
isFetching: false,
isSuccess: false,
isStale: true,
})
})
it('should not refetch disabled query when invalidated with invalidateQueries', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
enabled: false,
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(() => {
setActTimeout(() => {
queryClient.invalidateQueries({ queryKey: key })
}, 20)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(1)
expect(states[0]).toMatchObject({
data: undefined,
isFetching: false,
isSuccess: false,
isStale: true,
})
})
it('should not fetch when switching to a disabled query', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
function Page() {
const [count, setCount] = createSignal(0)
const state = createQuery(() => ({
queryKey: [key, count()],
queryFn: async () => {
await sleep(5)
return count()
},
enabled: count() === 0,
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(() => {
setActTimeout(() => {
setCount(1)
}, 10)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(50)
expect(states.length).toBe(3)
// Fetch query
expect(states[0]).toMatchObject({
isFetching: true,
isSuccess: false,
})
// Fetched query
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
})
// Switch to disabled query
expect(states[2]).toMatchObject({
isFetching: false,
isSuccess: false,
})
})
it('should keep the previous data when placeholderData is set', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
function Page() {
const [count, setCount] = createSignal(0)
const state = createQuery(() => ({
queryKey: [key, count()],
queryFn: async () => {
await sleep(10)
return count()
},
placeholderData: keepPreviousData,
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(() => {
setActTimeout(() => {
setCount(1)
}, 20)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => expect(states.length).toBe(4))
// Initial
expect(states[0]).toMatchObject({
data: undefined,
isFetching: true,
isSuccess: false,
isPlaceholderData: false,
})
// Fetched
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[2]).toMatchObject({
data: 0,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// New data
expect(states[3]).toMatchObject({
data: 1,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should not show initial data from next query if placeholderData is set', async () => {
const key = queryKey()
const states: Array<DefinedCreateQueryResult<number>> = []
function Page() {
const [count, setCount] = createSignal(0)
const state = createQuery(() => ({
queryKey: [key, count()],
queryFn: async () => {
await sleep(10)
return count()
},
initialData: 99,
placeholderData: keepPreviousData,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<h1>
data: {state.data}, count: {count()}, isFetching:{' '}
{String(state.isFetching)}
</h1>
<button onClick={() => setCount(1)}>inc</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() =>
screen.getByText('data: 0, count: 0, isFetching: false'),
)
fireEvent.click(screen.getByRole('button', { name: 'inc' }))
await waitFor(() =>
screen.getByText('data: 1, count: 1, isFetching: false'),
)
await waitFor(() => expect(states.length).toBe(4))
// Initial
expect(states[0]).toMatchObject({
data: 99,
isFetching: true,
isSuccess: true,
isPlaceholderData: false,
})
// Fetched
expect(states[1]).toMatchObject({
data: 0,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[2]).toMatchObject({
data: 99,
isFetching: true,
isSuccess: true,
isPlaceholderData: false,
})
// New data
expect(states[3]).toMatchObject({
data: 1,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should keep the previous data on disabled query when placeholderData is set and switching query key multiple times', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
queryClient.setQueryData([key, 10], 10)
await sleep(10)
function Page() {
const [count, setCount] = createSignal(10)
const state = createQuery(() => ({
queryKey: [key, count()],
queryFn: async () => {
await sleep(10)
return count()
},
enabled: false,
placeholderData: keepPreviousData,
notifyOnChangeProps: 'all',
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(() => {
const refetch = state.refetch
setActTimeout(() => {
setCount(11)
}, 20)
setActTimeout(() => {
setCount(12)
}, 30)
setActTimeout(() => {
refetch()
}, 40)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(4)
// Disabled query
expect(states[0]).toMatchObject({
data: 10,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
// Set state
expect(states[1]).toMatchObject({
data: 10,
isFetching: false,
isSuccess: true,
isPlaceholderData: true,
})
// Refetch
expect(states[2]).toMatchObject({
data: 10,
isFetching: true,
isSuccess: true,
isPlaceholderData: true,
})
// Refetch done
expect(states[3]).toMatchObject({
data: 12,
isFetching: false,
isSuccess: true,
isPlaceholderData: false,
})
})
it('should use the correct query function when components use different configurations', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
function FirstComponent() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 1
},
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<button onClick={() => state.refetch()}>refetch</button>
data: {state.data}
</div>
)
}
function SecondComponent() {
createQuery(() => ({
queryKey: key,
queryFn: () => 2,
}))
return null
}
function Page() {
return (
<>
<FirstComponent />
<SecondComponent />
</>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: 1'))
fireEvent.click(screen.getByRole('button', { name: /refetch/i }))
await waitFor(() => expect(states.length).toBe(4))
expect(states[0]).toMatchObject({
data: undefined,
})
expect(states[1]).toMatchObject({
data: 1,
})
expect(states[2]).toMatchObject({
data: 1,
})
// This state should be 1 instead of 2
expect(states[3]).toMatchObject({
data: 1,
})
})
it('should be able to set different stale times for a query', async () => {
const key = queryKey()
const states1: Array<CreateQueryResult<string>> = []
const states2: Array<CreateQueryResult<string>> = []
await queryClient.prefetchQuery({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'prefetch'
},
})
await sleep(20)
function FirstComponent() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'one'
},
staleTime: 100,
}))
createRenderEffect(() => {
states1.push({ ...state })
})
return null
}
function SecondComponent() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'two'
},
staleTime: 10,
}))
createRenderEffect(() => {
states2.push({ ...state })
})
return null
}
function Page() {
return (
<>
<FirstComponent />
<SecondComponent />
</>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(200)
expect(states1.length).toBe(4)
expect(states2.length).toBe(3)
expect(states1).toMatchObject([
// First render
{
data: 'prefetch',
isStale: false,
},
// Second createQuery started fetching
{
data: 'prefetch',
isStale: false,
},
// Second createQuery data came in
{
data: 'two',
isStale: false,
},
// Data became stale after 100ms
{
data: 'two',
isStale: true,
},
])
expect(states2).toMatchObject([
// First render, data is stale and starts fetching
{
data: 'prefetch',
isStale: true,
},
// Second createQuery data came in
{
data: 'two',
isStale: false,
},
// Data became stale after 5ms
{
data: 'two',
isStale: true,
},
])
})
it('should re-render when a query becomes stale', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'test',
staleTime: 50,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(3)
expect(states[0]).toMatchObject({ isStale: true })
expect(states[1]).toMatchObject({ isStale: false })
expect(states[2]).toMatchObject({ isStale: true })
})
it('should not re-render when it should only re-render on data changes and the data did not change', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(5)
return 'test'
},
notifyOnChangeProps: ['data'],
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(() => {
const refetch = state.refetch
setActTimeout(() => {
refetch()
}, 10)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(30)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: undefined,
status: 'pending',
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'test',
status: 'success',
isFetching: false,
})
})
// See https://github.com/tannerlinsley/react-query/issues/137
it('should not override initial data in dependent queries', async () => {
const key1 = queryKey()
const key2 = queryKey()
function Page() {
const first = createQuery(() => ({
queryKey: key1,
queryFn: () => 'data',
enabled: false,
initialData: 'init',
}))
const second = createQuery(() => ({
queryKey: key2,
queryFn: () => 'data',
enabled: false,
initialData: 'init',
}))
return (
<div>
<h2>First Data: {first.data}</h2>
<h2>Second Data: {second.data}</h2>
<div>First Status: {first.status}</div>
<div>Second Status: {second.status}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
screen.getByText('First Data: init')
screen.getByText('Second Data: init')
screen.getByText('First Status: success')
screen.getByText('Second Status: success')
})
it('should not override query configuration on render', async () => {
const key = queryKey()
const queryFn1 = async () => {
await sleep(10)
return 'data1'
}
const queryFn2 = async () => {
await sleep(10)
return 'data2'
}
function Page() {
createQuery(() => ({ queryKey: key, queryFn: queryFn1 }))
createQuery(() => ({ queryKey: key, queryFn: queryFn2 }))
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
expect(queryCache.find({ queryKey: key })!.options.queryFn).toBe(queryFn1)
})
it('should batch re-renders', async () => {
const key = queryKey()
let renders = 0
const queryFn = async () => {
await sleep(15)
return 'data'
}
function Page() {
createQuery(() => ({ queryKey: key, queryFn }))
createQuery(() => ({ queryKey: key, queryFn }))
renders++
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(20)
// Since components are rendered once
// There wiil only be one pass
expect(renders).toBe(1)
})
it('should render latest data even if react has discarded certain renders', async () => {
const key = queryKey()
function Page() {
const [, setNewState] = createSignal('state')
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
}))
createEffect(() => {
setActTimeout(() => {
queryClient.setQueryData(key, 'new')
// Update with same state to make react discard the next render
setNewState('state')
}, 10)
})
return <div>{state.data}</div>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('new'))
})
// See https://github.com/tannerlinsley/react-query/issues/170
it('should start with status pending, fetchStatus idle if enabled is false', async () => {
const key1 = queryKey()
const key2 = queryKey()
function Page() {
const first = createQuery(() => ({
queryKey: key1,
queryFn: () => 'data',
enabled: false,
}))
const second = createQuery(() => ({
queryKey: key2,
queryFn: () => 'data',
}))
return (
<div>
<div>
First Status: {first.status}, {first.fetchStatus}
</div>
<div>
Second Status: {second.status}, {second.fetchStatus}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
// use "act" to wait for state update and prevent console warning
screen.getByText('First Status: pending, idle')
await waitFor(() => screen.getByText('Second Status: pending, fetching'))
await waitFor(() => screen.getByText('Second Status: success, idle'))
})
// See https://github.com/tannerlinsley/react-query/issues/144
it('should be in "pending" state by default', async () => {
const key = queryKey()
function Page() {
const { status } = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
}))
return <div>status: {status}</div>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
screen.getByText('status: pending')
})
it('should not refetch query on focus when `enabled` is set to `false`', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
function Page() {
const { data = 'default' } = createQuery(() => ({
queryKey: key,
queryFn,
enabled: false,
}))
return (
<div>
<h1>{data}</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('default'))
window.dispatchEvent(new Event('visibilitychange'))
expect(queryFn).not.toHaveBeenCalled()
})
it('should not refetch stale query on focus when `refetchOnWindowFocus` is set to `false`', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => count++,
staleTime: 0,
refetchOnWindowFocus: false,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
window.dispatchEvent(new Event('visibilitychange'))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined, isFetching: true })
expect(states[1]).toMatchObject({ data: 0, isFetching: false })
})
it('should not refetch stale query on focus when `refetchOnWindowFocus` is set to a function that returns `false`', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => count++,
staleTime: 0,
refetchOnWindowFocus: () => false,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
window.dispatchEvent(new Event('visibilitychange'))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined, isFetching: true })
expect(states[1]).toMatchObject({ data: 0, isFetching: false })
})
it('should not refetch fresh query on focus when `refetchOnWindowFocus` is set to `true`', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => count++,
staleTime: Infinity,
refetchOnWindowFocus: true,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
window.dispatchEvent(new Event('visibilitychange'))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined, isFetching: true })
expect(states[1]).toMatchObject({ data: 0, isFetching: false })
})
it('should refetch fresh query on focus when `refetchOnWindowFocus` is set to `always`', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return count++
},
staleTime: Infinity,
refetchOnWindowFocus: 'always',
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(20)
window.dispatchEvent(new Event('visibilitychange'))
await sleep(20)
await waitFor(() => expect(states.length).toBe(4))
expect(states[0]).toMatchObject({ data: undefined, isFetching: true })
expect(states[1]).toMatchObject({ data: 0, isFetching: false })
expect(states[2]).toMatchObject({ data: 0, isFetching: true })
expect(states[3]).toMatchObject({ data: 1, isFetching: false })
})
it('should calculate focus behaviour for refetchOnWindowFocus depending on function', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return count++
},
staleTime: 0,
retry: 0,
refetchOnWindowFocus: (query) => (query.state.data || 0) < 1,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return <div>data: {state.data}</div>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('data: 0')
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({ data: undefined, isFetching: true })
expect(states[1]).toMatchObject({ data: 0, isFetching: false })
window.dispatchEvent(new Event('visibilitychange'))
await screen.findByText('data: 1')
// refetch should happen
expect(states.length).toBe(4)
expect(states[2]).toMatchObject({ data: 0, isFetching: true })
expect(states[3]).toMatchObject({ data: 1, isFetching: false })
await sleep(20)
// no more refetch now
expect(states.length).toBe(4)
})
it('should refetch fresh query when refetchOnMount is set to always', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => 'prefetched',
})
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
refetchOnMount: 'always',
staleTime: Infinity,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'prefetched',
isStale: false,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: false,
isFetching: false,
})
})
it('should refetch stale query when refetchOnMount is set to true', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => 'prefetched',
})
await sleep(10)
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
refetchOnMount: true,
staleTime: 0,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'prefetched',
isStale: true,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: true,
isFetching: false,
})
})
it('should set status to error if queryFn throws', async () => {
const key = queryKey()
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => {
return Promise.reject(new Error('Error test jaylen'))
},
retry: false,
}))
return (
<div>
<h1>{state.status}</h1>
<h2>{state.error?.message}</h2>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('error'))
await waitFor(() => screen.getByText('Error test jaylen'))
consoleMock.mockRestore()
})
it('should throw error if queryFn throws and throwOnError is in use', async () => {
const key = queryKey()
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => Promise.reject(new Error('Error test jaylen')),
retry: false,
throwOnError: true,
}))
return (
<div>
<h1>{state.status}</h1>
<h2>{state.error?.message}</h2>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<ErrorBoundary fallback={() => <div>error boundary</div>}>
<Page />
</ErrorBoundary>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should update with data if we observe no properties and throwOnError', async () => {
const key = queryKey()
let result: CreateQueryResult<string> | undefined
function Page() {
const query = createQuery(() => ({
queryKey: key,
queryFn: () => Promise.resolve('data'),
throwOnError: true,
}))
createEffect(() => {
result = query
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(result?.data).toBe('data')
})
it('should set status to error instead of throwing when error should not be thrown', async () => {
const key = queryKey()
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => Promise.reject(new Error('Local Error')),
retry: false,
throwOnError: (err) => err.message !== 'Local Error',
}))
return (
<div>
<h1>{state.status}</h1>
<h2>{state.error?.message}</h2>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<ErrorBoundary fallback={() => <div>error boundary</div>}>
<Page />
</ErrorBoundary>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('error'))
await waitFor(() => screen.getByText('Local Error'))
})
it('should throw error instead of setting status when error should be thrown', async () => {
const key = queryKey()
function Page() {
const state = createQuery<unknown, Error>(() => ({
queryKey: key,
queryFn: () => Promise.reject(new Error('Remote Error')),
retry: false,
throwOnError: (err) => err.message !== 'Local Error',
}))
return (
<div>
<h1>{state.status}</h1>
<h2>{state.error?.message ?? ''}</h2>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<ErrorBoundary
fallback={(error) => (
<div>
<div>error boundary</div>
{/* eslint-disable-next-line @typescript-eslint/no-unnecessary-condition */}
<div>{error?.message}</div>
</div>
)}
>
<Page />
</ErrorBoundary>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('error boundary'))
await waitFor(() => screen.getByText('Remote Error'))
})
it('should continue retries when observers unmount and remount while waiting for a retry (#3031)', async () => {
const key = queryKey()
let count = 0
function Page() {
const result = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return Promise.reject(new Error('some error'))
},
retry: 2,
retryDelay: 100,
}))
return (
<div>
<div>error: {result.error?.message ?? 'null'}</div>
<div>failureCount: {result.failureCount}</div>
<div>failureReason: {result.failureReason?.message}</div>
</div>
)
}
function App() {
const [show, setShow] = createSignal(true)
const toggle = () => setShow((s) => !s)
return (
<div>
<button onClick={toggle}>{show() ? 'hide' : 'show'}</button>
{show() && <Page />}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('failureCount: 1'))
await waitFor(() => screen.getByText('failureReason: some error'))
fireEvent.click(screen.getByRole('button', { name: /hide/i }))
await waitFor(() => screen.getByRole('button', { name: /show/i }))
fireEvent.click(screen.getByRole('button', { name: /show/i }))
await waitFor(() => screen.getByText('error: some error'))
expect(count).toBe(3)
})
it('should restart when observers unmount and remount while waiting for a retry when query was cancelled in between (#3031)', async () => {
const key = queryKey()
let count = 0
function Page() {
const result = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return Promise.reject(new Error('some error'))
},
retry: 2,
retryDelay: 100,
}))
return (
<div>
<div>error: {result.error?.message ?? 'null'}</div>
<div>failureCount: {result.failureCount}</div>
<div>failureReason: {result.failureReason?.message}</div>
</div>
)
}
function App() {
const [show, setShow] = createSignal(true)
const toggle = () => setShow((s) => !s)
return (
<div>
<button onClick={toggle}>{show() ? 'hide' : 'show'}</button>
<button onClick={() => queryClient.cancelQueries({ queryKey: key })}>
cancel
</button>
{show() && <Page />}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('failureCount: 1'))
await waitFor(() => screen.getByText('failureReason: some error'))
fireEvent.click(screen.getByRole('button', { name: /hide/i }))
fireEvent.click(screen.getByRole('button', { name: /cancel/i }))
await waitFor(() => screen.getByRole('button', { name: /show/i }))
fireEvent.click(screen.getByRole('button', { name: /show/i }))
await waitFor(() => screen.getByText('error: some error'))
// initial fetch (1), which will be cancelled, followed by new mount(2) + 2 retries = 4
expect(count).toBe(4)
})
it('should always fetch if refetchOnMount is set to always', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => 'prefetched',
})
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
refetchOnMount: 'always',
staleTime: 50,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<div>data: {state.data ?? 'null'}</div>
<div>isFetching: {state.isFetching}</div>
<div>isStale: {state.isStale}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: data'))
await waitFor(() => expect(states.length).toBe(3))
expect(states[0]).toMatchObject({
data: 'prefetched',
isStale: false,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: false,
isFetching: false,
})
expect(states[2]).toMatchObject({
data: 'data',
isStale: true,
isFetching: false,
})
})
it('should fetch if initial data is set', async () => {
const key = queryKey()
const states: Array<DefinedCreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
initialData: 'initial',
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(50)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'initial',
isStale: true,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: true,
isFetching: false,
})
})
it('should not fetch if initial data is set with a stale time', async () => {
const key = queryKey()
const states: Array<DefinedCreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
staleTime: 50,
initialData: 'initial',
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'initial',
isStale: false,
isFetching: false,
})
expect(states[1]).toMatchObject({
data: 'initial',
isStale: true,
isFetching: false,
})
})
it('should fetch if initial data updated at is older than stale time', async () => {
const key = queryKey()
const states: Array<DefinedCreateQueryResult<string>> = []
const oneSecondAgo = Date.now() - 1000
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
staleTime: 50,
initialData: 'initial',
initialDataUpdatedAt: oneSecondAgo,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(3)
expect(states[0]).toMatchObject({
data: 'initial',
isStale: true,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: false,
isFetching: false,
})
expect(states[2]).toMatchObject({
data: 'data',
isStale: true,
isFetching: false,
})
})
it('should fetch if "initial data updated at" is exactly 0', async () => {
const key = queryKey()
const states: Array<DefinedCreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
staleTime: 10 * 1000, // 10 seconds
initialData: 'initial',
initialDataUpdatedAt: 0,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
expect(states[0]).toMatchObject({
data: 'initial',
isStale: true,
isFetching: true,
})
expect(states[1]).toMatchObject({
data: 'data',
isStale: false,
isFetching: false,
})
})
it('should keep initial data when the query key changes', async () => {
const key = queryKey()
const states: Array<Partial<DefinedCreateQueryResult<{ count: number }>>> =
[]
function Page() {
const [count, setCount] = createSignal(0)
const state = createQuery(() => ({
queryKey: [key, count()],
queryFn: () => ({ count: 10 }),
staleTime: Infinity,
initialData: () => ({ count: count() }),
reconcile: false,
}))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(() => {
setActTimeout(() => {
setCount(1)
}, 10)
}, [])
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
// Initial
expect(states[0]).toMatchObject({ data: { count: 0 } })
// Set state
expect(states[1]).toMatchObject({ data: { count: 1 } })
})
it('should retry specified number of times', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, unknown>()
queryFn.mockImplementation(() => {
return Promise.reject(new Error('Error test Barrett'))
})
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn,
retry: 1,
retryDelay: 1,
}))
return (
<div>
<h1>{state.status}</h1>
<h2>Failed {state.failureCount} times</h2>
<h2>Failed because {state.failureReason?.message}</h2>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('pending'))
await waitFor(() => screen.getByText('error'))
// query should fail `retry + 1` times, since first time isn't a "retry"
await waitFor(() => screen.getByText('Failed 2 times'))
await waitFor(() => screen.getByText('Failed because Error test Barrett'))
expect(queryFn).toHaveBeenCalledTimes(2)
})
it('should not retry if retry function `false`', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, unknown>()
queryFn.mockImplementationOnce(() => {
return Promise.reject(new Error('Error test Tanner'))
})
queryFn.mockImplementation(() => {
return Promise.reject(new Error('NoRetry'))
})
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn,
retryDelay: 1,
retry: (_failureCount, err) => err.message !== 'NoRetry',
}))
return (
<div>
<h1>{state.status}</h1>
<h2>Failed {state.failureCount} times</h2>
<h2>Failed because {state.failureReason?.message}</h2>
<h2>{state.error?.message}</h2>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('pending'))
await waitFor(() => screen.getByText('error'))
await waitFor(() => screen.getByText('Failed 2 times'))
await waitFor(() => screen.getByText('Failed because NoRetry'))
await waitFor(() => screen.getByText('NoRetry'))
expect(queryFn).toHaveBeenCalledTimes(2)
})
it('should extract retryDelay from error', async () => {
const key = queryKey()
type DelayError = { delay: number }
const queryFn = vi.fn<Array<unknown>, unknown>()
queryFn.mockImplementation(() => {
return Promise.reject({ delay: 50 })
})
function Page() {
const state = createQuery<unknown, DelayError>(() => ({
queryKey: key,
queryFn,
retry: 1,
retryDelay: (_, error: DelayError) => error.delay,
}))
return (
<div>
<h1>{state.status}</h1>
<h2>Failed {state.failureCount} times</h2>
<h2>Failed because DelayError: {state.failureReason?.delay}ms</h2>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(queryFn).toHaveBeenCalledTimes(1)
await waitFor(() => screen.getByText('Failed because DelayError: 50ms'))
await waitFor(() => screen.getByText('Failed 2 times'))
expect(queryFn).toHaveBeenCalledTimes(2)
})
// See https://github.com/tannerlinsley/react-query/issues/160
it('should continue retry after focus regain', async () => {
const key = queryKey()
// make page unfocused
const visibilityMock = mockVisibilityState('hidden')
let count = 0
function Page() {
const query = createQuery<unknown, string>(() => ({
queryKey: key,
queryFn: () => {
count++
return Promise.reject<unknown>(`fetching error ${count}`)
},
retry: 3,
retryDelay: 1,
}))
return (
<div>
<div>error {String(query.error)}</div>
<div>status {query.status}</div>
<div>failureCount {query.failureCount}</div>
<div>failureReason {query.failureReason}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
// The query should display the first error result
await waitFor(() => screen.getByText('failureCount 1'))
await waitFor(() => screen.getByText('failureReason fetching error 1'))
await waitFor(() => screen.getByText('status pending'))
await waitFor(() => screen.getByText('error null'))
// Check if the query really paused
await sleep(10)
await waitFor(() => screen.getByText('failureCount 1'))
await waitFor(() => screen.getByText('failureReason fetching error 1'))
visibilityMock.mockRestore()
window.dispatchEvent(new Event('visibilitychange'))
// Wait for the final result
await waitFor(() => screen.getByText('failureCount 4'))
await waitFor(() => screen.getByText('failureReason fetching error 4'))
await waitFor(() => screen.getByText('status error'))
await waitFor(() => screen.getByText('error fetching error 4'))
// Check if the query really stopped
await sleep(10)
await waitFor(() => screen.getByText('failureCount 4'))
await waitFor(() => screen.getByText('failureReason fetching error 4'))
})
it('should fetch on mount when a query was already created with setQueryData', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
queryClient.setQueryData(key, 'prefetched')
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
}))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(states.length).toBe(2)
expect(states).toMatchObject([
{
data: 'prefetched',
isFetching: true,
isStale: true,
},
{
data: 'data',
isFetching: false,
isStale: true,
},
])
})
it('should refetch after focus regain', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
// make page unfocused
const visibilityMock = mockVisibilityState('hidden')
// set data in cache to check if the hook query fn is actually called
queryClient.setQueryData(key, 'prefetched')
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'data'
},
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
{state.data}, {state.isStale}, {state.isFetching}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => expect(states.length).toBe(2))
// reset visibilityState to original value
visibilityMock.mockRestore()
window.dispatchEvent(new Event('visibilitychange'))
await waitFor(() => expect(states.length).toBe(4))
expect(states).toMatchObject([
{
data: 'prefetched',
isFetching: true,
isStale: true,
},
{
data: 'data',
isFetching: false,
isStale: true,
},
{
data: 'data',
isFetching: true,
isStale: true,
},
{
data: 'data',
isFetching: false,
isStale: true,
},
])
})
// See https://github.com/tannerlinsley/react-query/issues/195
it('should refetch if stale after a prefetch', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
const queryFn = vi.fn<Array<unknown>, string>()
queryFn.mockImplementation(() => 'data')
const prefetchQueryFn = vi.fn<Array<unknown>, string>()
prefetchQueryFn.mockImplementation(() => 'not yet...')
await queryClient.prefetchQuery({
queryKey: key,
queryFn: prefetchQueryFn,
staleTime: 10,
})
await sleep(11)
function Page() {
const state = createQuery(() => ({ queryKey: key, queryFn }))
createRenderEffect(() => {
states.push({ ...state })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => expect(states.length).toBe(2))
expect(prefetchQueryFn).toHaveBeenCalledTimes(1)
expect(queryFn).toHaveBeenCalledTimes(1)
})
it('should not refetch if not stale after a prefetch', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>()
queryFn.mockImplementation(() => 'data')
const prefetchQueryFn = vi.fn<Array<unknown>, Promise<string>>()
prefetchQueryFn.mockImplementation(async () => {
await sleep(10)
return 'not yet...'
})
await queryClient.prefetchQuery({
queryKey: key,
queryFn: prefetchQueryFn,
staleTime: 1000,
})
await sleep(0)
function Page() {
createQuery(() => ({ queryKey: key, queryFn, staleTime: 1000 }))
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(0)
expect(prefetchQueryFn).toHaveBeenCalledTimes(1)
expect(queryFn).toHaveBeenCalledTimes(0)
})
// See https://github.com/tannerlinsley/react-query/issues/190
it('should reset failureCount and failureReason on successful fetch', async () => {
const key = queryKey()
function Page() {
let counter = 0
const query = createQuery<unknown, Error>(() => ({
queryKey: key,
queryFn: async () => {
if (counter < 2) {
counter++
throw new Error('error')
} else {
return 'data'
}
},
retryDelay: 10,
}))
return (
<div>
<div>failureCount {query.failureCount}</div>
<div>failureReason {query.failureReason?.message ?? 'null'}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('failureCount 2'))
await waitFor(() => screen.getByText('failureReason error'))
await waitFor(() => screen.getByText('failureCount 0'))
await waitFor(() => screen.getByText('failureReason null'))
})
// See https://github.com/tannerlinsley/react-query/issues/199
it('should use prefetched data for dependent query', async () => {
const key = queryKey()
let count = 0
function Page() {
const [enabled, setEnabled] = createSignal(false)
const [isPrefetched, setPrefetched] = createSignal(false)
const query = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return count
},
enabled: enabled(),
}))
createEffect(() => {
async function prefetch() {
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('prefetched data'),
})
setPrefetched(true)
}
prefetch()
})
return (
<div>
{isPrefetched() && <div>isPrefetched</div>}
<button onClick={() => setEnabled(true)}>setKey</button>
<div>data: {query.data}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('isPrefetched'))
fireEvent.click(screen.getByText('setKey'))
await waitFor(() => screen.getByText('data: prefetched data'))
await waitFor(() => screen.getByText('data: 1'))
expect(count).toBe(1)
})
it('should support dependent queries via the enable config option', async () => {
const key = queryKey()
function Page() {
const [shouldFetch, setShouldFetch] = createSignal(false)
const query = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
enabled: shouldFetch(),
}))
return (
<div>
<div>FetchStatus: {query.fetchStatus}</div>
<h2>Data: {query.data || 'no data'}</h2>
{query.isStale ? (
<button onClick={() => setShouldFetch(true)}>fetch</button>
) : null}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
screen.getByText('FetchStatus: idle')
screen.getByText('Data: no data')
fireEvent.click(screen.getByText('fetch'))
await waitFor(() => screen.getByText('FetchStatus: fetching'))
await waitFor(() => [
screen.getByText('FetchStatus: idle'),
screen.getByText('Data: data'),
])
})
it('should mark query as fetching, when using initialData', async () => {
const key = queryKey()
const results: Array<DefinedCreateQueryResult<string>> = []
function Page() {
const result = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'serverData'
},
initialData: 'initialData',
}))
createRenderEffect(() => {
results.push({ ...result })
})
return <div>data: {result.data}</div>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: initialData'))
await waitFor(() => screen.getByText('data: serverData'))
expect(results.length).toBe(2)
expect(results[0]).toMatchObject({ data: 'initialData', isFetching: true })
expect(results[1]).toMatchObject({ data: 'serverData', isFetching: false })
})
it('should initialize state properly, when initialData is falsy', async () => {
const key = queryKey()
const results: Array<DefinedCreateQueryResult<number>> = []
function Page() {
const result = createQuery(() => ({
queryKey: key,
queryFn: () => 1,
initialData: 0,
}))
createRenderEffect(() => {
results.push({ ...result })
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(results.length).toBe(2)
expect(results[0]).toMatchObject({ data: 0, isFetching: true })
expect(results[1]).toMatchObject({ data: 1, isFetching: false })
})
// // See https://github.com/tannerlinsley/react-query/issues/214
it('data should persist when enabled is changed to false', async () => {
const key = queryKey()
const results: Array<DefinedCreateQueryResult<string>> = []
function Page() {
const [shouldFetch, setShouldFetch] = createSignal(true)
const result = createQuery(() => ({
queryKey: key,
queryFn: () => 'fetched data',
enabled: shouldFetch(),
initialData: shouldFetch() ? 'initial' : 'initial falsy',
}))
createRenderEffect(() => {
results.push({ ...result })
})
createEffect(() => {
setActTimeout(() => {
setShouldFetch(false)
}, 5)
})
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(50)
expect(results.length).toBe(2)
expect(results[0]).toMatchObject({ data: 'initial', isStale: true })
expect(results[1]).toMatchObject({ data: 'fetched data', isStale: true })
// Wont render 3rd time, because data is still the same
})
it('it should support enabled:false in query object syntax', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>()
queryFn.mockImplementation(() => 'data')
function Page() {
const { fetchStatus } = createQuery(() => ({
queryKey: key,
queryFn,
enabled: false,
}))
return <div>fetchStatus: {fetchStatus}</div>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
expect(queryFn).not.toHaveBeenCalled()
expect(queryCache.find({ queryKey: key })).not.toBeUndefined()
screen.getByText('fetchStatus: idle')
})
// See https://github.com/tannerlinsley/react-query/issues/360
it('should init to status:pending, fetchStatus:idle when enabled is false', async () => {
const key = queryKey()
function Page() {
const query = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
enabled: false,
}))
return (
<div>
<div>
status: {query.status}, {query.fetchStatus}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('status: pending, idle'))
})
it('should not schedule garbage collection, if gcTimeout is set to `Infinity`', async () => {
const key = queryKey()
function Page() {
const query = createQuery(() => ({
queryKey: key,
queryFn: () => 'fetched data',
gcTime: Infinity,
}))
return <div>{query.data}</div>
}
const result = render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('fetched data'))
const setTimeoutSpy = vi.spyOn(window, 'setTimeout')
result.unmount()
expect(setTimeoutSpy).not.toHaveBeenCalled()
})
it('should schedule garbage collection, if gcTimeout is not set to `Infinity`', async () => {
const key = queryKey()
function Page() {
const query = createQuery(() => ({
queryKey: key,
queryFn: () => 'fetched data',
gcTime: 1000 * 60 * 10, //10 Minutes
}))
return <div>{query.data}</div>
}
const result = render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('fetched data'))
const setTimeoutSpy = vi.spyOn(window, 'setTimeout')
result.unmount()
expect(setTimeoutSpy).toHaveBeenLastCalledWith(
expect.any(Function),
1000 * 60 * 10,
)
})
it('should not cause memo churn when data does not change', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
const memoFn = vi.fn()
function Page() {
const result = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return (
queryFn() || {
data: {
nested: true,
},
}
)
},
}))
createMemo(() => {
memoFn()
return result.data
})
return (
<div>
<div>status {result.status}</div>
<div>isFetching {result.isFetching ? 'true' : 'false'}</div>
<button onClick={() => result.refetch()}>refetch</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('status pending'))
await waitFor(() => screen.getByText('status success'))
fireEvent.click(screen.getByText('refetch'))
await waitFor(() => screen.getByText('isFetching true'))
await waitFor(() => screen.getByText('isFetching false'))
expect(queryFn).toHaveBeenCalledTimes(2)
expect(memoFn).toHaveBeenCalledTimes(2)
})
it('should update data upon interval changes', async () => {
const key = queryKey()
let count = 0
function Page() {
const [int, setInt] = createSignal(200)
const state = createQuery(() => ({
queryKey: key,
queryFn: () => count++,
refetchInterval: int(),
}))
createEffect(() => {
if (state.data === 2) {
setInt(0)
}
})
return <div>count: {state.data}</div>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
// mount
await waitFor(() => screen.getByText('count: 0'))
await waitFor(() => screen.getByText('count: 1'))
await waitFor(() => screen.getByText('count: 2'))
})
it('should refetch in an interval depending on function result', async () => {
const key = queryKey()
let count = 0
const states: Array<CreateQueryResult<number>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return count++
},
refetchInterval: ({ state: { data = 0 } }) => (data < 2 ? 10 : false),
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<h1>count: {state.data}</h1>
<h2>status: {state.status}</h2>
<h2>data: {state.data}</h2>
<h2>refetch: {state.isRefetching}</h2>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('count: 2'))
expect(states.length).toEqual(6)
expect(states).toMatchObject([
{
status: 'pending',
isFetching: true,
data: undefined,
},
{
status: 'success',
isFetching: false,
data: 0,
},
{
status: 'success',
isFetching: true,
data: 0,
},
{
status: 'success',
isFetching: false,
data: 1,
},
{
status: 'success',
isFetching: true,
data: 1,
},
{
status: 'success',
isFetching: false,
data: 2,
},
])
})
it('should not interval fetch with a refetchInterval of 0', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 1,
refetchInterval: 0,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return <div>count: {state.data}</div>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('count: 1'))
await sleep(10) //extra sleep to make sure we're not re-fetching
expect(states.length).toEqual(2)
expect(states).toMatchObject([
{
status: 'pending',
isFetching: true,
data: undefined,
},
{
status: 'success',
isFetching: false,
data: 1,
},
])
})
it('should accept an empty string as query key', async () => {
function Page() {
const result = createQuery(() => ({
queryKey: [''],
queryFn: (ctx) => ctx.queryKey,
}))
return <>{JSON.stringify(result.data)}</>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText(''))
})
it('should accept an object as query key', async () => {
function Page() {
const result = createQuery(() => ({
queryKey: [{ a: 'a' }],
queryFn: (ctx) => ctx.queryKey,
}))
return <>{JSON.stringify(result.data)}</>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('[{"a":"a"}]'))
})
it('should refetch if any query instance becomes enabled', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
function Disabled() {
createQuery(() => ({ queryKey: key, queryFn, enabled: false }))
return null
}
function Page() {
const [enabled, setEnabled] = createSignal(false)
const result = createQuery(() => ({
queryKey: key,
queryFn,
enabled: enabled(),
}))
return (
<>
<Disabled />
<div>{result.data}</div>
<button onClick={() => setEnabled(true)}>enable</button>
</>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
expect(queryFn).toHaveBeenCalledTimes(0)
fireEvent.click(screen.getByText('enable'))
await waitFor(() => screen.getByText('data'))
expect(queryFn).toHaveBeenCalledTimes(1)
})
it('should use placeholder data while the query loads', async () => {
const key1 = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key1,
queryFn: () => 'data',
placeholderData: 'placeholder',
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<h2>Data: {state.data}</h2>
<div>Status: {state.status}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Data: data'))
expect(states).toMatchObject([
{
isSuccess: true,
isPlaceholderData: true,
data: 'placeholder',
},
{
isSuccess: true,
isPlaceholderData: false,
data: 'data',
},
])
})
it('should use placeholder data even for disabled queries', async () => {
const key1 = queryKey()
const states: Array<{ state: CreateQueryResult<string>; count: number }> =
[]
function Page() {
const [count, setCount] = createSignal(0)
const state = createQuery(() => ({
queryKey: key1,
queryFn: () => 'data',
placeholderData: 'placeholder',
enabled: count() === 0,
}))
createRenderEffect(() => {
states.push({ state: { ...state }, count: count() })
})
createEffect(() => {
setCount(1)
})
return (
<div>
<h2>Data: {state.data}</h2>
<div>Status: {state.status}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Data: data'))
expect(states).toMatchObject([
{
state: {
isSuccess: true,
isPlaceholderData: true,
data: 'placeholder',
},
count: 0,
},
{
state: {
isSuccess: true,
isPlaceholderData: true,
data: 'placeholder',
},
count: 1,
},
{
state: {
isSuccess: true,
isPlaceholderData: false,
data: 'data',
},
count: 1,
},
])
})
it('placeholder data should run through select', async () => {
const key1 = queryKey()
const states: Array<CreateQueryResult<string>> = []
function Page() {
const state = createQuery(() => ({
queryKey: key1,
queryFn: () => 1,
placeholderData: 23,
select: (data) => String(data * 2),
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<h2>Data: {state.data}</h2>
<div>Status: {state.status}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Data: 2'))
expect(states).toMatchObject([
{
isSuccess: true,
isPlaceholderData: true,
data: '46',
},
{
isSuccess: true,
isPlaceholderData: false,
data: '2',
},
])
})
it('placeholder data function result should run through select', async () => {
const key1 = queryKey()
const states: Array<CreateQueryResult<string>> = []
let placeholderFunctionRunCount = 0
function Page() {
const state = createQuery(() => ({
queryKey: key1,
queryFn: () => 1,
placeholderData: () => {
placeholderFunctionRunCount++
return 23
},
select: (data) => String(data * 2),
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<h2>Data: {state.data}</h2>
<div>Status: {state.status}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Data: 2'))
expect(states).toMatchObject([
{
isSuccess: true,
isPlaceholderData: true,
data: '46',
},
{
isSuccess: true,
isPlaceholderData: false,
data: '2',
},
])
expect(placeholderFunctionRunCount).toEqual(1)
})
it('select should always return the correct state', async () => {
const key1 = queryKey()
function Page() {
const [count, setCount] = createSignal(2)
const [forceValue, setForceValue] = createSignal(1)
const inc = () => {
setCount((prev) => prev + 1)
}
const forceUpdate = () => {
setForceValue((prev) => prev + 1)
}
const state = createQuery(() => ({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 0
},
get select() {
const currentCount = count()
return (data: number) => `selected ${data + currentCount}`
},
placeholderData: 99,
}))
return (
<div>
<h2>Data: {state.data}</h2>
<h2>forceValue: {forceValue()}</h2>
<button onClick={inc}>inc: {count()}</button>
<button onClick={forceUpdate}>forceUpdate</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Data: selected 101')) // 99 + 2
await waitFor(() => screen.getByText('Data: selected 2')) // 0 + 2
fireEvent.click(screen.getByRole('button', { name: /inc/i }))
await waitFor(() => screen.getByText('Data: selected 3')) // 0 + 3
fireEvent.click(screen.getByRole('button', { name: /forceUpdate/i }))
await waitFor(() => screen.getByText('forceValue: 2'))
// data should still be 3 after an independent re-render
await waitFor(() => screen.getByText('Data: selected 3'))
})
it('select should structurally share data', async () => {
const key1 = queryKey()
const states: Array<Array<number>> = []
function Page() {
const [forceValue, setForceValue] = createSignal(1)
const state = createQuery(() => ({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return [1, 2]
},
select: (res) => res.map((x) => x + 1),
}))
createEffect(() => {
if (state.data) {
states.push(state.data)
}
})
const forceUpdate = () => {
setForceValue((prev) => prev + 1)
}
return (
<div>
<h2>Data: {JSON.stringify(state.data)}</h2>
<h2>forceValue: {forceValue()}</h2>
<button onClick={forceUpdate}>forceUpdate</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Data: [2,3]'))
expect(states).toHaveLength(1)
fireEvent.click(screen.getByRole('button', { name: /forceUpdate/i }))
await waitFor(() => screen.getByText('forceValue: 2'))
await waitFor(() => screen.getByText('Data: [2,3]'))
// effect should not be triggered again due to structural sharing
expect(states).toHaveLength(1)
})
it('The reconcile fn callback should correctly maintain referential equality', async () => {
const key1 = queryKey()
const states: Array<Array<number>> = []
function Page() {
const [forceValue, setForceValue] = createSignal(1)
const state = createQuery(() => ({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return [1, 2]
},
select: (res) => res.map((x) => x + 1),
reconcile(oldData, newData) {
return reconcile(newData)(oldData)
},
}))
createEffect(() => {
if (state.data) {
states.push(state.data)
}
})
const forceUpdate = () => {
setForceValue((prev) => prev + 1)
}
return (
<div>
<h2>Data: {JSON.stringify(state.data)}</h2>
<h2>forceValue: {forceValue()}</h2>
<button onClick={forceUpdate}>forceUpdate</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Data: [2,3]'))
expect(states).toHaveLength(1)
fireEvent.click(screen.getByRole('button', { name: /forceUpdate/i }))
await waitFor(() => screen.getByText('forceValue: 2'))
await waitFor(() => screen.getByText('Data: [2,3]'))
// effect should not be triggered again due to structural sharing
expect(states).toHaveLength(1)
})
it('should cancel the query function when there are no more subscriptions', async () => {
const key = queryKey()
let cancelFn: Mock = vi.fn()
const queryFn = ({ signal }: { signal?: AbortSignal }) => {
const promise = new Promise<string>((resolve, reject) => {
cancelFn = vi.fn(() => reject('Cancelled'))
signal?.addEventListener('abort', cancelFn)
sleep(20).then(() => resolve('OK'))
})
return promise
}
function Page() {
const state = createQuery(() => ({ queryKey: key, queryFn }))
return (
<div>
<h1>Status: {state.status}</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Blink duration={5}>
<Page />
</Blink>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('off'))
expect(cancelFn).toHaveBeenCalled()
})
it('should cancel the query if the signal was consumed and there are no more subscriptions', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
const queryFn: QueryFunction<
string,
readonly [typeof key, number]
> = async (ctx) => {
const [, limit] = ctx.queryKey
// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
const value = limit % 2 && ctx.signal ? 'abort' : `data ${limit}`
await sleep(25)
return value
}
function Page(props: { limit: number }) {
const state = createQuery(() => ({
queryKey: [key, props.limit] as const,
queryFn,
}))
states[props.limit] = state
return (
<div>
<h1>Status: {state.status}</h1>
<h1>data: {state.data}</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Blink duration={5}>
<Page limit={0} />
<Page limit={1} />
<Page limit={2} />
<Page limit={3} />
</Blink>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('off'))
await sleep(20)
await waitFor(() => expect(states).toHaveLength(4))
expect(queryCache.find({ queryKey: [key, 0] })?.state).toMatchObject({
data: 'data 0',
status: 'success',
dataUpdateCount: 1,
})
expect(queryCache.find({ queryKey: [key, 1] })?.state).toMatchObject({
data: undefined,
status: 'pending',
fetchStatus: 'idle',
})
expect(queryCache.find({ queryKey: [key, 2] })?.state).toMatchObject({
data: 'data 2',
status: 'success',
dataUpdateCount: 1,
})
expect(queryCache.find({ queryKey: [key, 3] })?.state).toMatchObject({
data: undefined,
status: 'pending',
fetchStatus: 'idle',
})
})
it('should refetch when quickly switching to a failed query', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<string>> = []
const queryFn = async () => {
await sleep(50)
return 'OK'
}
function Page() {
const [id, setId] = createSignal(1)
const [hasChanged, setHasChanged] = createSignal(false)
const state = createQuery(() => ({ queryKey: [key, id()], queryFn }))
createRenderEffect(() => {
states.push({ ...state })
})
createEffect(
on(hasChanged, () => {
setId((prevId) => (prevId === 1 ? 2 : 1))
setHasChanged(true)
}),
)
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(100)
expect(states.length).toBe(2)
// Load query 1
expect(states[0]).toMatchObject({
status: 'pending',
error: null,
})
// No rerenders - No state updates
// Loaded query 1
expect(states[1]).toMatchObject({
status: 'success',
error: null,
})
})
it('should update query state and refetch when reset with resetQueries', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
staleTime: Infinity,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<button onClick={() => queryClient.resetQueries({ queryKey: key })}>
reset
</button>
<div>data: {state.data ?? 'null'}</div>
<div>isFetching: {state.isFetching}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: 1'))
fireEvent.click(screen.getByRole('button', { name: /reset/i }))
await waitFor(() => expect(states.length).toBe(4))
await waitFor(() => screen.getByText('data: 2'))
expect(count).toBe(2)
expect(states[0]).toMatchObject({
isPending: true,
isFetching: true,
isSuccess: false,
isStale: true,
})
expect(states[1]).toMatchObject({
data: 1,
isPending: false,
isFetching: false,
isSuccess: true,
isStale: false,
})
expect(states[2]).toMatchObject({
isPending: true,
isFetching: true,
isSuccess: false,
isStale: true,
})
expect(states[3]).toMatchObject({
data: 2,
isPending: false,
isFetching: false,
isSuccess: true,
isStale: false,
})
})
it('should update query state and not refetch when resetting a disabled query with resetQueries', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
count++
return count
},
staleTime: Infinity,
enabled: false,
notifyOnChangeProps: 'all',
}))
createRenderEffect(() => {
states.push({ ...state })
})
const { refetch } = state
return (
<div>
<button onClick={() => refetch()}>refetch</button>
<button onClick={() => queryClient.resetQueries({ queryKey: key })}>
reset
</button>
<div>data: {state.data ?? 'null'}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: null'))
fireEvent.click(screen.getByRole('button', { name: /refetch/i }))
await waitFor(() => screen.getByText('data: 1'))
fireEvent.click(screen.getByRole('button', { name: /reset/i }))
await waitFor(() => screen.getByText('data: null'))
await waitFor(() => expect(states.length).toBe(4))
expect(count).toBe(1)
expect(states[0]).toMatchObject({
isPending: true,
isFetching: false,
isSuccess: false,
isStale: true,
})
expect(states[1]).toMatchObject({
isPending: true,
isFetching: true,
isSuccess: false,
isStale: true,
})
expect(states[2]).toMatchObject({
data: 1,
isPending: false,
isFetching: false,
isSuccess: true,
isStale: false,
})
expect(states[3]).toMatchObject({
isPending: true,
isFetching: false,
isSuccess: false,
isStale: true,
})
})
it('should only call the query hash function once', async () => {
const key = queryKey()
let hashes = 0
function queryKeyHashFn(x: any) {
hashes++
return JSON.stringify(x)
}
function Page() {
createQuery(() => ({
queryKey: key,
queryFn: () => 'test',
queryKeyHashFn,
}))
return null
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await sleep(10)
expect(hashes).toBe(1)
})
it('should refetch when changed enabled to true in error state', async () => {
const queryFn = vi.fn<Array<unknown>, unknown>()
queryFn.mockImplementation(async () => {
await sleep(10)
return Promise.reject(new Error('Suspense Error Bingo'))
})
function Page(props: { enabled: boolean }) {
const state = createQuery(() => ({
queryKey: ['key'],
queryFn,
enabled: props.enabled,
retry: false,
retryOnMount: false,
refetchOnMount: false,
refetchOnWindowFocus: false,
}))
return (
<Switch fallback={<div>rendered</div>}>
<Match when={state.isPending}>
<div>status: pending</div>
</Match>
<Match when={state.error instanceof Error}>
<div>error</div>
</Match>
</Switch>
)
}
function App() {
const [enabled, setEnabled] = createSignal(true)
const toggle = () => setEnabled((prev) => !prev)
return (
<div>
<Page enabled={enabled()} />
<button aria-label="retry" onClick={toggle}>
retry {enabled()}
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
// initial state check
screen.getByText('status: pending')
// // render error state component
await waitFor(() => screen.getByText('error'))
expect(queryFn).toBeCalledTimes(1)
// change to enabled to false
fireEvent.click(screen.getByLabelText('retry'))
await waitFor(() => screen.getByText('error'))
expect(queryFn).toBeCalledTimes(1)
// // change to enabled to true
fireEvent.click(screen.getByLabelText('retry'))
expect(queryFn).toBeCalledTimes(2)
})
it('should refetch when query key changed when previous status is error', async () => {
function Page(props: { id: number }) {
const state = createQuery(() => ({
queryKey: [props.id],
queryFn: async () => {
await sleep(10)
if (props.id % 2 === 1) {
return Promise.reject(new Error('Error'))
} else {
return 'data'
}
},
retry: false,
retryOnMount: false,
refetchOnMount: false,
refetchOnWindowFocus: false,
}))
return (
<Switch fallback={<div>rendered</div>}>
<Match when={state.isPending}>
<div>status: pending</div>
</Match>
<Match when={state.error instanceof Error}>
<div>error</div>
</Match>
</Switch>
)
}
function App() {
const [id, setId] = createSignal(1)
const changeId = () => setId((x) => x + 1)
return (
<div>
<Page id={id()} />
<button aria-label="change" onClick={changeId}>
change {id()}
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
// initial state check
screen.getByText('status: pending')
// render error state component
await waitFor(() => screen.getByText('error'))
// change to unmount query
fireEvent.click(screen.getByLabelText('change'))
await waitFor(() => screen.getByText('rendered'))
// change to mount new query
fireEvent.click(screen.getByLabelText('change'))
await waitFor(() => screen.getByText('error'))
})
it('should refetch when query key changed when switching between erroneous queries', async () => {
function Page(props: { id: boolean }) {
const state = createQuery(() => ({
queryKey: [props.id],
queryFn: async () => {
await sleep(10)
return Promise.reject<unknown>(new Error('Error'))
},
retry: false,
retryOnMount: false,
refetchOnMount: false,
refetchOnWindowFocus: false,
}))
return (
<Switch fallback={<div>rendered</div>}>
<Match when={state.isFetching}>
<div>status: fetching</div>
</Match>
<Match when={state.error instanceof Error}>
<div>error</div>
</Match>
</Switch>
)
}
function App() {
const [value, setValue] = createSignal(true)
const toggle = () => setValue((x) => !x)
return (
<div>
<Page id={value()} />
<button aria-label="change" onClick={toggle}>
change {value()}
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
// initial state check
screen.getByText('status: fetching')
// render error state component
await waitFor(() => screen.getByText('error'))
// change to mount second query
fireEvent.click(screen.getByLabelText('change'))
await waitFor(() => screen.getByText('status: fetching'))
await waitFor(() => screen.getByText('error'))
// change to mount first query again
fireEvent.click(screen.getByLabelText('change'))
await waitFor(() => screen.getByText('status: fetching'))
await waitFor(() => screen.getByText('error'))
})
it('should have no error in pending state when refetching after error occurred', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
const error = new Error('oops')
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (count === 0) {
count++
throw error
}
return 5
},
retry: false,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<Switch fallback={<div>data: {state.data}</div>}>
<Match when={state.isPending}>
<div>status: pending</div>
</Match>
<Match when={state.error instanceof Error}>
<div>
<div>error</div>
<button onClick={() => state.refetch()}>refetch</button>
</div>
</Match>
</Switch>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('error'))
fireEvent.click(screen.getByRole('button', { name: 'refetch' }))
await waitFor(() => screen.getByText('data: 5'))
await waitFor(() => expect(states.length).toBe(4))
expect(states[0]).toMatchObject({
status: 'pending',
data: undefined,
error: null,
})
expect(states[1]).toMatchObject({
status: 'error',
data: undefined,
error,
})
expect(states[2]).toMatchObject({
status: 'pending',
data: undefined,
error: null,
})
expect(states[3]).toMatchObject({
status: 'success',
data: 5,
error: null,
})
})
describe('networkMode online', () => {
it('online queries should not start fetching if you are offline', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const key = queryKey()
const states: Array<any> = []
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'data'
},
}))
createEffect(() => {
states.push(state.fetchStatus)
})
return (
<div>
<div>
status: {state.status}, isPaused: {String(state.isPaused)}
</div>
<div>data: {state.data}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
window.dispatchEvent(new Event('offline'))
await waitFor(() => screen.getByText('status: pending, isPaused: true'))
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await waitFor(() => screen.getByText('status: success, isPaused: false'))
await waitFor(() => {
expect(screen.getByText('data: data')).toBeInTheDocument()
})
expect(states).toEqual(['paused', 'fetching', 'idle'])
})
it('online queries should not refetch if you are offline', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = createQuery<unknown, string, string>(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
}))
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus},
failureCount: {state.failureCount}
</div>
<div>failureReason: {state.failureReason ?? 'null'}</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: data1'))
const onlineMock = mockOnlineManagerIsOnline(false)
window.dispatchEvent(new Event('offline'))
fireEvent.click(screen.getByRole('button', { name: /invalidate/i }))
await waitFor(() =>
screen.getByText(
'status: success, fetchStatus: paused, failureCount: 0',
),
)
await waitFor(() => screen.getByText('failureReason: null'))
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await waitFor(() =>
screen.getByText(
'status: success, fetchStatus: fetching, failureCount: 0',
),
)
await waitFor(() => screen.getByText('failureReason: null'))
await waitFor(() =>
screen.getByText('status: success, fetchStatus: idle, failureCount: 0'),
)
await waitFor(() => screen.getByText('failureReason: null'))
await waitFor(() => {
expect(screen.getByText('data: data2')).toBeInTheDocument()
})
})
it('online queries should not refetch if you are offline and refocus', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
}))
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: data1'))
const onlineMock = mockOnlineManagerIsOnline(false)
fireEvent.click(screen.getByRole('button', { name: /invalidate/i }))
await waitFor(() =>
screen.getByText('status: success, fetchStatus: paused'),
)
window.dispatchEvent(new Event('visibilitychange'))
await sleep(15)
await waitFor(() =>
expect(screen.queryByText('data: data2')).not.toBeInTheDocument(),
)
expect(count).toBe(1)
onlineMock.mockRestore()
})
it('online queries should not refetch while already paused', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
}))
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() =>
screen.getByText('status: pending, fetchStatus: paused'),
)
fireEvent.click(screen.getByRole('button', { name: /invalidate/i }))
await sleep(15)
// invalidation should not trigger a refetch
await waitFor(() =>
screen.getByText('status: pending, fetchStatus: paused'),
)
expect(count).toBe(0)
onlineMock.mockRestore()
})
it('online queries should not refetch while already paused if data is in the cache', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
initialData: 'initial',
}))
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() =>
screen.getByText('status: success, fetchStatus: paused'),
)
await waitFor(() => {
expect(screen.getByText('data: initial')).toBeInTheDocument()
})
fireEvent.click(screen.getByRole('button', { name: /invalidate/i }))
await sleep(15)
// invalidation should not trigger a refetch
await waitFor(() =>
screen.getByText('status: success, fetchStatus: paused'),
)
expect(count).toBe(0)
onlineMock.mockRestore()
})
it('online queries should not get stuck in fetching state when pausing multiple times', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
initialData: 'initial',
}))
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
window.dispatchEvent(new Event('offline'))
await waitFor(() =>
screen.getByText('status: success, fetchStatus: paused'),
)
await waitFor(() => {
expect(screen.getByText('data: initial')).toBeInTheDocument()
})
// triggers one pause
fireEvent.click(screen.getByRole('button', { name: /invalidate/i }))
await sleep(15)
await waitFor(() =>
screen.getByText('status: success, fetchStatus: paused'),
)
// triggers a second pause
window.dispatchEvent(new Event('visibilitychange'))
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await waitFor(() =>
screen.getByText('status: success, fetchStatus: idle'),
)
await waitFor(() => {
expect(screen.getByText('data: data1')).toBeInTheDocument()
})
expect(count).toBe(1)
})
it('online queries should pause retries if you are offline', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = createQuery<unknown, Error>(() => ({
queryKey: key,
queryFn: async (): Promise<unknown> => {
count++
await sleep(10)
throw new Error('failed' + count)
},
retry: 2,
retryDelay: 10,
}))
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus},
failureCount: {state.failureCount}
</div>
<div>failureReason: {state.failureReason?.message ?? 'null'}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() =>
screen.getByText(
'status: pending, fetchStatus: fetching, failureCount: 1',
),
)
await waitFor(() => screen.getByText('failureReason: failed1'))
window.dispatchEvent(new Event('offline'))
const onlineMock = mockOnlineManagerIsOnline(false)
await sleep(20)
await waitFor(() =>
screen.getByText(
'status: pending, fetchStatus: paused, failureCount: 1',
),
)
await waitFor(() => screen.getByText('failureReason: failed1'))
expect(count).toBe(1)
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await waitFor(() =>
screen.getByText('status: error, fetchStatus: idle, failureCount: 3'),
)
await waitFor(() => screen.getByText('failureReason: failed3'))
expect(count).toBe(3)
})
it('online queries should fetch if paused and we go online even if already unmounted (because not cancelled)', async () => {
const key = queryKey()
let count = 0
function Component() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
}))
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
</div>
)
}
function Page() {
const [show, setShow] = createSignal(true)
return (
<div>
{show() && <Component />}
<button onClick={() => setShow(false)}>hide</button>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
window.dispatchEvent(new Event('offline'))
await waitFor(() =>
screen.getByText('status: pending, fetchStatus: paused'),
)
fireEvent.click(screen.getByRole('button', { name: /hide/i }))
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await sleep(15)
expect(queryClient.getQueryState(key)).toMatchObject({
fetchStatus: 'idle',
status: 'success',
})
expect(count).toBe(1)
})
it('online queries should not fetch if paused and we go online when cancelled and no refetchOnReconnect', async () => {
const key = queryKey()
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data' + count
},
refetchOnReconnect: false,
}))
return (
<div>
<button
onClick={() => queryClient.cancelQueries({ queryKey: key })}
>
cancel
</button>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
</div>
)
}
const onlineMock = mockOnlineManagerIsOnline(false)
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() =>
screen.getByText('status: pending, fetchStatus: paused'),
)
fireEvent.click(screen.getByRole('button', { name: /cancel/i }))
await waitFor(() =>
screen.getByText('status: pending, fetchStatus: idle'),
)
expect(count).toBe(0)
onlineMock.mockReturnValue(true)
window.dispatchEvent(new Event('online'))
await sleep(15)
await waitFor(() =>
screen.getByText('status: pending, fetchStatus: idle'),
)
expect(count).toBe(0)
onlineMock.mockRestore()
})
it('online queries should not fetch if paused and we go online if already unmounted when signal consumed', async () => {
const key = queryKey()
let count = 0
function Component() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async ({ signal: _signal }) => {
count++
await sleep(10)
return `signal${count}`
},
}))
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus}
</div>
<div>data: {state.data}</div>
</div>
)
}
function Page() {
const [show, setShow] = createSignal(true)
return (
<div>
{show() && <Component />}
<button onClick={() => setShow(false)}>hide</button>
<button
onClick={() => queryClient.invalidateQueries({ queryKey: key })}
>
invalidate
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() =>
screen.getByText('status: success, fetchStatus: idle'),
)
const onlineMock = mockOnlineManagerIsOnline(false)
fireEvent.click(screen.getByRole('button', { name: /invalidate/i }))
await waitFor(() =>
screen.getByText('status: success, fetchStatus: paused'),
)
fireEvent.click(screen.getByRole('button', { name: /hide/i }))
await sleep(15)
onlineMock.mockReturnValue(true)
window.dispatchEvent(new Event('online'))
await sleep(15)
expect(queryClient.getQueryState(key)).toMatchObject({
fetchStatus: 'idle',
status: 'success',
})
expect(count).toBe(1)
onlineMock.mockRestore()
})
})
describe('networkMode always', () => {
it('always queries should start fetching even if you are offline', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const key = queryKey()
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return 'data ' + count
},
networkMode: 'always',
}))
return (
<div>
<div>
status: {state.status}, isPaused: {String(state.isPaused)}
</div>
<div>data: {state.data}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('status: success, isPaused: false'))
await waitFor(() => {
expect(screen.getByText('data: data 1')).toBeInTheDocument()
})
onlineMock.mockRestore()
})
it('always queries should not pause retries', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const key = queryKey()
let count = 0
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async (): Promise<unknown> => {
count++
await sleep(10)
throw new Error('error ' + count)
},
networkMode: 'always',
retry: 1,
retryDelay: 5,
}))
return (
<div>
<div>
status: {state.status}, isPaused: {String(state.isPaused)}
</div>
<div>
error: {state.error instanceof Error && state.error.message}
</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('status: error, isPaused: false'))
await waitFor(() => {
expect(screen.getByText('error: error 2')).toBeInTheDocument()
})
expect(count).toBe(2)
onlineMock.mockRestore()
})
})
describe('networkMode offlineFirst', () => {
it('offlineFirst queries should start fetching if you are offline, but pause retries', async () => {
const onlineMock = mockOnlineManagerIsOnline(false)
const key = queryKey()
let count = 0
function Page() {
const state = createQuery<unknown, Error>(() => ({
queryKey: key,
queryFn: async (): Promise<unknown> => {
count++
await sleep(10)
throw new Error('failed' + count)
},
retry: 2,
retryDelay: 1,
networkMode: 'offlineFirst',
}))
return (
<div>
<div>
status: {state.status}, fetchStatus: {state.fetchStatus},
failureCount: {state.failureCount}
</div>
<div>failureReason: {state.failureReason?.message ?? 'null'}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
window.dispatchEvent(new Event('offline'))
await waitFor(() =>
screen.getByText(
'status: pending, fetchStatus: paused, failureCount: 1',
),
)
await waitFor(() => screen.getByText('failureReason: failed1'))
expect(count).toBe(1)
onlineMock.mockRestore()
window.dispatchEvent(new Event('online'))
await waitFor(() =>
screen.getByText('status: error, fetchStatus: idle, failureCount: 3'),
)
await waitFor(() => screen.getByText('failureReason: failed3'))
expect(count).toBe(3)
})
})
it('it should have status=error on mount when a query has failed', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<unknown>> = []
const error = new Error('oops')
const queryFn = async (): Promise<unknown> => {
throw error
}
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn,
retry: false,
retryOnMount: false,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return <></>
}
await queryClient.prefetchQuery({ queryKey: key, queryFn })
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => expect(states).toHaveLength(1))
expect(states[0]).toMatchObject({
status: 'error',
error,
})
})
it('setQueryData - should respect updatedAt', async () => {
const key = queryKey()
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: () => 'data',
}))
return (
<div>
<div>data: {state.data}</div>
<div>dataUpdatedAt: {state.dataUpdatedAt}</div>
<button
onClick={() => {
queryClient.setQueryData(key, 'newData', {
updatedAt: 100,
})
}}
>
setQueryData
</button>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: data'))
fireEvent.click(screen.getByRole('button', { name: /setQueryData/i }))
await waitFor(() => screen.getByText('data: newData'))
await waitFor(() => {
expect(screen.getByText('dataUpdatedAt: 100')).toBeInTheDocument()
})
})
it('errorUpdateCount should increased on each fetch failure', async () => {
const key = queryKey()
const error = new Error('oops')
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async (): Promise<unknown> => {
throw error
},
retry: false,
}))
return (
<div>
<button onClick={() => state.refetch()}>refetch</button>
<span>data: {state.errorUpdateCount}</span>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
const fetchBtn = screen.getByRole('button', { name: 'refetch' })
await waitFor(() => screen.getByText('data: 1'))
fireEvent.click(fetchBtn)
await waitFor(() => screen.getByText('data: 2'))
fireEvent.click(fetchBtn)
await waitFor(() => screen.getByText('data: 3'))
})
it('should use provided custom queryClient', async () => {
const key = queryKey()
const queryFn = () => {
return Promise.resolve('custom client')
}
function Page() {
const state = createQuery(
() => ({ queryKey: key, queryFn }),
() => queryClient,
)
return (
<div>
<h1>Status: {state.data}</h1>
</div>
)
}
render(() => <Page />)
await waitFor(() => screen.getByText('Status: custom client'))
})
})
|
4,044 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/createQuery.types.test.tsx | import { describe, it } from 'vitest'
import { createQuery, queryOptions } from '../index'
export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
T,
>() => T extends Y ? 1 : 2
? true
: false
export type Expect<T extends true> = T
const doNotExecute = (_func: () => void) => true
describe('initialData', () => {
describe('Config object overload', () => {
it('TData should always be defined when initialData is provided as an object', () => {
doNotExecute(() => {
const { data } = createQuery(() => ({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: {
wow: true,
},
}))
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('TData should be defined when passed through queryOptions', () => {
doNotExecute(() => {
const options = queryOptions(() => ({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: {
wow: true,
},
}))
const { data } = createQuery(options)
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('TData should always be defined when initialData is provided as a function which ALWAYS returns the data', () => {
doNotExecute(() => {
const { data } = createQuery(() => ({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: () => ({
wow: true,
}),
}))
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('TData should have undefined in the union when initialData is NOT provided', () => {
doNotExecute(() => {
const { data } = createQuery(() => ({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
}))
const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
true
return result
})
})
it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
doNotExecute(() => {
const { data } = createQuery(() => ({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: () => undefined as { wow: boolean } | undefined,
}))
const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
true
return result
})
})
})
describe('Query key overload', () => {
it('TData should always be defined when initialData is provided', () => {
doNotExecute(() => {
const { data } = createQuery(() => ({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: {
wow: true,
},
}))
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('TData should have undefined in the union when initialData is NOT provided', () => {
doNotExecute(() => {
const { data } = createQuery(() => ({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
}))
const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
true
return result
})
})
})
describe('Query key and func', () => {
it('TData should always be defined when initialData is provided', () => {
doNotExecute(() => {
const { data } = createQuery(() => ({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: {
wow: true,
},
}))
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('TData should have undefined in the union when initialData is NOT provided', () => {
doNotExecute(() => {
const { data } = createQuery(() => ({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
}))
const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
true
return result
})
})
})
})
|
4,045 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/suspense.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library'
import {
ErrorBoundary,
Show,
Suspense,
createRenderEffect,
createSignal,
on,
} from 'solid-js'
import {
QueryCache,
QueryClientProvider,
createInfiniteQuery,
createQuery,
} from '..'
import { createQueryClient, queryKey, sleep } from './utils'
import type {
CreateInfiniteQueryResult,
CreateQueryResult,
InfiniteData,
} from '..'
describe("useQuery's in Suspense mode", () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should render the correct amount of times in Suspense mode', async () => {
const key = queryKey()
const states: Array<CreateQueryResult<number>> = []
let count = 0
let renders = 0
function Page() {
const [stateKey, setStateKey] = createSignal(key)
const state = createQuery(() => ({
queryKey: stateKey(),
queryFn: async () => {
count++
await sleep(10)
return count
},
}))
createRenderEffect(() => {
states.push({ ...state })
})
createRenderEffect(
on([() => ({ ...state }), () => key], () => {
renders++
}),
)
return (
<div>
<button aria-label="toggle" onClick={() => setStateKey(queryKey())} />
data: {String(state.data)}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Suspense fallback="loading">
<Page />
</Suspense>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: 1'))
fireEvent.click(screen.getByLabelText('toggle'))
await waitFor(() => screen.getByText('data: 2'))
expect(renders).toBe(4)
expect(states.length).toBe(4)
expect(states[1]).toMatchObject({ data: 1, status: 'success' })
expect(states[3]).toMatchObject({ data: 2, status: 'success' })
})
it('should return the correct states for a successful infinite query', async () => {
const key = queryKey()
const states: Array<CreateInfiniteQueryResult<InfiniteData<number>>> = []
function Page() {
const [multiplier, setMultiplier] = createSignal(1)
const state = createInfiniteQuery(() => ({
queryKey: [`${key}_${multiplier()}`],
queryFn: async ({ pageParam }) => {
await sleep(10)
return Number(pageParam * multiplier())
},
initialPageParam: 1,
suspense: true,
getNextPageParam: (lastPage) => lastPage + 1,
}))
createRenderEffect(() => {
states.push({ ...state })
})
return (
<div>
<button onClick={() => setMultiplier(2)}>next</button>
data: {state.data?.pages.join(',')}
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Suspense fallback="loading">
<Page />
</Suspense>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('data: 1'))
// TODO(lukemurray): in react this is 1 in solid this is 2 because suspense
// occurs on read.
expect(states.length).toBe(2)
expect(states[1]).toMatchObject({
data: { pages: [1], pageParams: [1] },
status: 'success',
})
fireEvent.click(screen.getByText('next'))
await waitFor(() => screen.getByText('data: 2'))
// TODO(lukemurray): in react this is 2 and in solid it is 4
expect(states.length).toBe(4)
expect(states[3]).toMatchObject({
data: { pages: [2], pageParams: [1] },
status: 'success',
})
})
it('should not call the queryFn twice when used in Suspense mode', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, string>()
queryFn.mockImplementation(() => {
sleep(10)
return 'data'
})
function Page() {
createQuery(() => ({ queryKey: [key], queryFn, suspense: true }))
return <>rendered</>
}
render(() => (
<QueryClientProvider client={queryClient}>
<Suspense fallback="loading">
<Page />
</Suspense>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('rendered'))
expect(queryFn).toHaveBeenCalledTimes(1)
})
it('should remove query instance when component unmounted', async () => {
const key = queryKey()
function Page() {
createQuery(() => ({
queryKey: key,
queryFn: () => {
sleep(10)
return 'data'
},
}))
return <>rendered</>
}
function App() {
const [show, setShow] = createSignal(false)
return (
<>
<Suspense fallback="loading">{show() && <Page />}</Suspense>
<button
aria-label="toggle"
onClick={() => setShow((prev) => !prev)}
/>
</>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
expect(screen.queryByText('rendered')).toBeNull()
expect(queryCache.find({ queryKey: key })).toBeFalsy()
fireEvent.click(screen.getByLabelText('toggle'))
await waitFor(() => screen.getByText('rendered'))
expect(queryCache.find({ queryKey: key })?.getObserversCount()).toBe(1)
fireEvent.click(screen.getByLabelText('toggle'))
expect(screen.queryByText('rendered')).toBeNull()
expect(queryCache.find({ queryKey: key })?.getObserversCount()).toBe(0)
})
// https://github.com/tannerlinsley/react-query/issues/468
it('should reset error state if new component instances are mounted', async () => {
const key = queryKey()
let succeed = false
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return 'data'
}
},
retryDelay: 10,
suspense: true,
}))
// Suspense only triggers if used in JSX
return (
<Show when={state.data}>
<div>rendered</div>
</Show>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<ErrorBoundary
fallback={(_err, resetSolid) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
succeed = true
resetSolid()
}}
>
retry
</button>
</div>
)}
>
<Suspense fallback={'Loading...'}>
<Page />
</Suspense>
</ErrorBoundary>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Loading...'))
await waitFor(() => screen.getByText('error boundary'))
await waitFor(() => screen.getByText('retry'))
fireEvent.click(screen.getByText('retry'))
await waitFor(() => screen.getByText('rendered'))
})
it('should retry fetch if the reset error boundary has been reset', async () => {
const key = queryKey()
let succeed = false
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return 'data'
}
},
retry: false,
suspense: true,
}))
// Suspense only triggers if used in JSX
return (
<Show when={state.data}>
<div>rendered</div>
</Show>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<ErrorBoundary
fallback={(_err, resetSolid) => (
<div>
<div>error boundary</div>
<button
onClick={() => {
resetSolid()
}}
>
retry
</button>
</div>
)}
>
<Suspense fallback="Loading...">
<Page />
</Suspense>
</ErrorBoundary>
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Loading...'))
await waitFor(() => screen.getByText('error boundary'))
await waitFor(() => screen.getByText('retry'))
fireEvent.click(screen.getByText('retry'))
await waitFor(() => screen.getByText('error boundary'))
await waitFor(() => screen.getByText('retry'))
succeed = true
fireEvent.click(screen.getByText('retry'))
await waitFor(() => screen.getByText('rendered'))
})
it('should refetch when re-mounting', async () => {
const key = queryKey()
let count = 0
function Component() {
const result = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(100)
count++
return count
},
retry: false,
suspense: true,
staleTime: 0,
}))
return (
<div>
<span>data: {result.data}</span>
<span>fetching: {result.isFetching ? 'true' : 'false'}</span>
</div>
)
}
function Page() {
const [show, setShow] = createSignal(true)
return (
<div>
<button
onClick={() => {
setShow(!show())
}}
>
{show() ? 'hide' : 'show'}
</button>
<Suspense fallback="Loading...">{show() && <Component />}</Suspense>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Loading...'))
await waitFor(() => screen.getByText('data: 1'))
await waitFor(() => screen.getByText('fetching: false'))
await waitFor(() => screen.getByText('hide'))
fireEvent.click(screen.getByText('hide'))
await waitFor(() => screen.getByText('show'))
fireEvent.click(screen.getByText('show'))
await waitFor(() => screen.getByText('fetching: true'))
await waitFor(() => screen.getByText('data: 2'))
await waitFor(() => screen.getByText('fetching: false'))
})
it('should suspend when switching to a new query', async () => {
const key1 = queryKey()
const key2 = queryKey()
function Component(props: { queryKey: Array<string> }) {
const result = createQuery(() => ({
queryKey: props.queryKey,
queryFn: async () => {
await sleep(100)
return props.queryKey
},
retry: false,
suspense: true,
}))
return <div>data: {result.data}</div>
}
function Page() {
const [key, setKey] = createSignal(key1)
return (
<div>
<button
onClick={() => {
setKey(key2)
}}
>
switch
</button>
<Suspense fallback="Loading...">
<Component queryKey={key()} />
</Suspense>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Loading...'))
await waitFor(() => screen.getByText(`data: ${key1}`))
fireEvent.click(screen.getByText('switch'))
await waitFor(() => screen.getByText('Loading...'))
await waitFor(() => screen.getByText(`data: ${key2}`))
})
it('should throw errors to the error boundary by default', async () => {
const key = queryKey()
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async (): Promise<unknown> => {
await sleep(10)
throw new Error('Suspense Error a1x')
},
retry: false,
suspense: true,
}))
// read state.data to trigger suspense.
createRenderEffect(() => {
// eslint-disable-next-line @typescript-eslint/no-unused-expressions -- trigger suspense
state.data
})
return <div>rendered</div>
}
function App() {
return (
<ErrorBoundary
fallback={() => (
<div>
<div>error boundary</div>
</div>
)}
>
<Suspense fallback="Loading...">
<Page />
</Suspense>
</ErrorBoundary>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Loading...'))
await waitFor(() => screen.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should not throw errors to the error boundary when throwOnError: false', async () => {
const key = queryKey()
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async (): Promise<unknown> => {
await sleep(10)
throw new Error('Suspense Error a2x')
},
retry: false,
throwOnError: false,
}))
// read state.data to trigger suspense.
createRenderEffect(() => {
// eslint-disable-next-line @typescript-eslint/no-unused-expressions -- trigger suspense
state.data
})
return <div>rendered</div>
}
function App() {
return (
<ErrorBoundary
fallback={() => (
<div>
<div>error boundary</div>
</div>
)}
>
<Suspense fallback="Loading...">
<Page />
</Suspense>
</ErrorBoundary>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Loading...'))
await waitFor(() => screen.getByText('rendered'))
})
it('should throw errors to the error boundary when a throwOnError function returns true', async () => {
const key = queryKey()
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async (): Promise<unknown> => {
await sleep(10)
return Promise.reject(new Error('Remote Error'))
},
retry: false,
throwOnError: (err) => err.message !== 'Local Error',
}))
// read state.data to trigger suspense.
createRenderEffect(() => {
// eslint-disable-next-line @typescript-eslint/no-unused-expressions -- trigger suspense
state.data
})
return <div>rendered</div>
}
function App() {
return (
<ErrorBoundary
fallback={() => (
<div>
<div>error boundary</div>
</div>
)}
>
<Suspense fallback="Loading...">
<Page />
</Suspense>
</ErrorBoundary>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Loading...'))
await waitFor(() => screen.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should not throw errors to the error boundary when a throwOnError function returns false', async () => {
const key = queryKey()
function Page() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async (): Promise<unknown> => {
await sleep(10)
return Promise.reject(new Error('Local Error'))
},
retry: false,
suspense: true,
throwOnError: (err) => err.message !== 'Local Error',
}))
// read state.data to trigger suspense.
createRenderEffect(() => {
// eslint-disable-next-line @typescript-eslint/no-unused-expressions -- trigger suspense
state.data
})
return <div>rendered</div>
}
function App() {
return (
<ErrorBoundary
fallback={() => (
<div>
<div>error boundary</div>
</div>
)}
>
<Suspense fallback="Loading...">
<Page />
</Suspense>
</ErrorBoundary>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Loading...'))
await waitFor(() => screen.getByText('rendered'))
})
it('should not call the queryFn when not enabled', async () => {
const key = queryKey()
const queryFn = vi.fn<Array<unknown>, Promise<string>>()
queryFn.mockImplementation(async () => {
await sleep(10)
return '23'
})
function Page() {
const [enabled, setEnabled] = createSignal(false)
const result = createQuery(() => ({
queryKey: [key],
queryFn,
suspense: true,
enabled: enabled(),
}))
return (
<div>
<button onClick={() => setEnabled(true)}>fire</button>
<h1>{result.data}</h1>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Suspense fallback="loading">
<Page />
</Suspense>
</QueryClientProvider>
))
expect(queryFn).toHaveBeenCalledTimes(0)
await sleep(5)
fireEvent.click(screen.getByRole('button', { name: /fire/i }))
await waitFor(() => {
expect(screen.getByRole('heading').textContent).toBe('23')
})
expect(queryFn).toHaveBeenCalledTimes(1)
})
it('should error catched in error boundary without infinite loop', async () => {
const key = queryKey()
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
let succeed = true
function Page() {
const [nonce] = createSignal(0)
const queryKeys = [`${key}-${succeed}`]
const result = createQuery(() => ({
queryKey: queryKeys,
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return nonce()
}
},
retry: false,
suspense: true,
}))
return (
<div>
<span>rendered</span> <span>{result.data}</span>
<button
aria-label="fail"
onClick={async () => {
await queryClient.resetQueries()
}}
>
fail
</button>
</div>
)
}
function App() {
return (
<ErrorBoundary fallback={() => <div>error boundary</div>}>
<Suspense fallback="Loading...">
<Page />
</Suspense>
</ErrorBoundary>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
// render suspense fallback (Loading...)
await waitFor(() => screen.getByText('Loading...'))
// resolve promise -> render Page (rendered)
await waitFor(() => screen.getByText('rendered'))
// change query key
succeed = false
// reset query -> and throw error
fireEvent.click(screen.getByLabelText('fail'))
// render error boundary fallback (error boundary)
await waitFor(() => screen.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should error catched in error boundary without infinite loop when query keys changed', async () => {
let succeed = true
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const [key, setKey] = createSignal(0)
const result = createQuery(() => ({
queryKey: [`${key()}-${succeed}`],
queryFn: async () => {
await sleep(10)
if (!succeed) {
throw new Error('Suspense Error Bingo')
} else {
return 'data'
}
},
retry: false,
suspense: true,
}))
return (
<div>
<span>rendered</span> <span>{result.data}</span>
<button aria-label="fail" onClick={() => setKey((k) => k + 1)}>
fail
</button>
</div>
)
}
function App() {
return (
<ErrorBoundary fallback={() => <div>error boundary</div>}>
<Suspense fallback="Loading...">
<Page />
</Suspense>
</ErrorBoundary>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
// render suspense fallback (Loading...)
await waitFor(() => screen.getByText('Loading...'))
// resolve promise -> render Page (rendered)
await waitFor(() => screen.getByText('rendered'))
// change promise result to error
succeed = false
// change query key
fireEvent.click(screen.getByLabelText('fail'))
// render error boundary fallback (error boundary)
await waitFor(() => screen.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should error catched in error boundary without infinite loop when enabled changed', async () => {
const consoleMock = vi
.spyOn(console, 'error')
.mockImplementation(() => undefined)
function Page() {
const queryKeys = '1'
const [enabled, setEnabled] = createSignal(false)
const result = createQuery<string>(() => ({
queryKey: [queryKeys],
queryFn: async () => {
await sleep(10)
throw new Error('Suspense Error Bingo')
},
retry: false,
suspense: true,
enabled: enabled(),
}))
return (
<div>
<span>rendered</span> <span>{result.data}</span>
<button
aria-label="fail"
onClick={() => {
setEnabled(true)
}}
>
fail
</button>
</div>
)
}
function App() {
return (
<ErrorBoundary fallback={() => <div>error boundary</div>}>
<Suspense fallback="Loading...">
<Page />
</Suspense>
</ErrorBoundary>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<App />
</QueryClientProvider>
))
// render empty data with 'rendered' when enabled is false
await waitFor(() => screen.getByText('rendered'))
// change enabled to true
fireEvent.click(screen.getByLabelText('fail'))
// render pending fallback
await waitFor(() => screen.getByText('Loading...'))
// render error boundary fallback (error boundary)
await waitFor(() => screen.getByText('error boundary'))
consoleMock.mockRestore()
})
it('should render the correct amount of times in Suspense mode when gcTime is set to 0', async () => {
const key = queryKey()
let state: CreateQueryResult<number> | null = null
let count = 0
let renders = 0
function Page() {
state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
count++
await sleep(10)
return count
},
gcTime: 0,
}))
createRenderEffect(
on([() => ({ ...state })], () => {
renders++
}),
)
return (
<div>
<span>rendered</span>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Suspense fallback="loading">
<Page />
</Suspense>
</QueryClientProvider>
))
await waitFor(() =>
expect(state).toMatchObject({
data: 1,
status: 'success',
}),
)
expect(renders).toBe(2)
expect(screen.queryByText('rendered')).not.toBeNull()
})
})
|
4,046 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/transition.test.tsx | import { describe, it } from 'vitest'
import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library'
import { Show, Suspense, createSignal, startTransition } from 'solid-js'
import { QueryCache, QueryClientProvider, createQuery } from '..'
import { createQueryClient, queryKey, sleep } from './utils'
describe("createQuery's in Suspense mode with transitions", () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
it('should render the content when the transition is done', async () => {
const key = queryKey()
function Suspended() {
const state = createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return true
},
}))
return <Show when={state.data}>Message</Show>
}
function Page() {
const [showSignal, setShowSignal] = createSignal(false)
return (
<div>
<button
aria-label="toggle"
onClick={() =>
startTransition(() => setShowSignal((value) => !value))
}
>
{showSignal() ? 'Hide' : 'Show'}
</button>
<Suspense fallback="Loading">
<Show when={showSignal()}>
<Suspended />
</Show>
</Suspense>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => screen.getByText('Show'))
fireEvent.click(screen.getByLabelText('toggle'))
await waitFor(() => screen.getByText('Message'))
// verify that the button also updated. See https://github.com/solidjs/solid/issues/1249
await waitFor(() => screen.getByText('Hide'))
})
})
|
4,047 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/useIsFetching.test.tsx | import { describe, expect, it } from 'vitest'
import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library'
import { Show, createEffect, createRenderEffect, createSignal } from 'solid-js'
import { QueryCache, QueryClientProvider, createQuery, useIsFetching } from '..'
import { createQueryClient, queryKey, setActTimeout, sleep } from './utils'
describe('useIsFetching', () => {
// See https://github.com/tannerlinsley/react-query/issues/105
it('should update as queries start and stop fetching', async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const key = queryKey()
function IsFetching() {
const isFetching = useIsFetching()
return <div>isFetching: {isFetching()}</div>
}
function Query() {
const [ready, setReady] = createSignal(false)
createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(50)
return 'test'
},
enabled: ready(),
}))
return <button onClick={() => setReady(true)}>setReady</button>
}
function Page() {
return (
<div>
<IsFetching />
<Query />
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('isFetching: 0')
fireEvent.click(screen.getByRole('button', { name: /setReady/i }))
await screen.findByText('isFetching: 1')
await screen.findByText('isFetching: 0')
})
it('should not update state while rendering', async () => {
const queryCache = new QueryCache()
const queryClient = createQueryClient({ queryCache })
const key1 = queryKey()
const key2 = queryKey()
const isFetchings: Array<number> = []
function IsFetching() {
const isFetching = useIsFetching()
createRenderEffect(() => {
isFetchings.push(isFetching())
})
return null
}
function FirstQuery() {
createQuery(() => ({
queryKey: key1,
queryFn: async () => {
await sleep(150)
return 'data'
},
}))
return null
}
function SecondQuery() {
createQuery(() => ({
queryKey: key2,
queryFn: async () => {
await sleep(200)
return 'data'
},
}))
return null
}
function Page() {
const [renderSecond, setRenderSecond] = createSignal(false)
createEffect(() => {
setActTimeout(() => {
setRenderSecond(true)
}, 100)
})
return (
<>
<IsFetching />
<FirstQuery />
<Show when={renderSecond()}>
<SecondQuery />
</Show>
</>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
// unlike react, Updating renderSecond wont cause a rerender for FirstQuery
await waitFor(() => expect(isFetchings).toEqual([0, 1, 2, 1, 0]))
})
it('should be able to filter', async () => {
const queryClient = createQueryClient()
const key1 = queryKey()
const key2 = queryKey()
const isFetchings: Array<number> = []
function One() {
createQuery(() => ({
queryKey: key1,
queryFn: async () => {
await sleep(10)
return 'test'
},
}))
return null
}
function Two() {
createQuery(() => ({
queryKey: key2,
queryFn: async () => {
await sleep(20)
return 'test'
},
}))
return null
}
function Page() {
const [started, setStarted] = createSignal(false)
const isFetching = useIsFetching(() => ({
queryKey: key1,
}))
createRenderEffect(() => {
isFetchings.push(isFetching())
})
return (
<div>
<button onClick={() => setStarted(true)}>setStarted</button>
<div>isFetching: {isFetching()}</div>
<Show when={started()}>
<>
<One />
<Two />
</>
</Show>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('isFetching: 0')
fireEvent.click(screen.getByRole('button', { name: /setStarted/i }))
await screen.findByText('isFetching: 1')
await screen.findByText('isFetching: 0')
// at no point should we have isFetching: 2
expect(isFetchings).toEqual(expect.not.arrayContaining([2]))
})
it('should show the correct fetching state when mounted after a query', async () => {
const queryClient = createQueryClient()
const key = queryKey()
function Page() {
createQuery(() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
}))
const isFetching = useIsFetching()
return (
<div>
<div>isFetching: {isFetching()}</div>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await screen.findByText('isFetching: 1')
await screen.findByText('isFetching: 0')
})
it('should use provided custom queryClient', async () => {
const queryClient = createQueryClient()
const key = queryKey()
function Page() {
createQuery(
() => ({
queryKey: key,
queryFn: async () => {
await sleep(10)
return 'test'
},
}),
() => queryClient,
)
const isFetching = useIsFetching(undefined, () => queryClient)
return (
<div>
<div>isFetching: {isFetching()}</div>
</div>
)
}
render(() => <Page></Page>)
await screen.findByText('isFetching: 1')
})
})
|
4,048 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/useIsMutating.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library'
import { Show, createEffect, createRenderEffect, createSignal } from 'solid-js'
import * as QueryCore from '@tanstack/query-core'
import { QueryClientProvider, createMutation, useIsMutating } from '..'
import { createQueryClient, setActTimeout, sleep } from './utils'
describe('useIsMutating', () => {
it('should return the number of fetching mutations', async () => {
const isMutatings: Array<number> = []
const queryClient = createQueryClient()
function IsMutating() {
const isMutating = useIsMutating()
createRenderEffect(() => {
isMutatings.push(isMutating())
})
return null
}
function Mutations() {
const { mutate: mutate1 } = createMutation(() => ({
mutationKey: ['mutation1'],
mutationFn: async () => {
await sleep(150)
return 'data'
},
}))
const { mutate: mutate2 } = createMutation(() => ({
mutationKey: ['mutation2'],
mutationFn: async () => {
await sleep(50)
return 'data'
},
}))
createEffect(() => {
mutate1()
setActTimeout(() => {
mutate2()
}, 50)
})
return null
}
function Page() {
return (
<div>
<IsMutating />
<Mutations />
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => expect(isMutatings).toEqual([0, 1, 2, 1, 0]))
})
it('should filter correctly by mutationKey', async () => {
const isMutatings: Array<number> = []
const queryClient = createQueryClient()
function IsMutating() {
const isMutating = useIsMutating(() => ({ mutationKey: ['mutation1'] }))
createRenderEffect(() => {
isMutatings.push(isMutating())
})
return null
}
function Page() {
const { mutate: mutate1 } = createMutation(() => ({
mutationKey: ['mutation1'],
mutationFn: async () => {
await sleep(100)
return 'data'
},
}))
const { mutate: mutate2 } = createMutation(() => ({
mutationKey: ['mutation2'],
mutationFn: async () => {
await sleep(100)
return 'data'
},
}))
createEffect(() => {
mutate1()
mutate2()
})
return <IsMutating />
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
// Unlike React, IsMutating Wont re-render twice with mutation2
await waitFor(() => expect(isMutatings).toEqual([0, 1, 0]))
})
it('should filter correctly by predicate', async () => {
const isMutatings: Array<number> = []
const queryClient = createQueryClient()
function IsMutating() {
const isMutating = useIsMutating(() => ({
predicate: (mutation) =>
mutation.options.mutationKey?.[0] === 'mutation1',
}))
createRenderEffect(() => {
isMutatings.push(isMutating())
})
return null
}
function Page() {
const { mutate: mutate1 } = createMutation(() => ({
mutationKey: ['mutation1'],
mutationFn: async () => {
await sleep(100)
return 'data'
},
}))
const { mutate: mutate2 } = createMutation(() => ({
mutationKey: ['mutation2'],
mutationFn: async () => {
await sleep(100)
return 'data'
},
}))
createEffect(() => {
mutate1()
mutate2()
})
return <IsMutating />
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
// Again, No unnecessary re-renders like React
await waitFor(() => expect(isMutatings).toEqual([0, 1, 0]))
})
it('should use provided custom queryClient', async () => {
const queryClient = createQueryClient()
function Page() {
const isMutating = useIsMutating(undefined, () => queryClient)
const { mutate } = createMutation(
() => ({
mutationKey: ['mutation1'],
mutationFn: async () => {
await sleep(10)
return 'data'
},
}),
() => queryClient,
)
createEffect(() => {
mutate()
})
return (
<div>
<div>mutating: {isMutating()}</div>
</div>
)
}
render(() => <Page></Page>)
await waitFor(() => screen.findByText('mutating: 1'))
})
it('should not change state if unmounted', async () => {
// We have to mock the MutationCache to not unsubscribe
// the listener when the component is unmounted
class MutationCacheMock extends QueryCore.MutationCache {
subscribe(listener: any) {
super.subscribe(listener)
return () => void 0
}
}
const MutationCacheSpy = vi
.spyOn(QueryCore, 'MutationCache')
.mockImplementation((fn) => {
return new MutationCacheMock(fn)
})
const queryClient = createQueryClient()
function IsMutating() {
useIsMutating()
return null
}
function Page() {
const [mounted, setMounted] = createSignal(true)
const { mutate: mutate1 } = createMutation(() => ({
mutationKey: ['mutation1'],
mutationFn: async () => {
await sleep(10)
return 'data'
},
}))
createEffect(() => {
mutate1()
})
return (
<div>
<button onClick={() => setMounted(false)}>unmount</button>
<Show when={mounted()}>
<IsMutating />
</Show>
</div>
)
}
render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
fireEvent.click(screen.getByText('unmount'))
// Should not display the console error
// "Warning: Can't perform a React state update on an unmounted component"
await sleep(20)
MutationCacheSpy.mockRestore()
})
})
|
4,049 | 0 | petrpan-code/TanStack/query/packages/solid-query/src | petrpan-code/TanStack/query/packages/solid-query/src/__tests__/useMutationState.test.tsx | import { describe, expect, expectTypeOf, it } from 'vitest'
import { fireEvent, render, waitFor } from '@solidjs/testing-library'
import { createEffect } from 'solid-js'
import { useMutationState } from '../useMutationState'
import { createMutation } from '../createMutation'
import { QueryClientProvider } from '../QueryClientProvider'
import { createQueryClient, doNotExecute, sleep } from './utils'
import type { MutationState, MutationStatus } from '@tanstack/query-core'
describe('useMutationState', () => {
describe('types', () => {
it('should default to QueryState', () => {
doNotExecute(() => {
const result = useMutationState(() => ({
filters: { status: 'pending' },
}))
expectTypeOf<Array<MutationState>>(result())
})
})
it('should infer with select', () => {
doNotExecute(() => {
const result = useMutationState(() => ({
filters: { status: 'pending' },
select: (mutation) => mutation.state.status,
}))
expectTypeOf<Array<MutationStatus>>(result())
})
})
})
it('should return variables after calling mutate', async () => {
const queryClient = createQueryClient()
const variables: Array<Array<unknown>> = []
const mutationKey = ['mutation']
function Variables() {
const states = useMutationState(() => ({
filters: { mutationKey, status: 'pending' },
select: (mutation) => mutation.state.variables,
}))
createEffect(() => {
variables.push(states())
})
return null
}
function Mutate() {
const mutation = createMutation(() => ({
mutationKey,
mutationFn: async (input: number) => {
await sleep(150)
return 'data' + input
},
}))
return (
<div>
data: {mutation.data ?? 'null'}
<button onClick={() => mutation.mutate(1)}>mutate</button>
</div>
)
}
function Page() {
return (
<div>
<Variables />
<Mutate />
</div>
)
}
const rendered = render(() => (
<QueryClientProvider client={queryClient}>
<Page />
</QueryClientProvider>
))
await waitFor(() => rendered.getByText('data: null'))
fireEvent.click(rendered.getByRole('button', { name: /mutate/i }))
await waitFor(() => rendered.getByText('data: data1'))
expect(variables).toEqual([[], [1], []])
})
})
|
4,066 | 0 | petrpan-code/TanStack/query/packages/svelte-query-persist-client/src | petrpan-code/TanStack/query/packages/svelte-query-persist-client/src/__tests__/PersistQueryClientProvider.test.ts | import { render, waitFor } from '@testing-library/svelte'
import { describe, expect, test, vi } from 'vitest'
import { persistQueryClientSave } from '@tanstack/query-persist-client-core'
import { get, writable } from 'svelte/store'
import AwaitOnSuccess from './AwaitOnSuccess/Provider.svelte'
import FreshData from './FreshData/Provider.svelte'
import OnSuccess from './OnSuccess/Provider.svelte'
import InitialData from './InitialData/Provider.svelte'
import RemoveCache from './RemoveCache/Provider.svelte'
import RestoreCache from './RestoreCache/Provider.svelte'
import UseQueries from './UseQueries/Provider.svelte'
import { createQueryClient, queryKey, sleep } from './utils'
import type {
PersistedClient,
Persister,
} from '@tanstack/query-persist-client-core'
import type { Writable } from 'svelte/store'
import type { StatusResult } from './utils'
const createMockPersister = (): Persister => {
let storedState: PersistedClient | undefined
return {
async persistClient(persistClient: PersistedClient) {
storedState = persistClient
},
async restoreClient() {
await sleep(10)
return storedState
},
removeClient() {
storedState = undefined
},
}
}
const createMockErrorPersister = (
removeClient: Persister['removeClient'],
): [Error, Persister] => {
const error = new Error('restore failed')
return [
error,
{
async persistClient() {
// noop
},
async restoreClient() {
await sleep(10)
throw error
},
removeClient,
},
]
}
describe('PersistQueryClientProvider', () => {
test('restores cache from persister', async () => {
const key = queryKey()
const states: Writable<Array<StatusResult<string>>> = writable([])
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
const rendered = render(RestoreCache, {
props: {
queryClient,
persistOptions: { persister },
key,
states,
},
})
await waitFor(() => rendered.getByText('fetchStatus: idle'))
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
const states_ = get(states)
expect(states_).toHaveLength(4)
expect(states_[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states_[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states_[2]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states_[3]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'fetched',
})
})
test('should also put useQueries into idle state', async () => {
const key = queryKey()
const states: Writable<Array<StatusResult<string>>> = writable([])
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
const rendered = render(UseQueries, {
props: {
queryClient,
persistOptions: { persister },
key,
states,
},
})
await waitFor(() => rendered.getByText('fetchStatus: idle'))
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
const states_ = get(states)
expect(states_).toHaveLength(4)
expect(states_[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states_[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states_[2]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states_[3]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'fetched',
})
})
test('should show initialData while restoring', async () => {
const key = queryKey()
const states: Writable<Array<StatusResult<string>>> = writable([])
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
const rendered = render(InitialData, {
props: {
queryClient,
persistOptions: { persister },
key,
states,
},
})
await waitFor(() => rendered.getByText('initial'))
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
const states_ = get(states)
expect(states_).toHaveLength(4)
expect(states_[0]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'initial',
})
expect(states_[1]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states_[2]).toMatchObject({
status: 'success',
fetchStatus: 'fetching',
data: 'hydrated',
})
expect(states_[3]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'fetched',
})
})
test('should not refetch after restoring when data is fresh', async () => {
const key = queryKey()
const states: Writable<Array<StatusResult<string>>> = writable([])
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
const fetched = writable(false)
const rendered = render(FreshData, {
props: {
queryClient,
persistOptions: { persister },
key,
states,
fetched,
},
})
await waitFor(() => rendered.getByText('data: null'))
await waitFor(() => rendered.getByText('data: hydrated'))
const states_ = get(states)
expect(states_).toHaveLength(2)
expect(get(fetched)).toBe(false)
expect(states_[0]).toMatchObject({
status: 'pending',
fetchStatus: 'idle',
data: undefined,
})
expect(states_[1]).toMatchObject({
status: 'success',
fetchStatus: 'idle',
data: 'hydrated',
})
})
test('should call onSuccess after successful restoring', async () => {
const key = queryKey()
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
const onSuccess = vi.fn()
const rendered = render(OnSuccess, {
props: {
queryClient,
persistOptions: { persister },
key,
onSuccess,
},
})
expect(onSuccess).toHaveBeenCalledTimes(0)
await waitFor(() => rendered.getByText('hydrated'))
expect(onSuccess).toHaveBeenCalledTimes(1)
await waitFor(() => rendered.getByText('fetched'))
})
test('should await onSuccess after successful restoring', async () => {
const key = queryKey()
const queryClient = createQueryClient()
await queryClient.prefetchQuery({
queryKey: key,
queryFn: () => Promise.resolve('hydrated'),
})
const persister = createMockPersister()
await persistQueryClientSave({ queryClient, persister })
queryClient.clear()
const states: Writable<Array<string>> = writable([])
const rendered = render(AwaitOnSuccess, {
props: {
queryClient,
persistOptions: { persister },
key,
states,
onSuccess: async () => {
states.update((s) => [...s, 'onSuccess'])
await sleep(20)
states.update((s) => [...s, 'onSuccess done'])
},
},
})
await waitFor(() => rendered.getByText('hydrated'))
await waitFor(() => rendered.getByText('fetched'))
expect(get(states)).toEqual([
'onSuccess',
'onSuccess done',
'fetching',
'fetched',
])
})
test('should remove cache after non-successful restoring', async () => {
const key = queryKey()
const consoleMock = vi.spyOn(console, 'error')
const consoleWarn = vi
.spyOn(console, 'warn')
.mockImplementation(() => undefined)
consoleMock.mockImplementation(() => undefined)
const queryClient = createQueryClient()
const removeClient = vi.fn()
const [error, persister] = createMockErrorPersister(removeClient)
const rendered = render(RemoveCache, {
props: { queryClient, persistOptions: { persister }, key },
})
await waitFor(() => rendered.getByText('fetched'))
expect(removeClient).toHaveBeenCalledTimes(1)
expect(consoleMock).toHaveBeenCalledTimes(1)
expect(consoleMock).toHaveBeenNthCalledWith(1, error)
consoleMock.mockRestore()
consoleWarn.mockRestore()
})
})
|
4,109 | 0 | petrpan-code/TanStack/query/packages/svelte-query/src | petrpan-code/TanStack/query/packages/svelte-query/src/__tests__/context.test.ts | import { describe, expect, it } from 'vitest'
import { getIsRestoringContext } from '../context'
describe('getIsRestoringContext', () => {
it('Should not throw when called outside of a component', async () => {
expect(() => getIsRestoringContext()).to.not.throw()
})
})
|
4,110 | 0 | petrpan-code/TanStack/query/packages/svelte-query/src | petrpan-code/TanStack/query/packages/svelte-query/src/__tests__/createMutation.test.ts | import { describe, expect, it, vi } from 'vitest'
import { fireEvent, render, waitFor } from '@testing-library/svelte'
import CreateMutation from './CreateMutation.svelte'
describe('createMutation', () => {
it('Call mutate and check function runs', async () => {
const mutationFn = vi.fn()
const rendered = render(CreateMutation, {
props: {
options: {
mutationFn,
},
},
})
fireEvent.click(rendered.getByRole('button'))
await waitFor(() => {
expect(mutationFn).toHaveBeenCalledTimes(1)
})
})
})
|
4,111 | 0 | petrpan-code/TanStack/query/packages/svelte-query/src | petrpan-code/TanStack/query/packages/svelte-query/src/__tests__/createQueries.test.ts | import { describe, expect, it } from 'vitest'
import { render, waitFor } from '@testing-library/svelte'
import { QueryClient } from '@tanstack/query-core'
import CreateQueries from './CreateQueries.svelte'
import { sleep } from './utils'
describe('createQueries', () => {
it('Render and wait for success', async () => {
const rendered = render(CreateQueries, {
props: {
options: {
queries: [
{
queryKey: ['key-1'],
queryFn: async () => {
await sleep(10)
return 'Success 1'
},
},
{
queryKey: ['key-2'],
queryFn: async () => {
await sleep(10)
return 'Success 2'
},
},
],
},
queryClient: new QueryClient(),
},
})
await waitFor(() => {
expect(rendered.getByText('Loading 1')).toBeInTheDocument()
expect(rendered.getByText('Loading 2')).toBeInTheDocument()
})
await waitFor(() => {
expect(rendered.getByText('Success 1')).toBeInTheDocument()
expect(rendered.getByText('Success 2')).toBeInTheDocument()
})
})
it('should combine queries', async () => {
const ids = [1, 2, 3]
const rendered = render(CreateQueries, {
props: {
options: {
queries: ids.map((id) => ({
queryKey: [id],
queryFn: async () => {
await sleep(10)
return id
},
})),
combine: (results) => {
return {
isPending: results.some((result) => result.isPending),
isSuccess: results.every((result) => result.isSuccess),
data: results.map((res) => res.data).join(','),
}
},
},
queryClient: new QueryClient(),
},
})
await waitFor(() => {
expect(rendered.getByText('Loading')).toBeInTheDocument()
})
await waitFor(() => {
expect(rendered.getByText('1,2,3')).toBeInTheDocument()
})
})
})
|
4,112 | 0 | petrpan-code/TanStack/query/packages/svelte-query/src | petrpan-code/TanStack/query/packages/svelte-query/src/__tests__/createQuery.test.ts | import { describe, expect, test } from 'vitest'
import { render, waitFor } from '@testing-library/svelte'
import { derived, writable } from 'svelte/store'
import { QueryClient } from '@tanstack/query-core'
import CreateQuery from './CreateQuery.svelte'
import { sleep } from './utils'
describe('createQuery', () => {
test('Render and wait for success', async () => {
const rendered = render(CreateQuery, {
props: {
options: {
queryKey: ['test'],
queryFn: async () => {
await sleep(10)
return 'Success'
},
},
queryClient: new QueryClient(),
},
})
await waitFor(() => {
expect(rendered.queryByText('Loading')).toBeInTheDocument()
})
await waitFor(() => {
expect(rendered.queryByText('Success')).toBeInTheDocument()
})
})
test('Accept a writable store for options', async () => {
const optionsStore = writable({
queryKey: ['test'],
queryFn: async () => {
await sleep(10)
return 'Success'
},
})
const rendered = render(CreateQuery, {
props: {
options: optionsStore,
queryClient: new QueryClient(),
},
})
await waitFor(() => {
expect(rendered.queryByText('Success')).toBeInTheDocument()
})
})
test('Accept a derived store for options', async () => {
const writableStore = writable('test')
const derivedStore = derived(writableStore, ($store) => ({
queryKey: [$store],
queryFn: async () => {
await sleep(10)
return 'Success'
},
}))
const rendered = render(CreateQuery, {
props: {
options: derivedStore,
queryClient: new QueryClient(),
},
})
await waitFor(() => {
expect(rendered.queryByText('Success')).toBeInTheDocument()
})
})
test('Ensure reactivity when queryClient defaults are set', async () => {
const writableStore = writable(1)
const derivedStore = derived(writableStore, ($store) => ({
queryKey: [$store],
queryFn: async () => {
await sleep(10)
return `Success ${$store}`
},
}))
const rendered = render(CreateQuery, {
props: {
options: derivedStore,
queryClient: new QueryClient({
defaultOptions: { queries: { staleTime: 60 * 1000 } },
}),
},
})
await waitFor(() => {
expect(rendered.queryByText('Success 1')).toBeInTheDocument()
expect(rendered.queryByText('Success 2')).not.toBeInTheDocument()
})
writableStore.set(2)
await waitFor(() => {
expect(rendered.queryByText('Success 1')).not.toBeInTheDocument()
expect(rendered.queryByText('Success 2')).toBeInTheDocument()
})
writableStore.set(1)
await waitFor(() => {
expect(rendered.queryByText('Success 1')).toBeInTheDocument()
expect(rendered.queryByText('Success 2')).not.toBeInTheDocument()
})
})
test('Keep previous data when returned as placeholder data', async () => {
const writableStore = writable<Array<number>>([1])
const derivedStore = derived(writableStore, ($store) => ({
queryKey: ['test', $store],
queryFn: async () => {
await sleep(10)
return $store.map((id) => `Success ${id}`)
},
placeholderData: (previousData: string) => previousData,
}))
const rendered = render(CreateQuery, {
props: {
options: derivedStore,
queryClient: new QueryClient(),
},
})
await waitFor(() => {
expect(rendered.queryByText('Success 1')).not.toBeInTheDocument()
expect(rendered.queryByText('Success 2')).not.toBeInTheDocument()
})
await waitFor(() => {
expect(rendered.queryByText('Success 1')).toBeInTheDocument()
expect(rendered.queryByText('Success 2')).not.toBeInTheDocument()
})
writableStore.set([1, 2])
await waitFor(() => {
expect(rendered.queryByText('Success 1')).toBeInTheDocument()
expect(rendered.queryByText('Success 2')).not.toBeInTheDocument()
})
await waitFor(() => {
expect(rendered.queryByText('Success 1')).toBeInTheDocument()
expect(rendered.queryByText('Success 2')).toBeInTheDocument()
})
})
})
|
4,150 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/mutationCache.test.ts | import { beforeAll, describe, expect, test, vi } from 'vitest'
import { ref } from 'vue-demi'
import { MutationCache as MutationCacheOrigin } from '@tanstack/query-core'
import { MutationCache } from '../mutationCache'
describe('MutationCache', () => {
beforeAll(() => {
vi.spyOn(MutationCacheOrigin.prototype, 'find')
vi.spyOn(MutationCacheOrigin.prototype, 'findAll')
})
describe('find', () => {
test('should properly unwrap parameters', async () => {
const mutationCache = new MutationCache()
mutationCache.find({
mutationKey: ref(['baz']),
})
expect(MutationCacheOrigin.prototype.find).toBeCalledWith({
mutationKey: ['baz'],
})
})
})
describe('findAll', () => {
test('should properly unwrap parameters', async () => {
const mutationCache = new MutationCache()
mutationCache.findAll({
mutationKey: ref(['baz']),
})
expect(MutationCacheOrigin.prototype.findAll).toBeCalledWith({
mutationKey: ['baz'],
})
})
})
})
|
4,151 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/queryCache.test.ts | import { beforeAll, describe, expect, test, vi } from 'vitest'
import { ref } from 'vue-demi'
import { QueryCache as QueryCacheOrigin } from '@tanstack/query-core'
import { QueryCache } from '../queryCache'
describe('QueryCache', () => {
beforeAll(() => {
vi.spyOn(QueryCacheOrigin.prototype, 'find')
vi.spyOn(QueryCacheOrigin.prototype, 'findAll')
})
describe('find', () => {
test('should properly unwrap parameters', async () => {
const queryCache = new QueryCache()
queryCache.find({
queryKey: ['foo', ref('bar')],
})
expect(QueryCacheOrigin.prototype.find).toBeCalledWith({
queryKey: ['foo', 'bar'],
})
})
})
describe('findAll', () => {
test('should properly unwrap two parameters', async () => {
const queryCache = new QueryCache()
queryCache.findAll({
queryKey: ['foo', ref('bar')],
})
expect(QueryCacheOrigin.prototype.findAll).toBeCalledWith({
queryKey: ['foo', 'bar'],
})
})
test('should default to empty filters', async () => {
const queryCache = new QueryCache()
queryCache.findAll()
expect(QueryCacheOrigin.prototype.findAll).toBeCalledWith({})
})
})
})
|
4,152 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/queryClient.test.ts | import { describe, expect, test, vi } from 'vitest'
import { ref } from 'vue-demi'
import { QueryClient as QueryClientOrigin } from '@tanstack/query-core'
import { QueryClient } from '../queryClient'
vi.mock('@tanstack/query-core')
const queryKeyRef = ['foo', ref('bar')]
const queryKeyUnref = ['foo', 'bar']
const fn = () => 'mock'
describe('QueryCache', () => {
describe('isFetching', () => {
test('should properly unwrap 1 parameter', async () => {
const queryClient = new QueryClient()
queryClient.isFetching({
queryKey: queryKeyRef,
})
expect(QueryClientOrigin.prototype.isFetching).toBeCalledWith({
queryKey: queryKeyUnref,
})
})
})
describe('isMutating', () => {
test('should properly unwrap 1 parameter', async () => {
const queryClient = new QueryClient()
queryClient.isMutating({
mutationKey: queryKeyRef,
})
expect(QueryClientOrigin.prototype.isMutating).toBeCalledWith({
mutationKey: queryKeyUnref,
})
})
})
describe('getQueryData', () => {
test('should properly unwrap 1 parameter', async () => {
const queryClient = new QueryClient()
queryClient.getQueryData(queryKeyRef)
expect(QueryClientOrigin.prototype.getQueryData).toBeCalledWith(
queryKeyUnref,
)
})
})
describe('getQueriesData', () => {
test('should properly unwrap queryKey param', async () => {
const queryClient = new QueryClient()
queryClient.getQueriesData({ queryKey: queryKeyRef })
expect(QueryClientOrigin.prototype.getQueriesData).toBeCalledWith({
queryKey: queryKeyUnref,
})
})
test('should properly unwrap filters param', async () => {
const queryClient = new QueryClient()
queryClient.getQueriesData({ queryKey: queryKeyRef })
expect(QueryClientOrigin.prototype.getQueriesData).toBeCalledWith({
queryKey: queryKeyUnref,
})
})
})
describe('setQueryData', () => {
test('should properly unwrap 3 parameter', async () => {
const queryClient = new QueryClient()
queryClient.setQueryData(queryKeyRef, fn, {
updatedAt: ref(3),
})
expect(QueryClientOrigin.prototype.setQueryData).toBeCalledWith(
queryKeyUnref,
fn,
{ updatedAt: 3 },
)
})
})
describe('setQueriesData', () => {
test('should properly unwrap params with queryKey', async () => {
const queryClient = new QueryClient()
queryClient.setQueriesData({ queryKey: queryKeyRef }, fn, {
updatedAt: ref(3),
})
expect(QueryClientOrigin.prototype.setQueriesData).toBeCalledWith(
{ queryKey: queryKeyUnref },
fn,
{ updatedAt: 3 },
)
})
test('should properly unwrap params with filters', async () => {
const queryClient = new QueryClient()
queryClient.setQueriesData({ queryKey: queryKeyRef }, fn, {
updatedAt: ref(3),
})
expect(QueryClientOrigin.prototype.setQueriesData).toBeCalledWith(
{ queryKey: queryKeyUnref },
fn,
{ updatedAt: 3 },
)
})
})
describe('getQueryState', () => {
test('should properly unwrap 1 parameter', async () => {
const queryClient = new QueryClient()
queryClient.getQueryState(queryKeyRef)
expect(QueryClientOrigin.prototype.getQueryState).toBeCalledWith(
queryKeyUnref,
)
})
})
describe('removeQueries', () => {
test('should properly unwrap 1 parameter', async () => {
const queryClient = new QueryClient()
queryClient.removeQueries({
queryKey: queryKeyRef,
})
expect(QueryClientOrigin.prototype.removeQueries).toBeCalledWith({
queryKey: queryKeyUnref,
})
})
})
describe('resetQueries', () => {
test('should properly unwrap 2 parameter', async () => {
const queryClient = new QueryClient()
queryClient.resetQueries(
{
queryKey: queryKeyRef,
},
{ cancelRefetch: ref(false) },
)
expect(QueryClientOrigin.prototype.resetQueries).toBeCalledWith(
{
queryKey: queryKeyUnref,
},
{ cancelRefetch: false },
)
})
})
describe('cancelQueries', () => {
test('should properly unwrap 2 parameter', async () => {
const queryClient = new QueryClient()
queryClient.cancelQueries(
{
queryKey: queryKeyRef,
},
{ revert: ref(false) },
)
expect(QueryClientOrigin.prototype.cancelQueries).toBeCalledWith(
{
queryKey: queryKeyUnref,
},
{ revert: false },
)
})
})
describe('invalidateQueries', () => {
test('should properly unwrap 2 parameter', async () => {
const queryClient = new QueryClient()
queryClient.invalidateQueries(
{
queryKey: queryKeyRef,
},
{ cancelRefetch: ref(false) },
)
expect(QueryClientOrigin.prototype.invalidateQueries).toBeCalledWith(
{
queryKey: queryKeyUnref,
},
{ cancelRefetch: false },
)
})
})
describe('refetchQueries', () => {
test('should properly unwrap 2 parameter', async () => {
const queryClient = new QueryClient()
queryClient.refetchQueries(
{
queryKey: queryKeyRef,
},
{ cancelRefetch: ref(false) },
)
expect(QueryClientOrigin.prototype.refetchQueries).toBeCalledWith(
{
queryKey: queryKeyUnref,
},
{ cancelRefetch: false },
)
})
})
describe('fetchQuery', () => {
test('should properly unwrap parameter', async () => {
const queryClient = new QueryClient()
queryClient.fetchQuery({
queryKey: queryKeyRef,
})
expect(QueryClientOrigin.prototype.fetchQuery).toBeCalledWith({
queryKey: queryKeyUnref,
})
})
})
describe('prefetchQuery', () => {
test('should properly unwrap parameters', async () => {
const queryClient = new QueryClient()
queryClient.prefetchQuery({ queryKey: queryKeyRef, queryFn: fn })
expect(QueryClientOrigin.prototype.prefetchQuery).toBeCalledWith({
queryKey: queryKeyUnref,
queryFn: fn,
})
})
})
describe('fetchInfiniteQuery', () => {
test('should properly unwrap parameter', async () => {
const queryClient = new QueryClient()
queryClient.fetchInfiniteQuery({
queryKey: queryKeyRef,
initialPageParam: 0,
})
expect(QueryClientOrigin.prototype.fetchInfiniteQuery).toBeCalledWith({
initialPageParam: 0,
queryKey: queryKeyUnref,
})
})
})
describe('prefetchInfiniteQuery', () => {
test('should properly unwrap parameters', async () => {
const queryClient = new QueryClient()
queryClient.prefetchInfiniteQuery({
queryKey: queryKeyRef,
queryFn: fn,
initialPageParam: 0,
})
expect(QueryClientOrigin.prototype.prefetchInfiniteQuery).toBeCalledWith({
initialPageParam: 0,
queryKey: queryKeyUnref,
queryFn: fn,
})
})
})
describe('setDefaultOptions', () => {
test('should properly unwrap parameters', async () => {
const queryClient = new QueryClient()
queryClient.setDefaultOptions({
queries: {
enabled: ref(false),
},
})
expect(QueryClientOrigin.prototype.setDefaultOptions).toBeCalledWith({
queries: {
enabled: false,
},
})
})
})
describe('setQueryDefaults', () => {
test('should properly unwrap parameters', async () => {
const queryClient = new QueryClient()
queryClient.setQueryDefaults(queryKeyRef, {
enabled: ref(false),
})
expect(QueryClientOrigin.prototype.setQueryDefaults).toBeCalledWith(
queryKeyUnref,
{
enabled: false,
},
)
})
})
describe('getQueryDefaults', () => {
test('should properly unwrap parameters', async () => {
const queryClient = new QueryClient()
queryClient.getQueryDefaults(queryKeyRef)
expect(QueryClientOrigin.prototype.getQueryDefaults).toBeCalledWith(
queryKeyUnref,
)
})
})
describe('setMutationDefaults', () => {
test('should properly unwrap parameters', async () => {
const queryClient = new QueryClient()
queryClient.setMutationDefaults(queryKeyRef, {
mutationKey: queryKeyRef,
})
expect(QueryClientOrigin.prototype.setMutationDefaults).toBeCalledWith(
queryKeyUnref,
{
mutationKey: queryKeyUnref,
},
)
})
})
describe('getMutationDefaults', () => {
test('should properly unwrap parameters', async () => {
const queryClient = new QueryClient()
queryClient.getMutationDefaults(queryKeyRef)
expect(QueryClientOrigin.prototype.getMutationDefaults).toBeCalledWith(
queryKeyUnref,
)
})
})
})
|
4,153 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/queryOptions.types.test.ts | import { describe, it } from 'vitest'
import { QueryClient } from '@tanstack/query-core'
import { reactive } from 'vue-demi'
import { queryOptions } from '../queryOptions'
import { useQuery } from '../useQuery'
import { doNotExecute } from './test-utils'
import type { dataTagSymbol } from '@tanstack/query-core'
import type { Equal, Expect } from './test-utils'
describe('queryOptions', () => {
it('should not allow excess properties', () => {
doNotExecute(() => {
return queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
// @ts-expect-error this is a good error, because stallTime does not exist!
stallTime: 1000,
})
})
})
it('should infer types for callbacks', () => {
doNotExecute(() => {
return queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
staleTime: 1000,
select: (data) => {
const result: Expect<Equal<number, typeof data>> = true
return result
},
})
})
})
it('should work when passed to useQuery', () => {
doNotExecute(() => {
const options = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const { data } = reactive(useQuery(options))
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should tag the queryKey with the result type of the QueryFn', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const result: Expect<
Equal<(typeof queryKey)[typeof dataTagSymbol], number>
> = true
return result
})
it('should tag the queryKey even if no promise is returned', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => 5,
})
const result: Expect<
Equal<(typeof queryKey)[typeof dataTagSymbol], number>
> = true
return result
})
})
it('should tag the queryKey with unknown if there is no queryFn', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
})
const result: Expect<
Equal<(typeof queryKey)[typeof dataTagSymbol], unknown>
> = true
return result
})
})
it('should return the proper type when passed to getQueryData', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const queryClient = new QueryClient()
const data = queryClient.getQueryData(queryKey)
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should properly type updaterFn when passed to setQueryData', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const queryClient = new QueryClient()
const data = queryClient.setQueryData(queryKey, (prev) => {
const result: Expect<Equal<typeof prev, number | undefined>> = true
return result ? prev : 1
})
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
it('should properly type value when passed to setQueryData', () => {
doNotExecute(() => {
const { queryKey } = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(5),
})
const queryClient = new QueryClient()
// @ts-expect-error value should be a number
queryClient.setQueryData(queryKey, '5')
// @ts-expect-error value should be a number
queryClient.setQueryData(queryKey, () => '5')
const data = queryClient.setQueryData(queryKey, 5)
const result: Expect<Equal<typeof data, number | undefined>> = true
return result
})
})
})
})
|
4,155 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useInfiniteQuery.test.ts | import { describe, expect, test, vi } from 'vitest'
import { useInfiniteQuery } from '../useInfiniteQuery'
import { flushPromises, infiniteFetcher } from './test-utils'
vi.mock('../useQueryClient')
describe('useQuery', () => {
test('should properly execute infinite query', async () => {
const { data, fetchNextPage, status } = useInfiniteQuery({
queryKey: ['infiniteQuery'],
queryFn: infiniteFetcher,
initialPageParam: 0,
getNextPageParam: () => 12,
})
expect(data.value).toStrictEqual(undefined)
expect(status.value).toStrictEqual('pending')
await flushPromises()
expect(data.value).toStrictEqual({
pageParams: [0],
pages: ['data on page 0'],
})
expect(status.value).toStrictEqual('success')
fetchNextPage()
await flushPromises()
expect(data.value).toStrictEqual({
pageParams: [0, 12],
pages: ['data on page 0', 'data on page 12'],
})
expect(status.value).toStrictEqual('success')
})
})
|
4,156 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useInfiniteQuery.types.test.tsx | import { describe, it } from 'vitest'
import { reactive } from 'vue-demi'
import { useInfiniteQuery } from '../useInfiniteQuery'
import { doNotExecute, simpleFetcher } from './test-utils'
import type { Equal, Expect } from './test-utils'
import type { InfiniteData } from '@tanstack/query-core'
describe('Discriminated union return type', () => {
it('data should be possibly undefined by default', () => {
doNotExecute(() => {
const query = reactive(
useInfiniteQuery({
queryKey: ['infiniteQuery'],
queryFn: simpleFetcher,
getNextPageParam: () => undefined,
initialPageParam: 0,
}),
)
// TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
const result: Expect<
Equal<InfiniteData<string, unknown> | undefined, typeof query.data>
> = true
return result
})
})
it('data should be defined when query is success', () => {
doNotExecute(() => {
const query = reactive(
useInfiniteQuery({
queryKey: ['infiniteQuery'],
queryFn: simpleFetcher,
getNextPageParam: () => undefined,
initialPageParam: 0,
}),
)
if (query.isSuccess) {
// TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
const result: Expect<
Equal<InfiniteData<string, unknown>, typeof query.data>
> = true
return result
}
return
})
})
it('error should be null when query is success', () => {
doNotExecute(() => {
const query = reactive(
useInfiniteQuery({
queryKey: ['infiniteQuery'],
queryFn: simpleFetcher,
getNextPageParam: () => undefined,
initialPageParam: 0,
}),
)
if (query.isSuccess) {
const result: Expect<Equal<null, typeof query.error>> = true
return result
}
return
})
})
it('data should be undefined when query is pending', () => {
doNotExecute(() => {
const query = reactive(
useInfiniteQuery({
queryKey: ['infiniteQuery'],
queryFn: simpleFetcher,
getNextPageParam: () => undefined,
initialPageParam: 0,
}),
)
if (query.isPending) {
const result: Expect<Equal<undefined, typeof query.data>> = true
return result
}
return
})
})
it('error should be defined when query is error', () => {
doNotExecute(() => {
const query = reactive(
useInfiniteQuery({
queryKey: ['infiniteQuery'],
queryFn: simpleFetcher,
getNextPageParam: () => undefined,
initialPageParam: 0,
}),
)
if (query.isError) {
const result: Expect<Equal<Error, typeof query.error>> = true
return result
}
return
})
})
})
|
4,157 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useIsFetching.test.ts | import { describe, expect, test, vi } from 'vitest'
import { onScopeDispose, reactive } from 'vue-demi'
import { useQuery } from '../useQuery'
import { useIsFetching } from '../useIsFetching'
import { flushPromises, simpleFetcher } from './test-utils'
import type { MockedFunction } from 'vitest'
vi.mock('../useQueryClient')
describe('useIsFetching', () => {
test('should properly return isFetching state', async () => {
const { isFetching: isFetchingQuery } = useQuery({
queryKey: ['isFetching1'],
queryFn: simpleFetcher,
})
useQuery({ queryKey: ['isFetching2'], queryFn: simpleFetcher })
const isFetching = useIsFetching()
expect(isFetchingQuery.value).toStrictEqual(true)
expect(isFetching.value).toStrictEqual(2)
await flushPromises()
expect(isFetchingQuery.value).toStrictEqual(false)
expect(isFetching.value).toStrictEqual(0)
})
test('should stop listening to changes on onScopeDispose', async () => {
const onScopeDisposeMock = onScopeDispose as MockedFunction<
typeof onScopeDispose
>
onScopeDisposeMock.mockImplementation((fn) => fn())
const { status } = useQuery({
queryKey: ['onScopeDispose'],
queryFn: simpleFetcher,
})
const isFetching = useIsFetching()
expect(status.value).toStrictEqual('pending')
expect(isFetching.value).toStrictEqual(1)
await flushPromises()
expect(status.value).toStrictEqual('pending')
expect(isFetching.value).toStrictEqual(1)
await flushPromises()
expect(status.value).toStrictEqual('pending')
expect(isFetching.value).toStrictEqual(1)
onScopeDisposeMock.mockReset()
})
test('should properly update filters', async () => {
const filter = reactive({ stale: false })
useQuery({
queryKey: ['isFetching'],
queryFn: () =>
new Promise((resolve) => {
setTimeout(() => {
return resolve('Some data')
}, 100)
}),
})
const isFetching = useIsFetching(filter)
expect(isFetching.value).toStrictEqual(0)
filter.stale = true
await flushPromises()
expect(isFetching.value).toStrictEqual(1)
})
})
|
4,158 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useIsMutating.test.ts | import { describe, expect, it, test, vi } from 'vitest'
import { onScopeDispose, reactive } from 'vue-demi'
import { useMutation } from '../useMutation'
import { useIsMutating, useMutationState } from '../useMutationState'
import { useQueryClient } from '../useQueryClient'
import { flushPromises, successMutator } from './test-utils'
import type { MockedFunction } from 'vitest'
vi.mock('../useQueryClient')
describe('useIsMutating', () => {
test('should properly return isMutating state', async () => {
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
})
const mutation2 = useMutation({
mutationFn: (params: string) => successMutator(params),
})
const isMutating = useIsMutating()
expect(isMutating.value).toStrictEqual(0)
mutation.mutateAsync('a')
mutation2.mutateAsync('b')
await flushPromises()
expect(isMutating.value).toStrictEqual(2)
await flushPromises()
expect(isMutating.value).toStrictEqual(0)
})
test('should stop listening to changes on onScopeDispose', async () => {
const onScopeDisposeMock = onScopeDispose as MockedFunction<
typeof onScopeDispose
>
onScopeDisposeMock.mockImplementation((fn) => fn())
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
})
const mutation2 = useMutation({
mutationFn: (params: string) => successMutator(params),
})
const isMutating = useIsMutating()
expect(isMutating.value).toStrictEqual(0)
mutation.mutateAsync('a')
mutation2.mutateAsync('b')
await flushPromises()
expect(isMutating.value).toStrictEqual(0)
await flushPromises()
expect(isMutating.value).toStrictEqual(0)
onScopeDisposeMock.mockReset()
})
test('should properly update filters', async () => {
const filter = reactive({ mutationKey: ['foo'] })
const { mutate } = useMutation({
mutationKey: ['isMutating'],
mutationFn: (params: string) => successMutator(params),
})
mutate('foo')
const isMutating = useIsMutating(filter)
expect(isMutating.value).toStrictEqual(0)
filter.mutationKey = ['isMutating']
await flushPromises()
expect(isMutating.value).toStrictEqual(1)
})
})
describe('useMutationState', () => {
it('should return variables after calling mutate', async () => {
const mutationKey = ['mutation']
const variables = 'foo123'
const { mutate } = useMutation({
mutationKey: mutationKey,
mutationFn: (params: string) => successMutator(params),
})
mutate(variables)
const mutationState = useMutationState({
filters: { mutationKey, status: 'pending' },
select: (mutation) => mutation.state.variables,
})
expect(mutationState.value).toEqual([variables])
})
it('should return variables after calling mutate', async () => {
const queryClient = useQueryClient()
queryClient.clear()
const mutationKey = ['mutation']
const variables = 'bar234'
const { mutate } = useMutation({
mutationKey: mutationKey,
mutationFn: (params: string) => successMutator(params),
})
mutate(variables)
const mutationState = useMutationState()
expect(mutationState.value[0]).toContain({ variables: variables })
})
})
|
4,159 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useMutation.test.ts | import { beforeEach, describe, expect, test, vi } from 'vitest'
import { reactive, ref } from 'vue-demi'
import { useMutation } from '../useMutation'
import { useQueryClient } from '../useQueryClient'
import { errorMutator, flushPromises, successMutator } from './test-utils'
vi.mock('../useQueryClient')
describe('useMutation', () => {
test('should be in idle state initially', () => {
const mutation = useMutation({
mutationFn: (params) => successMutator(params),
})
expect(mutation).toMatchObject({
isIdle: { value: true },
isPending: { value: false },
isError: { value: false },
isSuccess: { value: false },
})
})
test('should change state after invoking mutate', () => {
const result = 'Mock data'
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
})
mutation.mutate(result)
expect(mutation).toMatchObject({
isIdle: { value: false },
isPending: { value: true },
isError: { value: false },
isSuccess: { value: false },
data: { value: undefined },
error: { value: null },
})
})
test('should return error when request fails', async () => {
const mutation = useMutation({ mutationFn: errorMutator })
mutation.mutate({})
await flushPromises(10)
expect(mutation).toMatchObject({
isIdle: { value: false },
isPending: { value: false },
isError: { value: true },
isSuccess: { value: false },
data: { value: undefined },
error: { value: Error('Some error') },
})
})
test('should return data when request succeeds', async () => {
const result = 'Mock data'
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
})
mutation.mutate(result)
await flushPromises(10)
expect(mutation).toMatchObject({
isIdle: { value: false },
isPending: { value: false },
isError: { value: false },
isSuccess: { value: true },
data: { value: 'Mock data' },
error: { value: null },
})
})
test('should update reactive options', async () => {
const queryClient = useQueryClient()
const mutationCache = queryClient.getMutationCache()
const options = reactive({
mutationKey: ['foo'],
mutationFn: (params: string) => successMutator(params),
})
const mutation = useMutation(options)
options.mutationKey = ['bar']
await flushPromises()
mutation.mutate('xyz')
await flushPromises()
const mutations = mutationCache.find({ mutationKey: ['bar'] })
expect(mutations?.options.mutationKey).toEqual(['bar'])
})
test('should update reactive options deeply', async () => {
type MutationKeyTest = {
entity: string
otherObject: {
name: string
}
}
const mutationKey = ref<Array<MutationKeyTest>>([
{
entity: 'test',
otherObject: { name: 'objectName' },
},
])
const queryClient = useQueryClient()
const mutationCache = queryClient.getMutationCache()
const options = reactive({
mutationKey,
mutationFn: (params: string) => successMutator(params),
})
const mutation = useMutation(options)
mutationKey.value[0]!.otherObject.name = 'someOtherObjectName'
await flushPromises()
mutation.mutate('xyz')
await flushPromises()
const mutations = mutationCache.getAll()
const relevantMutation = mutations.find((m) => {
return (
Array.isArray(m.options.mutationKey) &&
!!m.options.mutationKey[0].otherObject
)
})
expect(
(relevantMutation?.options.mutationKey as Array<MutationKeyTest>)[0]
?.otherObject.name === 'someOtherObjectName',
)
})
test('should allow for non-options object (mutationFn or mutationKey) passed as arg1 & arg2 to trigger reactive updates', async () => {
const mutationKey = ref<Array<string>>(['foo2'])
const mutationFn = ref((params: string) => successMutator(params))
const queryClient = useQueryClient()
const mutationCache = queryClient.getMutationCache()
const mutation = useMutation({ mutationKey, mutationFn })
mutationKey.value = ['bar2']
let proof = false
mutationFn.value = (params: string) => {
proof = true
return successMutator(params)
}
await flushPromises()
mutation.mutate('xyz')
await flushPromises()
const mutations = mutationCache.find({ mutationKey: ['bar2'] })
expect(mutations?.options.mutationKey).toEqual(['bar2'])
expect(proof).toEqual(true)
})
test('should reset state after invoking mutation.reset', async () => {
const mutation = useMutation({
mutationFn: (params: string) => errorMutator(params),
})
mutation.mutate('')
await flushPromises(10)
mutation.reset()
expect(mutation).toMatchObject({
isIdle: { value: true },
isPending: { value: false },
isError: { value: false },
isSuccess: { value: false },
data: { value: undefined },
error: { value: null },
})
})
describe('side effects', () => {
beforeEach(() => {
vi.clearAllMocks()
})
test('should call onMutate when passed as an option', async () => {
const onMutate = vi.fn()
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
onMutate,
})
mutation.mutate('')
await flushPromises(10)
expect(onMutate).toHaveBeenCalledTimes(1)
})
test('should call onError when passed as an option', async () => {
const onError = vi.fn()
const mutation = useMutation({
mutationFn: (params: string) => errorMutator(params),
onError,
})
mutation.mutate('')
await flushPromises(10)
expect(onError).toHaveBeenCalledTimes(1)
})
test('should call onSuccess when passed as an option', async () => {
const onSuccess = vi.fn()
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
onSuccess,
})
mutation.mutate('')
await flushPromises(10)
expect(onSuccess).toHaveBeenCalledTimes(1)
})
test('should call onSettled when passed as an option', async () => {
const onSettled = vi.fn()
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
onSettled,
})
mutation.mutate('')
await flushPromises(10)
expect(onSettled).toHaveBeenCalledTimes(1)
})
test('should call onError when passed as an argument of mutate function', async () => {
const onError = vi.fn()
const mutation = useMutation({
mutationFn: (params: string) => errorMutator(params),
})
mutation.mutate('', { onError })
await flushPromises(10)
expect(onError).toHaveBeenCalledTimes(1)
})
test('should call onSuccess when passed as an argument of mutate function', async () => {
const onSuccess = vi.fn()
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
})
mutation.mutate('', { onSuccess })
await flushPromises(10)
expect(onSuccess).toHaveBeenCalledTimes(1)
})
test('should call onSettled when passed as an argument of mutate function', async () => {
const onSettled = vi.fn()
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
})
mutation.mutate('', { onSettled })
await flushPromises(10)
expect(onSettled).toHaveBeenCalledTimes(1)
})
test('should fire both onSettled functions', async () => {
const onSettled = vi.fn()
const onSettledOnFunction = vi.fn()
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
onSettled,
})
mutation.mutate('', { onSettled: onSettledOnFunction })
await flushPromises(10)
expect(onSettled).toHaveBeenCalledTimes(1)
expect(onSettledOnFunction).toHaveBeenCalledTimes(1)
})
})
describe('async', () => {
beforeEach(() => {
vi.clearAllMocks()
})
test('should resolve properly', async () => {
const result = 'Mock data'
const mutation = useMutation({
mutationFn: (params: string) => successMutator(params),
})
await expect(mutation.mutateAsync(result)).resolves.toBe(result)
expect(mutation).toMatchObject({
isIdle: { value: false },
isPending: { value: false },
isError: { value: false },
isSuccess: { value: true },
data: { value: 'Mock data' },
error: { value: null },
})
})
test('should throw on error', async () => {
const mutation = useMutation({ mutationFn: errorMutator })
await expect(mutation.mutateAsync({})).rejects.toThrowError('Some error')
expect(mutation).toMatchObject({
isIdle: { value: false },
isPending: { value: false },
isError: { value: true },
isSuccess: { value: false },
data: { value: undefined },
error: { value: Error('Some error') },
})
})
})
describe('throwOnError', () => {
test('should evaluate throwOnError when mutation is expected to throw', async () => {
const err = new Error('Expected mock error. All is well!')
const boundaryFn = vi.fn()
const { mutate } = useMutation({
mutationFn: () => {
return Promise.reject(err)
},
throwOnError: boundaryFn,
})
mutate()
await flushPromises()
expect(boundaryFn).toHaveBeenCalledTimes(1)
expect(boundaryFn).toHaveBeenCalledWith(err)
})
})
})
|
4,160 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useMutation.types.test.tsx | import { describe, it } from 'vitest'
import { reactive } from 'vue-demi'
import { useMutation } from '../useMutation'
import { doNotExecute, successMutator } from './test-utils'
import type { Equal, Expect } from './test-utils'
describe('Discriminated union return type', () => {
it('data should be possibly undefined by default', () => {
doNotExecute(() => {
const mutation = reactive(
useMutation({ mutationFn: successMutator<string> }),
)
const result: Expect<Equal<string | undefined, typeof mutation.data>> =
true
return result
})
})
it('data should be defined when mutation is success', () => {
doNotExecute(() => {
const mutation = reactive(
useMutation({ mutationFn: successMutator<string> }),
)
if (mutation.isSuccess) {
const result: Expect<Equal<string, typeof mutation.data>> = true
return result
}
return
})
})
it('error should be null when mutation is success', () => {
doNotExecute(() => {
const mutation = reactive(
useMutation({ mutationFn: successMutator<string> }),
)
if (mutation.isSuccess) {
const result: Expect<Equal<null, typeof mutation.error>> = true
return result
}
return
})
})
it('data should be undefined when mutation is pending', () => {
doNotExecute(() => {
const mutation = reactive(
useMutation({ mutationFn: successMutator<string> }),
)
if (mutation.isPending) {
const result: Expect<Equal<undefined, typeof mutation.data>> = true
return result
}
return
})
})
it('error should be defined when mutation is error', () => {
doNotExecute(() => {
const mutation = reactive(
useMutation({ mutationFn: successMutator<string> }),
)
if (mutation.isError) {
const result: Expect<Equal<Error, typeof mutation.error>> = true
return result
}
return
})
})
it('should narrow variables', () => {
doNotExecute(() => {
const mutation = reactive(
useMutation({ mutationFn: successMutator<string> }),
)
if (mutation.isIdle) {
const result: Expect<Equal<undefined, typeof mutation.variables>> = true
return result
}
if (mutation.isPending) {
const result: Expect<Equal<string, typeof mutation.variables>> = true
return result
}
if (mutation.isSuccess) {
const result: Expect<Equal<string, typeof mutation.variables>> = true
return result
}
const result: Expect<Equal<string, typeof mutation.variables>> = true
return result
})
})
})
|
4,161 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useQueries.test.ts | import { beforeEach, describe, expect, test, vi } from 'vitest'
import { onScopeDispose, ref } from 'vue-demi'
import { useQueries } from '../useQueries'
import { useQueryClient } from '../useQueryClient'
import { QueryClient } from '../queryClient'
import {
flushPromises,
getSimpleFetcherWithReturnData,
rejectFetcher,
simpleFetcher,
} from './test-utils'
import type { MockedFunction } from 'vitest'
vi.mock('../useQueryClient')
describe('useQueries', () => {
beforeEach(() => {
vi.restoreAllMocks()
})
test('should return result for each query', () => {
const queries = [
{
queryKey: ['key1'],
queryFn: simpleFetcher,
},
{
queryKey: ['key2'],
queryFn: simpleFetcher,
},
]
const queriesState = useQueries({ queries })
expect(queriesState.value).toMatchObject([
{
status: 'pending',
isPending: true,
isFetching: true,
isStale: true,
},
{
status: 'pending',
isPending: true,
isFetching: true,
isStale: true,
},
])
})
test('should resolve to success and update reactive state', async () => {
const queries = [
{
queryKey: ['key11'],
queryFn: simpleFetcher,
},
{
queryKey: ['key12'],
queryFn: simpleFetcher,
},
]
const queriesState = useQueries({ queries })
await flushPromises()
expect(queriesState.value).toMatchObject([
{
status: 'success',
isPending: false,
isFetching: false,
isStale: true,
},
{
status: 'success',
isPending: false,
isFetching: false,
isStale: true,
},
])
})
test('should reject one of the queries and update reactive state', async () => {
const queries = [
{
queryKey: ['key21'],
queryFn: rejectFetcher,
},
{
queryKey: ['key22'],
queryFn: simpleFetcher,
},
]
const queriesState = useQueries({ queries })
await flushPromises()
expect(queriesState.value).toMatchObject([
{
status: 'error',
isPending: false,
isFetching: false,
isStale: true,
},
{
status: 'success',
isPending: false,
isFetching: false,
isStale: true,
},
])
})
test('should return state for new queries', async () => {
const queries = ref([
{
queryKey: ['key31'],
queryFn: getSimpleFetcherWithReturnData('value31'),
},
{
queryKey: ['key32'],
queryFn: getSimpleFetcherWithReturnData('value32'),
},
{
queryKey: ['key33'],
queryFn: getSimpleFetcherWithReturnData('value33'),
},
])
const queriesState = useQueries({ queries })
await flushPromises()
queries.value.splice(
0,
queries.value.length,
{
queryKey: ['key31'],
queryFn: getSimpleFetcherWithReturnData('value31'),
},
{
queryKey: ['key34'],
queryFn: getSimpleFetcherWithReturnData('value34'),
},
)
await flushPromises()
await flushPromises()
expect(queriesState.value.length).toEqual(2)
expect(queriesState.value).toMatchObject([
{
data: 'value31',
status: 'success',
isPending: false,
isFetching: false,
isStale: true,
},
{
data: 'value34',
status: 'success',
isPending: false,
isFetching: false,
isStale: true,
},
])
})
test('should stop listening to changes on onScopeDispose', async () => {
const onScopeDisposeMock = onScopeDispose as MockedFunction<
typeof onScopeDispose
>
onScopeDisposeMock.mockImplementationOnce((fn) => fn())
const queries = [
{
queryKey: ['key41'],
queryFn: simpleFetcher,
},
{
queryKey: ['key42'],
queryFn: simpleFetcher,
},
]
const queriesState = useQueries({ queries })
await flushPromises()
expect(queriesState.value).toMatchObject([
{
status: 'pending',
isPending: true,
isFetching: true,
isStale: true,
},
{
status: 'pending',
isPending: true,
isFetching: true,
isStale: true,
},
])
})
test('should use queryClient provided via options', async () => {
const queryClient = new QueryClient()
const queries = [
{
queryKey: ['key41'],
queryFn: simpleFetcher,
},
{
queryKey: ['key42'],
queryFn: simpleFetcher,
},
]
useQueries({ queries }, queryClient)
await flushPromises()
expect(useQueryClient).toHaveBeenCalledTimes(0)
})
test('should combine queries', async () => {
const firstResult = 'first result'
const secondResult = 'second result'
const queryClient = new QueryClient()
const queries = [
{
queryKey: ['key41'],
queryFn: getSimpleFetcherWithReturnData(firstResult),
},
{
queryKey: ['key42'],
queryFn: getSimpleFetcherWithReturnData(secondResult),
},
]
const queriesResult = useQueries(
{
queries,
combine: (results) => {
return {
combined: true,
res: results.map((res) => res.data),
}
},
},
queryClient,
)
await flushPromises()
expect(queriesResult.value).toMatchObject({
combined: true,
res: [firstResult, secondResult],
})
})
test('should be `enabled` to accept getter function', async () => {
const fetchFn = vi.fn()
const checked = ref(false)
useQueries({
queries: [
{
queryKey: ['enabled'],
queryFn: fetchFn,
enabled: () => checked.value,
},
],
})
expect(fetchFn).not.toHaveBeenCalled()
checked.value = true
await flushPromises()
expect(fetchFn).toHaveBeenCalled()
})
})
|
4,162 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useQuery.test.ts | import { describe, expect, test, vi } from 'vitest'
import {
computed,
getCurrentInstance,
onScopeDispose,
reactive,
ref,
} from 'vue-demi'
import { QueryObserver } from '@tanstack/query-core'
import { useQuery } from '../useQuery'
import { useBaseQuery } from '../useBaseQuery'
import {
flushPromises,
getSimpleFetcherWithReturnData,
rejectFetcher,
simpleFetcher,
} from './test-utils'
import type { Mock, MockedFunction } from 'vitest'
vi.mock('../useQueryClient')
vi.mock('../useBaseQuery')
describe('useQuery', () => {
test('should properly execute query', () => {
useQuery({ queryKey: ['key0'], queryFn: simpleFetcher, staleTime: 1000 })
expect(useBaseQuery).toBeCalledWith(
QueryObserver,
{
queryKey: ['key0'],
queryFn: simpleFetcher,
staleTime: 1000,
},
undefined,
)
})
test('should return pending status initially', () => {
const query = useQuery({ queryKey: ['key1'], queryFn: simpleFetcher })
expect(query).toMatchObject({
status: { value: 'pending' },
isPending: { value: true },
isFetching: { value: true },
isStale: { value: true },
})
})
test('should resolve to success and update reactive state: useQuery(key, dataFn)', async () => {
const query = useQuery({
queryKey: ['key2'],
queryFn: getSimpleFetcherWithReturnData('result2'),
})
await flushPromises()
expect(query).toMatchObject({
status: { value: 'success' },
data: { value: 'result2' },
isPending: { value: false },
isFetching: { value: false },
isFetched: { value: true },
isSuccess: { value: true },
})
})
test('should resolve to success and update reactive state: useQuery(optionsObj)', async () => {
const query = useQuery({
queryKey: ['key31'],
queryFn: getSimpleFetcherWithReturnData('result31'),
enabled: true,
})
await flushPromises()
expect(query).toMatchObject({
status: { value: 'success' },
data: { value: 'result31' },
isPending: { value: false },
isFetching: { value: false },
isFetched: { value: true },
isSuccess: { value: true },
})
})
test('should resolve to success and update reactive state: useQuery(key, optionsObj)', async () => {
const query = useQuery({
queryKey: ['key32'],
queryFn: getSimpleFetcherWithReturnData('result32'),
enabled: true,
})
await flushPromises()
expect(query).toMatchObject({
status: { value: 'success' },
data: { value: 'result32' },
isPending: { value: false },
isFetching: { value: false },
isFetched: { value: true },
isSuccess: { value: true },
})
})
test('should reject and update reactive state', async () => {
const query = useQuery({
queryKey: ['key3'],
queryFn: rejectFetcher,
})
await flushPromises()
expect(query).toMatchObject({
status: { value: 'error' },
data: { value: undefined },
error: { value: { message: 'Some error' } },
isPending: { value: false },
isFetching: { value: false },
isFetched: { value: true },
isError: { value: true },
failureCount: { value: 1 },
failureReason: { value: { message: 'Some error' } },
})
})
test('should update query on reactive (Ref) key change', async () => {
const secondKeyRef = ref('key7')
const query = useQuery({
queryKey: ['key6', secondKeyRef],
queryFn: simpleFetcher,
})
await flushPromises()
expect(query).toMatchObject({
status: { value: 'success' },
})
secondKeyRef.value = 'key8'
await flushPromises()
expect(query).toMatchObject({
status: { value: 'pending' },
data: { value: undefined },
})
await flushPromises()
expect(query).toMatchObject({
status: { value: 'success' },
})
})
test("should update query when an option is passed as Ref and it's changed", async () => {
const enabled = ref(false)
const query = useQuery({
queryKey: ['key9'],
queryFn: simpleFetcher,
enabled,
})
await flushPromises()
expect(query).toMatchObject({
fetchStatus: { value: 'idle' },
data: { value: undefined },
})
enabled.value = true
await flushPromises()
expect(query).toMatchObject({
fetchStatus: { value: 'fetching' },
data: { value: undefined },
})
await flushPromises()
expect(query).toMatchObject({
status: { value: 'success' },
})
})
test('should properly execute dependant queries', async () => {
const { data } = useQuery({
queryKey: ['dependant1'],
queryFn: simpleFetcher,
})
const enabled = computed(() => !!data.value)
const dependentQueryFn = vi.fn().mockImplementation(simpleFetcher)
const { fetchStatus, status } = useQuery(
reactive({
queryKey: ['dependant2'],
queryFn: dependentQueryFn,
enabled,
}),
)
expect(data.value).toStrictEqual(undefined)
expect(fetchStatus.value).toStrictEqual('idle')
expect(dependentQueryFn).not.toHaveBeenCalled()
await flushPromises()
expect(data.value).toStrictEqual('Some data')
expect(fetchStatus.value).toStrictEqual('fetching')
await flushPromises()
expect(fetchStatus.value).toStrictEqual('idle')
expect(status.value).toStrictEqual('success')
expect(dependentQueryFn).toHaveBeenCalledTimes(1)
expect(dependentQueryFn).toHaveBeenCalledWith(
expect.objectContaining({ queryKey: ['dependant2'] }),
)
})
test('should stop listening to changes on onScopeDispose', async () => {
const onScopeDisposeMock = onScopeDispose as MockedFunction<
typeof onScopeDispose
>
onScopeDisposeMock.mockImplementationOnce((fn) => fn())
const { status } = useQuery({
queryKey: ['onScopeDispose'],
queryFn: simpleFetcher,
})
expect(status.value).toStrictEqual('pending')
await flushPromises()
expect(status.value).toStrictEqual('pending')
await flushPromises()
expect(status.value).toStrictEqual('pending')
})
test('should use the current value for the queryKey when refetch is called', async () => {
const fetchFn = vi.fn()
const keyRef = ref('key11')
const query = useQuery({
queryKey: ['key10', keyRef],
queryFn: fetchFn,
enabled: false,
})
expect(fetchFn).not.toHaveBeenCalled()
await query.refetch()
expect(fetchFn).toHaveBeenCalledTimes(1)
expect(fetchFn).toHaveBeenCalledWith(
expect.objectContaining({
queryKey: ['key10', 'key11'],
}),
)
keyRef.value = 'key12'
await query.refetch()
expect(fetchFn).toHaveBeenCalledTimes(2)
expect(fetchFn).toHaveBeenCalledWith(
expect.objectContaining({
queryKey: ['key10', 'key12'],
}),
)
})
test('should be `enabled` to accept getter function', async () => {
const fetchFn = vi.fn()
const checked = ref(false)
useQuery({
queryKey: ['enabled'],
queryFn: fetchFn,
enabled: () => checked.value,
})
expect(fetchFn).not.toHaveBeenCalled()
checked.value = true
await flushPromises()
expect(fetchFn).toHaveBeenCalled()
})
describe('throwOnError', () => {
test('should evaluate throwOnError when query is expected to throw', async () => {
const boundaryFn = vi.fn()
useQuery({
queryKey: ['key0'],
queryFn: rejectFetcher,
retry: false,
throwOnError: boundaryFn,
})
await flushPromises()
expect(boundaryFn).toHaveBeenCalledTimes(1)
expect(boundaryFn).toHaveBeenCalledWith(
Error('Some error'),
expect.objectContaining({
state: expect.objectContaining({ status: 'error' }),
}),
)
})
})
describe('suspense', () => {
test('should return a Promise', () => {
const getCurrentInstanceSpy = getCurrentInstance as Mock
getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} }))
const query = useQuery({ queryKey: ['suspense'], queryFn: simpleFetcher })
const result = query.suspense()
expect(result).toBeInstanceOf(Promise)
})
test('should resolve after being enabled', () => {
const getCurrentInstanceSpy = getCurrentInstance as Mock
getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} }))
let afterTimeout = false
const isEnabeld = ref(false)
const query = useQuery({
queryKey: ['suspense'],
queryFn: simpleFetcher,
enabled: isEnabeld,
})
setTimeout(() => {
afterTimeout = true
isEnabeld.value = true
}, 200)
return query.suspense().then(() => {
expect(afterTimeout).toBe(true)
})
})
test('should resolve immidiately when stale without refetching', () => {
const getCurrentInstanceSpy = getCurrentInstance as Mock
getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} }))
const fetcherSpy = vi.fn(() => simpleFetcher())
// let afterTimeout = false;
const query = useQuery({
queryKey: ['suspense'],
queryFn: simpleFetcher,
staleTime: 10000,
initialData: 'foo',
})
return query.suspense().then(() => {
expect(fetcherSpy).toHaveBeenCalledTimes(0)
})
})
})
})
|
4,163 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useQuery.types.test.ts | import { describe, it } from 'vitest'
import { reactive } from 'vue-demi'
import { useQuery } from '../useQuery'
import { queryOptions } from '../queryOptions'
import { doNotExecute, simpleFetcher } from './test-utils'
import type { UseQueryOptions } from '../useQuery'
import type { Equal, Expect } from './test-utils'
describe('initialData', () => {
describe('Config object overload', () => {
it('TData should always be defined when initialData is provided as an object', () => {
doNotExecute(() => {
const { data } = reactive(
useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: {
wow: true,
},
}),
)
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('TData should be defined when passed through queryOptions', () => {
doNotExecute(() => {
const options = queryOptions({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: {
wow: true,
},
})
const { data } = reactive(useQuery(options))
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('it should be possible to define a different TData than TQueryFnData using select with queryOptions spread into useQuery', () => {
doNotExecute(() => {
const options = queryOptions({
queryKey: ['key'],
queryFn: () => Promise.resolve(1),
})
const query = reactive(
useQuery({
...options,
select: (data) => data > 1,
}),
)
const result: Expect<Equal<boolean | undefined, typeof query.data>> =
true
return result
})
})
it('TData should always be defined when initialData is provided as a function which ALWAYS returns the data', () => {
doNotExecute(() => {
const { data } = reactive(
useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: () => ({
wow: true,
}),
}),
)
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
})
})
it('TData should have undefined in the union when initialData is NOT provided', () => {
doNotExecute(() => {
const { data } = reactive(
useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
}),
)
const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
true
return result
})
})
it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
doNotExecute(() => {
const { data } = reactive(
useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: () => undefined as { wow: boolean } | undefined,
}),
)
const result: Expect<Equal<{ wow: boolean } | undefined, typeof data>> =
true
return result
})
})
it('TData should be narrowed after an isSuccess check when initialData is provided as a function which can return undefined', () => {
doNotExecute(() => {
const { data, isSuccess } = reactive(
useQuery({
queryKey: ['key'],
queryFn: () => {
return {
wow: true,
}
},
initialData: () => undefined as { wow: boolean } | undefined,
}),
)
if (isSuccess) {
const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
return result
}
return false
})
})
})
describe('custom composables', () => {
it('should allow custom composables using UseQueryOptions', () => {
doNotExecute(() => {
type Data = string
const useCustomQuery = (
options?: Omit<UseQueryOptions<Data>, 'queryKey' | 'queryFn'>,
) => {
return useQuery({
...options,
queryKey: ['todos-key'],
queryFn: () => Promise.resolve('data'),
})
}
const { data } = reactive(useCustomQuery())
const result: Expect<Equal<Data | undefined, typeof data>> = true
return result
})
})
})
describe('structuralSharing', () => {
it('should restrict to same types', () => {
doNotExecute(() => {
useQuery({
queryKey: ['key'],
queryFn: () => 5,
structuralSharing: (_oldData, newData) => {
return newData
},
})
})
})
})
describe('Discriminated union return type', () => {
it('data should be possibly undefined by default', () => {
doNotExecute(() => {
const query = reactive(
useQuery({
queryKey: ['key'],
queryFn: simpleFetcher,
}),
)
const result: Expect<Equal<string | undefined, typeof query.data>> =
true
return result
})
})
it('data should be defined when query is success', () => {
doNotExecute(() => {
const query = reactive(
useQuery({
queryKey: ['key'],
queryFn: simpleFetcher,
}),
)
if (query.isSuccess) {
const result: Expect<Equal<string, typeof query.data>> = true
return result
}
return
})
})
it('error should be null when query is success', () => {
doNotExecute(() => {
const query = reactive(
useQuery({
queryKey: ['key'],
queryFn: simpleFetcher,
}),
)
if (query.isSuccess) {
const result: Expect<Equal<null, typeof query.error>> = true
return result
}
return
})
})
it('data should be undefined when query is pending', () => {
doNotExecute(() => {
const query = reactive(
useQuery({
queryKey: ['key'],
queryFn: simpleFetcher,
}),
)
if (query.isPending) {
const result: Expect<Equal<undefined, typeof query.data>> = true
return result
}
return
})
})
it('error should be defined when query is error', () => {
doNotExecute(() => {
const query = reactive(
useQuery({
queryKey: ['key'],
queryFn: simpleFetcher,
}),
)
if (query.isError) {
const result: Expect<Equal<Error, typeof query.error>> = true
return result
}
return
})
})
})
})
|
4,164 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/useQueryClient.test.ts | import { beforeEach, describe, expect, test, vi } from 'vitest'
import { hasInjectionContext, inject } from 'vue-demi'
import { useQueryClient } from '../useQueryClient'
import { VUE_QUERY_CLIENT } from '../utils'
import type { Mock } from 'vitest'
describe('useQueryClient', () => {
const injectSpy = inject as Mock
const hasInjectionContextSpy = hasInjectionContext as Mock
beforeEach(() => {
vi.restoreAllMocks()
})
test('should return queryClient when it is provided in the context', () => {
const queryClientMock = { name: 'Mocked client' }
injectSpy.mockReturnValueOnce(queryClientMock)
const queryClient = useQueryClient()
expect(queryClient).toStrictEqual(queryClientMock)
expect(injectSpy).toHaveBeenCalledTimes(1)
expect(injectSpy).toHaveBeenCalledWith(VUE_QUERY_CLIENT)
})
test('should throw an error when queryClient does not exist in the context', () => {
injectSpy.mockReturnValueOnce(undefined)
expect(useQueryClient).toThrowError()
expect(injectSpy).toHaveBeenCalledTimes(1)
expect(injectSpy).toHaveBeenCalledWith(VUE_QUERY_CLIENT)
})
test('should throw an error when used outside of setup function', () => {
hasInjectionContextSpy.mockReturnValueOnce(false)
expect(useQueryClient).toThrowError()
expect(hasInjectionContextSpy).toHaveBeenCalledTimes(1)
})
test('should call inject with a custom key as a suffix', () => {
const queryClientKey = 'foo'
const expectedKeyParameter = `${VUE_QUERY_CLIENT}:${queryClientKey}`
const queryClientMock = { name: 'Mocked client' }
injectSpy.mockReturnValueOnce(queryClientMock)
useQueryClient(queryClientKey)
expect(injectSpy).toHaveBeenCalledWith(expectedKeyParameter)
})
})
|
4,165 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/utils.test.ts | import { describe, expect, test } from 'vitest'
import { reactive, ref } from 'vue-demi'
import { cloneDeep, cloneDeepUnref, updateState } from '../utils'
describe('utils', () => {
describe('updateState', () => {
test('should update first object with values from the second one', () => {
const origin = { option1: 'a', option2: 'b', option3: 'c' }
const update = { option1: 'x', option2: 'y', option3: 'z' }
const expected = { option1: 'x', option2: 'y', option3: 'z' }
updateState(origin, update)
expect(origin).toEqual(expected)
})
test('should update only existing keys', () => {
const origin = { option1: 'a', option2: 'b' }
const update = { option1: 'x', option2: 'y', option3: 'z' }
const expected = { option1: 'x', option2: 'y' }
updateState(origin, update)
expect(origin).toEqual(expected)
})
test('should remove non existing keys', () => {
const origin = { option1: 'a', option2: 'b', option3: 'c' }
const update = { option1: 'x', option2: 'y' }
const expected = { option1: 'x', option2: 'y' }
updateState(origin, update)
expect(origin).toEqual(expected)
})
})
describe('cloneDeep', () => {
test('should copy primitives and functions AS-IS', () => {
expect(cloneDeep(3456)).toBe(3456)
expect(cloneDeep('theString')).toBe('theString')
expect(cloneDeep(null)).toBe(null)
})
test('should copy Maps and Sets AS-IS', () => {
const setVal = new Set([3, 4, 5])
const setValCopy = cloneDeep(setVal)
expect(setValCopy).toBe(setVal)
expect(setValCopy).toStrictEqual(new Set([3, 4, 5]))
const mapVal = new Map([
['a', 'aVal'],
['b', 'bVal'],
])
const mapValCopy = cloneDeep(mapVal)
expect(mapValCopy).toBe(mapVal)
expect(mapValCopy).toStrictEqual(
new Map([
['a', 'aVal'],
['b', 'bVal'],
]),
)
})
test('should deeply copy arrays', () => {
const val = [
25,
'str',
null,
new Set([3, 4]),
[5, 6, { a: 1 }],
undefined,
]
const cp = cloneDeep(val)
expect(cp).toStrictEqual([
25,
'str',
null,
new Set([3, 4]),
[5, 6, { a: 1 }],
undefined,
])
expect(cp).not.toBe(val)
expect(cp[3]).toBe(val[3]) // Set([3, 4])
expect(cp[4]).not.toBe(val[4]) // [5, 6, { a: 1 }]
expect((cp[4] as Array<number>)[2]).not.toBe((val[4] as Array<number>)[2]) // { a : 1 }
})
test('should deeply copy object', () => {
const val = reactive({
a: 25,
b: 'str',
c: null,
d: undefined,
e: new Set([5, 6]),
f: [3, 4],
g: { fa: 26 },
})
const cp = cloneDeep(val)
expect(cp).toStrictEqual({
a: 25,
b: 'str',
c: null,
d: undefined,
e: new Set([5, 6]),
f: [3, 4],
g: { fa: 26 },
})
expect(cp.e).toBe(val.e) // Set
expect(cp.f).not.toBe(val.f) // []
expect(cp.g).not.toBe(val.g) // {}
})
})
describe('cloneDeepUnref', () => {
test('should unref primitives', () => {
expect(cloneDeepUnref(ref(34))).toBe(34)
expect(cloneDeepUnref(ref('mystr'))).toBe('mystr')
})
test('should deeply unref arrays', () => {
const val = ref([2, 3, ref(4), ref('5'), { a: ref(6) }, [ref(7)]])
const cp = cloneDeepUnref(val)
expect(cp).toStrictEqual([2, 3, 4, '5', { a: 6 }, [7]])
})
test('should deeply unref objects', () => {
const val = ref({
a: 1,
b: ref(2),
c: [ref('c1'), ref(['c2'])],
d: {
e: ref('e'),
},
})
const cp = cloneDeepUnref(val)
expect(cp).toEqual({
a: 1,
b: 2,
c: ['c1', ['c2']],
d: { e: 'e' },
})
})
test('should unref undefined', () => {
expect(cloneDeepUnref(ref(undefined))).toBe(undefined)
})
})
})
|
4,166 | 0 | petrpan-code/TanStack/query/packages/vue-query/src | petrpan-code/TanStack/query/packages/vue-query/src/__tests__/vueQueryPlugin.test.ts | import { describe, expect, test, vi } from 'vitest'
import { isVue2, isVue3, ref } from 'vue-demi'
import { QueryClient } from '../queryClient'
import { VueQueryPlugin } from '../vueQueryPlugin'
import { VUE_QUERY_CLIENT } from '../utils'
import { setupDevtools } from '../devtools/devtools'
import { useQuery } from '../useQuery'
import { useQueries } from '../useQueries'
import { flushPromises } from './test-utils'
import type { App, ComponentOptions } from 'vue'
import type { Mock } from 'vitest'
vi.mock('../devtools/devtools')
vi.mock('../useQueryClient')
vi.mock('../useBaseQuery')
interface TestApp extends App {
onUnmount: Function
_unmount: Function
_mixin: ComponentOptions
_provided: Record<string, any>
$root: TestApp
}
const testIf = (condition: boolean) => (condition ? test : test.skip)
function getAppMock(withUnmountHook = false): TestApp {
const mock = {
provide: vi.fn(),
unmount: vi.fn(),
onUnmount: withUnmountHook
? vi.fn((u: Function) => {
mock._unmount = u
})
: undefined,
mixin: (m: ComponentOptions): any => {
mock._mixin = m
},
} as unknown as TestApp
return mock
}
describe('VueQueryPlugin', () => {
describe('devtools', () => {
test('should NOT setup devtools', () => {
const setupDevtoolsMock = setupDevtools as Mock
const appMock = getAppMock()
VueQueryPlugin.install(appMock)
expect(setupDevtoolsMock).toHaveBeenCalledTimes(0)
})
testIf(isVue2)('should setup devtools', () => {
const envCopy = process.env.NODE_ENV
process.env.NODE_ENV = 'development'
const setupDevtoolsMock = setupDevtools as Mock
const appMock = getAppMock()
VueQueryPlugin.install(appMock)
appMock.$root = appMock
appMock._mixin.beforeCreate?.call(appMock)
process.env.NODE_ENV = envCopy
expect(setupDevtoolsMock).toHaveBeenCalledTimes(1)
})
testIf(isVue3)('should setup devtools', () => {
const envCopy = process.env.NODE_ENV
process.env.NODE_ENV = 'development'
const setupDevtoolsMock = setupDevtools as Mock
const appMock = getAppMock()
VueQueryPlugin.install(appMock)
process.env.NODE_ENV = envCopy
expect(setupDevtoolsMock).toHaveBeenCalledTimes(1)
})
})
describe('when app unmounts', () => {
test('should call unmount on each client when onUnmount is missing', () => {
const appMock = getAppMock()
const customClient = {
mount: vi.fn(),
unmount: vi.fn(),
} as unknown as QueryClient
const originalUnmount = appMock.unmount
VueQueryPlugin.install(appMock, {
queryClient: customClient,
})
appMock.unmount()
expect(appMock.unmount).not.toEqual(originalUnmount)
expect(customClient.unmount).toHaveBeenCalledTimes(1)
expect(originalUnmount).toHaveBeenCalledTimes(1)
})
test('should call onUnmount if present', () => {
const appMock = getAppMock(true)
const customClient = {
mount: vi.fn(),
unmount: vi.fn(),
} as unknown as QueryClient
const originalUnmount = appMock.unmount
VueQueryPlugin.install(appMock, { queryClient: customClient })
appMock._unmount()
expect(appMock.unmount).toEqual(originalUnmount)
expect(customClient.unmount).toHaveBeenCalledTimes(1)
})
})
describe('when called without additional options', () => {
testIf(isVue2)('should provide a client with default clientKey', () => {
const appMock = getAppMock()
VueQueryPlugin.install(appMock)
appMock._mixin.beforeCreate?.call(appMock)
expect(appMock._provided).toMatchObject({
VUE_QUERY_CLIENT: expect.any(QueryClient),
})
})
testIf(isVue3)('should provide a client with default clientKey', () => {
const appMock = getAppMock()
VueQueryPlugin.install(appMock)
expect(appMock.provide).toHaveBeenCalledWith(
VUE_QUERY_CLIENT,
expect.any(QueryClient),
)
})
})
describe('when called with custom clientKey', () => {
testIf(isVue2)('should provide a client with customized clientKey', () => {
const appMock = getAppMock()
VueQueryPlugin.install(appMock, { queryClientKey: 'CUSTOM' })
appMock._mixin.beforeCreate?.call(appMock)
expect(appMock._provided).toMatchObject({
[VUE_QUERY_CLIENT + ':CUSTOM']: expect.any(QueryClient),
})
})
testIf(isVue3)('should provide a client with customized clientKey', () => {
const appMock = getAppMock()
VueQueryPlugin.install(appMock, { queryClientKey: 'CUSTOM' })
expect(appMock.provide).toHaveBeenCalledWith(
VUE_QUERY_CLIENT + ':CUSTOM',
expect.any(QueryClient),
)
})
})
describe('when called with custom client', () => {
testIf(isVue2)('should provide that custom client', () => {
const appMock = getAppMock()
const customClient = { mount: vi.fn() } as unknown as QueryClient
VueQueryPlugin.install(appMock, { queryClient: customClient })
appMock._mixin.beforeCreate?.call(appMock)
expect(customClient.mount).toHaveBeenCalled()
expect(appMock._provided).toMatchObject({
VUE_QUERY_CLIENT: customClient,
})
})
testIf(isVue3)('should provide that custom client', () => {
const appMock = getAppMock()
const customClient = { mount: vi.fn() } as unknown as QueryClient
VueQueryPlugin.install(appMock, { queryClient: customClient })
expect(customClient.mount).toHaveBeenCalled()
expect(appMock.provide).toHaveBeenCalledWith(
VUE_QUERY_CLIENT,
customClient,
)
})
})
describe('when called with custom client config', () => {
testIf(isVue2)(
'should instantiate a client with the provided config',
() => {
const appMock = getAppMock()
const config = {
defaultOptions: { queries: { enabled: true } },
}
VueQueryPlugin.install(appMock, {
queryClientConfig: config,
})
appMock._mixin.beforeCreate?.call(appMock)
const client = appMock._provided.VUE_QUERY_CLIENT as QueryClient
const defaultOptions = client.getDefaultOptions()
expect(defaultOptions).toEqual(config.defaultOptions)
},
)
testIf(isVue3)(
'should instantiate a client with the provided config',
() => {
const appMock = getAppMock()
const config = {
defaultOptions: { queries: { enabled: true } },
}
VueQueryPlugin.install(appMock, {
queryClientConfig: config,
})
const client = (appMock.provide as Mock).mock.calls[0][1]
const defaultOptions = client.getDefaultOptions()
expect(defaultOptions).toEqual(config.defaultOptions)
},
)
})
describe('when persister is provided', () => {
test('should properly modify isRestoring flag on queryClient', async () => {
const appMock = getAppMock()
const customClient = {
mount: vi.fn(),
isRestoring: ref(false),
} as unknown as QueryClient
VueQueryPlugin.install(appMock, {
queryClient: customClient,
clientPersister: () => [
vi.fn(),
new Promise((resolve) => {
resolve()
}),
],
})
expect(customClient.isRestoring.value).toBeTruthy()
await flushPromises()
expect(customClient.isRestoring.value).toBeFalsy()
})
test('should delay useQuery subscription and not call fetcher if data is not stale', async () => {
const appMock = getAppMock()
const customClient = new QueryClient({
defaultOptions: {
queries: {
staleTime: 1000 * 60 * 60,
},
},
})
VueQueryPlugin.install(appMock, {
queryClient: customClient,
clientPersister: (client) => [
vi.fn(),
new Promise((resolve) => {
setTimeout(() => {
client.setQueryData(['persist'], () => ({
foo: 'bar',
}))
resolve()
}, 0)
}),
],
})
const fnSpy = vi.fn()
const query = useQuery(
{
queryKey: ['persist'],
queryFn: fnSpy,
},
customClient,
)
expect(customClient.isRestoring.value).toBeTruthy()
expect(query.isFetching.value).toBeFalsy()
expect(query.data.value).toStrictEqual(undefined)
expect(fnSpy).toHaveBeenCalledTimes(0)
await flushPromises()
expect(customClient.isRestoring.value).toBeFalsy()
expect(query.data.value).toStrictEqual({ foo: 'bar' })
expect(fnSpy).toHaveBeenCalledTimes(0)
})
test('should delay useQueries subscription and not call fetcher if data is not stale', async () => {
const appMock = getAppMock()
const customClient = new QueryClient({
defaultOptions: {
queries: {
staleTime: 1000 * 60 * 60,
},
},
})
VueQueryPlugin.install(appMock, {
queryClient: customClient,
clientPersister: (client) => [
vi.fn(),
new Promise((resolve) => {
setTimeout(() => {
client.setQueryData(['persist1'], () => ({
foo1: 'bar1',
}))
client.setQueryData(['persist2'], () => ({
foo2: 'bar2',
}))
resolve()
}, 0)
}),
],
})
const fnSpy = vi.fn()
const query = useQuery(
{
queryKey: ['persist1'],
queryFn: fnSpy,
},
customClient,
)
const queries = useQueries(
{
queries: [
{
queryKey: ['persist2'],
queryFn: fnSpy,
},
],
},
customClient,
)
expect(customClient.isRestoring.value).toBeTruthy()
expect(query.isFetching.value).toBeFalsy()
expect(query.data.value).toStrictEqual(undefined)
expect(queries.value[0].isFetching).toBeFalsy()
expect(queries.value[0].data).toStrictEqual(undefined)
expect(fnSpy).toHaveBeenCalledTimes(0)
await flushPromises()
expect(customClient.isRestoring.value).toBeFalsy()
expect(query.data.value).toStrictEqual({ foo1: 'bar1' })
expect(queries.value[0].data).toStrictEqual({ foo2: 'bar2' })
expect(fnSpy).toHaveBeenCalledTimes(0)
})
})
})
|
4,960 | 0 | petrpan-code/TanStack/table/packages/match-sorter-utils | petrpan-code/TanStack/table/packages/match-sorter-utils/__tests__/match-sorter-utils.test.ts | import { rankings, rankItem } from '../src'
interface Person {
firstName: string
lastName: string
email: string
}
const testPerson: Person = {
firstName: 'John',
lastName: 'Doe',
email: '[email protected]',
}
describe('match-sorter-utils', () => {
describe('rankItem', () => {
describe('with accessorFn', () => {
it('CASE_SENSITIVE_EQUAL', () => {
const ranking = rankItem(testPerson, 'John', {
accessors: [
item => item.firstName,
item => item.lastName,
item => item.email,
],
})
expect(ranking.rank).toBe(rankings.CASE_SENSITIVE_EQUAL)
expect(ranking.passed).toBe(true)
expect(ranking.rankedValue).toBe(testPerson.firstName)
expect(ranking.accessorIndex).toBe(0)
expect(ranking.accessorThreshold).toBe(1)
})
it('NO_MATCH', () => {
const ranking = rankItem(testPerson, 'Tom', {
accessors: [
item => item.firstName,
item => item.lastName,
item => item.email,
],
})
expect(ranking.rank).toBe(rankings.NO_MATCH)
expect(ranking.passed).toBe(false)
expect(ranking.rankedValue).toBe(testPerson)
expect(ranking.accessorIndex).toBe(-1)
expect(ranking.accessorThreshold).toBe(1)
})
})
describe('with accessorOptions and custom Threshold', () => {
it('CASE_SENSITIVE_EQUAL', () => {
const ranking = rankItem(testPerson, 'John', {
accessors: [
{
accessor: item => item.firstName,
threshold: rankings.CONTAINS,
},
{
accessor: item => item.lastName,
threshold: rankings.CONTAINS,
},
{
accessor: item => item.email,
threshold: rankings.MATCHES,
},
],
})
expect(ranking.rank).toBe(rankings.CASE_SENSITIVE_EQUAL)
expect(ranking.passed).toBe(true)
expect(ranking.rankedValue).toBe(testPerson.firstName)
expect(ranking.accessorIndex).toBe(0)
expect(ranking.accessorThreshold).toBe(rankings.CONTAINS)
})
it('ACRONYM but threshold is CONTAINS', () => {
const ranking = rankItem(testPerson, 'jd', {
threshold: rankings.ACRONYM,
accessors: [
{
accessor: item => item.firstName,
threshold: rankings.CONTAINS,
},
{
accessor: item => item.lastName,
threshold: rankings.CONTAINS,
},
{
accessor: item => `${item.firstName} ${item.lastName}`,
threshold: rankings.CONTAINS,
},
{
accessor: item => item.email,
threshold: rankings.CONTAINS,
},
],
})
expect(ranking.rank).toBe(rankings.NO_MATCH)
expect(ranking.passed).toBe(false)
expect(ranking.rankedValue).toBe(testPerson)
expect(ranking.accessorIndex).toBe(-1)
expect(ranking.accessorThreshold).toBe(rankings.ACRONYM)
})
it('NO_MATCH', () => {
const ranking = rankItem(testPerson, 'Tom', {
accessors: [
{
accessor: item => item.firstName,
threshold: rankings.CONTAINS,
},
{
accessor: item => item.lastName,
threshold: rankings.CONTAINS,
},
{
accessor: item => item.email,
threshold: rankings.MATCHES,
},
],
})
expect(ranking.rank).toBe(rankings.NO_MATCH)
expect(ranking.passed).toBe(false)
expect(ranking.rankedValue).toBe(testPerson)
expect(ranking.accessorIndex).toBe(-1)
expect(ranking.accessorThreshold).toBe(1)
})
})
})
})
|
4,976 | 0 | petrpan-code/TanStack/table/packages/react-table/__tests__ | petrpan-code/TanStack/table/packages/react-table/__tests__/core/core.test.tsx | import * as React from 'react'
import { act, renderHook } from '@testing-library/react-hooks'
import * as RTL from '@testing-library/react'
import '@testing-library/jest-dom'
import {
useReactTable,
getCoreRowModel,
ColumnDef,
flexRender,
} from '@tanstack/react-table'
type Person = {
firstName: string
lastName: string
age: number
visits: number
status: string
progress: number
}
const defaultData: Person[] = [
{
firstName: 'tanner',
lastName: 'linsley',
age: 29,
visits: 100,
status: 'In Relationship',
progress: 50,
},
{
firstName: 'derek',
lastName: 'perkins',
age: 40,
visits: 40,
status: 'Single',
progress: 80,
},
{
firstName: 'joe',
lastName: 'bergevin',
age: 45,
visits: 20,
status: 'Complicated',
progress: 10,
},
]
const defaultColumns: ColumnDef<Person>[] = [
{
header: 'Name',
footer: props => props.column.id,
columns: [
{
accessorKey: 'firstName',
cell: info => info.renderValue(),
footer: props => props.column.id,
},
{
accessorFn: row => row.lastName,
id: 'lastName',
cell: info => info.renderValue(),
header: () => <span>Last Name</span>,
footer: props => props.column.id,
},
],
},
{
header: 'Info',
footer: props => props.column.id,
columns: [
{
accessorKey: 'age',
header: () => 'Age',
footer: props => props.column.id,
},
{
header: 'More Info',
columns: [
{
accessorKey: 'visits',
header: () => <span>Visits</span>,
footer: props => props.column.id,
},
{
accessorKey: 'status',
header: 'Status',
footer: props => props.column.id,
},
{
accessorKey: 'progress',
header: 'Profile Progress',
footer: props => props.column.id,
},
],
},
],
},
]
describe('core', () => {
it('renders a table with markup', () => {
const Table = () => {
const [data] = React.useState<Person[]>(() => [...defaultData])
const [columns] = React.useState<typeof defaultColumns>(() => [
...defaultColumns,
])
const [columnVisibility, setColumnVisibility] = React.useState({})
const rerender = React.useReducer(() => ({}), {})[1]
const table = useReactTable({
data,
columns,
onColumnVisibilityChange: setColumnVisibility,
state: {
columnVisibility,
},
getCoreRowModel: getCoreRowModel(),
// debug: true,
})
return (
<div className="p-2">
<table>
<thead>
{table.getHeaderGroups().map(headerGroup => (
<tr key={headerGroup.id}>
{headerGroup.headers.map(header => (
<th key={header.id} colSpan={header.colSpan}>
{header.isPlaceholder
? null
: flexRender(
header.column.columnDef.header,
header.getContext()
)}
</th>
))}
</tr>
))}
</thead>
<tbody>
{table.getRowModel().rows.map(row => (
<tr key={row.id}>
{row.getVisibleCells().map(cell => (
<td key={cell.id}>
{flexRender(
cell.column.columnDef.cell,
cell.getContext()
)}
</td>
))}
</tr>
))}
</tbody>
<tfoot>
{table.getFooterGroups().map(footerGroup => (
<tr key={footerGroup.id}>
{footerGroup.headers.map(header => (
<th key={header.id} colSpan={header.colSpan}>
{header.isPlaceholder
? null
: flexRender(
header.column.columnDef.footer,
header.getContext()
)}
</th>
))}
</tr>
))}
</tfoot>
</table>
<div className="h-4" />
<button onClick={() => rerender()} className="border p-2">
Rerender
</button>
</div>
)
}
// let api: any;
const rendered = RTL.render(<Table />)
// RTL.screen.logTestingPlaygroundURL()
RTL.screen.getByRole('table')
expect(RTL.screen.getAllByRole('rowgroup').length).toEqual(3)
expect(RTL.screen.getAllByRole('row').length).toEqual(9)
expect(RTL.screen.getAllByRole('columnheader').length).toEqual(24)
expect(RTL.screen.getAllByRole('cell').length).toEqual(18)
expect(
Array.from(rendered.container.querySelectorAll('thead > tr')).map(d =>
Array.from(d.querySelectorAll('th')).map(d => [
d.innerHTML,
d.getAttribute('colspan'),
])
)
).toMatchSnapshot()
expect(
Array.from(rendered.container.querySelectorAll('tbody > tr')).map(d =>
Array.from(d.querySelectorAll('td')).map(d => d.innerHTML)
)
).toMatchSnapshot()
expect(
Array.from(rendered.container.querySelectorAll('tfoot > tr')).map(d =>
Array.from(d.querySelectorAll('th')).map(d => [
d.innerHTML,
d.getAttribute('colspan'),
])
)
).toMatchSnapshot()
})
it('has a stable api', () => {
const { result } = renderHook(() => {
const rerender = React.useReducer(() => ({}), {})[1]
const table = useReactTable({
data: defaultData,
columns: defaultColumns,
getCoreRowModel: getCoreRowModel(),
})
return {
table,
rerender,
}
})
const prev = result.current
act(() => {
result.current.rerender()
})
const next = result.current
expect(prev).toStrictEqual(next)
})
it('can return the rowModel', () => {
const { result } = renderHook(() => {
const rerender = React.useReducer(() => ({}), {})[1]
const table = useReactTable({
data: defaultData,
columns: defaultColumns,
getCoreRowModel: getCoreRowModel(),
})
return {
table,
rerender,
}
})
const rowModel = result.current.table.getRowModel()
expect(rowModel.rows.length).toEqual(3)
expect(rowModel.flatRows.length).toEqual(3)
expect(rowModel.rowsById['2']?.original).toEqual(defaultData[2])
})
})
|
4,977 | 0 | petrpan-code/TanStack/table/packages/react-table/__tests__/core | petrpan-code/TanStack/table/packages/react-table/__tests__/core/__snapshots__/core.test.tsx.snap | // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
exports[`core > renders a table with markup 1`] = `
[
[
[
"Name",
"2",
],
[
"Info",
"4",
],
],
[
[
"",
"1",
],
[
"",
"1",
],
[
"",
"1",
],
[
"More Info",
"3",
],
],
[
[
"firstName",
"1",
],
[
"<span>Last Name</span>",
"1",
],
[
"Age",
"1",
],
[
"<span>Visits</span>",
"1",
],
[
"Status",
"1",
],
[
"Profile Progress",
"1",
],
],
]
`;
exports[`core > renders a table with markup 2`] = `
[
[
"tanner",
"linsley",
"29",
"100",
"In Relationship",
"50",
],
[
"derek",
"perkins",
"40",
"40",
"Single",
"80",
],
[
"joe",
"bergevin",
"45",
"20",
"Complicated",
"10",
],
]
`;
exports[`core > renders a table with markup 3`] = `
[
[
[
"firstName",
"1",
],
[
"lastName",
"1",
],
[
"age",
"1",
],
[
"visits",
"1",
],
[
"status",
"1",
],
[
"progress",
"1",
],
],
[
[
"",
"1",
],
[
"",
"1",
],
[
"",
"1",
],
[
"",
"3",
],
],
[
[
"Name",
"2",
],
[
"Info",
"4",
],
],
]
`;
|
4,978 | 0 | petrpan-code/TanStack/table/packages/react-table/__tests__ | petrpan-code/TanStack/table/packages/react-table/__tests__/features/RowSelection.test.tsx | import {
ColumnDef,
flexRender,
getCoreRowModel,
TableOptions,
useReactTable,
} from '@tanstack/react-table'
import { fireEvent, render, screen } from '@testing-library/react'
import React, { FC } from 'react'
type Person = {
firstName: string
lastName: string
age: number
visits: number
status: string
progress: number
}
const defaultData: Person[] = [
{
firstName: 'tanner',
lastName: 'linsley',
age: 29,
visits: 100,
status: 'In Relationship',
progress: 50,
},
{
firstName: 'joe',
lastName: 'bergevin',
age: 45,
visits: 20,
status: 'Complicated',
progress: 10,
},
]
const defaultColumns: ColumnDef<Person>[] = [
{
id: 'select',
header: ({ table }) => {
return (
<input
data-testid="select-all"
aria-checked={table.getIsSomeRowsSelected() ? 'mixed' : undefined}
type="checkbox"
checked={table.getIsAllRowsSelected()}
onChange={table.getToggleAllRowsSelectedHandler()}
/>
)
},
cell: ({ row }) => {
return (
<input
type="checkbox"
disabled={row.getCanSelect()}
checked={row.getIsSelected()}
onChange={row.getToggleSelectedHandler()}
/>
)
},
},
{
header: 'First Name',
accessorKey: 'firstName',
},
]
const defaultPaginatedColumns: ColumnDef<Person>[] = [
{
id: 'select',
header: ({ table }) => {
return (
<input
data-testid="select-all-page"
aria-checked={table.getIsSomePageRowsSelected() ? 'mixed' : undefined}
type="checkbox"
disabled
checked={table.getIsAllPageRowsSelected()}
onChange={table.getToggleAllRowsSelectedHandler()}
/>
)
},
cell: ({ row }) => {
return ( row.getCanSelect() ? (
<input
data-testid="select-single"
type="checkbox"
disabled={row.getCanSelect()}
checked={row.getIsSelected()}
onChange={row.getToggleSelectedHandler()}
/>
):null)
},
},
{
header: 'First Name',
accessorKey: 'firstName',
},
]
const TableComponent: FC<{ options?: Partial<TableOptions<Person>> }> = ({
options = {},
}) => {
const table = useReactTable({
data: defaultData,
columns: defaultColumns,
getCoreRowModel: getCoreRowModel(),
...options,
})
return (
<table>
<thead>
{table.getHeaderGroups().map(headerGroup => (
<tr key={headerGroup.id}>
{headerGroup.headers.map(header => (
<th key={header.id} colSpan={header.colSpan}>
{header.isPlaceholder
? null
: flexRender(
header.column.columnDef.header,
header.getContext()
)}
</th>
))}
</tr>
))}
</thead>
<tbody>
{table.getRowModel().rows.map(row => (
<tr key={row.id}>
{row.getVisibleCells().map(cell => (
<td key={cell.id}>
{flexRender(cell.column.columnDef.cell, cell.getContext())}
</td>
))}
</tr>
))}
</tbody>
</table>
)
}
test(`Select all do not select rows which are not available for selection`, () => {
render(
<TableComponent
options={{ enableRowSelection: row => row.original.age > 40 }}
/>
)
const [title, notSelected, selected] = screen.getAllByRole('checkbox')
// Let's trigger a select all
fireEvent.click(screen.getByTestId('select-all'))
// Assert everything - except the not available - is selected
expect(title).toBePartiallyChecked()
expect(notSelected).not.toBeChecked()
expect(selected).toBeChecked()
// Let's unselect all
fireEvent.click(screen.getByTestId('select-all'))
// Now everything is unchecked again
expect(title).not.toBePartiallyChecked()
expect(notSelected).not.toBeChecked()
expect(selected).not.toBeChecked()
})
// issue #4757
test(`Select all is unchecked for current page if all rows are not available for selection`, () => {
let condition = row => row.original.age > 50;
const {rerender} = render(
<TableComponent
options={{
columns: defaultPaginatedColumns,
data: defaultData,
enableRowSelection: condition
}}
/>
)
expect(screen.queryByTestId('select-single')).not.toBeInTheDocument()
let selectedOnPage = screen.getByTestId('select-all-page')
expect(selectedOnPage).not.toBeChecked()
expect(selectedOnPage).not.toHaveAttribute('aria-checked', 'mixed')
condition = row => row.original.age > 40;
rerender(<TableComponent
options={{
columns: defaultPaginatedColumns,
data: defaultData,
enableRowSelection: condition
}}
/>
)
expect(screen.queryByTestId('select-single')).toBeInTheDocument()
selectedOnPage = screen.getByTestId('select-all-page')
expect(selectedOnPage).not.toBeChecked()
expect(selectedOnPage).not.toHaveAttribute('aria-checked', 'mixed')
fireEvent.click(screen.queryByTestId('select-single'))
expect(selectedOnPage).toBeChecked()
})
test(`Select all when all rows are available for selection`, () => {
render(<TableComponent />)
const [title, rowOne, rowTwo] = screen.getAllByRole('checkbox')
// Let's trigger a select all
fireEvent.click(screen.getByTestId('select-all'))
// Assert all the rows are selected
expect(title).toBeChecked()
expect(rowOne).toBeChecked()
expect(rowTwo).toBeChecked()
// Let's unselect all
fireEvent.click(screen.getByTestId('select-all'))
// Now everything is unchecked again
expect(title).not.toBeChecked()
expect(rowOne).not.toBeChecked()
expect(rowTwo).not.toBeChecked()
})
test(`Select a single row`, () => {
render(<TableComponent />)
const [title, rowOne, rowTwo] = screen.getAllByRole('checkbox')
// Let's trigger a select in row one
fireEvent.click(rowOne)
// Assert only the row we've clicked before is selected
expect(title).toBePartiallyChecked()
expect(rowOne).toBeChecked()
expect(rowTwo).not.toBeChecked()
// Let's unselect the row one
fireEvent.click(rowOne)
// Now everything is unchecked again
expect(title).not.toBeChecked()
expect(rowOne).not.toBeChecked()
expect(rowTwo).not.toBeChecked()
})
|
4,979 | 0 | petrpan-code/TanStack/table/packages/react-table/__tests__ | petrpan-code/TanStack/table/packages/react-table/__tests__/features/Visibility.test.tsx | import * as React from 'react'
// import { renderHook } from '@testing-library/react-hooks'
import * as RTL from '@testing-library/react'
import '@testing-library/jest-dom'
import {
useReactTable,
getCoreRowModel,
ColumnDef,
flexRender,
} from '@tanstack/react-table'
type Person = {
firstName: string
lastName: string
age: number
visits: number
status: string
progress: number
}
const defaultData: Person[] = [
{
firstName: 'tanner',
lastName: 'linsley',
age: 29,
visits: 100,
status: 'In Relationship',
progress: 50,
},
{
firstName: 'derek',
lastName: 'perkins',
age: 40,
visits: 40,
status: 'Single',
progress: 80,
},
{
firstName: 'joe',
lastName: 'bergevin',
age: 45,
visits: 20,
status: 'Complicated',
progress: 10,
},
]
const defaultColumns: ColumnDef<Person>[] = [
{
header: 'Name',
footer: props => props.column.id,
columns: [
{
accessorKey: 'firstName',
cell: props => props.renderValue(),
footer: props => props.column.id,
},
{
accessorFn: row => row.lastName,
id: 'lastName',
cell: props => props.renderValue(),
header: () => <span>Last Name</span>,
footer: props => props.column.id,
},
],
},
{
header: 'Info',
footer: props => props.column.id,
columns: [
{
accessorKey: 'age',
header: () => 'Age',
footer: props => props.column.id,
},
{
header: 'More Info',
columns: [
{
accessorKey: 'visits',
header: () => <span>Visits</span>,
footer: props => props.column.id,
},
{
accessorKey: 'status',
header: 'Status',
footer: props => props.column.id,
},
{
accessorKey: 'progress',
header: 'Profile Progress',
footer: props => props.column.id,
},
],
},
],
},
]
describe('useReactTable', () => {
it('can toggle column visibility', () => {
const Table = () => {
const [data] = React.useState<Person[]>(() => [...defaultData])
const [columns] = React.useState<typeof defaultColumns>(() => [
...defaultColumns,
])
const [columnVisibility, setColumnVisibility] = React.useState({})
const rerender = React.useReducer(() => ({}), {})[1]
const table = useReactTable({
data,
columns,
onColumnVisibilityChange: setColumnVisibility,
state: {
columnVisibility,
},
getCoreRowModel: getCoreRowModel(),
// debug: true,
})
return (
<div className="p-2">
<div className="inline-block border border-black shadow rounded">
<div className="px-1 border-b border-black">
<label>
<input
{...{
type: 'checkbox',
checked: table.getIsAllColumnsVisible(),
onChange: table.getToggleAllColumnsVisibilityHandler(),
}}
/>{' '}
Toggle All
</label>
</div>
{table.getAllLeafColumns().map(column => {
return (
<div key={column.id} className="px-1">
<label>
<input
{...{
type: 'checkbox',
checked: column.getIsVisible(),
onChange: column.getToggleVisibilityHandler(),
}}
/>{' '}
{column.id}
</label>
</div>
)
})}
</div>
<div className="h-4" />
<table>
<thead>
{table.getHeaderGroups().map(headerGroup => (
<tr key={headerGroup.id}>
{headerGroup.headers.map(header => (
<th key={header.id} colSpan={header.colSpan}>
{header.isPlaceholder
? null
: flexRender(
header.column.columnDef.header,
header.getContext()
)}
</th>
))}
</tr>
))}
</thead>
<tbody>
{table.getRowModel().rows.map(row => (
<tr key={row.id}>
{row.getVisibleCells().map(cell => (
<td key={cell.id}>
{flexRender(
cell.column.columnDef.cell,
cell.getContext()
)}
</td>
))}
</tr>
))}
</tbody>
<tfoot>
{table.getFooterGroups().map(footerGroup => (
<tr key={footerGroup.id}>
{footerGroup.headers.map(header => (
<th key={header.id} colSpan={header.colSpan}>
{header.isPlaceholder
? null
: flexRender(
header.column.columnDef.footer,
header.getContext()
)}
</th>
))}
</tr>
))}
</tfoot>
</table>
<div className="h-4" />
<button onClick={() => rerender()} className="border p-2">
Rerender
</button>
</div>
)
}
// let api: any;
const rendered = RTL.render(<Table />)
// RTL.screen.logTestingPlaygroundURL()
let snapIndex = 0
const snap = (name: string) => {
expect({
headers: Array.from(
rendered.container.querySelectorAll('thead > tr')
).map(d =>
Array.from(d.querySelectorAll('th')).map(d => [
d.innerHTML,
d.getAttribute('colspan'),
])
),
rows: Array.from(rendered.container.querySelectorAll('tbody > tr')).map(
d => Array.from(d.querySelectorAll('td')).map(d => d.innerHTML)
),
footers: Array.from(
rendered.container.querySelectorAll('tfoot > tr')
).map(d =>
Array.from(d.querySelectorAll('th')).map(d => [
d.innerHTML,
d.getAttribute('colspan'),
])
),
}).toMatchSnapshot(`${snapIndex++} - ${name}`)
}
RTL.fireEvent.click(rendered.getByLabelText('Toggle All'))
snap('after toggling all off')
RTL.fireEvent.click(rendered.getByLabelText('Toggle All'))
snap('after toggling all on')
RTL.fireEvent.click(rendered.getByLabelText('firstName'))
snap('after toggling firstName off')
RTL.fireEvent.click(rendered.getByLabelText('firstName'))
RTL.fireEvent.click(rendered.getByLabelText('visits'))
RTL.fireEvent.click(rendered.getByLabelText('status'))
RTL.fireEvent.click(rendered.getByLabelText('progress'))
snap('after toggling More Info off')
})
})
|
4,992 | 0 | petrpan-code/TanStack/table/packages/react-table/__tests__ | petrpan-code/TanStack/table/packages/react-table/__tests__/features/withSorting.notest.tsx | import React from 'react'
import { renderHook, act } from '@testing-library/react-hooks'
import { getHeaderIds, getRowValues } from '../../test-utils'
import { useTable } from '../../core/useTable'
import { noop } from '../../utils'
import { withSorting } from '../withSorting'
import type { Column, TableState } from '../../types'
const data = [
{
firstName: 'tanner',
lastName: 'linsley',
age: 29,
visits: 100,
status: 'In Relationship',
progress: 80,
},
{
firstName: 'derek',
lastName: 'perkins',
age: 40,
visits: 40,
status: 'Single',
progress: 80,
},
{
firstName: 'joe',
lastName: 'bergevin',
age: 45,
visits: 20,
status: 'Complicated',
progress: 10,
},
]
const columns: Column[] = [
{
Header: 'Name',
columns: [
{
Header: 'First Name',
accessor: 'firstName',
},
{
Header: 'Last Name',
accessor: 'lastName',
},
],
},
{
Header: 'Info',
columns: [
{
Header: 'Age',
accessor: 'age',
},
{
Header: 'Visits',
accessor: 'visits',
},
{
Header: 'Status',
accessor: 'status',
},
{
Header: 'Profile Progress',
accessor: 'progress',
},
],
},
]
describe('withSorting', () => {
it('renders a sortable table', () => {
const { result } = renderHook(
options => {
const table = useTable(options, [withCore, withSorting])
return table
},
{
initialProps: {
data,
columns,
},
}
)
expect(getHeaderIds(result.current)).toEqual([
['Name', 'Info'],
['firstName', 'lastName', 'age', 'visits', 'status', 'progress'],
])
expect(getRowValues(result.current)).toEqual([
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
['derek', 'perkins', 40, 40, 'Single', 80],
['joe', 'bergevin', 45, 20, 'Complicated', 10],
])
act(() => {
result.current.flatHeaders
.find(d => d.id === 'firstName')
?.getToggleSortingProps?.()
.onClick({
persist: noop,
})
})
expect(getRowValues(result.current)).toEqual([
['derek', 'perkins', 40, 40, 'Single', 80],
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
])
act(() => {
result.current.flatHeaders
.find(d => d.id === 'firstName')
?.getToggleSortingProps?.()
.onClick({
persist: noop,
})
})
expect(getRowValues(result.current)).toEqual([
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['derek', 'perkins', 40, 40, 'Single', 80],
])
act(() => {
result.current.flatHeaders
.find(d => d.id === 'progress')
?.getToggleSortingProps?.()
.onClick({
persist: noop,
})
})
expect(getRowValues(result.current)).toEqual([
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
['derek', 'perkins', 40, 40, 'Single', 80],
])
act(() => {
result.current.flatHeaders
.find(d => d.id === 'firstName')
?.getToggleSortingProps?.()
.onClick({
persist: noop,
shiftKey: true,
})
})
expect(getRowValues(result.current)).toEqual([
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['derek', 'perkins', 40, 40, 'Single', 80],
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
])
})
it('renders a controlled sorted table', () => {
const { result, rerender } = renderHook(
options => {
const table = useTable(options, [withSorting])
return table
},
{
initialProps: {
data,
columns,
state: {},
},
}
)
expect(getHeaderIds(result.current)).toEqual([
['Name', 'Info'],
['firstName', 'lastName', 'age', 'visits', 'status', 'progress'],
])
expect(getRowValues(result.current)).toEqual([
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
['derek', 'perkins', 40, 40, 'Single', 80],
['joe', 'bergevin', 45, 20, 'Complicated', 10],
])
rerender({
data,
columns,
state: { sorting: [{ id: 'firstName', desc: false }] },
})
expect(getRowValues(result.current)).toEqual([
['derek', 'perkins', 40, 40, 'Single', 80],
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
])
rerender({
data,
columns,
state: { sorting: [{ id: 'firstName', desc: true }] },
})
expect(getRowValues(result.current)).toEqual([
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['derek', 'perkins', 40, 40, 'Single', 80],
])
rerender({
data,
columns,
state: { sorting: [{ id: 'progress', desc: false }] },
})
expect(getRowValues(result.current)).toEqual([
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
['derek', 'perkins', 40, 40, 'Single', 80],
])
rerender({
data,
columns,
state: {
sorting: [
{ id: 'progress', desc: false },
{ id: 'firstName', desc: false },
],
},
})
expect(getRowValues(result.current)).toEqual([
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['derek', 'perkins', 40, 40, 'Single', 80],
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
])
})
it('renders a hoisted state sorted table', () => {
const { result } = renderHook(
options => {
const [sorting, setSorting] = React.useState<TableState['sorting']>([])
const table = useTable(
{
...options,
state: {
sorting,
},
onSortingChange: setSorting,
},
[withSorting]
)
return table
},
{
initialProps: {
data,
columns,
},
}
)
expect(getHeaderIds(result.current)).toEqual([
['Name', 'Info'],
['firstName', 'lastName', 'age', 'visits', 'status', 'progress'],
])
expect(getRowValues(result.current)).toEqual([
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
['derek', 'perkins', 40, 40, 'Single', 80],
['joe', 'bergevin', 45, 20, 'Complicated', 10],
])
act(() => {
result.current.flatHeaders
.find(d => d.id === 'firstName')
?.getToggleSortingProps?.()
.onClick({
persist: noop,
})
})
expect(getRowValues(result.current)).toEqual([
['derek', 'perkins', 40, 40, 'Single', 80],
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
])
act(() => {
result.current.flatHeaders
.find(d => d.id === 'firstName')
?.getToggleSortingProps?.()
.onClick({
persist: noop,
})
})
expect(getRowValues(result.current)).toEqual([
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['derek', 'perkins', 40, 40, 'Single', 80],
])
act(() => {
result.current.flatHeaders
.find(d => d.id === 'progress')
?.getToggleSortingProps?.()
.onClick({
persist: noop,
})
})
expect(getRowValues(result.current)).toEqual([
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
['derek', 'perkins', 40, 40, 'Single', 80],
])
act(() => {
result.current.flatHeaders
.find(d => d.id === 'firstName')
?.getToggleSortingProps?.()
.onClick({
persist: noop,
shiftKey: true,
})
})
expect(getRowValues(result.current)).toEqual([
['joe', 'bergevin', 45, 20, 'Complicated', 10],
['derek', 'perkins', 40, 40, 'Single', 80],
['tanner', 'linsley', 29, 100, 'In Relationship', 80],
])
})
})
|
4,993 | 0 | petrpan-code/TanStack/table/packages/react-table/__tests__/features | petrpan-code/TanStack/table/packages/react-table/__tests__/features/__snapshots__/Visibility.test.tsx.snap | // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
exports[`useReactTable > can toggle column visibility > 0 - after toggling all off 1`] = `
{
"footers": [
[],
[],
[],
],
"headers": [
[],
[],
[],
],
"rows": [
[],
[],
[],
],
}
`;
exports[`useReactTable > can toggle column visibility > 1 - after toggling all on 1`] = `
{
"footers": [
[
[
"firstName",
"1",
],
[
"lastName",
"1",
],
[
"age",
"1",
],
[
"visits",
"1",
],
[
"status",
"1",
],
[
"progress",
"1",
],
],
[
[
"",
"1",
],
[
"",
"1",
],
[
"",
"1",
],
[
"",
"3",
],
],
[
[
"Name",
"2",
],
[
"Info",
"4",
],
],
],
"headers": [
[
[
"Name",
"2",
],
[
"Info",
"4",
],
],
[
[
"",
"1",
],
[
"",
"1",
],
[
"",
"1",
],
[
"More Info",
"3",
],
],
[
[
"firstName",
"1",
],
[
"<span>Last Name</span>",
"1",
],
[
"Age",
"1",
],
[
"<span>Visits</span>",
"1",
],
[
"Status",
"1",
],
[
"Profile Progress",
"1",
],
],
],
"rows": [
[
"tanner",
"linsley",
"29",
"100",
"In Relationship",
"50",
],
[
"derek",
"perkins",
"40",
"40",
"Single",
"80",
],
[
"joe",
"bergevin",
"45",
"20",
"Complicated",
"10",
],
],
}
`;
exports[`useReactTable > can toggle column visibility > 2 - after toggling firstName off 1`] = `
{
"footers": [
[
[
"lastName",
"1",
],
[
"age",
"1",
],
[
"visits",
"1",
],
[
"status",
"1",
],
[
"progress",
"1",
],
],
[
[
"",
"1",
],
[
"",
"1",
],
[
"",
"3",
],
],
[
[
"Name",
"1",
],
[
"Info",
"4",
],
],
],
"headers": [
[
[
"Name",
"1",
],
[
"Info",
"4",
],
],
[
[
"",
"1",
],
[
"",
"1",
],
[
"More Info",
"3",
],
],
[
[
"<span>Last Name</span>",
"1",
],
[
"Age",
"1",
],
[
"<span>Visits</span>",
"1",
],
[
"Status",
"1",
],
[
"Profile Progress",
"1",
],
],
],
"rows": [
[
"linsley",
"29",
"100",
"In Relationship",
"50",
],
[
"perkins",
"40",
"40",
"Single",
"80",
],
[
"bergevin",
"45",
"20",
"Complicated",
"10",
],
],
}
`;
exports[`useReactTable > can toggle column visibility > 3 - after toggling More Info off 1`] = `
{
"footers": [
[
[
"firstName",
"1",
],
[
"lastName",
"1",
],
[
"age",
"1",
],
],
[
[
"",
"1",
],
[
"",
"1",
],
[
"",
"1",
],
],
[
[
"Name",
"2",
],
[
"Info",
"1",
],
],
],
"headers": [
[
[
"Name",
"2",
],
[
"Info",
"1",
],
],
[
[
"",
"1",
],
[
"",
"1",
],
[
"",
"1",
],
],
[
[
"firstName",
"1",
],
[
"<span>Last Name</span>",
"1",
],
[
"Age",
"1",
],
],
],
"rows": [
[
"tanner",
"linsley",
"29",
],
[
"derek",
"perkins",
"40",
],
[
"joe",
"bergevin",
"45",
],
],
}
`;
|
5,007 | 0 | petrpan-code/TanStack/table/packages/table-core | petrpan-code/TanStack/table/packages/table-core/__tests__/Pinning.test.ts | import {
ColumnDef,
createColumnHelper,
createTable,
getCoreRowModel,
getPaginationRowModel,
} from '../src'
import * as Pinning from '../src/features/Pinning'
import { makeData, Person } from './makeTestData'
type personKeys = keyof Person
type PersonColumn = ColumnDef<Person, string | number | Person[] | undefined>
function generateColumns(people: Person[]): PersonColumn[] {
const columnHelper = createColumnHelper<Person>()
const person = people[0]
return Object.keys(person).map(key => {
const typedKey = key as personKeys
return columnHelper.accessor(typedKey, { id: typedKey })
})
}
describe('Pinning', () => {
describe('createTable', () => {
describe('_getPinnedRows', () => {
it('should return pinned rows when keepPinnedRows is true rows are visible', () => {
const data = makeData(10)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowPinning: true,
keepPinnedRows: true,
onStateChange() {},
renderFallbackValue: '',
data,
state: {
pagination: {
pageSize: 5,
pageIndex: 0, //pinned rows will be on page 0
},
rowPinning: {
top: ['0', '1'],
},
},
columns,
getPaginationRowModel: getPaginationRowModel(),
getCoreRowModel: getCoreRowModel(),
})
const result = table._getPinnedRows('top')
expect(result.length).toBe(2)
expect(result[0].id).toBe('0')
expect(result[1].id).toBe('1')
})
it('should return pinned rows when keepPinnedRows is true rows are not visible', () => {
const data = makeData(10)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowPinning: true,
keepPinnedRows: true,
onStateChange() {},
renderFallbackValue: '',
data,
state: {
pagination: {
pageSize: 5,
pageIndex: 1, //pinned rows will be on page 0
},
rowPinning: {
top: ['0', '1'],
},
},
columns,
getPaginationRowModel: getPaginationRowModel(),
getCoreRowModel: getCoreRowModel(),
})
const result = table._getPinnedRows('top')
expect(result.length).toBe(2)
expect(result[0].id).toBe('0')
expect(result[1].id).toBe('1')
})
it('should return pinned rows when keepPinnedRows is false rows are visible', () => {
const data = makeData(10)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowPinning: true,
keepPinnedRows: false,
onStateChange() {},
renderFallbackValue: '',
data,
state: {
pagination: {
pageSize: 5,
pageIndex: 0, //pinned rows will be on page 0
},
rowPinning: {
top: ['0', '1'],
},
},
columns,
getPaginationRowModel: getPaginationRowModel(),
getCoreRowModel: getCoreRowModel(),
})
const result = table._getPinnedRows('top')
expect(result.length).toBe(2)
expect(result[0].id).toBe('0')
expect(result[1].id).toBe('1')
})
it('should not return pinned rows when keepPinnedRows is false and rows are not visible', () => {
const data = makeData(10)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowPinning: true,
keepPinnedRows: false,
onStateChange() {},
renderFallbackValue: '',
data,
state: {
pagination: {
pageSize: 5,
pageIndex: 1, //pinned rows will be on page 0, but this is page 1
},
rowPinning: {
top: ['0', '1'],
},
},
columns,
getPaginationRowModel: getPaginationRowModel(),
getCoreRowModel: getCoreRowModel(),
})
const result = table._getPinnedRows('top')
expect(result.length).toBe(0)
})
})
describe('getTopRows', () => {
it('should return correct top rows', () => {
const data = makeData(10)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowPinning: true,
keepPinnedRows: true,
onStateChange() {},
renderFallbackValue: '',
data,
state: {
pagination: {
pageSize: 5,
pageIndex: 0, //pinned rows will be on page 0
},
rowPinning: {
top: ['1', '3'],
},
},
columns,
getPaginationRowModel: getPaginationRowModel(),
getCoreRowModel: getCoreRowModel(),
})
const result = table.getTopRows()
expect(result.length).toBe(2)
expect(result[0].id).toBe('1')
expect(result[1].id).toBe('3')
})
})
describe('getBottomRows', () => {
it('should return correct bottom rows', () => {
const data = makeData(10)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowPinning: true,
keepPinnedRows: true,
onStateChange() {},
renderFallbackValue: '',
data,
state: {
pagination: {
pageSize: 5,
pageIndex: 0, //pinned rows will be on page 0
},
rowPinning: {
bottom: ['1', '3'],
},
},
columns,
getPaginationRowModel: getPaginationRowModel(),
getCoreRowModel: getCoreRowModel(),
})
const result = table.getBottomRows()
expect(result.length).toBe(2)
expect(result[0].id).toBe('1')
expect(result[1].id).toBe('3')
})
})
describe('getCenterRows', () => {
it('should return all rows except any pinned rows', () => {
const data = makeData(6)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowPinning: true,
keepPinnedRows: true,
onStateChange() {},
renderFallbackValue: '',
data,
state: {
pagination: {
pageSize: 10,
pageIndex: 0,
},
rowPinning: {
top: ['1', '3'],
bottom: ['2', '4'],
},
},
columns,
getPaginationRowModel: getPaginationRowModel(),
getCoreRowModel: getCoreRowModel(),
})
const result = table.getCenterRows()
expect(result.length).toBe(2)
expect(result[0].id).toBe('0') // 0 and 5 are the only rows not pinned
expect(result[1].id).toBe('5')
})
})
})
})
|
5,008 | 0 | petrpan-code/TanStack/table/packages/table-core | petrpan-code/TanStack/table/packages/table-core/__tests__/RowSelection.test.ts | import {
ColumnDef,
createColumnHelper,
createTable,
getCoreRowModel,
} from '../src'
import * as RowSelection from '../src/features/RowSelection'
import { makeData, Person } from './makeTestData'
type personKeys = keyof Person
type PersonColumn = ColumnDef<Person, string | number | Person[] | undefined>
function generateColumns(people: Person[]): PersonColumn[] {
const columnHelper = createColumnHelper<Person>()
const person = people[0]
return Object.keys(person).map(key => {
const typedKey = key as personKeys
return columnHelper.accessor(typedKey, { id: typedKey })
})
}
describe('RowSelection', () => {
describe('selectRowsFn', () => {
it('should only return rows that are selected', () => {
const data = makeData(5)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowSelection: true,
onStateChange() {},
renderFallbackValue: '',
data,
getSubRows: row => row.subRows,
state: {
rowSelection: {
'0': true,
'2': true,
},
},
columns,
getCoreRowModel: getCoreRowModel(),
})
const rowModel = table.getCoreRowModel()
const result = RowSelection.selectRowsFn(table, rowModel)
expect(result.rows.length).toBe(2)
expect(result.flatRows.length).toBe(2)
expect(result.rowsById).toHaveProperty('0')
expect(result.rowsById).toHaveProperty('2')
})
it('should recurse into subRows and only return selected subRows', () => {
const data = makeData(3, 2) // assuming 3 parent rows with 2 sub-rows each
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowSelection: true,
onStateChange() {},
renderFallbackValue: '',
data,
getSubRows: row => row.subRows,
state: {
rowSelection: {
'0': true,
'0.0': true,
},
},
columns,
getCoreRowModel: getCoreRowModel(),
})
const rowModel = table.getCoreRowModel()
const result = RowSelection.selectRowsFn(table, rowModel)
expect(result.rows[0].subRows.length).toBe(1)
expect(result.flatRows.length).toBe(2)
expect(result.rowsById).toHaveProperty('0')
expect(result.rowsById).toHaveProperty('0.0')
})
it('should return an empty list if no rows are selected', () => {
const data = makeData(5)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowSelection: true,
onStateChange() {},
renderFallbackValue: '',
data,
getSubRows: row => row.subRows,
state: {
rowSelection: {},
},
columns,
getCoreRowModel: getCoreRowModel(),
})
const rowModel = table.getCoreRowModel()
const result = RowSelection.selectRowsFn(table, rowModel)
expect(result.rows.length).toBe(0)
expect(result.flatRows.length).toBe(0)
expect(result.rowsById).toEqual({})
})
})
describe('isRowSelected', () => {
it('should return true if the row id exists in selection and is set to true', () => {
const row = { id: '123', data: {} } as any
const selection: Record<string, boolean> = {
'123': true,
'456': false,
}
const result = RowSelection.isRowSelected(row, selection)
expect(result).toEqual(true)
})
it('should return false if the row id exists in selection and is set to false', () => {
const row = { id: '456', data: {} } as any
const selection: Record<string, boolean> = {
'123': true,
'456': false,
}
const result = RowSelection.isRowSelected(row, selection)
expect(result).toEqual(false)
})
it('should return false if the row id does not exist in selection', () => {
const row = { id: '789', data: {} } as any
const selection: Record<string, boolean> = {
'123': true,
'456': false,
}
const result = RowSelection.isRowSelected(row, selection)
expect(result).toEqual(false)
})
it('should return false if selection is an empty object', () => {
const row = { id: '789', data: {} } as any
const selection: Record<string, boolean> = {}
const result = RowSelection.isRowSelected(row, selection)
expect(result).toEqual(false)
})
})
describe('isSubRowSelected', () => {
it('should return false if there are no sub-rows', () => {
const data = makeData(3)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowSelection: true,
onStateChange() {},
renderFallbackValue: '',
data,
state: {},
columns,
getCoreRowModel: getCoreRowModel(),
})
const firstRow = table.getCoreRowModel().rows[0]
const result = RowSelection.isSubRowSelected(
firstRow,
table.getState().rowSelection,
table
)
expect(result).toEqual(false)
})
it('should return false if no sub-rows are selected', () => {
const data = makeData(3, 2)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowSelection: true,
onStateChange() {},
renderFallbackValue: '',
data,
getSubRows: row => row.subRows,
state: {
rowSelection: {},
},
columns,
getCoreRowModel: getCoreRowModel(),
})
const firstRow = table.getCoreRowModel().rows[0]
const result = RowSelection.isSubRowSelected(
firstRow,
table.getState().rowSelection,
table
)
expect(result).toEqual(false)
})
it('should return some if some sub-rows are selected', () => {
const data = makeData(3, 2)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowSelection: true,
onStateChange() {},
renderFallbackValue: '',
data,
getSubRows: row => row.subRows,
state: {
rowSelection: {
'0.0': true,
},
},
columns,
getCoreRowModel: getCoreRowModel(),
})
const firstRow = table.getCoreRowModel().rows[0]
const result = RowSelection.isSubRowSelected(
firstRow,
table.getState().rowSelection,
table
)
expect(result).toEqual('some')
})
it('should return all if all sub-rows are selected', () => {
const data = makeData(3, 2)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowSelection: true,
onStateChange() {},
renderFallbackValue: '',
data,
getSubRows: row => row.subRows,
state: {
rowSelection: {
'0.0': true,
'0.1': true,
},
},
columns,
getCoreRowModel: getCoreRowModel(),
})
const firstRow = table.getCoreRowModel().rows[0]
const result = RowSelection.isSubRowSelected(
firstRow,
table.getState().rowSelection,
table
)
expect(result).toEqual('all')
})
it('should return all if all selectable sub-rows are selected', () => {
const data = makeData(3, 2)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowSelection: row => row.index === 0, // only first row is selectable (of 2 sub-rows)
onStateChange() {},
renderFallbackValue: '',
data,
getSubRows: row => row.subRows,
state: {
rowSelection: {
'0.0': true, // first sub-row
},
},
columns,
getCoreRowModel: getCoreRowModel(),
})
const firstRow = table.getCoreRowModel().rows[0]
const result = RowSelection.isSubRowSelected(
firstRow,
table.getState().rowSelection,
table
)
expect(result).toEqual('all')
})
it('should return some when some nested sub-rows are selected', () => {
const data = makeData(3, 2, 2)
const columns = generateColumns(data)
const table = createTable<Person>({
enableRowSelection: true,
onStateChange() {},
renderFallbackValue: '',
data,
getSubRows: row => row.subRows,
state: {
rowSelection: {
'0.0.0': true, // first nested sub-row
},
},
columns,
getCoreRowModel: getCoreRowModel(),
})
const firstRow = table.getCoreRowModel().rows[0]
const result = RowSelection.isSubRowSelected(
firstRow,
table.getState().rowSelection,
table
)
expect(result).toEqual('some')
})
})
})
|
5,009 | 0 | petrpan-code/TanStack/table/packages/table-core | petrpan-code/TanStack/table/packages/table-core/__tests__/getGroupedRowModel.test.ts | import { ColumnDef, getCoreRowModel } from '../src'
import { createColumnHelper } from '../src/columnHelper'
import { createTable } from '../src/core/table'
import { getGroupedRowModel } from '../src/utils/getGroupedRowModel'
import { makeData, Person } from './makeTestData'
type personKeys = keyof Person
type PersonColumn = ColumnDef<Person, string | number | Person[] | undefined>
function generateColumns(people: Person[]): PersonColumn[] {
const columnHelper = createColumnHelper<Person>()
const person = people[0]
return Object.keys(person).map(key => {
const typedKey = key as personKeys
return columnHelper.accessor(typedKey, { id: typedKey })
})
}
describe('#getGroupedRowModel', () => {
it('groups 50k rows and 3 grouped columns with clustered data in less than 3 seconds', () => {
const data = makeData(50000)
const columns = generateColumns(data)
const grouping = ['firstName', 'lastName', 'age']
const start = new Date()
data.forEach(p => (p.firstName = 'Fixed'))
data.forEach(p => (p.lastName = 'Name'))
data.forEach(p => (p.age = 123))
const table = createTable<Person>({
onStateChange() {},
renderFallbackValue: '',
data,
state: { grouping },
columns,
getCoreRowModel: getCoreRowModel(),
getGroupedRowModel: getGroupedRowModel(),
})
const groupedById = table.getGroupedRowModel().rowsById
const end = new Date()
expect(groupedById['firstName:Fixed'].leafRows.length).toEqual(50000)
expect(
groupedById['firstName:Fixed>lastName:Name'].leafRows.length
).toEqual(50000)
expect(
groupedById['firstName:Fixed>lastName:Name>age:123'].leafRows.length
).toEqual(50000)
expect(end.valueOf() - start.valueOf()).toBeLessThan(3000)
})
})
|
5,378 | 0 | petrpan-code/TanStack/router/packages/react-router | petrpan-code/TanStack/router/packages/react-router/tests/createRoute.test.ts | import { describe, it } from 'vitest'
import { z } from 'zod'
import { createMemoryHistory, RootRoute, Route, Router } from '../src'
const lazyTest = (comp: any, key: any) => {
comp.preload = () => {}
return comp
}
// Write a test
describe('everything', () => {
it('should work', () => {
// // Build our routes. We could do this in our component, too.
// const rootRoute = new RootRoute()
// const indexRoute = new Route({
// getParentRoute: () => rootRoute,
// path: '/',
// validateSearch: (search) =>
// z
// .object({
// version: z.number(),
// })
// .parse(search),
// })
// const testRoute = new Route({
// getParentRoute: () => rootRoute,
// component: lazyTest(() => import('./TestComponent'), 'NamedComponent'),
// path: 'test',
// validateSearch: (search) =>
// z
// .object({
// version: z.number(),
// isGood: z.boolean(),
// })
// .parse(search),
// })
// const dashboardRoute = new Route({
// getParentRoute: () => rootRoute,
// path: 'dashboard',
// load: async () => {
// console.log('Fetching all invoices...')
// return {
// invoices: 'await fetchInvoices()',
// }
// },
// })
// const dashboardIndexRoute = new Route({
// getParentRoute: () => dashboardRoute,
// path: '/',
// })
// const invoicesRoute = new Route({
// getParentRoute: () => dashboardRoute,
// path: 'invoices',
// })
// const invoicesIndexRoute = new Route({
// getParentRoute: () => invoicesRoute,
// path: '/',
// })
// const invoiceRoute = new Route({
// getParentRoute: () => invoicesRoute,
// path: '$invoiceId',
// parseParams: ({ invoiceId }) => ({ invoiceId: Number(invoiceId) }),
// stringifyParams: ({ invoiceId }) => ({
// invoiceId: String(invoiceId),
// }),
// load: async ({ params: { invoiceId } }) => {
// console.log('Fetching invoice...')
// return {
// invoice: 'await fetchInvoiceById(invoiceId!)',
// }
// },
// })
// const usersRoute = new Route({
// getParentRoute: () => dashboardRoute,
// path: 'users',
// load: async () => {
// return {
// users: 'await fetchUsers()',
// }
// },
// validateSearch: (search) =>
// z
// .object({
// usersView: z
// .object({
// sortBy: z.enum(['name', 'id', 'email']).optional(),
// filterBy: z.string().optional(),
// })
// .optional(),
// })
// .parse(search),
// preSearchFilters: [
// // Keep the usersView search param around
// // while in this route (or it's children!)
// (search) => ({
// ...search,
// usersView: {
// ...search.usersView,
// },
// }),
// ],
// })
// const userRoute = new Route({
// getParentRoute: () => usersRoute,
// path: '$userId',
// load: async ({ params: { userId }, search }) => {
// return {
// user: 'await fetchUserById(userId!)',
// }
// },
// })
// const authenticatedRoute = new Route({
// getParentRoute: () => rootRoute,
// path: 'authenticated/', // Trailing slash doesn't mean anything
// })
// const authenticatedIndexRoute = new Route({
// getParentRoute: () => authenticatedRoute,
// path: '/',
// })
// const layoutRoute = new Route({
// getParentRoute: () => rootRoute,
// id: 'layout',
// component: () => 'layout-wrapper',
// validateSearch: (search) =>
// z
// .object({
// isLayout: z.boolean(),
// })
// .parse(search),
// })
// const layoutARoute = new Route({
// getParentRoute: () => layoutRoute,
// path: 'layout-a',
// component: () => 'layout-a',
// })
// const layoutBRoute = new Route({
// getParentRoute: () => layoutRoute,
// path: 'layout-b',
// component: () => 'layout-b',
// })
// const routeTree = rootRoute.addChildren([
// indexRoute,
// testRoute,
// dashboardRoute.addChildren([
// dashboardIndexRoute,
// invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
// usersRoute.addChildren([userRoute]),
// ]),
// authenticatedRoute.addChildren([authenticatedIndexRoute]),
// layoutRoute.addChildren([layoutARoute, layoutBRoute]),
// ])
// const router = new Router({
// routeTree,
// history: createMemoryHistory({
// initialEntries: ['/?version=1'],
// }),
// })
// const route = router.getRoute('/dashboard/users/$userId')
// router.buildLink({
// to: '/dashboard/users/$userId',
// params: {
// userId: '2',
// },
// search: (prev) => ({
// usersView: {
// sortBy: 'email',
// },
// }),
// })
// // @ts-expect-error
// router.buildLink({
// from: '/',
// to: '/test',
// })
// router.buildLink({
// from: '/',
// to: '/test',
// search: () => {
// return {
// version: 2,
// isGood: true,
// }
// },
// })
// router.buildLink({
// from: '/test',
// to: '/',
// })
// router.buildLink({
// from: route.id,
// to: '',
// })
// router.buildLink({
// from: '/dashboard',
// to: '/dashboard/invoices',
// params: {
// invoiceId: 2,
// },
// })
// router.buildLink({
// from: '/dashboard',
// to: '/dashboard/invoices/$invoiceId',
// params: {
// // @ts-expect-error
// invoiceId: '2',
// },
// })
// router.buildLink({
// to: '/dashboard/invoices/$invoiceId',
// params: {
// invoiceId: 2,
// },
// })
// router.buildLink({
// to: '/',
// search: {
// version: 2,
// },
// })
// router.buildLink({
// to: '/dashboard/users/$userId',
// // @ts-expect-error
// params: (current) => ({
// userId: current?.invoiceId,
// }),
// search: (old) => ({
// usersView: {
// sortBy: 'email' as const,
// filterBy: String(old.version),
// },
// }),
// })
// router.buildLink({
// from: '/dashboard/invoices/$invoiceId',
// to: '/dashboard/users/$userId',
// params: (current) => ({
// userId: `${current?.invoiceId}`,
// }),
// search: (prev) => {
// return {
// usersView: {
// sortBy: 'name' as const,
// filterBy: 'tanner',
// },
// }
// },
// })
// router.buildLink({
// from: '/dashboard/users/$userId',
// to: '/',
// search: (prev) => {
// return {
// version: 2,
// }
// },
// })
// router.buildLink({
// from: '/',
// to: '/dashboard/users/$userId',
// params: {
// userId: '2',
// },
// search: (prev) => ({
// usersView: {
// sortBy: 'id',
// filterBy: `${prev.version}`,
// },
// }),
// })
// router.navigate({
// search: (prev: any) => ({
// version: prev.version,
// }),
// })
// router.buildLink({
// from: '/dashboard/invoices',
// to: '/dashboard',
// })
// router.buildLink({
// from: '/',
// // @ts-expect-error
// to: '/does-not-exist',
// })
// router.buildLink({
// to: '/dashboard/invoices/$invoiceId',
// params: {
// invoiceId: 2,
// },
// })
// router.buildLink({
// from: '/dashboard/invoices/$invoiceId',
// to: '.',
// params: (d) => ({
// invoiceId: d.invoiceId,
// }),
// })
// router.buildLink({
// from: '/dashboard/invoices/$invoiceId',
// to: testRoute.fullPath,
// search: {
// version: 2,
// isGood: true,
// },
// })
// router.buildLink({
// to: '/layout-a',
// search: (current) => ({
// isLayout: !!current.version,
// }),
// })
// router.buildLink({
// to: '/',
// state: true,
// })
// router.buildLink({
// to: '/',
// state: {},
// })
// router.buildLink({
// to: '/',
// state: (prev) => prev,
// })
// router.buildLink({
// to: '/',
// state: (prev) => ({
// test: true,
// }),
// })
})
})
|
5,379 | 0 | petrpan-code/TanStack/router/packages/react-router | petrpan-code/TanStack/router/packages/react-router/tests/index.test.ts | import { describe, test, expect } from 'vitest'
// import {
// cleanPath,
// // Location,
// matchPathname,
// ParsedLocation,
// parsePathname,
// // Route,
// // createMemoryHistory,
// resolvePath,
// Segment,
// trimPath,
// trimPathLeft,
// } from '../src'
// import { createTimer, sleep } from './utils'
// function RouterInstance(opts?: { initialEntries?: string[] }) {
// return new RouterInstance({
// routes: [],
// history: createMemoryHistory({
// initialEntries: opts?.initialEntries ?? ['/'],
// }),
// })
// }
// function createLocation(location: Partial<Location>): ParsedLocation {
// return {
// pathname: '',
// href: '',
// search: {},
// searchStr: '',
// state: {},
// hash: '',
// ...location,
// }
// }
test('it works', () => {})
// describe('Router', () => {
// test('mounts to /', async () => {
// const router = RouterInstance()
// const routes = [
// {
// path: '/',
// },
// ]
// router.update({
// routes,
// })
// const promise = router.mount()
// expect(router.store.pendingMatches[0].id).toBe('/')
// await promise
// expect(router.state.matches[0].id).toBe('/')
// })
// test('mounts to /a', async () => {
// const router = RouterInstance({ initialEntries: ['/a'] })
// const routes: Route[] = [
// {
// path: '/',
// },
// {
// path: '/a',
// },
// ]
// router.update({
// routes,
// })
// let promise = router.mount()
// expect(router.store.pendingMatches[0].id).toBe('/a')
// await promise
// expect(router.state.matches[0].id).toBe('/a')
// })
// test('mounts to /a/b', async () => {
// const router = RouterInstance({
// initialEntries: ['/a/b'],
// })
// const routes: Route[] = [
// {
// path: '/',
// },
// {
// path: '/a',
// children: [
// {
// path: '/b',
// },
// ],
// },
// ]
// router.update({
// routes,
// })
// let promise = router.mount()
// expect(router.store.pendingMatches[1].id).toBe('/a/b')
// await promise
// expect(router.state.matches[1].id).toBe('/a/b')
// })
// test('navigates to /a', async () => {
// const router = RouterInstance()
// const routes: Route[] = [
// {
// path: '/',
// },
// {
// path: 'a',
// },
// ]
// router.update({
// routes,
// })
// let promise = router.mount()
// expect(router.store.pendingMatches[0].id).toBe('/')
// await promise
// expect(router.state.matches[0].id).toBe('/')
// promise = router.navigate({ to: 'a' })
// expect(router.state.matches[0].id).toBe('/')
// expect(router.store.pendingMatches[0].id).toBe('a')
// await promise
// expect(router.state.matches[0].id).toBe('a')
// expect(router.store.pending).toBe(undefined)
// })
// test('navigates to /a to /a/b', async () => {
// const router = RouterInstance()
// const routes: Route[] = [
// {
// path: '/',
// },
// {
// path: 'a',
// children: [
// {
// path: 'b',
// },
// ],
// },
// ]
// router.update({
// routes,
// })
// await router.mount()
// expect(router.state.location.href).toBe('/')
// let promise = router.navigate({ to: 'a' })
// expect(router.store.pendingLocation.href).toBe('/a')
// await promise
// expect(router.state.location.href).toBe('/a')
// promise = router.navigate({ to: './b' })
// expect(router.store.pendingLocation.href).toBe('/a/b')
// await promise
// expect(router.state.location.href).toBe('/a/b')
// expect(router.store.pending).toBe(undefined)
// })
// test('async navigates to /a/b', async () => {
// const router = RouterInstance()
// const routes: Route[] = [
// {
// path: '/',
// },
// {
// path: 'a',
// load: () => sleep(10).then((d) => ({ a: true })),
// children: [
// {
// path: 'b',
// load: () => sleep(10).then((d) => ({ b: true })),
// },
// ],
// },
// ]
// const timer = createTimer()
// router.update({
// routes,
// })
// router.mount()
// timer.start()
// await router.navigate({ to: 'a/b' })
// expect(router.store.loaderData).toEqual({
// a: true,
// b: true,
// })
// expect(timer.getTime()).toBeLessThan(30)
// })
// test('async navigates with import + loader', async () => {
// const router = RouterInstance()
// const routes: Route[] = [
// {
// path: '/',
// },
// {
// path: 'a',
// import: async () => {
// await sleep(10)
// return {
// load: () => sleep(10).then((d) => ({ a: true })),
// }
// },
// children: [
// {
// path: 'b',
// import: async () => {
// await sleep(10)
// return {
// load: () =>
// sleep(10).then((d) => ({
// b: true,
// })),
// }
// },
// },
// ],
// },
// ]
// const timer = createTimer()
// router.update({
// routes,
// })
// router.mount()
// timer.start()
// await router.navigate({ to: 'a/b' })
// expect(router.store.loaderData).toEqual({
// a: true,
// b: true,
// })
// expect(timer.getTime()).toBeLessThan(28)
// })
// test('async navigates with import + elements + loader', async () => {
// const router = RouterInstance()
// const routes: Route[] = [
// {
// path: '/',
// },
// {
// path: 'a',
// import: async () => {
// await sleep(10)
// return {
// element: async () => {
// await sleep(20)
// return 'element'
// },
// load: () => sleep(30).then((d) => ({ a: true })),
// }
// },
// children: [
// {
// path: 'b',
// import: async () => {
// await sleep(10)
// return {
// element: async () => {
// await sleep(20)
// return 'element'
// },
// load: () =>
// sleep(30).then((d) => ({
// b: true,
// })),
// }
// },
// },
// ],
// },
// ]
// const timer = createTimer()
// router.update({
// routes,
// })
// router.mount()
// await router.navigate({ to: 'a/b' })
// expect(router.store.loaderData).toEqual({
// a: true,
// b: true,
// })
// expect(timer.getTime()).toBeLessThan(55)
// })
// test('async navigates with pending state', async () => {
// const router = RouterInstance()
// const routes: Route[] = [
// {
// path: '/',
// },
// {
// path: 'a',
// pendingMs: 10,
// load: () => sleep(20),
// children: [
// {
// path: 'b',
// pendingMs: 30,
// load: () => sleep(40),
// },
// ],
// },
// ]
// router.update({
// routes,
// })
// await router.mount()
// const timer = createTimer()
// await router.navigate({ to: 'a/b' })
// expect(timer.getTime()).toBeLessThan(46)
// })
// })
// describe('matchRoute', () => {
// describe('fuzzy', () => {
// ;(
// [
// [
// '/',
// {
// to: '/',
// fuzzy: true,
// },
// {},
// ],
// [
// '/a',
// {
// to: '/',
// fuzzy: true,
// },
// {},
// ],
// [
// '/a',
// {
// to: '/$',
// fuzzy: true,
// },
// { '*': 'a' },
// ],
// [
// '/a/b',
// {
// to: '/$',
// fuzzy: true,
// },
// { '*': 'a/b' },
// ],
// [
// '/a/b/c',
// {
// to: '/$',
// fuzzy: true,
// },
// { '*': 'a/b/c' },
// ],
// [
// '/a/b/c',
// {
// to: '/',
// fuzzy: true,
// },
// {},
// ],
// [
// '/a/b',
// {
// to: '/a/b/',
// fuzzy: true,
// },
// {},
// ],
// ] as const
// ).forEach(([a, b, eq]) => {
// test(`${a} == ${b.to}`, () => {
// expect(matchPathname('', a, b)).toEqual(eq)
// })
// })
// })
// describe('exact', () => {
// ;(
// [
// [
// '/a/b/c',
// {
// to: '/',
// },
// undefined,
// ],
// [
// '/a/b/c',
// {
// to: '/a/b',
// },
// undefined,
// ],
// [
// '/a/b/c',
// {
// to: '/a/b/c',
// },
// {},
// ],
// ] as const
// ).forEach(([a, b, eq]) => {
// test(`${a} == ${b.to}`, () => {
// expect(matchPathname('', a, b)).toEqual(eq)
// })
// })
// })
// describe('basepath', () => {
// ;(
// [
// [
// '/base',
// '/base',
// {
// to: '/',
// },
// {},
// ],
// [
// '/base',
// '/base/a',
// {
// to: '/a',
// },
// {},
// ],
// [
// '/base',
// '/base/a/b/c',
// {
// to: '/a/b/c',
// },
// {},
// ],
// [
// '/base',
// '/base/posts',
// {
// fuzzy: true,
// to: '/',
// },
// {},
// ],
// [
// '/base',
// '/base/a',
// {
// to: '/b',
// },
// undefined,
// ],
// ] as const
// ).forEach(([a, b, c, eq]) => {
// test(`${b} == ${a} + ${c.to}`, () => {
// expect(matchPathname(a, b, c)).toEqual(eq)
// })
// })
// })
// describe('params', () => {
// ;(
// [
// [
// '/a/b',
// {
// to: '/a/$b',
// },
// { b: 'b' },
// ],
// [
// '/a/b/c',
// {
// to: '/a/$b/$c',
// },
// { b: 'b', c: 'c' },
// ],
// [
// '/a/b/c',
// {
// to: '/$a/$b/$c',
// },
// { a: 'a', b: 'b', c: 'c' },
// ],
// [
// '/a/b/c',
// {
// to: '/$a/$',
// },
// { a: 'a', '*': 'b/c' },
// ],
// [
// '/a/b/c',
// {
// to: '/a/$b/c',
// },
// { b: 'b' },
// ],
// ] as const
// ).forEach(([a, b, eq]) => {
// test(`${a} == ${b.to}`, () => {
// expect(matchPathname('', a, b)).toEqual(eq)
// })
// })
// })
// })
// describe('resolvePath', () => {
// describe('basic resolution', () => {
// ;[
// ['/', '/', '/', '/'],
// ['/', '/', '/a', '/a'],
// ['/', '/', 'a/', '/a/'],
// ['/', '/', '/a/b', '/a/b'],
// ['/', 'a', 'b', '/a/b'],
// ['/a/b', 'c', '/a/b/c', '/a/b/c'],
// ].forEach(([base, a, b, eq]) => {
// test(`${a} to ${b} === ${eq}`, () => {
// expect(resolvePath(base, a, b)).toEqual(eq)
// })
// })
// })
// describe('relative', () => {
// ;[
// ['/a/b', '/', './c', '/a/b/c'],
// ['/', '/', './a/b', '/a/b'],
// ['/', '/a/b/c', './d', '/a/b/c/d'],
// ['/', '/a/b/c', '../d', '/a/b/d'],
// ['/', '/a/b/c', '../../d', '/a/d'],
// ['/', '/a/b/c', '../..', '/a'],
// ['/', '/a/b/c/', '../..', '/a'],
// ['/', '/a/b/c', '../../..', '/'],
// ['/', '/a/b/c/', '../../..', '/'],
// ].forEach(([base, a, b, eq]) => {
// test(`${a} to ${b} === ${eq}`, () => {
// expect(resolvePath(base, a, b)).toEqual(eq)
// })
// })
// })
// describe('trailing slash', () => {
// ;[
// ['/', '/a', './b/', '/a/b/'],
// ['/', '/', 'a/b/c/', '/a/b/c/'],
// ].forEach(([base, a, b, eq]) => {
// test(`${a} to ${b} === ${eq}`, () => {
// expect(resolvePath(base, a, b)).toEqual(eq)
// })
// })
// })
// })
|
5,704 | 0 | petrpan-code/TanStack/virtual/packages/react-virtual | petrpan-code/TanStack/virtual/packages/react-virtual/__tests__/index.test.tsx | import * as React from 'react'
import { render, screen, fireEvent } from '@testing-library/react'
import { useVirtualizer, Range } from '../src/index'
beforeEach(() => {
Object.defineProperties(HTMLElement.prototype, {
scrollHeight: {
configurable: true,
get: () => Number.MAX_SAFE_INTEGER,
},
scrollWidth: {
configurable: true,
get: () => Number.MAX_SAFE_INTEGER,
},
})
})
let renderer: jest.Mock<undefined, []>
interface ListProps {
count?: number
overscan?: number
height?: number
width?: number
itemSize?: number
rangeExtractor?: (range: Range) => number[]
dynamic?: boolean
}
function List({
count = 200,
overscan,
height = 200,
width = 200,
itemSize,
rangeExtractor,
dynamic,
}: ListProps) {
renderer()
const parentRef = React.useRef<HTMLDivElement>(null)
const elementRectCallbackRef = React.useRef<
((rect: { height: number; width: number }) => void) | null
>(null)
const rowVirtualizer = useVirtualizer({
count,
getScrollElement: () => parentRef.current,
estimateSize: () => 50,
overscan,
observeElementRect: (_, cb) => {
cb({ height, width })
elementRectCallbackRef.current = cb
},
measureElement: () => itemSize ?? 0,
rangeExtractor,
})
React.useEffect(() => {
elementRectCallbackRef.current?.({ height, width })
}, [height, width])
const measureElement = dynamic ? rowVirtualizer.measureElement : undefined
const items = rowVirtualizer.getVirtualItems()
return (
<div
ref={parentRef}
style={{ height, width, overflow: 'auto' }}
data-testid="scroller"
>
<div
style={{
height: rowVirtualizer.getTotalSize(),
width: '100%',
position: 'relative',
}}
>
{items.map((virtualRow) => (
<div
data-testid={`item-${virtualRow.key}`}
key={virtualRow.key}
data-index={virtualRow.index}
ref={measureElement}
style={{
position: 'absolute',
top: 0,
left: 0,
width: '100%',
transform: `translateY(${virtualRow.start}px)`,
height: itemSize,
}}
>
Row {virtualRow.index}
</div>
))}
</div>
</div>
)
}
beforeEach(() => {
renderer = jest.fn(() => undefined)
})
test('should render', () => {
render(<List />)
expect(screen.queryByText('Row 0')).toBeInTheDocument()
expect(screen.queryByText('Row 4')).toBeInTheDocument()
expect(screen.queryByText('Row 5')).not.toBeInTheDocument()
expect(renderer).toHaveBeenCalledTimes(2)
})
test('should render with overscan', () => {
render(<List overscan={0} />)
expect(screen.queryByText('Row 0')).toBeInTheDocument()
expect(screen.queryByText('Row 3')).toBeInTheDocument()
expect(screen.queryByText('Row 4')).not.toBeInTheDocument()
expect(renderer).toHaveBeenCalledTimes(2)
})
test('should render given dynamic size', async () => {
render(<List itemSize={100} dynamic />)
expect(screen.queryByText('Row 0')).toBeInTheDocument()
expect(screen.queryByText('Row 1')).toBeInTheDocument()
expect(screen.queryByText('Row 2')).toBeInTheDocument()
expect(screen.queryByText('Row 3')).not.toBeInTheDocument()
expect(renderer).toHaveBeenCalledTimes(3)
})
test('should render given dynamic size after scroll', () => {
render(<List itemSize={100} dynamic />)
expect(screen.queryByText('Row 0')).toBeInTheDocument()
expect(screen.queryByText('Row 1')).toBeInTheDocument()
expect(screen.queryByText('Row 2')).toBeInTheDocument()
expect(screen.queryByText('Row 3')).not.toBeInTheDocument()
expect(renderer).toHaveBeenCalledTimes(3)
renderer.mockReset()
fireEvent.scroll(screen.getByTestId('scroller'), {
target: { scrollTop: 400 },
})
expect(screen.queryByText('Row 2')).not.toBeInTheDocument()
expect(screen.queryByText('Row 3')).toBeInTheDocument()
expect(screen.queryByText('Row 6')).toBeInTheDocument()
expect(screen.queryByText('Row 7')).not.toBeInTheDocument()
expect(renderer).toHaveBeenCalledTimes(2)
})
test('should use rangeExtractor', () => {
render(<List rangeExtractor={() => [0, 1]} />)
expect(screen.queryByText('Row 0')).toBeInTheDocument()
expect(screen.queryByText('Row 1')).toBeInTheDocument()
expect(screen.queryByText('Row 2')).not.toBeInTheDocument()
})
test('should handle count change', () => {
const { rerender } = render(<List count={2} />)
expect(screen.queryByText('Row 0')).toBeInTheDocument()
expect(screen.queryByText('Row 1')).toBeInTheDocument()
expect(screen.queryByText('Row 2')).not.toBeInTheDocument()
rerender(<List count={10} />)
expect(screen.queryByText('Row 2')).toBeInTheDocument()
expect(screen.queryByText('Row 4')).toBeInTheDocument()
expect(screen.queryByText('Row 5')).not.toBeInTheDocument()
})
test('should handle handle height change', () => {
const { rerender } = render(<List count={0} height={0} />)
expect(screen.queryByText('Row 0')).not.toBeInTheDocument()
rerender(<List count={1} height={200} />)
expect(screen.queryByText('Row 0')).toBeInTheDocument()
})
|
5,715 | 0 | petrpan-code/TanStack/virtual/packages/virtual-core | petrpan-code/TanStack/virtual/packages/virtual-core/__tests__/index.test.ts | import { Virtualizer } from '../src/index'
test('should export the Virtualizer class', () => {
expect(Virtualizer).toBeDefined()
})
test('should return empty items for empty scroll element', () => {
const virtualizer = new Virtualizer({
count: 100,
getScrollElement: () => null,
estimateSize: () => 50,
scrollToFn: jest.fn(),
observeElementRect: jest.fn(),
observeElementOffset: jest.fn(),
})
expect(virtualizer.getVirtualItems()).toEqual([])
})
|
5,798 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/basic.test.tsx | import {
Component as ClassComponent,
ReactNode,
StrictMode,
useEffect,
useLayoutEffect,
useState,
} from 'react'
import { act, fireEvent, render } from '@testing-library/react'
import ReactDOM from 'react-dom'
import { afterEach, expect, it, vi } from 'vitest'
import { create } from 'zustand'
import type { StoreApi } from 'zustand'
import { createWithEqualityFn } from 'zustand/traditional'
const consoleError = console.error
afterEach(() => {
console.error = consoleError
})
it('creates a store hook and api object', () => {
let params
const result = create((...args) => {
params = args
return { value: null }
})
expect({ params, result }).toMatchInlineSnapshot(`
{
"params": [
[Function],
[Function],
{
"destroy": [Function],
"getState": [Function],
"setState": [Function],
"subscribe": [Function],
},
],
"result": [Function],
}
`)
})
type CounterState = {
count: number
inc: () => void
}
it('uses the store with no args', async () => {
const useBoundStore = create<CounterState>((set) => ({
count: 0,
inc: () => set((state) => ({ count: state.count + 1 })),
}))
function Counter() {
const { count, inc } = useBoundStore()
useEffect(inc, [inc])
return <div>count: {count}</div>
}
const { findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 1')
})
it('uses the store with selectors', async () => {
const useBoundStore = create<CounterState>((set) => ({
count: 0,
inc: () => set((state) => ({ count: state.count + 1 })),
}))
function Counter() {
const count = useBoundStore((s) => s.count)
const inc = useBoundStore((s) => s.inc)
useEffect(inc, [inc])
return <div>count: {count}</div>
}
const { findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 1')
})
it('uses the store with a selector and equality checker', async () => {
const useBoundStore = createWithEqualityFn(
() => ({ item: { value: 0 } }),
Object.is,
)
const { setState } = useBoundStore
let renderCount = 0
function Component() {
// Prevent re-render if new value === 1.
const item = useBoundStore(
(s) => s.item,
(_, newItem) => newItem.value === 1,
)
return (
<div>
renderCount: {++renderCount}, value: {item.value}
</div>
)
}
const { findByText } = render(
<>
<Component />
</>,
)
await findByText('renderCount: 1, value: 0')
// This will not cause a re-render.
act(() => setState({ item: { value: 1 } }))
await findByText('renderCount: 1, value: 0')
// This will cause a re-render.
act(() => setState({ item: { value: 2 } }))
await findByText('renderCount: 2, value: 2')
})
it('only re-renders if selected state has changed', async () => {
const useBoundStore = create<CounterState>((set) => ({
count: 0,
inc: () => set((state) => ({ count: state.count + 1 })),
}))
let counterRenderCount = 0
let controlRenderCount = 0
function Counter() {
const count = useBoundStore((state) => state.count)
counterRenderCount++
return <div>count: {count}</div>
}
function Control() {
const inc = useBoundStore((state) => state.inc)
controlRenderCount++
return <button onClick={inc}>button</button>
}
const { getByText, findByText } = render(
<>
<Counter />
<Control />
</>,
)
fireEvent.click(getByText('button'))
await findByText('count: 1')
expect(counterRenderCount).toBe(2)
expect(controlRenderCount).toBe(1)
})
it('can batch updates', async () => {
const useBoundStore = create<CounterState>((set) => ({
count: 0,
inc: () => set((state) => ({ count: state.count + 1 })),
}))
function Counter() {
const { count, inc } = useBoundStore()
useEffect(() => {
ReactDOM.unstable_batchedUpdates(() => {
inc()
inc()
})
}, [inc])
return <div>count: {count}</div>
}
const { findByText } = render(
<>
<Counter />
</>,
)
await findByText('count: 2')
})
it('can update the selector', async () => {
type State = { one: string; two: string }
type Props = { selector: (state: State) => string }
const useBoundStore = create<State>(() => ({
one: 'one',
two: 'two',
}))
function Component({ selector }: Props) {
return <div>{useBoundStore(selector)}</div>
}
const { findByText, rerender } = render(
<StrictMode>
<Component selector={(s) => s.one} />
</StrictMode>,
)
await findByText('one')
rerender(
<StrictMode>
<Component selector={(s) => s.two} />
</StrictMode>,
)
await findByText('two')
})
it('can update the equality checker', async () => {
type State = { value: number }
type Props = { equalityFn: (a: State, b: State) => boolean }
const useBoundStore = createWithEqualityFn<State>(
() => ({ value: 0 }),
Object.is,
)
const { setState } = useBoundStore
const selector = (s: State) => s
let renderCount = 0
function Component({ equalityFn }: Props) {
const { value } = useBoundStore(selector, equalityFn)
return (
<div>
renderCount: {++renderCount}, value: {value}
</div>
)
}
// Set an equality checker that always returns false to always re-render.
const { findByText, rerender } = render(
<>
<Component equalityFn={() => false} />
</>,
)
// This will cause a re-render due to the equality checker.
act(() => setState({ value: 0 }))
await findByText('renderCount: 2, value: 0')
// Set an equality checker that always returns true to never re-render.
rerender(
<>
<Component equalityFn={() => true} />
</>,
)
// This will NOT cause a re-render due to the equality checker.
act(() => setState({ value: 1 }))
await findByText('renderCount: 3, value: 0')
})
it('can call useBoundStore with progressively more arguments', async () => {
type State = { value: number }
type Props = {
selector?: (state: State) => number
equalityFn?: (a: number, b: number) => boolean
}
const useBoundStore = createWithEqualityFn<State>(
() => ({ value: 0 }),
Object.is,
)
const { setState } = useBoundStore
let renderCount = 0
function Component({ selector, equalityFn }: Props) {
const value = useBoundStore(selector as any, equalityFn)
return (
<div>
renderCount: {++renderCount}, value: {JSON.stringify(value)}
</div>
)
}
// Render with no args.
const { findByText, rerender } = render(
<>
<Component />
</>,
)
await findByText('renderCount: 1, value: {"value":0}')
// Render with selector.
rerender(
<>
<Component selector={(s) => s.value} />
</>,
)
await findByText('renderCount: 2, value: 0')
// Render with selector and equality checker.
rerender(
<>
<Component
selector={(s) => s.value}
equalityFn={(oldV, newV) => oldV > newV}
/>
</>,
)
// Should not cause a re-render because new value is less than previous.
act(() => setState({ value: -1 }))
await findByText('renderCount: 3, value: 0')
act(() => setState({ value: 1 }))
await findByText('renderCount: 4, value: 1')
})
it('can throw an error in selector', async () => {
console.error = vi.fn()
type State = { value: string | number }
const initialState: State = { value: 'foo' }
const useBoundStore = create<State>(() => initialState)
const { setState } = useBoundStore
const selector = (s: State) =>
// @ts-expect-error This function is supposed to throw an error
s.value.toUpperCase()
class ErrorBoundary extends ClassComponent<
{ children?: ReactNode | undefined },
{ hasError: boolean }
> {
constructor(props: { children?: ReactNode | undefined }) {
super(props)
this.state = { hasError: false }
}
static getDerivedStateFromError() {
return { hasError: true }
}
render() {
return this.state.hasError ? <div>errored</div> : this.props.children
}
}
function Component() {
useBoundStore(selector)
return <div>no error</div>
}
const { findByText } = render(
<StrictMode>
<ErrorBoundary>
<Component />
</ErrorBoundary>
</StrictMode>,
)
await findByText('no error')
act(() => {
setState({ value: 123 })
})
await findByText('errored')
})
it('can throw an error in equality checker', async () => {
console.error = vi.fn()
type State = { value: string | number }
const initialState: State = { value: 'foo' }
const useBoundStore = createWithEqualityFn(() => initialState, Object.is)
const { setState } = useBoundStore
const selector = (s: State) => s
const equalityFn = (a: State, b: State) =>
// @ts-expect-error This function is supposed to throw an error
a.value.trim() === b.value.trim()
class ErrorBoundary extends ClassComponent<
{ children?: ReactNode | undefined },
{ hasError: boolean }
> {
constructor(props: { children?: ReactNode | undefined }) {
super(props)
this.state = { hasError: false }
}
static getDerivedStateFromError() {
return { hasError: true }
}
render() {
return this.state.hasError ? <div>errored</div> : this.props.children
}
}
function Component() {
useBoundStore(selector, equalityFn)
return <div>no error</div>
}
const { findByText } = render(
<StrictMode>
<ErrorBoundary>
<Component />
</ErrorBoundary>
</StrictMode>,
)
await findByText('no error')
act(() => {
setState({ value: 123 })
})
await findByText('errored')
})
it('can get the store', () => {
type State = {
value: number
getState1: () => State
getState2: () => State
}
const { getState } = create<State>((_, get) => ({
value: 1,
getState1: () => get(),
getState2: (): State => getState(),
}))
expect(getState().getState1().value).toBe(1)
expect(getState().getState2().value).toBe(1)
})
it('can set the store', () => {
type State = {
value: number
setState1: StoreApi<State>['setState']
setState2: StoreApi<State>['setState']
}
const { setState, getState } = create<State>((set) => ({
value: 1,
setState1: (v) => set(v),
setState2: (v) => setState(v),
}))
getState().setState1({ value: 2 })
expect(getState().value).toBe(2)
getState().setState2({ value: 3 })
expect(getState().value).toBe(3)
getState().setState1((s) => ({ value: ++s.value }))
expect(getState().value).toBe(4)
getState().setState2((s) => ({ value: ++s.value }))
expect(getState().value).toBe(5)
})
it('both NaN should not update', () => {
const { setState, subscribe } = create<number>(() => NaN)
const fn = vi.fn()
subscribe(fn)
setState(NaN)
expect(fn).not.toBeCalled()
})
it('can set the store without merging', () => {
const { setState, getState } = create<{ a: number } | { b: number }>(
(_set) => ({
a: 1,
}),
)
// Should override the state instead of merging.
setState({ b: 2 }, true)
expect(getState()).toEqual({ b: 2 })
})
it('can destroy the store', () => {
const { destroy, getState, setState, subscribe } = create(() => ({
value: 1,
}))
subscribe(() => {
throw new Error('did not clear listener on destroy')
})
destroy()
setState({ value: 2 })
expect(getState().value).toEqual(2)
})
it('only calls selectors when necessary', async () => {
type State = { a: number; b: number }
const useBoundStore = create<State>(() => ({ a: 0, b: 0 }))
const { setState } = useBoundStore
let inlineSelectorCallCount = 0
let staticSelectorCallCount = 0
function staticSelector(s: State) {
staticSelectorCallCount++
return s.a
}
function Component() {
useBoundStore((s) => (inlineSelectorCallCount++, s.b))
useBoundStore(staticSelector)
return (
<>
<div>inline: {inlineSelectorCallCount}</div>
<div>static: {staticSelectorCallCount}</div>
</>
)
}
const { rerender, findByText } = render(
<>
<Component />
</>,
)
await findByText('inline: 1')
await findByText('static: 1')
rerender(
<>
<Component />
</>,
)
await findByText('inline: 2')
await findByText('static: 1')
act(() => setState({ a: 1, b: 1 }))
await findByText('inline: 4')
await findByText('static: 2')
})
it('ensures parent components subscribe before children', async () => {
type State = {
children: { [key: string]: { text: string } }
}
type Props = { id: string }
const useBoundStore = create<State>(() => ({
children: {
'1': { text: 'child 1' },
'2': { text: 'child 2' },
},
}))
const api = useBoundStore
function changeState() {
api.setState({
children: {
'3': { text: 'child 3' },
},
})
}
function Child({ id }: Props) {
const text = useBoundStore((s) => s.children[id]?.text)
return <div>{text}</div>
}
function Parent() {
const childStates = useBoundStore((s) => s.children)
return (
<>
<button onClick={changeState}>change state</button>
{Object.keys(childStates).map((id) => (
<Child id={id} key={id} />
))}
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Parent />
</StrictMode>,
)
fireEvent.click(getByText('change state'))
await findByText('child 3')
})
// https://github.com/pmndrs/zustand/issues/84
it('ensures the correct subscriber is removed on unmount', async () => {
const useBoundStore = create(() => ({ count: 0 }))
const api = useBoundStore
function increment() {
api.setState(({ count }) => ({ count: count + 1 }))
}
function Count() {
const c = useBoundStore((s) => s.count)
return <div>count: {c}</div>
}
function CountWithInitialIncrement() {
useLayoutEffect(increment, [])
return <Count />
}
function Component() {
const [Counter, setCounter] = useState(() => CountWithInitialIncrement)
useLayoutEffect(() => {
setCounter(() => Count)
}, [])
return (
<>
<Counter />
<Count />
</>
)
}
const { findAllByText } = render(
<>
<Component />
</>,
)
expect((await findAllByText('count: 1')).length).toBe(2)
act(increment)
expect((await findAllByText('count: 2')).length).toBe(2)
})
// https://github.com/pmndrs/zustand/issues/86
it('ensures a subscriber is not mistakenly overwritten', async () => {
const useBoundStore = create(() => ({ count: 0 }))
const { setState } = useBoundStore
function Count1() {
const c = useBoundStore((s) => s.count)
return <div>count1: {c}</div>
}
function Count2() {
const c = useBoundStore((s) => s.count)
return <div>count2: {c}</div>
}
// Add 1st subscriber.
const { findAllByText, rerender } = render(
<StrictMode>
<Count1 />
</StrictMode>,
)
// Replace 1st subscriber with another.
rerender(
<StrictMode>
<Count2 />
</StrictMode>,
)
// Add 2 additional subscribers.
rerender(
<StrictMode>
<Count2 />
<Count1 />
<Count1 />
</StrictMode>,
)
// Call all subscribers
act(() => setState({ count: 1 }))
expect((await findAllByText('count1: 1')).length).toBe(2)
expect((await findAllByText('count2: 1')).length).toBe(1)
})
it('works with non-object state', async () => {
const useCount = create(() => 1)
const inc = () => useCount.setState((c) => c + 1)
const Counter = () => {
const count = useCount()
return (
<>
<div>count: {count}</div>
<button onClick={inc}>button</button>
</>
)
}
const { getByText, findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
fireEvent.click(getByText('button'))
await findByText('count: 2')
})
|
5,799 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/context.test.tsx | import {
Component as ClassComponent,
ReactNode,
StrictMode,
useCallback,
useEffect,
useState,
} from 'react'
import { render } from '@testing-library/react'
import { afterEach, it, vi } from 'vitest'
import { create } from 'zustand'
import type { StoreApi } from 'zustand'
import createContext from 'zustand/context'
import { subscribeWithSelector } from 'zustand/middleware'
const consoleError = console.error
afterEach(() => {
console.error = consoleError
})
type CounterState = {
count: number
inc: () => void
}
it('creates and uses context store', async () => {
const { Provider, useStore } = createContext<StoreApi<CounterState>>()
const createStore = () =>
create<CounterState>((set) => ({
count: 0,
inc: () => set((state) => ({ count: state.count + 1 })),
}))
function Counter() {
const { count, inc } = useStore()
useEffect(inc, [inc])
return <div>count: {count * 1}</div>
}
const { findByText } = render(
<>
<Provider createStore={createStore}>
<Counter />
</Provider>
</>,
)
await findByText('count: 1')
})
it('uses context store with selectors', async () => {
const { Provider, useStore } = createContext<StoreApi<CounterState>>()
const createStore = () =>
create<CounterState>((set) => ({
count: 0,
inc: () => set((state) => ({ count: state.count + 1 })),
}))
function Counter() {
const count = useStore((state) => state.count)
const inc = useStore((state) => state.inc)
useEffect(inc, [inc])
return <div>count: {count * 1}</div>
}
const { findByText } = render(
<>
<Provider createStore={createStore}>
<Counter />
</Provider>
</>,
)
await findByText('count: 1')
})
it('uses context store api', async () => {
const createStore = () =>
create<CounterState>()(
subscribeWithSelector((set) => ({
count: 0,
inc: () => set((state) => ({ count: state.count + 1 })),
})),
)
type CustomStore = ReturnType<typeof createStore>
const { Provider, useStoreApi } = createContext<CustomStore>()
function Counter() {
const storeApi = useStoreApi()
const [count, setCount] = useState(0)
useEffect(
() =>
storeApi.subscribe(
(state) => state.count,
() => setCount(storeApi.getState().count),
),
[storeApi],
)
useEffect(() => {
storeApi.setState({ count: storeApi.getState().count + 1 })
}, [storeApi])
useEffect(() => {
if (count === 1) {
storeApi.destroy()
storeApi.setState({ count: storeApi.getState().count + 1 })
}
}, [storeApi, count])
return <div>count: {count * 1}</div>
}
const { findByText } = render(
<>
<Provider createStore={createStore}>
<Counter />
</Provider>
</>,
)
await findByText('count: 1')
})
it('throws error when not using provider', async () => {
console.error = vi.fn()
class ErrorBoundary extends ClassComponent<
{ children?: ReactNode | undefined },
{ hasError: boolean }
> {
constructor(props: { children?: ReactNode | undefined }) {
super(props)
this.state = { hasError: false }
}
static getDerivedStateFromError() {
return { hasError: true }
}
render() {
return this.state.hasError ? <div>errored</div> : this.props.children
}
}
const { useStore } = createContext<StoreApi<CounterState>>()
function Component() {
useStore()
return <div>no error</div>
}
const { findByText } = render(
<StrictMode>
<ErrorBoundary>
<Component />
</ErrorBoundary>
</StrictMode>,
)
await findByText('errored')
})
it('useCallback with useStore infers types correctly', async () => {
const { useStore } = createContext<StoreApi<CounterState>>()
function _Counter() {
const _x = useStore(useCallback((state) => state.count, []))
expectAreTypesEqual<typeof _x, number>().toBe(true)
}
})
const expectAreTypesEqual = <A, B>() => ({
toBe: (
_: (<T>() => T extends B ? 1 : 0) extends <T>() => T extends A ? 1 : 0
? true
: false,
) => {},
})
|
5,800 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/devtools.test.tsx | import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { devtools, redux } from 'zustand/middleware'
import { StoreApi, createStore } from 'zustand/vanilla'
type TupleOfEqualLengthH<
Arr extends unknown[],
T,
Acc extends T[],
> = Arr extends [unknown, ...infer Rest]
? TupleOfEqualLengthH<Rest, T, [T, ...Acc]>
: Acc
type TupleOfEqualLength<Arr extends unknown[], T> = number extends Arr['length']
? T[]
: TupleOfEqualLengthH<Arr, T, []>
type Connection = {
subscribers: ((message: unknown) => void)[]
api: {
subscribe: Mock<[f: (m: unknown) => void], () => void>
unsubscribe: Mock<any>
send: Mock<any>
init: Mock<any>
error: Mock<any>
dispatch?: Mock<any>
}
}
const namedConnections = new Map<string | undefined, Connection>()
const unnamedConnections = new Map<string, Connection>()
function assertAllAreDefined<T>(arr: (T | undefined)[]): asserts arr is T[] {
if (arr.some((e) => e === undefined)) {
throw new Error()
}
}
function getNamedConnectionApis<Keys extends (string | undefined)[]>(
...keys: Keys
) {
const apis = keys.map((k) => namedConnections.get(k)?.api)
assertAllAreDefined(apis)
return apis as TupleOfEqualLength<Keys, Connection['api']>
}
function getNamedConnectionSubscribers<Keys extends (string | undefined)[]>(
...keys: Keys
) {
const subscribers = keys.map((k) => {
const subs = namedConnections.get(k)?.subscribers
if (subs?.length !== 1) throw new Error()
return subs[0]
})
assertAllAreDefined(subscribers)
return subscribers as TupleOfEqualLength<
Keys,
Connection['subscribers'][number]
>
}
function getUnnamedConnectionApis<Keys extends string[]>(...keys: Keys) {
const apis = keys.map((k) => unnamedConnections.get(k)?.api)
assertAllAreDefined(apis)
return apis as TupleOfEqualLength<Keys, Connection['api']>
}
function getUnnamedConnectionSubscribers<Keys extends string[]>(...keys: Keys) {
const subscribers = keys.map((k) => {
const subs = unnamedConnections.get(k)?.subscribers
if (!subs) {
throw new Error()
}
return subs[0]
})
assertAllAreDefined(subscribers)
return subscribers as TupleOfEqualLength<
Keys,
Connection['subscribers'][number]
>
}
function getKeyFromOptions(options: any): string | undefined {
let key: string | undefined = options?.name
if (options?.testStore) {
key = `${options?.name}|${options?.testStore}`
}
return key
}
const extensionConnector = {
connect: vi.fn((options: any) => {
const key = getKeyFromOptions(options)
//console.log('options', options)
const areNameUndefinedMapsNeeded =
options.testConnectionId !== undefined && options?.name === undefined
const connectionMap = areNameUndefinedMapsNeeded
? unnamedConnections
: namedConnections
const subscribers: Connection['subscribers'] = []
const api = {
subscribe: vi.fn((f: (m: unknown) => void) => {
subscribers.push(f)
return () => {}
}),
unsubscribe: vi.fn(),
send: vi.fn(),
init: vi.fn(),
error: vi.fn(),
}
connectionMap.set(
areNameUndefinedMapsNeeded ? options.testConnectionId : key,
{
subscribers,
api,
},
)
return api
}),
}
;(window as any).__REDUX_DEVTOOLS_EXTENSION__ = extensionConnector
beforeEach(() => {
vi.resetModules()
extensionConnector.connect.mockClear()
namedConnections.clear()
unnamedConnections.clear()
})
it('connects to the extension by passing the options and initializes', async () => {
const options = { name: 'test', foo: 'bar' }
const initialState = { count: 0 }
createStore(devtools(() => initialState, { enabled: true, ...options }))
expect(extensionConnector.connect).toHaveBeenLastCalledWith(options)
const [conn] = getNamedConnectionApis(options.name)
expect(conn.init).toHaveBeenLastCalledWith(initialState)
})
describe('If there is no extension installed...', () => {
let savedConsoleWarn: any
beforeEach(() => {
savedConsoleWarn = console.warn
console.warn = vi.fn()
;(window as any).__REDUX_DEVTOOLS_EXTENSION__ = undefined
})
afterEach(() => {
console.warn = savedConsoleWarn
;(window as any).__REDUX_DEVTOOLS_EXTENSION__ = extensionConnector
})
it('does not throw', async () => {
expect(() => {
createStore(devtools(() => ({ count: 0 })))
}).not.toThrow()
})
it('does not warn if not enabled', async () => {
createStore(devtools(() => ({ count: 0 })))
expect(console.warn).not.toBeCalled()
})
it('[DEV-ONLY] warns if enabled in dev mode', async () => {
createStore(devtools(() => ({ count: 0 }), { enabled: true }))
expect(console.warn).toBeCalled()
})
it.skip('[PRD-ONLY] does not warn if not in dev env', async () => {
createStore(devtools(() => ({ count: 0 })))
expect(console.warn).not.toBeCalled()
})
it.skip('[PRD-ONLY] does not warn if not in dev env even if enabled', async () => {
createStore(devtools(() => ({ count: 0 }), { enabled: true }))
expect(console.warn).not.toBeCalled()
})
})
describe('When state changes...', () => {
it("sends { type: setStateName || 'anonymous`, ...rest } as the action with current state", async () => {
const options = {
name: 'testOptionsName',
enabled: true,
}
const api = createStore(devtools(() => ({ count: 0, foo: 'bar' }), options))
api.setState({ count: 10 }, false, 'testSetStateName')
const [connection] = getNamedConnectionApis(options.name)
expect(connection.send).toHaveBeenLastCalledWith(
{ type: 'testSetStateName' },
{ count: 10, foo: 'bar' },
)
api.setState({ count: 15 }, false, {
type: 'testSetStateName',
payload: 15,
})
expect(connection.send).toHaveBeenLastCalledWith(
{ type: 'testSetStateName', payload: 15 },
{ count: 15, foo: 'bar' },
)
api.setState({ count: 5, foo: 'baz' }, true)
expect(connection.send).toHaveBeenLastCalledWith(
{ type: 'anonymous' },
{ count: 5, foo: 'baz' },
)
})
})
describe('when it receives a message of type...', () => {
describe('ACTION...', () => {
it('does nothing', async () => {
const initialState = { count: 0 }
const api = createStore(devtools(() => initialState, { enabled: true }))
const setState = vi.spyOn(api, 'setState')
const [subscriber] = getNamedConnectionSubscribers(undefined)
subscriber({
type: 'ACTION',
payload: '{ "type": "INCREMENT" }',
})
expect(api.getState()).toBe(initialState)
expect(setState).not.toBeCalled()
})
it('unless action type is __setState', async () => {
const initialState = { count: 0 }
const api = createStore(devtools(() => initialState, { enabled: true }))
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'ACTION',
payload: '{ "type": "__setState", "state": { "foo": "bar" } }',
})
expect(api.getState()).toStrictEqual({ ...initialState, foo: 'bar' })
})
it('does nothing even if there is `api.dispatch`', async () => {
const initialState = { count: 0 }
const api = createStore(devtools(() => initialState, { enabled: true }))
;(api as any).dispatch = vi.fn()
const setState = vi.spyOn(api, 'setState')
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'ACTION',
payload: '{ "type": "INCREMENT" }',
})
expect(api.getState()).toBe(initialState)
expect(setState).not.toBeCalled()
expect((api as any).dispatch).not.toBeCalled()
})
it('dispatches with `api.dispatch` when `api.dispatchFromDevtools` is set to true', async () => {
const initialState = { count: 0 }
const api = createStore(devtools(() => initialState, { enabled: true }))
;(api as any).dispatch = vi.fn()
;(api as any).dispatchFromDevtools = true
const setState = vi.spyOn(api, 'setState')
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'ACTION',
payload: '{ "type": "INCREMENT" }',
})
expect(api.getState()).toBe(initialState)
expect(setState).not.toBeCalled()
expect((api as any).dispatch).toHaveBeenLastCalledWith({
type: 'INCREMENT',
})
})
it('does not throw for unsupported payload', async () => {
const initialState = { count: 0 }
const api = createStore(devtools(() => initialState, { enabled: true }))
;(api as any).dispatch = vi.fn()
;(api as any).dispatchFromDevtools = true
const setState = vi.spyOn(api, 'setState')
const originalConsoleError = console.error
console.error = vi.fn()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
expect(() => {
connectionSubscriber({
type: 'ACTION',
payload: 'this.increment()',
})
}).not.toThrow()
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('this.increment()')
} catch (e) {
return e
}
})(),
)
expect(() => {
connectionSubscriber({
type: 'ACTION',
payload: { name: 'increment', args: [] },
})
}).not.toThrow()
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Unsupported action format',
)
expect(api.getState()).toBe(initialState)
expect(setState).not.toBeCalled()
expect((api as any).dispatch).not.toBeCalled()
console.error = originalConsoleError
})
})
describe('DISPATCH and payload of type...', () => {
it('RESET, it inits with initial state', async () => {
const initialState = { count: 0 }
const api = createStore(devtools(() => initialState, { enabled: true }))
api.setState({ count: 1 })
const [connection] = getNamedConnectionApis(undefined)
connection.send.mockClear()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'RESET' },
})
expect(api.getState()).toStrictEqual(initialState)
expect(connection.init).toHaveBeenLastCalledWith(initialState)
expect(connection.send).not.toBeCalled()
})
it('COMMIT, it inits with current state', async () => {
const initialState = { count: 0 }
const api = createStore(devtools(() => initialState, { enabled: true }))
api.setState({ count: 2 })
const currentState = api.getState()
const [connection] = getNamedConnectionApis(undefined)
connection.send.mockClear()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'COMMIT' },
})
expect(connection.init).toHaveBeenLastCalledWith(currentState)
expect(connection.send).not.toBeCalled()
})
describe('ROLLBACK...', () => {
it('it updates state without recording and inits with `message.state`', async () => {
const initialState = { count: 0, increment: () => {} }
const api = createStore(devtools(() => initialState, { enabled: true }))
const newState = { foo: 'bar' }
const [connection] = getNamedConnectionApis(undefined)
connection.send.mockClear()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'ROLLBACK' },
state: JSON.stringify(newState),
})
expect(api.getState()).toStrictEqual({ ...initialState, ...newState })
expect(connection.init).toHaveBeenLastCalledWith({
...initialState,
...newState,
})
expect(connection.send).not.toBeCalled()
})
it('does not throw for unparsable `message.state`', async () => {
const increment = () => {}
const initialState = { count: 0, increment }
const api = createStore(devtools(() => initialState, { enabled: true }))
const originalConsoleError = console.error
console.error = vi.fn()
const [connection] = getNamedConnectionApis(undefined)
connection.init.mockClear()
connection.send.mockClear()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'ROLLBACK' },
state: 'foobar',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar')
} catch (e) {
return e
}
})(),
)
expect(api.getState()).toBe(initialState)
expect(connection.init).not.toBeCalled()
expect(connection.send).not.toBeCalled()
console.error = originalConsoleError
})
})
describe('JUMP_TO_STATE...', () => {
const increment = () => {}
it('it updates state without recording with `message.state`', async () => {
const initialState = { count: 0, increment }
const api = createStore(devtools(() => initialState, { enabled: true }))
const newState = { foo: 'bar' }
const [connection] = getNamedConnectionApis(undefined)
connection.send.mockClear()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_STATE' },
state: JSON.stringify(newState),
})
expect(api.getState()).toStrictEqual({ ...initialState, ...newState })
expect(connection.send).not.toBeCalled()
})
it('does not throw for unparsable `message.state`', async () => {
const initialState = { count: 0, increment: () => {} }
const api = createStore(devtools(() => initialState, { enabled: true }))
const originalConsoleError = console.error
console.error = vi.fn()
const [connection] = getNamedConnectionApis(undefined)
connection.send.mockClear()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_STATE' },
state: 'foobar',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar')
} catch (e) {
return e
}
})(),
)
expect(api.getState()).toBe(initialState)
expect(connection.send).not.toBeCalled()
console.error = originalConsoleError
})
})
describe('JUMP_TO_ACTION...', () => {
it('it updates state without recording with `message.state`', async () => {
const initialState = { count: 0, increment: () => {} }
const api = createStore(devtools(() => initialState, { enabled: true }))
const newState = { foo: 'bar' }
const [connection] = getNamedConnectionApis(undefined)
connection.send.mockClear()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_ACTION' },
state: JSON.stringify(newState),
})
expect(api.getState()).toStrictEqual({ ...initialState, ...newState })
expect(connection.send).not.toBeCalled()
})
it('does not throw for unparsable `message.state`', async () => {
const increment = () => {}
const initialState = { count: 0, increment }
const api = createStore(devtools(() => initialState, { enabled: true }))
const originalConsoleError = console.error
console.error = vi.fn()
const [connection] = getNamedConnectionApis(undefined)
connection.send.mockClear()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_ACTION' },
state: 'foobar',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar')
} catch (e) {
return e
}
})(),
)
expect(api.getState()).toBe(initialState)
expect(connection.send).not.toBeCalled()
console.error = originalConsoleError
})
})
it('IMPORT_STATE, it updates state without recording and inits the last computedState', async () => {
const initialState = { count: 0, increment: () => {} }
const api = createStore(devtools(() => initialState, { enabled: true }))
const nextLiftedState = {
computedStates: [{ state: { count: 4 } }, { state: { count: 5 } }],
}
const [connection] = getNamedConnectionApis(undefined)
connection.send.mockClear()
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: {
type: 'IMPORT_STATE',
nextLiftedState,
},
})
expect(api.getState()).toStrictEqual({
...initialState,
...nextLiftedState.computedStates.slice(-1)[0]?.state,
})
expect(connection.send).toHaveBeenLastCalledWith(null, nextLiftedState)
})
it('PAUSE_RECORDING, it toggles the sending of actions', async () => {
const api = createStore(devtools(() => ({ count: 0 }), { enabled: true }))
api.setState({ count: 1 }, false, 'increment')
const [connection] = getNamedConnectionApis(undefined)
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
expect(connection.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
{ count: 1 },
)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
api.setState({ count: 2 }, false, 'increment')
expect(connection.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
{ count: 1 },
)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
api.setState({ count: 3 }, false, 'increment')
expect(connection.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
{ count: 3 },
)
})
})
})
describe('with redux middleware', () => {
let api: StoreApi<{
count: number
dispatch: (
action: { type: 'INCREMENT' } | { type: 'DECREMENT' },
) => { type: 'INCREMENT' } | { type: 'DECREMENT' }
}>
it('works as expected', async () => {
api = createStore(
devtools(
redux(
(
{ count },
{ type }: { type: 'INCREMENT' } | { type: 'DECREMENT' },
) => ({
count: count + (type === 'INCREMENT' ? 1 : -1),
}),
{ count: 0 },
),
{ enabled: true },
),
)
;(api as any).dispatch({ type: 'INCREMENT' })
;(api as any).dispatch({ type: 'INCREMENT' })
const [connection] = getNamedConnectionApis(undefined)
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'ACTION',
payload: JSON.stringify({ type: 'DECREMENT' }),
})
expect(connection.init.mock.calls).toMatchObject([
[{ count: 0 }] as unknown as Record<string, unknown>,
])
expect(connection.send.mock.calls).toMatchObject([
[{ type: 'INCREMENT' }, { count: 1 }] as unknown as Record<
string,
unknown
>,
[{ type: 'INCREMENT' }, { count: 2 }] as unknown as Record<
string,
unknown
>,
[{ type: 'DECREMENT' }, { count: 1 }] as unknown as Record<
string,
unknown
>,
])
expect(api.getState()).toMatchObject({ count: 1 })
})
it('[DEV-ONLY] warns about misusage', () => {
const originalConsoleWarn = console.warn
console.warn = vi.fn()
;(api as any).dispatch({ type: '__setState' as any })
expect(console.warn).toHaveBeenLastCalledWith(
'[zustand devtools middleware] "__setState" action type is reserved ' +
'to set state from the devtools. Avoid using it.',
)
console.warn = originalConsoleWarn
})
})
it('works in non-browser env', async () => {
const originalWindow = global.window
global.window = undefined as any
expect(() => {
createStore(devtools(() => ({ count: 0 }), { enabled: true }))
}).not.toThrow()
global.window = originalWindow
})
it('works in react native env', async () => {
const originalWindow = global.window
global.window = {} as any
expect(() => {
createStore(devtools(() => ({ count: 0 }), { enabled: true }))
}).not.toThrow()
global.window = originalWindow
})
it('preserves isRecording after setting from devtools', async () => {
const api = createStore(devtools(() => ({ count: 0 }), { enabled: true }))
const [connection] = getNamedConnectionApis(undefined)
const [connectionSubscriber] = getNamedConnectionSubscribers(undefined)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
connectionSubscriber({
type: 'ACTION',
payload: '{ "type": "__setState", "state": { "foo": "bar" } }',
})
api.setState({ count: 1 })
expect(connection.send).not.toBeCalled()
})
/* features:
* [] if name is undefined - use multiple devtools connections.
* [] if name and store is defined - use connection for specific 'name'.
* [] if two stores are coonected to one 'name' group and.
* another connected to another 'name' group, then feature should work
* [] check actions with this feature, for multiple stores that store prefixes are added -
* [] - reset
* [] - commit
* [] - rollback
* [] - jump to state, jump to action
* [] - import state
**/
describe('when redux connection was called on multiple stores with `name` undefined in `devtools` options', () => {
it('should create separate connection for each devtools store with .connect call', async () => {
const options1 = { foo: 'bar', testConnectionId: 'asdf' }
const options2 = { foo: 'barr', testConnectionId: '123asd' }
const initialState1 = { count: 0 }
const initialState2 = { count1: 1 }
createStore(devtools(() => initialState1, { enabled: true, ...options1 }))
createStore(devtools(() => initialState2, { enabled: true, ...options2 }))
expect(extensionConnector.connect).toHaveBeenNthCalledWith(1, options1)
expect(extensionConnector.connect).toHaveBeenNthCalledWith(2, options2)
})
it('should call .init on each different connection object', async () => {
const options1 = { foo: 'bar', testConnectionId: 'asdf' }
const options2 = { foo: 'barr', testConnectionId: '123asd' }
const initialState1 = { count: 0 }
const initialState2 = { count1: 1 }
createStore(devtools(() => initialState1, { enabled: true, ...options1 }))
createStore(devtools(() => initialState2, { enabled: true, ...options2 }))
const [conn1, conn2] = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
)
expect(conn1.init).toHaveBeenCalledWith(initialState1)
expect(conn2.init).toHaveBeenCalledWith(initialState2)
})
describe('when `store` property was provided in `devtools` call in options', () => {
// FIXME: Run this test separately in CI, until we're able to test modules in isolation i.e. use jest.resetModule and re-import modules in each test
// Relevant issues https://github.com/nodejs/node/issues/35889
it('[CI-MATRIX-1] should create single connection for all indernal calls of .connect and `store` is not passed to .connect', async () => {
const { devtools: newDevtools } = await import('zustand/middleware')
const options1 = { store: 'store1123', foo: 'bar1' }
const options2 = { store: 'store2313132', foo: 'bar2' }
const initialState1 = { count: 0 }
const initialState2 = { count1: 1 }
createStore(
newDevtools(() => initialState1, { enabled: true, ...options1 }),
)
createStore(
newDevtools(() => initialState2, { enabled: true, ...options2 }),
)
expect(extensionConnector.connect).toHaveBeenCalledTimes(1)
expect(extensionConnector.connect).toHaveBeenCalledWith({
foo: options1.foo,
})
})
// FIXME: Run this test separately in CI, until we're able to test modules in isolation i.e. use jest.resetModule and re-import modules in each test
// Relevant issues https://github.com/nodejs/node/issues/35889
it('[CI-MATRIX-2] should call `.init` on single connection with combined states after each `create(devtools` call', async () => {
const { devtools: newDevtools } = await import('zustand/middleware')
const options1 = { store: 'store12' }
const options2 = { store: 'store21' }
const initialState1 = { count1: 0 }
const initialState2 = { count2: 1 }
createStore(
newDevtools(() => initialState1, { enabled: true, ...options1 }),
)
createStore(
newDevtools(() => initialState2, { enabled: true, ...options2 }),
)
expect(extensionConnector.connect).toHaveBeenCalledTimes(1)
const [connection] = getNamedConnectionApis(undefined)
expect(connection.init).toHaveBeenCalledTimes(2)
expect(connection.init).toHaveBeenNthCalledWith(1, {
[options1.store]: initialState1,
})
expect(connection.init).toHaveBeenNthCalledWith(2, {
[options1.store]: initialState1,
[options2.store]: initialState2,
})
})
})
})
describe('when redux connection was called on multiple stores with `name` provided in `devtools` options', () => {
describe('when same `name` is provided to all stores in devtools options', () => {
it('should call .connect of redux extension with `name` that was passed from `devtools` options', async () => {
const connectionName = 'test'
const options1 = { name: connectionName, store: 'store1123', foo: 'bar1' }
const options2 = { name: connectionName, store: 'store1414', foo: 'bar1' }
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
createStore(devtools(() => initialState1, { enabled: true, ...options1 }))
createStore(devtools(() => initialState2, { enabled: true, ...options2 }))
expect(extensionConnector.connect).toHaveBeenCalledTimes(1)
expect(extensionConnector.connect).toHaveBeenCalledWith({
foo: options1.foo,
name: connectionName,
})
})
})
describe('when different `name` props were provided for different group of stores in devtools options', () => {
it('should call .connect of redux extension with `name` that was passed from `devtools` options', async () => {
const connectionNameGroup1 = 'test1'
const connectionNameGroup2 = 'test2'
const options1 = {
name: connectionNameGroup1,
store: 'store1123',
foo: 'bar2',
}
const options2 = {
name: connectionNameGroup1,
store: 'store1232',
foo: 'bar3',
}
const options3 = {
name: connectionNameGroup2,
store: 'store61661',
foo: 'bar4',
}
const options4 = {
name: connectionNameGroup2,
store: 'store14632',
foo: 'bar5',
}
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 5 }
const initialState4 = { count: 7 }
createStore(devtools(() => initialState1, { enabled: true, ...options1 }))
createStore(devtools(() => initialState2, { enabled: true, ...options2 }))
createStore(devtools(() => initialState3, { enabled: true, ...options3 }))
createStore(devtools(() => initialState4, { enabled: true, ...options4 }))
expect(extensionConnector.connect).toHaveBeenCalledTimes(2)
expect(extensionConnector.connect).toHaveBeenNthCalledWith(1, {
foo: options1.foo,
name: connectionNameGroup1,
})
expect(extensionConnector.connect).toHaveBeenNthCalledWith(2, {
foo: options3.foo,
name: connectionNameGroup2,
})
})
// FIXME: Run this test separately in CI, until we're able to test modules in isolation i.e. use jest.resetModule and re-import modules in each test
// Relevant issues https://github.com/nodejs/node/issues/35889
it('[CI-MATRIX-3] should call `.init` on single connection with combined states after each `create(devtools` call', async () => {
const { devtools: newDevtools } = await import('zustand/middleware')
const connectionNameGroup1 = 'test1'
const connectionNameGroup2 = 'test2'
const options1 = {
name: connectionNameGroup1,
store: 'store1123',
foo: 'bar2',
}
const options2 = {
name: connectionNameGroup1,
store: 'store1232',
foo: 'bar3',
}
const options3 = {
name: connectionNameGroup2,
store: 'store61661',
foo: 'bar4',
}
const options4 = {
name: connectionNameGroup2,
store: 'store14632',
foo: 'bar5',
}
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 5 }
const initialState4 = { count: 7 }
createStore(
newDevtools(() => initialState1, { enabled: true, ...options1 }),
)
createStore(
newDevtools(() => initialState2, { enabled: true, ...options2 }),
)
createStore(
newDevtools(() => initialState3, { enabled: true, ...options3 }),
)
createStore(
newDevtools(() => initialState4, { enabled: true, ...options4 }),
)
expect(extensionConnector.connect).toHaveBeenCalledTimes(2)
const [connection1, connection2] = getNamedConnectionApis(
connectionNameGroup1,
connectionNameGroup2,
)
expect(connection1.init).toHaveBeenCalledTimes(2)
expect(connection1.init).toHaveBeenNthCalledWith(1, {
[options1.store]: initialState1,
})
expect(connection1.init).toHaveBeenNthCalledWith(2, {
[options1.store]: initialState1,
[options2.store]: initialState2,
})
expect(connection2.init).toHaveBeenCalledTimes(2)
expect(connection2.init).toHaveBeenNthCalledWith(1, {
[options3.store]: initialState3,
})
expect(connection2.init).toHaveBeenNthCalledWith(2, {
[options3.store]: initialState3,
[options4.store]: initialState4,
})
})
it('preserves isRecording after setting from devtools on proper connection subscriber', async () => {
const options1 = { name: 'asdf1' }
const options2 = { name: 'asdf2' }
const api1 = createStore(
devtools(() => ({ count: 0 }), { enabled: true, ...options1 }),
)
createStore(
devtools(() => ({ count: 0 }), { enabled: true, ...options2 }),
)
const connections = getNamedConnectionApis(options1.name, options2.name)
const [connectionSubscriber] = getNamedConnectionSubscribers(
options1.name,
)
connectionSubscriber({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
connectionSubscriber({
type: 'ACTION',
payload: '{ "type": "__setState", "state": { "foo": "bar" } }',
})
api1.setState({ count: 1 })
connections.forEach((conn) => expect(conn.send).not.toBeCalled())
})
describe('with redux middleware', () => {
let api1: StoreApi<{
count: number
dispatch: (
action: { type: 'INCREMENT' } | { type: 'DECREMENT' },
) => { type: 'INCREMENT' } | { type: 'DECREMENT' }
}>
let api2: StoreApi<{
count: number
dispatch: (
action: { type: 'INCREMENT' } | { type: 'DECREMENT' },
) => { type: 'INCREMENT' } | { type: 'DECREMENT' }
}>
it('works as expected', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
api1 = createStore(
devtools(
redux(
(
{ count },
{ type }: { type: 'INCREMENT' } | { type: 'DECREMENT' },
) => ({
count: count + (type === 'INCREMENT' ? 1 : -1),
}),
{ count: 0 },
),
{ enabled: true, ...options1 },
),
)
api2 = createStore(
devtools(
redux(
(
{ count },
{ type }: { type: 'INCREMENT' } | { type: 'DECREMENT' },
) => ({
count: count + (type === 'INCREMENT' ? 1 : -1),
}),
{ count: 10 },
),
{ enabled: true, ...options2 },
),
)
;(api1 as any).dispatch({ type: 'INCREMENT' })
;(api1 as any).dispatch({ type: 'INCREMENT' })
;(api2 as any).dispatch({ type: 'INCREMENT' })
;(api2 as any).dispatch({ type: 'INCREMENT' })
const [connection1, connection2] = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
)
const [connectionSubscriber1, connectionSubscriber2] =
getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
)
connectionSubscriber1({
type: 'ACTION',
payload: JSON.stringify({ type: 'DECREMENT' }),
})
connectionSubscriber2({
type: 'ACTION',
payload: JSON.stringify({ type: 'DECREMENT' }),
})
expect(connection1.init.mock.calls).toMatchObject([
[{ count: 0 }] as unknown as Record<string, unknown>,
])
expect(connection2.init.mock.calls).toMatchObject([
[{ count: 10 }] as unknown as Record<string, unknown>,
])
expect(connection1.send.mock.calls).toMatchObject([
[{ type: 'INCREMENT' }, { count: 1 }] as unknown as Record<
string,
unknown
>,
[{ type: 'INCREMENT' }, { count: 2 }] as unknown as Record<
string,
unknown
>,
[{ type: 'DECREMENT' }, { count: 1 }] as unknown as Record<
string,
unknown
>,
])
expect(connection2.send.mock.calls).toMatchObject([
[{ type: 'INCREMENT' }, { count: 11 }] as unknown as Record<
string,
unknown
>,
[{ type: 'INCREMENT' }, { count: 12 }] as unknown as Record<
string,
unknown
>,
[{ type: 'DECREMENT' }, { count: 11 }] as unknown as Record<
string,
unknown
> as unknown as Record<string, unknown>,
])
expect(api1.getState()).toMatchObject({ count: 1 })
expect(api2.getState()).toMatchObject({ count: 11 })
})
})
})
})
describe('when create devtools was called multiple times with `name` option undefined', () => {
describe('When state changes...', () => {
it("sends { type: setStateName || 'anonymous`, ...rest } as the action with current state, isolated from other connections", async () => {
const options1 = {
enabled: true,
testConnectionId: '123',
}
const options2 = {
enabled: true,
testConnectionId: '324',
}
const options3 = {
enabled: true,
testConnectionId: '412',
}
const api1 = createStore(
devtools(() => ({ count: 0, foo: 'bar' }), options1),
)
createStore(devtools(() => ({ count: 0, foo: 'bar1' }), options2))
createStore(devtools(() => ({ count: 0, foo: 'bar2' }), options3))
api1.setState({ count: 10 }, false, 'testSetStateName')
const [connection1, connection2, connection3] = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
expect(connection1.send).toHaveBeenLastCalledWith(
{ type: 'testSetStateName' },
{ count: 10, foo: 'bar' },
)
expect(connection2.send).not.toBeCalled()
expect(connection3.send).not.toBeCalled()
api1.setState({ count: 15 }, false, {
type: 'testSetStateName',
payload: 15,
})
expect(connection1.send).toHaveBeenLastCalledWith(
{ type: 'testSetStateName', payload: 15 },
{ count: 15, foo: 'bar' },
)
expect(connection2.send).not.toBeCalled()
expect(connection3.send).not.toBeCalled()
api1.setState({ count: 5, foo: 'baz' }, true)
expect(connection1.send).toHaveBeenLastCalledWith(
{ type: 'anonymous' },
{ count: 5, foo: 'baz' },
)
expect(connection2.send).not.toBeCalled()
expect(connection3.send).not.toBeCalled()
})
})
describe('when it receives a message of type...', () => {
describe('ACTION...', () => {
it('does nothing, connections isolated from each other', async () => {
const options1 = { testConnectionId: '123' }
const options2 = { testConnectionId: '231' }
const options3 = { testConnectionId: '4342' }
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 3 }
const api1 = createStore(
devtools(() => initialState1, {
enabled: true,
...options1,
}),
)
const api2 = createStore(
devtools(() => initialState2, {
enabled: true,
...options2,
}),
)
const api3 = createStore(
devtools(() => initialState3, {
enabled: true,
...options3,
}),
)
const setState1 = vi.spyOn(api1, 'setState')
const setState2 = vi.spyOn(api2, 'setState')
const setState3 = vi.spyOn(api3, 'setState')
const [subscriber] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
)
subscriber({
type: 'ACTION',
payload: '{ "type": "INCREMENT" }',
})
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(api3.getState()).toBe(initialState3)
expect(setState1).not.toBeCalled()
expect(setState2).not.toBeCalled()
expect(setState3).not.toBeCalled()
})
it('unless action type is __setState, connections isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 5 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
const [connectionSubscriber] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
)
connectionSubscriber({
type: 'ACTION',
payload: '{ "type": "__setState", "state": { "foo": "bar" } }',
})
expect(api1.getState()).toStrictEqual({ ...initialState1, foo: 'bar' })
expect(api2.getState()).toStrictEqual({ ...initialState2 })
expect(api3.getState()).toStrictEqual({ ...initialState3 })
})
it('does nothing even if there is `api.dispatch`, connections isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 5 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
;(api1 as any).dispatch = vi.fn()
;(api2 as any).dispatch = vi.fn()
;(api3 as any).dispatch = vi.fn()
const setState1 = vi.spyOn(api1, 'setState')
const setState2 = vi.spyOn(api2, 'setState')
const setState3 = vi.spyOn(api3, 'setState')
const subscribers = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
const testPayload = {
type: 'ACTION',
payload: '{ "type": "INCREMENT" }',
}
subscribers.forEach((sub) => sub(testPayload))
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(api3.getState()).toBe(initialState3)
expect(setState1).not.toBeCalled()
expect(setState2).not.toBeCalled()
expect(setState3).not.toBeCalled()
expect((api1 as any).dispatch).not.toBeCalled()
expect((api2 as any).dispatch).not.toBeCalled()
expect((api3 as any).dispatch).not.toBeCalled()
})
it('dispatches with `api.dispatch` when `api.dispatchFromDevtools` is set to true, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 5 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
;(api1 as any).dispatch = vi.fn()
;(api1 as any).dispatchFromDevtools = true
;(api2 as any).dispatch = vi.fn()
;(api2 as any).dispatchFromDevtools = true
;(api3 as any).dispatch = vi.fn()
;(api3 as any).dispatchFromDevtools = true
const setState1 = vi.spyOn(api1, 'setState')
const setState2 = vi.spyOn(api2, 'setState')
const setState3 = vi.spyOn(api3, 'setState')
const subscribers = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
const getTestPayload = (n: number) => ({
type: 'ACTION',
payload: `{ "type": "INCREMENT${n}" }`,
})
subscribers.forEach((sub, i) => sub(getTestPayload(i + 1)))
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(api3.getState()).toBe(initialState3)
expect(setState1).not.toBeCalled()
expect(setState2).not.toBeCalled()
expect(setState3).not.toBeCalled()
expect((api1 as any).dispatch).toHaveBeenLastCalledWith({
type: 'INCREMENT1',
})
expect((api2 as any).dispatch).toHaveBeenLastCalledWith({
type: 'INCREMENT2',
})
expect((api3 as any).dispatch).toHaveBeenLastCalledWith({
type: 'INCREMENT3',
})
})
it('does not throw for unsupported payload, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 5 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
;(api1 as any).dispatch = vi.fn()
;(api1 as any).dispatchFromDevtools = true
;(api2 as any).dispatch = vi.fn()
;(api2 as any).dispatchFromDevtools = true
;(api3 as any).dispatch = vi.fn()
;(api3 as any).dispatchFromDevtools = true
const setState1 = vi.spyOn(api1, 'setState')
const setState2 = vi.spyOn(api2, 'setState')
const setState3 = vi.spyOn(api3, 'setState')
const originalConsoleError = console.error
console.error = vi.fn()
const [
connectionSubscriber1,
connectionSubscriber2,
connectionSubscriber3,
] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
expect(() => {
connectionSubscriber1({
type: 'ACTION',
payload: 'this.increment1()',
})
}).not.toThrow()
expect(console.error).toHaveBeenNthCalledWith(
1,
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('this.increment1()')
} catch (e) {
return e
}
})(),
)
expect(() => {
connectionSubscriber1({
type: 'ACTION',
payload: 'this.increment2()',
})
}).not.toThrow()
expect(console.error).toHaveBeenNthCalledWith(
2,
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('this.increment2()')
} catch (e) {
return e
}
})(),
)
expect(() => {
connectionSubscriber1({
type: 'ACTION',
payload: 'this.increment3()',
})
}).not.toThrow()
expect(console.error).toHaveBeenNthCalledWith(
3,
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('this.increment3()')
} catch (e) {
return e
}
})(),
)
expect(() => {
connectionSubscriber1({
type: 'ACTION',
payload: { name: 'increment', args: [] },
})
}).not.toThrow()
expect(console.error).toHaveBeenNthCalledWith(
4,
'[zustand devtools middleware] Unsupported action format',
)
expect(() => {
connectionSubscriber2({
type: 'ACTION',
payload: { name: 'increment', args: [] },
})
}).not.toThrow()
expect(console.error).toHaveBeenNthCalledWith(
5,
'[zustand devtools middleware] Unsupported action format',
)
expect(() => {
connectionSubscriber3({
type: 'ACTION',
payload: { name: 'increment', args: [] },
})
}).not.toThrow()
expect(console.error).toHaveBeenNthCalledWith(
6,
'[zustand devtools middleware] Unsupported action format',
)
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(api3.getState()).toBe(initialState3)
expect(setState1).not.toBeCalled()
expect(setState2).not.toBeCalled()
expect(setState3).not.toBeCalled()
expect((api1 as any).dispatch).not.toBeCalled()
expect((api2 as any).dispatch).not.toBeCalled()
expect((api3 as any).dispatch).not.toBeCalled()
console.error = originalConsoleError
})
})
describe('DISPATCH and payload of type...', () => {
it('RESET, it inits with initial state, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 5 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
api1.setState({ count: 1 })
api2.setState({ count: 3 })
api3.setState({ count: 10 })
const connections = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
const [connection1, connection2, connection3] = connections
connections.forEach((conn) => conn.send.mockClear())
const subscribers = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
const action = {
type: 'DISPATCH',
payload: { type: 'RESET' },
}
subscribers.forEach((sub) => sub(action))
expect(api1.getState()).toStrictEqual(initialState1)
expect(api1.getState()).toStrictEqual(initialState1)
expect(api1.getState()).toStrictEqual(initialState1)
expect(connection1.init).toHaveBeenLastCalledWith(initialState1)
expect(connection2.init).toHaveBeenLastCalledWith(initialState2)
expect(connection3.init).toHaveBeenLastCalledWith(initialState3)
connections.forEach((conn) => expect(conn.send).not.toBeCalled())
})
it('COMMIT, it inits with current state, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 5 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
api1.setState({ count: 1 })
api2.setState({ count: 3 })
api3.setState({ count: 10 })
const currentState1 = api1.getState()
const currentState2 = api2.getState()
const currentState3 = api3.getState()
const connections = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connections.forEach((conn) => conn.send.mockClear())
const subscribers = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
const action = {
type: 'DISPATCH',
payload: { type: 'COMMIT' },
}
subscribers.forEach((sub) => sub(action))
const [connection1, connection2, connection3] = connections
expect(connection1.init).toHaveBeenLastCalledWith(currentState1)
expect(connection2.init).toHaveBeenLastCalledWith(currentState2)
expect(connection3.init).toHaveBeenLastCalledWith(currentState3)
connections.forEach((conn) => expect(conn.send).not.toBeCalled())
})
})
describe('ROLLBACK...', () => {
it('it updates state without recording and inits with `message.state, connections are isolated from each other`', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0, increment: () => {} }
const initialState2 = { count: 2, increment: () => {} }
const initialState3 = { count: 5, increment: () => {} }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
const newState1 = { foo: 'bar1' }
const newState2 = { foo: 'bar2' }
const newState3 = { foo: 'bar3' }
const connections = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connections.forEach((conn) => conn.send.mockClear())
const [
connectionSubscriber1,
connectionSubscriber2,
connectionSubscriber3,
] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connectionSubscriber1({
type: 'DISPATCH',
payload: { type: 'ROLLBACK' },
state: JSON.stringify(newState1),
})
connectionSubscriber2({
type: 'DISPATCH',
payload: { type: 'ROLLBACK' },
state: JSON.stringify(newState2),
})
connectionSubscriber3({
type: 'DISPATCH',
payload: { type: 'ROLLBACK' },
state: JSON.stringify(newState3),
})
expect(api1.getState()).toStrictEqual({
...initialState1,
...newState1,
})
expect(api2.getState()).toStrictEqual({
...initialState2,
...newState2,
})
expect(api3.getState()).toStrictEqual({
...initialState3,
...newState3,
})
const [connection1, connection2, connection3] = connections
expect(connection1.init).toHaveBeenLastCalledWith({
...initialState1,
...newState1,
})
expect(connection2.init).toHaveBeenLastCalledWith({
...initialState2,
...newState2,
})
expect(connection3.init).toHaveBeenLastCalledWith({
...initialState3,
...newState3,
})
connections.forEach((conn) => expect(conn.send).not.toBeCalled())
})
it('does not throw for unparsable `message.state`, connections are isolated from each other', async () => {
const increment1 = () => {}
const increment2 = () => {}
const increment3 = () => {}
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0, increment: increment1 }
const initialState2 = { count: 2, increment: increment2 }
const initialState3 = { count: 5, increment: increment3 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
const originalConsoleError = console.error
console.error = vi.fn()
const connections = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connections.forEach((conn) => conn.init.mockClear())
connections.forEach((conn) => conn.send.mockClear())
const [
connectionSubscriber1,
connectionSubscriber2,
connectionSubscriber3,
] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connectionSubscriber1({
type: 'DISPATCH',
payload: { type: 'ROLLBACK' },
state: 'foobar',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar')
} catch (e) {
return e
}
})(),
)
connectionSubscriber2({
type: 'DISPATCH',
payload: { type: 'ROLLBACK' },
state: 'foobar1',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar1')
} catch (e) {
return e
}
})(),
)
connectionSubscriber3({
type: 'DISPATCH',
payload: { type: 'ROLLBACK' },
state: 'foobar3',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar3')
} catch (e) {
return e
}
})(),
)
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(api3.getState()).toBe(initialState3)
connections.forEach((conn) => {
expect(conn.init).not.toBeCalled()
expect(conn.send).not.toBeCalled()
})
console.error = originalConsoleError
})
})
describe('JUMP_TO_STATE...', () => {
const increment1 = () => {}
const increment2 = () => {}
const increment3 = () => {}
it('it updates state without recording with `message.state`, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0, increment: increment1 }
const initialState2 = { count: 2, increment: increment2 }
const initialState3 = { count: 5, increment: increment3 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
const newState1 = { foo: 'bar1' }
const newState2 = { foo: 'bar2' }
const newState3 = { foo: 'bar3' }
const connections = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connections.forEach((conn) => conn.send.mockClear())
const [
connectionSubscriber1,
connectionSubscriber2,
connectionSubscriber3,
] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connectionSubscriber1({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_STATE' },
state: JSON.stringify(newState1),
})
connectionSubscriber2({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_STATE' },
state: JSON.stringify(newState2),
})
connectionSubscriber3({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_STATE' },
state: JSON.stringify(newState3),
})
expect(api1.getState()).toStrictEqual({
...initialState1,
...newState1,
})
expect(api2.getState()).toStrictEqual({
...initialState2,
...newState2,
})
expect(api3.getState()).toStrictEqual({
...initialState3,
...newState3,
})
connections.forEach((conn) => expect(conn.send).not.toBeCalled())
})
it('does not throw for unparsable `message.state`, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0, increment: increment1 }
const initialState2 = { count: 2, increment: increment2 }
const initialState3 = { count: 5, increment: increment3 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
const originalConsoleError = console.error
console.error = vi.fn()
const connections = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connections.forEach((conn) => conn.send.mockClear())
const [
connectionSubscriber1,
connectionSubscriber2,
connectionSubscriber3,
] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connectionSubscriber1({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_STATE' },
state: 'foobar',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar')
} catch (e) {
return e
}
})(),
)
connectionSubscriber2({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_STATE' },
state: 'foobar2',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar2')
} catch (e) {
return e
}
})(),
)
connectionSubscriber3({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_STATE' },
state: 'foobar3',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar3')
} catch (e) {
return e
}
})(),
)
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(api3.getState()).toBe(initialState3)
connections.forEach((conn) => expect(conn.send).not.toBeCalled())
console.error = originalConsoleError
})
})
describe('JUMP_TO_ACTION...', () => {
const increment1 = () => {}
const increment2 = () => {}
const increment3 = () => {}
it('it updates state without recording with `message.state`, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0, increment: increment1 }
const initialState2 = { count: 2, increment: increment2 }
const initialState3 = { count: 5, increment: increment3 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
const newState1 = { foo: 'bar1' }
const newState2 = { foo: 'bar2' }
const newState3 = { foo: 'bar3' }
const connections = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connections.forEach((conn) => conn.send.mockClear())
const [
connectionSubscriber1,
connectionSubscriber2,
connectionSubscriber3,
] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connectionSubscriber1({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_ACTION' },
state: JSON.stringify(newState1),
})
connectionSubscriber2({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_ACTION' },
state: JSON.stringify(newState2),
})
connectionSubscriber3({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_ACTION' },
state: JSON.stringify(newState3),
})
expect(api1.getState()).toStrictEqual({
...initialState1,
...newState1,
})
expect(api2.getState()).toStrictEqual({
...initialState2,
...newState2,
})
expect(api3.getState()).toStrictEqual({
...initialState3,
...newState3,
})
connections.forEach((conn) => expect(conn.send).not.toBeCalled())
})
it('does not throw for unparsable `message.state`, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0, increment: increment1 }
const initialState2 = { count: 2, increment: increment2 }
const initialState3 = { count: 5, increment: increment3 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
const originalConsoleError = console.error
console.error = vi.fn()
const connections = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connections.forEach((conn) => conn.send.mockClear())
const [
connectionSubscriber1,
connectionSubscriber2,
connectionSubscriber3,
] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connectionSubscriber1({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_ACTION' },
state: 'foobar',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar')
} catch (e) {
return e
}
})(),
)
connectionSubscriber2({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_ACTION' },
state: 'foobar2',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar2')
} catch (e) {
return e
}
})(),
)
connectionSubscriber3({
type: 'DISPATCH',
payload: { type: 'JUMP_TO_ACTION' },
state: 'foobar3',
})
expect(console.error).toHaveBeenLastCalledWith(
'[zustand devtools middleware] Could not parse the received json',
(() => {
try {
JSON.parse('foobar3')
} catch (e) {
return e
}
})(),
)
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(api3.getState()).toBe(initialState3)
connections.forEach((conn) => expect(conn.send).not.toBeCalled())
console.error = originalConsoleError
})
it('IMPORT_STATE, it updates state without recording and inits the last computedState, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const initialState1 = { count: 0, increment: increment1 }
const initialState2 = { count: 2, increment: increment2 }
const initialState3 = { count: 5, increment: increment3 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => initialState3, { enabled: true, ...options3 }),
)
const nextLiftedState1 = {
computedStates: [{ state: { count: 4 } }, { state: { count: 5 } }],
}
const nextLiftedState2 = {
computedStates: [{ state: { count: 20 } }, { state: { count: 8 } }],
}
const nextLiftedState3 = {
computedStates: [{ state: { count: 12 } }, { state: { count: 100 } }],
}
const connections = getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connections.forEach((conn) => conn.send.mockClear())
const [
connectionSubscriber1,
connectionSubscriber2,
connectionSubscriber3,
] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
connectionSubscriber1({
type: 'DISPATCH',
payload: {
type: 'IMPORT_STATE',
nextLiftedState: nextLiftedState1,
},
})
connectionSubscriber2({
type: 'DISPATCH',
payload: {
type: 'IMPORT_STATE',
nextLiftedState: nextLiftedState2,
},
})
connectionSubscriber3({
type: 'DISPATCH',
payload: {
type: 'IMPORT_STATE',
nextLiftedState: nextLiftedState3,
},
})
expect(api1.getState()).toStrictEqual({
...initialState1,
...nextLiftedState1.computedStates.slice(-1)[0]?.state,
})
expect(api2.getState()).toStrictEqual({
...initialState2,
...nextLiftedState2.computedStates.slice(-1)[0]?.state,
})
expect(api3.getState()).toStrictEqual({
...initialState3,
...nextLiftedState3.computedStates.slice(-1)[0]?.state,
})
const [connection1, connection2, connection3] = connections
expect(connection1.send).toHaveBeenLastCalledWith(
null,
nextLiftedState1,
)
expect(connection2.send).toHaveBeenLastCalledWith(
null,
nextLiftedState2,
)
expect(connection3.send).toHaveBeenLastCalledWith(
null,
nextLiftedState3,
)
})
it('PAUSE_RECORDING, it toggles the sending of actions, connections are isolated from each other', async () => {
const options1 = { testConnectionId: 'asdf' }
const options2 = { testConnectionId: '2f' }
const options3 = { testConnectionId: 'd2e' }
const api1 = createStore(
devtools(() => ({ count: 0 }), { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => ({ count: 2 }), { enabled: true, ...options2 }),
)
const api3 = createStore(
devtools(() => ({ count: 4 }), { enabled: true, ...options3 }),
)
const newState1 = { count: 1 }
const newState2 = { count: 12 }
const newState3 = { count: 30 }
api1.setState(newState1, false, 'increment')
api2.setState(newState2, false, 'increment')
api3.setState(newState3, false, 'increment')
const [connection1, connection2, connection3] =
getUnnamedConnectionApis(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
const [
connectionSubscriber1,
connectionSubscriber2,
connectionSubscriber3,
] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
options2.testConnectionId,
options3.testConnectionId,
)
expect(connection1.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
newState1,
)
connectionSubscriber1({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
api1.setState({ count: 2 }, false, 'increment')
expect(connection1.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
newState1,
)
connectionSubscriber1({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
api1.setState({ count: 3 }, false, 'increment')
expect(connection1.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
{ count: 3 },
)
expect(connection2.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
newState2,
)
connectionSubscriber2({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
api2.setState({ count: 2 }, false, 'increment')
expect(connection2.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
newState2,
)
connectionSubscriber2({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
api2.setState({ count: 3 }, false, 'increment')
expect(connection2.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
{ count: 3 },
)
expect(connection3.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
newState3,
)
connectionSubscriber3({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
api3.setState({ count: 2 }, false, 'increment')
expect(connection3.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
newState3,
)
connectionSubscriber3({
type: 'DISPATCH',
payload: { type: 'PAUSE_RECORDING' },
})
api3.setState({ count: 3 }, false, 'increment')
expect(connection3.send).toHaveBeenLastCalledWith(
{ type: 'increment' },
{ count: 3 },
)
})
})
})
})
describe('when create devtools was called multiple times with `name` and `store` options defined', () => {
describe('when `type` was provided in store state methods as option', () => {
describe('When state changes...', () => {
it("sends { type: setStateName || 'anonymous`, ...rest } as the action with current state", async () => {
const options = {
name: 'testOptionsName',
store: 'someStore',
enabled: true,
}
const api = createStore(
devtools(() => ({ count: 0, foo: 'bar' }), options),
)
const testStateActionType = 'testSetStateName'
api.setState({ count: 10 }, false, testStateActionType)
const [connection] = getNamedConnectionApis(options.name)
expect(connection.send).toHaveBeenLastCalledWith(
{ type: `${options.store}/${testStateActionType}` },
{ [options.store]: { count: 10, foo: 'bar' } },
)
api.setState({ count: 15 }, false, {
type: testStateActionType,
payload: 15,
})
expect(connection.send).toHaveBeenLastCalledWith(
{ type: `${options.store}/${testStateActionType}`, payload: 15 },
{ [options.store]: { count: 15, foo: 'bar' } },
)
api.setState({ count: 5, foo: 'baz' }, true)
expect(connection.send).toHaveBeenLastCalledWith(
{ type: `${options.store}/anonymous` },
{ [options.store]: { count: 5, foo: 'baz' } },
)
})
})
describe('when it receives a message of type...', () => {
describe('ACTION...', () => {
it('does nothing, connections isolated from each other', async () => {
const options1 = { testConnectionId: '123', store: 'store1' }
const options2 = { testConnectionId: '231', store: 'store2' }
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const initialState3 = { count: 5 }
const initialState4 = { count: 6 }
const api1 = createStore(
devtools(() => initialState1, {
enabled: true,
...options1,
}),
)
const api2 = createStore(
devtools(() => initialState2, {
enabled: true,
...options1,
}),
)
const api3 = createStore(
devtools(() => initialState3, {
enabled: true,
...options2,
}),
)
const api4 = createStore(
devtools(() => initialState4, {
enabled: true,
...options2,
}),
)
const setState1 = vi.spyOn(api1, 'setState')
const setState2 = vi.spyOn(api2, 'setState')
const setState3 = vi.spyOn(api3, 'setState')
const setState4 = vi.spyOn(api4, 'setState')
const [subscriber] = getUnnamedConnectionSubscribers(
options1.testConnectionId,
)
subscriber({
type: 'ACTION',
payload: '{ "type": "INCREMENT" }',
})
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(api3.getState()).toBe(initialState3)
expect(api4.getState()).toBe(initialState4)
expect(setState1).not.toBeCalled()
expect(setState2).not.toBeCalled()
expect(setState3).not.toBeCalled()
expect(setState4).not.toBeCalled()
})
it('unless action type is __setState, connections isolated from each other', async () => {
const name1 = 'name1'
const name2 = 'name2'
const store1 = 'someStore1'
const store2 = 'someStore2'
const options1 = {
name: name1,
store: store1,
testStore: store1,
}
const options2 = {
name: name2,
store: store2,
testStore: store2,
}
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const api1 = createStore(
devtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
devtools(() => initialState2, { enabled: true, ...options2 }),
)
const originalConsoleError = console.error
console.error = vi.fn()
const [connectionSubscriber] = getNamedConnectionSubscribers(
getKeyFromOptions(options1),
)
connectionSubscriber({
type: 'ACTION',
payload:
'{ "type": "__setState", "state": { "foo": "bar", "foo2": "bar2" } }',
})
expect(console.error).toHaveBeenCalledWith(
expect.stringContaining(
'[zustand devtools middleware] Unsupported __setState',
),
)
connectionSubscriber({
type: 'ACTION',
payload: `{ "type": "__setState", "state": { "${options1.store}": { "foo": "bar" } } }`,
})
expect(console.error).toHaveBeenCalledTimes(1)
expect(api1.getState()).toStrictEqual({
...initialState1,
foo: 'bar',
})
expect(api2.getState()).toStrictEqual({ ...initialState2 })
console.error = originalConsoleError
})
// FIXME: Run this test separately in CI, until we're able to test modules in isolation i.e. use jest.resetModule and re-import modules in each test
// Relevant issues https://github.com/nodejs/node/issues/35889
it('[CI-MATRIX-4] does nothing even if there is `api.dispatch`, connections isolated from each other', async () => {
const { devtools: newDevtools } = await import('zustand/middleware')
const name1 = 'name1'
const name2 = 'name2'
const store1 = 'someStore1'
const store2 = 'someStore2'
const options1 = {
name: name1,
store: store1,
testStore: store1,
}
const options2 = {
name: name2,
store: store2,
testStore: store2,
}
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const api1 = createStore(
newDevtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
newDevtools(() => initialState2, { enabled: true, ...options2 }),
)
;(api1 as any).dispatch = vi.fn()
;(api2 as any).dispatch = vi.fn()
const setState1 = vi.spyOn(api1, 'setState')
const setState2 = vi.spyOn(api2, 'setState')
const subscribers = getNamedConnectionSubscribers(
getKeyFromOptions(options1),
getKeyFromOptions(options2),
)
const testPayload = {
type: 'ACTION',
payload: '{ "type": "INCREMENT" }',
}
subscribers.forEach((sub) => sub(testPayload))
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(setState1).not.toBeCalled()
expect(setState2).not.toBeCalled()
expect((api1 as any).dispatch).not.toBeCalled()
expect((api2 as any).dispatch).not.toBeCalled()
})
// FIXME: Run this test separately in CI, until we're able to test modules in isolation i.e. use jest.resetModule and re-import modules in each test
// Relevant issues https://github.com/nodejs/node/issues/35889
it('[CI-MATRIX-5] dispatches with `api.dispatch` when `api.dispatchFromDevtools` is set to true, connections are isolated from each other', async () => {
const { devtools: newDevtools } = await import('zustand/middleware')
const name1 = 'name1'
const name2 = 'name2'
const store1 = 'someStore1'
const store2 = 'someStore2'
const options1 = {
name: name1,
store: store1,
testStore: store1,
}
const options2 = {
name: name2,
store: store2,
testStore: store2,
}
const initialState1 = { count: 0 }
const initialState2 = { count: 2 }
const api1 = createStore(
newDevtools(() => initialState1, { enabled: true, ...options1 }),
)
const api2 = createStore(
newDevtools(() => initialState2, { enabled: true, ...options2 }),
)
;(api1 as any).dispatch = vi.fn()
;(api1 as any).dispatchFromDevtools = true
;(api2 as any).dispatch = vi.fn()
;(api2 as any).dispatchFromDevtools = true
const setState1 = vi.spyOn(api1, 'setState')
const setState2 = vi.spyOn(api2, 'setState')
const subscribers = getNamedConnectionSubscribers(
getKeyFromOptions(options1),
getKeyFromOptions(options2),
)
const getTestPayload = (n: number) => ({
type: 'ACTION',
payload: `{ "type": "INCREMENT${n}" }`,
})
subscribers.forEach((sub, i) => sub(getTestPayload(i + 1)))
expect(api1.getState()).toBe(initialState1)
expect(api2.getState()).toBe(initialState2)
expect(setState1).not.toBeCalled()
expect(setState2).not.toBeCalled()
expect((api1 as any).dispatch).toHaveBeenLastCalledWith({
type: 'INCREMENT1',
})
expect((api2 as any).dispatch).toHaveBeenLastCalledWith({
type: 'INCREMENT2',
})
})
})
})
})
})
|
5,801 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/middlewareTypes.test.tsx | import { describe, it } from 'vitest'
import { create } from 'zustand'
import type { StoreApi } from 'zustand'
import {
combine,
devtools,
persist,
redux,
subscribeWithSelector,
} from 'zustand/middleware'
import { immer } from 'zustand/middleware/immer'
import { createStore } from 'zustand/vanilla'
type CounterState = {
count: number
inc: () => void
}
describe('counter state spec (no middleware)', () => {
it('no middleware', () => {
const useBoundStore = create<CounterState>((set, get) => ({
count: 0,
inc: () => set({ count: get().count + 1 }, false),
}))
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
return <></>
}
TestComponent
})
})
describe('counter state spec (single middleware)', () => {
it('immer', () => {
const useBoundStore = create<CounterState>()(
immer((set, get) => ({
count: 0,
inc: () =>
set((state) => {
state.count = get().count + 1
}),
})),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
return <></>
}
TestComponent
const _testSubtyping: StoreApi<object> = createStore(
immer(() => ({ count: 0 })),
)
})
it('redux', () => {
const useBoundStore = create(
redux<{ count: number }, { type: 'INC' }>(
(state, action) => {
switch (action.type) {
case 'INC':
return { ...state, count: state.count + 1 }
default:
return state
}
},
{ count: 0 },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.dispatch)({ type: 'INC' })
useBoundStore().dispatch({ type: 'INC' })
useBoundStore.dispatch({ type: 'INC' })
return <></>
}
TestComponent
const _testSubtyping: StoreApi<object> = createStore(
redux((x) => x, { count: 0 }),
)
})
it('devtools', () => {
const useBoundStore = create<CounterState>()(
devtools(
(set, get) => ({
count: 0,
inc: () => set({ count: get().count + 1 }, false, 'inc'),
}),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.setState({ count: 0 }, false, 'reset')
return <></>
}
TestComponent
const _testSubtyping: StoreApi<object> = createStore(
devtools(() => ({ count: 0 })),
)
})
it('subscribeWithSelector', () => {
const useBoundStore = create<CounterState>()(
subscribeWithSelector((set, get) => ({
count: 1,
inc: () => set({ count: get().count + 1 }, false),
})),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.subscribe(
(state) => state.count,
(count) => console.log(count * 2),
)
return <></>
}
TestComponent
const _testSubtyping: StoreApi<object> = createStore(
subscribeWithSelector(() => ({ count: 0 })),
)
})
it('combine', () => {
const useBoundStore = create(
combine({ count: 1 }, (set, get) => ({
inc: () => set({ count: get().count + 1 }, false),
})),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
return <></>
}
TestComponent
const _testSubtyping: StoreApi<object> = createStore(
combine({ count: 0 }, () => ({})),
)
})
it('persist', () => {
const useBoundStore = create<CounterState>()(
persist(
(set, get) => ({
count: 1,
inc: () => set({ count: get().count + 1 }, false),
}),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.persist.hasHydrated()
return <></>
}
TestComponent
const _testSubtyping: StoreApi<object> = createStore(
persist(() => ({ count: 0 }), { name: 'prefix' }),
)
})
it('persist with partialize', () => {
const useBoundStore = create<CounterState>()(
persist(
(set, get) => ({
count: 1,
inc: () => set({ count: get().count + 1 }, false),
}),
{ name: 'prefix', partialize: (s) => s.count },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.persist.hasHydrated()
useBoundStore.persist.setOptions({
// @ts-expect-error to test if the partialized state is inferred as number
partialize: () => 'not-a-number',
})
return <></>
}
TestComponent
})
it('persist without custom api (#638)', () => {
const useBoundStore = create<CounterState>()(
persist(
(set, get) => ({
count: 1,
inc: () => set({ count: get().count + 1 }, false),
}),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
return <></>
}
TestComponent
})
})
describe('counter state spec (double middleware)', () => {
it('immer & devtools', () => {
const useBoundStore = create<CounterState>()(
immer(
devtools(
(set, get) => ({
count: 0,
inc: () =>
set(
(state) => {
state.count = get().count + 1
},
false,
{ type: 'inc', by: 1 },
),
}),
{ name: 'prefix' },
),
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.setState({ count: 0 }, false, 'reset')
return <></>
}
TestComponent
})
it('devtools & redux', () => {
const useBoundStore = create(
devtools(
redux(
(state, action: { type: 'INC' }) => {
switch (action.type) {
case 'INC':
return { ...state, count: state.count + 1 }
default:
return state
}
},
{ count: 0 },
),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.dispatch)({ type: 'INC' })
useBoundStore().dispatch({ type: 'INC' })
useBoundStore.dispatch({ type: 'INC' })
useBoundStore.setState({ count: 0 }, false, 'reset')
return <></>
}
TestComponent
})
it('devtools & combine', () => {
const useBoundStore = create(
devtools(
combine({ count: 1 }, (set, get) => ({
inc: () => set({ count: get().count + 1 }, false, 'inc'),
})),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.setState({ count: 0 }, false, 'reset')
return <></>
}
TestComponent
})
it('subscribeWithSelector & combine', () => {
const useBoundStore = create(
subscribeWithSelector(
combine({ count: 1 }, (set, get) => ({
inc: () => set({ count: get().count + 1 }, false),
})),
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.subscribe(
(state) => state.count,
(count) => console.log(count * 2),
)
return <></>
}
TestComponent
})
it('devtools & subscribeWithSelector', () => {
const useBoundStore = create<CounterState>()(
devtools(
subscribeWithSelector((set, get) => ({
count: 1,
inc: () => set({ count: get().count + 1 }, false, 'inc'),
})),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.subscribe(
(state) => state.count,
(count) => console.log(count * 2),
)
useBoundStore.setState({ count: 0 }, false, 'reset')
return <></>
}
TestComponent
})
it('devtools & persist', () => {
const useBoundStore = create<CounterState>()(
devtools(
persist(
(set, get) => ({
count: 1,
inc: () => set({ count: get().count + 1 }, false, 'inc'),
}),
{ name: 'count' },
),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.setState({ count: 0 }, false, 'reset')
useBoundStore.persist.hasHydrated()
return <></>
}
TestComponent
})
})
describe('counter state spec (triple middleware)', () => {
it('devtools & persist & immer', () => {
const useBoundStore = create<CounterState>()(
devtools(
persist(
immer((set, get) => ({
count: 0,
inc: () =>
set((state) => {
state.count = get().count + 1
}),
})),
{ name: 'count' },
),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.setState({ count: 0 }, false, 'reset')
useBoundStore.persist.hasHydrated()
return <></>
}
TestComponent
})
it('devtools & subscribeWithSelector & combine', () => {
const useBoundStore = create(
devtools(
subscribeWithSelector(
combine({ count: 1 }, (set, get) => ({
inc: () => set({ count: get().count + 1 }, false, 'inc'),
})),
),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.subscribe(
(state) => state.count,
(count) => console.log(count * 2),
)
useBoundStore.setState({ count: 0 }, false, 'reset')
return <></>
}
TestComponent
})
it('devtools & subscribeWithSelector & persist', () => {
const useBoundStore = create<CounterState>()(
devtools(
subscribeWithSelector(
persist(
(set, get) => ({
count: 0,
inc: () => set({ count: get().count + 1 }, false),
}),
{ name: 'count' },
),
),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.subscribe(
(state) => state.count,
(count) => console.log(count * 2),
)
useBoundStore.setState({ count: 0 }, false, 'reset')
useBoundStore.persist.hasHydrated()
return <></>
}
TestComponent
})
})
describe('counter state spec (quadruple middleware)', () => {
it('devtools & subscribeWithSelector & persist & immer (#616)', () => {
const useBoundStore = create<CounterState>()(
devtools(
subscribeWithSelector(
persist(
immer((set, get) => ({
count: 0,
inc: () =>
set((state) => {
state.count = get().count + 1
}),
})),
{ name: 'count' },
),
),
{ name: 'prefix' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.subscribe(
(state) => state.count,
(count) => console.log(count * 2),
)
useBoundStore.setState({ count: 0 }, false, 'reset')
useBoundStore.persist.hasHydrated()
return <></>
}
TestComponent
})
})
describe('more complex state spec with subscribeWithSelector', () => {
it('#619, #632', () => {
const useBoundStore = create(
subscribeWithSelector(
persist(
() => ({
foo: true,
}),
{ name: 'name' },
),
),
)
const TestComponent = () => {
useBoundStore((s) => s.foo)
useBoundStore().foo
useBoundStore.getState().foo
useBoundStore.subscribe(
(state) => state.foo,
(foo) => console.log(foo),
)
useBoundStore.persist.hasHydrated()
return <></>
}
TestComponent
})
it('#631', () => {
type MyState = {
foo: number | null
}
const useBoundStore = create<MyState>()(
subscribeWithSelector(
() =>
({
foo: 1,
}) as MyState, // NOTE: Asserting the entire state works too.
),
)
const TestComponent = () => {
useBoundStore((s) => s.foo)
useBoundStore().foo
useBoundStore.getState().foo
useBoundStore.subscribe(
(state) => state.foo,
(foo) => console.log(foo),
)
return <></>
}
TestComponent
})
it('#650', () => {
type MyState = {
token: string | undefined
authenticated: boolean
authenticate: (username: string, password: string) => Promise<void>
}
const useBoundStore = create<MyState>()(
persist(
(set) => ({
token: undefined,
authenticated: false,
authenticate: async (_username, _password) => {
set({ authenticated: true })
},
}),
{ name: 'auth-store' },
),
)
const TestComponent = () => {
useBoundStore((s) => s.authenticated)
useBoundStore((s) => s.authenticate)('u', 'p')
useBoundStore().authenticated
useBoundStore().authenticate('u', 'p')
useBoundStore.getState().authenticated
useBoundStore.getState().authenticate('u', 'p')
return <></>
}
TestComponent
})
})
describe('create with explicitly annotated mutators', () => {
it('subscribeWithSelector & persist', () => {
const useBoundStore = create<
CounterState,
[
['zustand/subscribeWithSelector', never],
['zustand/persist', CounterState],
]
>(
subscribeWithSelector(
persist(
(set, get) => ({
count: 0,
inc: () => set({ count: get().count + 1 }, false),
}),
{ name: 'count' },
),
),
)
const TestComponent = () => {
useBoundStore((s) => s.count) * 2
useBoundStore((s) => s.inc)()
useBoundStore().count * 2
useBoundStore().inc()
useBoundStore.getState().count * 2
useBoundStore.getState().inc()
useBoundStore.subscribe(
(state) => state.count,
(count) => console.log(count * 2),
)
useBoundStore.setState({ count: 0 }, false)
useBoundStore.persist.hasHydrated()
return <></>
}
TestComponent
})
})
|
5,802 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/persistAsync.test.tsx | import { StrictMode, useEffect } from 'react'
import { act, render, waitFor } from '@testing-library/react'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { create } from 'zustand'
import { createJSONStorage, persist } from 'zustand/middleware'
import { replacer, reviver } from './test-utils'
const createPersistantStore = (initialValue: string | null) => {
let state = initialValue
const getItem = async (): Promise<string | null> => {
getItemSpy()
return state
}
const setItem = async (name: string, newState: string) => {
setItemSpy(name, newState)
state = newState
}
const removeItem = async (name: string) => {
removeItemSpy(name)
state = null
}
const getItemSpy = vi.fn()
const setItemSpy = vi.fn()
const removeItemSpy = vi.fn()
return {
storage: { getItem, setItem, removeItem },
getItemSpy,
setItemSpy,
removeItemSpy,
}
}
describe('persist middleware with async configuration', () => {
const consoleError = console.error
afterEach(() => {
console.error = consoleError
})
it('can rehydrate state', async () => {
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: async (name: string) =>
JSON.stringify({
state: { count: 42, name },
version: 0,
}),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(
() => ({
count: 0,
name: 'empty',
}),
{
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
},
),
)
function Counter() {
const { count, name } = useBoundStore()
return (
<div>
count: {count}, name: {name}
</div>
)
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0, name: empty')
await findByText('count: 42, name: test-storage')
expect(onRehydrateStorageSpy).toBeCalledWith(
{ count: 42, name: 'test-storage' },
undefined,
)
})
it('can throw rehydrate error', async () => {
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: async () => {
throw new Error('getItem error')
},
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
await waitFor(() => {
expect(onRehydrateStorageSpy).toBeCalledWith(
undefined,
new Error('getItem error'),
)
})
})
it('can persist state', async () => {
const { storage, setItemSpy } = createPersistantStore(null)
const createStore = () => {
const onRehydrateStorageSpy = vi.fn()
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
return { useBoundStore, onRehydrateStorageSpy }
}
// Initialize from empty storage
const { useBoundStore, onRehydrateStorageSpy } = createStore()
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
await waitFor(() => {
expect(onRehydrateStorageSpy).toBeCalledWith({ count: 0 }, undefined)
})
// Write something to the store
act(() => useBoundStore.setState({ count: 42 }))
await findByText('count: 42')
expect(setItemSpy).toBeCalledWith(
'test-storage',
JSON.stringify({ state: { count: 42 }, version: 0 }),
)
// Create the same store a second time and check if the persisted state
// is loaded correctly
const {
useBoundStore: useBoundStore2,
onRehydrateStorageSpy: onRehydrateStorageSpy2,
} = createStore()
function Counter2() {
const { count } = useBoundStore2()
return <div>count: {count}</div>
}
const { findByText: findByText2 } = render(
<StrictMode>
<Counter2 />
</StrictMode>,
)
await findByText2('count: 42')
await waitFor(() => {
expect(onRehydrateStorageSpy2).toBeCalledWith({ count: 42 }, undefined)
})
})
it('can migrate persisted state', async () => {
const setItemSpy = vi.fn()
const onRehydrateStorageSpy = vi.fn()
const migrateSpy = vi.fn(() => ({ count: 99 }))
const storage = {
getItem: async () =>
JSON.stringify({
state: { count: 42 },
version: 12,
}),
setItem: setItemSpy,
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
version: 13,
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
migrate: migrateSpy,
}),
)
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
await findByText('count: 99')
expect(migrateSpy).toBeCalledWith({ count: 42 }, 12)
expect(setItemSpy).toBeCalledWith(
'test-storage',
JSON.stringify({
state: { count: 99 },
version: 13,
}),
)
expect(onRehydrateStorageSpy).toBeCalledWith({ count: 99 }, undefined)
})
it('can merge partial persisted state', async () => {
const storage = {
getItem: async () =>
JSON.stringify({
state: { count: 42 },
}),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create<{
count: number
name: string
setName: (name: string) => void
}>()(
persist(
(set) => ({
count: 0,
name: 'unknown',
setName: (name: string) => {
set({ name })
},
}),
{
name: 'test-storage',
storage: createJSONStorage(() => storage),
},
),
)
function Component() {
const { count, setName, name } = useBoundStore()
useEffect(() => {
setName('test')
}, [setName])
return (
<div>
<div>count: {count}</div>
<div>name: {name}</div>
</div>
)
}
const { findByText } = render(
<StrictMode>
<Component />
</StrictMode>,
)
await findByText('count: 42')
await findByText('name: test')
expect(useBoundStore.getState()).toEqual(
expect.objectContaining({
count: 42,
name: 'test',
}),
)
})
it('can correclty handle a missing migrate function', async () => {
console.error = vi.fn()
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: async () =>
JSON.stringify({
state: { count: 42 },
version: 12,
}),
setItem: (_: string, _value: string) => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
version: 13,
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
await waitFor(() => {
expect(console.error).toHaveBeenCalled()
expect(onRehydrateStorageSpy).toBeCalledWith({ count: 0 }, undefined)
})
})
it('can throw migrate error', async () => {
console.error = vi.fn()
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: async () =>
JSON.stringify({
state: {},
version: 12,
}),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
version: 13,
storage: createJSONStorage(() => storage),
migrate: () => {
throw new Error('migrate error')
},
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
await waitFor(() => {
expect(onRehydrateStorageSpy).toBeCalledWith(
undefined,
new Error('migrate error'),
)
})
})
it('passes the latest state to onRehydrateStorage and onHydrate on first hydrate', async () => {
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: async () => JSON.stringify({ state: { count: 1 } }),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: onRehydrateStorageSpy,
}),
)
/**
* NOTE: It's currently not possible to add an 'onHydrate' listener which will be
* invoked prior to the first hydration. This is because, during first hydration,
* the 'onHydrate' listener set (which will be empty) is evaluated before the
* 'persist' API is exposed to the caller of 'create'/'createStore'.
*
* const onHydrateSpy = vi.fn()
* useBoundStore.persist.onHydrate(onHydrateSpy)
* ...
* await waitFor(() => expect(onHydrateSpy).toBeCalledWith({ count: 0 }))
*/
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
// The 'onRehydrateStorage' spy is invoked prior to rehydration, so it should
// be passed the default state.
await waitFor(() => {
expect(onRehydrateStorageSpy).toBeCalledWith({ count: 0 })
})
})
it('gives the merged state to onRehydrateStorage', async () => {
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: async () =>
JSON.stringify({
state: { count: 1 },
version: 0,
}),
setItem: () => {},
removeItem: () => {},
}
const unstorableMethod = () => {}
const useBoundStore = create(
persist(() => ({ count: 0, unstorableMethod }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 0')
await waitFor(() => {
expect(onRehydrateStorageSpy).toBeCalledWith(
{ count: 1, unstorableMethod },
undefined,
)
})
})
it('can custom merge the stored state', async () => {
const storage = {
getItem: async () =>
JSON.stringify({
state: {
count: 1,
actions: {},
},
version: 0,
}),
setItem: () => {},
removeItem: () => {},
}
const unstorableMethod = () => {}
const useBoundStore = create(
persist(() => ({ count: 0, actions: { unstorableMethod } }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
merge: (_persistedState, currentState) => {
const persistedState = _persistedState as any
delete persistedState.actions
return {
...currentState,
...persistedState,
}
},
}),
)
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
expect(useBoundStore.getState()).toEqual({
count: 1,
actions: {
unstorableMethod,
},
})
})
it("can merge the state when the storage item doesn't have a version", async () => {
const storage = {
getItem: async () =>
JSON.stringify({
state: {
count: 1,
},
}),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
}),
)
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 1')
expect(useBoundStore.getState()).toEqual({
count: 1,
})
})
it('can manually rehydrate through the api', async () => {
const storageValue = '{"state":{"count":1},"version":0}'
const storage = {
getItem: async () => '',
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
}),
)
storage.getItem = async () => storageValue
await useBoundStore.persist.rehydrate()
expect(useBoundStore.getState()).toEqual({
count: 1,
})
})
it('can check if the store has been hydrated through the api', async () => {
const storage = {
getItem: async () => null,
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
}),
)
expect(useBoundStore.persist.hasHydrated()).toBe(false)
await new Promise((resolve) =>
useBoundStore.persist.onFinishHydration(resolve),
)
expect(useBoundStore.persist.hasHydrated()).toBe(true)
await useBoundStore.persist.rehydrate()
expect(useBoundStore.persist.hasHydrated()).toBe(true)
})
it('can skip initial hydration', async () => {
const storage = {
getItem: async (name: string) => ({
state: { count: 42, name },
version: 0,
}),
setItem: () => {},
removeItem: () => {},
}
const onRehydrateStorageSpy = vi.fn()
const useBoundStore = create(
persist(
() => ({
count: 0,
name: 'empty',
}),
{
name: 'test-storage',
storage: storage,
onRehydrateStorage: () => onRehydrateStorageSpy,
skipHydration: true,
},
),
)
expect(useBoundStore.getState()).toEqual({
count: 0,
name: 'empty',
})
// Because `skipHydration` is only in newImpl and the hydration function for newImpl is now a promise
// In the default case we would need to await `onFinishHydration` to assert the auto hydration has completed
// As we are testing the skip hydration case we await nextTick, to make sure the store is initialised
await new Promise((resolve) => process.nextTick(resolve))
// Asserting store hasn't hydrated from nextTick
expect(useBoundStore.persist.hasHydrated()).toBe(false)
await useBoundStore.persist.rehydrate()
expect(useBoundStore.getState()).toEqual({
count: 42,
name: 'test-storage',
})
expect(onRehydrateStorageSpy).toBeCalledWith(
{ count: 42, name: 'test-storage' },
undefined,
)
})
it('handles state updates during onRehydrateStorage', async () => {
const storage = {
getItem: async () => JSON.stringify({ state: { count: 1 } }),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create<{ count: number; inc: () => void }>()(
persist(
(set) => ({
count: 0,
inc: () => set((s) => ({ count: s.count + 1 })),
}),
{
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => (s) => s?.inc(),
},
),
)
function Counter() {
const { count } = useBoundStore()
return <div>count: {count}</div>
}
const { findByText } = render(
<StrictMode>
<Counter />
</StrictMode>,
)
await findByText('count: 2')
expect(useBoundStore.getState().count).toEqual(2)
})
it('can rehydrate state with custom deserialized Map', async () => {
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: async () =>
JSON.stringify({
state: {
map: { type: 'Map', value: [['foo', 'bar']] },
},
}),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(
() => ({
map: new Map(),
}),
{
name: 'test-storage',
storage: createJSONStorage(() => storage, { replacer, reviver }),
onRehydrateStorage: () => onRehydrateStorageSpy,
},
),
)
function MapDisplay() {
const { map } = useBoundStore()
return <div>map: {map.get('foo')}</div>
}
const { findByText } = render(
<StrictMode>
<MapDisplay />
</StrictMode>,
)
await findByText('map: bar')
expect(onRehydrateStorageSpy).toBeCalledWith(
{ map: new Map([['foo', 'bar']]) },
undefined,
)
})
it('can persist state with custom serialization of Map', async () => {
const { storage, setItemSpy } = createPersistantStore(null)
const map = new Map()
const createStore = () => {
const onRehydrateStorageSpy = vi.fn()
const useBoundStore = create(
persist(() => ({ map }), {
name: 'test-storage',
storage: createJSONStorage(() => storage, { replacer, reviver }),
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
return { useBoundStore, onRehydrateStorageSpy }
}
// Initialize from empty storage
const { useBoundStore, onRehydrateStorageSpy } = createStore()
function MapDisplay() {
const { map } = useBoundStore()
return <div>map-content: {map.get('foo')}</div>
}
const { findByText } = render(
<StrictMode>
<MapDisplay />
</StrictMode>,
)
await findByText('map-content:')
await waitFor(() => {
expect(onRehydrateStorageSpy).toBeCalledWith({ map }, undefined)
})
// Write something to the store
const updatedMap = new Map(map).set('foo', 'bar')
act(() => useBoundStore.setState({ map: updatedMap }))
await findByText('map-content: bar')
expect(setItemSpy).toBeCalledWith(
'test-storage',
JSON.stringify({
state: { map: { type: 'Map', value: [['foo', 'bar']] } },
version: 0,
}),
)
// Create the same store a second time and check if the persisted state
// is loaded correctly
const {
useBoundStore: useBoundStore2,
onRehydrateStorageSpy: onRehydrateStorageSpy2,
} = createStore()
function MapDisplay2() {
const { map } = useBoundStore2()
return <div>map-content: {map.get('foo')}</div>
}
const { findByText: findByText2 } = render(
<StrictMode>
<MapDisplay2 />
</StrictMode>,
)
await findByText2('map-content: bar')
await waitFor(() => {
expect(onRehydrateStorageSpy2).toBeCalledWith(
{ map: updatedMap },
undefined,
)
})
})
})
|
5,803 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/persistSync.test.tsx | import { afterEach, describe, expect, it, vi } from 'vitest'
import { create } from 'zustand'
import { createJSONStorage, persist } from 'zustand/middleware'
import { replacer, reviver } from './test-utils'
const createPersistentStore = (initialValue: string | null) => {
let state = initialValue
const getItem = (): string | null => {
getItemSpy()
return state
}
const setItem = (name: string, newState: string) => {
setItemSpy(name, newState)
state = newState
}
const removeItem = (name: string) => {
removeItemSpy(name)
state = null
}
const getItemSpy = vi.fn()
const setItemSpy = vi.fn()
const removeItemSpy = vi.fn()
return {
storage: { getItem, setItem, removeItem },
getItemSpy,
setItemSpy,
}
}
describe('persist middleware with sync configuration', () => {
const consoleError = console.error
afterEach(() => {
console.error = consoleError
})
it('can rehydrate state', () => {
const storage = {
getItem: (name: string) =>
JSON.stringify({
state: { count: 42, name },
version: 0,
}),
setItem: () => {},
removeItem: () => {},
}
const onRehydrateStorageSpy = vi.fn()
const useBoundStore = create(
persist(
() => ({
count: 0,
name: 'empty',
}),
{
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
},
),
)
expect(useBoundStore.getState()).toEqual({
count: 42,
name: 'test-storage',
})
expect(onRehydrateStorageSpy).toBeCalledWith(
{ count: 42, name: 'test-storage' },
undefined,
)
})
it('can throw rehydrate error', () => {
const storage = {
getItem: () => {
throw new Error('getItem error')
},
setItem: () => {},
removeItem: () => {},
}
const spy = vi.fn()
create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => spy,
}),
)
expect(spy).toBeCalledWith(undefined, new Error('getItem error'))
})
it('can persist state', () => {
const { storage, setItemSpy } = createPersistentStore(null)
const createStore = () => {
const onRehydrateStorageSpy = vi.fn()
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
return { useBoundStore, onRehydrateStorageSpy }
}
// Initialize from empty storage
const { useBoundStore, onRehydrateStorageSpy } = createStore()
expect(useBoundStore.getState()).toEqual({ count: 0 })
expect(onRehydrateStorageSpy).toBeCalledWith({ count: 0 }, undefined)
// Write something to the store
useBoundStore.setState({ count: 42 })
expect(useBoundStore.getState()).toEqual({ count: 42 })
expect(setItemSpy).toBeCalledWith(
'test-storage',
JSON.stringify({ state: { count: 42 }, version: 0 }),
)
// Create the same store a second time and check if the persisted state
// is loaded correctly
const {
useBoundStore: useBoundStore2,
onRehydrateStorageSpy: onRehydrateStorageSpy2,
} = createStore()
expect(useBoundStore2.getState()).toEqual({ count: 42 })
expect(onRehydrateStorageSpy2).toBeCalledWith({ count: 42 }, undefined)
})
it('can migrate persisted state', () => {
const setItemSpy = vi.fn()
const onRehydrateStorageSpy = vi.fn()
const migrateSpy = vi.fn(() => ({ count: 99 }))
const storage = {
getItem: () =>
JSON.stringify({
state: { count: 42 },
version: 12,
}),
setItem: setItemSpy,
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
version: 13,
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
migrate: migrateSpy,
}),
)
expect(useBoundStore.getState()).toEqual({ count: 99 })
expect(migrateSpy).toBeCalledWith({ count: 42 }, 12)
expect(setItemSpy).toBeCalledWith(
'test-storage',
JSON.stringify({
state: { count: 99 },
version: 13,
}),
)
expect(onRehydrateStorageSpy).toBeCalledWith({ count: 99 }, undefined)
})
it('can correclty handle a missing migrate function', () => {
console.error = vi.fn()
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: () =>
JSON.stringify({
state: { count: 42 },
version: 12,
}),
setItem: (_: string, _value: string) => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
version: 13,
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
expect(useBoundStore.getState()).toEqual({ count: 0 })
expect(console.error).toHaveBeenCalled()
expect(onRehydrateStorageSpy).toBeCalledWith({ count: 0 }, undefined)
})
it('can throw migrate error', () => {
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: () =>
JSON.stringify({
state: {},
version: 12,
}),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
version: 13,
storage: createJSONStorage(() => storage),
migrate: () => {
throw new Error('migrate error')
},
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
expect(useBoundStore.getState()).toEqual({ count: 0 })
expect(onRehydrateStorageSpy).toBeCalledWith(
undefined,
new Error('migrate error'),
)
})
it('passes the latest state to onRehydrateStorage and onHydrate on first hydrate', () => {
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: () => JSON.stringify({ state: { count: 1 } }),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: onRehydrateStorageSpy,
}),
)
/**
* NOTE: It's currently not possible to add an 'onHydrate' listener which will be
* invoked prior to the first hydration. This is because, during first hydration,
* the 'onHydrate' listener set (which will be empty) is evaluated before the
* 'persist' API is exposed to the caller of 'create'/'createStore'.
*
* const onHydrateSpy = vi.fn()
* useBoundStore.persist.onHydrate(onHydrateSpy)
* expect(onHydrateSpy).toBeCalledWith({ count: 0 })
*/
// The 'onRehydrateStorage' and 'onHydrate' spies are invoked prior to rehydration,
// so they should both be passed the default state.
expect(onRehydrateStorageSpy).toBeCalledWith({ count: 0 })
expect(useBoundStore.getState()).toEqual({ count: 1 })
})
it('gives the merged state to onRehydrateStorage', () => {
const onRehydrateStorageSpy = vi.fn()
const storage = {
getItem: () =>
JSON.stringify({
state: { count: 1 },
version: 0,
}),
setItem: () => {},
removeItem: () => {},
}
const unstorableMethod = () => {}
const useBoundStore = create(
persist(() => ({ count: 0, unstorableMethod }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
const expectedState = { count: 1, unstorableMethod }
expect(useBoundStore.getState()).toEqual(expectedState)
expect(onRehydrateStorageSpy).toBeCalledWith(expectedState, undefined)
})
it('can custom merge the stored state', () => {
const storage = {
getItem: () =>
JSON.stringify({
state: {
count: 1,
actions: {},
},
version: 0,
}),
setItem: () => {},
removeItem: () => {},
}
const unstorableMethod = () => {}
const useBoundStore = create(
persist(() => ({ count: 0, actions: { unstorableMethod } }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
merge: (_persistedState, currentState) => {
const persistedState = _persistedState as any
delete persistedState.actions
return {
...currentState,
...persistedState,
}
},
}),
)
expect(useBoundStore.getState()).toEqual({
count: 1,
actions: {
unstorableMethod,
},
})
})
it("can merge the state when the storage item doesn't have a version", () => {
const storage = {
getItem: () =>
JSON.stringify({
state: {
count: 1,
},
}),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
}),
)
expect(useBoundStore.getState()).toEqual({
count: 1,
})
})
it('can filter the persisted value', () => {
const setItemSpy = vi.fn()
const storage = {
getItem: () => '',
setItem: setItemSpy,
removeItem: () => {},
}
const useBoundStore = create(
persist(
() => ({
object: {
first: '0',
second: '1',
},
array: [
{
value: '0',
},
{
value: '1',
},
{
value: '2',
},
],
}),
{
name: 'test-storage',
storage: createJSONStorage(() => storage),
partialize: (state) => {
return {
object: {
first: state.object.first,
},
array: state.array.filter((e) => e.value !== '1'),
}
},
},
),
)
useBoundStore.setState({})
expect(setItemSpy).toBeCalledWith(
'test-storage',
JSON.stringify({
state: {
object: {
first: '0',
},
array: [
{
value: '0',
},
{
value: '2',
},
],
},
version: 0,
}),
)
})
it('can access the options through the api', () => {
const storage = {
getItem: () => null,
setItem: vi.fn(),
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
}),
)
expect(useBoundStore.persist.getOptions().name).toBeDefined()
expect(useBoundStore.persist.getOptions().name).toBe('test-storage')
})
it('can change the options through the api', () => {
const setItemSpy = vi.fn()
const storage = {
getItem: () => null,
setItem: setItemSpy,
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
partialize: (s) => s as Partial<typeof s>,
}),
)
useBoundStore.setState({})
expect(setItemSpy).toBeCalledWith(
'test-storage',
'{"state":{"count":0},"version":0}',
)
useBoundStore.persist.setOptions({
name: 'test-storage-2',
partialize: (state) =>
Object.fromEntries(
Object.entries(state).filter(([key]) => key !== 'count'),
),
})
useBoundStore.setState({})
expect(setItemSpy).toBeCalledWith(
'test-storage-2',
'{"state":{},"version":0}',
)
})
it('can clear the storage through the api', () => {
const removeItemSpy = vi.fn()
const storage = {
getItem: () => null,
setItem: () => {},
removeItem: removeItemSpy,
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
}),
)
useBoundStore.persist.clearStorage()
expect(removeItemSpy).toBeCalledWith('test-storage')
})
it('can manually rehydrate through the api', () => {
const storageValue = '{"state":{"count":1},"version":0}'
const storage = {
getItem: () => '',
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
}),
)
storage.getItem = () => storageValue
useBoundStore.persist.rehydrate()
expect(useBoundStore.getState()).toEqual({
count: 1,
})
})
it('can check if the store has been hydrated through the api', async () => {
const storage = {
getItem: () => null,
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
}),
)
expect(useBoundStore.persist.hasHydrated()).toBe(true)
await useBoundStore.persist.rehydrate()
expect(useBoundStore.persist.hasHydrated()).toBe(true)
})
it('can wait for rehydration through the api', async () => {
const storageValue1 = '{"state":{"count":1},"version":0}'
const storageValue2 = '{"state":{"count":2},"version":0}'
const onHydrateSpy1 = vi.fn()
const onHydrateSpy2 = vi.fn()
const onFinishHydrationSpy1 = vi.fn()
const onFinishHydrationSpy2 = vi.fn()
const storage = {
getItem: () => '',
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create(
persist(() => ({ count: 0 }), {
name: 'test-storage',
storage: createJSONStorage(() => storage),
}),
)
const hydrateUnsub1 = useBoundStore.persist.onHydrate(onHydrateSpy1)
useBoundStore.persist.onHydrate(onHydrateSpy2)
const finishHydrationUnsub1 = useBoundStore.persist.onFinishHydration(
onFinishHydrationSpy1,
)
useBoundStore.persist.onFinishHydration(onFinishHydrationSpy2)
storage.getItem = () => storageValue1
await useBoundStore.persist.rehydrate()
expect(onHydrateSpy1).toBeCalledWith({ count: 0 })
expect(onHydrateSpy2).toBeCalledWith({ count: 0 })
expect(onFinishHydrationSpy1).toBeCalledWith({ count: 1 })
expect(onFinishHydrationSpy2).toBeCalledWith({ count: 1 })
hydrateUnsub1()
finishHydrationUnsub1()
storage.getItem = () => storageValue2
await useBoundStore.persist.rehydrate()
expect(onHydrateSpy1).not.toBeCalledTimes(2)
expect(onHydrateSpy2).toBeCalledWith({ count: 1 })
expect(onFinishHydrationSpy1).not.toBeCalledTimes(2)
expect(onFinishHydrationSpy2).toBeCalledWith({ count: 2 })
})
it('can skip initial hydration', async () => {
const storage = {
getItem: (name: string) => ({
state: { count: 42, name },
version: 0,
}),
setItem: () => {},
removeItem: () => {},
}
const onRehydrateStorageSpy = vi.fn()
const useBoundStore = create(
persist(
() => ({
count: 0,
name: 'empty',
}),
{
name: 'test-storage',
storage: storage,
onRehydrateStorage: () => onRehydrateStorageSpy,
skipHydration: true,
},
),
)
expect(useBoundStore.getState()).toEqual({
count: 0,
name: 'empty',
})
// Because `skipHydration` is only in newImpl and the hydration function for newImpl is now a promise
// In the default case we would need to await `onFinishHydration` to assert the auto hydration has completed
// As we are testing the skip hydration case we await nextTick, to make sure the store is initialised
await new Promise((resolve) => process.nextTick(resolve))
// Asserting store hasn't hydrated from nextTick
expect(useBoundStore.persist.hasHydrated()).toBe(false)
await useBoundStore.persist.rehydrate()
expect(useBoundStore.getState()).toEqual({
count: 42,
name: 'test-storage',
})
expect(onRehydrateStorageSpy).toBeCalledWith(
{ count: 42, name: 'test-storage' },
undefined,
)
})
it('handles state updates during onRehydrateStorage', () => {
const storage = {
getItem: () => JSON.stringify({ state: { count: 1 } }),
setItem: () => {},
removeItem: () => {},
}
const useBoundStore = create<{ count: number; inc: () => void }>()(
persist(
(set) => ({
count: 0,
inc: () => set((s) => ({ count: s.count + 1 })),
}),
{
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => (s) => s?.inc(),
},
),
)
expect(useBoundStore.getState().count).toEqual(2)
})
it('can rehydrate state with custom deserialized Map', () => {
const storage = {
getItem: () =>
JSON.stringify({
map: { type: 'Map', value: [['foo', 'bar']] },
}),
setItem: () => {},
removeItem: () => {},
}
const map = new Map()
const onRehydrateStorageSpy = vi.fn()
const useBoundStore = create(
persist(
() => ({
map,
}),
{
name: 'test-storage',
storage: createJSONStorage(() => storage),
onRehydrateStorage: () => onRehydrateStorageSpy,
},
),
)
const updatedMap = map.set('foo', 'bar')
expect(useBoundStore.getState()).toEqual({
map: updatedMap,
})
expect(onRehydrateStorageSpy).toBeCalledWith({ map: updatedMap }, undefined)
})
it('can persist state with custom serialization of Map', () => {
const { storage, setItemSpy } = createPersistentStore(null)
const map = new Map()
const createStore = () => {
const onRehydrateStorageSpy = vi.fn()
const useBoundStore = create(
persist(() => ({ map }), {
name: 'test-storage',
storage: createJSONStorage(() => storage, { replacer, reviver }),
onRehydrateStorage: () => onRehydrateStorageSpy,
}),
)
return { useBoundStore, onRehydrateStorageSpy }
}
// Initialize from empty storage
const { useBoundStore, onRehydrateStorageSpy } = createStore()
expect(useBoundStore.getState()).toEqual({ map })
expect(onRehydrateStorageSpy).toBeCalledWith({ map }, undefined)
// Write something to the store
const updatedMap = map.set('foo', 'bar')
useBoundStore.setState({ map: updatedMap })
expect(useBoundStore.getState()).toEqual({
map: updatedMap,
})
expect(setItemSpy).toBeCalledWith(
'test-storage',
JSON.stringify({
state: { map: { type: 'Map', value: [['foo', 'bar']] } },
version: 0,
}),
)
// Create the same store a second time and check if the persisted state
// is loaded correctly
const {
useBoundStore: useBoundStore2,
onRehydrateStorageSpy: onRehydrateStorageSpy2,
} = createStore()
expect(useBoundStore2.getState()).toEqual({ map: updatedMap })
expect(onRehydrateStorageSpy2).toBeCalledWith(
{ map: updatedMap },
undefined,
)
})
})
|
5,804 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/shallow.test.tsx | import { useState } from 'react'
import { act, fireEvent, render } from '@testing-library/react'
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { create } from 'zustand'
import { useShallow } from 'zustand/react/shallow'
import { shallow } from 'zustand/vanilla/shallow'
describe('types', () => {
it('works with useBoundStore and array selector (#1107)', () => {
const useBoundStore = create(() => ({
villages: [] as { name: string }[],
}))
const Component = () => {
const villages = useBoundStore((state) => state.villages, shallow)
return <>{villages.length}</>
}
expect(Component).toBeDefined()
})
it('works with useBoundStore and string selector (#1107)', () => {
const useBoundStore = create(() => ({
refetchTimestamp: '',
}))
const Component = () => {
const refetchTimestamp = useBoundStore(
(state) => state.refetchTimestamp,
shallow,
)
return <>{refetchTimestamp.toUpperCase()}</>
}
expect(Component).toBeDefined()
})
})
describe('useShallow', () => {
const testUseShallowSimpleCallback =
vi.fn<[{ selectorOutput: string[]; useShallowOutput: string[] }]>()
const TestUseShallowSimple = ({
selector,
state,
}: {
state: Record<string, unknown>
selector: (state: Record<string, unknown>) => string[]
}) => {
const selectorOutput = selector(state)
const useShallowOutput = useShallow(selector)(state)
return (
<div
data-testid="test-shallow"
onClick={() =>
testUseShallowSimpleCallback({ selectorOutput, useShallowOutput })
}
/>
)
}
beforeEach(() => {
testUseShallowSimpleCallback.mockClear()
})
it('input and output selectors always return shallow equal values', () => {
const res = render(
<TestUseShallowSimple state={{ a: 1, b: 2 }} selector={Object.keys} />,
)
expect(testUseShallowSimpleCallback).toHaveBeenCalledTimes(0)
fireEvent.click(res.getByTestId('test-shallow'))
const firstRender = testUseShallowSimpleCallback.mock.lastCall?.[0]
expect(testUseShallowSimpleCallback).toHaveBeenCalledTimes(1)
expect(firstRender).toBeTruthy()
expect(firstRender?.selectorOutput).toEqual(firstRender?.useShallowOutput)
res.rerender(
<TestUseShallowSimple
state={{ a: 1, b: 2, c: 3 }}
selector={Object.keys}
/>,
)
fireEvent.click(res.getByTestId('test-shallow'))
expect(testUseShallowSimpleCallback).toHaveBeenCalledTimes(2)
const secondRender = testUseShallowSimpleCallback.mock.lastCall?.[0]
expect(secondRender).toBeTruthy()
expect(secondRender?.selectorOutput).toEqual(secondRender?.useShallowOutput)
})
it('returns the previously computed instance when possible', () => {
const state = { a: 1, b: 2 }
const res = render(
<TestUseShallowSimple state={state} selector={Object.keys} />,
)
fireEvent.click(res.getByTestId('test-shallow'))
expect(testUseShallowSimpleCallback).toHaveBeenCalledTimes(1)
const output1 =
testUseShallowSimpleCallback.mock.lastCall?.[0]?.useShallowOutput
expect(output1).toBeTruthy()
// Change selector, same output
res.rerender(
<TestUseShallowSimple
state={state}
selector={(state) => Object.keys(state)}
/>,
)
fireEvent.click(res.getByTestId('test-shallow'))
expect(testUseShallowSimpleCallback).toHaveBeenCalledTimes(2)
const output2 =
testUseShallowSimpleCallback.mock.lastCall?.[0]?.useShallowOutput
expect(output2).toBeTruthy()
expect(output2).toBe(output1)
})
it('only re-renders if selector output has changed according to shallow', () => {
let countRenders = 0
const useMyStore = create(
(): Record<string, unknown> => ({ a: 1, b: 2, c: 3 }),
)
const TestShallow = ({
selector = (state) => Object.keys(state).sort(),
}: {
selector?: (state: Record<string, unknown>) => string[]
}) => {
const output = useMyStore(useShallow(selector))
++countRenders
return <div data-testid="test-shallow">{output.join(',')}</div>
}
expect(countRenders).toBe(0)
const res = render(<TestShallow />)
expect(countRenders).toBe(1)
expect(res.getByTestId('test-shallow').textContent).toBe('a,b,c')
act(() => {
useMyStore.setState({ a: 4 }) // This will not cause a re-render.
})
expect(countRenders).toBe(1)
act(() => {
useMyStore.setState({ d: 10 }) // This will cause a re-render.
})
expect(countRenders).toBe(2)
expect(res.getByTestId('test-shallow').textContent).toBe('a,b,c,d')
})
it('does not cause stale closure issues', () => {
const useMyStore = create(
(): Record<string, unknown> => ({ a: 1, b: 2, c: 3 }),
)
const TestShallowWithState = () => {
const [count, setCount] = useState(0)
const output = useMyStore(
useShallow((state) => Object.keys(state).concat([count.toString()])),
)
return (
<div
data-testid="test-shallow"
onClick={() => setCount((prev) => ++prev)}
>
{output.join(',')}
</div>
)
}
const res = render(<TestShallowWithState />)
expect(res.getByTestId('test-shallow').textContent).toBe('a,b,c,0')
fireEvent.click(res.getByTestId('test-shallow'))
expect(res.getByTestId('test-shallow').textContent).toBe('a,b,c,1')
})
})
|
5,805 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/ssr.test.tsx | import React, { useEffect } from 'react'
import { act, screen } from '@testing-library/react'
import { renderToString } from 'react-dom/server'
import { describe, expect, it, vi } from 'vitest'
import { create } from 'zustand'
interface BearStoreState {
bears: number
}
interface BearStoreAction {
increasePopulation: () => void
}
const initialState = { bears: 0 }
const useBearStore = create<BearStoreState & BearStoreAction>((set) => ({
...initialState,
increasePopulation: () => set(({ bears }) => ({ bears: bears + 1 })),
}))
function Counter() {
const { bears, increasePopulation } = useBearStore(
({ bears, increasePopulation }) => ({
bears,
increasePopulation,
}),
)
useEffect(() => {
increasePopulation()
}, [increasePopulation])
return <div>bears: {bears}</div>
}
describe.skipIf(!React.version.startsWith('18'))(
'ssr behavior with react 18',
() => {
it('should handle different states between server and client correctly', async () => {
const { hydrateRoot } =
await vi.importActual<typeof import('react-dom/client')>(
'react-dom/client',
)
const markup = renderToString(
<React.Suspense fallback={<div>Loading...</div>}>
<Counter />
</React.Suspense>,
)
const container = document.createElement('div')
document.body.appendChild(container)
container.innerHTML = markup
expect(container.textContent).toContain('bears: 0')
await act(async () => {
hydrateRoot(
container,
<React.Suspense fallback={<div>Loading...</div>}>
<Counter />
</React.Suspense>,
)
})
const bearCountText = await screen.findByText('bears: 1')
expect(bearCountText).not.toBeNull()
document.body.removeChild(container)
})
},
)
|
5,806 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/subscribe.test.tsx | import { describe, expect, it, vi } from 'vitest'
import { create } from 'zustand'
import { subscribeWithSelector } from 'zustand/middleware'
describe('subscribe()', () => {
it('should not be called if new state identity is the same', () => {
const spy = vi.fn()
const initialState = { value: 1, other: 'a' }
const { setState, subscribe } = create(() => initialState)
subscribe(spy)
setState(initialState)
expect(spy).not.toHaveBeenCalled()
})
it('should be called if new state identity is different', () => {
const spy = vi.fn()
const initialState = { value: 1, other: 'a' }
const { setState, getState, subscribe } = create(() => initialState)
subscribe(spy)
setState({ ...getState() })
expect(spy).toHaveBeenCalledWith(initialState, initialState)
})
it('should not be called when state slice is the same', () => {
const spy = vi.fn()
const initialState = { value: 1, other: 'a' }
const { setState, subscribe } = create(
subscribeWithSelector(() => initialState),
)
subscribe((s) => s.value, spy)
setState({ other: 'b' })
expect(spy).not.toHaveBeenCalled()
})
it('should be called when state slice changes', () => {
const spy = vi.fn()
const initialState = { value: 1, other: 'a' }
const { setState, subscribe } = create(
subscribeWithSelector(() => initialState),
)
subscribe((s) => s.value, spy)
setState({ value: initialState.value + 1 })
expect(spy).toHaveBeenCalledTimes(1)
expect(spy).toHaveBeenCalledWith(initialState.value + 1, initialState.value)
})
it('should not be called when equality checker returns true', () => {
const spy = vi.fn()
const initialState = { value: 1, other: 'a' }
const { setState, subscribe } = create(
subscribeWithSelector(() => initialState),
)
subscribe((s) => s, spy, { equalityFn: () => true })
setState({ value: initialState.value + 2 })
expect(spy).not.toHaveBeenCalled()
})
it('should be called when equality checker returns false', () => {
const spy = vi.fn()
const initialState = { value: 1, other: 'a' }
const { setState, subscribe } = create(
subscribeWithSelector(() => initialState),
)
subscribe((s) => s.value, spy, { equalityFn: () => false })
setState({ value: initialState.value + 2 })
expect(spy).toHaveBeenCalledTimes(1)
expect(spy).toHaveBeenCalledWith(initialState.value + 2, initialState.value)
})
it('should unsubscribe correctly', () => {
const spy = vi.fn()
const initialState = { value: 1, other: 'a' }
const { setState, subscribe } = create(
subscribeWithSelector(() => initialState),
)
const unsub = subscribe((s) => s.value, spy)
setState({ value: initialState.value + 1 })
unsub()
setState({ value: initialState.value + 2 })
expect(spy).toHaveBeenCalledTimes(1)
expect(spy).toHaveBeenCalledWith(initialState.value + 1, initialState.value)
})
it('should keep consistent behavior with equality check', () => {
const spy = vi.fn()
const initialState = { value: 1, other: 'a' }
const { getState, setState, subscribe } = create(
subscribeWithSelector(() => initialState),
)
const isRoughEqual = (x: number, y: number) => Math.abs(x - y) < 1
setState({ value: 0 })
spy.mockReset()
const spy2 = vi.fn()
let prevValue = getState().value
const unsub = subscribe((s) => {
if (isRoughEqual(prevValue, s.value)) {
// skip assuming values are equal
return
}
spy(s.value, prevValue)
prevValue = s.value
})
const unsub2 = subscribe((s) => s.value, spy2, { equalityFn: isRoughEqual })
setState({ value: 0.5 })
setState({ value: 1 })
unsub()
unsub2()
expect(spy).toHaveBeenCalledTimes(1)
expect(spy).toHaveBeenCalledWith(1, 0)
expect(spy2).toHaveBeenCalledTimes(1)
expect(spy2).toHaveBeenCalledWith(1, 0)
})
})
|
5,808 | 0 | petrpan-code/pmndrs/zustand | petrpan-code/pmndrs/zustand/tests/types.test.tsx | import { expect, it } from 'vitest'
import { create } from 'zustand'
import type {
StateCreator,
StoreApi,
StoreMutatorIdentifier,
UseBoundStore,
} from 'zustand'
import { persist } from 'zustand/middleware'
it('can use exposed types', () => {
type ExampleState = {
num: number
numGet: () => number
numGetState: () => number
numSet: (v: number) => void
numSetState: (v: number) => void
}
const listener = (state: ExampleState) => {
if (state) {
const value = state.num * state.numGet() * state.numGetState()
state.numSet(value)
state.numSetState(value)
}
}
const selector = (state: ExampleState) => state.num
const partial: Partial<ExampleState> = {
num: 2,
numGet: () => 2,
}
const partialFn: (state: ExampleState) => Partial<ExampleState> = (
state,
) => ({
...state,
num: 2,
})
const equalityFn = (state: ExampleState, newState: ExampleState) =>
state !== newState
const storeApi = create<ExampleState>((set, get) => ({
num: 1,
numGet: () => get().num,
numGetState: () => {
// TypeScript can't get the type of storeApi when it trys to enforce the signature of numGetState.
// Need to explicitly state the type of storeApi.getState().num or storeApi type will be type 'any'.
const result: number = storeApi.getState().num
return result
},
numSet: (v) => {
set({ num: v })
},
numSetState: (v) => {
storeApi.setState({ num: v })
},
}))
const useBoundStore = storeApi
const stateCreator: StateCreator<ExampleState> = (set, get) => ({
num: 1,
numGet: () => get().num,
numGetState: () => get().num,
numSet: (v) => {
set({ num: v })
},
numSetState: (v) => {
set({ num: v })
},
})
function checkAllTypes(
_getState: StoreApi<ExampleState>['getState'],
_partialState:
| Partial<ExampleState>
| ((s: ExampleState) => Partial<ExampleState>),
_setState: StoreApi<ExampleState>['setState'],
_state: object,
_stateListener: (state: ExampleState, previousState: ExampleState) => void,
_stateSelector: (state: ExampleState) => number,
_storeApi: StoreApi<ExampleState>,
_subscribe: StoreApi<ExampleState>['subscribe'],
_destroy: StoreApi<ExampleState>['destroy'],
_equalityFn: (a: ExampleState, b: ExampleState) => boolean,
_stateCreator: StateCreator<ExampleState>,
_useBoundStore: UseBoundStore<StoreApi<ExampleState>>,
) {
expect(true).toBeTruthy()
}
checkAllTypes(
storeApi.getState,
Math.random() > 0.5 ? partial : partialFn,
storeApi.setState,
storeApi.getState(),
listener,
selector,
storeApi,
storeApi.subscribe,
storeApi.destroy,
equalityFn,
stateCreator,
useBoundStore,
)
})
type AssertEqual<Type, Expected> = Type extends Expected
? Expected extends Type
? true
: never
: never
it('should have correct (partial) types for setState', () => {
type Count = { count: number }
const store = create<Count>((set) => ({
count: 0,
// @ts-expect-error we shouldn't be able to set count to undefined [LATEST-TS-ONLY]
a: () => set(() => ({ count: undefined })),
// @ts-expect-error we shouldn't be able to set count to undefined [LATEST-TS-ONLY]
b: () => set({ count: undefined }),
c: () => set({ count: 1 }),
}))
const setState: AssertEqual<
typeof store.setState,
StoreApi<Count>['setState']
> = true
expect(setState).toEqual(true)
// ok, should not error
store.setState({ count: 1 })
store.setState({})
store.setState((previous) => previous)
// @ts-expect-error type undefined is not assignable to type number [LATEST-TS-ONLY]
store.setState({ count: undefined })
// @ts-expect-error type undefined is not assignable to type number [LATEST-TS-ONLY]
store.setState((state) => ({ ...state, count: undefined }))
})
it('should allow for different partial keys to be returnable from setState', () => {
type State = {
count: number
something: string
}
const store = create<State>(() => ({
count: 0,
something: 'foo',
}))
const setState: AssertEqual<
typeof store.setState,
StoreApi<State>['setState']
> = true
expect(setState).toEqual(true)
// ok, should not error
store.setState((previous) => {
if (previous.count === 0) {
return { count: 1 }
}
return { count: 0 }
})
store.setState((previous) => {
if (previous.count === 0) {
return { count: 1 }
}
if (previous.count === 1) {
return previous
}
return { something: 'foo' }
})
// @ts-expect-error Type '{ something: boolean; count?: undefined; }' is not assignable to type 'State'.
store.setState((previous) => {
if (previous.count === 0) {
return { count: 1 }
}
return { something: true }
})
})
it('state is covariant', () => {
const store = create<{ count: number; foo: string }>()(() => ({
count: 0,
foo: '',
}))
const _testIsCovariant: StoreApi<{ count: number }> = store
// @ts-expect-error should not compile
const _testIsNotContravariant: StoreApi<{
count: number
foo: string
baz: string
}> = store
})
it('StateCreator<T, [StoreMutatorIdentfier, unknown][]> is StateCreator<T, []>', () => {
interface State {
count: number
increment: () => void
}
const foo: <M extends [StoreMutatorIdentifier, unknown][]>() => StateCreator<
State,
M
> = () => (set, get) => ({
count: 0,
increment: () => {
set({ count: get().count + 1 })
},
})
create<State>()(persist(foo(), { name: 'prefix' }))
})
it('StateCreator subtyping', () => {
interface State {
count: number
increment: () => void
}
const foo: () => StateCreator<State, []> = () => (set, get) => ({
count: 0,
increment: () => {
set({ count: get().count + 1 })
},
})
create<State>()(persist(foo(), { name: 'prefix' }))
const _testSubtyping: StateCreator<State, [['zustand/persist', unknown]]> =
{} as StateCreator<State, []>
})
it('set state exists on store with readonly store', () => {
interface State {
count: number
increment: () => void
}
const useStore = create<State>()((set, get) => ({
count: 0,
increment: () => set({ count: get().count + 1 }),
}))
useStore.setState((state) => ({ ...state, count: state.count + 1 }))
})
|
5,809 | 0 | petrpan-code/pmndrs/zustand/tests | petrpan-code/pmndrs/zustand/tests/vanilla/basic.test.ts | import { afterEach, expect, it, vi } from 'vitest'
import { createStore } from 'zustand/vanilla'
import type { StoreApi } from 'zustand/vanilla'
// To avoid include react deps on vanilla version
vi.mock('react', () => ({}))
const consoleError = console.error
afterEach(() => {
console.error = consoleError
})
it('create a store', () => {
let params
const result = createStore((...args) => {
params = args
return { value: null }
})
expect({ params, result }).toMatchInlineSnapshot(`
{
"params": [
[Function],
[Function],
{
"destroy": [Function],
"getState": [Function],
"setState": [Function],
"subscribe": [Function],
},
],
"result": {
"destroy": [Function],
"getState": [Function],
"setState": [Function],
"subscribe": [Function],
},
}
`)
})
type CounterState = {
count: number
inc: () => void
}
it('uses the store', async () => {
const store = createStore<CounterState>((set) => ({
count: 0,
inc: () => set((state) => ({ count: state.count + 1 })),
}))
store.getState().inc()
expect(store.getState().count).toBe(1)
})
it('can get the store', async () => {
type State = {
value: number
getState1: () => State
getState2: () => State
}
const store = createStore<State>((_, get) => ({
value: 1,
getState1: () => get(),
getState2: (): State => store.getState(),
}))
expect(store.getState().getState1().value).toBe(1)
expect(store.getState().getState2().value).toBe(1)
})
it('can set the store', async () => {
type State = {
value: number
setState1: StoreApi<State>['setState']
setState2: StoreApi<State>['setState']
}
const store = createStore<State>((set) => ({
value: 1,
setState1: (v) => set(v),
setState2: (v): void => store.setState(v),
}))
store.getState().setState1({ value: 2 })
expect(store.getState().value).toBe(2)
store.getState().setState2({ value: 3 })
expect(store.getState().value).toBe(3)
})
it('both NaN should not update', () => {
const store = createStore<number>(() => NaN)
const fn = vi.fn()
store.subscribe(fn)
store.setState(NaN)
expect(fn).not.toBeCalled()
})
it('can set the store without merging', () => {
const { setState, getState } = createStore<{ a: number } | { b: number }>(
(_set) => ({
a: 1,
}),
)
// Should override the state instead of merging.
setState({ b: 2 }, true)
expect(getState()).toEqual({ b: 2 })
})
it('works with non-object state', () => {
const store = createStore<number>(() => 1)
const inc = () => store.setState((c) => c + 1)
inc()
expect(store.getState()).toBe(2)
})
it('can destroy the store', () => {
const { destroy, getState, setState, subscribe } = createStore(() => ({
value: 1,
}))
subscribe(() => {
throw new Error('did not clear listener on destroy')
})
destroy()
setState({ value: 2 })
expect(getState().value).toEqual(2)
})
|
5,810 | 0 | petrpan-code/pmndrs/zustand/tests | petrpan-code/pmndrs/zustand/tests/vanilla/shallow.test.tsx | import { describe, expect, it } from 'vitest'
import { shallow } from 'zustand/vanilla/shallow'
describe('shallow', () => {
it('compares primitive values', () => {
expect(shallow(true, true)).toBe(true)
expect(shallow(true, false)).toBe(false)
expect(shallow(1, 1)).toBe(true)
expect(shallow(1, 2)).toBe(false)
expect(shallow('zustand', 'zustand')).toBe(true)
expect(shallow('zustand', 'redux')).toBe(false)
})
it('compares objects', () => {
expect(shallow({ foo: 'bar', asd: 123 }, { foo: 'bar', asd: 123 })).toBe(
true,
)
expect(
shallow({ foo: 'bar', asd: 123 }, { foo: 'bar', foobar: true }),
).toBe(false)
expect(
shallow({ foo: 'bar', asd: 123 }, { foo: 'bar', asd: 123, foobar: true }),
).toBe(false)
})
it('compares arrays', () => {
expect(shallow([1, 2, 3], [1, 2, 3])).toBe(true)
expect(shallow([1, 2, 3], [2, 3, 4])).toBe(false)
expect(
shallow([{ foo: 'bar' }, { asd: 123 }], [{ foo: 'bar' }, { asd: 123 }]),
).toBe(false)
expect(shallow([{ foo: 'bar' }], [{ foo: 'bar', asd: 123 }])).toBe(false)
})
it('compares Maps', () => {
function createMap<T extends object>(obj: T) {
return new Map(Object.entries(obj))
}
expect(
shallow(
createMap({ foo: 'bar', asd: 123 }),
createMap({ foo: 'bar', asd: 123 }),
),
).toBe(true)
expect(
shallow(
createMap({ foo: 'bar', asd: 123 }),
createMap({ foo: 'bar', foobar: true }),
),
).toBe(false)
expect(
shallow(
createMap({ foo: 'bar', asd: 123 }),
createMap({ foo: 'bar', asd: 123, foobar: true }),
),
).toBe(false)
})
it('compares Sets', () => {
expect(shallow(new Set(['bar', 123]), new Set(['bar', 123]))).toBe(true)
expect(shallow(new Set(['bar', 123]), new Set(['bar', 2]))).toBe(false)
expect(shallow(new Set(['bar', 123]), new Set(['bar', 123, true]))).toBe(
false,
)
})
it('compares functions', () => {
function firstFnCompare() {
return { foo: 'bar' }
}
function secondFnCompare() {
return { foo: 'bar' }
}
expect(shallow(firstFnCompare, firstFnCompare)).toBe(true)
expect(shallow(secondFnCompare, secondFnCompare)).toBe(true)
expect(shallow(firstFnCompare, secondFnCompare)).toBe(false)
})
})
describe('unsupported cases', () => {
it('date', () => {
expect(
shallow(
new Date('2022-07-19T00:00:00.000Z'),
new Date('2022-07-20T00:00:00.000Z'),
),
).not.toBe(false)
})
})
|
6,310 | 0 | petrpan-code/pmndrs/react-spring/packages/core | petrpan-code/pmndrs/react-spring/packages/core/src/AnimationConfig.test.ts | import { AnimationConfig, mergeConfig } from './AnimationConfig'
const expo = (t: number) => Math.pow(t, 2)
describe('mergeConfig', () => {
it('can merge partial configs', () => {
let config = new AnimationConfig()
mergeConfig(config, { tension: 0 })
mergeConfig(config, { friction: 0 })
expect(config).toMatchObject({
tension: 0,
friction: 0,
})
config = new AnimationConfig()
mergeConfig(config, { frequency: 2 })
mergeConfig(config, { damping: 0 })
expect(config).toMatchObject({
frequency: 2,
damping: 0,
})
config = new AnimationConfig()
mergeConfig(config, { duration: 2000 })
mergeConfig(config, { easing: expo })
expect(config).toMatchObject({
duration: 2000,
easing: expo,
})
})
it('resets the "duration" when props are incompatible', () => {
const config = new AnimationConfig()
mergeConfig(config, { duration: 1000 })
expect(config.duration).toBeDefined()
mergeConfig(config, { decay: 0.998 })
expect(config.duration).toBeUndefined()
expect(config.decay).toBe(0.998)
mergeConfig(config, { duration: 1000 })
expect(config.duration).toBeDefined()
mergeConfig(config, { frequency: 0.5 })
expect(config.duration).toBeUndefined()
expect(config.frequency).toBe(0.5)
})
it('resets the "decay" when props are incompatible', () => {
const config = new AnimationConfig()
mergeConfig(config, { decay: 0.998 })
expect(config.decay).toBeDefined()
mergeConfig(config, { mass: 2 })
expect(config.decay).toBeUndefined()
expect(config.mass).toBe(2)
})
it('resets the "frequency" when props are incompatible', () => {
const config = new AnimationConfig()
mergeConfig(config, { frequency: 0.5 })
expect(config.frequency).toBeDefined()
mergeConfig(config, { tension: 0 })
expect(config.frequency).toBeUndefined()
expect(config.tension).toBe(0)
})
describe('frequency/damping props', () => {
it('properly converts to tension/friction', () => {
const config = new AnimationConfig()
const merged = mergeConfig(config, { frequency: 0.5, damping: 1 })
expect(merged.tension).toBe(157.91367041742973)
expect(merged.friction).toBe(25.132741228718345)
})
it('works with extreme but valid values', () => {
const config = new AnimationConfig()
const merged = mergeConfig(config, { frequency: 2.6, damping: 0.1 })
expect(merged.tension).toBe(5.840002604194885)
expect(merged.friction).toBe(0.483321946706122)
})
it('prevents a damping ratio less than 0', () => {
const config = new AnimationConfig()
const validConfig = mergeConfig(config, { frequency: 0.5, damping: 0 })
const invalidConfig = mergeConfig(config, { frequency: 0.5, damping: -1 })
expect(invalidConfig).toMatchObject(validConfig)
})
it('prevents a frequency response less than 0.01', () => {
const config = new AnimationConfig()
const validConfig = mergeConfig(config, { frequency: 0.01, damping: 1 })
const invalidConfig = mergeConfig(config, { frequency: 0, damping: 1 })
expect(invalidConfig).toMatchObject(validConfig)
})
})
})
|
6,313 | 0 | petrpan-code/pmndrs/react-spring/packages/core | petrpan-code/pmndrs/react-spring/packages/core/src/Controller.test.ts | import { Controller } from './Controller'
import { flushMicroTasks } from 'flush-microtasks'
import { getFinishedResult } from './AnimationResult'
const frameLength = 1000 / 60
describe('Controller', () => {
it('can animate a number', async () => {
const ctrl = new Controller({ x: 0 })
ctrl.start({ x: 100 })
await global.advanceUntilIdle()
const frames = global.getFrames(ctrl)
expect(frames).toMatchSnapshot()
// The first frame should *not* be the from value.
expect(frames[0]).not.toEqual({ x: 0 })
// The last frame should be the goal value.
expect(frames.slice(-1)[0]).toEqual({ x: 100 })
})
it('can animate an array of numbers', async () => {
const config = { precision: 0.005 }
const ctrl = new Controller<{ x: [number, number] }>({ x: [1, 2], config })
ctrl.start({ x: [5, 10] })
await global.advanceUntilIdle()
const frames = global.getFrames(ctrl)
expect(frames).toMatchSnapshot()
// The last frame should be the goal value.
expect(frames.slice(-1)[0]).toEqual({ x: [5, 10] })
// The 2nd value is always ~2x the 1st value (within the defined precision).
const factors = frames.map(frame => frame.x[1] / frame.x[0])
expect(
factors.every(factor => Math.abs(2 - factor) < config.precision)
).toBeTruthy()
})
describe('when the "to" prop is an async function', () => {
it('respects the "cancel" prop', async () => {
const ctrl = new Controller({ from: { x: 0 } })
const promise = ctrl.start({
to: async next => {
while (true) {
await next({ x: 1, reset: true })
}
},
})
const { x } = ctrl.springs
await global.advanceUntilValue(x, 0.5)
ctrl.start({ cancel: true })
await flushMicroTasks()
expect(ctrl.idle).toBeTruthy()
expect((await promise).cancelled).toBeTruthy()
})
it('respects the "stop" method', async () => {
const ctrl = new Controller({ from: { x: 0 } })
const promise = ctrl.start({
to: async next => {
while (true) {
await next({ x: 1, reset: true })
}
},
})
const { x } = ctrl.springs
await global.advanceUntilValue(x, 0.5)
ctrl.stop()
expect(ctrl.idle).toBeTruthy()
expect((await promise).finished).toBeFalsy()
})
it('respects the "pause" prop', async () => {
const ctrl = new Controller({ from: { x: 0 } })
ctrl.start({ pause: true })
let n = 0
ctrl.start({
to: async animate => {
while (true) {
n += 1
await animate({ x: 1, reset: true })
}
},
})
await flushMicroTasks()
expect(n).toBe(0)
ctrl.start({ pause: false })
await flushMicroTasks()
expect(n).toBe(1)
})
describe('when the "to" prop is changed', () => {
it('stops the old "to" prop', async () => {
const ctrl = new Controller({ from: { x: 0 } })
let n = 0
const promise = ctrl.start({
to: async next => {
while (++n < 5) {
await next({ x: 1, reset: true })
}
},
})
await global.advance()
expect(n).toBe(1)
ctrl.start({
to: () => {},
})
await global.advanceUntilIdle()
expect(n).toBe(1)
expect(await promise).toMatchObject({
finished: false,
})
})
})
// This function is the "to" prop's 1st argument.
describe('the "animate" function', () => {
it('inherits any default props', async () => {
const ctrl = new Controller({ from: { x: 0 } })
const onStart = jest.fn()
ctrl.start({
onStart,
to: async animate => {
expect(onStart).toBeCalledTimes(0)
await animate({ x: 1 })
expect(onStart).toBeCalledTimes(1)
await animate({ x: 0 })
},
})
await global.advanceUntilIdle()
expect(onStart).toBeCalledTimes(2)
})
it('can start its own async animation', async () => {
const ctrl = new Controller({ from: { x: 0 } })
// Call this from inside the nested "to" prop.
const nestedFn = jest.fn()
// Call this after the nested "to" prop is done.
const afterFn = jest.fn()
ctrl.start({
to: async animate => {
await animate({
to: async animate => {
nestedFn()
await animate({ x: 1 })
},
})
afterFn()
},
})
await global.advanceUntilIdle()
await flushMicroTasks()
expect(nestedFn).toBeCalledTimes(1)
expect(afterFn).toBeCalledTimes(1)
})
})
describe('nested async animation', () => {
it('stops the parent on bail', async () => {
const ctrl = new Controller({ from: { x: 0 } })
const { x } = ctrl.springs
const afterFn = jest.fn()
ctrl.start({
to: async animate => {
await animate({
to: async animate => {
await animate({ x: 1 })
},
})
afterFn()
},
})
await global.advanceUntilValue(x, 0.5)
ctrl.start({ cancel: true })
await flushMicroTasks()
expect(ctrl.idle).toBeTruthy()
expect(afterFn).not.toHaveBeenCalled()
})
})
describe('while paused', () => {
it('stays paused when its values are force-finished', () => {
const ctrl = new Controller<{ t: number }>({ t: 0 })
const { t } = ctrl.springs
const onRest = jest.fn()
ctrl.start({
to: next => next({ t: 1 }),
onRest,
})
global.mockRaf.step()
ctrl.pause()
t.finish()
global.mockRaf.step()
expect(ctrl['_state'].paused).toBeTruthy()
expect(onRest).not.toBeCalled()
})
})
it('acts strangely without the "from" prop', async () => {
const ctrl = new Controller<{ x: number }>()
const { springs } = ctrl
const promise = ctrl.start({
to: async update => {
// The spring does not exist yet!
expect(springs.x).toBeUndefined()
// Any values passed here are treated as "from" values,
// because no "from" prop was ever given.
const p1 = update({ x: 1 })
// Now the spring exists!
expect(springs.x).toBeDefined()
// But the spring is idle!
expect(springs.x.idle).toBeTruthy()
// This call *will* start an animation!
const p2 = update({ x: 2 })
expect(springs.x.idle).toBeFalsy()
await Promise.all([p1, p2])
},
})
await Promise.all([global.advanceUntilIdle(), promise])
expect(ctrl.idle).toBeTruthy()
// Since we call `update` twice, frames are generated!
expect(global.getFrames(ctrl)).toMatchSnapshot()
})
describe('when skipAnimations is true', () => {
it('should not run at all', async () => {
const ctrl = new Controller({ from: { x: 0 } })
let n = 0
global.setSkipAnimation(true)
ctrl.start({
to: async next => {
while (true) {
n += 1
await next({ x: 1, reset: true })
}
},
})
await flushMicroTasks()
expect(n).toBe(0)
})
it('should stop running and push the animation to the finished state when called mid animation', async () => {
const ctrl = new Controller({ from: { x: 0 } })
let n = 0
ctrl.start({
to: async next => {
while (n < 5) {
n++
await next({ x: 10, reset: true })
}
},
})
await global.advance()
expect(n).toBe(1)
global.setSkipAnimation(true)
await global.advanceUntilIdle()
const { x } = ctrl.springs
expect(n).toBe(2)
expect(x.get()).toEqual(10)
})
})
})
describe('when the "onStart" prop is defined', () => {
it('is called once per "start" call maximum', async () => {
const ctrl = new Controller({ x: 0, y: 0 })
const onStart = jest.fn()
ctrl.start({
x: 1,
y: 1,
onStart,
})
await global.advanceUntilIdle()
expect(onStart).toBeCalledTimes(1)
})
it('can be different per key', async () => {
const ctrl = new Controller({ x: 0, y: 0 })
const onStart1 = jest.fn()
ctrl.start({ x: 1, onStart: onStart1 })
const onStart2 = jest.fn()
ctrl.start({ y: 1, onStart: onStart2 })
await global.advanceUntilIdle()
expect(onStart1).toBeCalledTimes(1)
expect(onStart2).toBeCalledTimes(1)
})
})
describe('the "loop" prop', () => {
it('can be combined with the "reverse" prop', async () => {
const ctrl = new Controller({
t: 1,
from: { t: 0 },
config: { duration: frameLength * 3 },
})
const { t } = ctrl.springs
expect(t.get()).toBe(0)
await global.advanceUntilIdle()
expect(t.get()).toBe(1)
ctrl.start({
loop: { reverse: true },
})
await global.advanceUntilValue(t, 0)
await global.advanceUntilValue(t, 1)
expect(global.getFrames(t)).toMatchSnapshot()
})
describe('used with multiple values', () => {
it('loops all values at the same time', async () => {
const ctrl = new Controller()
ctrl.start({
to: { x: 1, y: 1 },
from: { x: 0, y: 0 },
config: key => ({ frequency: key == 'x' ? 0.3 : 1 }),
loop: true,
})
const { x, y } = ctrl.springs
for (let i = 0; i < 2; i++) {
await global.advanceUntilValue(y, 1)
// Both values should equal their "from" value at the same time.
expect(x.get()).toBe(x.animation.from)
expect(y.get()).toBe(y.animation.from)
}
})
})
describe('used when "to" is', () => {
describe('an async function', () => {
it('calls the "to" function repeatedly', async () => {
const ctrl = new Controller({ t: 0 })
const { t } = ctrl.springs
let loop = true
let times = 2
// Note: This example is silly, since you could use a for-loop
// to more easily achieve the same result, but it tests the ability
// to halt a looping script via the "loop" function prop.
ctrl.start({
loop: () => loop,
to: async next => {
await next({ t: 1 })
await next({ t: 0 })
if (times--) return
loop = false
},
})
await global.advanceUntilValue(t, 1)
expect(t.idle).toBeFalsy()
for (let i = 0; i < 2; i++) {
await global.advanceUntilValue(t, 0)
expect(t.idle).toBeFalsy()
await global.advanceUntilValue(t, 1)
expect(t.idle).toBeFalsy()
}
await global.advanceUntilValue(t, 0)
expect(t.idle).toBeTruthy()
})
})
describe('an array', () => {
it('repeats the chain of updates', async () => {
const ctrl = new Controller({ t: 0 })
const { t } = ctrl.springs
let loop = true
const promise = ctrl.start({
loop: () => {
return loop
},
from: { t: 0 },
to: [{ t: 1 }, { t: 2 }],
config: { duration: 3000 / 60 },
})
for (let i = 0; i < 3; i++) {
await global.advanceUntilValue(t, 2)
expect(t.idle).toBeFalsy()
// Run the first frame of the next loop.
global.mockRaf.step()
}
loop = false
await global.advanceUntilValue(t, 2)
expect(t.idle).toBeTruthy()
expect(await promise).toMatchObject({
value: { t: 2 },
finished: true,
})
})
})
})
describe('used on a noop update', () => {
it('does not loop', async () => {
const ctrl = new Controller({ t: 0 })
const loop = jest.fn(() => true)
ctrl.start({ t: 0, loop })
await global.advanceUntilIdle()
expect(loop).toBeCalledTimes(0)
})
})
describe('when "finish" is called while paused', () => {
async function getPausedLoop() {
const ctrl = new Controller<{ t: number }>({
from: { t: 0 }, // FIXME: replace this line with `t: 0,` for a stack overflow
loop: {
async to(start) {
await start({
t: 1,
reset: true,
})
},
},
})
// Ensure `loop.to` has been called.
await flushMicroTasks()
// Apply the first frame.
global.mockRaf.step()
ctrl.pause()
return ctrl
}
it('finishes immediately', async () => {
const ctrl = await getPausedLoop()
const { t } = ctrl.springs
expect(t.get()).toBeLessThan(1)
t.finish()
expect(t.get()).toBe(1)
})
it('does not loop until resumed', async () => {
const ctrl = await getPausedLoop()
const { t } = ctrl.springs
t.finish()
expect(t.idle).toBeTruthy()
expect(t.get()).toBe(1)
// HACK: The internal promise is undefined once resolved.
const expectResolved = (isResolved: boolean) =>
!ctrl['_state'].promise == isResolved
// Resume the paused loop.
ctrl.resume()
// Its promise is not resolved yet..
expectResolved(false)
expect(t.idle).toBeTruthy()
expect(t.get()).toBe(1)
// ..but in the next microtask, it will be..
await flushMicroTasks()
expectResolved(true)
// ..which means the loop restarts!
expect(t.idle).toBeFalsy()
expect(t.get()).toBe(0)
})
})
})
describe('the "stop" method', () => {
it('prevents any updates with pending delays', async () => {
const ctrl = new Controller<{ t: number }>({ t: 0 })
const { t } = ctrl.springs
ctrl.start({ t: 1, delay: 100 })
ctrl.stop()
await global.advanceUntilIdle()
expect(ctrl['_state'].timeouts.size).toBe(0)
expect(t['_state'].timeouts.size).toBe(0)
})
it('stops the active runAsync call', async () => {
const ctrl = new Controller<{ t: number }>({ t: 0 })
ctrl.start({
to: async animate => {
await animate({ t: 1 })
},
})
ctrl.stop()
await global.advanceUntilIdle()
expect(ctrl['_state'].asyncTo).toBeUndefined()
})
})
describe('events', () => {
test('events recieve an AnimationResult and the Controller as the first two args', async () => {
const ctrl = new Controller<{ t: number }>({ t: 0 })
const onRest = jest.fn()
const onStart = jest.fn()
const onChange = jest.fn()
ctrl.start({
to: next => next({ t: 1 }),
onRest,
onStart,
onChange,
})
global.mockRaf.step()
expect(onStart).toBeCalledWith(
getFinishedResult({ t: 0.022634843307857987 }, false),
ctrl,
undefined
)
expect(onChange).toBeCalledWith(
getFinishedResult(ctrl.get(), false),
ctrl,
undefined
)
await global.advanceUntilIdle()
expect(onRest).toBeCalledWith(
getFinishedResult(ctrl.get(), true),
ctrl,
undefined
)
})
test('events recieve also recieve the item if set as the third', async () => {
const ctrl = new Controller<{ t: number }>({ t: 0 })
const item = { msg: 'hello world', key: 1 }
ctrl.item = item
const onRest = jest.fn()
const onStart = jest.fn()
const onChange = jest.fn()
ctrl.start({
to: next => next({ t: 1 }),
onRest,
onStart,
onChange,
})
global.mockRaf.step()
expect(onStart).toBeCalledWith(
getFinishedResult({ t: 0.022634843307857987 }, false),
ctrl,
item
)
expect(onChange).toBeCalledWith(
getFinishedResult(ctrl.get(), false),
ctrl,
item
)
await global.advanceUntilIdle()
expect(onRest).toBeCalledWith(
getFinishedResult(ctrl.get(), true),
ctrl,
item
)
})
test('onStart & onRest are flushed even if the `immediate` prop is true', async () => {
const onRest = jest.fn()
const onStart = jest.fn()
const ctrl = new Controller<{ t: number }>({
t: 0,
onStart,
onRest,
})
ctrl.start({
t: 1,
immediate: true,
})
await global.advanceUntilIdle()
expect(ctrl.get().t).toBe(1)
expect(onStart).toHaveBeenCalled()
expect(onRest).toHaveBeenCalled()
})
})
})
|
6,316 | 0 | petrpan-code/pmndrs/react-spring/packages/core | petrpan-code/pmndrs/react-spring/packages/core/src/Interpolation.test.ts | import { SpringValue } from './SpringValue'
import { to } from './interpolate'
import { addFluidObserver } from '@react-spring/shared'
describe('Interpolation', () => {
it.todo('can use a SpringValue')
it.todo('can use another Interpolation')
it.todo('can use a non-animated FluidValue')
describe('when multiple inputs change in the same frame', () => {
it.todo('only computes its value once')
})
describe('when an input resets its animation', () => {
it.todo('computes its value before the first frame')
})
describe('when all inputs are paused', () => {
it('leaves the frameloop', () => {
const a = new SpringValue({ from: 0, to: 1 })
const b = new SpringValue({ from: 1, to: 0 })
global.mockRaf.step()
const calc = jest.fn((a: number, b: number) => Math.abs(a - b))
const c = to([a, b], calc)
// For interpolation to be active, it must be observed.
const observer = jest.fn()
addFluidObserver(c, observer)
// Pause the first input.
a.pause()
// Expect interpolation to continue.
calc.mockClear()
global.mockRaf.step()
expect(calc).toBeCalled()
// Pause the other input.
b.pause()
// In the next frame, the interpolation still calculates its next value.
// When its value stays the same, it checks the idle status of each input,
// which triggers an update to its own idle status.
calc.mockClear()
global.mockRaf.step()
expect(calc).toBeCalled()
expect(c.idle).toBeTruthy()
// Expect interpolation to be paused.
calc.mockClear()
global.mockRaf.step()
expect(calc).not.toBeCalled()
})
})
})
|
6,318 | 0 | petrpan-code/pmndrs/react-spring/packages/core | petrpan-code/pmndrs/react-spring/packages/core/src/SpringContext.test.tsx | import * as React from 'react'
import { render, RenderResult } from '@testing-library/react'
import { SpringContext } from './SpringContext'
import { SpringValue } from './SpringValue'
import { useSpring } from './hooks'
describe('SpringContext', () => {
let t: SpringValue<number>
const Child = () => {
t = useSpring({ t: 1, from: { t: 0 } }).t
return null
}
const update = createUpdater(props => (
<SpringContext {...props}>
<Child />
</SpringContext>
))
it('only merges when changed', () => {
const context: SpringContext = {}
const onProps = jest.fn()
const Test = () => {
useSpring({ onProps, x: 0 })
return null
}
const getRoot = () => (
<SpringContext {...context}>
<Test />
</SpringContext>
)
const expectUpdates = (updates: any[]) => {
onProps.mock.calls.forEach((args, i) => {
const update = updates[i]
if (update) {
expect(args[0]).toMatchObject(update)
} else {
// Unexpected update.
expect(args[0]).toBeUndefined()
}
})
onProps.mockClear()
}
const elem = render(getRoot())
expectUpdates([{ onProps, to: { x: 0 } }])
context.pause = true
elem.rerender(getRoot())
expectUpdates([{ default: context }, { onProps, to: { x: 0 } }])
elem.rerender(getRoot())
expectUpdates([{ onProps, to: { x: 0 } }])
})
it('can pause current animations', () => {
update({})
global.mockRaf.step()
expect(t.idle).toBeFalsy()
update({ pause: true })
expect(t.idle).toBeTruthy()
expect(t.goal).toBe(1)
update({ pause: false })
expect(t.idle).toBeFalsy()
expect(t.goal).toBe(1)
})
it('can pause future animations', () => {
// Paused right away.
update({ pause: true })
expect(t.idle).toBeTruthy()
expect(t.goal).toBeUndefined()
// This update is paused too.
t.start(2)
expect(t.idle).toBeTruthy()
expect(t.goal).toBeUndefined()
// Let it roll.
update({ pause: false })
expect(t.idle).toBeFalsy()
// The `goal` is not 2, because the `useSpring` hook is
// executed by the SpringContext update.
expect(t.goal).toBe(1)
})
it('can make current animations immediate', () => {
update({})
global.mockRaf.step()
expect(t.idle).toBeFalsy()
update({ immediate: true })
global.mockRaf.step()
expect(t.idle).toBeTruthy()
expect(t.get()).toBe(1)
})
it('can make future animations immediate', () => {
update({ immediate: true })
global.mockRaf.step()
expect(t.idle).toBeTruthy()
expect(t.get()).toBe(1)
t.start(2)
global.mockRaf.step()
expect(t.idle).toBeTruthy()
expect(t.get()).toBe(2)
})
})
function createUpdater(Component: React.ComponentType<SpringContext>) {
let result: RenderResult | undefined
afterEach(() => {
result = undefined
})
return (props: SpringContext) => {
const elem = <Component {...props} />
if (result) result.rerender(elem)
else result = render(elem)
return result
}
}
|
6,322 | 0 | petrpan-code/pmndrs/react-spring/packages/core | petrpan-code/pmndrs/react-spring/packages/core/src/SpringValue.test.ts | import { SpringValue } from './SpringValue'
import { FrameValue } from './FrameValue'
import { flushMicroTasks } from 'flush-microtasks'
import {
addFluidObserver,
FluidObserver,
getFluidObservers,
Globals,
removeFluidObserver,
} from '@react-spring/shared'
const frameLength = 1000 / 60
describe('SpringValue', () => {
it('can animate a number', async () => {
const spring = new SpringValue(0)
spring.start(1, {
config: { duration: 10 * frameLength },
})
await global.advanceUntilIdle()
const frames = global.getFrames(spring)
expect(frames).toMatchSnapshot()
})
it('can animate a string', async () => {
const spring = new SpringValue<string>()
const promise = spring.start({
to: '10px 20px',
from: '0px 0px',
config: { duration: 10 * frameLength },
})
await global.advanceUntilIdle()
const frames = global.getFrames(spring)
expect(frames).toMatchSnapshot()
const { finished } = await promise
expect(finished).toBeTruthy()
})
// FIXME: This test fails.
xit('animates a number the same as a numeric string', async () => {
const spring1 = new SpringValue(0)
spring1.start(10)
await global.advanceUntilIdle()
const frames = global.getFrames(spring1).map(n => n + 'px')
const spring2 = new SpringValue('0px')
spring2.start('10px')
await global.advanceUntilIdle()
expect(frames).toEqual(global.getFrames(spring2))
})
it('can animate an array of numbers', async () => {
const onChange = jest.fn()
const spring = new SpringValue()
spring.start({
to: [10, 20],
from: [0, 0],
config: { duration: 10 * frameLength },
onChange,
})
await global.advanceUntilIdle()
expect(onChange.mock.calls.slice(-1)[0]).toEqual([
spring.animation.to,
spring,
])
expect(global.getFrames(spring)).toMatchSnapshot()
})
it('can have an animated string as its target', async () => {
const target = new SpringValue('yellow')
const spring = new SpringValue({
to: target,
config: { duration: 10 * frameLength },
})
// The target is not attached until the spring is observed.
addFluidObserver(spring, () => {})
global.mockRaf.step()
target.set('red')
await global.advanceUntilIdle()
expect(global.getFrames(spring)).toMatchSnapshot()
})
describeProps()
describeEvents()
describeMethods()
describeGlobals()
describeTarget('another SpringValue', from => {
const node = new SpringValue(from)
return {
node,
set: node.set.bind(node),
start: node.start.bind(node),
reset: node.reset.bind(node),
}
})
describeTarget('an Interpolation', from => {
const parent = new SpringValue(from - 1)
const node = parent.to(n => n + 1)
return {
node,
set: n => parent.set(n - 1),
start: n => parent.start(n - 1),
reset: parent.reset.bind(parent),
}
})
// No-op updates don't change the goal value.
describe('no-op updates', () => {
it('resolves when the animation is finished', async () => {
const spring = new SpringValue(0)
spring.start(1)
// Create a no-op update.
const resolve = jest.fn()
spring.start(1).then(resolve)
await flushMicroTasks()
expect(resolve).not.toBeCalled()
await global.advanceUntilIdle()
expect(resolve).toBeCalled()
})
})
})
function describeProps() {
describeToProp()
describeFromProp()
describeResetProp()
describeDefaultProp()
describeReverseProp()
describeImmediateProp()
describeConfigProp()
describeLoopProp()
describeDelayProp()
}
function describeToProp() {
describe('when "to" prop is changed', () => {
it.todo('resolves the "start" promise with (finished: false)')
it.todo('avoids calling the "onStart" prop')
it.todo('avoids calling the "onRest" prop')
})
describe('when "to" prop equals current value', () => {
it('cancels any pending animation', async () => {
const spring = new SpringValue(0)
spring.start(1)
// Prevent the animation to 1 (which hasn't started yet)
spring.start(0)
await global.advanceUntilIdle()
expect(global.getFrames(spring)).toEqual([])
})
it('avoids interrupting an active animation', async () => {
const spring = new SpringValue(0)
spring.start(1)
await global.advance()
const goal = spring.get()
spring.start(goal)
expect(spring.idle).toBeFalsy()
await global.advanceUntilIdle()
expect(spring.get()).toBe(goal)
expect(global.getFrames(spring)).toMatchSnapshot()
})
})
describe('when "to" prop is a function', () => {
describe('and "from" prop is defined', () => {
it('stops the active animation before "to" is called', () => {
const spring = new SpringValue({ from: 0, to: 1 })
global.mockRaf.step()
expect.assertions(1)
spring.start({
from: 2,
to: () => {
expect(spring.get()).toBe(2)
},
})
})
})
})
}
function describeFromProp() {
describe('when "from" prop is defined', () => {
it.todo('controls the start value')
})
}
function describeResetProp() {
describe('when "reset" prop is true', () => {
it('calls "onRest" before jumping back to its "from" value', async () => {
const onRest = jest.fn((result: any) => {
expect(result.value).not.toBe(0)
})
const spring = new SpringValue({ from: 0, to: 1, onRest })
global.mockRaf.step()
spring.start({ reset: true })
expect(onRest).toHaveBeenCalled()
expect(spring.get()).toBe(0)
})
it.todo('resolves the "start" promise with (finished: false)')
it.todo('calls the "onRest" prop with (finished: false)')
})
}
function describeDefaultProp() {
// The hook API always uses { default: true } for render-driven updates.
// Some props can have default values (eg: onRest, config, etc), and
// other props may behave differently when { default: true } is used.
describe('when "default" prop is true', () => {
describe('and "from" prop is changed', () => {
describe('before the first animation', () => {
it('updates the current value', () => {
const props = { default: true, from: 1, to: 1 }
const spring = new SpringValue(props)
expect(spring.get()).toBe(1)
expect(spring.idle).toBeTruthy()
props.from = 0
spring.start(props)
expect(spring.get()).not.toBe(1)
expect(spring.idle).toBeFalsy()
})
})
describe('after the first animation', () => {
it('does not start animating', async () => {
const props = { default: true, from: 0, to: 2 }
const spring = new SpringValue(props)
await global.advanceUntilIdle()
props.from = 1
spring.start(props)
expect(spring.get()).toBe(2)
expect(spring.idle).toBeTruthy()
expect(spring.animation.from).toBe(1)
})
describe('and "reset" prop is true', () => {
it('starts at the "from" prop', async () => {
const props: any = { default: true, from: 0, to: 2 }
const spring = new SpringValue(props)
await global.advanceUntilIdle()
props.from = 1
props.reset = true
spring.start(props)
expect(spring.animation.from).toBe(1)
expect(spring.idle).toBeFalsy()
})
})
})
})
})
describe('when "default" prop is false', () => {
describe('and "from" prop is defined', () => {
it('updates the current value', () => {
const spring = new SpringValue(0)
spring.start({ from: 1 })
expect(spring.get()).toBe(1)
})
it('updates the "from" value', () => {
const spring = new SpringValue(0)
spring.start({ from: 1 })
expect(spring.animation.from).toBe(1)
})
describe('and "to" prop is undefined', () => {
it('updates the "to" value', () => {
const spring = new SpringValue(0)
spring.start({ from: 1 })
expect(spring.animation.to).toBe(1)
})
it('stops the active animation', async () => {
const spring = new SpringValue(0)
// This animation will be stopped.
const promise = spring.start({ from: 0, to: 1 })
global.mockRaf.step()
const value = spring.get()
spring.start({ from: 0 })
expect(spring.idle).toBeTruthy()
expect(spring.animation.to).toBe(0)
expect(await promise).toMatchObject({
value,
finished: false,
})
})
})
})
})
}
function describeReverseProp() {
describe('when "reverse" prop is true', () => {
it('swaps the "to" and "from" props', async () => {
const spring = new SpringValue<number>()
spring.start({ from: 0, to: 1, reverse: true })
await global.advanceUntilIdle()
expect(global.getFrames(spring)).toMatchSnapshot()
})
it('works when "to" and "from" were set by an earlier update', async () => {
// TODO: remove the need for "<number>"
const spring = new SpringValue<number>({ from: 0, to: 1 })
await global.advanceUntilValue(spring, 0.5)
spring.start({ reverse: true })
expect(spring.animation).toMatchObject({
from: 1,
to: 0,
})
await global.advanceUntilIdle()
expect(global.getFrames(spring)).toMatchSnapshot()
})
it('works when "from" was set by an earlier update', async () => {
const spring = new SpringValue(0)
expect(spring.animation.from).toBe(0)
spring.start({ to: 1, reverse: true })
await global.advanceUntilIdle()
expect(global.getFrames(spring)).toMatchSnapshot()
})
it('preserves the reversal for future updates', async () => {
const spring = new SpringValue(0)
spring.start({ to: 1, reverse: true })
expect(spring.animation).toMatchObject({
to: 0,
from: 1,
})
await global.advanceUntilIdle()
spring.start({ to: 2 })
expect(spring.animation).toMatchObject({
to: 2,
from: 1,
})
})
})
}
function describeImmediateProp() {
describe('when "immediate" prop is true', () => {
it.todo('still resolves the "start" promise')
it.todo('never calls the "onStart" prop')
it.todo('never calls the "onRest" prop')
it('stops animating', async () => {
const spring = new SpringValue(0)
spring.start(2)
await global.advanceUntilValue(spring, 1)
// Use "immediate" to emulate the "stop" method. (see #884)
const value = spring.get()
spring.start(value, { immediate: true })
// The "immediate" prop waits until the next frame before going idle.
global.mockRaf.step()
expect(spring.idle).toBeTruthy()
expect(spring.get()).toBe(value)
})
})
describe('when "immediate: true" is followed by "immediate: false" in same frame', () => {
it('applies the immediate goal synchronously', () => {
const spring = new SpringValue(0)
// The immediate update is applied in the next frame.
spring.start({ to: 1, immediate: true })
expect(spring.get()).toBe(0)
// But when an animated update is merged before the next frame,
// the immediate update is applied synchronously.
spring.start({ to: 2 })
expect(spring.get()).toBe(1)
expect(spring.animation).toMatchObject({
fromValues: [1],
toValues: [2],
})
})
it('does nothing if the 2nd update has "reset: true"', () => {
const spring = new SpringValue(0)
// The immediate update is applied in the next frame.
spring.start({ to: 1, immediate: true })
expect(spring.get()).toBe(0)
// But when an animated update is merged before the next frame,
// the immediate update is applied synchronously.
spring.start({ to: 2, reset: true })
expect(spring.get()).toBe(0)
expect(spring.animation).toMatchObject({
fromValues: [0],
toValues: [2],
})
})
})
}
function describeConfigProp() {
describe('the "config" prop', () => {
it('resets the velocity when "to" changes', () => {
const spring = new SpringValue(0)
spring.start({ to: 100, config: { velocity: 10 } })
const { config } = spring.animation
expect(config.velocity).toBe(10)
// Preserve velocity if "to" did not change.
spring.start({ config: { tension: 200 } })
expect(config.velocity).toBe(10)
spring.start({ to: 200 })
expect(config.velocity).toBe(0)
})
describe('when "damping" is 1.0', () => {
it('should prevent bouncing', async () => {
const spring = new SpringValue(0)
spring.start(1, {
config: { frequency: 1.5, damping: 1 },
})
await global.advanceUntilIdle()
expect(global.countBounces(spring)).toBe(0)
})
})
describe('when "damping" is less than 1.0', () => {
// FIXME: This test fails.
xit('should bounce', async () => {
const spring = new SpringValue(0)
spring.start(1, {
config: { frequency: 1.5, damping: 1 },
})
await global.advanceUntilIdle()
expect(global.countBounces(spring)).toBeGreaterThan(0)
})
})
describe('the "precision" prop', () => {
describe('stops spring easing when step difference is less than precision', () => {
it.each([100, 10, 1, 0.1, 0.01, 0.001, 0.0001])(
'with precision: %d',
async precision => {
const spring = new SpringValue(0)
spring.start(precision * 10, {
config: {
precision,
},
})
await global.advanceUntilIdle()
const frames = global.getFrames(spring)
expect(spring.get() - frames[frames.length - 2]).toBeGreaterThan(
precision
)
expect(
spring.get() - frames[frames.length - 1]
).toBeLessThanOrEqual(precision)
}
)
})
describe('stops decay easing when step difference is less than precision', () => {
it.each([100, 10, 1, 0.1, 0.01, 0.001, 0.0001])(
'with precision: %d',
async precision => {
const spring = new SpringValue(0)
spring.start({
config: {
velocity: precision * 10,
decay: true,
precision,
},
})
await global.advanceUntilIdle()
const frames = global.getFrames(spring)
expect(
frames[frames.length - 1] - frames[frames.length - 3]
).toBeGreaterThan(precision)
expect(
frames[frames.length - 1] - frames[frames.length - 2]
).toBeLessThanOrEqual(precision)
}
)
})
})
})
}
function describeLoopProp() {
describe('the "loop" prop', () => {
it('resets the animation once finished', async () => {
const spring = new SpringValue(0)
spring.start(1, {
loop: true,
config: { duration: frameLength * 3 },
})
await global.advanceUntilValue(spring, 1)
const firstRun = global.getFrames(spring)
expect(firstRun).toMatchSnapshot()
// The loop resets the value before the next frame.
// FIXME: Reset on next frame instead?
expect(spring.get()).toBe(0)
await global.advanceUntilValue(spring, 1)
expect(global.getFrames(spring)).toEqual(firstRun)
})
it('can pass a custom delay', async () => {
const spring = new SpringValue(0)
spring.start(1, {
loop: { reset: true, delay: 1000 },
})
await global.advanceUntilValue(spring, 1)
expect(spring.get()).toBe(1)
global.mockRaf.step({ time: 1000 })
expect(spring.get()).toBeLessThan(1)
await global.advanceUntilValue(spring, 1)
expect(spring.get()).toBe(1)
})
it('supports deferred evaluation', async () => {
const spring = new SpringValue(0)
let loop: any = true
spring.start(1, { loop: () => loop })
await global.advanceUntilValue(spring, 1)
expect(spring.idle).toBeFalsy()
expect(spring.get()).toBeLessThan(1)
loop = { reset: true, delay: 1000 }
await global.advanceUntilValue(spring, 1)
expect(spring.idle).toBeTruthy()
expect(spring.get()).toBe(1)
global.mockRaf.step({ time: 1000 })
expect(spring.idle).toBeFalsy()
expect(spring.get()).toBeLessThan(1)
loop = false
await global.advanceUntilValue(spring, 1)
expect(spring.idle).toBeTruthy()
expect(spring.get()).toBe(1)
})
it('does not affect later updates', async () => {
const spring = new SpringValue(0)
spring.start(1, { loop: true })
await global.advanceUntilValue(spring, 0.5)
spring.start(2)
await global.advanceUntilValue(spring, 2)
expect(spring.idle).toBeTruthy()
})
it('can be combined with the "reset" prop', async () => {
const spring = new SpringValue(0)
spring.start(1)
await global.advanceUntilIdle()
spring.start({ reset: true, loop: true })
expect(spring.get()).toBe(0)
await global.advanceUntilValue(spring, 1)
expect(spring.get()).toBe(0)
expect(spring.idle).toBeFalsy()
})
it('can be combined with the "reverse" prop', async () => {
const spring = new SpringValue(0)
spring.start(1, { config: { duration: frameLength * 3 } })
await global.advanceUntilIdle()
spring.start({
loop: { reverse: true },
})
await global.advanceUntilValue(spring, 0)
await global.advanceUntilValue(spring, 1)
expect(global.getFrames(spring)).toMatchSnapshot()
})
})
}
function describeDelayProp() {
describe('the "delay" prop', () => {
// "Temporal prevention" means a delayed update can be cancelled by an
// earlier update. This removes the need for explicit delay cancellation.
it('allows the update to be temporally prevented', async () => {
const spring = new SpringValue(0)
const anim = spring.animation
spring.start(1, { config: { duration: 1000 } })
// This update will be ignored, because the next "start" call updates
// the "to" prop before this update's delay is finished. This update
// would *not* be ignored be if its "to" prop was undefined.
spring.start(2, { delay: 500, immediate: true })
// This update won't be affected by the previous update.
spring.start(0, { delay: 100, config: { duration: 1000 } })
expect(anim.to).toBe(1)
await global.advanceByTime(100)
expect(anim.to).toBe(0)
await global.advanceByTime(400)
expect(anim.immediate).toBeFalsy()
expect(anim.to).toBe(0)
})
})
}
function describeEvents() {
describe('the "onStart" event', () => {
it('is called on the first frame', async () => {
const onStart = jest.fn()
const spring = new SpringValue(0, { onStart })
spring.start(1)
expect(onStart).toBeCalledTimes(0)
global.mockRaf.step()
expect(onStart).toBeCalledTimes(1)
await global.advanceUntilIdle()
expect(onStart).toBeCalledTimes(1)
})
it('is called by the "finish" method', () => {
const onStart = jest.fn()
const spring = new SpringValue({ from: 0, to: 1, onStart })
expect(onStart).toBeCalledTimes(0)
spring.finish()
expect(onStart).toBeCalledTimes(1)
})
it('is called when immediate is set to true', async () => {
const onStart = jest.fn()
new SpringValue({
from: 0,
to: 1,
onStart,
immediate: true,
})
global.mockRaf.step()
expect(onStart).toBeCalledTimes(1)
})
})
describe('the "onChange" event', () => {
it('is called on every frame', async () => {
const onChange = jest.fn()
const spring = new SpringValue({ from: 0, to: 1, onChange })
await global.advanceUntilIdle()
const frames = global.getFrames(spring)
expect(onChange).toBeCalledTimes(frames.length)
})
it('receives the "to" value on the last frame', async () => {
const onChange = jest.fn()
const spring = new SpringValue('blue', { onChange })
spring.start('red')
await global.advanceUntilIdle()
const [lastValue] = onChange.mock.calls.slice(-1)[0]
expect(lastValue).toBe('red')
})
it('is called by the "set" method', () => {
const onChange = jest.fn()
const spring = new SpringValue({ from: 0, to: 1, onChange })
global.mockRaf.step()
expect(onChange).toBeCalledTimes(1)
// During an animation:
spring.set(1)
expect(onChange).toBeCalledTimes(2)
expect(spring.idle).toBeTruthy()
// While idle:
spring.set(0)
expect(onChange).toBeCalledTimes(3)
// No-op calls are ignored:
spring.set(0)
expect(onChange).toBeCalledTimes(3)
})
describe('when active handler', () => {
it('is never called by the "set" method', () => {
const spring = new SpringValue(0)
const onChange = jest.fn()
spring.start(1, { onChange })
// Before first frame
spring.set(2)
expect(onChange).not.toBeCalled()
spring.start(1, { onChange })
global.mockRaf.step()
onChange.mockReset()
// Before last frame
spring.set(0)
expect(onChange).not.toBeCalled()
})
})
})
describe('the "onPause" event', () => {
it('is called by the "pause" method', () => {
const onPause = jest.fn()
const spring = new SpringValue({ from: 0, to: 1, onPause })
global.mockRaf.step()
spring.pause()
spring.pause() // noop
expect(onPause).toBeCalledTimes(1)
spring.resume()
spring.pause()
expect(onPause).toBeCalledTimes(2)
})
})
describe('the "onResume" event', () => {
it('is called by the "resume" method', () => {
const onResume = jest.fn()
const spring = new SpringValue({ from: 0, to: 1, onResume })
global.mockRaf.step()
spring.resume() // noop
expect(onResume).toBeCalledTimes(0)
spring.pause()
spring.resume()
expect(onResume).toBeCalledTimes(1)
})
})
describe('the "onRest" event', () => {
it('is called on the last frame', async () => {
const onRest = jest.fn()
new SpringValue({
from: 0,
to: 1,
onRest,
config: {
// The animation is 3 frames long.
duration: 3 * frameLength,
},
})
global.mockRaf.step()
global.mockRaf.step()
expect(onRest).not.toBeCalled()
global.mockRaf.step()
expect(onRest).toBeCalledTimes(1)
})
it('is called by the "stop" method', () => {
const onRest = jest.fn()
const spring = new SpringValue({ from: 0, to: 1, onRest })
global.mockRaf.step()
spring.stop()
expect(onRest).toBeCalledTimes(1)
expect(onRest.mock.calls[0][0]).toMatchObject({
value: spring.get(),
finished: false,
})
})
it('is called by the "finish" method', () => {
const onRest = jest.fn()
const spring = new SpringValue({ from: 0, to: 1, onRest })
global.mockRaf.step()
spring.finish()
expect(onRest).toBeCalledTimes(1)
expect(onRest.mock.calls[0][0]).toMatchObject({
value: 1,
finished: true,
})
})
it('is called when the "cancel" prop is true', () => {
const onRest = jest.fn()
const spring = new SpringValue({ from: 0, to: 1, onRest })
global.mockRaf.step()
spring.start({ cancel: true })
expect(onRest).toBeCalledTimes(1)
expect(onRest.mock.calls[0][0]).toMatchObject({
value: spring.get(),
cancelled: true,
})
})
it('is called after an async animation', async () => {
const onRest = jest.fn()
const spring = new SpringValue(0)
await spring.start({
to: () => {},
onRest,
})
expect(onRest).toBeCalledTimes(1)
expect(onRest.mock.calls[0][0]).toMatchObject({
value: spring.get(),
finished: true,
})
})
it('is called when immediate is set to true', async () => {
const onRest = jest.fn()
new SpringValue({
from: 0,
to: 1,
onRest,
immediate: true,
})
global.mockRaf.step()
expect(onRest).toBeCalledTimes(1)
})
})
}
function describeMethods() {
describe('"set" method', () => {
it('stops the active animation', async () => {
const spring = new SpringValue(0)
const promise = spring.start(1)
await global.advanceUntilValue(spring, 0.5)
const value = spring.get()
spring.set(2)
expect(spring.idle).toBeTruthy()
expect(await promise).toMatchObject({
finished: false,
value,
})
})
})
}
/** The minimum requirements for testing a dynamic target */
type OpaqueTarget = {
node: FrameValue
set: (value: number) => any
start: (value: number) => Promise<any>
reset: () => void
}
function describeTarget(name: string, create: (from: number) => OpaqueTarget) {
describe('when our target is ' + name, () => {
let target: OpaqueTarget
let spring: SpringValue
let observer: FluidObserver
beforeEach(() => {
target = create(1)
spring = new SpringValue(0)
// The target is not attached until the spring is observed.
addFluidObserver(spring, (observer = () => {}))
})
it('animates toward the current value', async () => {
spring.start({ to: target.node })
expect(spring.priority).toBeGreaterThan(target.node.priority)
expect(spring.animation).toMatchObject({
to: target.node,
toValues: null,
})
await global.advanceUntilIdle()
expect(spring.get()).toBe(target.node.get())
})
it.todo('preserves its "onRest" prop between animations')
it('can change its target while animating', async () => {
spring.start({ to: target.node })
await global.advanceUntilValue(spring, target.node.get() / 2)
spring.start(0)
expect(spring.priority).toBe(0)
expect(spring.animation).toMatchObject({
to: 0,
toValues: [0],
})
await global.advanceUntilIdle()
expect(spring.get()).toBe(0)
})
describe('when target is done animating', () => {
it('keeps animating until the target is reached', async () => {
spring.start({ to: target.node })
target.start(1.1)
await global.advanceUntil(() => target.node.idle)
expect(spring.idle).toBeFalsy()
await global.advanceUntilIdle()
expect(spring.idle).toBeTruthy()
expect(spring.get()).toBe(target.node.get())
})
})
describe('when target animates after we go idle', () => {
it('starts animating', async () => {
spring.start({ to: target.node })
await global.advanceUntil(() => spring.idle)
// Clear the frame cache.
global.getFrames(spring)
target.start(2)
await global.advanceUntilIdle()
expect(global.getFrames(spring).length).toBeGreaterThan(1)
expect(spring.get()).toBe(target.node.get())
})
})
describe('when target has its value set (not animated)', () => {
it('animates toward the new value', async () => {
spring.start({ to: target.node })
await global.advanceUntilIdle()
target.set(2)
await global.advanceUntilIdle()
expect(global.getFrames(spring).length).toBeGreaterThan(1)
expect(spring.get()).toBe(target.node.get())
})
})
describe('when target resets its animation', () => {
it('keeps animating', async () => {
spring.start({ to: target.node })
target.start(2)
await global.advanceUntilValue(target.node, 1.5)
expect(target.node.idle).toBeFalsy()
target.reset()
expect(target.node.get()).toBe(1)
await global.advanceUntilIdle()
const frames = global.getFrames(spring)
expect(frames.length).toBeGreaterThan(1)
expect(spring.get()).toBe(target.node.get())
})
})
// In the case of an Interpolation, staying attached will prevent
// garbage collection when an animation loop is active, which results
// in a memory leak since the Interpolation stays in the frameloop.
describe('when our last child is detached', () => {
it('detaches from the target', () => {
spring.start({ to: target.node })
// Expect the target node to be attached.
expect(hasFluidObserver(target.node, spring)).toBeTruthy()
// Remove the observer.
removeFluidObserver(spring, observer)
// Expect the target node to be detached.
expect(hasFluidObserver(target.node, spring)).toBeFalsy()
})
})
})
}
function describeGlobals() {
const defaults = { ...Globals }
const resetGlobals = () => Globals.assign(defaults)
describe('"skipAnimation" global', () => {
afterEach(resetGlobals)
it('should skip animations', async () => {
const spring = new SpringValue(0)
global.mockRaf.step()
spring.start(1)
expect(spring.get()).toEqual(0)
await global.advanceUntilIdle()
expect(spring.get()).toEqual(1)
Globals.assign({
skipAnimation: true,
})
spring.start(0)
expect(spring.get()).toEqual(0)
})
it('should skip to end even if delay is present', async () => {
const spring = new SpringValue(0)
global.mockRaf.step()
spring.start(1, { delay: 400 })
expect(spring.get()).toEqual(0)
await global.advanceUntilIdle()
expect(spring.get()).toEqual(1)
Globals.assign({
skipAnimation: true,
})
spring.start(0, {
delay: 400,
})
expect(spring.get()).toEqual(0)
})
it('still calls "onStart", "onChange", and "onRest" props', async () => {
const spring = new SpringValue(0)
const onStart = jest.fn()
const onChange = jest.fn()
const onRest = jest.fn()
Globals.assign({ skipAnimation: true })
await spring.start(1, { onStart, onChange, onRest })
expect(onStart).toBeCalledTimes(1)
expect(onChange).toBeCalledTimes(1)
expect(onRest).toBeCalledTimes(1)
})
})
}
function hasFluidObserver(target: any, observer: FluidObserver) {
const observers = getFluidObservers(target)
return !!observers && observers.has(observer)
}
|
6,327 | 0 | petrpan-code/pmndrs/react-spring/packages/core | petrpan-code/pmndrs/react-spring/packages/core/src/helpers.test.ts | import { inferTo } from './helpers'
import { ReservedProps } from './types/props'
describe('helpers', () => {
it('interpolateTo', () => {
const forwardProps = {
result: 'ok',
}
const restProps = {
from: 'from',
config: 'config',
onStart: 'onStart',
}
const excludeProps: Required<ReservedProps> = {
children: undefined,
config: undefined,
from: undefined,
to: undefined,
ref: undefined,
loop: undefined,
reset: undefined,
pause: undefined,
cancel: undefined,
reverse: undefined,
immediate: undefined,
default: undefined,
delay: undefined,
items: undefined,
trail: undefined,
sort: undefined,
expires: undefined,
initial: undefined,
enter: undefined,
leave: undefined,
update: undefined,
onProps: undefined,
onStart: undefined,
onChange: undefined,
onPause: undefined,
onResume: undefined,
onRest: undefined,
onResolve: undefined,
onDestroyed: undefined,
keys: undefined,
callId: undefined,
parentId: undefined,
}
expect(
inferTo({
...forwardProps,
...restProps,
...excludeProps,
})
).toMatchObject({
...restProps,
...excludeProps,
})
})
})
|
6,330 | 0 | petrpan-code/pmndrs/react-spring/packages/core | petrpan-code/pmndrs/react-spring/packages/core/src/interpolate.test.ts | import { Interpolation } from './Interpolation'
import { Globals } from '@react-spring/shared'
Globals.assign({
to: (...args) => new Interpolation(...args),
})
import { assert, _ } from 'spec.ts'
import { SpringValue } from './SpringValue'
import { to } from './interpolate'
function spring<T>(value: T): SpringValue<T> {
return new SpringValue(value!)
}
describe('AnimatedValue interpolation options', () => {
it('accepts an AnimatedValue and a range shortcut config', () => {
const value = to(spring(1), [0, 1, 2], [4, 5, 6])
expect(value.get()).toBe(5)
})
it('accepts a config object with extrapolate extend', () => {
const value = to(spring(2), {
range: [0, 1],
output: [10, 20],
extrapolate: 'extend',
})
expect(value.get()).toBe(30)
})
it('accepts a config object with extrapolate clamp', () => {
const value = to(spring(100), {
range: [0, 1],
output: [10, 20],
extrapolate: 'clamp',
})
expect(value.get()).toBe(20)
})
it('accepts a config object with extrapolate identity', () => {
const value = to(spring(100), {
output: [10, 20],
extrapolate: 'identity',
})
expect(value.get()).toBe(100)
})
it('accepts an AnimatedValueArray and a range shortcut config', () => {
const value = to(spring([1, 2]), [1, 2], [4, 5])
expect(value.get()).toBe(4)
})
it('accepts multiple AnimatedValues and a range shortcut config', () => {
const value = to(
[spring(2), spring(4)],
[0, 2, 4, 6, 8],
[10, 20, 30, 40, 50]
)
assert(value, _ as Interpolation<number>)
expect(value.get()).toBe(20)
})
it('accepts multiple AnimatedValues and an interpolation function', () => {
const value = to([spring(5), spring('text')] as const, (a, b) => {
assert(a, _ as number)
assert(b, _ as string)
return `t(${a}, ${b})`
})
assert(value, _ as Interpolation<string>)
expect(value.get()).toBe('t(5, text)')
})
it('accepts an AnimatedValueArray and an interpolation function', () => {
const value = to(spring([1, 2, 3]), (r, g, b) => `rgb(${r}, ${g}, ${b})`)
expect(value.get()).toBe('rgba(1, 2, 3, 1)')
})
it('chains interpolations', () => {
const value = to(spring(1), [0, 1], [1, 2])
.to(x => x * 2)
.to([3, 4], [30, 40])
.to(x => x / 2)
expect(value.get()).toBe(20)
})
})
|
6,334 | 0 | petrpan-code/pmndrs/react-spring/packages/core/src | petrpan-code/pmndrs/react-spring/packages/core/src/__snapshots__/Controller.test.ts.snap | // Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Controller can animate a number 1`] = `
[
{
"x": 2.263484330785799,
},
{
"x": 7.615528894993947,
},
{
"x": 14.72729545687759,
},
{
"x": 22.67933293781441,
},
{
"x": 30.85053191603684,
},
{
"x": 38.83524421610096,
},
{
"x": 46.38171205392548,
},
{
"x": 53.346574480369156,
},
{
"x": 59.66146523130329,
},
{
"x": 65.30867180317823,
},
{
"x": 70.30355736424129,
},
{
"x": 74.68200657416291,
},
{
"x": 78.49158337229619,
},
{
"x": 81.78541406742545,
},
{
"x": 84.61805634019797,
},
{
"x": 87.04280232770594,
},
{
"x": 89.11000586164683,
},
{
"x": 90.8661309883985,
},
{
"x": 92.35329941206051,
},
{
"x": 93.60917483504707,
},
{
"x": 94.66706719880813,
},
{
"x": 95.55617327559861,
},
{
"x": 96.30189477450246,
},
{
"x": 96.92619326731115,
},
{
"x": 97.4479544590839,
},
{
"x": 97.88334387327176,
},
{
"x": 98.2461428371077,
},
{
"x": 98.54805845242963,
},
{
"x": 98.7990045563195,
},
{
"x": 99.0073529166361,
},
{
"x": 99.18015536949562,
},
{
"x": 99.3233385117055,
},
{
"x": 99.4418730756026,
},
{
"x": 99.53992035746593,
},
{
"x": 99.62095813165256,
},
{
"x": 99.68788842438258,
},
{
"x": 99.74312938902625,
},
{
"x": 99.78869335076726,
},
{
"x": 99.8262528947063,
},
{
"x": 99.85719667273446,
},
{
"x": 99.8826764105673,
},
{
"x": 100,
},
]
`;
exports[`Controller can animate an array of numbers 1`] = `
[
{
"x": [
1.0905393732314317,
2.1810787464628634,
],
},
{
"x": [
1.3046211557997573,
2.6092423115995147,
],
},
{
"x": [
1.589091818275103,
3.178183636550206,
],
},
{
"x": [
1.9071733175125758,
3.8143466350251516,
],
},
{
"x": [
2.2340212766414735,
4.468042553282947,
],
},
{
"x": [
2.5534097686440376,
5.106819537288075,
],
},
{
"x": [
2.8552684821570185,
5.710536964314037,
],
},
{
"x": [
3.1338629792147654,
6.267725958429531,
],
},
{
"x": [
3.3864586092521307,
6.772917218504261,
],
},
{
"x": [
3.612346872127128,
7.224693744254256,
],
},
{
"x": [
3.8121422945696497,
7.624284589139299,
],
},
{
"x": [
3.987280262966515,
7.97456052593303,
],
},
{
"x": [
4.139663334891849,
8.279326669783698,
],
},
{
"x": [
4.271416562697019,
8.542833125394038,
],
},
{
"x": [
4.3847222536079205,
8.769444507215841,
],
},
{
"x": [
4.481712093108238,
8.963424186216477,
],
},
{
"x": [
4.5644002344658725,
9.128800468931745,
],
},
{
"x": [
4.634645239535937,
9.269290479071874,
],
},
{
"x": [
4.694131976482419,
9.388263952964838,
],
},
{
"x": [
4.7443669934018855,
9.488733986803771,
],
},
{
"x": [
4.786682687952328,
9.573365375904656,
],
},
{
"x": [
4.822246931023949,
9.644493862047899,
],
},
{
"x": [
4.852075790980104,
9.704151581960208,
],
},
{
"x": [
4.877047730692452,
9.754095461384903,
],
},
{
"x": [
4.89791817836336,
9.79583635672672,
],
},
{
"x": [
4.915333754930874,
9.830667509861748,
],
},
{
"x": [
4.929845713484313,
9.859691426968626,
],
},
{
"x": [
4.941922338097189,
9.883844676194379,
],
},
{
"x": [
4.951960182252786,
9.903920364505572,
],
},
{
"x": [
4.96029411666545,
9.9205882333309,
],
},
{
"x": [
4.967206214779832,
9.934412429559664,
],
},
{
"x": [
4.972933540468227,
9.945867080936454,
],
},
{
"x": [
4.97767492302411,
9.95534984604822,
],
},
{
"x": [
4.981596814298641,
9.963193628597281,
],
},
{
"x": [
4.984838325266105,
9.96967665053221,
],
},
{
"x": [
4.9875155369753035,
9.975031073950607,
],
},
{
"x": [
4.989725175561048,
9.979450351122097,
],
},
{
"x": [
4.991547734030691,
9.983095468061382,
],
},
{
"x": [
4.993050115788252,
9.986100231576504,
],
},
{
"x": [
4.994287866909378,
9.988575733818756,
],
},
{
"x": [
4.995027593476066,
9.990614112845385,
],
},
{
"x": [
4.995027593476066,
9.992291713056268,
],
},
{
"x": [
4.995027593476066,
9.99367173585381,
],
},
{
"x": [
4.995027593476066,
9.994806458630702,
],
},
{
"x": [
5,
10,
],
},
]
`;
exports[`Controller the "loop" prop can be combined with the "reverse" prop 1`] = `
[
0.33334,
0.66668,
1,
0.66666,
0.33331999999999995,
0,
0.33334,
0.66668,
1,
]
`;
exports[`Controller when the "to" prop is an async function acts strangely without the "from" prop 1`] = `
[
{
"x": 1.0226348433078583,
},
{
"x": 1.0761552889499395,
},
{
"x": 1.1472729545687759,
},
{
"x": 1.226793329378144,
},
{
"x": 1.3085053191603682,
},
{
"x": 1.3883524421610094,
},
{
"x": 1.4638171205392543,
},
{
"x": 1.5334657448036912,
},
{
"x": 1.5966146523130327,
},
{
"x": 1.6530867180317823,
},
{
"x": 1.7030355736424132,
},
{
"x": 1.74682006574163,
},
{
"x": 1.7849158337229636,
},
{
"x": 1.817854140674256,
},
{
"x": 1.8461805634019814,
},
{
"x": 1.870428023277061,
},
{
"x": 1.8911000586164695,
},
{
"x": 1.9086613098839855,
},
{
"x": 1.9235329941206056,
},
{
"x": 1.9360917483504718,
},
{
"x": 1.9466706719880824,
},
{
"x": 1.9555617327559878,
},
{
"x": 1.9630189477450264,
},
{
"x": 1.9692619326731133,
},
{
"x": 1.9744795445908405,
},
{
"x": 1.9788334387327189,
},
{
"x": 1.9824614283710786,
},
{
"x": 1.9854805845242978,
},
{
"x": 1.9879900455631967,
},
{
"x": 1.9900735291663625,
},
{
"x": 1.991801553694958,
},
{
"x": 1.9932333851170567,
},
{
"x": 1.9944187307560275,
},
{
"x": 1.9953992035746602,
},
{
"x": 1.9962095813165261,
},
{
"x": 1.9968788842438259,
},
{
"x": 1.997431293890262,
},
{
"x": 1.9978869335076728,
},
{
"x": 1.998262528947063,
},
{
"x": 1.9985719667273445,
},
{
"x": 1.9988267641056732,
},
{
"x": 2,
},
]
`;
|
6,335 | 0 | petrpan-code/pmndrs/react-spring/packages/core/src | petrpan-code/pmndrs/react-spring/packages/core/src/__snapshots__/SpringValue.test.ts.snap | // Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`SpringValue can animate a number 1`] = `
[
0.100002,
0.200004,
0.300006,
0.400008,
0.50001,
0.600012,
0.700014,
0.800016,
0.900018,
1,
]
`;
exports[`SpringValue can animate a string 1`] = `
[
"1.00002px 2.00004px",
"2.00004px 4.00008px",
"3.00006px 6.00012px",
"4.00008px 8.00016px",
"5.0001px 10.0002px",
"6.00012px 12.00024px",
"7.00014px 14.00028px",
"8.00016px 16.00032px",
"9.00018px 18.00036px",
"10px 20px",
]
`;
exports[`SpringValue can animate an array of numbers 1`] = `
[
[
1.00002,
2.00004,
],
[
2.00004,
4.00008,
],
[
3.00006,
6.00012,
],
[
4.00008,
8.00016,
],
[
5.0001,
10.0002,
],
[
6.00012,
12.00024,
],
[
7.00014,
14.00028,
],
[
8.00016,
16.00032,
],
[
9.00018,
18.00036,
],
[
10,
20,
],
]
`;
exports[`SpringValue can have an animated string as its target 1`] = `
[
"rgba(255, 255, 0, 1)",
"rgba(255, 229, 0, 1)",
"rgba(255, 204, 0, 1)",
"rgba(255, 178, 0, 1)",
"rgba(255, 153, 0, 1)",
"rgba(255, 127, 0, 1)",
"rgba(255, 102, 0, 1)",
"rgba(255, 76, 0, 1)",
"rgba(255, 51, 0, 1)",
"rgba(255, 25, 0, 1)",
"red",
]
`;
exports[`SpringValue the "loop" prop can be combined with the "reverse" prop 1`] = `
[
0.33334,
0.66668,
1,
0.66666,
0.33331999999999995,
0,
0.33334,
0.66668,
1,
]
`;
exports[`SpringValue the "loop" prop resets the animation once finished 1`] = `
[
0.33334,
0.66668,
1,
]
`;
exports[`SpringValue when "reverse" prop is true swaps the "to" and "from" props 1`] = `
[
0.9773651566921419,
0.9238447110500605,
0.852727045431224,
0.7732066706218559,
0.6914946808396315,
0.6116475578389905,
0.5361828794607453,
0.4665342551963084,
0.4033853476869672,
0.3469132819682177,
0.29696442635758724,
0.2531799342583708,
0.21508416627703766,
0.18214585932574526,
0.15381943659801983,
0.1295719767229399,
0.10889994138353111,
0.09133869011601468,
0.07646700587939456,
0.06390825164952882,
0.05332932801191841,
0.0444382672440135,
0.03698105225497496,
0.030738067326888108,
0.02552045540916056,
0.02116656126728198,
0.01753857162892271,
0.014519415475703344,
0.012009954436804516,
0.009926470833638602,
0.008198446305043062,
0.006766614882944518,
0.005581269243973591,
0.0046007964253405855,
0.0037904186834741348,
0.003121115756173977,
0.0025687061097373425,
0.002113066492326755,
0.0017374710529361444,
0.0014280332726546588,
0.001173235894326376,
0,
]
`;
exports[`SpringValue when "reverse" prop is true works when "from" was set by an earlier update 1`] = `
[
0.9773651566921419,
0.9238447110500605,
0.852727045431224,
0.7732066706218559,
0.6914946808396315,
0.6116475578389905,
0.5361828794607453,
0.4665342551963084,
0.4033853476869672,
0.3469132819682177,
0.29696442635758724,
0.2531799342583708,
0.21508416627703766,
0.18214585932574526,
0.15381943659801983,
0.1295719767229399,
0.10889994138353111,
0.09133869011601468,
0.07646700587939456,
0.06390825164952882,
0.05332932801191841,
0.0444382672440135,
0.03698105225497496,
0.030738067326888108,
0.02552045540916056,
0.02116656126728198,
0.01753857162892271,
0.014519415475703344,
0.012009954436804516,
0.009926470833638602,
0.008198446305043062,
0.006766614882944518,
0.005581269243973591,
0.0046007964253405855,
0.0037904186834741348,
0.003121115756173977,
0.0025687061097373425,
0.002113066492326755,
0.0017374710529361444,
0.0014280332726546588,
0.001173235894326376,
0,
]
`;
exports[`SpringValue when "reverse" prop is true works when "to" and "from" were set by an earlier update 1`] = `
[
0.022634843307857987,
0.07615528894993949,
0.14727295456877587,
0.226793329378144,
0.30850531916036833,
0.3883524421610094,
0.4638171205392546,
0.5334657448036914,
0.5739798090051748,
0.5769314290818427,
0.5557626190736369,
0.5200267363634852,
0.4764105145625939,
0.4295016985132453,
0.38236344286272556,
0.3369622784733687,
0.29448540630343617,
0.25557459185220316,
0.22049742047819276,
0.18927168260884208,
0.16175483826511933,
0.1377075920817319,
0.11683838434304501,
0.0988339093960519,
0.08337948597437063,
0.07017212884873279,
0.05892843425047188,
0.049388836173825494,
0.041319373575113914,
0.03451179641037492,
0.028782605949931907,
0.023971452443943598,
0.019939186165186966,
0.016565764841941392,
0.013748152945448568,
0.011398299719529353,
0.009441248327067157,
0.007813404341311832,
0.006460975252106907,
0.005338581610289848,
0.004408033349647206,
0.00363726055737456,
0.0029993856652006856,
0.0024719230850121722,
0.002036092265339304,
0.0016762306751292224,
0.0013792940991652848,
0.001134432694629231,
0.0009326324005005715,
0.0007664124372832261,
0.0006295707368567502,
0,
]
`;
exports[`SpringValue when "to" prop equals current value avoids interrupting an active animation 1`] = `
[
0.022634843307857987,
0.05403278177365278,
0.07284142865128296,
0.0828538750595177,
0.086845421255966,
0.08683009255947671,
0.0842549750547836,
0.08014705211134462,
0.0752238210530826,
0.06997634488902708,
0.06473137113972319,
0.059697592148462514,
0.05499992314855915,
0.050704753857468414,
0.04683842305057004,
0.04340062433783876,
0.040374037257053644,
0.03773116146592327,
0.03543909060575714,
0.033462778841422576,
0.031767213683302126,
0.030318803092499735,
0.029086205080955534,
0.028040767912793738,
0.022634843307857987,
]
`;
|
6,348 | 0 | petrpan-code/pmndrs/react-spring/packages/core/src | petrpan-code/pmndrs/react-spring/packages/core/src/hooks/useSpring.test.tsx | import * as React from 'react'
import { render, RenderResult } from '@testing-library/react'
import { is } from '@react-spring/shared'
import { Lookup } from '@react-spring/types'
import { SpringContext } from '../SpringContext'
import { SpringValue } from '../SpringValue'
import { SpringRef } from '../SpringRef'
import { useSpring } from './useSpring'
describe('useSpring', () => {
let springs: Lookup<SpringValue>
let ref: SpringRef
// Call the "useSpring" hook and update local variables.
const [update, context] = createUpdater(({ args }) => {
const result = useSpring(...args)
if (is.fun(args[0]) || args.length == 2) {
springs = result[0] as any
ref = result[1]
} else {
springs = result as any
ref = undefined as any
}
return null
})
describe('when only a props object is passed', () => {
it('is updated every render', () => {
update({ x: 0 })
expect(springs.x.goal).toBe(0)
update({ x: 1 })
expect(springs.x.goal).toBe(1)
})
it('does not return a ref', () => {
update({ x: 0 })
expect(ref).toBeUndefined()
})
describe('when SpringContext has "pause={false}"', () => {
it('stays paused if last rendered with "pause: true"', () => {
const props = { from: { t: 0 }, to: { t: 1 } }
// Paused by context.
context.set({ pause: true })
update({ ...props, pause: false })
expect(springs.t.isPaused).toBeTruthy()
// Paused by props and context.
update({ ...props, pause: true })
expect(springs.t.isPaused).toBeTruthy()
// Paused by props.
context.set({ pause: false })
expect(springs.t.isPaused).toBeTruthy()
// Resumed.
update({ ...props, pause: false })
expect(springs.t.isPaused).toBeFalsy()
})
})
})
describe('when both a props object and a deps array are passed', () => {
it('is updated only when a dependency changes', () => {
update({ x: 0 }, [1])
expect(springs.x.goal).toBe(0)
update({ x: 1 }, [1])
expect(springs.x.goal).toBe(0)
update({ x: 1 }, [2])
expect(springs.x.goal).toBe(1)
})
it('returns a ref', () => {
update({ x: 0 }, [1])
testIsRef(ref)
})
})
describe('when only a props function is passed', () => {
it('is never updated on render', () => {
update(() => ({ x: 0 }))
expect(springs.x.goal).toBe(0)
update(() => ({ x: 1 }))
expect(springs.x.goal).toBe(0)
})
it('returns a ref', () => {
update(() => ({ x: 0 }))
testIsRef(ref)
})
})
describe('when both a props function and a deps array are passed', () => {
it('is updated when a dependency changes', () => {
update(() => ({ x: 0 }), [1])
expect(springs.x.goal).toBe(0)
update(() => ({ x: 1 }), [1])
expect(springs.x.goal).toBe(0)
update(() => ({ x: 1 }), [2])
expect(springs.x.goal).toBe(1)
})
it('returns a ref', () => {
update(() => ({ x: 0 }), [1])
testIsRef(ref)
})
})
})
interface TestContext extends SpringContext {
set(values: SpringContext): void
}
function createUpdater(Component: React.ComponentType<{ args: [any, any?] }>) {
let prevElem: JSX.Element | undefined
let result: RenderResult | undefined
const context: TestContext = {
set(values) {
Object.assign(this, values)
if (prevElem) {
renderWithContext(prevElem)
}
},
}
// Ensure `context.set` is ignored.
Object.defineProperty(context, 'set', {
value: context.set,
enumerable: false,
})
afterEach(() => {
result = prevElem = undefined
for (const key in context) {
delete (context as any)[key]
}
})
function renderWithContext(elem: JSX.Element) {
const wrapped = <SpringContext {...context}>{elem}</SpringContext>
if (result) result.rerender(wrapped)
else result = render(wrapped)
return result
}
type Args = Parameters<typeof useSpring>
const update = (...args: [Args[0], Args[1]?]) =>
renderWithContext((prevElem = <Component args={args} />))
return [update, context] as const
}
function testIsRef(ref: SpringRef | null) {
const props = [
'add',
'delete',
'pause',
'resume',
'set',
'start',
'stop',
'update',
'_getProps',
]
props.forEach(prop => expect(ref).toHaveProperty(prop))
}
|
Subsets and Splits