lib/tests/navigationlib_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Unit tests for lib/navigationlib.php
  19  *
  20  * @package   core
  21  * @category  test
  22  * @copyright 2009 Sam Hemelryk
  23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later (5)
  24  */
  25
  26 namespace core;
  27
  28 use action_link;
  29 use global_navigation;
  30 use navbar;
  31 use navigation_cache;
  32 use navigation_node;
  33 use navigation_node_collection;
  34 use pix_icon;
  35 use popup_action;
  36 use settings_navigation;
  37
  38 defined('MOODLE_INTERNAL') || die();
  39
  40 global $CFG;
  41 require_once($CFG->libdir . '/navigationlib.php');
  42
  43 /**
  44  * Unit tests for lib/navigationlib.php
  45  *
  46  * @package   core
  47  * @category  test
  48  * @copyright 2009 Sam Hemelryk
  49  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later (5)
  50  */
  51 class navigationlib_test extends \advanced_testcase {
  52     /**
  53      * @var navigation_node
  54      */
  55     public $node;
  56
  57     protected function setup_node() {
  58         global $PAGE, $SITE;
  59
  60         $PAGE->set_url('/');
  61         $PAGE->set_course($SITE);
  62
  63         $activeurl = $PAGE->url;
  64         $inactiveurl = new \moodle_url('http://www.moodle.com/');
  65
  66         navigation_node::override_active_url($PAGE->url);
  67
  68         $this->node = new navigation_node('Test Node');
  69         $this->node->type = navigation_node::TYPE_SYSTEM;
  70         // We add the first child without key. This way we make sure all keys search by comparison is performed using ===.
  71         $this->node->add('first child without key', null, navigation_node::TYPE_CUSTOM);
  72         $demo1 = $this->node->add('demo1', $inactiveurl, navigation_node::TYPE_COURSE, null, 'demo1', new pix_icon('i/course', ''));
  73         $demo2 = $this->node->add('demo2', $inactiveurl, navigation_node::TYPE_COURSE, null, 'demo2', new pix_icon('i/course', ''));
  74         $demo3 = $this->node->add('demo3', $inactiveurl, navigation_node::TYPE_CATEGORY, null, 'demo3', new pix_icon('i/course', ''));
  75         $demo4 = $demo3->add('demo4', $inactiveurl, navigation_node::TYPE_COURSE,  null, 'demo4', new pix_icon('i/course', ''));
  76         $demo5 = $demo3->add('demo5', $activeurl, navigation_node::TYPE_COURSE, null, 'demo5', new pix_icon('i/course', ''));
  77         $demo5->add('activity1', null, navigation_node::TYPE_ACTIVITY, null, 'activity1')->make_active();
  78         $demo6 = $demo3->add('demo6', null, navigation_node::TYPE_CONTAINER, 'container node test', 'demo6');
  79         $hiddendemo1 = $this->node->add('hiddendemo1', $inactiveurl, navigation_node::TYPE_CATEGORY, null, 'hiddendemo1', new pix_icon('i/course', ''));
  80         $hiddendemo1->hidden = true;
  81         $hiddendemo1->add('hiddendemo2', $inactiveurl, navigation_node::TYPE_COURSE, null, 'hiddendemo2', new pix_icon('i/course', ''))->helpbutton = 'Here is a help button';
  82         $hiddendemo1->add('hiddendemo3', $inactiveurl, navigation_node::TYPE_COURSE, null, 'hiddendemo3', new pix_icon('i/course', ''))->display = false;
  83     }
  84
  85     public function test_node__construct() {
  86         $this->setup_node();
  87
  88         $fakeproperties = array(
  89             'text' => 'text',
  90             'shorttext' => 'A very silly extra long short text string, more than 25 characters',
  91             'key' => 'key',
  92             'type' => 'navigation_node::TYPE_COURSE',
  93             'action' => new \moodle_url('http://www.moodle.org/'));
  94
  95         $node = new navigation_node($fakeproperties);
  96         $this->assertSame($fakeproperties['text'], $node->text);
  97         $this->assertTrue(strpos($fakeproperties['shorttext'], substr($node->shorttext, 0, -3)) === 0);
  98         $this->assertSame($fakeproperties['key'], $node->key);
  99         $this->assertSame($fakeproperties['type'], $node->type);
 100         $this->assertSame($fakeproperties['action'], $node->action);
 101     }
 102
 103     public function test_node_add() {
 104         $this->setup_node();
 105
 106         // Add a node with all args set.
 107         $node1 = $this->node->add('test_add_1', 'http://www.moodle.org/', navigation_node::TYPE_COURSE, 'testadd1', 'key', new pix_icon('i/course', ''));
 108         // Add a node with the minimum args required.
 109         $node2 = $this->node->add('test_add_2', null, navigation_node::TYPE_CUSTOM, 'testadd2');
 110         $node3 = $this->node->add(str_repeat('moodle ', 15), str_repeat('moodle', 15));
 111
 112         $this->assertInstanceOf('navigation_node', $node1);
 113         $this->assertInstanceOf('navigation_node', $node2);
 114         $this->assertInstanceOf('navigation_node', $node3);
 115
 116         $ref = $this->node->get('key');
 117         $this->assertSame($node1, $ref);
 118
 119         $ref = $this->node->get($node2->key);
 120         $this->assertSame($node2, $ref);
 121
 122         $ref = $this->node->get($node2->key, $node2->type);
 123         $this->assertSame($node2, $ref);
 124
 125         $ref = $this->node->get($node3->key, $node3->type);
 126         $this->assertSame($node3, $ref);
 127     }
 128
 129     public function test_node_add_before() {
 130         $this->setup_node();
 131
 132         // Create 3 nodes.
 133         $node1 = navigation_node::create('test_add_1', null, navigation_node::TYPE_CUSTOM,
 134             'test 1', 'testadd1');
 135         $node2 = navigation_node::create('test_add_2', null, navigation_node::TYPE_CUSTOM,
 136             'test 2', 'testadd2');
 137         $node3 = navigation_node::create('test_add_3', null, navigation_node::TYPE_CUSTOM,
 138             'test 3', 'testadd3');
 139         // Add node 2, then node 1 before 2, then node 3 at end.
 140         $this->node->add_node($node2);
 141         $this->node->add_node($node1, 'testadd2');
 142         $this->node->add_node($node3);
 143         // Check the last 3 nodes are in 1, 2, 3 order and have those indexes.
 144         foreach ($this->node->children as $child) {
 145             $keys[] = $child->key;
 146         }
 147         $this->assertSame('testadd1', $keys[count($keys)-3]);
 148         $this->assertSame('testadd2', $keys[count($keys)-2]);
 149         $this->assertSame('testadd3', $keys[count($keys)-1]);
 150     }
 151
 152     public function test_node_add_class() {
 153         $this->setup_node();
 154
 155         $node = $this->node->get('demo1');
 156         $this->assertInstanceOf('navigation_node', $node);
 157         if ($node !== false) {
 158             $node->add_class('myclass');
 159             $classes = $node->classes;
 160             $this->assertContains('myclass', $classes);
 161         }
 162     }
 163
 164     public function test_node_check_if_active() {
 165         $this->setup_node();
 166
 167         // First test the string urls
 168         // Demo1 -> action is http://www.moodle.org/, thus should be true.
 169         $demo5 = $this->node->find('demo5', navigation_node::TYPE_COURSE);
 170         if ($this->assertInstanceOf('navigation_node', $demo5)) {
 171             $this->assertTrue($demo5->check_if_active());
 172         }
 173
 174         // Demo2 -> action is http://www.moodle.com/, thus should be false.
 175         $demo2 = $this->node->get('demo2');
 176         if ($this->assertInstanceOf('navigation_node', $demo2)) {
 177             $this->assertFalse($demo2->check_if_active());
 178         }
 179     }
 180
 181     public function test_node_contains_active_node() {
 182         $this->setup_node();
 183
 184         // Demo5, and activity1 were set to active during setup.
 185         // Should be true as it contains all nodes.
 186         $this->assertTrue($this->node->contains_active_node());
 187         // Should be true as demo5 is a child of demo3.
 188         $this->assertTrue($this->node->get('demo3')->contains_active_node());
 189         // Obviously duff.
 190         $this->assertFalse($this->node->get('demo1')->contains_active_node());
 191         // Should be true as demo5 contains activity1.
 192         $this->assertTrue($this->node->get('demo3')->get('demo5')->contains_active_node());
 193         // Should be true activity1 is the active node.
 194         $this->assertTrue($this->node->get('demo3')->get('demo5')->get('activity1')->contains_active_node());
 195         // Obviously duff.
 196         $this->assertFalse($this->node->get('demo3')->get('demo4')->contains_active_node());
 197     }
 198
 199     public function test_node_find_active_node() {
 200         $this->setup_node();
 201
 202         $activenode1 = $this->node->find_active_node();
 203         $activenode2 = $this->node->get('demo1')->find_active_node();
 204
 205         if ($this->assertInstanceOf('navigation_node', $activenode1)) {
 206             $ref = $this->node->get('demo3')->get('demo5')->get('activity1');
 207             $this->assertSame($activenode1, $ref);
 208         }
 209
 210         $this->assertNotInstanceOf('navigation_node', $activenode2);
 211     }
 212
 213     public function test_node_find() {
 214         $this->setup_node();
 215
 216         $node1 = $this->node->find('demo1', navigation_node::TYPE_COURSE);
 217         $node2 = $this->node->find('demo5', navigation_node::TYPE_COURSE);
 218         $node3 = $this->node->find('demo5', navigation_node::TYPE_CATEGORY);
 219         $node4 = $this->node->find('demo0', navigation_node::TYPE_COURSE);
 220         $this->assertInstanceOf('navigation_node', $node1);
 221         $this->assertInstanceOf('navigation_node', $node2);
 222         $this->assertNotInstanceOf('navigation_node', $node3);
 223         $this->assertNotInstanceOf('navigation_node', $node4);
 224     }
 225
 226     public function test_node_find_expandable() {
 227         $this->setup_node();
 228
 229         $expandable = array();
 230         $this->node->find_expandable($expandable);
 231
 232         $this->assertCount(0, $expandable);
 233         if (count($expandable) === 4) {
 234             $name = $expandable[0]['key'];
 235             $name .= $expandable[1]['key'];
 236             $name .= $expandable[2]['key'];
 237             $name .= $expandable[3]['key'];
 238             $this->assertSame('demo1demo2demo4hiddendemo2', $name);
 239         }
 240     }
 241
 242     public function test_node_get() {
 243         $this->setup_node();
 244
 245         $node1 = $this->node->get('demo1'); // Exists.
 246         $node2 = $this->node->get('demo4'); // Doesn't exist for this node.
 247         $node3 = $this->node->get('demo0'); // Doesn't exist at all.
 248         $node4 = $this->node->get(false);   // Sometimes occurs in nature code.
 249         $this->assertInstanceOf('navigation_node', $node1);
 250         $this->assertFalse($node2);
 251         $this->assertFalse($node3);
 252         $this->assertFalse($node4);
 253     }
 254
 255     public function test_node_get_css_type() {
 256         $this->setup_node();
 257
 258         $csstype1 = $this->node->get('demo3')->get_css_type();
 259         $csstype2 = $this->node->get('demo3')->get('demo5')->get_css_type();
 260         $this->node->get('demo3')->get('demo5')->type = 1000;
 261         $csstype3 = $this->node->get('demo3')->get('demo5')->get_css_type();
 262         $csstype4 = $this->node->get('demo3')->get('demo6')->get_css_type();
 263         $this->assertSame('type_category', $csstype1);
 264         $this->assertSame('type_course', $csstype2);
 265         $this->assertSame('type_unknown', $csstype3);
 266         $this->assertSame('type_container', $csstype4);
 267     }
 268
 269     public function test_node_make_active() {
 270         global $CFG;
 271         $this->setup_node();
 272
 273         $node1 = $this->node->add('active node 1', null, navigation_node::TYPE_CUSTOM, null, 'anode1');
 274         $node2 = $this->node->add('active node 2', new \moodle_url($CFG->wwwroot), navigation_node::TYPE_COURSE, null, 'anode2');
 275         $node1->make_active();
 276         $this->node->get('anode2')->make_active();
 277         $this->assertTrue($node1->isactive);
 278         $this->assertTrue($this->node->get('anode2')->isactive);
 279     }
 280
 281     public function test_node_remove() {
 282         $this->setup_node();
 283
 284         $remove1 = $this->node->add('child to remove 1', null, navigation_node::TYPE_CUSTOM, null, 'remove1');
 285         $remove2 = $this->node->add('child to remove 2', null, navigation_node::TYPE_CUSTOM, null, 'remove2');
 286         $remove3 = $remove2->add('child to remove 3', null, navigation_node::TYPE_CUSTOM, null, 'remove3');
 287
 288         $this->assertInstanceOf('navigation_node', $remove1);
 289         $this->assertInstanceOf('navigation_node', $remove2);
 290         $this->assertInstanceOf('navigation_node', $remove3);
 291
 292         $this->assertInstanceOf('navigation_node', $this->node->get('remove1'));
 293         $this->assertInstanceOf('navigation_node', $this->node->get('remove2'));
 294         $this->assertInstanceOf('navigation_node', $remove2->get('remove3'));
 295
 296         // Remove element and make sure this is no longer a child.
 297         $this->assertTrue($remove1->remove());
 298         $this->assertFalse($this->node->get('remove1'));
 299         $this->assertFalse(in_array('remove1', $this->node->get_children_key_list(), true));
 300
 301         // Make sure that we can insert element after removal.
 302         $insertelement = navigation_node::create('extra element 4', null, navigation_node::TYPE_CUSTOM, null, 'element4');
 303         $this->node->add_node($insertelement, 'remove2');
 304         $this->assertNotEmpty($this->node->get('element4'));
 305
 306         // Remove more elements.
 307         $this->assertTrue($this->node->get('remove2')->remove());
 308         $this->assertFalse($this->node->get('remove2'));
 309
 310         // Make sure that we can add element after removal.
 311         $this->node->add('extra element 5', null, navigation_node::TYPE_CUSTOM, null, 'element5');
 312         $this->assertNotEmpty($this->node->get('element5'));
 313
 314         $this->assertTrue($remove2->get('remove3')->remove());
 315
 316         $this->assertFalse($this->node->get('remove1'));
 317         $this->assertFalse($this->node->get('remove2'));
 318     }
 319
 320     public function test_node_remove_class() {
 321         $this->setup_node();
 322
 323         $this->node->add_class('testclass');
 324         $this->assertTrue($this->node->remove_class('testclass'));
 325         $this->assertNotContains('testclass', $this->node->classes);
 326     }
 327
 328     public function test_module_extends_navigation() {
 329         $node = new exposed_global_navigation();
 330         // Create an initial tree structure to work with.
 331         $cat1 = $node->add('category 1', null, navigation_node::TYPE_CATEGORY, null, 'cat1');
 332         $cat2 = $node->add('category 2', null, navigation_node::TYPE_CATEGORY, null, 'cat2');
 333         $cat3 = $node->add('category 3', null, navigation_node::TYPE_CATEGORY, null, 'cat3');
 334         $sub1 = $cat2->add('sub category 1', null, navigation_node::TYPE_CATEGORY, null, 'sub1');
 335         $sub2 = $cat2->add('sub category 2', null, navigation_node::TYPE_CATEGORY, null, 'sub2');
 336         $sub3 = $cat2->add('sub category 3', null, navigation_node::TYPE_CATEGORY, null, 'sub3');
 337         $course1 = $sub2->add('course 1', null, navigation_node::TYPE_COURSE, null, 'course1');
 338         $course2 = $sub2->add('course 2', null, navigation_node::TYPE_COURSE, null, 'course2');
 339         $course3 = $sub2->add('course 3', null, navigation_node::TYPE_COURSE, null, 'course3');
 340         $section1 = $course2->add('section 1', null, navigation_node::TYPE_SECTION, null, 'sec1');
 341         $section2 = $course2->add('section 2', null, navigation_node::TYPE_SECTION, null, 'sec2');
 342         $section3 = $course2->add('section 3', null, navigation_node::TYPE_SECTION, null, 'sec3');
 343         $act1 = $section2->add('activity 1', null, navigation_node::TYPE_ACTIVITY, null, 'act1');
 344         $act2 = $section2->add('activity 2', null, navigation_node::TYPE_ACTIVITY, null, 'act2');
 345         $act3 = $section2->add('activity 3', null, navigation_node::TYPE_ACTIVITY, null, 'act3');
 346         $res1 = $section2->add('resource 1', null, navigation_node::TYPE_RESOURCE, null, 'res1');
 347         $res2 = $section2->add('resource 2', null, navigation_node::TYPE_RESOURCE, null, 'res2');
 348         $res3 = $section2->add('resource 3', null, navigation_node::TYPE_RESOURCE, null, 'res3');
 349
 350         $this->assertTrue($node->exposed_module_extends_navigation('data'));
 351         $this->assertFalse($node->exposed_module_extends_navigation('test1'));
 352     }
 353
 354     public function test_navbar_prepend_and_add() {
 355         global $PAGE;
 356         // Unfortunate hack needed because people use global $PAGE around the place.
 357         $PAGE->set_url('/');
 358
 359         // We need to reset after this test because we using the generator.
 360         $this->resetAfterTest();
 361
 362         $generator = self::getDataGenerator();
 363         $cat1 = $generator->create_category();
 364         $cat2 = $generator->create_category(array('parent' => $cat1->id));
 365         $course = $generator->create_course(array('category' => $cat2->id));
 366
 367         $page = new \moodle_page();
 368         $page->set_course($course);
 369         $page->set_url(new \moodle_url('/course/view.php', array('id' => $course->id)));
 370         $page->navbar->prepend('test 1');
 371         $page->navbar->prepend('test 2');
 372         $page->navbar->add('test 3');
 373         $page->navbar->add('test 4');
 374
 375         $items = $page->navbar->get_items();
 376         foreach ($items as $item) {
 377             $this->assertInstanceOf('navigation_node', $item);
 378         }
 379
 380         $i = 0;
 381         $this->assertSame('test 1', $items[$i++]->text);
 382         $this->assertSame('test 2', $items[$i++]->text);
 383         $this->assertSame('home', $items[$i++]->key);
 384         $this->assertSame('courses', $items[$i++]->key);
 385         $this->assertSame($cat1->id, $items[$i++]->key);
 386         $this->assertSame($cat2->id, $items[$i++]->key);
 387         $this->assertSame($course->id, $items[$i++]->key);
 388         $this->assertSame('test 3', $items[$i++]->text);
 389         $this->assertSame('test 4', $items[$i++]->text);
 390
 391         return $page;
 392     }
 393
 394     /**
 395      * @depends test_navbar_prepend_and_add
 396      * @param $node
 397      */
 398     public function test_navbar_has_items(\moodle_page $page) {
 399         $this->resetAfterTest();
 400
 401         $this->assertTrue($page->navbar->has_items());
 402     }
 403
 404     public function test_cache__get() {
 405         $cache = new navigation_cache('unittest_nav');
 406         $cache->anysetvariable = true;
 407
 408         $this->assertTrue($cache->anysetvariable);
 409         $this->assertEquals($cache->notasetvariable, null);
 410     }
 411
 412     public function test_cache__set() {
 413         $cache = new navigation_cache('unittest_nav');
 414         $cache->anysetvariable = true;
 415
 416         $cache->myname = 'Sam Hemelryk';
 417         $this->assertTrue($cache->cached('myname'));
 418         $this->assertSame('Sam Hemelryk', $cache->myname);
 419     }
 420
 421     public function test_cache_cached() {
 422         $cache = new navigation_cache('unittest_nav');
 423         $cache->anysetvariable = true;
 424
 425         $this->assertTrue($cache->cached('anysetvariable'));
 426         $this->assertFalse($cache->cached('notasetvariable'));
 427     }
 428
 429     public function test_cache_clear() {
 430         $cache = new navigation_cache('unittest_nav');
 431         $cache->anysetvariable = true;
 432
 433         $cache = clone($cache);
 434         $this->assertTrue($cache->cached('anysetvariable'));
 435         $cache->clear();
 436         $this->assertFalse($cache->cached('anysetvariable'));
 437     }
 438
 439     public function test_cache_set() {
 440         $cache = new navigation_cache('unittest_nav');
 441         $cache->anysetvariable = true;
 442
 443         $cache->set('software', 'Moodle');
 444         $this->assertTrue($cache->cached('software'));
 445         $this->assertEquals($cache->software, 'Moodle');
 446     }
 447
 448     public function test_setting___construct() {
 449         global $PAGE, $SITE;
 450
 451         $this->resetAfterTest(false);
 452
 453         $PAGE->set_url('/');
 454         $PAGE->set_course($SITE);
 455
 456         $node = new exposed_settings_navigation();
 457
 458         return $node;
 459     }
 460
 461     /**
 462      * @depends test_setting___construct
 463      * @param mixed $node
 464      * @return mixed
 465      */
 466     public function test_setting__initialise($node) {
 467         $this->resetAfterTest(false);
 468
 469         $node->initialise();
 470         $this->assertEquals($node->id, 'settingsnav');
 471
 472         return $node;
 473     }
 474
 475     /**
 476      * Test that users with the correct permissions can view the preferences page.
 477      */
 478     public function test_can_view_user_preferences() {
 479         global $PAGE, $DB, $SITE;
 480         $this->resetAfterTest();
 481
 482         $persontoview = $this->getDataGenerator()->create_user();
 483         $persondoingtheviewing = $this->getDataGenerator()->create_user();
 484
 485         $PAGE->set_url('/');
 486         $PAGE->set_course($SITE);
 487
 488         // Check that a standard user can not view the preferences page.
 489         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 490         $this->getDataGenerator()->role_assign($studentrole->id, $persondoingtheviewing->id);
 491         $this->setUser($persondoingtheviewing);
 492         $settingsnav = new exposed_settings_navigation();
 493         $settingsnav->initialise();
 494         $settingsnav->extend_for_user($persontoview->id);
 495         $this->assertFalse($settingsnav->can_view_user_preferences($persontoview->id));
 496
 497         // Set persondoingtheviewing as a manager.
 498         $managerrole = $DB->get_record('role', array('shortname' => 'manager'));
 499         $this->getDataGenerator()->role_assign($managerrole->id, $persondoingtheviewing->id);
 500         $settingsnav = new exposed_settings_navigation();
 501         $settingsnav->initialise();
 502         $settingsnav->extend_for_user($persontoview->id);
 503         $this->assertTrue($settingsnav->can_view_user_preferences($persontoview->id));
 504
 505         // Check that the admin can view the preferences page.
 506         $this->setAdminUser();
 507         $settingsnav = new exposed_settings_navigation();
 508         $settingsnav->initialise();
 509         $settingsnav->extend_for_user($persontoview->id);
 510         $preferencenode = $settingsnav->find('userviewingsettings' . $persontoview->id, null);
 511         $this->assertTrue($settingsnav->can_view_user_preferences($persontoview->id));
 512     }
 513
 514     /**
 515      * @depends test_setting__initialise
 516      * @param mixed $node
 517      * @return mixed
 518      */
 519     public function test_setting_in_alternative_role($node) {
 520         $this->resetAfterTest();
 521
 522         $this->assertFalse($node->exposed_in_alternative_role());
 523     }
 524
 525
 526     public function test_navigation_node_collection_remove_with_no_type() {
 527         $navigationnodecollection = new navigation_node_collection();
 528         $this->setup_node();
 529         $this->node->key = 100;
 530
 531         // Test it's empty
 532         $this->assertEquals(0, count($navigationnodecollection->get_key_list()));
 533
 534         // Add a node
 535         $navigationnodecollection->add($this->node);
 536
 537         // Test it's not empty
 538         $this->assertEquals(1, count($navigationnodecollection->get_key_list()));
 539
 540         // Remove a node - passing key only!
 541         $this->assertTrue($navigationnodecollection->remove(100));
 542
 543         // Test it's empty again!
 544         $this->assertEquals(0, count($navigationnodecollection->get_key_list()));
 545     }
 546
 547     public function test_navigation_node_collection_remove_with_type() {
 548         $navigationnodecollection = new navigation_node_collection();
 549         $this->setup_node();
 550         $this->node->key = 100;
 551
 552         // Test it's empty
 553         $this->assertEquals(0, count($navigationnodecollection->get_key_list()));
 554
 555         // Add a node
 556         $navigationnodecollection->add($this->node);
 557
 558         // Test it's not empty
 559         $this->assertEquals(1, count($navigationnodecollection->get_key_list()));
 560
 561         // Remove a node - passing type
 562         $this->assertTrue($navigationnodecollection->remove(100, 1));
 563
 564         // Test it's empty again!
 565         $this->assertEquals(0, count($navigationnodecollection->get_key_list()));
 566     }
 567 }
 568
 569
 570 /**
 571  * This is a dummy object that allows us to call protected methods within the
 572  * global navigation class by prefixing the methods with `exposed_`
 573  */
 574 class exposed_global_navigation extends global_navigation {
 575     protected $exposedkey = 'exposed_';
 576     public function __construct(\moodle_page $page=null) {
 577         global $PAGE;
 578         if ($page === null) {
 579             $page = $PAGE;
 580         }
 581         parent::__construct($page);
 582         $this->cache = new navigation_cache('unittest_nav');
 583     }
 584     public function __call($method, $arguments) {
 585         if (strpos($method, $this->exposedkey) !== false) {
 586             $method = substr($method, strlen($this->exposedkey));
 587         }
 588         if (method_exists($this, $method)) {
 589             return call_user_func_array(array($this, $method), $arguments);
 590         }
 591         throw new \coding_exception('You have attempted to access a method that does not exist for the given object '.$method, DEBUG_DEVELOPER);
 592     }
 593     public function set_initialised() {
 594         $this->initialised = true;
 595     }
 596 }
 597
 598
 599 class mock_initialise_global_navigation extends global_navigation {
 600
 601     protected static $count = 1;
 602
 603     public function load_for_category() {
 604         $this->add('load_for_category', null, null, null, 'initcall'.self::$count);
 605         self::$count++;
 606         return 0;
 607     }
 608
 609     public function load_for_course() {
 610         $this->add('load_for_course', null, null, null, 'initcall'.self::$count);
 611         self::$count++;
 612         return 0;
 613     }
 614
 615     public function load_for_activity() {
 616         $this->add('load_for_activity', null, null, null, 'initcall'.self::$count);
 617         self::$count++;
 618         return 0;
 619     }
 620
 621     public function load_for_user($user=null, $forceforcontext=false) {
 622         $this->add('load_for_user', null, null, null, 'initcall'.self::$count);
 623         self::$count++;
 624         return 0;
 625     }
 626 }
 627
 628 /**
 629  * This is a dummy object that allows us to call protected methods within the
 630  * global navigation class by prefixing the methods with `exposed_`.
 631  */
 632 class exposed_navbar extends navbar {
 633     protected $exposedkey = 'exposed_';
 634     public function __construct(\moodle_page $page) {
 635         parent::__construct($page);
 636         $this->cache = new navigation_cache('unittest_nav');
 637     }
 638     public function __call($method, $arguments) {
 639         if (strpos($method, $this->exposedkey) !== false) {
 640             $method = substr($method, strlen($this->exposedkey));
 641         }
 642         if (method_exists($this, $method)) {
 643             return call_user_func_array(array($this, $method), $arguments);
 644         }
 645         throw new \coding_exception('You have attempted to access a method that does not exist for the given object '.$method, DEBUG_DEVELOPER);
 646     }
 647 }
 648
 649 class navigation_exposed_moodle_page extends \moodle_page {
 650     public function set_navigation(navigation_node $node) {
 651         $this->_navigation = $node;
 652     }
 653 }
 654
 655 /**
 656  * This is a dummy object that allows us to call protected methods within the
 657  * global navigation class by prefixing the methods with `exposed_`.
 658  */
 659 class exposed_settings_navigation extends settings_navigation {
 660     protected $exposedkey = 'exposed_';
 661     public function __construct() {
 662         global $PAGE;
 663         parent::__construct($PAGE);
 664         $this->cache = new navigation_cache('unittest_nav');
 665     }
 666     public function __call($method, $arguments) {
 667         if (strpos($method, $this->exposedkey) !== false) {
 668             $method = substr($method, strlen($this->exposedkey));
 669         }
 670         if (method_exists($this, $method)) {
 671             return call_user_func_array(array($this, $method), $arguments);
 672         }
 673         throw new \coding_exception('You have attempted to access a method that does not exist for the given object '.$method, DEBUG_DEVELOPER);
 674     }
 675 }