StateMachineBehaviorTest

Complexity

Total Complexity

38

Size/Duplication

Total Lines	632
Duplicated Lines	7.28 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

38 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	6	1
A	testGetAllTransitions()	0	3	1
A	testAvailableStates()	0	3	1
A	testTransitionById()	0	13	1
A	testIgnoreValidationOnTransition()	0	9	1
A	testValidateOnTransition()	0	7	1
A	testStateListener()	0	21	1
A	testCanTransitionById()	0	16	1
A	testFindAllByState()	23	23	1
A	testFindCountByState()	0	10	1
A	testFindFirstByState()	23	23	1
A	testInitialState()	0	4	1
A	testIsMethodsById()	0	16	1
B	testIsMethods()	0	25	1
A	testOnMethods()	0	16	1
A	testBadMethodCall()	0	4	1
A	whenParked()	0	3	1
A	testWhenMethods()	0	12	1
A	testBubble()	0	13	1
A	testInvalidTransition()	0	5	1
A	testVehicleTitle()	0	15	1
A	testCreateVehicle()	0	10	1
A	testAddToPrepareArrayNoRoles()	0	49	1
A	testAddToPrepareArrayWithRoles()	0	54	1
B	testAddToPrepareArrayWithDependsAndRoles()	0	77	1
A	testToDot()	0	3	1
B	testCreateDotFileForRoles()	0	45	1
A	testCallable()	0	7	1
A	testExistingCallable()	0	8	1
A	testUnhandled()	0	4	1
A	testInvalidOnStateChange()	0	4	1
A	testOnStateChange()	0	11	1
A	testRules()	0	19	1
A	testRulesWithCanTransitionById()	0	19	1
A	testRuleWithCallback()	0	13	1
A	testInvalidRules()	0	6	1
A	testWrongRole()	0	4	1
A	tearDown()	0	4	1

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 4 and the first side effect is on line 2.

App::uses('StateMachineBehavior', 'StateMachine.Model/Behavior');

class BaseVehicle extends CakeTestModel {

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

	public $useTable = 'vehicles';

	public $actsAs = array('StateMachine.StateMachine');

	public $initialState = 'parked';

	public $transitions = array(
		'ignite' => array(
			'parked' => 'idling',
			'stalled' => 'stalled'
		),
		'park' => array(
			'idling' => 'parked',
			'first_gear' => 'parked'
		),
		'shift_up' => array(
			'idling' => 'first_gear',
			'first_gear' => 'second_gear',
			'second_gear' => 'third_gear'
		),
		'shift_down' => array(
			'first_gear' => 'idling',
			'second_gear' => 'first_gear',
			'third_gear' => 'second_gear'
		),
		'crash' => array(
			'first_gear' => 'stalled',
			'second_gear' => 'stalled',
			'third_gear' => 'stalled'
		),
		'repair' => array(
			'stalled' => 'parked'
		),
		'idle' => array(
			'first_gear' => 'idling'
		),
		'turn_off' => array(
			'all' => 'parked'
		),
		'baz' => array()
	);
}

class Vehicle extends BaseVehicle {

PSR1 recommends that each class should be in its own file to aid autoloaders.

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

	public function onStateChange($newState) {
	}

	public function onStateIdling($newState) {
	}

	public function onBeforeTransition($currentState, $previousState, $transition) {
	}

	public function onAfterTransition($currentState, $previousState, $transition) {
	}

	public function onBeforeIgnite($currentState, $previousState, $transition) {
	}

}

class RulesVehicle extends BaseVehicle {

PSR1 recommends that each class should be in its own file to aid autoloaders.

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

	public $transitionRules = array(
		'hardwire' => array(
			'role' => array('thief'),
		),
		'ignite' => array(
			'role' => array('driver'),
			'depends' => 'has_key'
		),
		'park' => array(
			'role' => array('driver', 'thief'),
			'depends' => 'available_parking'
		),
		'repair' => array(
			'role' => array('mechanic'),
			'depends' => 'has_tools'
		)
	);

	public function __construct($id = false, $table = null, $ds = null) {
		$this->transitions += array(
			'hardwire' => array(
				'parked' => 'idling',
				'stalled' => 'stalled'
			)
		);

		parent::__construct($id, $table, $ds);
	}

	public function hasKey($role) {
		if ($role == 'driver') {
			return true;
		}

		return false;
	}

	public function availableParking($role) {
		return $role == 'thief';
	}

}

class ValidationsVehicle extends Vehicle {

PSR1 recommends that each class should be in its own file to aid autoloaders.

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

	public $validate = array(
		'title' => array(
			'custom' => array(
				'rule' => array('custom', '/toyota yaris/i')
			)
		)
	);

}

class StateMachineBehaviorTest extends CakeTestCase {

PSR1 recommends that each class should be in its own file to aid autoloaders.

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

	public $fixtures = array(
		'plugin.state_machine.vehicle'
	);

	public $Vehicle;

	public $StateMachine;

	public function setUp() {
		parent::setUp();

		$this->Vehicle = new Vehicle(1);
		$this->StateMachine = $this->Vehicle->Behaviors->StateMachine;
	}

	public function testGetAllTransitions() {
		$this->assertCount(9, $this->Vehicle->getAllTransitions());
	}

	public function testAvailableStates() {
		$this->assertCount(6, $this->Vehicle->getAvailableStates());
	}

	public function testTransitionById() {
		$this->Vehicle->ignite(1);
		$this->assertEquals("idling", $this->Vehicle->getCurrentState(1));
		$this->assertEquals("parked", $this->Vehicle->getPreviousState(1));
		$this->assertEquals("ignite", $this->Vehicle->getLastTransition(1));
		$this->assertEquals("", $this->Vehicle->getLastRole(1));
		$this->Vehicle->shiftUp(1);
		$this->assertEquals("first_gear", $this->Vehicle->getCurrentState(1));
		$this->assertEquals("idling", $this->Vehicle->getPreviousState(1));
		$this->Vehicle->shiftUp(1);
		$this->assertEquals("second_gear", $this->Vehicle->getCurrentState(1));
		$this->assertEquals("first_gear", $this->Vehicle->getPreviousState(1));
	}

	public function testIgnoreValidationOnTransition() {
		$this->Vehicle = new ValidationsVehicle(1);

		$this->assertFalse($this->Vehicle->ignite());
		$this->assertEquals("parked", $this->Vehicle->getCurrentState());

		$this->assertTrue($this->Vehicle->ignite(null, null, false));
		$this->assertEquals("idling", $this->Vehicle->getCurrentState());
	}

	public function testValidateOnTransition() {
		$this->Vehicle = new ValidationsVehicle(1);
		$this->assertFalse($this->Vehicle->ignite());

		$this->Vehicle = new ValidationsVehicle(2);
		$this->assertTrue($this->Vehicle->ignite());
	}

	public function testStateListener() {
		// test state listener on transition failed
		$this->Vehicle = $this->getMock('ValidationsVehicle', array(
			'onStateChange', 'onStateIdling', 'onBeforeTransition', 'onAfterTransition'));
		$this->Vehicle->id = 1;
		$this->Vehicle->expects($this->once())->method('onBeforeTransition');
		$this->Vehicle->expects($this->never())->method('onAfterTransition');
		$this->Vehicle->expects($this->never())->method('onStateChange');
		$this->Vehicle->expects($this->never())->method('onStateIdling');
		$this->assertFalse($this->Vehicle->ignite());

		// test state listener on transition success
		$this->Vehicle = $this->getMock('ValidationsVehicle', array(
			'onStateChange', 'onStateIdling', 'onBeforeTransition', 'onAfterTransition'));
		$this->Vehicle->id = 2;
		$this->Vehicle->expects($this->once())->method('onBeforeTransition');
		$this->Vehicle->expects($this->once())->method('onAfterTransition');
		$this->Vehicle->expects($this->once())->method('onStateChange');
		$this->Vehicle->expects($this->once())->method('onStateIdling');
		$this->assertTrue($this->Vehicle->ignite());
	}

	public function testCanTransitionById() {
		$this->assertTrue($this->Vehicle->is('parked'));

		$this->assertEquals($this->Vehicle->can('shift_up', 1), $this->Vehicle->canShiftUp(1));
		$this->assertFalse($this->Vehicle->can('shift_up', 1));

		$this->assertTrue($this->Vehicle->can('ignite', 1));
		$this->Vehicle->ignite();
		$this->assertEquals("idling", $this->Vehicle->getCurrentState());

		$this->assertEquals($this->Vehicle->can('shift_up', 1), $this->Vehicle->canShiftUp(1));
		$this->assertTrue($this->Vehicle->canShiftUp(1));
		$this->assertFalse($this->Vehicle->canShiftDown(1));

		$this->assertFalse($this->Vehicle->canShiftUp(2));
	}

	public function testFindAllByState() {

This method seems to be duplicated in your project.

		$this->assertFalse($this->Vehicle->findAllByState());
		$this->assertFalse($this->Vehicle->findAllByState('illegal_state_should_not_be_possible'));
		$this->assertFalse($this->Vehicle->findAllByState(array('illegal_state_should_not_be_possible', 'parked')));
		$this->assertCount(2, $this->Vehicle->findAllByState('parked'));
		$this->assertCount(1, $this->Vehicle->findAllByState('parked', array('conditions' => array('Vehicle.title' => 'Audi Q4'))));
		$this->assertCount(4, $this->Vehicle->findAllByState('all'));
		$this->assertCount(1, $this->Vehicle->findAllByState('idling'));
		$this->assertCount(3, $this->Vehicle->findAllByState(array('idling', 'parked')));

		// test with transition array
		$testTransitions = $this->Vehicle->findAllByState('parked');
		$this->assertTrue(is_array($testTransitions[0]['Vehicle']['Transitions']));
		$this->assertCount(2, $testTransitions[0]['Vehicle']['Transitions']);

		// test without transitions array
		$testTransitions = $this->Vehicle->findAllByState('parked', array(), false);
		$this->assertFalse(isset($testTransitions[0]['Vehicle']['Transitions']));

		$this->Vehicle = new RulesVehicle(1);
		$testTransitions = $this->Vehicle->findAllByState('parked', array(), true, 'driver');
		$this->assertEqual(array('ignite', 'turn_off'), $testTransitions[0]['RulesVehicle']['Transitions']);
	}

	public function testFindCountByState() {
		$this->assertFalse($this->Vehicle->findCountByState());
		$this->assertFalse($this->Vehicle->findCountByState('illegal_state_should_not_be_possible'));
		$this->assertFalse($this->Vehicle->findCountByState(array('illegal_state_should_not_be_possible', 'parked')));
		$this->assertEqual(2, $this->Vehicle->findCountByState('parked'));
		$this->assertEqual(1, $this->Vehicle->findCountByState('parked', array('conditions' => array('Vehicle.title' => 'Audi Q4'))));
		$this->assertEqual(4, $this->Vehicle->findCountByState('all'));
		$this->assertEqual(1, $this->Vehicle->findCountByState('idling'));
		$this->assertEqual(3, $this->Vehicle->findCountByState(array('idling', 'parked')));
	}

	public function testFindFirstByState() {

This method seems to be duplicated in your project.

		$this->assertFalse($this->Vehicle->findFirstByState());
		$this->assertFalse($this->Vehicle->findFirstByState('illegal_state_should_not_be_possible'));
		$this->assertFalse($this->Vehicle->findFirstByState(array('illegal_state_should_not_be_possible', 'parked')));
		$this->assertCount(1, $this->Vehicle->findFirstByState('parked'));
		$this->assertCount(1, $this->Vehicle->findFirstByState('parked', array('conditions' => array('Vehicle.title' => 'Audi Q4'))));
		$this->assertCount(1, $this->Vehicle->findFirstByState('all'));
		$this->assertCount(1, $this->Vehicle->findFirstByState('idling'));
		$this->assertCount(1, $this->Vehicle->findFirstByState(array('idling', 'parked')));

		// test with transition array
		$testTransitions = $this->Vehicle->findFirstByState('parked');
		$this->assertTrue(is_array($testTransitions[0]['Vehicle']['Transitions']));
		$this->assertCount(2, $testTransitions[0]['Vehicle']['Transitions']);

		// test without transitions array
		$testTransitions = $this->Vehicle->findFirstByState('parked', array(), false);
		$this->assertFalse(isset($testTransitions[0]['Vehicle']['Transitions']));

		$this->Vehicle = new RulesVehicle(1);
		$testTransitions = $this->Vehicle->findFirstByState('parked', array(), true, 'driver');
		$this->assertEqual(array('ignite', 'turn_off'), $testTransitions[0]['RulesVehicle']['Transitions']);
	}

	public function testInitialState() {
		$this->assertEquals("parked", $this->Vehicle->getCurrentState());
		$this->assertEquals('parked', $this->Vehicle->getStates('turn_off'));
	}

	public function testIsMethodsById() {
		$this->assertEquals("parked", $this->Vehicle->getCurrentState());
		$this->assertEquals($this->Vehicle->isParked(1), $this->Vehicle->is('parked', 1));
		$this->assertTrue($this->Vehicle->isParked(1));

		$this->Vehicle->ignite();

		$this->assertEquals("idling", $this->Vehicle->getCurrentState());
		$this->assertEquals($this->Vehicle->isIdling(1), $this->Vehicle->is('idling', 1));
		$this->assertTrue($this->Vehicle->isIdling(1));

		$this->assertEquals("parked", $this->Vehicle->getCurrentState(2));
		$this->assertEquals($this->Vehicle->isParked(2), $this->Vehicle->is('parked', 2));
		$this->assertTrue($this->Vehicle->isParked(2));
		$this->assertFalse($this->Vehicle->isIdling(2));
	}

	public function testIsMethods() {
		$this->assertEquals($this->Vehicle->isParked(), $this->Vehicle->is('parked'));
		$this->assertEquals($this->Vehicle->isIdling(), $this->Vehicle->is('idling'));
		$this->assertEquals($this->Vehicle->isStalled(), $this->Vehicle->is('stalled'));
		$this->assertEquals($this->Vehicle->isIdling(), $this->Vehicle->is('idling'));

		$this->assertEquals($this->Vehicle->canShiftUp(), $this->Vehicle->can('shift_up'));
		$this->assertFalse($this->Vehicle->canShiftUp());

		$this->assertTrue($this->Vehicle->canIgnite());
		$this->Vehicle->ignite();
		$this->assertEquals("idling", $this->Vehicle->getCurrentState());

		$this->assertTrue($this->Vehicle->canShiftUp());
		$this->assertFalse($this->Vehicle->canShiftDown());

		$this->assertTrue($this->Vehicle->isIdling());
		$this->assertFalse($this->Vehicle->canCrash());
		$this->Vehicle->shiftUp();
		$this->Vehicle->crash();
		$this->assertEquals("stalled", $this->Vehicle->getCurrentState());
		$this->assertTrue($this->Vehicle->isStalled());
		$this->Vehicle->repair();
		$this->assertTrue($this->Vehicle->isParked());
	}

	public function testOnMethods() {
		$scope = $this;
		$this->Vehicle->onIgnite('before', function ($currentState, $previousState, $transition) use ($scope) {
			$scope->assertEquals("parked", $currentState);
			$scope->assertNull($previousState);
			$scope->assertEquals("ignite", $transition);
		});

		$this->Vehicle->on('ignite', 'after', function ($currentState, $previousState, $transition) use ($scope) {
			$scope->assertEquals("idling", $currentState);
			$scope->assertEquals("parked", $previousState);
			$scope->assertEquals("ignite", $transition);
		});

		$this->Vehicle->ignite();
	}

	public function testBadMethodCall() {
		$this->setExpectedException('PDOException');
		$this->Vehicle->isFoobar();
	}

	public function whenParked() {
		$this->assertEquals('parked', $this->Vehicle->getCurrentState());
	}

	public function testWhenMethods() {
		$this->Vehicle->whenStalled(function () {
			$this->assertEquals("stalled", $this->Vehicle->getCurrentState());
		});

		$this->Vehicle->when('parked', array($this, 'whenParked'));

		$this->Vehicle->ignite();
		$this->Vehicle->shiftUp();
		$this->Vehicle->crash();
		$this->Vehicle->repair();
	}

	public function testBubble() {
		$scope = $this;
		$this->Vehicle->on('ignite', 'before', function () use ($scope) {
			$scope->assertEquals("parked", $scope->Vehicle->getCurrentState());
		}, false);

		$this->Vehicle->on('transition', 'before', function () use ($scope) {
			// this should never be called
			$scope->assertTrue(false);
		});

		$this->Vehicle->ignite();
	}

	public function testInvalidTransition() {
		$this->assertFalse($this->Vehicle->getStates('foobar'));
		$this->assertFalse($this->Vehicle->getStates('baz'));
		$this->assertFalse($this->Vehicle->baz());
	}

	public function testVehicleTitle() {
		$this->Vehicle = new Vehicle(3);

		$this->assertEquals("Opel Astra", $this->Vehicle->field('title'));
		$this->assertEquals("idling", $this->Vehicle->getCurrentState());
		$this->Vehicle->shiftUp();
		$this->assertEquals("first_gear", $this->Vehicle->getCurrentState());

		$this->Vehicle = new Vehicle(4);
		$this->assertEquals("Nissan Leaf", $this->Vehicle->field('title'));
		$this->assertEquals("stalled", $this->Vehicle->getCurrentState());
		$this->assertTrue($this->Vehicle->canRepair());
		$this->assertTrue($this->Vehicle->repair());
		$this->assertEquals("parked", $this->Vehicle->getCurrentState());
	}

	public function testCreateVehicle() {
		$this->Vehicle->create();
		$this->Vehicle->save(array(
			'Vehicle' => array(
				'title' => 'Toybota'
			)
		));
		$this->Vehicle->id = $this->Vehicle->getLastInsertID();
		$this->assertEquals($this->Vehicle->initialState, $this->Vehicle->getCurrentState());
	}

	public function testAddToPrepareArrayNoRoles() {
		$this->Vehicle = new Vehicle(1);

		$dataArrayToFill = array();
		$dataToAdd = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch'
		);

		// Case 1 - illegal parameters
		$this->assertFalse($this->Vehicle->addToPrepareArray(null, $dataArrayToFill));
		$this->assertFalse($this->Vehicle->addToPrepareArray(array(), $dataArrayToFill));

		// Case 2 - adding first array
		$expected[] = $dataToAdd;

$expected was never initialized. Although not strictly required by PHP, it is generally a good practice to add $expected = array(); before regardless.

		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 3 - adding second array
		$dataToAdd = array(
			'stateFrom' => 'second',
			'stateTo' => 'third',
			'transition' => 'launch2',
			'not_care' => 'anyvalue'
		);
		$expected[] = $dataToAdd;
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 4 - adding same array should not increase
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 5 - adding depends
		$dataToAdd = array(
			'stateFrom' => 'second',
			'stateTo' => 'third',
			'transition' => 'launch2',
			'depends' => 'hasValid'
		);
		$expected[] = $dataToAdd;
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 6 - adding same depends should skip it
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);
	}

	public function testAddToPrepareArrayWithRoles() {
		$this->Vehicle = new Vehicle(1);
		$expected = $dataArrayToFill = array();

		// Case 1 - adding role without depends, we reset the data
		$dataToAdd = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'roles' => array('role1')
		);
		$dataArrayToFill[] = $expected[] = $dataToAdd;
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		//debug($dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 2 - adding same role twice shoud not duplicate
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 3 - Adding same state&Transition but with additional role
		$dataToAdd = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'roles' => array('role2')
		);
		$expected = array();
		$expected[] = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'roles' => array('role1', 'role2')
		);
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 4 - Adding same state&Transition but with additional role
		$dataToAdd = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'roles' => array('role3', 'role4')
		);
		$expected = array();
		$expected[] = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'roles' => array('role1', 'role2', 'role3', 'role4')
		);
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);
	}

	public function testAddToPrepareArrayWithDependsAndRoles() {
		$this->Vehicle = new Vehicle(1);
		$expected = $dataArrayToFill = array();

		// Case 1 - adding role without depends, we reset the data
		$dataToAdd = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'depends' => 'is_allowed',
			'roles' => array('role1')
		);
		$dataArrayToFill[] = $expected[] = $dataToAdd;
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		//debug($dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 2 - adding same role twice shoud not duplicate
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 3 - Adding same state&Transition&depends but with additional role
		$dataToAdd = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'depends' => 'is_allowed',
			'roles' => array('role2')
		);
		$expected = array();
		$expected[] = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'depends' => 'is_allowed',
			'roles' => array('role1', 'role2')
		);
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 4 - Adding same state&Transition&depends but with additional role
		$dataToAdd = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'depends' => 'is_allowed',
			'roles' => array('role3', 'role4')
		);
		$expected = array();
		$expected[] = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'depends' => 'is_allowed',
			'roles' => array('role1', 'role2', 'role3', 'role4')
		);
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);

		// Case 5 - Adding same state&Transition&depends but with different depends
		$dataToAdd = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'depends' => 'different_is_allowed',
			'roles' => array('role3', 'role4')
		);
		$expected[] = array(
			'stateFrom' => 'initial',
			'stateTo' => 'second',
			'transition' => 'launch',
			'depends' => 'different_is_allowed',
			'roles' => array('role3', 'role4')
		);
		$dataArrayToFill = $this->Vehicle->addToPrepareArray($dataToAdd, $dataArrayToFill);
		$this->assertEqual($expected, $dataArrayToFill);
	}

	public function testToDot() {
		$this->Vehicle->toDot();
	}

	public function testCreateDotFileForRoles() {
		$this->Vehicle = new RulesVehicle(1);

		$expected = <<<EOT
digraph finite_state_machine {
	fontsize=12;
	node [shape = oval, style=filled, color = "lightgrey"];
	style=filled;
	label="Statemachine for RulesVehicle role(s) : Driver, Thief"
	"Parked" [ color = green ];
	"Parked" -> "Idling" [ style = bold, fontsize = 9, arrowType = normal, label = "Ignite by (Driver)
if Has Key" color = "blue"];
	"Stalled" -> "Stalled" [ style = bold, fontsize = 9, arrowType = normal, label = "Ignite by (Driver)
if Has Key" color = "blue"];
	"Idling" -> "Parked" [ style = bold, fontsize = 9, arrowType = normal, label = "Park by All
if Available Parking" ];
	"First Gear" -> "Parked" [ style = bold, fontsize = 9, arrowType = normal, label = "Park by All
if Available Parking" ];
	"Idling" -> "First Gear" [ style = bold, fontsize = 9, arrowType = normal, label = "Shift Up by All" ];
	"First Gear" -> "Second Gear" [ style = bold, fontsize = 9, arrowType = normal, label = "Shift Up by All" ];
	"Second Gear" -> "Third Gear" [ style = bold, fontsize = 9, arrowType = normal, label = "Shift Up by All" ];
	"First Gear" -> "Idling" [ style = bold, fontsize = 9, arrowType = normal, label = "Shift Down by All" ];
	"Second Gear" -> "First Gear" [ style = bold, fontsize = 9, arrowType = normal, label = "Shift Down by All" ];
	"Third Gear" -> "Second Gear" [ style = bold, fontsize = 9, arrowType = normal, label = "Shift Down by All" ];
	"First Gear" -> "Stalled" [ style = bold, fontsize = 9, arrowType = normal, label = "Crash by All" ];
	"Second Gear" -> "Stalled" [ style = bold, fontsize = 9, arrowType = normal, label = "Crash by All" ];
	"Third Gear" -> "Stalled" [ style = bold, fontsize = 9, arrowType = normal, label = "Crash by All" ];
	"First Gear" -> "Idling" [ style = bold, fontsize = 9, arrowType = normal, label = "Idle by All" ];
	"All" -> "Parked" [ style = bold, fontsize = 9, arrowType = normal, label = "Turn Off by All" ];
	"Parked" -> "Idling" [ style = bold, fontsize = 9, arrowType = normal, label = "Hardwire by (Thief)" color = "red"];
	"Stalled" -> "Stalled" [ style = bold, fontsize = 9, arrowType = normal, label = "Hardwire by (Thief)" color = "red"];
}

EOT;
		$this->assertEqual($expected, $this->Vehicle->createDotFileForRoles(array(
				'driver' => array(
					'color' => 'blue'),
				'thief' => array(
					'color' => 'red')
			), array(
				'color' => 'lightgrey',
				'activeColor' => 'green'
			)
		));
	}

	public function testCallable() {
		$this->Vehicle->addMethod('whatIsMyName', function (Model $model, $method, $name) {
			return $model->alias . '-' . $method . '-' . $name;
		});

		$this->assertEquals("Vehicle-whatIsMyName-Toybota", $this->Vehicle->whatIsMyName("Toybota"));
	}

	public function testExistingCallable() {
		$this->Vehicle->addMethod('foobar', function () {
		});

		$this->setExpectedException('InvalidArgumentException');
		$this->Vehicle->addMethod('foobar', function () {
		});
	}

	public function testUnhandled() {
		$this->setExpectedException('PDOException');
		$this->assertEquals(array("unhandled"), $this->Vehicle->handleMethodCall("foobar"));
	}

	public function testInvalidOnStateChange() {
		$this->Vehicle = new BaseVehicle(1);
		$this->Vehicle->ignite();
	}

	public function testOnStateChange() {
		$this->Vehicle = $this->getMock('Vehicle', array(
			'onStateChange', 'onStateIdling', 'onBeforeTransition', 'onAfterTransition'));
		$this->Vehicle->id = 1;
		$this->Vehicle->expects($this->once())->method('onBeforeTransition');
		$this->Vehicle->expects($this->once())->method('onAfterTransition');
		$this->Vehicle->expects($this->once())->method('onStateChange');
		$this->Vehicle->expects($this->once())->method('onStateIdling');

		$this->assertTrue($this->Vehicle->ignite());
	}

	public function testRules() {
		$this->Vehicle = new RulesVehicle(1);

		$this->assertTrue($this->Vehicle->canIgnite(null, 'driver'));
		$this->assertFalse($this->Vehicle->canIgnite(null, 'thief'));
		$this->assertTrue($this->Vehicle->canHardwire(null, 'thief'));
		$this->assertFalse($this->Vehicle->canHardwire(null, 'driver'));

		$this->Vehicle->ignite(null, 'driver');

		$this->Vehicle->ignite(1, 'driver');
		$this->assertEquals("idling", $this->Vehicle->getCurrentState(1));
		$this->assertEquals("parked", $this->Vehicle->getPreviousState(1));
		$this->assertEquals("ignite", $this->Vehicle->getLastTransition(1));
		$this->assertEquals("driver", $this->Vehicle->getLastRole(1));

		$this->assertFalse($this->Vehicle->canPark(null, 'driver'));
		$this->assertTrue($this->Vehicle->canPark(null, 'thief'));
	}

	public function testRulesWithCanTransitionById() {
		$this->Vehicle = new RulesVehicle(1);

		$this->assertTrue($this->Vehicle->canIgnite(1, 'driver'));
		$this->assertFalse($this->Vehicle->canIgnite(1, 'thief'));
		$this->assertTrue($this->Vehicle->canHardwire(1, 'thief'));
		$this->assertFalse($this->Vehicle->canHardwire(1, 'driver'));

		$this->Vehicle->ignite(null, 'driver');

		$this->Vehicle->ignite(1, 'driver');
		$this->assertEquals("idling", $this->Vehicle->getCurrentState(1));
		$this->assertEquals("parked", $this->Vehicle->getPreviousState(1));
		$this->assertEquals("ignite", $this->Vehicle->getLastTransition(1));
		$this->assertEquals("driver", $this->Vehicle->getLastRole(1));

		$this->assertFalse($this->Vehicle->canPark(1, 'driver'));
		$this->assertTrue($this->Vehicle->canPark(1, 'thief'));
	}

	public function testRuleWithCallback() {
		$this->Vehicle = new RulesVehicle(1);
		$this->Vehicle->ignite(null, 'driver');
		$this->Vehicle->shiftUp();
		$this->Vehicle->crash();

		$this->Vehicle->addMethod('hasTools', function ($role) {
			return $role == 'mechanic';
		});

		$this->assertTrue($this->Vehicle->canRepair(null, 'mechanic'));
		$this->assertTrue($this->Vehicle->repair(null, 'mechanic'));
	}

	public function testInvalidRules() {
		$this->setExpectedException('InvalidArgumentException');

		$this->Vehicle = new RulesVehicle(1);
		$this->Vehicle->ignite();
	}

	public function testWrongRole() {
		$this->Vehicle = new RulesVehicle(1);
		$this->assertFalse($this->Vehicle->ignite(null, 'thief'));
	}

	public function tearDown() {
		parent::tearDown();
		unset($this->Vehicle, $this->StateMachine);
	}
}