ilObjStudyProgrammeTest.php

Go to the documentation of this file.

<?php
/*
    +-----------------------------------------------------------------------------+
    | ILIAS open source                                                           |
    +-----------------------------------------------------------------------------+
    | Copyright (c) 1998-2009 ILIAS open source, University of Cologne            |
    |                                                                             |
    | This program is free software; you can redistribute it and/or               |
    | modify it under the terms of the GNU General Public License                 |
    | as published by the Free Software Foundation; either version 2              |
    | of the License, or (at your option) any later version.                      |
    |                                                                             |
    | This program is distributed in the hope that it will be useful,             |
    | but WITHOUT ANY WARRANTY; without even the implied warranty of              |
    | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               |
    | GNU General Public License for more details.                                |
    |                                                                             |
    | You should have received a copy of the GNU General Public License           |
    | along with this program; if not, write to the Free Software                 |
    | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. |
    +-----------------------------------------------------------------------------+
*/
 
require_once(__DIR__ . "/mocks.php");
 
class ilObjStudyProgrammeTest extends PHPUnit_Framework_TestCase
{
    protected $backupGlobals = false;
 
    protected function setUp()
    {
        PHPUnit_Framework_Error_Deprecated::$enabled = false;
 
        require_once("./Modules/StudyProgramme/classes/class.ilObjStudyProgramme.php");
 
        include_once("./Services/PHPUnit/classes/class.ilUnitUtil.php");
        ilUnitUtil::performInitialisation();
        
        $this->root_object = ilObjStudyProgramme::createInstance();
        $this->root_object_obj_id = $this->root_object->getId();
        $this->root_object_ref_id = $this->root_object->getRefId();
        $this->root_object->putInTree(ROOT_FOLDER_ID);
        
        //
        
        global $DIC;
        $tree = $DIC['tree'];
        $this->tree = $tree;
        
        global $DIC;
        $objDefinition = $DIC['objDefinition'];
        $this->obj_definition = $objDefinition;
    }
    
    protected function tearDown()
    {
        if ($this->root_object) {
            $this->root_object->delete();
        }
    }
    
    public function testCreation()
    {
        $this->assertNotEmpty($this->root_object_obj_id);
        $this->assertGreaterThan(0, $this->root_object_obj_id);
 
        $this->assertNotEmpty($this->root_object_ref_id);
        $this->assertGreaterThan(0, $this->root_object_ref_id);
 
        $this->assertTrue($this->tree->isInTree($this->root_object_ref_id));
    }
    
    public function testDefaults()
    {
        $this->assertEquals($this->root_object->getStatus(), ilStudyProgramme::STATUS_DRAFT);
    }
 
    public function testLoadByObjId()
    {
        $loaded = new ilObjStudyProgramme($this->root_object_obj_id, false);
        $orig = $this->root_object;
        $load_ref_id = ilObjStudyProgramme::getInstanceByRefId($this->root_object_ref_id);
 
        $this->assertNotNull($loaded);
        $this->assertGreaterThan(0, $loaded->getId());
        $this->assertEquals($orig->getId(), $loaded->getId());
        $this->assertEquals(
            $orig->getLastChange()->get(IL_CAL_DATETIME),
            $loaded->getLastChange()->get(IL_CAL_DATETIME)
        );
        $this->assertEquals($orig->getPoints(), $loaded->getPoints());
        $this->assertEquals($orig->getLPMode(), $loaded->getLPMode());
        $this->assertEquals($orig->getStatus(), $loaded->getStatus());
    }
 
    public function testLoadByRefId()
    {
        $loaded = new ilObjStudyProgramme($this->root_object_ref_id);
        $orig = $this->root_object;
 
        $this->assertNotNull($loaded);
        $this->assertGreaterThan(0, $loaded->getId());
        $this->assertEquals($orig->getId(), $loaded->getId());
        $this->assertEquals(
            $orig->getLastChange()->get(IL_CAL_DATETIME),
            $loaded->getLastChange()->get(IL_CAL_DATETIME)
        );
        $this->assertEquals($orig->getPoints(), $loaded->getPoints());
        $this->assertEquals($orig->getLPMode(), $loaded->getLPMode());
        $this->assertEquals($orig->getStatus(), $loaded->getStatus());
    }
 
    public function testGetInstanceByRefId()
    {
        require_once("Modules/StudyProgramme/classes/class.ilObjStudyProgrammeCache.php");
 
        ilObjStudyProgrammeCache::singleton()->test_clear();
        $this->assertTrue(ilObjStudyProgrammeCache::singleton()->test_isEmpty());
        
        $loaded = ilObjStudyProgramme::getInstanceByRefId($this->root_object_ref_id);
        $orig = $this->root_object;
 
        $this->assertNotNull($loaded);
        $this->assertGreaterThan(0, $loaded->getId());
        $this->assertEquals($orig->getId(), $loaded->getId());
        $this->assertEquals(
            $orig->getLastChange()->get(IL_CAL_DATETIME),
            $loaded->getLastChange()->get(IL_CAL_DATETIME)
        );
        $this->assertEquals($orig->getPoints(), $loaded->getPoints());
        $this->assertEquals($orig->getLPMode(), $loaded->getLPMode());
        $this->assertEquals($orig->getStatus(), $loaded->getStatus());
    }
 
    public function testSettings()
    {
        $obj = ilObjStudyProgramme::getInstanceByRefId($this->root_object_ref_id);
 
        $obj->setPoints(10);
        $obj->setStatus(ilStudyProgramme::STATUS_ACTIVE);
        $obj->update();
        
        $obj = ilObjStudyProgramme::getInstanceByRefId($this->root_object_ref_id);
 
        $this->assertEquals(10, $obj->getPoints());
        $this->assertEquals(ilStudyProgramme::STATUS_ACTIVE, $obj->getStatus());
 
        $midnight = strtotime("today midnight");
        $this->assertGreaterThan($midnight, $obj->getLastChange()->getUnixTime());
    }
 
    public function testDelete()
    {
        $deleted_object = ilObjStudyProgramme::getInstanceByRefId($this->root_object_ref_id);
 
        $this->assertTrue($deleted_object->delete());
    }
 
    protected function createSmallTree()
    {
        $first_node = ilObjStudyProgramme::createInstance();
        $second_node = ilObjStudyProgramme::createInstance();
        $third_node = ilObjStudyProgramme::createInstance();
 
        $this->root_object->addNode($first_node);
        $this->root_object->addNode($second_node);
        $this->root_object->addNode($third_node);
 
        $third_first_node = ilObjStudyProgramme::createInstance();
        $third_node->addNode($third_first_node);
    }
 
    public function testTreeCreation()
    {
        $this->createSmallTree();
        $this->assertEquals(3, $this->root_object->getAmountOfChildren());
    }
 
    public function testTreeGetChildren()
    {
        $this->createSmallTree();
        
        $children = $this->root_object->getChildren();
        $this->assertEquals(3, count($children), "getChildren()");
 
        $children = ilObjStudyProgramme::getAllChildren($this->root_object_ref_id);
        $this->assertEquals(4, count($children), "ilObjStudyProgramme::getAllChildren(" . $this->root_object_ref_id . ")");
 
        $this->assertTrue($this->root_object->hasChildren(), "hasChildren()");
        $this->assertEquals(3, $this->root_object->getAmountOfChildren(), "getAmountOfChildren()");
        
        $this->assertFalse($children[0]->hasChildren(), "hasChildren()");
        $this->assertEquals(0, $children[0]->getAmountOfChildren(), "getAmountOfChildren()");
        $this->assertEquals(0, count($children[0]->getChildren()));
    }
 
    public function testTreeGetParent()
    {
        $this->createSmallTree();
        $children = $this->root_object->getChildren();
 
        $child = $children[0];
        $this->assertNotNull($child->getParent());
        $this->assertNull($this->root_object->getParent());
    }
    
    public function testTreeGetParents()
    {
        $this->createSmallTree();
        $node3 = ilObjStudyProgramme::createInstance();
        $children = $this->root_object->getChildren();
        $children[0]->addNode($node3);
        
        $parents = $node3->getParents();
        $parent_ids = array_map(function ($node) {
            return $node->getId();
        }, $parents);
        $parent_ids_expected = array( $this->root_object->getId()
                                    , $children[0]->getId()
                                    );
        
        $this->assertEquals($parent_ids_expected, $parent_ids);
    }
 
    public function testTreeDepth()
    {
        $this->createSmallTree();
        $children = $this->root_object->getChildren();
 
        $child = $children[0];
 
        $this->assertEquals(1, $child->getDepth());
    }
 
    public function testTreeGetRoot()
    {
        $this->createSmallTree();
        $children = $this->root_object->getChildren();
        $child = $children[0];
 
        $this->assertEquals($this->root_object->getId(), $child->getRoot()->getId());
    }
    
    public function testApplyToSubTreeNodes()
    {
        $this->createSmallTree();
        $children = $this->root_object->getChildren();
        
        $val = 0;
        $this->root_object->applyToSubTreeNodes(function ($node) use (&$val) {
            $val += $node->getPoints();
        });
        
        // We didn't make modification on the points of the nodes.
        $this->assertEquals($val, 5 * ilStudyProgramme::DEFAULT_POINTS);
 
 
        $this->root_object->setPoints(1);
        $children[0]->setPoints(2);
        $children[1]->setPoints(4);
        $children[2]->setPoints(1);
 
        $third_level = $children[2]->getChildren();
        $third_level[0]->setPoints(2);
        
        $val = 0;
        $this->root_object->applyToSubTreeNodes(function ($node) use (&$val) {
            $val += $node->getPoints();
        });
        
        $this->assertEquals($val, 10);
    }
    
    public function testAddNode()
    {
        $this->createSmallTree();
        
        $children = $this->root_object->getChildren();
        $child = $children[0];
        $grandchild = new ilObjStudyProgramme();
        $grandchild->create();
        $child->addNode($grandchild);
        
        $this->assertEquals($child->getId(), $grandchild->getParent()->getId());
        $this->assertEquals(
            $this->root_object->getId(),
            $grandchild->getRoot()->getId(),
            "Root of grandchild is root of tree."
        );
        $this->assertEquals(1, $child->getAmountOfChildren());
        $this->assertEquals(2, $grandchild->getDepth());
        $this->assertEquals($child->getLPMode(), ilStudyProgramme::MODE_POINTS);
    }
    
    public function testRemoveNode()
    {
        $this->createSmallTree();
        
        $children = $this->root_object->getChildren();
        $child = $children[0];
        $this->root_object->removeNode($child);
        
        // Is not in tree anymore...
        $raised = false;
        try {
            $child->getParent();
        } catch (ilStudyProgrammeTreeException $e) {
            $raised = true;
        }
        $this->assertTrue($raised, "Child does not raise on getParent after it is removed.");
        
        $this->assertEquals(2, $this->root_object->getAmountOfChildren());
        
        // Can't be removed a second time...
        $raised = false;
        try {
            $this->root_object->removeNode($child);
        } catch (ilStudyProgrammeTreeException $e) {
            $raised = true;
        }
        $this->assertTrue($raised, "Child can be removed two times.");
    }
    
    public function testAddLeaf()
    {
        $this->createSmallTree();
        $mock_leaf = new ilStudyProgrammeLeafMock();
 
        $children = $this->root_object->getChildren();
        $first_child = $children[0];
 
        $first_child->addLeaf($mock_leaf);
 
        // We use our mock factory, since the original factory won't know how
        // to create our mock leaf.
        $first_child->object_factory = new ilObjectFactoryWrapperMock();
 
        $this->assertEquals(3, $this->root_object->getAmountOfChildren(), "getAmountOfChildren()");
        // Check if StudyProgrammes are not counted as LP-Children
        $this->assertEquals(0, $this->root_object->getAmountOfLPChildren(), "getAmountOfLPChildren() on root");
        $this->assertEquals(false, $this->root_object->hasLPChildren(), "hasLPChildren() on root");
 
        $this->assertEquals(1, $first_child->getAmountOfLPChildren(), "getAmountOfLPChildren() on first child");
        $this->assertEquals(true, $first_child->hasLPChildren(), "hasLPChildren() on first child");
        $this->assertEquals($first_child->getLPMode(), ilStudyProgramme::MODE_LP_COMPLETED);
        
        $lp_children = $first_child->getLPChildren();
        $this->assertEquals(1, count($lp_children));
        $this->assertEquals($mock_leaf->getId(), $lp_children[0]->getId());
    }
    
    public function testRemoveLeaf()
    {
        $mock_leaf = new ilStudyProgrammeLeafMock();
        $this->root_object->addLeaf($mock_leaf);
        
        $this->root_object->removeLeaf($mock_leaf);
        $this->assertEquals(0, $this->root_object->getAmountOfChildren(), "getAmountOfChildren()");
        $this->assertEquals(0, $this->root_object->getAmountOfLPChildren(), "getAmountOfLPChildren()");
        
        $lp_children = $this->root_object->getLPChildren();
        $this->assertEquals(0, count($lp_children));
    }
    
    public function testAddWrongChildType()
    {
        $this->createSmallTree();
        $children = $this->root_object->getChildren();
        $child_n = $children[0];
        $child_l = $children[1];
        
        $mock_leaf1 = new ilStudyProgrammeLeafMock();
        $mock_leaf2 = new ilStudyProgrammeLeafMock();
        $node1 = new ilObjStudyProgramme();
        $node2 = new ilObjStudyProgramme();
        $node1->create();
        $node2->create();
        
        $child_n->addNode($node1);
        $child_l->addLeaf($mock_leaf1);
        
        $raised = false;
        try {
            $child_n->addLeaf($mock_leaf2);
        } catch (ilStudyProgrammeTreeException $e) {
            $raised = true;
        }
        $this->assertTrue($raised, "Could add leaf to program containing node.");
 
        $raised = false;
        try {
            $child_n->addLeaf($mock_leaf2);
        } catch (ilStudyProgrammeTreeException $e) {
            $raised = true;
        }
        $this->assertTrue($raised, "Could add node to program containing leaf.");
    }
    
    public function testMoveTo()
    {
        $this->createSmallTree();
        $children = $this->root_object->getChildren();
        $child_l = $children[0];
        $child_r = $children[1];
        $child_m = $children[2];
 
        $child_r->moveTo($child_l);
 
        $this->assertEquals(2, $child_r->getDepth());
        $this->assertEquals($child_l->getId(), $child_r->getParent()->getId());
        $this->assertEquals(2, $this->root_object->getAmountOfChildren());
        $this->assertEquals(1, $child_l->getAmountOfChildren());
 
        // test recursive moving
        $this->assertEquals(1, $child_m->getAmountOfChildren());
 
        $child_m->moveTo($child_r);
 
        $m_children = $child_m->getChildren();
        $first_third_node = $m_children[0];
 
        $this->assertEquals(3, $child_m->getDepth());
        $this->assertEquals(1, $child_m->getAmountOfChildren());
        $this->assertNotNull($first_third_node);
        $this->assertEquals(4, $first_third_node->getDepth());
        $this->assertEquals($child_m->getId(), $first_third_node->getParent()->getId());
 
        $this->assertEquals(1, $this->root_object->getAmountOfChildren());
        $this->assertEquals(3, count(ilObjStudyProgramme::getAllChildren($child_l->getRefId())));
    }
    
    public function testCantRemoveNodeWithRelevantProgress()
    {
        $this->createSmallTree();
        $children = $this->root_object->getChildren();
        $child_l = $children[0];
        $child_r = $children[1];
        $this->root_object->setStatus(ilStudyProgramme::STATUS_ACTIVE);
        $child_l->setStatus(ilStudyProgramme::STATUS_ACTIVE);
        $child_r->setStatus(ilStudyProgramme::STATUS_ACTIVE);
        
        $user = new ilObjUser();
        $user->create();
        
        $child_l->assignUser($user->getId());
        $this->root_object->removeNode($child_l);
    }
    
    public function testCanRemoveNodeWithNotRelevantProgress()
    {
        $this->createSmallTree();
        $children = $this->root_object->getChildren();
        $child_l = $children[0];
        $child_r = $children[1];
        $this->root_object->setStatus(ilStudyProgramme::STATUS_ACTIVE);
        $child_l->setStatus(ilStudyProgramme::STATUS_ACTIVE);
        $child_r->setStatus(ilStudyProgramme::STATUS_OUTDATED);
        
        $user = new ilObjUser();
        $user->create();
        
        $this->root_object->assignUser($user->getId());
        $this->root_object->removeNode($child_r);
    }
    
    public function testCreateableSubObjects()
    {
        $this->createSmallTree();
        $children = $this->root_object->getChildren();
        $child_l = $children[0];
        
        $all_possible_subobjects = $this->root_object->getPossibleSubObjects();
        // don't take rolfs into account, we don't need rolf anymore
        unset($all_possible_subobjects["rolf"]);
        
        // this is course reference and training programme
        $this->assertCount(2, $all_possible_subobjects);
        $this->assertArrayHasKey("prg", $all_possible_subobjects);
        $this->assertArrayHasKey("crsr", $all_possible_subobjects);
        
        // root already contains program nodes, so course ref is forbidden
        $subobjs = ilObjStudyProgramme::getCreatableSubObjects($all_possible_subobjects, $this->root_object->getRefId());
        $this->assertCount(1, $subobjs);
        $this->assertArrayHasKey("prg", $subobjs);
        
        // first node contains nothing, so course ref and program node are allowed
        $subobjs = ilObjStudyProgramme::getCreatableSubObjects($all_possible_subobjects, $child_l->getRefId());
        $this->assertCount(2, $subobjs);
        $this->assertArrayHasKey("prg", $subobjs);
        $this->assertArrayHasKey("crsr", $subobjs);
        
        $mock_leaf = new ilStudyProgrammeLeafMock();
        $children = $this->root_object->getChildren();
        $child_l->object_factory = new ilObjectFactoryWrapperMock();
        $child_l->addLeaf($mock_leaf);
 
        // Now we added a leaf, so no program nodes are allowed anymore.
        $subobjs = ilObjStudyProgramme::getCreatableSubObjects($all_possible_subobjects, $child_l->getRefId());
        $this->assertCount(1, $subobjs);
        $this->assertArrayHasKey("crsr", $subobjs);
    }
    
    public function testCreatableSubObjectsWithoutRef()
    {
        $all_possible_subobjects = $this->obj_definition->getSubObjects("prg");
        // don't take rolfs into account, we don't need rolf anymore
        unset($all_possible_subobjects["rolf"]);
        $this->assertEquals(
            $all_possible_subobjects,
            ilObjStudyProgramme::getCreatableSubObjects($all_possible_subobjects, null)
        );
    }
 
    public function testCreatableSubObjectsRaisesOnNonProgramRef()
    {
        ilObjStudyProgramme::getCreatableSubObjects(array(), 9);
    }
    
    public function testDeleteRemovesEntriesInPrgSettings()
    {
        $this->root_object->delete();
        $this->root_object = null;
        
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $res = $ilDB->query(
            "SELECT COUNT(*) cnt "
                            . " FROM " . ilStudyProgramme::returnDbTableName()
                            . " WHERE obj_id = " . $this->root_object_obj_id
        );
        $rec = $ilDB->fetchAssoc($res);
        $this->assertEquals(0, $rec["cnt"]);
    }
    
    public function testCreatePermissionExists()
    {
        // Ask for permission id for creation of "foobar" to check assumption
        // that lookupCreateOperationIds just drops unknown object types.
        $op_ids = ilRbacReview::lookupCreateOperationIds(array("prg", "foobar"));
        $this->assertCount(1, $op_ids);
    }
}