[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   * Data generators tests
  19   *
  20   * @package    core
  21   * @category   phpunit
  22   * @copyright  2012 Petr Skoda {@link http://skodak.org}
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  defined('MOODLE_INTERNAL') || die();
  27  
  28  
  29  /**
  30   * Test data generator
  31   *
  32   * @package    core
  33   * @category   phpunit
  34   * @copyright  2012 Petr Skoda {@link http://skodak.org}
  35   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  36   */
  37  class core_test_generator_testcase extends advanced_testcase {
  38      public function test_get_plugin_generator_good_case() {
  39          $generator = $this->getDataGenerator()->get_plugin_generator('core_question');
  40          $this->assertInstanceOf('core_question_generator', $generator);
  41      }
  42  
  43      public function test_get_plugin_generator_sloppy_name() {
  44          $generator = $this->getDataGenerator()->get_plugin_generator('quiz');
  45          $this->assertDebuggingCalled('Please specify the component you want a generator for as ' .
  46                      'mod_quiz, not quiz.', DEBUG_DEVELOPER);
  47          $this->assertInstanceOf('mod_quiz_generator', $generator);
  48      }
  49  
  50      /**
  51       * Test plugin generator, with no component directory.
  52       *
  53       * @expectedException        coding_exception
  54       * @expectedExceptionMessage Component core_completion does not support generators yet. Missing tests/generator/lib.php.
  55       */
  56      public function test_get_plugin_generator_no_component_dir() {
  57          $generator = $this->getDataGenerator()->get_plugin_generator('core_completion');
  58      }
  59  
  60      public function test_create_user() {
  61          global $DB, $CFG;
  62          require_once($CFG->dirroot.'/user/lib.php');
  63  
  64          $this->resetAfterTest(true);
  65          $generator = $this->getDataGenerator();
  66  
  67          $count = $DB->count_records('user');
  68          $this->setCurrentTimeStart();
  69          $user = $generator->create_user();
  70          $this->assertEquals($count + 1, $DB->count_records('user'));
  71          $this->assertSame($user->username, core_user::clean_field($user->username, 'username'));
  72          $this->assertSame($user->email, core_user::clean_field($user->email, 'email'));
  73          $this->assertSame(AUTH_PASSWORD_NOT_CACHED, $user->password);
  74          $this->assertNotEmpty($user->firstnamephonetic);
  75          $this->assertNotEmpty($user->lastnamephonetic);
  76          $this->assertNotEmpty($user->alternatename);
  77          $this->assertNotEmpty($user->middlename);
  78          $this->assertSame('manual', $user->auth);
  79          $this->assertSame('en', $user->lang);
  80          $this->assertSame('1', $user->confirmed);
  81          $this->assertSame('0', $user->deleted);
  82          $this->assertTimeCurrent($user->timecreated);
  83          $this->assertSame($user->timecreated, $user->timemodified);
  84          $this->assertSame('0.0.0.0', $user->lastip);
  85  
  86          $record = array(
  87              'auth' => 'email',
  88              'firstname' => 'Žluťoučký',
  89              'lastname' => 'Koníček',
  90              'firstnamephonetic' => 'Zhlutyoucky',
  91              'lastnamephonetic' => 'Koniiczek',
  92              'middlename' => 'Hopper',
  93              'alternatename' => 'horse',
  94              'idnumber' => 'abc1',
  95              'mnethostid' => (string)$CFG->mnet_localhost_id,
  96              'username' => 'konic666',
  97              'password' => 'password1',
  98              'email' => 'email@example.com',
  99              'confirmed' => '1',
 100              'lang' => 'cs',
 101              'maildisplay' => '1',
 102              'mailformat' => '0',
 103              'maildigest' => '1',
 104              'autosubscribe' => '0',
 105              'trackforums' => '0',
 106              'deleted' => '0',
 107              'timecreated' => '666',
 108          );
 109          $user = $generator->create_user($record);
 110          $this->assertEquals($count + 2, $DB->count_records('user'));
 111          foreach ($record as $k => $v) {
 112              if ($k === 'password') {
 113                  $this->assertTrue(password_verify($v, $user->password));
 114              } else {
 115                  $this->assertSame($v, $user->{$k});
 116              }
 117          }
 118  
 119          $record = array(
 120              'firstname' => 'Some',
 121              'lastname' => 'User',
 122              'idnumber' => 'def',
 123              'username' => 'user666',
 124              'email' => 'email666@example.com',
 125              'deleted' => '1',
 126          );
 127          $user = $generator->create_user($record);
 128          $this->assertEquals($count + 3, $DB->count_records('user'));
 129          $this->assertSame('', $user->idnumber);
 130          $this->assertSame(md5($record['username']), $user->email);
 131          $this->assertFalse(context_user::instance($user->id, IGNORE_MISSING));
 132  
 133          // Test generating user with interests.
 134          $user = $generator->create_user(array('interests' => 'Cats, Dogs'));
 135          $userdetails = user_get_user_details($user);
 136          $this->assertSame('Cats, Dogs', $userdetails['interests']);
 137      }
 138  
 139      public function test_create() {
 140          global $DB;
 141  
 142          $this->resetAfterTest(true);
 143          $generator = $this->getDataGenerator();
 144  
 145          $count = $DB->count_records('course_categories');
 146          $category = $generator->create_category();
 147          $this->assertEquals($count+1, $DB->count_records('course_categories'));
 148          $this->assertRegExp('/^Course category \d/', $category->name);
 149          $this->assertSame('', $category->idnumber);
 150          $this->assertRegExp('/^Test course category \d/', $category->description);
 151          $this->assertSame(FORMAT_MOODLE, $category->descriptionformat);
 152  
 153          $count = $DB->count_records('cohort');
 154          $cohort = $generator->create_cohort();
 155          $this->assertEquals($count+1, $DB->count_records('cohort'));
 156          $this->assertEquals(context_system::instance()->id, $cohort->contextid);
 157          $this->assertRegExp('/^Cohort \d/', $cohort->name);
 158          $this->assertSame('', $cohort->idnumber);
 159          $this->assertRegExp('/^Test cohort \d/', $cohort->description);
 160          $this->assertSame(FORMAT_MOODLE, $cohort->descriptionformat);
 161          $this->assertSame('', $cohort->component);
 162          $this->assertLessThanOrEqual(time(), $cohort->timecreated);
 163          $this->assertSame($cohort->timecreated, $cohort->timemodified);
 164  
 165          $count = $DB->count_records('course');
 166          $course = $generator->create_course();
 167          $this->assertEquals($count+1, $DB->count_records('course'));
 168          $this->assertRegExp('/^Test course \d/', $course->fullname);
 169          $this->assertRegExp('/^tc_\d/', $course->shortname);
 170          $this->assertSame('', $course->idnumber);
 171          $this->assertSame('topics', $course->format);
 172          $this->assertEquals(0, $course->newsitems);
 173          $this->assertEquals(5, $course->numsections);
 174          $this->assertRegExp('/^Test course \d/', $course->summary);
 175          $this->assertSame(FORMAT_MOODLE, $course->summaryformat);
 176  
 177          $section = $generator->create_course_section(array('course'=>$course->id, 'section'=>3));
 178          $this->assertEquals($course->id, $section->course);
 179  
 180          $course = $generator->create_course(array('tags' => 'Cat, Dog'));
 181          $this->assertEquals(array('Cat', 'Dog'), array_values(core_tag_tag::get_item_tags_array('core', 'course', $course->id)));
 182  
 183          $scale = $generator->create_scale();
 184          $this->assertNotEmpty($scale);
 185      }
 186  
 187      public function test_create_module() {
 188          global $CFG, $SITE, $DB;
 189          if (!file_exists("$CFG->dirroot/mod/page/")) {
 190              $this->markTestSkipped('Can not find standard Page module');
 191          }
 192  
 193          $this->resetAfterTest(true);
 194          $generator = $this->getDataGenerator();
 195  
 196          $page = $generator->create_module('page', array('course'=>$SITE->id));
 197          $this->assertNotEmpty($page);
 198          $cm = get_coursemodule_from_instance('page', $page->id, $SITE->id, true);
 199          $this->assertEquals(0, $cm->sectionnum);
 200  
 201          $page = $generator->create_module('page', array('course'=>$SITE->id), array('section'=>3));
 202          $this->assertNotEmpty($page);
 203          $cm = get_coursemodule_from_instance('page', $page->id, $SITE->id, true);
 204          $this->assertEquals(3, $cm->sectionnum);
 205  
 206          $page = $generator->create_module('page', array('course' => $SITE->id, 'tags' => 'Cat, Dog'));
 207          $this->assertEquals(array('Cat', 'Dog'),
 208              array_values(core_tag_tag::get_item_tags_array('core', 'course_modules', $page->cmid)));
 209  
 210          // Prepare environment to generate modules with all possible options.
 211  
 212          // Enable advanced functionality.
 213          $CFG->enablecompletion = 1;
 214          $CFG->enableavailability = 1;
 215          $CFG->enableoutcomes = 1;
 216          require_once($CFG->libdir.'/gradelib.php');
 217          require_once($CFG->libdir.'/completionlib.php');
 218          require_once($CFG->dirroot.'/rating/lib.php');
 219  
 220          // Create a course with enabled completion.
 221          $course = $generator->create_course(array('enablecompletion' => true));
 222  
 223          // Create new grading category in this course.
 224          $grade_category = new grade_category();
 225          $grade_category->courseid = $course->id;
 226          $grade_category->fullname = 'Grade category';
 227          $grade_category->insert();
 228  
 229          // Create group and grouping.
 230          $group = $generator->create_group(array('courseid' => $course->id));
 231          $grouping = $generator->create_grouping(array('courseid' => $course->id));
 232          $generator->create_grouping_group(array('groupid' => $group->id, 'groupingid' => $grouping->id));
 233  
 234          // Prepare arrays with properties that we can both use for creating modules and asserting the data in created modules.
 235  
 236          // General properties.
 237          $optionsgeneral = array(
 238              'visible' => 0, // Note: 'visibleold' will always be set to the same value as 'visible'.
 239              'section' => 3, // Note: section will be created if does not exist.
 240              // Module supports FEATURE_IDNUMBER.
 241              'cmidnumber' => 'IDNUM', // Note: alternatively can have key 'idnumber'.
 242              // Module supports FEATURE_GROUPS;
 243              'groupmode' => SEPARATEGROUPS, // Note: will be reset to 0 if course groupmodeforce is set.
 244              // Module supports FEATURE_GROUPINGS.
 245              'groupingid' => $grouping->id,
 246          );
 247  
 248          // In case completion is enabled on site and for course every module can have manual completion.
 249          $featurecompletionmanual = array(
 250              'completion' => COMPLETION_TRACKING_MANUAL, // "Students can manually mark activity as completed."
 251              'completionexpected' => time() + 7 * DAYSECS,
 252          );
 253  
 254          // Automatic completion is possible if module supports FEATURE_COMPLETION_TRACKS_VIEWS or FEATURE_GRADE_HAS_GRADE.
 255          // Note: completionusegrade is stored in DB and can be found in cm_info as 'completiongradeitemnumber' - either NULL or 0.
 256          // Note: module can have more autocompletion rules as defined in moodleform_mod::add_completion_rules().
 257          $featurecompletionautomatic = array(
 258              'completion' => COMPLETION_TRACKING_AUTOMATIC, // "Show activity as complete when conditions are met."
 259              'completionview' => 1, // "Student must view this activity to complete it"
 260              'completionusegrade' => 1, // "Student must receive a grade to complete this activity"
 261          );
 262  
 263          // Module supports FEATURE_RATE:
 264          $featurerate = array(
 265              'assessed' => RATING_AGGREGATE_AVERAGE, // "Aggregate type"
 266              'scale' => 100, // Either max grade or negative number for scale id.
 267              'ratingtime' => 1, // "Restrict ratings to items with dates in this range".
 268              'assesstimestart' => time() - DAYSECS, // Note: Will be ignored if neither 'assessed' nor 'ratingtime' is set.
 269              'assesstimefinish' => time() + DAYSECS, // Note: Will be ignored if neither 'assessed' nor 'ratingtime' is set.
 270          );
 271  
 272          // Module supports FEATURE_GRADE_HAS_GRADE:
 273          $featuregrade = array(
 274              'grade' => 10,
 275              'gradecat' => $grade_category->id, // Note: if $CFG->enableoutcomes is set, this can be set to -1 to automatically create new grade category.
 276          );
 277  
 278          // Now let's create several modules with different options.
 279          $m1 = $generator->create_module('assign',
 280              array('course' => $course->id) +
 281              $optionsgeneral);
 282          $m2 = $generator->create_module('data',
 283              array('course' => $course->id) +
 284              $featurecompletionmanual +
 285              $featurerate);
 286          $m3 = $generator->create_module('assign',
 287              array('course' => $course->id) +
 288              $featurecompletionautomatic +
 289              $featuregrade);
 290  
 291          // We need id of the grading item for the second module to create availability dependency in the 3rd module.
 292          $gradingitem = grade_item::fetch(array('courseid'=>$course->id, 'itemtype'=>'mod', 'itemmodule' => 'assign', 'iteminstance' => $m3->id));
 293  
 294          // Now prepare option to create the 4th module with an availability condition.
 295          $optionsavailability = array(
 296              'availability' => '{"op":"&","showc":[true],"c":[' .
 297                  '{"type":"date","d":">=","t":' . (time() - WEEKSECS) . '}]}',
 298          );
 299  
 300          // Create module with conditional availability.
 301          $m4 = $generator->create_module('assign',
 302                  array('course' => $course->id) +
 303                  $optionsavailability
 304          );
 305  
 306          // Verifying that everything is generated correctly.
 307          $modinfo = get_fast_modinfo($course->id);
 308          $cm1 = $modinfo->cms[$m1->cmid];
 309          $this->assertEquals($optionsgeneral['visible'], $cm1->visible);
 310          $this->assertEquals($optionsgeneral['section'], $cm1->sectionnum); // Note difference in key.
 311          $this->assertEquals($optionsgeneral['cmidnumber'], $cm1->idnumber); // Note difference in key.
 312          $this->assertEquals($optionsgeneral['groupmode'], $cm1->groupmode);
 313          $this->assertEquals($optionsgeneral['groupingid'], $cm1->groupingid);
 314  
 315          $cm2 = $modinfo->cms[$m2->cmid];
 316          $this->assertEquals($featurecompletionmanual['completion'], $cm2->completion);
 317          $this->assertEquals($featurecompletionmanual['completionexpected'], $cm2->completionexpected);
 318          $this->assertEquals(null, $cm2->completiongradeitemnumber);
 319          // Rating info is stored in the module's table (in our test {data}).
 320          $data = $DB->get_record('data', array('id' => $m2->id));
 321          $this->assertEquals($featurerate['assessed'], $data->assessed);
 322          $this->assertEquals($featurerate['scale'], $data->scale);
 323          $this->assertEquals($featurerate['assesstimestart'], $data->assesstimestart);
 324          $this->assertEquals($featurerate['assesstimefinish'], $data->assesstimefinish);
 325          // No validation for 'ratingtime'. It is only used in to enable/disable assesstime* when adding module.
 326  
 327          $cm3 = $modinfo->cms[$m3->cmid];
 328          $this->assertEquals($featurecompletionautomatic['completion'], $cm3->completion);
 329          $this->assertEquals($featurecompletionautomatic['completionview'], $cm3->completionview);
 330          $this->assertEquals(0, $cm3->completiongradeitemnumber); // Zero instead of default null since 'completionusegrade' was set.
 331          $gradingitem = grade_item::fetch(array('courseid'=>$course->id, 'itemtype'=>'mod', 'itemmodule' => 'assign', 'iteminstance' => $m3->id));
 332          $this->assertEquals(0, $gradingitem->grademin);
 333          $this->assertEquals($featuregrade['grade'], $gradingitem->grademax);
 334          $this->assertEquals($featuregrade['gradecat'], $gradingitem->categoryid);
 335  
 336          $cm4 = $modinfo->cms[$m4->cmid];
 337          $this->assertEquals($optionsavailability['availability'], $cm4->availability);
 338      }
 339  
 340      public function test_create_block() {
 341          global $CFG;
 342          if (!file_exists("$CFG->dirroot/blocks/online_users/")) {
 343              $this->markTestSkipped('Can not find standard Online users block');
 344          }
 345  
 346          $this->resetAfterTest(true);
 347          $generator = $this->getDataGenerator();
 348  
 349          $page = $generator->create_block('online_users');
 350          $this->assertNotEmpty($page);
 351      }
 352  
 353      public function test_enrol_user() {
 354          global $DB;
 355  
 356          $this->resetAfterTest();
 357  
 358          $selfplugin = enrol_get_plugin('self');
 359          $this->assertNotEmpty($selfplugin);
 360  
 361          $manualplugin = enrol_get_plugin('manual');
 362          $this->assertNotEmpty($manualplugin);
 363  
 364          // Prepare some data.
 365  
 366          $studentrole = $DB->get_record('role', array('shortname'=>'student'));
 367          $this->assertNotEmpty($studentrole);
 368          $teacherrole = $DB->get_record('role', array('shortname'=>'teacher'));
 369          $this->assertNotEmpty($teacherrole);
 370  
 371          $course1 = $this->getDataGenerator()->create_course();
 372          $course2 = $this->getDataGenerator()->create_course();
 373          $course3 = $this->getDataGenerator()->create_course();
 374  
 375          $context1 = context_course::instance($course1->id);
 376          $context2 = context_course::instance($course2->id);
 377          $context3 = context_course::instance($course3->id);
 378  
 379          $user1 = $this->getDataGenerator()->create_user();
 380          $user2 = $this->getDataGenerator()->create_user();
 381          $user3 = $this->getDataGenerator()->create_user();
 382          $user4 = $this->getDataGenerator()->create_user();
 383  
 384          $this->assertEquals(3, $DB->count_records('enrol', array('enrol'=>'self')));
 385          $instance1 = $DB->get_record('enrol', array('courseid'=>$course1->id, 'enrol'=>'self'), '*', MUST_EXIST);
 386          $instance2 = $DB->get_record('enrol', array('courseid'=>$course2->id, 'enrol'=>'self'), '*', MUST_EXIST);
 387          $instance3 = $DB->get_record('enrol', array('courseid'=>$course3->id, 'enrol'=>'self'), '*', MUST_EXIST);
 388  
 389          $this->assertEquals($studentrole->id, $instance1->roleid);
 390          $this->assertEquals($studentrole->id, $instance2->roleid);
 391          $this->assertEquals($studentrole->id, $instance3->roleid);
 392  
 393          $this->assertEquals(3, $DB->count_records('enrol', array('enrol'=>'manual')));
 394          $maninstance1 = $DB->get_record('enrol', array('courseid'=>$course1->id, 'enrol'=>'manual'), '*', MUST_EXIST);
 395          $maninstance2 = $DB->get_record('enrol', array('courseid'=>$course2->id, 'enrol'=>'manual'), '*', MUST_EXIST);
 396          $maninstance3 = $DB->get_record('enrol', array('courseid'=>$course3->id, 'enrol'=>'manual'), '*', MUST_EXIST);
 397          $maninstance3->roleid = $teacherrole->id;
 398          $DB->update_record('enrol', $maninstance3, array('id'=>$maninstance3->id));
 399  
 400          $this->assertEquals($studentrole->id, $maninstance1->roleid);
 401          $this->assertEquals($studentrole->id, $maninstance2->roleid);
 402          $this->assertEquals($teacherrole->id, $maninstance3->roleid);
 403  
 404          $result = $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
 405          $this->assertTrue($result);
 406          $this->assertTrue($DB->record_exists('user_enrolments', array('enrolid'=>$maninstance1->id, 'userid'=>$user1->id)));
 407          $this->assertTrue($DB->record_exists('role_assignments', array('contextid'=>$context1->id, 'userid'=>$user1->id, 'roleid'=>$studentrole->id)));
 408  
 409          $result = $this->getDataGenerator()->enrol_user($user1->id, $course2->id, $teacherrole->id, 'manual');
 410          $this->assertTrue($result);
 411          $this->assertTrue($DB->record_exists('user_enrolments', array('enrolid'=>$maninstance2->id, 'userid'=>$user1->id)));
 412          $this->assertTrue($DB->record_exists('role_assignments', array('contextid'=>$context2->id, 'userid'=>$user1->id, 'roleid'=>$teacherrole->id)));
 413  
 414          $result = $this->getDataGenerator()->enrol_user($user4->id, $course2->id, 'teacher', 'manual');
 415          $this->assertTrue($result);
 416          $this->assertTrue($DB->record_exists('user_enrolments',
 417                  array('enrolid' => $maninstance2->id, 'userid' => $user4->id)));
 418          $this->assertTrue($DB->record_exists('role_assignments',
 419                  array('contextid' => $context2->id, 'userid' => $user4->id, 'roleid' => $teacherrole->id)));
 420  
 421          $result = $this->getDataGenerator()->enrol_user($user1->id, $course3->id, 0, 'manual');
 422          $this->assertTrue($result);
 423          $this->assertTrue($DB->record_exists('user_enrolments', array('enrolid'=>$maninstance3->id, 'userid'=>$user1->id)));
 424          $this->assertFalse($DB->record_exists('role_assignments', array('contextid'=>$context3->id, 'userid'=>$user1->id)));
 425  
 426          $result = $this->getDataGenerator()->enrol_user($user2->id, $course1->id, null, 'self');
 427          $this->assertTrue($result);
 428          $this->assertTrue($DB->record_exists('user_enrolments', array('enrolid'=>$instance1->id, 'userid'=>$user2->id)));
 429          $this->assertTrue($DB->record_exists('role_assignments', array('contextid'=>$context1->id, 'userid'=>$user2->id, 'roleid'=>$studentrole->id)));
 430  
 431          $selfplugin->add_instance($course2, array('status'=>ENROL_INSTANCE_ENABLED, 'roleid'=>$teacherrole->id));
 432          $result = $this->getDataGenerator()->enrol_user($user2->id, $course2->id, null, 'self');
 433          $this->assertFalse($result);
 434  
 435          $DB->delete_records('enrol', array('enrol'=>'self', 'courseid'=>$course3->id));
 436          $result = $this->getDataGenerator()->enrol_user($user2->id, $course3->id, null, 'self');
 437          $this->assertFalse($result);
 438      }
 439  
 440      public function test_create_grade_category() {
 441          global $DB, $CFG;
 442          require_once $CFG->libdir . '/grade/constants.php';
 443  
 444          $this->resetAfterTest(true);
 445          $generator = $this->getDataGenerator();
 446          $course = $generator->create_course();
 447  
 448          // Generate category and make sure number of records in DB table increases.
 449          // Note we only count grade cats with depth > 1 because the course grade category
 450          // is lazily created.
 451          $count = $DB->count_records_select('grade_categories', 'depth <> 1');
 452          $gradecategory = $generator->create_grade_category(array('courseid'=>$course->id));
 453          $this->assertEquals($count+1, $DB->count_records_select('grade_categories', 'depth <> 1'));
 454          $this->assertEquals(2, $gradecategory->depth);
 455          $this->assertEquals($course->id, $gradecategory->courseid);
 456          $this->assertEquals('Grade category 1', $gradecategory->fullname);
 457  
 458          // Generate category and make sure aggregation is set.
 459          $gradecategory = $generator->create_grade_category(
 460                  array('courseid' => $course->id, 'aggregation' => GRADE_AGGREGATE_MEDIAN));
 461          $this->assertEquals(GRADE_AGGREGATE_MEDIAN, $gradecategory->aggregation);
 462  
 463          // Generate category and make sure parent is set.
 464          $gradecategory2 = $generator->create_grade_category(
 465                  array('courseid' => $course->id,
 466                      'parent' => $gradecategory->id));
 467          $this->assertEquals($gradecategory->id, $gradecategory2->parent);
 468      }
 469  }