[Summary view]

   1  <?php
   2  // This file is part of Moodle - https://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 <https://www.gnu.org/licenses/>.
  16  
  17  namespace core;
  18  
  19  /**
  20   * Unit tests for context helper class.
  21   *
  22   * NOTE: more tests are in lib/tests/accesslib_test.php
  23   *
  24   * @package   core
  25   * @copyright Petr Skoda
  26   * @license   https://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  27   * @coversDefaultClass \core\context_helper
  28   */
  29  class context_helper_test extends \advanced_testcase {
  30      /**
  31       * Tests covered method.
  32       * @covers ::parse_external_level
  33       */
  34      public function test_parse_external_level() {
  35          $this->assertSame(context\system::class, context_helper::parse_external_level('system'));
  36          $this->assertSame(context\system::class, context_helper::parse_external_level(CONTEXT_SYSTEM));
  37          $this->assertSame(context\system::class, context_helper::parse_external_level((string)CONTEXT_SYSTEM));
  38  
  39          $this->assertSame(context\user::class, context_helper::parse_external_level('user'));
  40          $this->assertSame(context\user::class, context_helper::parse_external_level(CONTEXT_USER));
  41          $this->assertSame(context\user::class, context_helper::parse_external_level((string)CONTEXT_USER));
  42  
  43          $this->assertSame(context\coursecat::class, context_helper::parse_external_level('coursecat'));
  44          $this->assertSame(context\coursecat::class, context_helper::parse_external_level(CONTEXT_COURSECAT));
  45          $this->assertSame(context\coursecat::class, context_helper::parse_external_level((string)CONTEXT_COURSECAT));
  46  
  47          $this->assertSame(context\course::class, context_helper::parse_external_level('course'));
  48          $this->assertSame(context\course::class, context_helper::parse_external_level(CONTEXT_COURSE));
  49          $this->assertSame(context\course::class, context_helper::parse_external_level((string)CONTEXT_COURSE));
  50  
  51          $this->assertSame(context\module::class, context_helper::parse_external_level('module'));
  52          $this->assertSame(context\module::class, context_helper::parse_external_level(CONTEXT_MODULE));
  53          $this->assertSame(context\module::class, context_helper::parse_external_level((string)CONTEXT_MODULE));
  54  
  55          $this->assertSame(context\block::class, context_helper::parse_external_level('block'));
  56          $this->assertSame(context\block::class, context_helper::parse_external_level(CONTEXT_BLOCK));
  57          $this->assertSame(context\block::class, context_helper::parse_external_level((string)CONTEXT_BLOCK));
  58  
  59          $this->assertNull(context_helper::parse_external_level('core_system'));
  60          $this->assertNull(context_helper::parse_external_level('xsystem'));
  61          $this->assertNull(context_helper::parse_external_level(1));
  62          $this->assertNull(context_helper::parse_external_level(''));
  63      }
  64  
  65      /**
  66       * Tests covered method.
  67       * @covers ::resolve_behat_reference
  68       */
  69      public function test_resolve_behat_reference() {
  70          $this->assertNull(context_helper::resolve_behat_reference('blahbla', 'blahbla'));
  71          $this->assertNull(context_helper::resolve_behat_reference('', ''));
  72          $this->assertNull(context_helper::resolve_behat_reference('0', ''));
  73  
  74          $syscontext = context\system::instance();
  75          $result = context_helper::resolve_behat_reference('System', '');
  76          $this->assertSame($syscontext->id, $result->id);
  77  
  78          $syscontext = context\system::instance();
  79          $result = context_helper::resolve_behat_reference('10', '');
  80          $this->assertSame($syscontext->id, $result->id);
  81  
  82          // The rest is tested in each context class test.
  83      }
  84  
  85      /**
  86       * Tests covered method.
  87       * @covers ::get_class_for_level
  88       */
  89      public function test_get_class_for_level() {
  90          $this->assertSame(context\system::class, context_helper::get_class_for_level(CONTEXT_SYSTEM));
  91          $this->assertSame(context\system::class, context_helper::get_class_for_level((string)CONTEXT_SYSTEM));
  92  
  93          $this->assertSame(context\user::class, context_helper::get_class_for_level(CONTEXT_USER));
  94          $this->assertSame(context\user::class, context_helper::get_class_for_level((string)CONTEXT_USER));
  95  
  96          $this->assertSame(context\coursecat::class, context_helper::get_class_for_level(CONTEXT_COURSECAT));
  97          $this->assertSame(context\coursecat::class, context_helper::get_class_for_level((string)CONTEXT_COURSECAT));
  98  
  99          $this->assertSame(context\course::class, context_helper::get_class_for_level(CONTEXT_COURSE));
 100          $this->assertSame(context\course::class, context_helper::get_class_for_level((string)CONTEXT_COURSE));
 101  
 102          $this->assertSame(context\module::class, context_helper::get_class_for_level(CONTEXT_MODULE));
 103          $this->assertSame(context\module::class, context_helper::get_class_for_level((string)CONTEXT_MODULE));
 104  
 105          $this->assertSame(context\block::class, context_helper::get_class_for_level(CONTEXT_BLOCK));
 106          $this->assertSame(context\block::class, context_helper::get_class_for_level((string)CONTEXT_BLOCK));
 107  
 108          try {
 109              context_helper::get_class_for_level(1);
 110              $this->fail('Exception expected if level does not exist');
 111          } catch (\moodle_exception $e) {
 112              $this->assertInstanceOf(\coding_exception::class, $e);
 113              $this->assertSame('Coding error detected, it must be fixed by a programmer: Invalid context level specified',
 114                  $e->getMessage());
 115          }
 116      }
 117  
 118      /**
 119       * Tests covered method.
 120       * @covers ::get_all_levels
 121       */
 122      public function test_get_all_levels() {
 123          $levels = context_helper::get_all_levels();
 124  
 125          $this->assertArrayHasKey(CONTEXT_SYSTEM, $levels);
 126          $this->assertSame(context\system::class, $levels[CONTEXT_SYSTEM]);
 127  
 128          $this->assertArrayHasKey(CONTEXT_USER, $levels);
 129          $this->assertSame(context\user::class, $levels[CONTEXT_USER]);
 130  
 131          $this->assertArrayHasKey(CONTEXT_COURSECAT, $levels);
 132          $this->assertSame(context\coursecat::class, $levels[CONTEXT_COURSECAT]);
 133  
 134          $this->assertArrayHasKey(CONTEXT_COURSE, $levels);
 135          $this->assertSame(context\course::class, $levels[CONTEXT_COURSE]);
 136  
 137          $this->assertArrayHasKey(CONTEXT_MODULE, $levels);
 138          $this->assertSame(context\module::class, $levels[CONTEXT_MODULE]);
 139  
 140          $this->assertArrayHasKey(CONTEXT_BLOCK, $levels);
 141          $this->assertSame(context\block::class, $levels[CONTEXT_BLOCK]);
 142  
 143          $sorted = $levels;
 144          ksort($sorted, SORT_NUMERIC);
 145          $block = $sorted[CONTEXT_BLOCK];
 146          unset($sorted[CONTEXT_BLOCK]);
 147          $sorted[CONTEXT_BLOCK] = $block;
 148          $this->assertSame(array_keys($sorted), array_keys($levels));
 149  
 150          // Make sure level is set properly.
 151          foreach ($levels as $level => $classname) {
 152              $this->assertEquals($level, $classname::LEVEL);
 153              if ($level != CONTEXT_SYSTEM) {
 154                  $this->assertGreaterThan(CONTEXT_SYSTEM, $level);
 155              }
 156          }
 157      }
 158  
 159      /**
 160       * Tests covered method.
 161       * @covers ::get_child_levels
 162       */
 163      public function test_get_child_levels() {
 164          $alllevels = context_helper::get_all_levels();
 165  
 166          $childlevels = context_helper::get_child_levels(CONTEXT_SYSTEM);
 167          $this->assertSame(count($alllevels) - 1, count($childlevels));
 168  
 169          $childlevels = context_helper::get_child_levels(CONTEXT_USER);
 170          $this->assertNotContains(CONTEXT_SYSTEM, $childlevels);
 171          $this->assertNotContains(CONTEXT_USER, $childlevels);
 172          $this->assertNotContains(CONTEXT_COURSECAT, $childlevels);
 173          $this->assertNotContains(CONTEXT_COURSE, $childlevels);
 174          $this->assertNotContains(CONTEXT_MODULE, $childlevels);
 175          $this->assertContains(CONTEXT_BLOCK, $childlevels);
 176  
 177          $childlevels = context_helper::get_child_levels(CONTEXT_COURSECAT);
 178          $this->assertNotContains(CONTEXT_SYSTEM, $childlevels);
 179          $this->assertNotContains(CONTEXT_USER, $childlevels);
 180          $this->assertContains(CONTEXT_COURSECAT, $childlevels);
 181          $this->assertContains(CONTEXT_COURSE, $childlevels);
 182          $this->assertContains(CONTEXT_MODULE, $childlevels);
 183          $this->assertContains(CONTEXT_BLOCK, $childlevels);
 184  
 185          $childlevels = context_helper::get_child_levels(CONTEXT_COURSE);
 186          $this->assertNotContains(CONTEXT_SYSTEM, $childlevels);
 187          $this->assertNotContains(CONTEXT_USER, $childlevels);
 188          $this->assertNotContains(CONTEXT_COURSECAT, $childlevels);
 189          $this->assertNotContains(CONTEXT_COURSE, $childlevels);
 190          $this->assertContains(CONTEXT_MODULE, $childlevels);
 191          $this->assertContains(CONTEXT_BLOCK, $childlevels);
 192  
 193          $childlevels = context_helper::get_child_levels(CONTEXT_MODULE);
 194          $this->assertNotContains(CONTEXT_SYSTEM, $childlevels);
 195          $this->assertNotContains(CONTEXT_USER, $childlevels);
 196          $this->assertNotContains(CONTEXT_COURSECAT, $childlevels);
 197          $this->assertNotContains(CONTEXT_COURSE, $childlevels);
 198          $this->assertNotContains(CONTEXT_MODULE, $childlevels);
 199          $this->assertContains(CONTEXT_BLOCK, $childlevels);
 200  
 201          $childlevels = context_helper::get_child_levels(CONTEXT_BLOCK);
 202          $this->assertCount(0, $childlevels);
 203      }
 204  
 205      /**
 206       * Tests covered method.
 207       * @covers ::get_compatible_levels
 208       */
 209      public function test_get_compatible_levels() {
 210          $levels = context_helper::get_compatible_levels('manager');
 211          $this->assertContains(CONTEXT_SYSTEM, $levels);
 212          $this->assertNotContains(CONTEXT_USER, $levels);
 213          $this->assertContains(CONTEXT_COURSECAT, $levels);
 214          $this->assertContains(CONTEXT_COURSE, $levels);
 215          $this->assertNotContains(CONTEXT_MODULE, $levels);
 216          $this->assertNotContains(CONTEXT_BLOCK, $levels);
 217  
 218          $levels = context_helper::get_compatible_levels('coursecreator');
 219          $this->assertContains(CONTEXT_SYSTEM, $levels);
 220          $this->assertNotContains(CONTEXT_USER, $levels);
 221          $this->assertContains(CONTEXT_COURSECAT, $levels);
 222          $this->assertNotContains(CONTEXT_COURSE, $levels);
 223          $this->assertNotContains(CONTEXT_MODULE, $levels);
 224          $this->assertNotContains(CONTEXT_BLOCK, $levels);
 225  
 226          $levels = context_helper::get_compatible_levels('editingteacher');
 227          $this->assertNotContains(CONTEXT_SYSTEM, $levels);
 228          $this->assertNotContains(CONTEXT_USER, $levels);
 229          $this->assertNotContains(CONTEXT_COURSECAT, $levels);
 230          $this->assertContains(CONTEXT_COURSE, $levels);
 231          $this->assertContains(CONTEXT_MODULE, $levels);
 232          $this->assertNotContains(CONTEXT_BLOCK, $levels);
 233  
 234          $levels = context_helper::get_compatible_levels('teacher');
 235          $this->assertNotContains(CONTEXT_SYSTEM, $levels);
 236          $this->assertNotContains(CONTEXT_USER, $levels);
 237          $this->assertNotContains(CONTEXT_COURSECAT, $levels);
 238          $this->assertContains(CONTEXT_COURSE, $levels);
 239          $this->assertContains(CONTEXT_MODULE, $levels);
 240          $this->assertNotContains(CONTEXT_BLOCK, $levels);
 241  
 242          $levels = context_helper::get_compatible_levels('student');
 243          $this->assertNotContains(CONTEXT_SYSTEM, $levels);
 244          $this->assertNotContains(CONTEXT_USER, $levels);
 245          $this->assertNotContains(CONTEXT_COURSECAT, $levels);
 246          $this->assertContains(CONTEXT_COURSE, $levels);
 247          $this->assertContains(CONTEXT_MODULE, $levels);
 248          $this->assertNotContains(CONTEXT_BLOCK, $levels);
 249  
 250          $levels = context_helper::get_compatible_levels('user');
 251          $this->assertCount(0, $levels);
 252  
 253          $levels = context_helper::get_compatible_levels('guest');
 254          $this->assertCount(0, $levels);
 255  
 256          $levels = context_helper::get_compatible_levels('frontpage');
 257          $this->assertCount(0, $levels);
 258      }
 259  
 260      /**
 261       * Tests covered method.
 262       * @covers ::cleanup_instances
 263       */
 264      public function test_cleanup_instances() {
 265          global $DB;
 266  
 267          $this->resetAfterTest();
 268          $this->preventResetByRollback();
 269  
 270          $prevcount = $DB->count_records('context', []);
 271          context_helper::cleanup_instances();
 272          $count = $DB->count_records('context', []);
 273          $this->assertSame($prevcount, $count);
 274  
 275          // Insert bogus records for each level and see if they get removed,
 276          // more test should be in tests for each context level.
 277          $alllevels = context_helper::get_all_levels();
 278          foreach ($alllevels as $classname) {
 279              if ($classname::LEVEL == CONTEXT_SYSTEM) {
 280                  continue;
 281              }
 282              $record = new \stdClass();
 283              $record->contextlevel = $classname::LEVEL;
 284              $record->instanceid = 9999999999;
 285              $record->path = null;
 286              $record->depth = '2';
 287              $record->id = $DB->insert_record('context', $record);
 288              $DB->set_field('context', 'path', SYSCONTEXTID . '/' . $record->id, ['id' => $record->id]);
 289          }
 290          context_helper::cleanup_instances();
 291          $count = $DB->count_records('context', []);
 292          $this->assertSame($prevcount, $count);
 293      }
 294  
 295      /**
 296       * Tests covered method.
 297       * @covers ::create_instances
 298       */
 299      public function test_create_instances() {
 300          global $DB;
 301  
 302          $this->resetAfterTest();
 303          $this->preventResetByRollback();
 304  
 305          $user = $this->getDataGenerator()->create_user();
 306          $usercontext = context\user::instance($user->id);
 307          $category = $this->getDataGenerator()->create_category();
 308          $categorycontext = context\coursecat::instance($category->id);
 309          $course = $this->getDataGenerator()->create_course();
 310          $coursecontext = context\course::instance($course->id);
 311          $page = $this->getDataGenerator()->create_module('page', ['course' => $course->id]);
 312          $pagecontext = context\module::instance($page->cmid);
 313  
 314          $prevcount = $DB->count_records('context', []);
 315          $DB->delete_records('context', ['id' => $usercontext->id]);
 316          $DB->delete_records('context', ['id' => $categorycontext->id]);
 317          $DB->delete_records('context', ['id' => $coursecontext->id]);
 318          $DB->delete_records('context', ['id' => $pagecontext->id]);
 319  
 320          context_helper::create_instances();
 321          $count = $DB->count_records('context', []);
 322          $this->assertSame($prevcount, $count);
 323      }
 324  
 325      /**
 326       * Tests covered method.
 327       * @covers ::build_all_paths
 328       */
 329      public function test_build_all_paths() {
 330          $this->resetAfterTest();
 331          $this->preventResetByRollback();
 332  
 333          // Just make sure there are no fatal errors for now.
 334          context_helper::build_all_paths(true);
 335          context_helper::build_all_paths();
 336      }
 337  
 338      /**
 339       * Tests covered method.
 340       * @covers ::reset_caches
 341       */
 342      public function test_reset_caches() {
 343          $this->resetAfterTest();
 344          $this->preventResetByRollback();
 345  
 346          // Just make sure there are no fatal errors for now.
 347          context_helper::reset_caches();
 348      }
 349  
 350      /**
 351       * Tests covered method.
 352       * @covers ::get_preload_record_columns
 353       */
 354      public function test_get_preload_record_columns() {
 355          $expected = array (
 356              'testalias.id' => 'ctxid',
 357              'testalias.path' => 'ctxpath',
 358              'testalias.depth' => 'ctxdepth',
 359              'testalias.contextlevel' => 'ctxlevel',
 360              'testalias.instanceid' => 'ctxinstance',
 361              'testalias.locked' => 'ctxlocked',
 362          );
 363          $result = context_helper::get_preload_record_columns('testalias');
 364          $this->assertSame($expected, $result);
 365      }
 366  
 367      /**
 368       * Tests covered method.
 369       * @covers ::get_preload_record_columns_sql
 370       */
 371      public function test_get_preload_record_columns_sql() {
 372          global $DB;
 373  
 374          $result = context_helper::get_preload_record_columns_sql('testalias');
 375          $expected = 'testalias.id AS ctxid, testalias.path AS ctxpath, testalias.depth AS ctxdepth,'
 376              .' testalias.contextlevel AS ctxlevel, testalias.instanceid AS ctxinstance, testalias.locked AS ctxlocked';
 377          $this->assertSame($expected, $result);
 378  
 379          $sql = "SELECT id, $result
 380                    FROM {context} testalias";
 381          $DB->get_records_sql($sql, []);
 382      }
 383  
 384      /**
 385       * Tests covered method.
 386       * @covers ::preload_from_record
 387       */
 388      public function test_preload_from_record() {
 389          global $DB;
 390  
 391          $select = context_helper::get_preload_record_columns_sql('testalias');
 392          $sql = "SELECT id, $select
 393                    FROM {context} testalias";
 394          $records = $DB->get_records_sql($sql, []);
 395          foreach ($records as $record) {
 396              $this->assertNull(context_helper::preload_from_record($record));
 397          }
 398  
 399          $this->assertDebuggingNotCalled();
 400          $record = reset($records);
 401          unset($record->ctxlevel);
 402          $this->assertNull(context_helper::preload_from_record($record));
 403      }
 404  
 405      /**
 406       * Tests covered method.
 407       * @covers ::preload_contexts_by_id
 408       */
 409      public function test_preload_contexts_by_id() {
 410          global $DB;
 411  
 412          $contextids = $DB->get_fieldset_sql("SELECT id FROM {context}", []);
 413          context_helper::preload_contexts_by_id($contextids);
 414          context_helper::preload_contexts_by_id($contextids);
 415  
 416          context_helper::reset_caches();
 417          context_helper::preload_contexts_by_id($contextids);
 418      }
 419  
 420      /**
 421       * Tests covered method.
 422       * @covers ::preload_course
 423       */
 424      public function test_preload_course() {
 425          global $SITE;
 426          context_helper::preload_course($SITE->id);
 427      }
 428  
 429      /**
 430       * Tests covered method.
 431       * @covers ::delete_instance
 432       */
 433      public function test_delete_instance() {
 434          $this->resetAfterTest();
 435  
 436          $user = $this->getDataGenerator()->create_user();
 437          $category = $this->getDataGenerator()->create_category();
 438          $course = $this->getDataGenerator()->create_course();
 439          $page = $this->getDataGenerator()->create_module('page', array('course' => $course->id));
 440  
 441          // This is a bit silly test, it might start failing in the future
 442          // because the instances are not deleted before deleting the contexts.
 443          context_helper::delete_instance(CONTEXT_USER, $user->id);
 444          context_helper::delete_instance(CONTEXT_COURSECAT, $category->id);
 445          context_helper::delete_instance(CONTEXT_COURSE, $course->id);
 446          context_helper::delete_instance(CONTEXT_MODULE, $page->cmid);
 447      }
 448  
 449      /**
 450       * Tests covered method.
 451       * @covers ::get_level_name
 452       */
 453      public function test_get_level_name() {
 454          $allevels = context_helper::get_all_levels();
 455          foreach ($allevels as $level => $classname) {
 456              $name = context_helper::get_level_name($level);
 457              $this->assertIsString($name);
 458          }
 459  
 460          $this->assertSame('System', context_helper::get_level_name(CONTEXT_SYSTEM));
 461          $this->assertSame('User', context_helper::get_level_name(CONTEXT_USER));
 462          $this->assertSame('Category', context_helper::get_level_name(CONTEXT_COURSECAT));
 463          $this->assertSame('Course', context_helper::get_level_name(CONTEXT_COURSE));
 464          $this->assertSame('Activity module', context_helper::get_level_name(CONTEXT_MODULE));
 465          $this->assertSame('Block', context_helper::get_level_name(CONTEXT_BLOCK));
 466      }
 467  
 468      /**
 469       * Tests covered method.
 470       * @covers ::get_navigation_filter_context
 471       */
 472      public function test_get_navigation_filter_context() {
 473          global $CFG;
 474          $this->resetAfterTest();
 475  
 476          $user = $this->getDataGenerator()->create_user();
 477          $usercontext = context\user::instance($user->id);
 478          $category = $this->getDataGenerator()->create_category();
 479          $categorycontext = context\coursecat::instance($category->id);
 480          $course = $this->getDataGenerator()->create_course();
 481          $coursecontext = context\course::instance($course->id);
 482          $page = $this->getDataGenerator()->create_module('page', array('course' => $course->id));
 483          $pagecontext = context\module::instance($page->cmid);
 484          $systemcontext = context\system::instance();
 485  
 486          // Default is OFF.
 487          $this->assertSame('0', $CFG->filternavigationwithsystemcontext);
 488  
 489          // First test passed values are returned if disabled.
 490          set_config('filternavigationwithsystemcontext', '0');
 491  
 492          $this->assertNull(context_helper::get_navigation_filter_context(null));
 493  
 494          $filtercontext = context_helper::get_navigation_filter_context($systemcontext);
 495          $this->assertSame($systemcontext, $filtercontext);
 496  
 497          $filtercontext = context_helper::get_navigation_filter_context($usercontext);
 498          $this->assertSame($usercontext, $filtercontext);
 499  
 500          $filtercontext = context_helper::get_navigation_filter_context($categorycontext);
 501          $this->assertSame($categorycontext, $filtercontext);
 502  
 503          $filtercontext = context_helper::get_navigation_filter_context($coursecontext);
 504          $this->assertSame($coursecontext, $filtercontext);
 505  
 506          $filtercontext = context_helper::get_navigation_filter_context($pagecontext);
 507          $this->assertSame($pagecontext, $filtercontext);
 508  
 509          // Now test that any input returns system context if enabled.
 510          set_config('filternavigationwithsystemcontext', '1');
 511  
 512          $filtercontext = context_helper::get_navigation_filter_context(null);
 513          $this->assertSame($systemcontext->id, $filtercontext->id);
 514  
 515          $filtercontext = context_helper::get_navigation_filter_context($systemcontext);
 516          $this->assertSame($systemcontext->id, $filtercontext->id);
 517  
 518          $filtercontext = context_helper::get_navigation_filter_context($usercontext);
 519          $this->assertSame($systemcontext->id, $filtercontext->id);
 520  
 521          $filtercontext = context_helper::get_navigation_filter_context($categorycontext);
 522          $this->assertSame($systemcontext->id, $filtercontext->id);
 523  
 524          $filtercontext = context_helper::get_navigation_filter_context($coursecontext);
 525          $this->assertSame($systemcontext->id, $filtercontext->id);
 526  
 527          $filtercontext = context_helper::get_navigation_filter_context($pagecontext);
 528          $this->assertSame($systemcontext->id, $filtercontext->id);
 529      }
 530  }