test(query-core): v5: infiniteQueryBehavior: 100% code coverage (#4994)

* test(query-core): infiniteQueryBehavior: manual pageParam

* test(query-core): infiniteQueryBehavior: query cancellation

* test(query-core): infiniteQueryBehavior: refetch cancel

* test(query-core): infiniteQueryBehavior: no page param

Author: arnaudbzn

packages/query-core/src/tests/infiniteQueryBehavior.test.tsx

@@ -3,8 +3,8 @@ import type {
   QueryClient,
   InfiniteQueryObserverResult,
 } from '@tanstack/query-core'
-import { InfiniteQueryObserver } from '@tanstack/query-core'
-import { createQueryClient, queryKey } from './utils'
+import { InfiniteQueryObserver, CancelledError } from '@tanstack/query-core'
+import { createQueryClient, queryKey, sleep } from './utils'
 
 describe('InfiniteQueryBehavior', () => {
   let queryClient: QueryClient
@@ -179,4 +179,290 @@ describe('InfiniteQueryBehavior', () => {
 
     unsubscribe()
   })
+
+  test('InfiniteQueryBehavior should apply pageParam', async () => {
+    const key = queryKey()
+    let abortSignal: AbortSignal | null = null
+
+    const queryFnSpy = jest.fn().mockImplementation(({ pageParam, signal }) => {
+      abortSignal = signal
+      return pageParam ?? 1
+    })
+
+    const observer = new InfiniteQueryObserver<number>(queryClient, {
+      queryKey: key,
+      queryFn: queryFnSpy,
+    })
+
+    let observerResult:
+      | InfiniteQueryObserverResult<unknown, unknown>
+      | undefined
+
+    const unsubscribe = observer.subscribe((result) => {
+      observerResult = result
+    })
+
+    // Wait for the first page to be fetched
+    await waitFor(() =>
+      expect(observerResult).toMatchObject({
+        isFetching: false,
+        data: { pages: [1], pageParams: [undefined] },
+      }),
+    )
+
+    queryFnSpy.mockClear()
+
+    // Fetch the next page using pageParam
+    await observer.fetchNextPage({ pageParam: 2 })
+
+    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
+      queryKey: key,
+      pageParam: 2,
+      meta: undefined,
+      signal: abortSignal,
+    })
+
+    expect(observerResult).toMatchObject({
+      isFetching: false,
+      data: { pages: [1, 2], pageParams: [undefined, 2] },
+    })
+
+    queryFnSpy.mockClear()
+
+    // Fetch the previous page using pageParam
+    await observer.fetchPreviousPage({ pageParam: 0 })
+
+    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
+      queryKey: key,
+      pageParam: 0,
+      meta: undefined,
+      signal: abortSignal,
+    })
+
+    expect(observerResult).toMatchObject({
+      isFetching: false,
+      data: { pages: [0, 1, 2], pageParams: [0, undefined, 2] },
+    })
+
+    queryFnSpy.mockClear()
+
+    // Refetch pages: old manual page params should be used
+    await observer.refetch()
+
+    expect(queryFnSpy).toHaveBeenCalledTimes(3)
+
+    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
+      queryKey: key,
+      pageParam: 0,
+      meta: undefined,
+      signal: abortSignal,
+    })
+
+    expect(queryFnSpy).toHaveBeenNthCalledWith(2, {
+      queryKey: key,
+      pageParam: undefined,
+      meta: undefined,
+      signal: abortSignal,
+    })
+
+    expect(queryFnSpy).toHaveBeenNthCalledWith(3, {
+      queryKey: key,
+      pageParam: 2,
+      meta: undefined,
+      signal: abortSignal,
+    })
+
+    unsubscribe()
+  })
+
+  test('InfiniteQueryBehavior should support query cancellation', async () => {
+    const key = queryKey()
+    let abortSignal: AbortSignal | null = null
+
+    const queryFnSpy = jest
+      .fn()
+      .mockImplementation(({ pageParam = 1, signal }) => {
+        abortSignal = signal
+        sleep(10)
+        return pageParam
+      })
+
+    const observer = new InfiniteQueryObserver<number>(queryClient, {
+      queryKey: key,
+      queryFn: queryFnSpy,
+      getNextPageParam: (lastPage) => lastPage + 1,
+      getPreviousPageParam: (firstPage) => firstPage - 1,
+    })
+
+    let observerResult:
+      | InfiniteQueryObserverResult<unknown, unknown>
+      | undefined
+
+    const unsubscribe = observer.subscribe((result) => {
+      observerResult = result
+    })
+
+    const query = observer.getCurrentQuery()
+    query.cancel()
+
+    // Wait for the first page to be cancelled
+    await waitFor(() =>
+      expect(observerResult).toMatchObject({
+        isFetching: false,
+        isError: true,
+        error: new CancelledError(),
+        data: undefined,
+      }),
+    )
+
+    expect(queryFnSpy).toHaveBeenCalledTimes(1)
+
+    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
+      queryKey: key,
+      pageParam: undefined,
+      meta: undefined,
+      signal: abortSignal,
+    })
+
+    unsubscribe()
+  })
+
+  test('InfiniteQueryBehavior should not refetch pages if the query is cancelled', async () => {
+    const key = queryKey()
+    let abortSignal: AbortSignal | null = null
+
+    let queryFnSpy = jest
+      .fn()
+      .mockImplementation(({ pageParam = 1, signal }) => {
+        abortSignal = signal
+        return pageParam
+      })
+
+    const observer = new InfiniteQueryObserver<number>(queryClient, {
+      queryKey: key,
+      queryFn: queryFnSpy,
+      getNextPageParam: (lastPage) => lastPage + 1,
+      getPreviousPageParam: (firstPage) => firstPage - 1,
+    })
+
+    let observerResult:
+      | InfiniteQueryObserverResult<unknown, unknown>
+      | undefined
+
+    const unsubscribe = observer.subscribe((result) => {
+      observerResult = result
+    })
+
+    // Wait for the first page to be fetched
+    await waitFor(() =>
+      expect(observerResult).toMatchObject({
+        isFetching: false,
+        data: { pages: [1], pageParams: [undefined] },
+      }),
+    )
+
+    queryFnSpy.mockClear()
+
+    // Fetch the second page
+    await observer.fetchNextPage()
+
+    expect(observerResult).toMatchObject({
+      isFetching: false,
+      data: { pages: [1, 2], pageParams: [undefined, 2] },
+    })
+
+    expect(queryFnSpy).toHaveBeenCalledTimes(1)
+
+    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
+      queryKey: key,
+      pageParam: 2,
+      meta: undefined,
+      signal: abortSignal,
+    })
+
+    queryFnSpy = jest.fn().mockImplementation(({ pageParam = 1, signal }) => {
+      abortSignal = signal
+      sleep(10)
+      return pageParam
+    })
+
+    // Refetch the query
+    observer.refetch()
+    expect(observerResult).toMatchObject({
+      isFetching: true,
+      isError: false,
+    })
+
+    // Cancel the query
+    const query = observer.getCurrentQuery()
+    query.cancel()
+
+    expect(observerResult).toMatchObject({
+      isFetching: false,
+      isError: true,
+      error: new CancelledError(),
+      data: { pages: [1, 2], pageParams: [undefined, 2] },
+    })
+
+    // Pages should not have been fetched
+    expect(queryFnSpy).toHaveBeenCalledTimes(0)
+
+    unsubscribe()
+  })
+
+  test('InfiniteQueryBehavior should return the current pages if no page param can be determined', async () => {
+    const key = queryKey()
+    let abortSignal: AbortSignal | null = null
+
+    const queryFnSpy = jest
+      .fn()
+      .mockImplementation(({ pageParam = 1, signal }) => {
+        abortSignal = signal
+        return pageParam
+      })
+
+    const observer = new InfiniteQueryObserver<number>(queryClient, {
+      queryKey: key,
+      queryFn: queryFnSpy,
+    })
+
+    let observerResult:
+      | InfiniteQueryObserverResult<unknown, unknown>
+      | undefined
+
+    const unsubscribe = observer.subscribe((result) => {
+      observerResult = result
+    })
+
+    // Wait for the first page to be fetched
+    await waitFor(() =>
+      expect(observerResult).toMatchObject({
+        isFetching: false,
+        data: { pages: [1], pageParams: [undefined] },
+      }),
+    )
+
+    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
+      queryKey: key,
+      pageParam: undefined,
+      meta: undefined,
+      signal: abortSignal,
+    })
+
+    queryFnSpy.mockClear()
+
+    // Try to fetch a page without page param and getNextPageParam defined
+    await observer.fetchNextPage()
+
+    // Current pages should be returned
+    expect(observerResult).toMatchObject({
+      isFetching: false,
+      data: { pages: [1], pageParams: [undefined] },
+    })
+
+    // queryFnSpy should not be called
+    expect(queryFnSpy).toBeCalledTimes(0)
+
+    unsubscribe()
+  })
 })