[Summary view]

Differences Between: [Versions 39 and 310] [Versions 39 and 311] [Versions 39 and 400] [Versions 39 and 401] [Versions 39 and 402] [Versions 39 and 403]

   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 info and subclasses.
  19   *
  20   * @package core_availability
  21   * @copyright 2014 The Open University
  22   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  defined('MOODLE_INTERNAL') || die();
  26  
  27  use core_availability\info;
  28  use core_availability\info_module;
  29  use core_availability\info_section;
  30  
  31  /**
  32   * Unit tests for info and subclasses.
  33   *
  34   * @package core_availability
  35   * @copyright 2014 The Open University
  36   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  37   */
  38  class info_testcase extends advanced_testcase {
  39      public function setUp() {
  40          // Load the mock condition so that it can be used.
  41          require_once (__DIR__ . '/fixtures/mock_condition.php');
  42      }
  43  
  44      /**
  45       * Tests the info_module class (is_available, get_full_information).
  46       */
  47      public function test_info_module() {
  48          global $DB, $CFG;
  49  
  50          // Create a course and pages.
  51          $CFG->enableavailability = 0;
  52          $this->setAdminUser();
  53          $this->resetAfterTest();
  54          $generator = $this->getDataGenerator();
  55          $course = $generator->create_course();
  56          $rec = array('course' => $course);
  57          $page1 = $generator->get_plugin_generator('mod_page')->create_instance($rec);
  58          $page2 = $generator->get_plugin_generator('mod_page')->create_instance($rec);
  59          $page3 = $generator->get_plugin_generator('mod_page')->create_instance($rec);
  60          $page4 = $generator->get_plugin_generator('mod_page')->create_instance($rec);
  61  
  62          // Set up the availability option for the pages to mock options.
  63          $DB->set_field('course_modules', 'availability', '{"op":"|","show":true,"c":[' .
  64                  '{"type":"mock","a":false,"m":"grandmaster flash"}]}', array('id' => $page1->cmid));
  65          $DB->set_field('course_modules', 'availability', '{"op":"|","show":true,"c":[' .
  66                  '{"type":"mock","a":true,"m":"the furious five"}]}', array('id' => $page2->cmid));
  67  
  68          // Third page is invalid. (Fourth has no availability settings.)
  69          $DB->set_field('course_modules', 'availability', '{{{', array('id' => $page3->cmid));
  70  
  71          $modinfo = get_fast_modinfo($course);
  72          $cm1 = $modinfo->get_cm($page1->cmid);
  73          $cm2 = $modinfo->get_cm($page2->cmid);
  74          $cm3 = $modinfo->get_cm($page3->cmid);
  75          $cm4 = $modinfo->get_cm($page4->cmid);
  76  
  77          // Do availability and full information checks.
  78          $info = new info_module($cm1);
  79          $information = '';
  80          $this->assertFalse($info->is_available($information));
  81          $this->assertEquals('SA: grandmaster flash', $information);
  82          $this->assertEquals('SA: [FULL]grandmaster flash', $info->get_full_information());
  83          $info = new info_module($cm2);
  84          $this->assertTrue($info->is_available($information));
  85          $this->assertEquals('', $information);
  86          $this->assertEquals('SA: [FULL]the furious five', $info->get_full_information());
  87  
  88          // Check invalid one.
  89          $info = new info_module($cm3);
  90          $this->assertFalse($info->is_available($information));
  91          $debugging = $this->getDebuggingMessages();
  92          $this->resetDebugging();
  93          $this->assertEquals(1, count($debugging));
  94          $this->assertContains('Invalid availability', $debugging[0]->message);
  95  
  96          // Check empty one.
  97          $info = new info_module($cm4);
  98          $this->assertTrue($info->is_available($information));
  99          $this->assertEquals('', $information);
 100          $this->assertEquals('', $info->get_full_information());
 101      }
 102  
 103      /**
 104       * Tests the info_section class (is_available, get_full_information).
 105       */
 106      public function test_info_section() {
 107          global $DB;
 108  
 109          // Create a course.
 110          $this->setAdminUser();
 111          $this->resetAfterTest();
 112          $generator = $this->getDataGenerator();
 113          $course = $generator->create_course(
 114                  array('numsections' => 4), array('createsections' => true));
 115  
 116          // Set up the availability option for the sections to mock options.
 117          $DB->set_field('course_sections', 'availability', '{"op":"|","show":true,"c":[' .
 118                  '{"type":"mock","a":false,"m":"public"}]}',
 119                  array('course' => $course->id, 'section' => 1));
 120          $DB->set_field('course_sections', 'availability', '{"op":"|","show":true,"c":[' .
 121                  '{"type":"mock","a":true,"m":"enemy"}]}',
 122                  array('course' => $course->id, 'section' => 2));
 123  
 124          // Third section is invalid. (Fourth has no availability setting.)
 125          $DB->set_field('course_sections', 'availability', '{{{',
 126                  array('course' => $course->id, 'section' => 3));
 127  
 128          $modinfo = get_fast_modinfo($course);
 129          $sections = $modinfo->get_section_info_all();
 130  
 131          // Do availability and full information checks.
 132          $info = new info_section($sections[1]);
 133          $information = '';
 134          $this->assertFalse($info->is_available($information));
 135          $this->assertEquals('SA: public', $information);
 136          $this->assertEquals('SA: [FULL]public', $info->get_full_information());
 137          $info = new info_section($sections[2]);
 138          $this->assertTrue($info->is_available($information));
 139          $this->assertEquals('', $information);
 140          $this->assertEquals('SA: [FULL]enemy', $info->get_full_information());
 141  
 142          // Check invalid one.
 143          $info = new info_section($sections[3]);
 144          $this->assertFalse($info->is_available($information));
 145          $debugging = $this->getDebuggingMessages();
 146          $this->resetDebugging();
 147          $this->assertEquals(1, count($debugging));
 148          $this->assertContains('Invalid availability', $debugging[0]->message);
 149  
 150          // Check empty one.
 151          $info = new info_section($sections[4]);
 152          $this->assertTrue($info->is_available($information));
 153          $this->assertEquals('', $information);
 154          $this->assertEquals('', $info->get_full_information());
 155      }
 156  
 157      /**
 158       * Tests the is_user_visible() static function in info_module.
 159       */
 160      public function test_is_user_visible() {
 161          global $CFG, $DB;
 162          require_once($CFG->dirroot . '/course/lib.php');
 163          $this->resetAfterTest();
 164          $CFG->enableavailability = 0;
 165  
 166          // Create a course and some pages:
 167          // 0. Invisible due to visible=0.
 168          // 1. Availability restriction (mock, set to fail).
 169          // 2. Availability restriction on section (mock, set to fail).
 170          // 3. Actually visible.
 171          $generator = $this->getDataGenerator();
 172          $course = $generator->create_course(
 173                  array('numsections' => 1), array('createsections' => true));
 174          $rec = array('course' => $course, );
 175          $pages = array();
 176          $pagegen = $generator->get_plugin_generator('mod_page');
 177          $pages[0] = $pagegen->create_instance($rec, array('visible' => 0));
 178          $pages[1] = $pagegen->create_instance($rec);
 179          $pages[2] = $pagegen->create_instance($rec);
 180          $pages[3] = $pagegen->create_instance($rec);
 181          $modinfo = get_fast_modinfo($course);
 182          $section = $modinfo->get_section_info(1);
 183          $cm = $modinfo->get_cm($pages[2]->cmid);
 184          moveto_module($cm, $section);
 185  
 186          // Set the availability restrictions in database. The enableavailability
 187          // setting is off so these do not take effect yet.
 188          $notavailable = '{"op":"|","show":true,"c":[{"type":"mock","a":false}]}';
 189          $DB->set_field('course_sections', 'availability',
 190                  $notavailable, array('id' => $section->id));
 191          $DB->set_field('course_modules', 'availability',
 192                  $notavailable, array('id' => $pages[1]->cmid));
 193          get_fast_modinfo($course, 0, true);
 194  
 195          // Set up 4 users - a teacher and student plus somebody who isn't even
 196          // on the course. Also going to use admin user and a spare student to
 197          // avoid cache problems.
 198          $roleids = $DB->get_records_menu('role', null, '', 'shortname, id');
 199          $teacher = $generator->create_user();
 200          $student = $generator->create_user();
 201          $student2 = $generator->create_user();
 202          $other = $generator->create_user();
 203          $admin = $DB->get_record('user', array('username' => 'admin'));
 204          $generator->enrol_user($teacher->id, $course->id, $roleids['teacher']);
 205          $generator->enrol_user($student->id, $course->id, $roleids['student']);
 206          $generator->enrol_user($student2->id, $course->id, $roleids['student']);
 207  
 208          // Basic case when availability disabled, for visible item.
 209          $this->assertTrue(info_module::is_user_visible($pages[3]->cmid, $student->id, false));
 210  
 211          // Specifying as an object should not make any queries.
 212          $cm = $DB->get_record('course_modules', array('id' => $pages[3]->cmid));
 213          $beforequeries = $DB->perf_get_queries();
 214          $this->assertTrue(info_module::is_user_visible($cm, $student->id, false));
 215          $this->assertEquals($beforequeries, $DB->perf_get_queries());
 216  
 217          // Specifying as cm_info for correct user should not make any more queries
 218          // if we have already obtained dynamic data.
 219          $modinfo = get_fast_modinfo($course, $student->id);
 220          $cminfo = $modinfo->get_cm($cm->id);
 221          // This will obtain dynamic data.
 222          $name = $cminfo->name;
 223          $beforequeries = $DB->perf_get_queries();
 224          $this->assertTrue(info_module::is_user_visible($cminfo, $student->id, false));
 225          $this->assertEquals($beforequeries, $DB->perf_get_queries());
 226  
 227          // Function does not care if you are in the course (unless $checkcourse).
 228          $this->assertTrue(info_module::is_user_visible($cm, $other->id, false));
 229  
 230          // With $checkcourse, check for enrolled, not enrolled, and admin user.
 231          $this->assertTrue(info_module::is_user_visible($cm, $student->id, true));
 232          $this->assertFalse(info_module::is_user_visible($cm, $other->id, true));
 233          $this->assertTrue(info_module::is_user_visible($cm, $admin->id, true));
 234  
 235          // With availability off, the student can access all except the
 236          // visible=0 one.
 237          $this->assertFalse(info_module::is_user_visible($pages[0]->cmid, $student->id, false));
 238          $this->assertTrue(info_module::is_user_visible($pages[1]->cmid, $student->id, false));
 239          $this->assertTrue(info_module::is_user_visible($pages[2]->cmid, $student->id, false));
 240  
 241          // Teacher and admin can even access the visible=0 one.
 242          $this->assertTrue(info_module::is_user_visible($pages[0]->cmid, $teacher->id, false));
 243          $this->assertTrue(info_module::is_user_visible($pages[0]->cmid, $admin->id, false));
 244  
 245          // Now enable availability (and clear cache).
 246          $CFG->enableavailability = true;
 247          get_fast_modinfo($course, 0, true);
 248  
 249          // Student cannot access the activity restricted by its own or by the
 250          // section's availability.
 251          $this->assertFalse(info_module::is_user_visible($pages[1]->cmid, $student->id, false));
 252          $this->assertFalse(info_module::is_user_visible($pages[2]->cmid, $student->id, false));
 253      }
 254  
 255      /**
 256       * Tests the convert_legacy_fields function used in restore.
 257       */
 258      public function test_convert_legacy_fields() {
 259          // Check with no availability conditions first.
 260          $rec = (object)array('availablefrom' => 0, 'availableuntil' => 0,
 261                  'groupingid' => 7, 'showavailability' => 1);
 262          $this->assertNull(info::convert_legacy_fields($rec, false));
 263  
 264          // Check same list for a section.
 265          $this->assertEquals(
 266                  '{"op":"&","showc":[false],"c":[{"type":"grouping","id":7}]}',
 267                  info::convert_legacy_fields($rec, true));
 268  
 269          // Check groupmembersonly with grouping.
 270          $rec->groupmembersonly = 1;
 271          $this->assertEquals(
 272                  '{"op":"&","showc":[false],"c":[{"type":"grouping","id":7}]}',
 273                  info::convert_legacy_fields($rec, false));
 274  
 275          // Check groupmembersonly without grouping.
 276          $rec->groupingid = 0;
 277          $this->assertEquals(
 278                  '{"op":"&","showc":[false],"c":[{"type":"group"}]}',
 279                  info::convert_legacy_fields($rec, false));
 280  
 281          // Check start date.
 282          $rec->groupmembersonly = 0;
 283          $rec->availablefrom = 123;
 284          $this->assertEquals(
 285                  '{"op":"&","showc":[true],"c":[{"type":"date","d":">=","t":123}]}',
 286                  info::convert_legacy_fields($rec, false));
 287  
 288          // Start date with show = false.
 289          $rec->showavailability = 0;
 290          $this->assertEquals(
 291                  '{"op":"&","showc":[false],"c":[{"type":"date","d":">=","t":123}]}',
 292                  info::convert_legacy_fields($rec, false));
 293  
 294          // End date.
 295          $rec->showavailability = 1;
 296          $rec->availablefrom = 0;
 297          $rec->availableuntil = 456;
 298          $this->assertEquals(
 299                  '{"op":"&","showc":[false],"c":[{"type":"date","d":"<","t":456}]}',
 300                  info::convert_legacy_fields($rec, false));
 301  
 302          // All together now.
 303          $rec->groupingid = 7;
 304          $rec->groupmembersonly = 1;
 305          $rec->availablefrom = 123;
 306          $this->assertEquals(
 307                  '{"op":"&","showc":[false,true,false],"c":[' .
 308                  '{"type":"grouping","id":7},' .
 309                  '{"type":"date","d":">=","t":123},' .
 310                  '{"type":"date","d":"<","t":456}' .
 311                  ']}',
 312                  info::convert_legacy_fields($rec, false));
 313          $this->assertEquals(
 314                  '{"op":"&","showc":[false,true,false],"c":[' .
 315                  '{"type":"grouping","id":7},' .
 316                  '{"type":"date","d":">=","t":123},' .
 317                  '{"type":"date","d":"<","t":456}' .
 318                  ']}',
 319                  info::convert_legacy_fields($rec, false, true));
 320      }
 321  
 322      /**
 323       * Tests the add_legacy_availability_condition function used in restore.
 324       */
 325      public function test_add_legacy_availability_condition() {
 326          // Completion condition tests.
 327          $rec = (object)array('sourcecmid' => 7, 'requiredcompletion' => 1);
 328          // No previous availability, show = true.
 329          $this->assertEquals(
 330                  '{"op":"&","showc":[true],"c":[{"type":"completion","cm":7,"e":1}]}',
 331                  info::add_legacy_availability_condition(null, $rec, true));
 332          // No previous availability, show = false.
 333          $this->assertEquals(
 334                  '{"op":"&","showc":[false],"c":[{"type":"completion","cm":7,"e":1}]}',
 335                  info::add_legacy_availability_condition(null, $rec, false));
 336  
 337          // Existing availability.
 338          $before = '{"op":"&","showc":[true],"c":[{"type":"date","d":">=","t":70}]}';
 339          $this->assertEquals(
 340                  '{"op":"&","showc":[true,true],"c":['.
 341                  '{"type":"date","d":">=","t":70},' .
 342                  '{"type":"completion","cm":7,"e":1}' .
 343                  ']}',
 344                  info::add_legacy_availability_condition($before, $rec, true));
 345  
 346          // Grade condition tests.
 347          $rec = (object)array('gradeitemid' => 3, 'grademin' => 7, 'grademax' => null);
 348          $this->assertEquals(
 349                  '{"op":"&","showc":[true],"c":[{"type":"grade","id":3,"min":7.00000}]}',
 350                  info::add_legacy_availability_condition(null, $rec, true));
 351          $rec->grademax = 8;
 352          $this->assertEquals(
 353                  '{"op":"&","showc":[true],"c":[{"type":"grade","id":3,"min":7.00000,"max":8.00000}]}',
 354                  info::add_legacy_availability_condition(null, $rec, true));
 355          unset($rec->grademax);
 356          unset($rec->grademin);
 357          $this->assertEquals(
 358                  '{"op":"&","showc":[true],"c":[{"type":"grade","id":3}]}',
 359                  info::add_legacy_availability_condition(null, $rec, true));
 360  
 361          // Note: There is no need to test the grade condition with show
 362          // true/false and existing availability, because this uses the same
 363          // function.
 364      }
 365  
 366      /**
 367       * Tests the add_legacy_availability_field_condition function used in restore.
 368       */
 369      public function test_add_legacy_availability_field_condition() {
 370          // User field, normal operator.
 371          $rec = (object)array('userfield' => 'email', 'shortname' => null,
 372                  'operator' => 'contains', 'value' => '@');
 373          $this->assertEquals(
 374                  '{"op":"&","showc":[true],"c":[' .
 375                  '{"type":"profile","op":"contains","sf":"email","v":"@"}]}',
 376                  info::add_legacy_availability_field_condition(null, $rec, true));
 377  
 378          // User field, non-value operator.
 379          $rec = (object)array('userfield' => 'email', 'shortname' => null,
 380                  'operator' => 'isempty', 'value' => '');
 381          $this->assertEquals(
 382                  '{"op":"&","showc":[true],"c":[' .
 383                  '{"type":"profile","op":"isempty","sf":"email"}]}',
 384                  info::add_legacy_availability_field_condition(null, $rec, true));
 385  
 386          // Custom field.
 387          $rec = (object)array('userfield' => null, 'shortname' => 'frogtype',
 388                  'operator' => 'isempty', 'value' => '');
 389          $this->assertEquals(
 390                  '{"op":"&","showc":[true],"c":[' .
 391                  '{"type":"profile","op":"isempty","cf":"frogtype"}]}',
 392                  info::add_legacy_availability_field_condition(null, $rec, true));
 393      }
 394  
 395      /**
 396       * Tests the filter_user_list() and get_user_list_sql() functions.
 397       */
 398      public function test_filter_user_list() {
 399          global $CFG, $DB;
 400          require_once($CFG->dirroot . '/course/lib.php');
 401          $this->resetAfterTest();
 402          $CFG->enableavailability = true;
 403  
 404          // Create a course with 2 sections and 2 pages and 3 users.
 405          // Availability is set up initially on the 'page/section 2' items.
 406          $generator = $this->getDataGenerator();
 407          $course = $generator->create_course(
 408                  array('numsections' => 2), array('createsections' => true));
 409          $u1 = $generator->create_user();
 410          $u2 = $generator->create_user();
 411          $u3 = $generator->create_user();
 412          $studentroleid = $DB->get_field('role', 'id', array('shortname' => 'student'), MUST_EXIST);
 413          $allusers = array($u1->id => $u1, $u2->id => $u2, $u3->id => $u3);
 414          $generator->enrol_user($u1->id, $course->id, $studentroleid);
 415          $generator->enrol_user($u2->id, $course->id, $studentroleid);
 416          $generator->enrol_user($u3->id, $course->id, $studentroleid);
 417  
 418          // Page 2 allows access to users 2 and 3, while section 2 allows access
 419          // to users 1 and 2.
 420          $pagegen = $generator->get_plugin_generator('mod_page');
 421          $page = $pagegen->create_instance(array('course' => $course));
 422          $page2 = $pagegen->create_instance(array('course' => $course,
 423                  'availability' => '{"op":"|","show":true,"c":[{"type":"mock","filter":[' .
 424                  $u2->id . ',' . $u3->id . ']}]}'));
 425          $modinfo = get_fast_modinfo($course);
 426          $section = $modinfo->get_section_info(1);
 427          $section2 = $modinfo->get_section_info(2);
 428          $DB->set_field('course_sections', 'availability',
 429                  '{"op":"|","show":true,"c":[{"type":"mock","filter":[' . $u1->id . ',' . $u2->id .']}]}',
 430                  array('id' => $section2->id));
 431          moveto_module($modinfo->get_cm($page2->cmid), $section2);
 432  
 433          // With no restrictions, returns full list.
 434          $info = new info_module($modinfo->get_cm($page->cmid));
 435          $this->assertEquals(array($u1->id, $u2->id, $u3->id),
 436                  array_keys($info->filter_user_list($allusers)));
 437          $this->assertEquals(array('', array()), $info->get_user_list_sql(true));
 438  
 439          // Set an availability restriction in database for section 1.
 440          // For the section we set it so it doesn't support filters; for the
 441          // module we have a filter.
 442          $DB->set_field('course_sections', 'availability',
 443                  '{"op":"|","show":true,"c":[{"type":"mock","a":false}]}',
 444                  array('id' => $section->id));
 445          $DB->set_field('course_modules', 'availability',
 446                  '{"op":"|","show":true,"c":[{"type":"mock","filter":[' . $u3->id .']}]}',
 447                  array('id' => $page->cmid));
 448          rebuild_course_cache($course->id, true);
 449          $modinfo = get_fast_modinfo($course);
 450  
 451          // Now it should work (for the module).
 452          $info = new info_module($modinfo->get_cm($page->cmid));
 453          $expected = array($u3->id);
 454          $this->assertEquals($expected,
 455                  array_keys($info->filter_user_list($allusers)));
 456          list ($sql, $params) = $info->get_user_list_sql();
 457          $result = $DB->get_fieldset_sql($sql, $params);
 458          sort($result);
 459          $this->assertEquals($expected, $result);
 460          $info = new info_section($modinfo->get_section_info(1));
 461          $this->assertEquals(array($u1->id, $u2->id, $u3->id),
 462                  array_keys($info->filter_user_list($allusers)));
 463          $this->assertEquals(array('', array()), $info->get_user_list_sql(true));
 464  
 465          // With availability disabled, module returns full list too.
 466          $CFG->enableavailability = false;
 467          $info = new info_module($modinfo->get_cm($page->cmid));
 468          $this->assertEquals(array($u1->id, $u2->id, $u3->id),
 469                  array_keys($info->filter_user_list($allusers)));
 470          $this->assertEquals(array('', array()), $info->get_user_list_sql(true));
 471  
 472          // Check the other section...
 473          $CFG->enableavailability = true;
 474          $info = new info_section($modinfo->get_section_info(2));
 475          $expected = array($u1->id, $u2->id);
 476          $this->assertEquals($expected, array_keys($info->filter_user_list($allusers)));
 477          list ($sql, $params) = $info->get_user_list_sql(true);
 478          $result = $DB->get_fieldset_sql($sql, $params);
 479          sort($result);
 480          $this->assertEquals($expected, $result);
 481  
 482          // And the module in that section - which has combined the section and
 483          // module restrictions.
 484          $info = new info_module($modinfo->get_cm($page2->cmid));
 485          $expected = array($u2->id);
 486          $this->assertEquals($expected, array_keys($info->filter_user_list($allusers)));
 487          list ($sql, $params) = $info->get_user_list_sql(true);
 488          $result = $DB->get_fieldset_sql($sql, $params);
 489          sort($result);
 490          $this->assertEquals($expected, $result);
 491  
 492          // If the students have viewhiddenactivities, they get past the module
 493          // restriction.
 494          role_change_permission($studentroleid, context_module::instance($page2->cmid),
 495                  'moodle/course:ignoreavailabilityrestrictions', CAP_ALLOW);
 496          $expected = array($u1->id, $u2->id);
 497          $this->assertEquals($expected, array_keys($info->filter_user_list($allusers)));
 498          list ($sql, $params) = $info->get_user_list_sql(true);
 499          $result = $DB->get_fieldset_sql($sql, $params);
 500          sort($result);
 501          $this->assertEquals($expected, $result);
 502  
 503          // If they have viewhiddensections, they also get past the section
 504          // restriction.
 505          role_change_permission($studentroleid, context_course::instance($course->id),
 506                  'moodle/course:ignoreavailabilityrestrictions', CAP_ALLOW);
 507          $expected = array($u1->id, $u2->id, $u3->id);
 508          $this->assertEquals($expected, array_keys($info->filter_user_list($allusers)));
 509          list ($sql, $params) = $info->get_user_list_sql(true);
 510          $result = $DB->get_fieldset_sql($sql, $params);
 511          sort($result);
 512          $this->assertEquals($expected, $result);
 513      }
 514  
 515      /**
 516       * Tests the info_module class when involved in a recursive call to $cm->name.
 517       */
 518      public function test_info_recursive_name_call() {
 519          global $DB;
 520  
 521          $this->resetAfterTest();
 522  
 523          // Create a course and page.
 524          $generator = $this->getDataGenerator();
 525          $course = $generator->create_course();
 526          $page1 = $generator->create_module('page', ['course' => $course->id, 'name' => 'Page1']);
 527  
 528          // Set invalid availability.
 529          $DB->set_field('course_modules', 'availability', 'not valid', ['id' => $page1->cmid]);
 530  
 531          // Get the cm_info object.
 532          $this->setAdminUser();
 533          $modinfo = get_fast_modinfo($course);
 534          $cm1 = $modinfo->get_cm($page1->cmid);
 535  
 536          // At this point we will generate dynamic data for $cm1, which will cause the debugging
 537          // call below.
 538          $this->assertEquals('Page1', $cm1->name);
 539  
 540          $this->assertDebuggingCalled('Error processing availability data for ' .
 541                  '&lsquo;Page1&rsquo;: Invalid availability text');
 542      }
 543  }