ilBasicNodeTest.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2014 ILIAS open source, Extended GPL, see docs/LICENSE */
 
class ilBasicNodeTest extends PHPUnit_Framework_TestCase
{
        public function setUp()
        {
                include_once("./Services/PHPUnit/classes/class.ilUnitUtil.php");
                //ilUnitUtil::performInitialisation();
                
                // Empty workflow.
                require_once './Services/WorkflowEngine/classes/workflows/class.ilEmptyWorkflow.php';
                $this->workflow = new ilEmptyWorkflow();                
        }
        
        public function tearDown()
        {
                global $ilSetting;
                if ($ilSetting !=  NULL)
                {
                        $ilSetting->delete('IL_PHPUNIT_TEST_TIME');
                        $ilSetting->delete('IL_PHPUNIT_TEST_MICROTIME');
                }
        }
        
        public function testConstructorValidContext()
        {
                // Act
                $node = new ilBasicNode($this->workflow);
                
                // Assert
                // No exception - good
                $this->assertTrue(
                        true, 
                        'Construction failed with valid context passed to constructor.'
                );
        }
 
        public function testGetContext()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                
                // Act
                $actual = $node->getContext();
                
                // Assert
                if ($actual === $this->workflow)
                {
                        $this->assertEquals($actual, $this->workflow);
                } else {
                        $this->assertTrue(false, 'Context not identical.');
                }
        }
        
        public function testIsActiveAndActivate()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
                
                // Act
                $node->activate();
                
                // Assert
                $actual = $node->isActive();
                $this->assertTrue($actual);
        }
        
        public function testDeactivate()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
                
                // Act
                $node->activate();
                $was_activated = $node->isActive();
                $node->deactivate();
                $was_deactivated = !$node->isActive();
                
                // Assert
                $this->assertEquals($was_activated, $was_deactivated);
        }
        
        public function testCheckTransitionPreconditionsValid()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
 
                // Act
                $detector->trigger(array());
                $preconditions = $node->checkTransitionPreconditions();
 
                // Assert
                $this->assertTrue($preconditions);
        }
        
        public function testCheckTransitionPreconditionsInvalid()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
 
                
                // Act
                $preconditions = $node->checkTransitionPreconditions();
                
                // Assert
                $this->assertFalse($preconditions);             
        }
        
        public function testAttemptTransitionValid()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
 
                // Act
                $detector->trigger(array());
                $result = $node->attemptTransition();
 
                // Assert
                $this->assertTrue($result);
        }
 
        public function testAttemptTransitionInvalid()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
 
                // Act
                $result = $node->attemptTransition();
 
                // Assert
                $this->assertFalse($result);
        }
        
        public function testExecuteTransition()
        { // This is test #100 of the WorkflowEngine, written on 9th of May, 2012
          // @ 14:15
 
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
                $node->activate();
 
                // Act
                $node->executeTransition();
                $state = $node->isActive();
 
                // Assert
                $this->assertFalse($state);
        }
        
        public function testExecuteActivitiesViaExecuteTransition()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
 
                require_once './Services/WorkflowEngine/classes/activities/class.ilLoggingActivity.php';
                $activity = new ilLoggingActivity($node);
                $activity->setLogFile('ilTransitionLog.txt');
                $activity->setLogLevel('MESSAGE');
                $activity->setLogMessage('TEST');
                $node->addActivity($activity);
 
                // Act
                $node->activate();
                $node->executeTransition();
 
                // Assert
                $expected = ' :: MESSAGE :: TEST';
                $fp = fopen('ilTransitionLog.txt', r);
                $line = fgets($fp);
                $actual = substr($line, 25, strlen($line)-27);
                @unlink('ilTransitionLog.txt'); // TODO: Use vfsStream
                $this->assertEquals(
                        $actual, 
                        $expected
                );
        }
 
        public function testExecuteEmitterViaExecuteTransition()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
 
                require_once './Services/WorkflowEngine/classes/emitters/class.ilActivationEmitter.php';
                $t_node = new ilBasicNode($this->workflow);
                $t_detector = new ilSimpleDetector($t_node);
                $t_node->addDetector($t_detector);
                $foo_detector = new ilSimpleDetector($t_node);
                $t_node->addDetector($foo_detector);
                // again a foo_detector to keep the t_node from transitting
 
                $emitter = new ilActivationEmitter($node);
                $emitter->setTargetDetector($t_detector);
                $node->addEmitter($emitter);
 
                // Act
                $node->activate();
                $node->executeTransition();
 
                // Assert
                $this->assertTrue($t_node->isActive()); 
        }
        
        public function testAddDetector()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
 
                // Act
                $node->addDetector($detector);
                $detectors = $node->getDetectors();
 
                // Assert
                $this->assertEquals($detector, $detectors[0]);
        }
 
        public function testAddEmitter()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/emitters/class.ilSimpleEmitter.php';
                $emitter = new ilSimpleEmitter($node);
 
                // Act
                $node->addEmitter($emitter);
                $emitters = $node->getEmitters();
 
                // Assert
                $this->assertEquals($emitter, $emitters[0]);
        }
 
        public function testAddActivity()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/activities/class.ilLoggingActivity.php';
                $activity = new ilLoggingActivity($node);
 
                // Act
                $node->addActivity($activity);
                $activities = $node->getActivities();
 
                // Assert
                $this->assertEquals($activity, $activities[0]);
        }
 
        public function testNotifyDetectorSatisfaction()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
 
                // Note: Order is important. Setting detector state prior to activation
                // will be voided.
                $node->activate();
                $detector->setDetectorState(true);
                        /* Setting the detector to true will actually be reported
                         * with notifyDetectorSatisfaction.
                         * To isolate this call, we need to reset the node back
                         * to active prior to evaluating if it successfully executes
                         * the transition and sets itself to inactive.
                         */
 
                // Act
                $node->notifyDetectorSatisfaction($detector);
 
                // Assert
                $this->assertFalse($node->isActive());
        }
 
        public function testSetGetIsForwardConditionNode()
        {
                // Arrange
                $node = new ilBasicNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
 
                // Act
                $node->activate();
 
                // Assert
                $this->assertFalse($node->isForwardConditionNode(), 'Forward condition should be false by default.');
                $node->setIsForwardConditionNode(true);
                $this->assertTrue($node->isForwardConditionNode(), 'Forward condition node state not properly stored.');
        }
 
}