CodeceptJS/test/unit/pause_test.js at b446ad5bb4a4dbfe50633657b64f3fb7079371ff · codeceptjs/CodeceptJS · 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
import { expect } from 'chai'
import sinon from 'sinon'
import pause, { setPauseHandler, pauseNow } from '../../lib/pause.js'
import recorder from '../../lib/recorder.js'
import event from '../../lib/event.js'
import store from '../../lib/store.js'

const settles = (promise, ms = 2000) =>
  Promise.race([
    promise,
    new Promise((_, reject) => {
      const t = setTimeout(() => reject(new Error(`did not settle within ${ms}ms`)), ms)
      t.unref?.()
    }),
  ])

describe('pause external handler hook', () => {
  afterEach(() => {
    setPauseHandler(null)
  })

  it('setPauseHandler is exported and callable', () => {
    expect(typeof setPauseHandler).to.equal('function')
    expect(() => setPauseHandler(() => Promise.resolve())).to.not.throw()
    expect(() => setPauseHandler(null)).to.not.throw()
  })

  it('handler receives registered variables and returns a Promise', async () => {
    let received = null
    const handler = arg => {
      received = arg
      return Promise.resolve()
    }
    setPauseHandler(handler)
    // Drive the handler directly to verify the contract
    const p = handler({ registeredVariables: { foo: 1 } })
    expect(p).to.be.a('promise')
    await p
    expect(received).to.deep.equal({ registeredVariables: { foo: 1 } })
  })
})

describe('pause listener lifecycle', () => {
  beforeEach(() => {
    store.dryRun = false
    setPauseHandler(null)
    recorder.reset()
    recorder.stop()
  })

  afterEach(() => {
    setPauseHandler(null)
    event.dispatcher.emit(event.test.finished)
    recorder.reset()
  })

  it('keeps exactly one listener no matter how many pause() calls', () => {
    const baseStep = event.dispatcher.listenerCount(event.step.after)
    const baseFin = event.dispatcher.listenerCount(event.test.finished)
    pause()
    pause()
    pause()
    expect(event.dispatcher.listenerCount(event.step.after)).to.equal(baseStep + 1)
    expect(event.dispatcher.listenerCount(event.test.finished)).to.equal(baseFin + 1)
  })

  it('removes both pause listeners when the test finishes', () => {
    const baseStep = event.dispatcher.listenerCount(event.step.after)
    const baseFin = event.dispatcher.listenerCount(event.test.finished)
    pause()
    expect(event.dispatcher.listenerCount(event.step.after)).to.equal(baseStep + 1)
    event.dispatcher.emit(event.test.finished)
    expect(event.dispatcher.listenerCount(event.step.after)).to.equal(baseStep)
    expect(event.dispatcher.listenerCount(event.test.finished)).to.equal(baseFin)
  })

  it('does not restore the pause session when none is open on test.finished', async () => {
    pause()
    recorder.start()
    const restoreSpy = sinon.spy(recorder.session, 'restore')
    event.dispatcher.emit(event.test.finished)
    event.dispatcher.emit(event.test.finished)
    const pauseRestores = restoreSpy.getCalls().filter(c => c.args[0] === 'pause').length
    restoreSpy.restore()
    expect(pauseRestores, 'no pause restore when nothing is open').to.equal(0)
    expect(recorder.getCurrentSessionId()).to.equal(null)
    await settles(recorder.promise())
  })

  it('pauseNow drives the external handler and restores the session', async () => {
    let received = null
    setPauseHandler(arg => {
      received = arg
      return Promise.resolve()
    })
    recorder.start()
    pauseNow({ foo: 1 })
    await settles(recorder.promise())
    expect(received).to.deep.equal({ registeredVariables: { foo: 1 } })
    expect(recorder.getCurrentSessionId()).to.equal(null)
  })
})