[Summary view] [Print] [Text view]

   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   * Tests for the block_manager class in ../blocklib.php.
  19   *
  20   * @package   core
  21   * @category  phpunit
  22   * @copyright 2009 Tim Hunt
  23   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  defined('MOODLE_INTERNAL') || die();
  27  
  28  global $CFG;
  29  require_once($CFG->libdir . '/pagelib.php');
  30  require_once($CFG->libdir . '/blocklib.php');
  31  require_once($CFG->dirroot . '/blocks/moodleblock.class.php');
  32  
  33  
  34  /**
  35   * Test various block related classes.
  36   */
  37  class core_blocklib_testcase extends advanced_testcase {
  38      protected $testpage;
  39      protected $blockmanager;
  40      protected $isediting = null;
  41  
  42      protected function setUp() {
  43          parent::setUp();
  44          $this->testpage = new moodle_page();
  45          $this->testpage->set_context(context_system::instance());
  46          $this->testpage->set_pagetype('phpunit-block-test');
  47          $this->blockmanager = new testable_block_manager($this->testpage);
  48      }
  49  
  50      protected function tearDown() {
  51          $this->testpage = null;
  52          $this->blockmanager = null;
  53          parent::tearDown();
  54      }
  55  
  56      protected function purge_blocks() {
  57          global $DB;
  58          $this->resetAfterTest();
  59  
  60          $bis = $DB->get_records('block_instances');
  61          foreach ($bis as $instance) {
  62              blocks_delete_instance($instance);
  63          }
  64      }
  65  
  66      public function test_no_regions_initially() {
  67          // Exercise SUT & Validate.
  68          $this->assertEquals(array(), $this->blockmanager->get_regions());
  69      }
  70  
  71      public function test_add_region() {
  72          // Exercise SUT.
  73          $this->blockmanager->add_region('a-region-name', false);
  74          // Validate.
  75          $this->assertEquals(array('a-region-name'), $this->blockmanager->get_regions());
  76      }
  77  
  78      public function test_add_regions() {
  79          // Set up fixture.
  80          $regions = array('a-region', 'another-region');
  81          // Exercise SUT.
  82          $this->blockmanager->add_regions($regions, false);
  83          // Validate.
  84          $this->assertEquals($regions, $this->blockmanager->get_regions(), '', 0, 10, true);
  85      }
  86  
  87      public function test_add_region_twice() {
  88          // Exercise SUT.
  89          $this->blockmanager->add_region('a-region-name', false);
  90          $this->blockmanager->add_region('another-region', false);
  91          // Validate.
  92          $this->assertEquals(array('a-region-name', 'another-region'), $this->blockmanager->get_regions(), '', 0, 10, true);
  93      }
  94  
  95      /**
  96       * @expectedException coding_exception
  97       */
  98      public function test_cannot_add_region_after_loaded() {
  99          // Set up fixture.
 100          $this->blockmanager->mark_loaded();
 101          // Exercise SUT.
 102          $this->blockmanager->add_region('too-late', false);
 103      }
 104  
 105      /**
 106       * Testing adding a custom region.
 107       */
 108      public function test_add_custom_region() {
 109          global $SESSION;
 110          // Exercise SUT.
 111          $this->blockmanager->add_region('a-custom-region-name');
 112          // Validate.
 113          $this->assertEquals(array('a-custom-region-name'), $this->blockmanager->get_regions());
 114          $this->assertTrue(isset($SESSION->custom_block_regions));
 115          $this->assertArrayHasKey('phpunit-block-test', $SESSION->custom_block_regions);
 116          $this->assertTrue(in_array('a-custom-region-name', $SESSION->custom_block_regions['phpunit-block-test']));
 117  
 118      }
 119  
 120      /**
 121       * Test adding two custom regions using add_regions method.
 122       */
 123      public function test_add_custom_regions() {
 124          global $SESSION;
 125          // Set up fixture.
 126          $regions = array('a-region', 'another-custom-region');
 127          // Exercise SUT.
 128          $this->blockmanager->add_regions($regions);
 129          // Validate.
 130          $this->assertEquals($regions, $this->blockmanager->get_regions(), '', 0, 10, true);
 131          $this->assertTrue(isset($SESSION->custom_block_regions));
 132          $this->assertArrayHasKey('phpunit-block-test', $SESSION->custom_block_regions);
 133          $this->assertTrue(in_array('another-custom-region', $SESSION->custom_block_regions['phpunit-block-test']));
 134      }
 135  
 136      /**
 137       * Test adding two custom block regions.
 138       */
 139      public function test_add_custom_region_twice() {
 140          // Exercise SUT.
 141          $this->blockmanager->add_region('a-custom-region-name');
 142          $this->blockmanager->add_region('another-custom-region');
 143          // Validate.
 144          $this->assertEquals(
 145              array('a-custom-region-name', 'another-custom-region'),
 146              $this->blockmanager->get_regions(),
 147              '', 0, 10, true
 148          );
 149      }
 150  
 151      /**
 152       * Test to ensure that we cannot add a region after the blocks have been loaded.
 153       * @expectedException coding_exception
 154       */
 155      public function test_cannot_add_custom_region_after_loaded() {
 156          // Set up fixture.
 157          $this->blockmanager->mark_loaded();
 158          // Exercise SUT.
 159          $this->blockmanager->add_region('too-late');
 160      }
 161  
 162      public function test_set_default_region() {
 163          // Set up fixture.
 164          $this->blockmanager->add_region('a-region-name', false);
 165          // Exercise SUT.
 166          $this->blockmanager->set_default_region('a-region-name');
 167          // Validate.
 168          $this->assertEquals('a-region-name', $this->blockmanager->get_default_region());
 169      }
 170  
 171      /**
 172       * @expectedException coding_exception
 173       */
 174      public function test_cannot_set_unknown_region_as_default() {
 175          // Exercise SUT.
 176          $this->blockmanager->set_default_region('a-region-name');
 177      }
 178  
 179      /**
 180       * @expectedException coding_exception
 181       */
 182      public function test_cannot_change_default_region_after_loaded() {
 183          // Set up fixture.
 184          $this->blockmanager->mark_loaded();
 185          // Exercise SUT.
 186          $this->blockmanager->set_default_region('too-late');
 187      }
 188  
 189      public function test_matching_page_type_patterns() {
 190          $this->assertEquals(array('site-index', 'site-index-*', 'site-*', '*'),
 191              matching_page_type_patterns('site-index'), '', 0, 10, true);
 192  
 193          $this->assertEquals(array('mod-quiz-report-overview', 'mod-quiz-report-overview-*', 'mod-quiz-report-*', 'mod-quiz-*', 'mod-*', '*'),
 194              matching_page_type_patterns('mod-quiz-report-overview'), '', 0, 10, true);
 195  
 196          $this->assertEquals(array('mod-forum-view', 'mod-*-view', 'mod-forum-view-*', 'mod-forum-*', 'mod-*', '*'),
 197              matching_page_type_patterns('mod-forum-view'), '', 0, 10, true);
 198  
 199          $this->assertEquals(array('mod-forum-index', 'mod-*-index', 'mod-forum-index-*', 'mod-forum-*', 'mod-*', '*'),
 200              matching_page_type_patterns('mod-forum-index'), '', 0, 10, true);
 201      }
 202  
 203      protected function get_a_page_and_block_manager($regions, $context, $pagetype, $subpage = '') {
 204          $page = new moodle_page;
 205          $page->set_context($context);
 206          $page->set_pagetype($pagetype);
 207          $page->set_subpage($subpage);
 208  
 209          $blockmanager = new testable_block_manager($page);
 210          $blockmanager->add_regions($regions, false);
 211          $blockmanager->set_default_region($regions[0]);
 212  
 213          return array($page, $blockmanager);
 214      }
 215  
 216      protected function get_a_known_block_type() {
 217          global $DB;
 218          $block = new stdClass;
 219          $block->name = 'ablocktype';
 220          $DB->insert_record('block', $block);
 221          return $block->name;
 222      }
 223  
 224      protected function assertContainsBlocksOfType($typearray, $blockarray) {
 225          if (!$this->assertEquals(count($typearray), count($blockarray), "Blocks array contains the wrong number of elements %s.")) {
 226              return;
 227          }
 228          $types = array_values($typearray);
 229          $i = 0;
 230          foreach ($blockarray as $block) {
 231              $blocktype = $types[$i];
 232              $this->assertEquals($blocktype, $block->name(), "Block types do not match at postition $i %s.");
 233              $i++;
 234          }
 235      }
 236  
 237      public function test_empty_initially() {
 238          $this->purge_blocks();
 239  
 240          // Set up fixture.
 241          list($page, $blockmanager) = $this->get_a_page_and_block_manager(array('a-region'),
 242              context_system::instance(), 'page-type');
 243          // Exercise SUT.
 244          $blockmanager->load_blocks();
 245          // Validate.
 246          $blocks = $blockmanager->get_loaded_blocks();
 247          $this->assertEquals(array('a-region' => array()), $blocks);
 248      }
 249  
 250      public function test_adding_and_retrieving_one_block() {
 251          $this->purge_blocks();
 252  
 253          // Set up fixture.
 254          $regionname = 'a-region';
 255          $blockname = $this->get_a_known_block_type();
 256          $context = context_system::instance();
 257  
 258          list($page, $blockmanager) = $this->get_a_page_and_block_manager(array($regionname),
 259              $context, 'page-type');
 260  
 261          // Exercise SUT.
 262          $blockmanager->add_block($blockname, $regionname, 0, false);
 263          $blockmanager->load_blocks();
 264          // Validate.
 265          $blocks = $blockmanager->get_blocks_for_region($regionname);
 266          $this->assertContainsBlocksOfType(array($blockname), $blocks);
 267      }
 268  
 269      public function test_adding_and_retrieving_two_blocks() {
 270          $this->purge_blocks();
 271  
 272          // Set up fixture.
 273          $regionname = 'a-region';
 274          $blockname = $this->get_a_known_block_type();
 275          $context = context_system::instance();
 276  
 277          list($page, $blockmanager) = $this->get_a_page_and_block_manager(array($regionname),
 278              $context, 'page-type');
 279  
 280          // Exercise SUT.
 281          $blockmanager->add_block($blockname, $regionname, 0, false);
 282          $blockmanager->add_block($blockname, $regionname, 1, false);
 283          $blockmanager->load_blocks();
 284          // Validate.
 285          $blocks = $blockmanager->get_blocks_for_region($regionname);
 286          $this->assertContainsBlocksOfType(array($blockname, $blockname), $blocks);
 287      }
 288  
 289      public function test_adding_blocks() {
 290          $this->purge_blocks();
 291  
 292          // Set up fixture.
 293          $regionname = 'a-region';
 294          $blockname = $this->get_a_known_block_type();
 295          $context = context_system::instance();
 296  
 297          list($page, $blockmanager) = $this->get_a_page_and_block_manager(array($regionname),
 298              $context, 'page-type');
 299  
 300          $blockmanager->add_blocks(array($regionname => array($blockname, $blockname)), null, null, false, 3);
 301          $blockmanager->load_blocks();
 302  
 303          $blocks = $blockmanager->get_blocks_for_region($regionname);
 304  
 305          $this->assertEquals('3', $blocks[0]->instance->weight);
 306          $this->assertEquals('4', $blocks[1]->instance->weight);
 307      }
 308  
 309      public function test_block_not_included_in_different_context() {
 310          $this->purge_blocks();
 311  
 312          // Set up fixture.
 313          $syscontext = context_system::instance();
 314          $cat = $this->getDataGenerator()->create_category(array('name' => 'testcategory'));
 315          $fakecontext = context_coursecat::instance($cat->id);
 316          $regionname = 'a-region';
 317          $blockname = $this->get_a_known_block_type();
 318  
 319          list($addpage, $addbm) = $this->get_a_page_and_block_manager(array($regionname), $fakecontext, 'page-type');
 320          list($viewpage, $viewbm) = $this->get_a_page_and_block_manager(array($regionname), $syscontext, 'page-type');
 321  
 322          $addbm->add_block($blockname, $regionname, 0, false);
 323  
 324          // Exercise SUT.
 325          $viewbm->load_blocks();
 326          // Validate.
 327          $blocks = $viewbm->get_blocks_for_region($regionname);
 328          $this->assertContainsBlocksOfType(array(), $blocks);
 329      }
 330  
 331      public function test_block_included_in_sub_context() {
 332          $this->purge_blocks();
 333  
 334          // Set up fixture.
 335          $syscontext = context_system::instance();
 336          $childcontext = context_coursecat::instance(1);
 337          $regionname = 'a-region';
 338          $blockname = $this->get_a_known_block_type();
 339  
 340          list($addpage, $addbm) = $this->get_a_page_and_block_manager(array($regionname), $syscontext, 'page-type');
 341          list($viewpage, $viewbm) = $this->get_a_page_and_block_manager(array($regionname), $childcontext, 'page-type');
 342  
 343          $addbm->add_block($blockname, $regionname, 0, true);
 344  
 345          // Exercise SUT.
 346          $viewbm->load_blocks();
 347          // Validate.
 348          $blocks = $viewbm->get_blocks_for_region($regionname);
 349          $this->assertContainsBlocksOfType(array($blockname), $blocks);
 350      }
 351  
 352      public function test_block_not_included_on_different_page_type() {
 353          $this->purge_blocks();
 354  
 355          // Set up fixture.
 356          $syscontext = context_system::instance();
 357          $regionname = 'a-region';
 358          $blockname = $this->get_a_known_block_type();
 359  
 360          list($addpage, $addbm) = $this->get_a_page_and_block_manager(array($regionname), $syscontext, 'page-type');
 361          list($viewpage, $viewbm) = $this->get_a_page_and_block_manager(array($regionname), $syscontext, 'other-page-type');
 362  
 363          $addbm->add_block($blockname, $regionname, 0, true);
 364  
 365          // Exercise SUT.
 366          $viewbm->load_blocks();
 367          // Validate.
 368          $blocks = $viewbm->get_blocks_for_region($regionname);
 369          $this->assertContainsBlocksOfType(array(), $blocks);
 370      }
 371  
 372      public function test_block_not_included_on_different_sub_page() {
 373          $this->purge_blocks();
 374  
 375          // Set up fixture.
 376          $regionname = 'a-region';
 377          $blockname = $this->get_a_known_block_type();
 378          $syscontext = context_system::instance();
 379  
 380          list($page, $blockmanager) = $this->get_a_page_and_block_manager(array($regionname),
 381              $syscontext, 'page-type', 'sub-page');
 382  
 383          $blockmanager->add_block($blockname, $regionname, 0, true, $page->pagetype, 'other-sub-page');
 384  
 385          // Exercise SUT.
 386          $blockmanager->load_blocks();
 387          // Validate.
 388          $blocks = $blockmanager->get_blocks_for_region($regionname);
 389          $this->assertContainsBlocksOfType(array(), $blocks);
 390      }
 391  
 392      public function test_block_included_with_explicit_sub_page() {
 393          $this->purge_blocks();
 394  
 395          // Set up fixture.
 396          $regionname = 'a-region';
 397          $blockname = $this->get_a_known_block_type();
 398          $syscontext = context_system::instance();
 399  
 400          list($page, $blockmanager) = $this->get_a_page_and_block_manager(array($regionname),
 401              $syscontext, 'page-type', 'sub-page');
 402  
 403          $blockmanager->add_block($blockname, $regionname, 0, true, $page->pagetype, $page->subpage);
 404  
 405          // Exercise SUT.
 406          $blockmanager->load_blocks();
 407          // Validate.
 408          $blocks = $blockmanager->get_blocks_for_region($regionname);
 409          $this->assertContainsBlocksOfType(array($blockname), $blocks);
 410      }
 411  
 412      public function test_block_included_with_page_type_pattern() {
 413          $this->purge_blocks();
 414  
 415          // Set up fixture.
 416          $regionname = 'a-region';
 417          $blockname = $this->get_a_known_block_type();
 418          $syscontext = context_system::instance();
 419  
 420          list($page, $blockmanager) = $this->get_a_page_and_block_manager(array($regionname),
 421              $syscontext, 'page-type', 'sub-page');
 422  
 423          $blockmanager->add_block($blockname, $regionname, 0, true, 'page-*', $page->subpage);
 424  
 425          // Exercise SUT.
 426          $blockmanager->load_blocks();
 427          // Validate.
 428          $blocks = $blockmanager->get_blocks_for_region($regionname);
 429          $this->assertContainsBlocksOfType(array($blockname), $blocks);
 430      }
 431  
 432      public function test_matching_page_type_patterns_from_pattern() {
 433          $pattern = '*';
 434          $expected = array('*');
 435          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 436  
 437          $pattern = 'admin-*';
 438          $expected = array('admin-*', 'admin', '*');
 439          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 440  
 441          $pattern = 'blog-index';
 442          $expected = array('blog-index', 'blog-index-*', 'blog-*', '*');
 443          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 444  
 445          $pattern = 'course-index-*';
 446          $expected = array('course-index-*', 'course-index', 'course-*', '*');
 447          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 448  
 449          $pattern = 'course-index-category';
 450          $expected = array('course-index-category', 'course-index-category-*', 'course-index-*', 'course-*', '*');
 451          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 452  
 453          $pattern = 'mod-assign-view';
 454          $expected = array('mod-assign-view', 'mod-*-view', 'mod-assign-view-*', 'mod-assign-*', 'mod-*', '*');
 455          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 456  
 457          $pattern = 'mod-assign-index';
 458          $expected = array('mod-assign-index', 'mod-*-index', 'mod-assign-index-*', 'mod-assign-*', 'mod-*', '*');
 459          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 460  
 461          $pattern = 'mod-forum-*';
 462          $expected = array('mod-forum-*', 'mod-forum', 'mod-*', '*');
 463          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 464  
 465          $pattern = 'mod-*-view';
 466          $expected = array('mod-*-view', 'mod', 'mod-*', '*');
 467          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 468  
 469          $pattern = 'mod-*-index';
 470          $expected = array('mod-*-index', 'mod', 'mod-*', '*');
 471          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 472  
 473          $pattern = 'my-index';
 474          $expected = array('my-index', 'my-index-*', 'my-*', '*');
 475          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 476  
 477          $pattern = 'user-profile';
 478          $expected = array('user-profile', 'user-profile-*', 'user-*', '*');
 479          $this->assertEquals($expected, array_values(matching_page_type_patterns_from_pattern($pattern)));
 480      }
 481  
 482      public function test_delete_instances() {
 483          global $DB;
 484          $this->purge_blocks();
 485          $this->setAdminUser();
 486  
 487          $regionname = 'a-region';
 488          $blockname = $this->get_a_known_block_type();
 489          $context = context_system::instance();
 490  
 491          list($page, $blockmanager) = $this->get_a_page_and_block_manager(array($regionname),
 492              $context, 'page-type');
 493  
 494          $blockmanager->add_blocks(array($regionname => array($blockname, $blockname, $blockname)), null, null, false, 3);
 495          $blockmanager->load_blocks();
 496  
 497          $blocks = $blockmanager->get_blocks_for_region($regionname);
 498          $blockids = array();
 499          $preferences = array();
 500  
 501          // Create block related data.
 502          foreach ($blocks as $block) {
 503              $instance = $block->instance;
 504              $pref = 'block' . $instance->id . 'hidden';
 505              set_user_preference($pref, '123', 123);
 506              $preferences[] = $pref;
 507              $pref = 'docked_block_instance_' . $instance->id;
 508              set_user_preference($pref, '123', 123);
 509              $preferences[] = $pref;
 510              blocks_set_visibility($instance, $page, 1);
 511              $blockids[] = $instance->id;
 512          }
 513  
 514          // Confirm what has been set.
 515          $this->assertCount(3, $blockids);
 516          list($insql, $inparams) = $DB->get_in_or_equal($blockids);
 517          $this->assertEquals(3, $DB->count_records_select('block_positions', "blockinstanceid $insql", $inparams));
 518          list($insql, $inparams) = $DB->get_in_or_equal($preferences);
 519          $this->assertEquals(6, $DB->count_records_select('user_preferences', "name $insql", $inparams));
 520  
 521          // Keep a block on the side.
 522          $allblockids = $blockids;
 523          $tokeep = array_pop($blockids);
 524  
 525          // Delete and confirm what should have happened.
 526          blocks_delete_instances($blockids);
 527  
 528          // Reload the manager.
 529          list($page, $blockmanager) = $this->get_a_page_and_block_manager(array($regionname),
 530              $context, 'page-type');
 531          $blockmanager->load_blocks();
 532          $blocks = $blockmanager->get_blocks_for_region($regionname);
 533  
 534          $this->assertCount(1, $blocks);
 535          list($insql, $inparams) = $DB->get_in_or_equal($allblockids);
 536          $this->assertEquals(1, $DB->count_records_select('block_positions', "blockinstanceid $insql", $inparams));
 537          list($insql, $inparams) = $DB->get_in_or_equal($preferences);
 538          $this->assertEquals(2, $DB->count_records_select('user_preferences', "name $insql", $inparams));
 539  
 540          $this->assertFalse(context_block::instance($blockids[0], IGNORE_MISSING));
 541          $this->assertFalse(context_block::instance($blockids[1], IGNORE_MISSING));
 542          context_block::instance($tokeep);   // Would throw an exception if it was deleted.
 543      }
 544  
 545  }
 546  
 547  /**
 548   * Test-specific subclass to make some protected things public.
 549   */
 550  class testable_block_manager extends block_manager {
 551  
 552      public function mark_loaded() {
 553          $this->birecordsbyregion = array();
 554      }
 555      public function get_loaded_blocks() {
 556          return $this->birecordsbyregion;
 557      }
 558  }
 559  
 560  /**
 561   * Test-specific subclass to make some protected things public.
 562   */
 563  class block_ablocktype extends block_base {
 564      public function init() {
 565      }
 566  }