query/packages/query-async-storage-persister/src/__tests__/asyncThrottle.test.ts at 9ad1e29161781b5f1f2cf7571aef596a8824c20a · TanStack/query · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
import { sleep } from '@tanstack/query-test-utils'
import { asyncThrottle } from '../asyncThrottle'

describe('asyncThrottle', () => {
  beforeEach(() => {
    vi.useFakeTimers()
  })

  afterEach(() => {
    vi.useRealTimers()
  })

  test('basic', async () => {
    const interval = 10
    const execTimeStamps: Array<number> = []
    const mockFunc = vi.fn(
      async (id: number, complete?: (value?: unknown) => void) => {
        await sleep(1)
        execTimeStamps.push(Date.now())
        if (complete) {
          complete(id)
        }
      },
    )
    const testFunc = asyncThrottle(mockFunc, { interval })

    testFunc(1)
    await vi.advanceTimersByTimeAsync(1)

    testFunc(2)
    await vi.advanceTimersByTimeAsync(1)

    new Promise((resolve) => testFunc(3, resolve))

    await vi.advanceTimersToNextTimerAsync()
    await vi.advanceTimersByTimeAsync(interval)

    expect(mockFunc).toBeCalledTimes(2)
    expect(mockFunc.mock.calls[1]?.[0]).toBe(3)
    expect(execTimeStamps.length).toBe(2)
    expect(execTimeStamps[1]! - execTimeStamps[0]!).toBeGreaterThanOrEqual(
      interval,
    )
  })

  test('Bug #3331 case 1: Special timing', async () => {
    const interval = 1000
    const execTimeStamps: Array<number> = []
    const mockFunc = vi.fn(
      async (id: number, complete?: (value?: unknown) => void) => {
        await sleep(30)
        execTimeStamps.push(Date.now())
        if (complete) {
          complete(id)
        }
      },
    )
    const testFunc = asyncThrottle(mockFunc, { interval })

    testFunc(1)
    testFunc(2)
    await vi.advanceTimersByTimeAsync(35)
    testFunc(3)
    await vi.advanceTimersByTimeAsync(35)
    new Promise((resolve) => testFunc(4, resolve))

    await vi.advanceTimersToNextTimerAsync()
    await vi.advanceTimersByTimeAsync(interval)

    expect(mockFunc).toBeCalledTimes(2)
    expect(mockFunc.mock.calls[1]?.[0]).toBe(4)
    expect(execTimeStamps.length).toBe(2)
    expect(execTimeStamps[1]! - execTimeStamps[0]!).toBeGreaterThanOrEqual(
      interval,
    )
  })

  test('Bug #3331 case 2: "func" execution time is greater than the interval.', async () => {
    const interval = 1000
    const execTimeStamps: Array<number> = []
    const mockFunc = vi.fn(
      async (id: number, complete?: (value?: unknown) => void) => {
        await sleep(interval + 10)
        execTimeStamps.push(Date.now())
        if (complete) {
          complete(id)
        }
      },
    )
    const testFunc = asyncThrottle(mockFunc, { interval })

    testFunc(1)
    testFunc(2)
    new Promise((resolve) => testFunc(3, resolve))

    await vi.advanceTimersToNextTimerAsync()
    await vi.advanceTimersByTimeAsync(interval + 10)
    await vi.advanceTimersByTimeAsync(interval + 10)

    expect(mockFunc).toBeCalledTimes(2)
    expect(mockFunc.mock.calls[1]?.[0]).toBe(3)
    expect(execTimeStamps.length).toBe(2)
    expect(execTimeStamps[1]! - execTimeStamps[0]!).toBeGreaterThanOrEqual(
      interval,
    )
  })

  test('"func" throw error not break next invoke', async () => {
    const interval = 10

    const mockFunc = vi.fn(
      async (id: number, complete?: (value?: unknown) => void) => {
        if (id === 1) throw new Error('error')
        await sleep(1)
        if (complete) {
          complete(id)
        }
      },
    )
    const testFunc = asyncThrottle(mockFunc, { interval })

    testFunc(1)
    await vi.advanceTimersByTimeAsync(1)

    new Promise((resolve) => testFunc(2, resolve))
    await vi.advanceTimersByTimeAsync(interval)

    expect(mockFunc).toBeCalledTimes(2)
    expect(mockFunc.mock.calls[1]?.[0]).toBe(2)
  })

  test('"onError" should be called when "func" throw error', () => {
    const err = new Error('error')
    const handleError = (e: unknown) => {
      expect(e).toBe(err)
    }

    const testFunc = asyncThrottle(
      () => {
        throw err
      },
      { onError: handleError },
    )
    testFunc()
  })

  test('should throw error when "func" is not a function', () => {
    expect(() => asyncThrottle(1 as any)).toThrow()
  })
})