ilEventDetectorTest.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2014 ILIAS open source, Extended GPL, see docs/LICENSE */
 
class ilEventDetectorTest extends PHPUnit_Framework_TestCase
{
    public function setUp()
    {
        include_once("./Services/PHPUnit/classes/class.ilUnitUtil.php");
        //ilUnitUtil::performInitialisation();
        
        require_once './Services/WorkflowEngine/classes/utils/class.ilWorkflowUtils.php';
        
        // Empty workflow.
        require_once './Services/WorkflowEngine/classes/workflows/class.ilEmptyWorkflow.php';
        $this->workflow = new ilEmptyWorkflow();
        
        // Basic node
        require_once './Services/WorkflowEngine/classes/nodes/class.ilBasicNode.php';
        $this->node = new ilBasicNode($this->workflow);
        
        // Wiring up so the node is attached to the workflow.
        $this->workflow->addNode($this->node);
        
        require_once './Services/WorkflowEngine/classes/detectors/class.ilEventDetector.php';
    }
    
    public function tearDown()
    {
        global $ilSetting;
        if ($ilSetting !=  null) {
            $ilSetting->delete('IL_PHPUNIT_TEST_TIME');
            $ilSetting->delete('IL_PHPUNIT_TEST_MICROTIME');
        }
    }
    
    public function testConstructorValidContext()
    {
        // Act
        $detector = new ilEventDetector($this->node);
        
        // Assert
        // No exception - good
        $this->assertTrue(
            true,
            'Construction failed with valid context passed to constructor.'
        );
    }
 
    public function testIsListeningWithTimeFrame()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $timer_start = ilWorkflowUtils::time() + 5*60; # +5 Minutes from here.
        $timer_end = 0;
        $detector->setListeningTimeframe($timer_start, $timer_end);
 
        // Act
        $actual = $detector->isListening();
 
        // Assert
        $this->assertFalse($actual, 'Detector should not be listening.');
    }
 
    public function testIsListeningWithPastTimeFrame()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $timer_start = ilWorkflowUtils::time() - 5*60; # -5 Minutes from now.
        $timer_end = ilWorkflowUtils::time() - 1*60; # -1 Minute from now.
        $detector->setListeningTimeframe($timer_start, $timer_end);
 
        // Act
        $actual = $detector->isListening();
 
        // Assert
        $this->assertFalse($actual, 'Detector should not be listening.');
    }
 
    public function testIsListeningWithWildcardEndingTimeFrame()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $timer_start = ilWorkflowUtils::time() - 5*60; # -5 Minutes from now.
        $timer_end = 0; # Wildcard.
        $detector->setListeningTimeframe($timer_start, $timer_end);
 
        // Act
        $actual = $detector->isListening();
 
        // Assert
        $this->assertTrue($actual, 'Detector should not be listening.');
    }
 
    public function testIsListeningWithWildcardBeginningTimeFrame()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $timer_start = 0; # Wildcard.
        $timer_end = ilWorkflowUtils::time() + 5*60; # +5 Minutes from now.
        $detector->setListeningTimeframe($timer_start, $timer_end);
 
        // Act
        $actual = $detector->isListening();
 
        // Assert
        $this->assertTrue($actual, 'Detector should not be listening.');
    }
 
    public function testIsListeningWithoutTimeFrame()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        
        // Act
        $actual = $detector->isListening();
        
        // Assert
        $this->assertTrue($actual, 'Detector should be listening.');
    }
 
    public function testSetGetListeningTimeframe()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $exp_start = 4711;
        $exp_end = 4712;
        
        // Act
        $detector->setListeningTimeframe($exp_start, $exp_end);
        $act = $detector->getListeningTimeframe();
        
        // Assert
        $this->assertEquals($exp_start . $exp_end, $act['listening_start'] . $act['listening_end']);
    }
 
    public function testSetGetIllegalListeningTimeframe()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $exp_start = 4712; # +5 Minutes from here.
        $exp_end = 4711;
 
        // Act
        $detector->setListeningTimeframe($exp_start, $exp_end);
        $act = $detector->getListeningTimeframe();
 
        // Assert
        $this->assertEquals($exp_start . $exp_end, $act['listening_start'] . $act['listening_end']);
    }
 
    public function testSetGetDbId()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $expected = '1234';
        
        // Act
        $detector->setDbId($expected);
        $actual = $detector->getDbId();
        
        // Assert
        $this->assertEquals($expected, $actual);
    }
 
    public function testGetNonExistingDbId()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $expected = '1234';
 
        // Act
        $actual = $detector->getDbId();
 
        // Assert
        $this->assertEquals($expected, $actual);
    }
 
    public function testHasDbIdSet()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $expected = '1234';
        
        // Act
        $detector->setDbId($expected);
        $actual = $detector->hasDbId();
        
        // Assert
        $this->assertTrue($actual);
    }
    
    public function testHasDbIdUnset()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        
        // Act
        $actual = $detector->hasDbId();
        
        // Assert
        $this->assertFalse($actual);
    }
    
    public function testWriteDetectorToDb()
    {
        $this->markTestIncomplete(
            '$ilDB throws notices during test.'
        );
        // Arrange
        $detector = new ilEventDetector($this->node);
 
        require_once './Services/Database/classes/class.ilDBMySQL.php';
        $ilDB_mock = $this->createMock('ilDBMySQL', array('nextID','quote','insert'), array(), '', false);
 
        $ilDB_mock->expects($this->once())->method('nextID')->with($this->equalTo('wfe_det_listening'))->will($this->returnValue(234));
        $ilDB_mock->expects($this->any())->method('quote')->will($this->returnArgument(0));
        $ilDB_mock->expects($this->any())->method('insert')->with(
            'wfe_det_listening',
            array(
                'detector_id'           => array('integer', 234),
                'workflow_id'           => array('integer', null),
                'type'                          => array('text', '' ),
                'content'                       => array('text', ''),
                'subject_type'          => array('text', ''),
                'subject_id'            => array('integer', ''),
                'context_type'          => array('text', ''),
                'context_id'            => array('integer', ''),
                'listening_start'       => array('integer', '0'),
                'listening_end'         => array('integer', '0')
            )
        )->will($this->returnValue(true));
 
        // Act
        $stashed_real_object = @$GLOBALS['ilDB'];
        $GLOBALS['ilDB'] = $ilDB_mock;
 
        // Act
        $detector->writeDetectorToDb();
        $actual = $detector->hasDbId();
 
        // Assert
        $this->assertTrue($actual);
 
        $GLOBALS['ilDB'] = $stashed_real_object;
    }
 
    public function testDeleteDetectorFromDb()
    {
        $this->markTestIncomplete(
            '$ilDB throws notices during test.'
        );
 
        // Arrange
        $detector = new ilEventDetector($this->node);
        require_once './Services/Database/classes/class.ilDBMySQL.php';
        $ilDB_mock = $this->createMock('ilDBMySQL', array('quote','manipulate'), array(), '', false);
 
        $ilDB_mock->expects($this->any())->method('quote')->will($this->returnValue(234));
        $ilDB_mock->expects($this->any())->method('manipulate')->with(
            'DELETE
                                FROM wfe_det_listening
                                WHERE detector_id = 234'
        )->will($this->returnValue(true));
 
        $stashed_real_object = @$GLOBALS['ilDB'];
        $GLOBALS['ilDB'] = $ilDB_mock;
 
        // Act
        $detector->setDbId(234);
        $detector->deleteDetectorFromDb();
        $actual = $detector->hasDbId();
 
        // Assert
        $this->assertFalse($actual);
        $GLOBALS['ilDB'] = $stashed_real_object;
    }
 
    public function testOnActivate()
    {
        $this->markTestIncomplete(
            '$ilDB throws notices during test.'
        );
        // Arrange
        $detector = new ilEventDetector($this->node);
 
        require_once './Services/Database/classes/class.ilDBMySQL.php';
        $ilDB_mock = $this->createMock('ilDBMySQL', array('nextID','quote','insert'), array(), '', false);
 
        $ilDB_mock->expects($this->once())->method('nextID')->with($this->equalTo('wfe_det_listening'))->will($this->returnValue(234));
        $ilDB_mock->expects($this->any())->method('quote')->will($this->returnArgument(0));
        $ilDB_mock->expects($this->any())->method('insert')->with(
            'wfe_det_listening',
            array(
                'detector_id'           => array('integer', 234),
                'workflow_id'           => array('integer', null),
                'type'                          => array('text', '' ),
                'content'                       => array('text', ''),
                'subject_type'          => array('text', ''),
                'subject_id'            => array('integer', ''),
                'context_type'          => array('text', ''),
                'context_id'            => array('integer', ''),
                'listening_start'       => array('integer', 0),
                'listening_end'         => array('integer', 0)
            )
        )->will($this->returnValue(true));
 
        $stashed_real_object = @$GLOBALS['ilDB'];
        $GLOBALS['ilDB'] = $ilDB_mock;
 
        // Act
        $detector->onActivate();
        $actual = $detector->hasDbId();
 
        // Assert
        $this->assertTrue($actual);
        $this->assertEquals(234, $detector->getDbId());
        $GLOBALS['ilDB'] = $stashed_real_object;
    }
    
    public function testOnDeactivate()
    {
        $this->markTestIncomplete(
            '$ilDB throws notices during test.'
        );
 
        // Arrange
        $detector = new ilEventDetector($this->node);
 
        require_once './Services/Database/classes/class.ilDBMySQL.php';
        $ilDB_mock = $this->createMock('ilDBMySQL', array('quote','manipulate'), array(), '', false);
 
        $ilDB_mock->expects($this->any())->method('quote')->will($this->returnValue(234));
        $ilDB_mock->expects($this->any())->method('manipulate')->with(
            'DELETE
                                FROM wfe_det_listening
                                WHERE detector_id = 234'
        )->will($this->returnValue(true));
 
        $stashed_real_object = @$GLOBALS['ilDB'];
        $GLOBALS['ilDB'] = $ilDB_mock;
 
        // Act
        $detector->setDbId(234);
        $detector->onDeactivate();
        $actual = $detector->hasDbId();
 
        // Assert
        $this->assertFalse($actual);
 
        $GLOBALS['ilDB'] = $stashed_real_object;
    }
    
    public function testSetGetEvent()
    {
        // Arrange INC
        $detector = new ilEventDetector($this->node);
        $exp_type = 'time_passed';
        $exp_content = 'time_passed';
 
        // Act
        $detector->setEvent($exp_type, $exp_content);
        
        // Assert
        $event = $detector->getEvent();
        $act_type = $event['type'];
        $act_content = $event['content'];
        $this->assertEquals($exp_type . $exp_content, $act_type . $act_content);
    }
    
    public function testSetGetEventSubject()
    {
        // Arrange INC
        $detector = new ilEventDetector($this->node);
        $exp_type = 'none';
        $exp_id = '0';
 
        // Act
        $detector->setEventSubject($exp_type, $exp_id);
        
        // Assert
        $event = $detector->getEventSubject();
        $act_type = $event['type'];
        $act_id = $event['identifier'];
        $this->assertEquals($exp_type . $exp_id, $act_type . $act_id);
    }
    
    public function testSetGetEventContext()
    {
        // Arrange INC
        $detector = new ilEventDetector($this->node);
        $exp_type = 'none';
        $exp_id = '0';
 
        // Act
        $detector->setEventContext($exp_type, $exp_id);
        
        // Assert
        $event = $detector->getEventContext();
        $act_type = $event['type'];
        $act_id = $event['identifier'];
        $this->assertEquals($exp_type . $exp_id, $act_type . $act_id);
    }
    
    public function testGetContext()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        
        // Act
        $actual = $detector->getContext();
        
        // Assert
        if ($actual === $this->node) {
            $this->assertEquals($actual, $this->node);
        } else {
            $this->assertTrue(false, 'Context not identical.');
        }
    }
 
    public function testTriggerValid()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $evt_type        = 'testEvent';
        $evt_content = 'content';
        $detector->setEvent($evt_type, $evt_content);
        $subj_type   = 'usr';
        $subj_id         = 6;
        $detector->setEventSubject($subj_type, $subj_id);
        $ctx_type        = 'crs';
        $ctx_id          = 48;
        $detector->setEventContext($ctx_type, $ctx_id);
        $params = array(
            $evt_type, $evt_content,
            $subj_type, $subj_id,
            $ctx_type, $ctx_id
        );
        
        // Act
        $detector->trigger($params);
        
        // Assert
        $actual = $detector->getDetectorState();
        $this->assertTrue($actual);
    }
 
    public function testTriggerValidTwice()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $evt_type        = 'testEvent';
        $evt_content = 'content';
        $detector->setEvent($evt_type, $evt_content);
        $subj_type   = 'usr';
        $subj_id         = 6;
        $detector->setEventSubject($subj_type, $subj_id);
        $ctx_type        = 'crs';
        $ctx_id          = 48;
        $detector->setEventContext($ctx_type, $ctx_id);
        $params = array(
            $evt_type, $evt_content,
            $subj_type, $subj_id,
            $ctx_type, $ctx_id
        );
 
        // Act
        $this->assertTrue($detector->trigger($params), 'First trigger should receive a true state.');
        $this->assertFalse($detector->trigger($params), 'Second trigger should receive a false state.');
 
        // Assert
        $actual = $detector->getDetectorState();
        $this->assertTrue($actual, 'After satisfaction of the trigger, detectorstate should be true.');
    }
 
    // TODO Test wildcards!
 
    public function testTriggerInvalidContent()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $evt_type        = 'testEvent';
        $evt_content = 'content';
        $detector->setEvent($evt_type, $evt_content);
        $subj_type   = 'usr';
        $subj_id         = 6;
        $detector->setEventSubject($subj_type, $subj_id);
        $ctx_type        = 'crs';
        $ctx_id          = 48;
        $detector->setEventContext($ctx_type, $ctx_id);
        $params = array(
            $evt_type, $evt_content . 'INVALIDATE',
            $subj_type, $subj_id,
            $ctx_type, $ctx_id
        );
        
        // Act
        $detector->trigger($params);
        
        // Assert
        $actual = $detector->getDetectorState();
        $this->assertFalse($actual);
    }
 
    public function testTriggerInvalidType()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $evt_type        = 'testEvent';
        $evt_content = 'content';
        $detector->setEvent($evt_type, $evt_content);
        $subj_type   = 'usr';
        $subj_id         = 6;
        $detector->setEventSubject($subj_type, $subj_id);
        $ctx_type        = 'crs';
        $ctx_id          = 48;
        $detector->setEventContext($ctx_type, $ctx_id);
        $params = array(
            $evt_type . 'INVALIDATE', $evt_content,
            $subj_type, $subj_id,
            $ctx_type, $ctx_id
        );
 
        // Act
        $detector->trigger($params);
 
        // Assert
        $actual = $detector->getDetectorState();
        $this->assertFalse($actual);
    }
 
    public function testTriggerInvalidSubjectType()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $evt_type        = 'testEvent';
        $evt_content = 'content';
        $detector->setEvent($evt_type, $evt_content);
        $subj_type   = 'usr';
        $subj_id         = 6;
        $detector->setEventSubject($subj_type, $subj_id);
        $ctx_type        = 'crs';
        $ctx_id          = 48;
        $detector->setEventContext($ctx_type, $ctx_id);
        $params = array(
            $evt_type, $evt_content,
            $subj_type . 'INVALIDATE', $subj_id,
            $ctx_type, $ctx_id
        );
 
        // Act
        $detector->trigger($params);
 
        // Assert
        $actual = $detector->getDetectorState();
        $this->assertFalse($actual);
    }
 
    public function testTriggerInvalidSubjectId()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $evt_type        = 'testEvent';
        $evt_content = 'content';
        $detector->setEvent($evt_type, $evt_content);
        $subj_type   = 'usr';
        $subj_id         = 6;
        $detector->setEventSubject($subj_type, $subj_id);
        $ctx_type        = 'crs';
        $ctx_id          = 48;
        $detector->setEventContext($ctx_type, $ctx_id);
        $params = array(
            $evt_type, $evt_content,
            $subj_type, $subj_id . 'INVALIDATE',
            $ctx_type, $ctx_id
        );
 
        // Act
        $detector->trigger($params);
 
        // Assert
        $actual = $detector->getDetectorState();
        $this->assertFalse($actual);
    }
 
    public function testTriggerInvalidContextType()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $evt_type        = 'testEvent';
        $evt_content = 'content';
        $detector->setEvent($evt_type, $evt_content);
        $subj_type   = 'usr';
        $subj_id         = 6;
        $detector->setEventSubject($subj_type, $subj_id);
        $ctx_type        = 'crs';
        $ctx_id          = 48;
        $detector->setEventContext($ctx_type, $ctx_id);
        $params = array(
            $evt_type, $evt_content,
            $subj_type, $subj_id,
            $ctx_type . 'INVALIDATE', $ctx_id
        );
 
        // Act
        $detector->trigger($params);
 
        // Assert
        $actual = $detector->getDetectorState();
        $this->assertFalse($actual);
    }
 
    public function testTriggerInvalidContextId()
    {
        // Arrange
        $detector = new ilEventDetector($this->node);
        $evt_type        = 'testEvent';
        $evt_content = 'content';
        $detector->setEvent($evt_type, $evt_content);
        $subj_type   = 'usr';
        $subj_id         = 6;
        $detector->setEventSubject($subj_type, $subj_id);
        $ctx_type        = 'crs';
        $ctx_id          = 48;
        $detector->setEventContext($ctx_type, $ctx_id);
        $params = array(
            $evt_type, $evt_content,
            $subj_type, $subj_id,
            $ctx_type, $ctx_id . 'INVALIDATE'
        );
 
        // Act
        $detector->trigger($params);
 
        // Assert
        $actual = $detector->getDetectorState();
        $this->assertFalse($actual);
    }
}