ilConditionalNodeTest.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2014 ILIAS open source, Extended GPL, see docs/LICENSE */

class ilConditionalNodeTest 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 ilConditionalNode($this->workflow);
                
                // Assert
                // No exception - good
                $this->assertTrue(
                        true, 
                        'Construction failed with valid context passed to constructor.'
                );
        }

        public function testGetContext()
        {
                // Arrange
                $node = new ilConditionalNode($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 ilConditionalNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
                $evaluation_expression = 'return null;';
                $node->setEvaluationExpression($evaluation_expression);

                // Act
                $node->activate();
                
                // Assert
                $actual = $node->isActive();
                $this->assertTrue($actual);
        }
        
        public function testDeactivate()
        {
                // Arrange
                $node = new ilConditionalNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
                $evaluation_expression = 'return null;';
                $node->setEvaluationExpression($evaluation_expression);
                
                // Act
                $node->activate();
                $was_activated = $node->isActive();
                $node->deactivate();
                $was_deactivated = !$node->isActive();
                
                // Assert
                $this->assertEquals($was_activated, $was_deactivated);
        }
        
        public function testCheckTransitionPreconditionsValidThen()
        {
                // Arrange
                $node = new ilConditionalNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector1 = new ilSimpleDetector($node);
                $node->addDetector($detector1);
                $detector2 = new ilSimpleDetector($node);
                $node->addDetector($detector2);

                $evaluation_expression =
                        '       
                        $retval = null;
                        if ($detectors[0]->getDetectorState() == false 
                                && $detectors[1]->getDetectorState() == true)
                        {
                                $retval = false; 
                        }
                        
                        if ($detectors[0]->getDetectorState() == true
                                && $detectors[1]->getDetectorState() == false)
                        {
                                $retval = true;
                        }
                        return $retval;
                        ';
                
                $node->setEvaluationExpression($evaluation_expression);
                $detector1->trigger(null);
                
                // Act
                $preconditions = $node->checkTransitionPreconditions();
                
                // Assert
                $this->assertTrue($preconditions);      
        }

        public function testCheckTransitionPreconditionsValidElse()
        {
                // Arrange
                $node = new ilConditionalNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector1 = new ilSimpleDetector($node);
                $node->addDetector($detector1);
                $detector2 = new ilSimpleDetector($node);
                $node->addDetector($detector2);

                $evaluation_expression =
                        '       
                        $retval = null;
                        if ($detectors[0]->getDetectorState() == false 
                                && $detectors[1]->getDetectorState() == true)
                        {
                                $retval = false; 
                        }
                        
                        if ($detectors[0]->getDetectorState() == true
                                && $detectors[1]->getDetectorState() == false)
                        {
                                $retval = true;
                        }
                        return $retval;
                        ';
                
                $node->setEvaluationExpression($evaluation_expression);
                $detector2->trigger(null);
                
                // Act
                $preconditions = $node->checkTransitionPreconditions();
                
                // Assert
                $this->assertTrue($preconditions);              
        }
        
        public function testCheckTransitionPreconditionsInvalid()
        {
                // Arrange
                $node = new ilConditionalNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector1 = new ilSimpleDetector($node);
                $node->addDetector($detector1);
                $detector2 = new ilSimpleDetector($node);
                $node->addDetector($detector2);
                
                $evaluation_expression =
                        '       
                        $retval = null;
                        if ($detectors[0]->getDetectorState() == false 
                                && $detectors[1]->getDetectorState() == true)
                        {
                                $retval = false; 
                        }
                        
                        if ($detectors[0]->getDetectorState() == true
                                && $detectors[1]->getDetectorState() == false)
                        {
                                $retval = true;
                        }
                        return $retval;
                        ';
                
                $node->setEvaluationExpression($evaluation_expression);
                
                // Act
                $preconditions = $node->checkTransitionPreconditions();
                
                // Assert
                $this->assertFalse($preconditions);             
        }
                
        public function testExecuteTransitionThen()
        { 
                // Arrange
                $node = new ilConditionalNode($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 testExecuteTransitionElse()
        { // This is test #100 of the WorkflowEngine, written on 9th of May, 2012
          // @ 14:15

                // Arrange
                $node = new ilConditionalNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
                $node->activate();
                
                // Act
                $node->executeElseTransition();
                $state = $node->isActive();
                
                // Assert
                $this->assertFalse($state);             
        }
        
        public function testExecuteActivitiesViaExecuteTransition()
        {
                // Arrange
                $node = new ilConditionalNode($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 testExecuteElseActivitiesViaExecuteTransition()
        {
                // Arrange
                $node = new ilConditionalNode($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, true);
                
                // Act
                $node->activate();
                $node->executeElseTransition();         
        
                // 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 ilConditionalNode($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 testExecuteElseEmitterViaExecuteTransition()
        {
                // Arrange
                $node = new ilConditionalNode($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,true);

                // Act
                $node->activate();
                $node->executeElseTransition();

                // Assert
                $this->assertTrue($t_node->isActive());
        }

        public function testExecuteElseEmitterViaAttemptTransition()
        {
                // Arrange
                $node = new ilConditionalNode($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,true);
                $node->setEvaluationExpression("return false;");
                // Act
                $node->activate();
                $node->AttemptTransition();

                // Assert
                $this->assertTrue($t_node->isActive());
        }

        public function testAddDetectorFirst()
        {
                // Arrange
                $node = new ilConditionalNode($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 testAddEmitterFirst()
        {
                // Arrange
                $node = new ilConditionalNode($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 testAddElseEmitterFirst()
        {
                // Arrange
                $node = new ilConditionalNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/emitters/class.ilSimpleEmitter.php';
                $emitter = new ilSimpleEmitter($node);

                // Act
                $node->addEmitter($emitter, true);
                $emitters = $node->getEmitters(true);
                
                // Assert
                $this->assertEquals($emitter, $emitters[0]);
        }

        public function testAddActivityFirst()
        {
                // Arrange
                $node = new ilConditionalNode($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 testAddElseActivityFirst()
        {
                // Arrange
                $node = new ilConditionalNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/activities/class.ilLoggingActivity.php';
                $activity = new ilLoggingActivity($node);

                // Act
                $node->addActivity($activity, true);
                $activities = $node->getActivities(true);
                
                // Assert
                $this->assertEquals($activity, $activities[0]);         
        }

        public function testNotifyDetectorSatisfaction()
        {
                // Arrange
                $node = new ilConditionalNode($this->workflow);
                
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector = new ilSimpleDetector($node);
                $node->addDetector($detector);
                $detector->setDetectorState(true);
                $node->setEvaluationExpression('return true;');
                
                $node->activate();
                        /* 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 testNotifyDetectorSatisfactionAndTransit()
        {
                // Arrange
                $node = new ilConditionalNode($this->workflow);
                require_once './Services/WorkflowEngine/classes/detectors/class.ilSimpleDetector.php';
                $detector1 = new ilSimpleDetector($node);
                $node->addDetector($detector1);
                $detector2 = new ilSimpleDetector($node);
                $node->addDetector($detector2);
                $node->setEvaluationExpression('return $GLOBALS["expr_retval"];');
                $GLOBALS['expr_retval'] = null;

                // Act
                $node->activate();
                $this->assertTrue($node->isActive());
                $GLOBALS['expr_retval'] = true;

                $detector1->trigger(null);
                $detector2->trigger(null);
                // TODO: Assert something more meaningful here.
                $this->assertFalse($node->isActive());
        }
}