StateMachine.spec.js ➔ ... ➔ describe(ꞌ#terminateꞌ) - Code Metrics - Inspection of "Lots of microbrushing" - ama-team/voxengine-scenario-framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( 249398...dac991 )

by Fike

created 2017-09-04 05:58 UTC

D

↳ Parent: StateMachine.spec.js ➔ ... ➔ describe(ꞌ.StateMachineꞌ)

Complexity

Conditions	9
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
nc	1
dl	0
loc	28
rs	4.909
c	0
b	0
f	0
nop	0

/* eslint-env mocha */
/* eslint-disable no-unused-expressions */

var Sinon = require('sinon')
var Chai = require('chai')
var expect = Chai.expect

Chai.use(require('chai-as-promised'))

var SDK = require('@ama-team/voxengine-sdk')
var Future = SDK.Concurrent.Future

var StateMachine = require('../../../../lib/Execution').StateMachine
var Status = require('../../../../lib/Schema').OperationStatus
var Errors = require('../../../../lib/Error')
var Executor = require('../../../../lib/Execution/Executor').Executor

describe('Integration', function () {
  describe('/Execution', function () {
    describe('/StateMachine.js', function () {
      describe('.StateMachine', function () {
        var context
        var executor

        var entrypointState
        var terminalState
        var redirectingState
        var erroneousState
        var timingOutState
        var infiniteState

        var scenario

        var errorHandler

        var handlerFactory = function (handler, timeout, name) {
          return {
            name: name || 'stub',
            timeout: timeout || null,
            handler: Sinon.spy(handler || function () {})
          }
        }

        var stateFactory = function (id, handler, terminal, timeout) {
          var state = {
            id: id,
            entrypoint: false,
            terminal: !!terminal
          }
          var handlers = ['transition', 'onTransitionTimeout', 'abort', 'onAbortTimeout']
          handlers.forEach(function (name) {
            state[name] = handlerFactory(handler, timeout, name)
          })
          return state
        }

        var scenarioFactory = function () {
          entrypointState.entrypoint = true
          var states = [
            entrypointState,
            terminalState,
            redirectingState,
            erroneousState,
            timingOutState,
            infiniteState
          ]
          scenario = {}
          states.forEach(function (state) {
            scenario[state.id] = state
          })
          return {
            states: scenario,
            onError: errorHandler
          }
        }

        beforeEach(function () {
          context = {}
          executor = new Executor(context)
          terminalState = stateFactory('terminal', function () {}, true)
          entrypointState = stateFactory('entrypoint', function () {
            return {trigger: {id: 'terminal'}}
          })
          redirectingState = stateFactory('redirect', function (_, hints) {
            return {trigger: hints.trigger}
          })
          erroneousState = stateFactory('error', function () {
            throw new Error()
          })
          timingOutState = stateFactory('timeout', function () {
            return new Promise(function () {})
          }, false, 0)
          infiniteState = stateFactory('infinite', function () {
            return new Promise(function () {})
          })
          errorHandler = handlerFactory(function () {}, null, 'onError')
          scenario = scenarioFactory()
        })

        var factory = function (scenario) {
          return new StateMachine(executor, scenario)
        }

        var autoFactory = function () {
          return factory(scenarioFactory())
        }

        describe('< new', function () {
          it('fails if entrypoint state is not provided', function () {
            var lambda = function () {
              var scenario = {
                states: {infinite: infiniteState},
                onError: function () {}
              }
              return new StateMachine(executor, scenario)
            }
            expect(lambda).to.throw(Errors.ScenarioError)
          })
        })

        describe('#run()', function () {
          it('ends if terminal state is reached', function () {
            entrypointState.terminal = true
            var machine = autoFactory()
            return machine
              .run()
              .then(function () {
                var entrypoint = entrypointState.transition.handler
                expect(entrypoint.callCount).to.eq(1)
              })
          })

          it('triggers error handler in case error has been thrown', function () {
            var error = {error: 'imma mighty errro woooooo'}
            entrypointState.transition.handler = Sinon.spy(function () {
              throw error
            })
            var hints = {x: 12}
            var machine = autoFactory()
            return machine
              .run(hints)
              .then(function (result) {
                expect(result.status).to.eq(Status.Failed)
                expect(result.value).to.eq(error)
                expect(errorHandler.handler.callCount).to.eq(1)
                var args = errorHandler.handler.getCall(0).args
                expect(args[0]).to.eq(error)
                expect(args[1]).to.eq(null)
                expect(args[2]).to.eq(entrypointState.id)
                expect(args[3]).to.eq(hints)
              })
          })

          it('tolerates error handler failure', function () {
            var error = {x: 'fake error'}
            entrypointState.transition.handler = Sinon.spy(function () {
              throw error
            })
            errorHandler.handler = Sinon.spy(function () {
              throw new Error()
            })
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Failed)
                expect(result.value).to.eq(error)
                expect(errorHandler.handler.callCount).to.eq(1)
              })
          })

          it('allows error handler to rescue the situation', function () {
            errorHandler.handler = Sinon.spy(function () {
              return {trigger: {id: 'terminal'}}
            })
            entrypointState.transition.handler = Sinon.spy(function () {
              throw new Error()
            })
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Finished)
                expect(errorHandler.handler.callCount).to.eq(1)
              })
          })

          it('triggers next state if `.trigger.id` is present in return value', function () {
            var hints = {x: 12}
            entrypointState.transition.handler = function () {
              return {trigger: {id: 'terminal', hints: hints}}
            }
            terminalState.transition.handler = Sinon.spy(function () {})
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Finished)
                var handler = terminalState.transition.handler
                expect(handler.callCount).to.eq(1)
                expect(handler.getCall(0).args[0]).to.eq(entrypointState.id)
                expect(handler.getCall(0).args[1]).to.deep.eq(hints)
              })
          })

          it('calls `.trigger.hints` in result if it is a function', function () {
            var hints = {x: 12}
            var wrapper = Sinon.spy(function () { return hints })
            entrypointState.transition.handler = function () {}
            entrypointState.triggers = {id: 'terminal', hints: wrapper}
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Finished)
                var handler = terminalState.transition.handler
                expect(handler.callCount).to.eq(1)
                expect(handler.getCall(0).args[0]).to.eq(entrypointState.id)
                expect(handler.getCall(0).args[1]).to.eq(hints)
                expect(wrapper.callCount).to.eq(1)
              })
          })

          it('triggers next state if `.triggers` property is set', function () {
            var hints = {x: 12}
            entrypointState.transition.handler = function () {}
            entrypointState.triggers = {id: 'terminal', hints: hints}
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Finished)
                var handler = terminalState.transition.handler
                expect(handler.callCount).to.eq(1)
                expect(handler.getCall(0).args[0]).to.eq(entrypointState.id)
                expect(handler.getCall(0).args[1]).to.eq(hints)
              })
          })

          it('calls `.triggers.hints` state property if it is a function', function () {
            var hints = {x: 12}
            var wrapper = Sinon.spy(function () { return hints })
            entrypointState.transition.handler = function () {}
            entrypointState.triggers = {id: 'terminal', hints: wrapper}
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Finished)
                var handler = terminalState.transition.handler
                expect(handler.callCount).to.eq(1)
                expect(handler.getCall(0).args[0]).to.eq(entrypointState.id)
                expect(handler.getCall(0).args[1]).to.eq(hints)
                expect(wrapper.callCount).to.eq(1)
              })
          })

          it('reads `.transitionedTo` result property', function () {
            entrypointState.transition.handler = function () {
              return {transitionedTo: 'terminal'}
            }
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Finished)
                expect(machine.getState()).to.eq(terminalState)
              })
          })

          it('terminates with error if `.transitionedTo` specifies nonexistent state', function () {
            entrypointState.transition.handler = function () {
              return {transitionedTo: 'nonexistent'}
            }
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Failed)
                expect(result.value).to.be.instanceOf(Errors.ScenarioError)
              })
          })

          it('terminates with Tripped status if internal error has been ecnountered', function () {
            var error = new Errors.InternalError()
            entrypointState.transition.handler = function () {
              throw error
            }
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Tripped)
                expect(result.value).to.eq(error)
              })
          })
        })

        describe('#transitionTo', function () {
          it('throws if missing state is specified', function () {
            var machine = autoFactory()
            var lambda = function () {
              machine.transitionTo('missing')
            }
            expect(lambda).to.throw(Errors.ScenarioError)
          })

          it('throws if machine has terminated', function () {
            entrypointState.terminal = true
            var machine = autoFactory()
            return machine
              .run()
              .then(function () {
                var lambda = function () {
                  machine.transitionTo('terminal')
                }
                expect(lambda).to.throw(Errors.ScenarioError)
              })
          })

          it('aborts running transition and ignores aborted transition errors', function () {
            var barrier = new Future()
            entrypointState = stateFactory('entrypoint', function () {
              return barrier.then(function () {
                throw new Error()
              })
            })
            var machine = autoFactory()
            var promise = machine.run()
            machine.transitionTo('terminal')
            barrier.resolve()
            return promise
              .then(function (result) {
                expect(result.status).to.eq(Status.Finished)
                expect(terminalState.transition.handler.callCount).to.eq(1)
                expect(entrypointState.abort.handler.callCount).to.eq(1)
              })
          })

          it('can be used to reanimate idle machine', function () {
            entrypointState.transition.handler = function () {}
            var machine = autoFactory()
            return machine
              .transitionTo('entrypoint')
              .then(function () {
                expect(machine.getStatus()).to.eq(StateMachine.Stage.Idle)
                machine.transitionTo('terminal')
                return machine.getTermination()
              })
              .then(function (result) {
                expect(result.status).to.eq(Status.Finished)
              })
          })

          it('tolerates string trigger', function () {
            entrypointState.transition.handler = Sinon.spy(function () {
              // not `trigger.id = ?` as expected
              return {trigger: 'terminal'}
            })
            var machine = autoFactory()
            return machine
              .run()
              .then(function (result) {
                expect(result.status).to.eq(Status.Finished)
                expect(entrypointState.transition.handler.callCount).to.eq(1)
                expect(terminalState.transition.handler.callCount).to.eq(1)
              })
          })
        })

        describe('#terminate', function () {
          it('aborts running transition', function () {
            entrypointState.transition.handler = function () {
              return new Promise(function () {})
            }
            entrypointState.abort.handler = Sinon.spy(function () {})
            var machine = autoFactory()
            machine.run()
            return machine
              .terminate()
              .then(function (result) {
                expect(result.status).to.eq(Status.Aborted)
                expect(entrypointState.abort.handler.callCount).to.eq(1)
              })
          })

          it('throws if called on inactive machine', function () {
            var machine = autoFactory()
            return machine
              .run()
              .then(function () {
                var lambda = function () {
                  machine.terminate()
                }
                expect(lambda).to.throw(Errors.InternalError)
              })
          })
        })

        describe('#getTransition()', function () {
          it('returns running transition', function () {
            entrypointState.transition.handler = function () {
              return new Promise(function () {})
            }
            var machine = autoFactory()
            var hints = {x: 12}
            expect(machine.getTransition()).to.be.null

            machine.run(hints)
            var transition = machine.getTransition()
            expect(transition.getOrigin()).to.eq(null)
            expect(transition.getTarget()).to.eq(entrypointState)
            expect(transition.getHints()).to.eq(hints)
          })

          it('returns null if transition has finished', function () {
            var machine = autoFactory()
            return machine
              .run()
              .then(function () {
                expect(machine.getTransition()).to.be.null

              })
          })
        })

        describe('#getTransitions()', function () {
          it('returns running and aborting transitions', function () {
            var barrier = new Future()
            var handler = function () {
              return barrier
            }
            entrypointState.transition.handler = handler
            entrypointState.abort.handler = handler
            terminalState.transition.handler = handler
            var machine = autoFactory()
            machine.run()
            machine.transitionTo('terminal')
            var transitions = machine.getTransitions()
            expect(transitions).to.have.lengthOf(2)

            expect(transitions[0].getOrigin()).to.be.null

            expect(transitions[0].getTarget()).to.eq(entrypointState)

            expect(transitions[1].getOrigin()).to.be.null

            expect(transitions[1].getTarget()).to.eq(terminalState)
          })
        })

        describe('#getHistory()', function () {
          it('stores up to 100 last history entries', function () {
            this.timeout(2000)
            var counter = 0
            entrypointState.transition.handler = function () {
              if (counter++ < 50) {
                return {trigger: {id: 'entrypoint'}}
              }
              return {trigger: {id: 'terminal'}}
            }
            var machine = autoFactory()
            return machine
              .run()
              .then(function () {
                expect(machine.getHistory()).to.have.lengthOf(100)
              })
          })
        })
      })
    })
  })
})


1			/* eslint-env mocha */
2			/* eslint-disable no-unused-expressions */
3
4			var Sinon = require('sinon')
5			var Chai = require('chai')
6			var expect = Chai.expect
7
8			Chai.use(require('chai-as-promised'))
9
10			var SDK = require('@ama-team/voxengine-sdk')
11			var Future = SDK.Concurrent.Future
12
13			var StateMachine = require('../../../../lib/Execution').StateMachine
14			var Status = require('../../../../lib/Schema').OperationStatus
15			var Errors = require('../../../../lib/Error')
16			var Executor = require('../../../../lib/Execution/Executor').Executor
17
18			describe('Integration', function () {
19			describe('/Execution', function () {
20			describe('/StateMachine.js', function () {
21			describe('.StateMachine', function () {
22			var context
23			var executor
24
25			var entrypointState
26			var terminalState
27			var redirectingState
28			var erroneousState
29			var timingOutState
30			var infiniteState
31
32			var scenario
33
34			var errorHandler
35
36			var handlerFactory = function (handler, timeout, name) {
37			return {
38			name: name \|\| 'stub',
39			timeout: timeout \|\| null,
40			handler: Sinon.spy(handler \|\| function () {})
41			}
42			}
43
44			var stateFactory = function (id, handler, terminal, timeout) {
45			var state = {
46			id: id,
47			entrypoint: false,
48			terminal: !!terminal
49			}
50			var handlers = ['transition', 'onTransitionTimeout', 'abort', 'onAbortTimeout']
51			handlers.forEach(function (name) {
52			state[name] = handlerFactory(handler, timeout, name)
53			})
54			return state
55			}
56
57			var scenarioFactory = function () {
58			entrypointState.entrypoint = true
59			var states = [
60			entrypointState,
61			terminalState,
62			redirectingState,
63			erroneousState,
64			timingOutState,
65			infiniteState
66			]
67			scenario = {}
68			states.forEach(function (state) {
69			scenario[state.id] = state
70			})
71			return {
72			states: scenario,
73			onError: errorHandler
74			}
75			}
76
77			beforeEach(function () {
78			context = {}
79			executor = new Executor(context)
80			terminalState = stateFactory('terminal', function () {}, true)
81			entrypointState = stateFactory('entrypoint', function () {
82			return {trigger: {id: 'terminal'}}
83			})
84			redirectingState = stateFactory('redirect', function (_, hints) {
85			return {trigger: hints.trigger}
86			})
87			erroneousState = stateFactory('error', function () {
88			throw new Error()
89			})
90			timingOutState = stateFactory('timeout', function () {
91			return new Promise(function () {})
92			}, false, 0)
93			infiniteState = stateFactory('infinite', function () {
94			return new Promise(function () {})
95			})
96			errorHandler = handlerFactory(function () {}, null, 'onError')
97			scenario = scenarioFactory()
98			})
99
100			var factory = function (scenario) {
101			return new StateMachine(executor, scenario)
102			}
103
104			var autoFactory = function () {
105			return factory(scenarioFactory())
106			}
107
108			describe('< new', function () {
109			it('fails if entrypoint state is not provided', function () {
110			var lambda = function () {
111			var scenario = {
112			states: {infinite: infiniteState},
113			onError: function () {}
114			}
115			return new StateMachine(executor, scenario)
116			}
117			expect(lambda).to.throw(Errors.ScenarioError)
118			})
119			})
120
121			describe('#run()', function () {
122			it('ends if terminal state is reached', function () {
123			entrypointState.terminal = true
124			var machine = autoFactory()
125			return machine
126			.run()
127			.then(function () {
128			var entrypoint = entrypointState.transition.handler
129			expect(entrypoint.callCount).to.eq(1)
130			})
131			})
132
133			it('triggers error handler in case error has been thrown', function () {
134			var error = {error: 'imma mighty errro woooooo'}
135			entrypointState.transition.handler = Sinon.spy(function () {
136			throw error
137			})
138			var hints = {x: 12}
139			var machine = autoFactory()
140			return machine
141			.run(hints)
142			.then(function (result) {
143			expect(result.status).to.eq(Status.Failed)
144			expect(result.value).to.eq(error)
145			expect(errorHandler.handler.callCount).to.eq(1)
146			var args = errorHandler.handler.getCall(0).args
147			expect(args[0]).to.eq(error)
148			expect(args[1]).to.eq(null)
149			expect(args[2]).to.eq(entrypointState.id)
150			expect(args[3]).to.eq(hints)
151			})
152			})
153
154			it('tolerates error handler failure', function () {
155			var error = {x: 'fake error'}
156			entrypointState.transition.handler = Sinon.spy(function () {
157			throw error
158			})
159			errorHandler.handler = Sinon.spy(function () {
160			throw new Error()
161			})
162			var machine = autoFactory()
163			return machine
164			.run()
165			.then(function (result) {
166			expect(result.status).to.eq(Status.Failed)
167			expect(result.value).to.eq(error)
168			expect(errorHandler.handler.callCount).to.eq(1)
169			})
170			})
171
172			it('allows error handler to rescue the situation', function () {
173			errorHandler.handler = Sinon.spy(function () {
174			return {trigger: {id: 'terminal'}}
175			})
176			entrypointState.transition.handler = Sinon.spy(function () {
177			throw new Error()
178			})
179			var machine = autoFactory()
180			return machine
181			.run()
182			.then(function (result) {
183			expect(result.status).to.eq(Status.Finished)
184			expect(errorHandler.handler.callCount).to.eq(1)
185			})
186			})
187
188			it('triggers next state if `.trigger.id` is present in return value', function () {
189			var hints = {x: 12}
190			entrypointState.transition.handler = function () {
191			return {trigger: {id: 'terminal', hints: hints}}
192			}
193			terminalState.transition.handler = Sinon.spy(function () {})
194			var machine = autoFactory()
195			return machine
196			.run()
197			.then(function (result) {
198			expect(result.status).to.eq(Status.Finished)
199			var handler = terminalState.transition.handler
200			expect(handler.callCount).to.eq(1)
201			expect(handler.getCall(0).args[0]).to.eq(entrypointState.id)
202			expect(handler.getCall(0).args[1]).to.deep.eq(hints)
203			})
204			})
205
206			it('calls `.trigger.hints` in result if it is a function', function () {
207			var hints = {x: 12}
208			var wrapper = Sinon.spy(function () { return hints })
209			entrypointState.transition.handler = function () {}
210			entrypointState.triggers = {id: 'terminal', hints: wrapper}
211			var machine = autoFactory()
212			return machine
213			.run()
214			.then(function (result) {
215			expect(result.status).to.eq(Status.Finished)
216			var handler = terminalState.transition.handler
217			expect(handler.callCount).to.eq(1)
218			expect(handler.getCall(0).args[0]).to.eq(entrypointState.id)
219			expect(handler.getCall(0).args[1]).to.eq(hints)
220			expect(wrapper.callCount).to.eq(1)
221			})
222			})
223
224			it('triggers next state if `.triggers` property is set', function () {
225			var hints = {x: 12}
226			entrypointState.transition.handler = function () {}
227			entrypointState.triggers = {id: 'terminal', hints: hints}
228			var machine = autoFactory()
229			return machine
230			.run()
231			.then(function (result) {
232			expect(result.status).to.eq(Status.Finished)
233			var handler = terminalState.transition.handler
234			expect(handler.callCount).to.eq(1)
235			expect(handler.getCall(0).args[0]).to.eq(entrypointState.id)
236			expect(handler.getCall(0).args[1]).to.eq(hints)
237			})
238			})
239
240			it('calls `.triggers.hints` state property if it is a function', function () {
241			var hints = {x: 12}
242			var wrapper = Sinon.spy(function () { return hints })
243			entrypointState.transition.handler = function () {}
244			entrypointState.triggers = {id: 'terminal', hints: wrapper}
245			var machine = autoFactory()
246			return machine
247			.run()
248			.then(function (result) {
249			expect(result.status).to.eq(Status.Finished)
250			var handler = terminalState.transition.handler
251			expect(handler.callCount).to.eq(1)
252			expect(handler.getCall(0).args[0]).to.eq(entrypointState.id)
253			expect(handler.getCall(0).args[1]).to.eq(hints)
254			expect(wrapper.callCount).to.eq(1)
255			})
256			})
257
258			it('reads `.transitionedTo` result property', function () {
259			entrypointState.transition.handler = function () {
260			return {transitionedTo: 'terminal'}
261			}
262			var machine = autoFactory()
263			return machine
264			.run()
265			.then(function (result) {
266			expect(result.status).to.eq(Status.Finished)
267			expect(machine.getState()).to.eq(terminalState)
268			})
269			})
270
271			it('terminates with error if `.transitionedTo` specifies nonexistent state', function () {
272			entrypointState.transition.handler = function () {
273			return {transitionedTo: 'nonexistent'}
274			}
275			var machine = autoFactory()
276			return machine
277			.run()
278			.then(function (result) {
279			expect(result.status).to.eq(Status.Failed)
280			expect(result.value).to.be.instanceOf(Errors.ScenarioError)
281			})
282			})
283
284			it('terminates with Tripped status if internal error has been ecnountered', function () {
285			var error = new Errors.InternalError()
286			entrypointState.transition.handler = function () {
287			throw error
288			}
289			var machine = autoFactory()
290			return machine
291			.run()
292			.then(function (result) {
293			expect(result.status).to.eq(Status.Tripped)
294			expect(result.value).to.eq(error)
295			})
296			})
297			})
298
299			describe('#transitionTo', function () {
300			it('throws if missing state is specified', function () {
301			var machine = autoFactory()
302			var lambda = function () {
303			machine.transitionTo('missing')
304			}
305			expect(lambda).to.throw(Errors.ScenarioError)
306			})
307
308			it('throws if machine has terminated', function () {
309			entrypointState.terminal = true
310			var machine = autoFactory()
311			return machine
312			.run()
313			.then(function () {
314			var lambda = function () {
315			machine.transitionTo('terminal')
316			}
317			expect(lambda).to.throw(Errors.ScenarioError)
318			})
319			})
320
321			it('aborts running transition and ignores aborted transition errors', function () {
322			var barrier = new Future()
323			entrypointState = stateFactory('entrypoint', function () {
324			return barrier.then(function () {
325			throw new Error()
326			})
327			})
328			var machine = autoFactory()
329			var promise = machine.run()
330			machine.transitionTo('terminal')
331			barrier.resolve()
332			return promise
333			.then(function (result) {
334			expect(result.status).to.eq(Status.Finished)
335			expect(terminalState.transition.handler.callCount).to.eq(1)
336			expect(entrypointState.abort.handler.callCount).to.eq(1)
337			})
338			})
339
340			it('can be used to reanimate idle machine', function () {
341			entrypointState.transition.handler = function () {}
342			var machine = autoFactory()
343			return machine
344			.transitionTo('entrypoint')
345			.then(function () {
346			expect(machine.getStatus()).to.eq(StateMachine.Stage.Idle)
347			machine.transitionTo('terminal')
348			return machine.getTermination()
349			})
350			.then(function (result) {
351			expect(result.status).to.eq(Status.Finished)
352			})
353			})
354
355			it('tolerates string trigger', function () {
356			entrypointState.transition.handler = Sinon.spy(function () {
357			// not `trigger.id = ?` as expected
358			return {trigger: 'terminal'}
359			})
360			var machine = autoFactory()
361			return machine
362			.run()
363			.then(function (result) {
364			expect(result.status).to.eq(Status.Finished)
365			expect(entrypointState.transition.handler.callCount).to.eq(1)
366			expect(terminalState.transition.handler.callCount).to.eq(1)
367			})
368			})
369			})
370
371			describe('#terminate', function () {
372			it('aborts running transition', function () {
373			entrypointState.transition.handler = function () {
374			return new Promise(function () {})
375			}
376			entrypointState.abort.handler = Sinon.spy(function () {})
377			var machine = autoFactory()
378			machine.run()
379			return machine
380			.terminate()
381			.then(function (result) {
382			expect(result.status).to.eq(Status.Aborted)
383			expect(entrypointState.abort.handler.callCount).to.eq(1)
384			})
385			})
386
387			it('throws if called on inactive machine', function () {
388			var machine = autoFactory()
389			return machine
390			.run()
391			.then(function () {
392			var lambda = function () {
393			machine.terminate()
394			}
395			expect(lambda).to.throw(Errors.InternalError)
396			})
397			})
398			})
399
400			describe('#getTransition()', function () {
401			it('returns running transition', function () {
402			entrypointState.transition.handler = function () {
403			return new Promise(function () {})
404			}
405			var machine = autoFactory()
406			var hints = {x: 12}
407			expect(machine.getTransition()).to.be.null
			0 ignored issues – show introduced 2017-09-04 05:58 UTC by Report Bug Copy Issue Report The result of the property access to `expect(machine.getTransition()).to.be.null` is not used. Loading history...
408			machine.run(hints)
409			var transition = machine.getTransition()
410			expect(transition.getOrigin()).to.eq(null)
411			expect(transition.getTarget()).to.eq(entrypointState)
412			expect(transition.getHints()).to.eq(hints)
413			})
414
415			it('returns null if transition has finished', function () {
416			var machine = autoFactory()
417			return machine
418			.run()
419			.then(function () {
420			expect(machine.getTransition()).to.be.null
			0 ignored issues – show introduced 2017-09-04 05:58 UTC by Report Bug Copy Issue Report The result of the property access to `expect(machine.getTransition()).to.be.null` is not used. Loading history...
421			})
422			})
423			})
424
425			describe('#getTransitions()', function () {
426			it('returns running and aborting transitions', function () {
427			var barrier = new Future()
428			var handler = function () {
429			return barrier
430			}
431			entrypointState.transition.handler = handler
432			entrypointState.abort.handler = handler
433			terminalState.transition.handler = handler
434			var machine = autoFactory()
435			machine.run()
436			machine.transitionTo('terminal')
437			var transitions = machine.getTransitions()
438			expect(transitions).to.have.lengthOf(2)
439
440			expect(transitions[0].getOrigin()).to.be.null
			0 ignored issues – show introduced 2017-09-04 05:58 UTC by Report Bug Copy Issue Report The result of the property access to `expect(transitions.0.getOrigin()).to.be.null` is not used. Loading history...
441			expect(transitions[0].getTarget()).to.eq(entrypointState)
442
443			expect(transitions[1].getOrigin()).to.be.null
			0 ignored issues – show introduced 2017-09-04 05:58 UTC by Report Bug Copy Issue Report The result of the property access to `expect(transitions.1.getOrigin()).to.be.null` is not used. Loading history...
444			expect(transitions[1].getTarget()).to.eq(terminalState)
445			})
446			})
447
448			describe('#getHistory()', function () {
449			it('stores up to 100 last history entries', function () {
450			this.timeout(2000)
451			var counter = 0
452			entrypointState.transition.handler = function () {
453			if (counter++ < 50) {
454			return {trigger: {id: 'entrypoint'}}
455			}
456			return {trigger: {id: 'terminal'}}
457			}
458			var machine = autoFactory()
459			return machine
460			.run()
461			.then(function () {
462			expect(machine.getHistory()).to.have.lengthOf(100)
463			})
464			})
465			})
466			})
467			})
468			})
469			})
470

ama-team / voxengine-scenario-framework

Push — dev ( 249398...dac991 )

D

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like