@tanstack/query-core 5.59.17 → 5.60.5

package/src/__tests__/onlineManager.test.tsx

@@ -1,168 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest'
-import { OnlineManager } from '../onlineManager'
-import { setIsServer, sleep } from './utils'
-
-describe('onlineManager', () => {
-  let onlineManager: OnlineManager
-  beforeEach(() => {
-    onlineManager = new OnlineManager()
-  })
-
-  test('isOnline should return true if navigator is undefined', () => {
-    const navigatorSpy = vi.spyOn(globalThis, 'navigator', 'get')
-
-    // Force navigator to be undefined
-    // @ts-expect-error
-    navigatorSpy.mockImplementation(() => undefined)
-    expect(onlineManager.isOnline()).toBeTruthy()
-
-    navigatorSpy.mockRestore()
-  })
-
-  test('isOnline should return true if navigator.onLine is true', () => {
-    const navigatorSpy = vi.spyOn(navigator, 'onLine', 'get')
-    navigatorSpy.mockImplementation(() => true)
-
-    expect(onlineManager.isOnline()).toBeTruthy()
-
-    navigatorSpy.mockRestore()
-  })
-
-  test('setEventListener should use online boolean arg', async () => {
-    let count = 0
-
-    const setup = (setOnline: (online: boolean) => void) => {
-      setTimeout(() => {
-        count++
-        setOnline(false)
-      }, 20)
-      return () => void 0
-    }
-
-    onlineManager.setEventListener(setup)
-
-    await sleep(30)
-    expect(count).toEqual(1)
-    expect(onlineManager.isOnline()).toBeFalsy()
-  })
-
-  test('setEventListener should call previous remove handler when replacing an event listener', () => {
-    const remove1Spy = vi.fn()
-    const remove2Spy = vi.fn()
-
-    onlineManager.setEventListener(() => remove1Spy)
-    onlineManager.setEventListener(() => remove2Spy)
-
-    expect(remove1Spy).toHaveBeenCalledTimes(1)
-    expect(remove2Spy).not.toHaveBeenCalled()
-  })
-
-  test('cleanup (removeEventListener) should not be called if window is not defined', async () => {
-    const restoreIsServer = setIsServer(true)
-
-    const removeEventListenerSpy = vi.spyOn(globalThis, 'removeEventListener')
-
-    const unsubscribe = onlineManager.subscribe(() => undefined)
-
-    unsubscribe()
-
-    expect(removeEventListenerSpy).not.toHaveBeenCalled()
-
-    restoreIsServer()
-  })
-
-  test('cleanup (removeEventListener) should not be called if window.addEventListener is not defined', async () => {
-    const { addEventListener } = globalThis.window
-
-    // @ts-expect-error
-    globalThis.window.addEventListener = undefined
-
-    const removeEventListenerSpy = vi.spyOn(globalThis, 'removeEventListener')
-
-    const unsubscribe = onlineManager.subscribe(() => undefined)
-
-    unsubscribe()
-
-    expect(removeEventListenerSpy).not.toHaveBeenCalled()
-
-    globalThis.window.addEventListener = addEventListener
-  })
-
-  test('it should replace default window listener when a new event listener is set', async () => {
-    const addEventListenerSpy = vi.spyOn(globalThis.window, 'addEventListener')
-
-    const removeEventListenerSpy = vi.spyOn(
-      globalThis.window,
-      'removeEventListener',
-    )
-
-    // Should set the default event listener with window event listeners
-    const unsubscribe = onlineManager.subscribe(() => undefined)
-    expect(addEventListenerSpy).toHaveBeenCalledTimes(2)
-
-    // Should replace the window default event listener by a new one
-    // and it should call window.removeEventListener twice
-    onlineManager.setEventListener(() => {
-      return () => void 0
-    })
-
-    expect(removeEventListenerSpy).toHaveBeenCalledTimes(2)
-
-    unsubscribe()
-    addEventListenerSpy.mockRestore()
-    removeEventListenerSpy.mockRestore()
-  })
-
-  test('should call removeEventListener when last listener unsubscribes', () => {
-    const addEventListenerSpy = vi.spyOn(globalThis.window, 'addEventListener')
-
-    const removeEventListenerSpy = vi.spyOn(
-      globalThis.window,
-      'removeEventListener',
-    )
-
-    const unsubscribe1 = onlineManager.subscribe(() => undefined)
-    const unsubscribe2 = onlineManager.subscribe(() => undefined)
-    expect(addEventListenerSpy).toHaveBeenCalledTimes(2) // online + offline
-
-    unsubscribe1()
-    expect(removeEventListenerSpy).toHaveBeenCalledTimes(0)
-    unsubscribe2()
-    expect(removeEventListenerSpy).toHaveBeenCalledTimes(2) // online + offline
-  })
-
-  test('should keep setup function even if last listener unsubscribes', () => {
-    const setupSpy = vi.fn().mockImplementation(() => () => undefined)
-
-    onlineManager.setEventListener(setupSpy)
-
-    const unsubscribe1 = onlineManager.subscribe(() => undefined)
-
-    expect(setupSpy).toHaveBeenCalledTimes(1)
-
-    unsubscribe1()
-
-    const unsubscribe2 = onlineManager.subscribe(() => undefined)
-
-    expect(setupSpy).toHaveBeenCalledTimes(2)
-
-    unsubscribe2()
-  })
-
-  test('should call listeners when setOnline is called', () => {
-    const listener = vi.fn()
-
-    onlineManager.subscribe(listener)
-
-    onlineManager.setOnline(false)
-    onlineManager.setOnline(false)
-
-    expect(listener).toHaveBeenNthCalledWith(1, false)
-
-    onlineManager.setOnline(true)
-    onlineManager.setOnline(true)
-
-    expect(listener).toHaveBeenCalledTimes(2)
-    expect(listener).toHaveBeenNthCalledWith(2, true)
-  })
-})

package/src/__tests__/queriesObserver.test.tsx

@@ -1,267 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
-import { waitFor } from '@testing-library/react'
-import { QueriesObserver } from '..'
-import { createQueryClient, queryKey, sleep } from './utils'
-import type { QueryClient, QueryObserverResult } from '..'
-
-describe('queriesObserver', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = createQueryClient()
-    queryClient.mount()
-  })
-
-  afterEach(() => {
-    queryClient.clear()
-  })
-
-  test('should return an array with all query results', async () => {
-    const key1 = queryKey()
-    const key2 = queryKey()
-    const queryFn1 = vi.fn().mockReturnValue(1)
-    const queryFn2 = vi.fn().mockReturnValue(2)
-    const observer = new QueriesObserver(queryClient, [
-      { queryKey: key1, queryFn: queryFn1 },
-      { queryKey: key2, queryFn: queryFn2 },
-    ])
-    let observerResult
-    const unsubscribe = observer.subscribe((result) => {
-      observerResult = result
-    })
-    await sleep(1)
-    unsubscribe()
-    expect(observerResult).toMatchObject([{ data: 1 }, { data: 2 }])
-  })
-
-  test('should update when a query updates', async () => {
-    const key1 = queryKey()
-    const key2 = queryKey()
-    const queryFn1 = vi.fn().mockReturnValue(1)
-    const queryFn2 = vi.fn().mockReturnValue(2)
-    const observer = new QueriesObserver(queryClient, [
-      { queryKey: key1, queryFn: queryFn1 },
-      { queryKey: key2, queryFn: queryFn2 },
-    ])
-    const results: Array<Array<QueryObserverResult>> = []
-    results.push(observer.getCurrentResult())
-    const unsubscribe = observer.subscribe((result) => {
-      results.push(result)
-    })
-    await sleep(1)
-    queryClient.setQueryData(key2, 3)
-    await sleep(1)
-    unsubscribe()
-    expect(results.length).toBe(6)
-    expect(results[0]).toMatchObject([
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-    ])
-    expect(results[1]).toMatchObject([
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-    ])
-    expect(results[2]).toMatchObject([
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-    ])
-    expect(results[3]).toMatchObject([
-      { status: 'success', data: 1 },
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-    ])
-    expect(results[4]).toMatchObject([
-      { status: 'success', data: 1 },
-      { status: 'success', data: 2 },
-    ])
-    expect(results[5]).toMatchObject([
-      { status: 'success', data: 1 },
-      { status: 'success', data: 3 },
-    ])
-  })
-
-  test('should update when a query is removed', async () => {
-    const key1 = queryKey()
-    const key2 = queryKey()
-    const queryFn1 = vi.fn().mockReturnValue(1)
-    const queryFn2 = vi.fn().mockReturnValue(2)
-    const observer = new QueriesObserver(queryClient, [
-      { queryKey: key1, queryFn: queryFn1 },
-      { queryKey: key2, queryFn: queryFn2 },
-    ])
-    const results: Array<Array<QueryObserverResult>> = []
-    results.push(observer.getCurrentResult())
-    const unsubscribe = observer.subscribe((result) => {
-      results.push(result)
-    })
-    await sleep(1)
-    observer.setQueries([{ queryKey: key2, queryFn: queryFn2 }])
-    await sleep(1)
-    const queryCache = queryClient.getQueryCache()
-    expect(queryCache.find({ queryKey: key1, type: 'active' })).toBeUndefined()
-    expect(queryCache.find({ queryKey: key2, type: 'active' })).toBeDefined()
-    unsubscribe()
-    expect(queryCache.find({ queryKey: key1, type: 'active' })).toBeUndefined()
-    expect(queryCache.find({ queryKey: key2, type: 'active' })).toBeUndefined()
-    expect(results.length).toBe(6)
-    expect(results[0]).toMatchObject([
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-    ])
-    expect(results[1]).toMatchObject([
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-    ])
-    expect(results[2]).toMatchObject([
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-    ])
-    expect(results[3]).toMatchObject([
-      { status: 'success', data: 1 },
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-    ])
-    expect(results[4]).toMatchObject([
-      { status: 'success', data: 1 },
-      { status: 'success', data: 2 },
-    ])
-    expect(results[5]).toMatchObject([{ status: 'success', data: 2 }])
-  })
-
-  test('should update when a query changed position', async () => {
-    const key1 = queryKey()
-    const key2 = queryKey()
-    const queryFn1 = vi.fn().mockReturnValue(1)
-    const queryFn2 = vi.fn().mockReturnValue(2)
-    const observer = new QueriesObserver(queryClient, [
-      { queryKey: key1, queryFn: queryFn1 },
-      { queryKey: key2, queryFn: queryFn2 },
-    ])
-    const results: Array<Array<QueryObserverResult>> = []
-    results.push(observer.getCurrentResult())
-    const unsubscribe = observer.subscribe((result) => {
-      results.push(result)
-    })
-    await sleep(1)
-    observer.setQueries([
-      { queryKey: key2, queryFn: queryFn2 },
-      { queryKey: key1, queryFn: queryFn1 },
-    ])
-    await sleep(1)
-    unsubscribe()
-    expect(results.length).toBe(6)
-    expect(results[0]).toMatchObject([
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-    ])
-    expect(results[1]).toMatchObject([
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-    ])
-    expect(results[2]).toMatchObject([
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-    ])
-    expect(results[3]).toMatchObject([
-      { status: 'success', data: 1 },
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-    ])
-    expect(results[4]).toMatchObject([
-      { status: 'success', data: 1 },
-      { status: 'success', data: 2 },
-    ])
-    expect(results[5]).toMatchObject([
-      { status: 'success', data: 2 },
-      { status: 'success', data: 1 },
-    ])
-  })
-
-  test('should not update when nothing has changed', async () => {
-    const key1 = queryKey()
-    const key2 = queryKey()
-    const queryFn1 = vi.fn().mockReturnValue(1)
-    const queryFn2 = vi.fn().mockReturnValue(2)
-    const observer = new QueriesObserver(queryClient, [
-      { queryKey: key1, queryFn: queryFn1 },
-      { queryKey: key2, queryFn: queryFn2 },
-    ])
-    const results: Array<Array<QueryObserverResult>> = []
-    results.push(observer.getCurrentResult())
-    const unsubscribe = observer.subscribe((result) => {
-      results.push(result)
-    })
-    await sleep(1)
-    observer.setQueries([
-      { queryKey: key1, queryFn: queryFn1 },
-      { queryKey: key2, queryFn: queryFn2 },
-    ])
-    await sleep(1)
-    unsubscribe()
-    expect(results.length).toBe(5)
-    expect(results[0]).toMatchObject([
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-    ])
-    expect(results[1]).toMatchObject([
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-      { status: 'pending', fetchStatus: 'idle', data: undefined },
-    ])
-    expect(results[2]).toMatchObject([
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-    ])
-    expect(results[3]).toMatchObject([
-      { status: 'success', data: 1 },
-      { status: 'pending', fetchStatus: 'fetching', data: undefined },
-    ])
-    expect(results[4]).toMatchObject([
-      { status: 'success', data: 1 },
-      { status: 'success', data: 2 },
-    ])
-  })
-
-  test('should trigger all fetches when subscribed', async () => {
-    const key1 = queryKey()
-    const key2 = queryKey()
-    const queryFn1 = vi.fn().mockReturnValue(1)
-    const queryFn2 = vi.fn().mockReturnValue(2)
-    const observer = new QueriesObserver(queryClient, [
-      { queryKey: key1, queryFn: queryFn1 },
-      { queryKey: key2, queryFn: queryFn2 },
-    ])
-    const unsubscribe = observer.subscribe(() => undefined)
-    await sleep(1)
-    unsubscribe()
-    expect(queryFn1).toHaveBeenCalledTimes(1)
-    expect(queryFn2).toHaveBeenCalledTimes(1)
-  })
-
-  test('should not destroy the observer if there is still a subscription', async () => {
-    const key1 = queryKey()
-    const observer = new QueriesObserver(queryClient, [
-      {
-        queryKey: key1,
-        queryFn: async () => {
-          await sleep(20)
-          return 1
-        },
-      },
-    ])
-
-    const subscription1Handler = vi.fn()
-    const subscription2Handler = vi.fn()
-
-    const unsubscribe1 = observer.subscribe(subscription1Handler)
-    const unsubscribe2 = observer.subscribe(subscription2Handler)
-
-    unsubscribe1()
-
-    await waitFor(() => {
-      // 1 call: pending
-      expect(subscription1Handler).toBeCalledTimes(1)
-      // 1 call: success
-      expect(subscription2Handler).toBeCalledTimes(1)
-    })
-
-    // Clean-up
-    unsubscribe2()
-  })
-})