FilesExpand file tree

main

/

coalesced-probe.test.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

74 lines (62 loc) · 2.42 KB

main

/

coalesced-probe.test.ts

Copy path

Top

File metadata and controls

• Code
• Blame

74 lines (62 loc) · 2.42 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'

import { runCoalescedProbe, type CoalescedProbes } from './coalesced-probe'

function deferred<T>(): {

promise: Promise<T>

resolve: (value: T) => void

reject: (error: unknown) => void

} {

let resolve: (value: T) => void = () => {}

let reject: (error: unknown) => void = () => {}

const promise = new Promise<T>((settle, fail) => {

resolve = settle

reject = fail

})

return { promise, resolve, reject }

}

describe('runCoalescedProbe', () => {

beforeEach(() => {

vi.useFakeTimers()

vi.setSystemTime(1_000_000)

})

afterEach(() => {

vi.useRealTimers()

})

it('replaces a stale probe without letting the older cleanup remove its successor', async () => {

const probes: CoalescedProbes<string> = new Map()

const first = deferred<string>()

const second = deferred<string>()

const createProbe = vi

.fn<() => Promise<string>>()

.mockReturnValueOnce(first.promise)

.mockReturnValueOnce(second.promise)

const firstRequest = runCoalescedProbe(probes, 'repo', createProbe, 60_000)

vi.setSystemTime(1_060_001)

const secondRequest = runCoalescedProbe(probes, 'repo', createProbe, 60_000)

expect(createProbe).toHaveBeenCalledTimes(2)

first.resolve('old')

await expect(firstRequest).resolves.toBe('old')

const joinedRequest = runCoalescedProbe(probes, 'repo', createProbe, 60_000)

expect(createProbe).toHaveBeenCalledTimes(2)

second.resolve('new')

await expect(secondRequest).resolves.toBe('new')

await expect(joinedRequest).resolves.toBe('new')

expect(probes).toEqual(new Map())

})

it('removes a settled probe only when it still owns the key', async () => {

const probes: CoalescedProbes<string> = new Map()

const first = deferred<string>()

const second = deferred<string>()

const createProbe = vi

.fn<() => Promise<string>>()

.mockReturnValueOnce(first.promise)

.mockReturnValueOnce(second.promise)

const firstRequest = runCoalescedProbe(probes, 'repo', createProbe, 1)

vi.advanceTimersByTime(2)

const secondRequest = runCoalescedProbe(probes, 'repo', createProbe, 1)

first.reject(new Error('old probe failed'))

await expect(firstRequest).rejects.toThrow('old probe failed')

expect(probes.get('repo')?.promise).toBe(second.promise)

second.resolve('new')

await expect(secondRequest).resolves.toBe('new')

})

})