[Summary view]

Differences Between: [Versions 310 and 402] [Versions 311 and 402] [Versions 39 and 402] [Versions 400 and 402] [Versions 401 and 402] [Versions 402 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 (some of) mod/quiz/locallib.php.
  19   *
  20   * @package    mod_quiz
  21   * @category   test
  22   * @copyright  2008 Tim Hunt
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  namespace mod_quiz;
  26  
  27  use mod_quiz\output\renderer;
  28  use mod_quiz\question\display_options;
  29  
  30  defined('MOODLE_INTERNAL') || die();
  31  
  32  global $CFG;
  33  require_once($CFG->dirroot . '/mod/quiz/locallib.php');
  34  
  35  
  36  /**
  37   * Unit tests for (some of) mod/quiz/locallib.php.
  38   *
  39   * @copyright  2008 Tim Hunt
  40   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  41   */
  42  class locallib_test extends \advanced_testcase {
  43  
  44      public function test_quiz_rescale_grade() {
  45          $quiz = new \stdClass();
  46          $quiz->decimalpoints = 2;
  47          $quiz->questiondecimalpoints = 3;
  48          $quiz->grade = 10;
  49          $quiz->sumgrades = 10;
  50          $this->assertEquals(quiz_rescale_grade(0.12345678, $quiz, false), 0.12345678);
  51          $this->assertEquals(quiz_rescale_grade(0.12345678, $quiz, true), format_float(0.12, 2));
  52          $this->assertEquals(quiz_rescale_grade(0.12345678, $quiz, 'question'),
  53              format_float(0.123, 3));
  54          $quiz->sumgrades = 5;
  55          $this->assertEquals(quiz_rescale_grade(0.12345678, $quiz, false), 0.24691356);
  56          $this->assertEquals(quiz_rescale_grade(0.12345678, $quiz, true), format_float(0.25, 2));
  57          $this->assertEquals(quiz_rescale_grade(0.12345678, $quiz, 'question'),
  58              format_float(0.247, 3));
  59      }
  60  
  61      public function quiz_attempt_state_data_provider() {
  62          return [
  63              [quiz_attempt::IN_PROGRESS, null, null, display_options::DURING],
  64              [quiz_attempt::FINISHED, -90, null, display_options::IMMEDIATELY_AFTER],
  65              [quiz_attempt::FINISHED, -7200, null, display_options::LATER_WHILE_OPEN],
  66              [quiz_attempt::FINISHED, -7200, 3600, display_options::LATER_WHILE_OPEN],
  67              [quiz_attempt::FINISHED, -30, 30, display_options::IMMEDIATELY_AFTER],
  68              [quiz_attempt::FINISHED, -90, -30, display_options::AFTER_CLOSE],
  69              [quiz_attempt::FINISHED, -7200, -3600, display_options::AFTER_CLOSE],
  70              [quiz_attempt::FINISHED, -90, -3600, display_options::AFTER_CLOSE],
  71              [quiz_attempt::ABANDONED, -10000000, null, display_options::LATER_WHILE_OPEN],
  72              [quiz_attempt::ABANDONED, -7200, 3600, display_options::LATER_WHILE_OPEN],
  73              [quiz_attempt::ABANDONED, -7200, -3600, display_options::AFTER_CLOSE],
  74          ];
  75      }
  76  
  77      /**
  78       * @dataProvider quiz_attempt_state_data_provider
  79       *
  80       * @param string $attemptstate as in the quiz_attempts.state DB column.
  81       * @param int|null $relativetimefinish time relative to now when the attempt finished, or null for 0.
  82       * @param int|null $relativetimeclose time relative to now when the quiz closes, or null for 0.
  83       * @param int $expectedstate expected result. One of the display_options constants.
  84       * @covers ::quiz_attempt_state
  85       */
  86      public function test_quiz_attempt_state(string $attemptstate,
  87              ?int $relativetimefinish, ?int $relativetimeclose, int $expectedstate) {
  88  
  89          $attempt = new \stdClass();
  90          $attempt->state = $attemptstate;
  91          if ($relativetimefinish === null) {
  92              $attempt->timefinish = 0;
  93          } else {
  94              $attempt->timefinish = time() + $relativetimefinish;
  95          }
  96  
  97          $quiz = new \stdClass();
  98          if ($relativetimeclose === null) {
  99              $quiz->timeclose = 0;
 100          } else {
 101              $quiz->timeclose = time() + $relativetimeclose;
 102          }
 103  
 104          $this->assertEquals($expectedstate, quiz_attempt_state($quiz, $attempt));
 105      }
 106  
 107      /**
 108       * @covers ::quiz_question_tostring
 109       */
 110      public function test_quiz_question_tostring() {
 111          $question = new \stdClass();
 112          $question->qtype = 'multichoice';
 113          $question->name = 'The question name';
 114          $question->questiontext = '<p>What sort of <b>inequality</b> is x &lt; y<img alt="?" src="..."></p>';
 115          $question->questiontextformat = FORMAT_HTML;
 116  
 117          $summary = quiz_question_tostring($question);
 118          $this->assertEquals('<span class="questionname">The question name</span> ' .
 119                  '<span class="questiontext">What sort of INEQUALITY is x &lt; y[?]' . "\n" . '</span>', $summary);
 120      }
 121  
 122      /**
 123       * @covers ::quiz_question_tostring
 124       */
 125      public function test_quiz_question_tostring_does_not_filter() {
 126          $question = new \stdClass();
 127          $question->qtype = 'multichoice';
 128          $question->name = 'The question name';
 129          $question->questiontext = '<p>No emoticons here :-)</p>';
 130          $question->questiontextformat = FORMAT_HTML;
 131  
 132          $summary = quiz_question_tostring($question);
 133          $this->assertEquals('<span class="questionname">The question name</span> ' .
 134                  '<span class="questiontext">No emoticons here :-)' . "\n</span>", $summary);
 135      }
 136  
 137      /**
 138       * Test quiz_view
 139       * @return void
 140       */
 141      public function test_quiz_view() {
 142          global $CFG;
 143  
 144          $CFG->enablecompletion = 1;
 145          $this->resetAfterTest();
 146  
 147          $this->setAdminUser();
 148          // Setup test data.
 149          $course = $this->getDataGenerator()->create_course(['enablecompletion' => 1]);
 150          $quiz = $this->getDataGenerator()->create_module('quiz', ['course' => $course->id],
 151                                                              ['completion' => 2, 'completionview' => 1]);
 152          $context = \context_module::instance($quiz->cmid);
 153          $cm = get_coursemodule_from_instance('quiz', $quiz->id);
 154  
 155          // Trigger and capture the event.
 156          $sink = $this->redirectEvents();
 157  
 158          quiz_view($quiz, $course, $cm, $context);
 159  
 160          $events = $sink->get_events();
 161          // 2 additional events thanks to completion.
 162          $this->assertCount(3, $events);
 163          $event = array_shift($events);
 164  
 165          // Checking that the event contains the expected values.
 166          $this->assertInstanceOf('\mod_quiz\event\course_module_viewed', $event);
 167          $this->assertEquals($context, $event->get_context());
 168          $moodleurl = new \moodle_url('/mod/quiz/view.php', ['id' => $cm->id]);
 169          $this->assertEquals($moodleurl, $event->get_url());
 170          $this->assertEventContextNotUsed($event);
 171          $this->assertNotEmpty($event->get_name());
 172          // Check completion status.
 173          $completion = new \completion_info($course);
 174          $completiondata = $completion->get_data($cm);
 175          $this->assertEquals(1, $completiondata->completionstate);
 176      }
 177  
 178      /**
 179       * Return false when there are not overrides for this quiz instance.
 180       */
 181      public function test_quiz_is_overriden_calendar_event_no_override() {
 182          global $CFG, $DB;
 183  
 184          $this->resetAfterTest();
 185          $this->setAdminUser();
 186  
 187          $generator = $this->getDataGenerator();
 188          $user = $generator->create_user();
 189          $course = $generator->create_course();
 190          $quizgenerator = $generator->get_plugin_generator('mod_quiz');
 191          $quiz = $quizgenerator->create_instance(['course' => $course->id]);
 192  
 193          $event = new \calendar_event((object)[
 194              'modulename' => 'quiz',
 195              'instance' => $quiz->id,
 196              'userid' => $user->id
 197          ]);
 198  
 199          $this->assertFalse(quiz_is_overriden_calendar_event($event));
 200      }
 201  
 202      /**
 203       * Return false if the given event isn't an quiz module event.
 204       */
 205      public function test_quiz_is_overriden_calendar_event_no_module_event() {
 206          global $CFG, $DB;
 207  
 208          $this->resetAfterTest();
 209          $this->setAdminUser();
 210  
 211          $generator = $this->getDataGenerator();
 212          $user = $generator->create_user();
 213          $course = $generator->create_course();
 214          $quizgenerator = $generator->get_plugin_generator('mod_quiz');
 215          $quiz = $quizgenerator->create_instance(['course' => $course->id]);
 216  
 217          $event = new \calendar_event((object)[
 218              'userid' => $user->id
 219          ]);
 220  
 221          $this->assertFalse(quiz_is_overriden_calendar_event($event));
 222      }
 223  
 224      /**
 225       * Return false if there is overrides for this use but they belong to another quiz
 226       * instance.
 227       */
 228      public function test_quiz_is_overriden_calendar_event_different_quiz_instance() {
 229          global $CFG, $DB;
 230  
 231          $this->resetAfterTest();
 232          $this->setAdminUser();
 233  
 234          $generator = $this->getDataGenerator();
 235          $user = $generator->create_user();
 236          $course = $generator->create_course();
 237          $quizgenerator = $generator->get_plugin_generator('mod_quiz');
 238          $quiz = $quizgenerator->create_instance(['course' => $course->id]);
 239          $quiz2 = $quizgenerator->create_instance(['course' => $course->id]);
 240  
 241          $event = new \calendar_event((object) [
 242              'modulename' => 'quiz',
 243              'instance' => $quiz->id,
 244              'userid' => $user->id
 245          ]);
 246  
 247          $record = (object) [
 248              'quiz' => $quiz2->id,
 249              'userid' => $user->id
 250          ];
 251  
 252          $DB->insert_record('quiz_overrides', $record);
 253  
 254          $this->assertFalse(quiz_is_overriden_calendar_event($event));
 255      }
 256  
 257      /**
 258       * Return true if there is a user override for this event and quiz instance.
 259       */
 260      public function test_quiz_is_overriden_calendar_event_user_override() {
 261          global $CFG, $DB;
 262  
 263          $this->resetAfterTest();
 264          $this->setAdminUser();
 265  
 266          $generator = $this->getDataGenerator();
 267          $user = $generator->create_user();
 268          $course = $generator->create_course();
 269          $quizgenerator = $generator->get_plugin_generator('mod_quiz');
 270          $quiz = $quizgenerator->create_instance(['course' => $course->id]);
 271  
 272          $event = new \calendar_event((object) [
 273              'modulename' => 'quiz',
 274              'instance' => $quiz->id,
 275              'userid' => $user->id
 276          ]);
 277  
 278          $record = (object) [
 279              'quiz' => $quiz->id,
 280              'userid' => $user->id
 281          ];
 282  
 283          $DB->insert_record('quiz_overrides', $record);
 284  
 285          $this->assertTrue(quiz_is_overriden_calendar_event($event));
 286      }
 287  
 288      /**
 289       * Return true if there is a group override for the event and quiz instance.
 290       */
 291      public function test_quiz_is_overriden_calendar_event_group_override() {
 292          global $CFG, $DB;
 293  
 294          $this->resetAfterTest();
 295          $this->setAdminUser();
 296  
 297          $generator = $this->getDataGenerator();
 298          $user = $generator->create_user();
 299          $course = $generator->create_course();
 300          $quizgenerator = $generator->get_plugin_generator('mod_quiz');
 301          $quiz = $quizgenerator->create_instance(['course' => $course->id]);
 302          $group = $this->getDataGenerator()->create_group(['courseid' => $quiz->course]);
 303          $groupid = $group->id;
 304          $userid = $user->id;
 305  
 306          $event = new \calendar_event((object) [
 307              'modulename' => 'quiz',
 308              'instance' => $quiz->id,
 309              'groupid' => $groupid
 310          ]);
 311  
 312          $record = (object) [
 313              'quiz' => $quiz->id,
 314              'groupid' => $groupid
 315          ];
 316  
 317          $DB->insert_record('quiz_overrides', $record);
 318  
 319          $this->assertTrue(quiz_is_overriden_calendar_event($event));
 320      }
 321  
 322      /**
 323       * Test test_quiz_get_user_timeclose().
 324       */
 325      public function test_quiz_get_user_timeclose() {
 326          global $DB;
 327  
 328          $this->resetAfterTest();
 329          $this->setAdminUser();
 330  
 331          $basetimestamp = time(); // The timestamp we will base the enddates on.
 332  
 333          // Create generator, course and quizzes.
 334          $student1 = $this->getDataGenerator()->create_user();
 335          $student2 = $this->getDataGenerator()->create_user();
 336          $student3 = $this->getDataGenerator()->create_user();
 337          $teacher = $this->getDataGenerator()->create_user();
 338          $course = $this->getDataGenerator()->create_course();
 339          $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');
 340  
 341          // Both quizzes close in two hours.
 342          $quiz1 = $quizgenerator->create_instance(['course' => $course->id, 'timeclose' => $basetimestamp + 7200]);
 343          $quiz2 = $quizgenerator->create_instance(['course' => $course->id, 'timeclose' => $basetimestamp + 7200]);
 344          $group1 = $this->getDataGenerator()->create_group(['courseid' => $course->id]);
 345          $group2 = $this->getDataGenerator()->create_group(['courseid' => $course->id]);
 346  
 347          $student1id = $student1->id;
 348          $student2id = $student2->id;
 349          $student3id = $student3->id;
 350          $teacherid = $teacher->id;
 351  
 352          // Users enrolments.
 353          $studentrole = $DB->get_record('role', ['shortname' => 'student']);
 354          $teacherrole = $DB->get_record('role', ['shortname' => 'editingteacher']);
 355          $this->getDataGenerator()->enrol_user($student1id, $course->id, $studentrole->id, 'manual');
 356          $this->getDataGenerator()->enrol_user($student2id, $course->id, $studentrole->id, 'manual');
 357          $this->getDataGenerator()->enrol_user($student3id, $course->id, $studentrole->id, 'manual');
 358          $this->getDataGenerator()->enrol_user($teacherid, $course->id, $teacherrole->id, 'manual');
 359  
 360          // Create groups.
 361          $group1 = $this->getDataGenerator()->create_group(['courseid' => $course->id]);
 362          $group2 = $this->getDataGenerator()->create_group(['courseid' => $course->id]);
 363          $group1id = $group1->id;
 364          $group2id = $group2->id;
 365          $this->getDataGenerator()->create_group_member(['userid' => $student1id, 'groupid' => $group1id]);
 366          $this->getDataGenerator()->create_group_member(['userid' => $student2id, 'groupid' => $group2id]);
 367  
 368          // Group 1 gets an group override for quiz 1 to close in three hours.
 369          $record1 = (object) [
 370              'quiz' => $quiz1->id,
 371              'groupid' => $group1id,
 372              'timeclose' => $basetimestamp + 10800 // In three hours.
 373          ];
 374          $DB->insert_record('quiz_overrides', $record1);
 375  
 376          // Let's test quiz 1 closes in three hours for user student 1 since member of group 1.
 377          // Quiz 2 closes in two hours.
 378          $this->setUser($student1id);
 379          $params = new \stdClass();
 380  
 381          $comparearray = [];
 382          $object = new \stdClass();
 383          $object->id = $quiz1->id;
 384          $object->usertimeclose = $basetimestamp + 10800; // The overriden timeclose for quiz 1.
 385  
 386          $comparearray[$quiz1->id] = $object;
 387  
 388          $object = new \stdClass();
 389          $object->id = $quiz2->id;
 390          $object->usertimeclose = $basetimestamp + 7200; // The unchanged timeclose for quiz 2.
 391  
 392          $comparearray[$quiz2->id] = $object;
 393  
 394          $this->assertEquals($comparearray, quiz_get_user_timeclose($course->id));
 395  
 396          // Let's test quiz 1 closes in two hours (the original value) for user student 3 since member of no group.
 397          $this->setUser($student3id);
 398          $params = new \stdClass();
 399  
 400          $comparearray = [];
 401          $object = new \stdClass();
 402          $object->id = $quiz1->id;
 403          $object->usertimeclose = $basetimestamp + 7200; // The original timeclose for quiz 1.
 404  
 405          $comparearray[$quiz1->id] = $object;
 406  
 407          $object = new \stdClass();
 408          $object->id = $quiz2->id;
 409          $object->usertimeclose = $basetimestamp + 7200; // The original timeclose for quiz 2.
 410  
 411          $comparearray[$quiz2->id] = $object;
 412  
 413          $this->assertEquals($comparearray, quiz_get_user_timeclose($course->id));
 414  
 415          // User 2 gets an user override for quiz 1 to close in four hours.
 416          $record2 = (object) [
 417              'quiz' => $quiz1->id,
 418              'userid' => $student2id,
 419              'timeclose' => $basetimestamp + 14400 // In four hours.
 420          ];
 421          $DB->insert_record('quiz_overrides', $record2);
 422  
 423          // Let's test quiz 1 closes in four hours for user student 2 since personally overriden.
 424          // Quiz 2 closes in two hours.
 425          $this->setUser($student2id);
 426  
 427          $comparearray = [];
 428          $object = new \stdClass();
 429          $object->id = $quiz1->id;
 430          $object->usertimeclose = $basetimestamp + 14400; // The overriden timeclose for quiz 1.
 431  
 432          $comparearray[$quiz1->id] = $object;
 433  
 434          $object = new \stdClass();
 435          $object->id = $quiz2->id;
 436          $object->usertimeclose = $basetimestamp + 7200; // The unchanged timeclose for quiz 2.
 437  
 438          $comparearray[$quiz2->id] = $object;
 439  
 440          $this->assertEquals($comparearray, quiz_get_user_timeclose($course->id));
 441  
 442          // Let's test a teacher sees the original times.
 443          // Quiz 1 and quiz 2 close in two hours.
 444          $this->setUser($teacherid);
 445  
 446          $comparearray = [];
 447          $object = new \stdClass();
 448          $object->id = $quiz1->id;
 449          $object->usertimeclose = $basetimestamp + 7200; // The unchanged timeclose for quiz 1.
 450  
 451          $comparearray[$quiz1->id] = $object;
 452  
 453          $object = new \stdClass();
 454          $object->id = $quiz2->id;
 455          $object->usertimeclose = $basetimestamp + 7200; // The unchanged timeclose for quiz 2.
 456  
 457          $comparearray[$quiz2->id] = $object;
 458  
 459          $this->assertEquals($comparearray, quiz_get_user_timeclose($course->id));
 460      }
 461  
 462      /**
 463       * This function creates a quiz with some standard (non-random) and some random questions.
 464       * The standard questions are created first and then random questions follow them.
 465       * So in a quiz with 3 standard question and 2 random question, the first random question is at slot 4.
 466       *
 467       * @param int $qnum Number of standard questions that should be created in the quiz.
 468       * @param int $randomqnum Number of random questions that should be created in the quiz.
 469       * @param array $questiontags Tags to be used for random questions.
 470       *      This is an array in the following format:
 471       *      [
 472       *          0 => ['foo', 'bar'],
 473       *          1 => ['baz', 'qux']
 474       *      ]
 475       * @param string[] $unusedtags Some additional tags to be created.
 476       * @return array An array of 2 elements: $quiz and $tagobjects.
 477       *      $tagobjects is an associative array of all created tag objects with its key being tag names.
 478       */
 479      private function setup_quiz_and_tags($qnum, $randomqnum, $questiontags = [], $unusedtags = []) {
 480          global $SITE;
 481  
 482          $tagobjects = [];
 483  
 484          // Get all the tags that need to be created.
 485          $alltags = [];
 486          foreach ($questiontags as $questiontag) {
 487              $alltags = array_merge($alltags, $questiontag);
 488          }
 489          $alltags = array_merge($alltags, $unusedtags);
 490          $alltags = array_unique($alltags);
 491  
 492          // Create tags.
 493          foreach ($alltags as $tagname) {
 494              $tagrecord = [
 495                  'isstandard' => 1,
 496                  'flag' => 0,
 497                  'rawname' => $tagname,
 498                  'description' => $tagname . ' desc'
 499              ];
 500              $tagobjects[$tagname] = $this->getDataGenerator()->create_tag($tagrecord);
 501          }
 502  
 503          // Create a quiz.
 504          $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');
 505          $quiz = $quizgenerator->create_instance(['course' => $SITE->id, 'questionsperpage' => 3, 'grade' => 100.0]);
 506  
 507          // Create a question category in the system context.
 508          $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');
 509          $cat = $questiongenerator->create_question_category();
 510  
 511          // Setup standard questions.
 512          for ($i = 0; $i < $qnum; $i++) {
 513              $question = $questiongenerator->create_question('shortanswer', null, ['category' => $cat->id]);
 514              quiz_add_quiz_question($question->id, $quiz);
 515          }
 516          // Setup random questions.
 517          for ($i = 0; $i < $randomqnum; $i++) {
 518              // Just create a standard question first, so there would be enough questions to pick a random question from.
 519              $question = $questiongenerator->create_question('shortanswer', null, ['category' => $cat->id]);
 520              $tagids = [];
 521              if (!empty($questiontags[$i])) {
 522                  foreach ($questiontags[$i] as $tagname) {
 523                      $tagids[] = $tagobjects[$tagname]->id;
 524                  }
 525              }
 526              quiz_add_random_questions($quiz, 0, $cat->id, 1, false, $tagids);
 527          }
 528  
 529          return [$quiz, $tagobjects];
 530      }
 531  
 532      public function test_quiz_override_summary() {
 533          global $DB, $PAGE;
 534          $this->resetAfterTest();
 535          $generator = $this->getDataGenerator();
 536          /** @var mod_quiz_generator $quizgenerator */
 537          $quizgenerator = $generator->get_plugin_generator('mod_quiz');
 538          /** @var renderer $renderer */
 539          $renderer = $PAGE->get_renderer('mod_quiz');
 540  
 541          // Course with quiz and a group - plus some others, to verify they don't get counted.
 542          $course = $generator->create_course();
 543          $quiz = $quizgenerator->create_instance(['course' => $course->id, 'groupmode' => SEPARATEGROUPS]);
 544          $cm = get_coursemodule_from_id('quiz', $quiz->cmid, $course->id);
 545          $group = $generator->create_group(['courseid' => $course->id]);
 546          $othergroup = $generator->create_group(['courseid' => $course->id]);
 547          $otherquiz = $quizgenerator->create_instance(['course' => $course->id]);
 548  
 549          // Initial test (as admin) with no data.
 550          $this->setAdminUser();
 551          $this->assertEquals(['group' => 0, 'user' => 0, 'mode' => 'allgroups'],
 552                  quiz_override_summary($quiz, $cm));
 553          $this->assertEquals(['group' => 0, 'user' => 0, 'mode' => 'onegroup'],
 554                  quiz_override_summary($quiz, $cm, $group->id));
 555  
 556          // Editing teacher.
 557          $teacher = $generator->create_user();
 558          $generator->enrol_user($teacher->id, $course->id, 'editingteacher');
 559  
 560          // Non-editing teacher.
 561          $tutor = $generator->create_user();
 562          $generator->enrol_user($tutor->id, $course->id, 'teacher');
 563          $generator->create_group_member(['userid' => $tutor->id, 'groupid' => $group->id]);
 564  
 565          // Three students.
 566          $student1 = $generator->create_user();
 567          $generator->enrol_user($student1->id, $course->id, 'student');
 568          $generator->create_group_member(['userid' => $student1->id, 'groupid' => $group->id]);
 569  
 570          $student2 = $generator->create_user();
 571          $generator->enrol_user($student2->id, $course->id, 'student');
 572          $generator->create_group_member(['userid' => $student2->id, 'groupid' => $othergroup->id]);
 573  
 574          $student3 = $generator->create_user();
 575          $generator->enrol_user($student3->id, $course->id, 'student');
 576  
 577          // Initial test now users exist, but before overrides.
 578          // Test as teacher.
 579          $this->setUser($teacher);
 580          $this->assertEquals(['group' => 0, 'user' => 0, 'mode' => 'allgroups'],
 581                  quiz_override_summary($quiz, $cm));
 582          $this->assertEquals(['group' => 0, 'user' => 0, 'mode' => 'onegroup'],
 583                  quiz_override_summary($quiz, $cm, $group->id));
 584  
 585          // Test as tutor.
 586          $this->setUser($tutor);
 587          $this->assertEquals(['group' => 0, 'user' => 0, 'mode' => 'somegroups'],
 588                  quiz_override_summary($quiz, $cm));
 589          $this->assertEquals(['group' => 0, 'user' => 0, 'mode' => 'onegroup'],
 590                  quiz_override_summary($quiz, $cm, $group->id));
 591          $this->assertEquals('', $renderer->quiz_override_summary_links($quiz, $cm));
 592  
 593          // Quiz setting overrides for students 1 and 3.
 594          $quizgenerator->create_override(['quiz' => $quiz->id, 'userid' => $student1->id, 'attempts' => 2]);
 595          $quizgenerator->create_override(['quiz' => $quiz->id, 'userid' => $student3->id, 'attempts' => 2]);
 596          $quizgenerator->create_override(['quiz' => $quiz->id, 'groupid' => $group->id, 'attempts' => 3]);
 597          $quizgenerator->create_override(['quiz' => $quiz->id, 'groupid' => $othergroup->id, 'attempts' => 3]);
 598          $quizgenerator->create_override(['quiz' => $otherquiz->id, 'userid' => $student2->id, 'attempts' => 2]);
 599  
 600          // Test as teacher.
 601          $this->setUser($teacher);
 602          $this->assertEquals(['group' => 2, 'user' => 2, 'mode' => 'allgroups'],
 603                  quiz_override_summary($quiz, $cm));
 604          $this->assertEquals('Settings overrides exist (Groups: 2, Users: 2)',
 605                  // Links checked by Behat, so strip them for these tests.
 606                  html_to_text($renderer->quiz_override_summary_links($quiz, $cm), 0, false));
 607          $this->assertEquals(['group' => 1, 'user' => 1, 'mode' => 'onegroup'],
 608                  quiz_override_summary($quiz, $cm, $group->id));
 609          $this->assertEquals('Settings overrides exist (Groups: 1, Users: 1) for this group',
 610                  html_to_text($renderer->quiz_override_summary_links($quiz, $cm, $group->id), 0, false));
 611  
 612          // Test as tutor.
 613          $this->setUser($tutor);
 614          $this->assertEquals(['group' => 1, 'user' => 1, 'mode' => 'somegroups'],
 615                  quiz_override_summary($quiz, $cm));
 616          $this->assertEquals('Settings overrides exist (Groups: 1, Users: 1) for your groups',
 617                  html_to_text($renderer->quiz_override_summary_links($quiz, $cm), 0, false));
 618          $this->assertEquals(['group' => 1, 'user' => 1, 'mode' => 'onegroup'],
 619                  quiz_override_summary($quiz, $cm, $group->id));
 620          $this->assertEquals('Settings overrides exist (Groups: 1, Users: 1) for this group',
 621                  html_to_text($renderer->quiz_override_summary_links($quiz, $cm, $group->id), 0, false));
 622  
 623          // Now set the quiz to be group mode: no groups, and re-test as tutor.
 624          // In this case, the tutor should see all groups.
 625          $DB->set_field('course_modules', 'groupmode', NOGROUPS, ['id' => $cm->id]);
 626          $cm = get_coursemodule_from_id('quiz', $quiz->cmid, $course->id);
 627  
 628          $this->assertEquals(['group' => 2, 'user' => 2, 'mode' => 'allgroups'],
 629                  quiz_override_summary($quiz, $cm));
 630          $this->assertEquals('Settings overrides exist (Groups: 2, Users: 2)',
 631                  html_to_text($renderer->quiz_override_summary_links($quiz, $cm), 0, false));
 632      }
 633  
 634      /**
 635       *  Test quiz_send_confirmation function.
 636       */
 637      public function test_quiz_send_confirmation() {
 638          global $CFG, $DB;
 639  
 640          $this->resetAfterTest();
 641          $this->setAdminUser();
 642          $this->preventResetByRollback();
 643  
 644          $course = $this->getDataGenerator()->create_course();
 645          $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');
 646          $quiz = $quizgenerator->create_instance(['course' => $course->id]);
 647          $cm = get_coursemodule_from_instance('quiz', $quiz->id);
 648  
 649          $recipient = $this->getDataGenerator()->create_user(['email' => 'student@example.com']);
 650  
 651          // Allow recipent to receive email confirm submission.
 652          $studentrole = $DB->get_record('role', ['shortname' => 'student']);
 653          assign_capability('mod/quiz:emailconfirmsubmission', CAP_ALLOW, $studentrole->id,
 654              \context_course::instance($course->id), true);
 655          $this->getDataGenerator()->enrol_user($recipient->id, $course->id, $studentrole->id, 'manual');
 656  
 657          $timenow = time();
 658          $data = new \stdClass();
 659          // Course info.
 660          $data->courseid        = $course->id;
 661          $data->coursename      = $course->fullname;
 662          // Quiz info.
 663          $data->quizname        = $quiz->name;
 664          $data->quizurl         = $CFG->wwwroot . '/mod/quiz/view.php?id=' . $cm->id;
 665          $data->quizid          = $quiz->id;
 666          $data->quizcmid        = $quiz->cmid;
 667          $data->attemptid       = 1;
 668          $data->submissiontime = userdate($timenow);
 669  
 670          $sink = $this->redirectEmails();
 671          quiz_send_confirmation($recipient, $data, true);
 672          $messages = $sink->get_messages();
 673          $message = reset($messages);
 674          $this->assertStringContainsString("Thank you for submitting your answers" ,
 675              quoted_printable_decode($message->body));
 676          $sink->close();
 677  
 678          $sink = $this->redirectEmails();
 679          quiz_send_confirmation($recipient, $data, false);
 680          $messages = $sink->get_messages();
 681          $message = reset($messages);
 682          $this->assertStringContainsString("Your answers were submitted automatically" ,
 683              quoted_printable_decode($message->body));
 684          $sink->close();
 685      }
 686  }