| import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest' |
| import { |
| computed, |
| getCurrentInstance, |
| onScopeDispose, |
| reactive, |
| ref, |
| } from 'vue-demi' |
| import { QueryObserver } from '@tanstack/query-core' |
| import { sleep } from '@tanstack/query-test-utils' |
| import { useQuery } from '../useQuery' |
| import { useBaseQuery } from '../useBaseQuery' |
| import type { Mock, MockedFunction } from 'vitest' |
|
|
| vi.mock('../useQueryClient') |
| vi.mock('../useBaseQuery') |
|
|
| describe('useQuery', () => { |
| beforeEach(() => { |
| vi.useFakeTimers() |
| }) |
|
|
| afterEach(() => { |
| vi.useRealTimers() |
| }) |
|
|
| test('should properly execute query', () => { |
| const queryFn = () => sleep(0).then(() => 'Some data') |
|
|
| useQuery({ |
| queryKey: ['key0'], |
| queryFn, |
| staleTime: 1000, |
| }) |
|
|
| expect(useBaseQuery).toBeCalledWith( |
| QueryObserver, |
| { |
| queryKey: ['key0'], |
| queryFn, |
| staleTime: 1000, |
| }, |
| undefined, |
| ) |
| }) |
|
|
| test('should return pending status initially', () => { |
| const query = useQuery({ |
| queryKey: ['key1'], |
| queryFn: () => sleep(0).then(() => 'Some data'), |
| }) |
|
|
| 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: () => sleep(0).then(() => 'result2'), |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| 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: () => sleep(0).then(() => 'result31'), |
| enabled: true, |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| 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: () => sleep(0).then(() => 'result32'), |
| enabled: true, |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| 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: () => |
| sleep(0).then(() => Promise.reject(new Error('Some error'))), |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| 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: () => sleep(10).then(() => 'Some data'), |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(10) |
|
|
| expect(query).toMatchObject({ |
| status: { value: 'success' }, |
| }) |
|
|
| secondKeyRef.value = 'key8' |
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(query).toMatchObject({ |
| status: { value: 'pending' }, |
| data: { value: undefined }, |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(10) |
|
|
| 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: () => sleep(10).then(() => 'Some data'), |
| enabled, |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(query).toMatchObject({ |
| fetchStatus: { value: 'idle' }, |
| data: { value: undefined }, |
| }) |
|
|
| enabled.value = true |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(query).toMatchObject({ |
| fetchStatus: { value: 'fetching' }, |
| data: { value: undefined }, |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(10) |
|
|
| expect(query).toMatchObject({ |
| status: { value: 'success' }, |
| }) |
| }) |
|
|
| test('should properly execute dependant queries', async () => { |
| const { data } = useQuery({ |
| queryKey: ['dependant1'], |
| queryFn: () => sleep(0).then(() => 'Some data'), |
| }) |
|
|
| const enabled = computed(() => !!data.value) |
|
|
| const dependentQueryFn = vi |
| .fn() |
| .mockImplementation(() => sleep(10).then(() => 'Some data')) |
| 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 vi.advanceTimersByTimeAsync(0) |
|
|
| expect(data.value).toStrictEqual('Some data') |
| expect(fetchStatus.value).toStrictEqual('fetching') |
|
|
| await vi.advanceTimersByTimeAsync(10) |
|
|
| 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: () => sleep(0).then(() => 'Some data'), |
| }) |
|
|
| expect(status.value).toStrictEqual('pending') |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(status.value).toStrictEqual('pending') |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| 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 vi.advanceTimersByTimeAsync(0) |
|
|
| expect(fetchFn).toHaveBeenCalled() |
| }) |
|
|
| test('should allow getters for query keys', async () => { |
| const fetchFn = vi.fn() |
| const key1 = ref('key1') |
| const key2 = ref('key2') |
|
|
| useQuery({ |
| queryKey: ['key', () => key1.value, () => key2.value], |
| queryFn: fetchFn, |
| }) |
|
|
| expect(fetchFn).toHaveBeenCalledTimes(1) |
|
|
| key1.value = 'key3' |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(fetchFn).toHaveBeenCalledTimes(2) |
|
|
| key2.value = 'key4' |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(fetchFn).toHaveBeenCalledTimes(3) |
| }) |
|
|
| test('should allow arbitrarily nested getters for query keys', async () => { |
| const fetchFn = vi.fn() |
| const key1 = ref('key1') |
| const key2 = ref('key2') |
| const key3 = ref('key3') |
| const key4 = ref('key4') |
| const key5 = ref('key5') |
|
|
| useQuery({ |
| queryKey: [ |
| 'key', |
| key1, |
| () => key2.value, |
| { key: () => key3.value }, |
| [{ foo: { bar: () => key4.value } }], |
| () => ({ |
| foo: { |
| bar: { |
| baz: () => key5.value, |
| }, |
| }, |
| }), |
| ], |
| queryFn: fetchFn, |
| }) |
|
|
| expect(fetchFn).toHaveBeenCalledTimes(1) |
|
|
| key1.value = 'key1-updated' |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(fetchFn).toHaveBeenCalledTimes(2) |
|
|
| key2.value = 'key2-updated' |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(fetchFn).toHaveBeenCalledTimes(3) |
|
|
| key3.value = 'key3-updated' |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(fetchFn).toHaveBeenCalledTimes(4) |
|
|
| key4.value = 'key4-updated' |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(fetchFn).toHaveBeenCalledTimes(5) |
|
|
| key5.value = 'key5-updated' |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(fetchFn).toHaveBeenCalledTimes(6) |
| }) |
|
|
| describe('throwOnError', () => { |
| test('should evaluate throwOnError when query is expected to throw', async () => { |
| const boundaryFn = vi.fn() |
| useQuery({ |
| queryKey: ['key'], |
| queryFn: () => |
| sleep(0).then(() => Promise.reject(new Error('Some error'))), |
| retry: false, |
| throwOnError: boundaryFn, |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| 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: () => sleep(0).then(() => 'Some data'), |
| }) |
| const result = query.suspense() |
|
|
| expect(result).toBeInstanceOf(Promise) |
| }) |
|
|
| test('should resolve after being enabled', async () => { |
| const getCurrentInstanceSpy = getCurrentInstance as Mock |
| getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} })) |
|
|
| let afterTimeout = false |
| const isEnabled = ref(false) |
| const query = useQuery({ |
| queryKey: ['suspense2'], |
| queryFn: () => sleep(0).then(() => 'Some data'), |
| enabled: isEnabled, |
| }) |
|
|
| setTimeout(() => { |
| afterTimeout = true |
| isEnabled.value = true |
| }, 200) |
|
|
| query.suspense() |
|
|
| await vi.advanceTimersByTimeAsync(200) |
|
|
| expect(afterTimeout).toBe(true) |
| }) |
|
|
| test('should resolve immediately when stale without refetching', () => { |
| const getCurrentInstanceSpy = getCurrentInstance as Mock |
| getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} })) |
|
|
| const fetcherSpy = vi.fn(() => sleep(0).then(() => 'Some data')) |
|
|
| |
| const query = useQuery({ |
| queryKey: ['suspense3'], |
| queryFn: () => sleep(0).then(() => 'Some data'), |
| staleTime: 10000, |
| initialData: 'foo', |
| }) |
|
|
| return query.suspense().then(() => { |
| expect(fetcherSpy).toHaveBeenCalledTimes(0) |
| }) |
| }) |
|
|
| test('should not throw from suspense by default', async () => { |
| const getCurrentInstanceSpy = getCurrentInstance as Mock |
| getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} })) |
|
|
| const query = useQuery({ |
| queryKey: ['suspense4'], |
| queryFn: () => |
| sleep(0).then(() => Promise.reject(new Error('Some error'))), |
| staleTime: 10000, |
| }) |
|
|
| await vi.advanceTimersByTimeAsync(0) |
|
|
| expect(query).toMatchObject({ |
| status: { value: 'error' }, |
| isError: { value: true }, |
| }) |
| }) |
|
|
| test('should throw from suspense when throwOnError is true', async () => { |
| const getCurrentInstanceSpy = getCurrentInstance as Mock |
| getCurrentInstanceSpy.mockImplementation(() => ({ suspense: {} })) |
|
|
| const boundaryFn = vi.fn() |
| const query = useQuery({ |
| queryKey: ['suspense5'], |
| queryFn: () => |
| sleep(0).then(() => Promise.reject(new Error('Some error'))), |
| staleTime: 10000, |
| throwOnError: boundaryFn, |
| }) |
|
|
| query.suspense() |
|
|
| await vi.advanceTimersByTimeAsync(10000) |
|
|
| expect(boundaryFn).toHaveBeenCalledTimes(2) |
| expect(boundaryFn).toHaveBeenNthCalledWith( |
| 1, |
| Error('Some error'), |
| expect.objectContaining({ |
| state: expect.objectContaining({ status: 'error' }), |
| }), |
| ) |
| expect(boundaryFn).toHaveBeenNthCalledWith( |
| 2, |
| Error('Some error'), |
| expect.objectContaining({ |
| state: expect.objectContaining({ status: 'error' }), |
| }), |
| ) |
| }) |
| }) |
| }) |
|
|
