//-----------------------------------------------------------------------------

QUnit.module("async");

//-----------------------------------------------------------------------------

test("state transitions", function() {

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'warn', from: 'green', to: 'yellow' },

{ name: 'panic', from: 'yellow', to: 'red' },

{ name: 'calm', from: 'red', to: 'yellow' },

{ name: 'clear', from: 'yellow', to: 'green' }

],

callbacks: {

onleavegreen: function() { return StateMachine.ASYNC; },

onleaveyellow: function() { return StateMachine.ASYNC; },

onleavered: function() { return StateMachine.ASYNC; }

}

});

equal(fsm.current, 'green', "initial state should be green");

fsm.warn(); equal(fsm.current, 'green', "should still be green because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

fsm.panic(); equal(fsm.current, 'yellow', "should still be yellow because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'red', "panic event should transition from yellow to red");

fsm.calm(); equal(fsm.current, 'red', "should still be red because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'yellow', "calm event should transition from red to yellow");

fsm.clear(); equal(fsm.current, 'yellow', "should still be yellow because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'green', "clear event should transition from yellow to green");

});

//-----------------------------------------------------------------------------

test("state transitions with delays", function() {

stop(); // doing async stuff - dont run next qunit test until I call start() below

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'warn', from: 'green', to: 'yellow' },

{ name: 'panic', from: 'yellow', to: 'red' },

{ name: 'calm', from: 'red', to: 'yellow' },

{ name: 'clear', from: 'yellow', to: 'green' }

],

callbacks: {

onleavegreen: function() { return StateMachine.ASYNC; },

onleaveyellow: function() { return StateMachine.ASYNC; },

onleavered: function() { return StateMachine.ASYNC; }

}

});

equal(fsm.current, 'green', "initial state should be green");

fsm.warn(); equal(fsm.current, 'green', "should still be green because we haven't transitioned yet");

setTimeout(function() {

fsm.transition(); equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

fsm.panic(); equal(fsm.current, 'yellow', "should still be yellow because we haven't transitioned yet");

setTimeout(function() {

fsm.transition(); equal(fsm.current, 'red', "panic event should transition from yellow to red");

fsm.calm(); equal(fsm.current, 'red', "should still be red because we haven't transitioned yet");

setTimeout(function() {

fsm.transition(); equal(fsm.current, 'yellow', "calm event should transition from red to yellow");

fsm.clear(); equal(fsm.current, 'yellow', "should still be yellow because we haven't transitioned yet");

setTimeout(function() {

fsm.transition(); equal(fsm.current, 'green', "clear event should transition from yellow to green");

start();

}, 10);

}, 10);

}, 10);

}, 10);

});

//-----------------------------------------------------------------------------

test("state transition fired during onleavestate callback - immediate", function() {

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'warn', from: 'green', to: 'yellow' },

{ name: 'panic', from: 'yellow', to: 'red' },

{ name: 'calm', from: 'red', to: 'yellow' },

{ name: 'clear', from: 'yellow', to: 'green' }

],

callbacks: {

onleavegreen: function() { this.transition(); return StateMachine.ASYNC; },

onleaveyellow: function() { this.transition(); return StateMachine.ASYNC; },

onleavered: function() { this.transition(); return StateMachine.ASYNC; }

}

});

equal(fsm.current, 'green', "initial state should be green");

fsm.warn(); equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

fsm.panic(); equal(fsm.current, 'red', "panic event should transition from yellow to red");

fsm.calm(); equal(fsm.current, 'yellow', "calm event should transition from red to yellow");

fsm.clear(); equal(fsm.current, 'green', "clear event should transition from yellow to green");

});

//-----------------------------------------------------------------------------

test("state transition fired during onleavestate callback - with delay", function() {

stop(); // doing async stuff - dont run next qunit test until I call start() below

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'panic', from: 'green', to: 'red' }

],

callbacks: {

onleavegreen: function() { setTimeout(function() { fsm.transition(); }, 10); return StateMachine.ASYNC; },

onenterred: function() {

equal(fsm.current, 'red', "panic event should transition from green to red");

start();

}

}

});

equal(fsm.current, 'green', "initial state should be green");

fsm.panic(); equal(fsm.current, 'green', "should still be green because we haven't transitioned yet");

});

//-----------------------------------------------------------------------------

test("state transition fired during onleavestate callback - but forgot to return ASYNC!", function() {

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'warn', from: 'green', to: 'yellow' },

{ name: 'panic', from: 'yellow', to: 'red' },

{ name: 'calm', from: 'red', to: 'yellow' },

{ name: 'clear', from: 'yellow', to: 'green' }

],

callbacks: {

onleavegreen: function() { this.transition(); /* return StateMachine.ASYNC; */ },

onleaveyellow: function() { this.transition(); /* return StateMachine.ASYNC; */ },

onleavered: function() { this.transition(); /* return StateMachine.ASYNC; */ }

}

});

equal(fsm.current, 'green', "initial state should be green");

fsm.warn(); equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

fsm.panic(); equal(fsm.current, 'red', "panic event should transition from yellow to red");

fsm.calm(); equal(fsm.current, 'yellow', "calm event should transition from red to yellow");

fsm.clear(); equal(fsm.current, 'green', "clear event should transition from yellow to green");

});

//-----------------------------------------------------------------------------

test("state transitions sometimes synchronous and sometimes asynchronous", function() {

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'warn', from: 'green', to: 'yellow' },

{ name: 'panic', from: 'yellow', to: 'red' },

{ name: 'calm', from: 'red', to: 'yellow' },

{ name: 'clear', from: 'yellow', to: 'green' }

]

});

// default behavior is synchronous

equal(fsm.current, 'green', "initial state should be green");

fsm.warn(); equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

fsm.panic(); equal(fsm.current, 'red', "panic event should transition from yellow to red");

fsm.calm(); equal(fsm.current, 'yellow', "calm event should transition from red to yellow");

fsm.clear(); equal(fsm.current, 'green', "clear event should transition from yellow to green");

// but add callbacks that return ASYNC and it magically becomes asynchronous

fsm.onleavegreen = function() { return StateMachine.ASYNC; }

fsm.onleaveyellow = function() { return StateMachine.ASYNC; }

fsm.onleavered = function() { return StateMachine.ASYNC; }

equal(fsm.current, 'green', "initial state should be green");

fsm.warn(); equal(fsm.current, 'green', "should still be green because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

fsm.panic(); equal(fsm.current, 'yellow', "should still be yellow because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'red', "panic event should transition from yellow to red");

fsm.calm(); equal(fsm.current, 'red', "should still be red because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'yellow', "calm event should transition from red to yellow");

fsm.clear(); equal(fsm.current, 'yellow', "should still be yellow because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'green', "clear event should transition from yellow to green");

// this allows you to make on-the-fly decisions about whether async or not ...

fsm.onleavegreen = function(event, from, to, async) {

if (async) {

setTimeout(function() {

fsm.transition(); equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

start(); // move on to next test

}, 10);

return StateMachine.ASYNC;

}

}

fsm.onleaveyellow = fsm.onleavered = null;

fsm.warn(false); equal(fsm.current, 'yellow', "expected synchronous transition from green to yellow");

fsm.clear(); equal(fsm.current, 'green', "clear event should transition from yellow to green");

fsm.warn(true); equal(fsm.current, 'green', "should still be green because we haven't transitioned yet");

stop(); // doing async stuff - dont run next qunit test until I call start() in callback above

});

//-----------------------------------------------------------------------------

test("state transition fired without completing previous transition", function() {

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'warn', from: 'green', to: 'yellow' },

{ name: 'panic', from: 'yellow', to: 'red' },

{ name: 'calm', from: 'red', to: 'yellow' },

{ name: 'clear', from: 'yellow', to: 'green' }

],

callbacks: {

onleavegreen: function() { return StateMachine.ASYNC; },

onleaveyellow: function() { return StateMachine.ASYNC; },

onleavered: function() { return StateMachine.ASYNC; }

}

});

equal(fsm.current, 'green', "initial state should be green");

fsm.warn(); equal(fsm.current, 'green', "should still be green because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

fsm.panic(); equal(fsm.current, 'yellow', "should still be yellow because we haven't transitioned yet");

throws(fsm.calm.bind(fsm), /event calm inappropriate because previous transition did not complete/);

});

//-----------------------------------------------------------------------------

test("state transition can be cancelled (github issue #22)", function() {

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'warn', from: 'green', to: 'yellow' },

{ name: 'panic', from: 'yellow', to: 'red' },

{ name: 'calm', from: 'red', to: 'yellow' },

{ name: 'clear', from: 'yellow', to: 'green' }

],

callbacks: {

onleavegreen: function() { return StateMachine.ASYNC; },

onleaveyellow: function() { return StateMachine.ASYNC; },

onleavered: function() { return StateMachine.ASYNC; }

}

});

equal(fsm.current, 'green', "initial state should be green");

fsm.warn(); equal(fsm.current, 'green', "should still be green because we haven't transitioned yet");

fsm.transition(); equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

fsm.panic(); equal(fsm.current, 'yellow', "should still be yellow because we haven't transitioned yet");

equal(fsm.can('panic'), false, "but cannot panic a 2nd time because a transition is still pending")

throws(fsm.panic.bind(fsm), /event panic inappropriate because previous transition did not complete/);

fsm.transition.cancel();

equal(fsm.current, 'yellow', "should still be yellow because we cancelled the async transition");

equal(fsm.can('panic'), true, "can now panic again because we cancelled previous async transition");

fsm.panic();

fsm.transition();

equal(fsm.current, 'red', "should finally be red now that we completed the async transition");

});

//-----------------------------------------------------------------------------

test("callbacks are ordered correctly", function() {

var called = [];

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'warn', from: 'green', to: 'yellow' },

{ name: 'panic', from: 'yellow', to: 'red' },

{ name: 'calm', from: 'red', to: 'yellow' },

{ name: 'clear', from: 'yellow', to: 'green' },

],

callbacks: {

// generic callbacks

onbeforeevent: function(event,from,to) { called.push('onbefore(' + event + ')'); },

onafterevent: function(event,from,to) { called.push('onafter(' + event + ')'); },

onleavestate: function(event,from,to) { called.push('onleave(' + from + ')'); },

onenterstate: function(event,from,to) { called.push('onenter(' + to + ')'); },

onchangestate: function(event,from,to) { called.push('onchange(' + from + ',' + to + ')'); },

// specific state callbacks

onentergreen: function() { called.push('onentergreen'); },

onenteryellow: function() { called.push('onenteryellow'); },

onenterred: function() { called.push('onenterred'); },

onleavegreen: function() { called.push('onleavegreen'); return StateMachine.ASYNC; },

onleaveyellow: function() { called.push('onleaveyellow'); return StateMachine.ASYNC; },

onleavered: function() { called.push('onleavered'); return StateMachine.ASYNC; },

// specific event callbacks

onbeforewarn: function() { called.push('onbeforewarn'); },

onbeforepanic: function() { called.push('onbeforepanic'); },

onbeforecalm: function() { called.push('onbeforecalm'); },

onbeforeclear: function() { called.push('onbeforeclear'); },

onafterwarn: function() { called.push('onafterwarn'); },

onafterpanic: function() { called.push('onafterpanic'); },

onaftercalm: function() { called.push('onaftercalm'); },

onafterclear: function() { called.push('onafterclear'); }

}

});

called = [];

fsm.warn(); deepEqual(called, ['onbeforewarn', 'onbefore(warn)', 'onleavegreen', 'onleave(green)']);

fsm.transition(); deepEqual(called, ['onbeforewarn', 'onbefore(warn)', 'onleavegreen', 'onleave(green)', 'onenteryellow', 'onenter(yellow)', 'onchange(green,yellow)', 'onafterwarn', 'onafter(warn)']);

called = [];

fsm.panic(); deepEqual(called, ['onbeforepanic', 'onbefore(panic)', 'onleaveyellow', 'onleave(yellow)']);

fsm.transition(); deepEqual(called, ['onbeforepanic', 'onbefore(panic)', 'onleaveyellow', 'onleave(yellow)', 'onenterred', 'onenter(red)', 'onchange(yellow,red)', 'onafterpanic', 'onafter(panic)']);

called = [];

fsm.calm(); deepEqual(called, ['onbeforecalm', 'onbefore(calm)', 'onleavered', 'onleave(red)']);

fsm.transition(); deepEqual(called, ['onbeforecalm', 'onbefore(calm)', 'onleavered', 'onleave(red)', 'onenteryellow', 'onenter(yellow)', 'onchange(red,yellow)', 'onaftercalm', 'onafter(calm)']);

called = [];

fsm.clear(); deepEqual(called, ['onbeforeclear', 'onbefore(clear)', 'onleaveyellow', 'onleave(yellow)']);

fsm.transition(); deepEqual(called, ['onbeforeclear', 'onbefore(clear)', 'onleaveyellow', 'onleave(yellow)', 'onentergreen', 'onenter(green)', 'onchange(yellow,green)', 'onafterclear', 'onafter(clear)']);

});

//-----------------------------------------------------------------------------

test("cannot fire event during existing transition", function() {

var fsm = StateMachine.create({

initial: 'green',

events: [

{ name: 'warn', from: 'green', to: 'yellow' },

{ name: 'panic', from: 'yellow', to: 'red' },

{ name: 'calm', from: 'red', to: 'yellow' },

{ name: 'clear', from: 'yellow', to: 'green' }

],

callbacks: {

onleavegreen: function() { return StateMachine.ASYNC; },

onleaveyellow: function() { return StateMachine.ASYNC; },

onleavered: function() { return StateMachine.ASYNC; }

}

});

equal(fsm.current, 'green', "initial state should be green");

equal(fsm.can('warn'), true, "should be able to warn");

equal(fsm.can('panic'), false, "should NOT be able to panic");

equal(fsm.can('calm'), false, "should NOT be able to calm");

equal(fsm.can('clear'), false, "should NOT be able to clear");

fsm.warn();

equal(fsm.current, 'green', "should still be green because we haven't transitioned yet");

equal(fsm.can('warn'), false, "should NOT be able to warn - during transition");

equal(fsm.can('panic'), false, "should NOT be able to panic - during transition");

equal(fsm.can('calm'), false, "should NOT be able to calm - during transition");

equal(fsm.can('clear'), false, "should NOT be able to clear - during transition");

fsm.transition();

equal(fsm.current, 'yellow', "warn event should transition from green to yellow");

equal(fsm.can('warn'), false, "should NOT be able to warn");

equal(fsm.can('panic'), true, "should be able to panic");

equal(fsm.can('calm'), false, "should NOT be able to calm");

equal(fsm.can('clear'), true, "should be able to clear");

fsm.panic();

equal(fsm.current, 'yellow', "should still be yellow because we haven't transitioned yet");

equal(fsm.can('warn'), false, "should NOT be able to warn - during transition");

equal(fsm.can('panic'), false, "should NOT be able to panic - during transition");

equal(fsm.can('calm'), false, "should NOT be able to calm - during transition");

equal(fsm.can('clear'), false, "should NOT be able to clear - during transition");

fsm.transition();

equal(fsm.current, 'red', "panic event should transition from yellow to red");

equal(fsm.can('warn'), false, "should NOT be able to warn");

equal(fsm.can('panic'), false, "should NOT be able to panic");

equal(fsm.can('calm'), true, "should be able to calm");

equal(fsm.can('clear'), false, "should NOT be able to clear");

});

//-----------------------------------------------------------------------------