checkout/__test__/retry-helper.test.ts at f2248d03e574332c604d0b8966e3b35f0caee86c · actions/checkout · 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
import * as core from '@actions/core'
import {RetryHelper} from '../lib/retry-helper'

let info: string[]

describe('retry-helper tests', () => {
  beforeAll(() => {
    // Mock @actions/core info()
    jest.spyOn(core, 'info').mockImplementation((message: string) => {
      info.push(message)
    })
  })

  beforeEach(() => {
    // Reset info
    info = []
  })

  afterAll(() => {
    // Restore
    jest.restoreAllMocks()
  })

  it('first attempt succeeds', async () => {
    const retryHelper: any = new RetryHelper(3, 1, 10)
    const sleep = jest.fn().mockResolvedValue(undefined)
    retryHelper.sleep = sleep

    const actual = await retryHelper.execute(async () => {
      return 'some result'
    })
    expect(actual).toBe('some result')
    expect(info).toHaveLength(0)
    expect(sleep).not.toHaveBeenCalled()
  })

  it('second attempt succeeds', async () => {
    const retryHelper: any = new RetryHelper(3, 1, 10)
    const sleep = jest.fn().mockResolvedValue(undefined)
    retryHelper.sleep = sleep
    let attempts = 0
    const actual = await retryHelper.execute(() => {
      if (++attempts == 1) {
        throw new Error('some error')
      }

      return Promise.resolve('some result')
    })
    expect(attempts).toBe(2)
    expect(actual).toBe('some result')
    expect(info).toHaveLength(2)
    expect(info[0]).toBe('some error')
    expect(info[1]).toBe('Waiting 1 seconds before trying again')
    expect(sleep).toHaveBeenCalledTimes(1)
    expect(sleep).toHaveBeenCalledWith(1)
  })

  it('third attempt succeeds', async () => {
    const retryHelper: any = new RetryHelper(3, 1, 10)
    const sleep = jest.fn().mockResolvedValue(undefined)
    retryHelper.sleep = sleep
    let attempts = 0
    const actual = await retryHelper.execute(() => {
      if (++attempts < 3) {
        throw new Error(`some error ${attempts}`)
      }

      return Promise.resolve('some result')
    })
    expect(attempts).toBe(3)
    expect(actual).toBe('some result')
    expect(info).toHaveLength(4)
    expect(info[0]).toBe('some error 1')
    expect(info[1]).toBe('Waiting 1 seconds before trying again')
    expect(info[2]).toBe('some error 2')
    expect(info[3]).toBe('Waiting 2 seconds before trying again')
    expect(sleep).toHaveBeenCalledTimes(2)
    expect(sleep).toHaveBeenNthCalledWith(1, 1)
    expect(sleep).toHaveBeenNthCalledWith(2, 2)
  })

  it('all attempts fail succeeds', async () => {
    const retryHelper: any = new RetryHelper(3, 1, 10)
    const sleep = jest.fn().mockResolvedValue(undefined)
    retryHelper.sleep = sleep
    let attempts = 0
    let error: Error = null as unknown as Error
    try {
      await retryHelper.execute(() => {
        throw new Error(`some error ${++attempts}`)
      })
    } catch (err) {
      error = err as Error
    }
    expect(error.message).toBe('some error 3')
    expect(attempts).toBe(3)
    expect(info).toHaveLength(4)
    expect(info[0]).toBe('some error 1')
    expect(info[1]).toBe('Waiting 1 seconds before trying again')
    expect(info[2]).toBe('some error 2')
    expect(info[3]).toBe('Waiting 2 seconds before trying again')
    expect(sleep).toHaveBeenCalledTimes(2)
    expect(sleep).toHaveBeenNthCalledWith(1, 1)
    expect(sleep).toHaveBeenNthCalledWith(2, 2)
  })

  it('server-side 500 errors are retried with exponential backoff', async () => {
    const retryHelper: any = new RetryHelper(4, 2, 10)
    const sleep = jest.fn().mockResolvedValue(undefined)
    retryHelper.sleep = sleep
    let attempts = 0

    const actual = await retryHelper.execute(() => {
      if (++attempts < 3) {
        const error: Error & {status?: number} = new Error(
          `server error ${attempts}`
        )
        error.status = 500
        throw error
      }

      return Promise.resolve('some result')
    })

    expect(actual).toBe('some result')
    expect(attempts).toBe(3)
    expect(info).toEqual([
      'server error 1',
      'Waiting 2 seconds before trying again',
      'server error 2',
      'Waiting 4 seconds before trying again'
    ])
    expect(sleep).toHaveBeenCalledTimes(2)
    expect(sleep).toHaveBeenNthCalledWith(1, 2)
    expect(sleep).toHaveBeenNthCalledWith(2, 4)
  })
})