mod/quiz/tests/calendar_event_modified_test.php

   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 namespace mod_quiz;
  18
  19 defined('MOODLE_INTERNAL') || die();
  20
  21 global $CFG;
  22 require_once($CFG->dirroot . '/mod/quiz/lib.php');
  23
  24 /**
  25  * Unit tests for the calendar event modification callbacks used
  26  * for dragging and dropping quiz calendar events in the calendar
  27  * UI.
  28  *
  29  * @package    mod_quiz
  30  * @category   test
  31  * @copyright  2017 Ryan Wyllie <ryan@moodle.com>
  32  * @license    http://www.gnu.org/copyleft/gpl.html GNU Public License
  33  */
  34 class calendar_event_modified_test extends \advanced_testcase {
  35
  36     /**
  37      * Create an instance of the quiz activity.
  38      *
  39      * @param array $properties Properties to set on the activity
  40      * @return stdClass Quiz activity instance
  41      */
  42     protected function create_quiz_instance(array $properties) {
  43         global $DB;
  44
  45         $generator = $this->getDataGenerator();
  46
  47         if (empty($properties['course'])) {
  48             $course = $generator->create_course();
  49             $courseid = $course->id;
  50         } else {
  51             $courseid = $properties['course'];
  52         }
  53
  54         $quizgenerator = $generator->get_plugin_generator('mod_quiz');
  55         $quiz = $quizgenerator->create_instance(array_merge(['course' => $courseid], $properties));
  56
  57         if (isset($properties['timemodified'])) {
  58             // The generator overrides the timemodified value to set it as
  59             // the current time even if a value is provided so we need to
  60             // make sure it's set back to the requested value.
  61             $quiz->timemodified = $properties['timemodified'];
  62             $DB->update_record('quiz', $quiz);
  63         }
  64
  65         return $quiz;
  66     }
  67
  68     /**
  69      * Create a calendar event for a quiz activity instance.
  70      *
  71      * @param \stdClass $quiz The activity instance
  72      * @param array $eventproperties Properties to set on the calendar event
  73      * @return calendar_event
  74      */
  75     protected function create_quiz_calendar_event(\stdClass $quiz, array $eventproperties) {
  76         $defaultproperties = [
  77             'name' => 'Test event',
  78             'description' => '',
  79             'format' => 1,
  80             'courseid' => $quiz->course,
  81             'groupid' => 0,
  82             'userid' => 2,
  83             'modulename' => 'quiz',
  84             'instance' => $quiz->id,
  85             'eventtype' => QUIZ_EVENT_TYPE_OPEN,
  86             'timestart' => time(),
  87             'timeduration' => 86400,
  88             'visible' => 1
  89         ];
  90
  91         return new \calendar_event(array_merge($defaultproperties, $eventproperties));
  92     }
  93
  94     /**
  95      * An unkown event type should not change the quiz instance.
  96      */
  97     public function test_mod_quiz_core_calendar_event_timestart_updated_unknown_event() {
  98         global $DB;
  99
 100         $this->resetAfterTest(true);
 101         $this->setAdminUser();
 102         $timeopen = time();
 103         $timeclose = $timeopen + DAYSECS;
 104         $quiz = $this->create_quiz_instance(['timeopen' => $timeopen, 'timeclose' => $timeclose]);
 105         $event = $this->create_quiz_calendar_event($quiz, [
 106             'eventtype' => QUIZ_EVENT_TYPE_OPEN . "SOMETHING ELSE",
 107             'timestart' => 1
 108         ]);
 109
 110         mod_quiz_core_calendar_event_timestart_updated($event, $quiz);
 111
 112         $quiz = $DB->get_record('quiz', ['id' => $quiz->id]);
 113         $this->assertEquals($timeopen, $quiz->timeopen);
 114         $this->assertEquals($timeclose, $quiz->timeclose);
 115     }
 116
 117     /**
 118      * A QUIZ_EVENT_TYPE_OPEN event should update the timeopen property of
 119      * the quiz activity.
 120      */
 121     public function test_mod_quiz_core_calendar_event_timestart_updated_open_event() {
 122         global $DB;
 123
 124         $this->resetAfterTest(true);
 125         $this->setAdminUser();
 126         $timeopen = time();
 127         $timeclose = $timeopen + DAYSECS;
 128         $timemodified = 1;
 129         $newtimeopen = $timeopen - DAYSECS;
 130         $quiz = $this->create_quiz_instance([
 131             'timeopen' => $timeopen,
 132             'timeclose' => $timeclose,
 133             'timemodified' => $timemodified
 134         ]);
 135         $event = $this->create_quiz_calendar_event($quiz, [
 136             'eventtype' => QUIZ_EVENT_TYPE_OPEN,
 137             'timestart' => $newtimeopen
 138         ]);
 139
 140         mod_quiz_core_calendar_event_timestart_updated($event, $quiz);
 141
 142         $quiz = $DB->get_record('quiz', ['id' => $quiz->id]);
 143         // Ensure the timeopen property matches the event timestart.
 144         $this->assertEquals($newtimeopen, $quiz->timeopen);
 145         // Ensure the timeclose isn't changed.
 146         $this->assertEquals($timeclose, $quiz->timeclose);
 147         // Ensure the timemodified property has been changed.
 148         $this->assertNotEquals($timemodified, $quiz->timemodified);
 149     }
 150
 151     /**
 152      * A QUIZ_EVENT_TYPE_CLOSE event should update the timeclose property of
 153      * the quiz activity.
 154      */
 155     public function test_mod_quiz_core_calendar_event_timestart_updated_close_event() {
 156         global $DB;
 157
 158         $this->resetAfterTest(true);
 159         $this->setAdminUser();
 160         $timeopen = time();
 161         $timeclose = $timeopen + DAYSECS;
 162         $timemodified = 1;
 163         $newtimeclose = $timeclose + DAYSECS;
 164         $quiz = $this->create_quiz_instance([
 165             'timeopen' => $timeopen,
 166             'timeclose' => $timeclose,
 167             'timemodified' => $timemodified
 168         ]);
 169         $event = $this->create_quiz_calendar_event($quiz, [
 170             'eventtype' => QUIZ_EVENT_TYPE_CLOSE,
 171             'timestart' => $newtimeclose
 172         ]);
 173
 174         mod_quiz_core_calendar_event_timestart_updated($event, $quiz);
 175
 176         $quiz = $DB->get_record('quiz', ['id' => $quiz->id]);
 177         // Ensure the timeclose property matches the event timestart.
 178         $this->assertEquals($newtimeclose, $quiz->timeclose);
 179         // Ensure the timeopen isn't changed.
 180         $this->assertEquals($timeopen, $quiz->timeopen);
 181         // Ensure the timemodified property has been changed.
 182         $this->assertNotEquals($timemodified, $quiz->timemodified);
 183     }
 184
 185     /**
 186      * A QUIZ_EVENT_TYPE_OPEN event should not update the timeopen property of
 187      * the quiz activity if it's an override.
 188      */
 189     public function test_mod_quiz_core_calendar_event_timestart_updated_open_event_override() {
 190         global $DB;
 191
 192         $this->resetAfterTest(true);
 193         $this->setAdminUser();
 194         $user = $this->getDataGenerator()->create_user();
 195         $timeopen = time();
 196         $timeclose = $timeopen + DAYSECS;
 197         $timemodified = 1;
 198         $newtimeopen = $timeopen - DAYSECS;
 199         $quiz = $this->create_quiz_instance([
 200             'timeopen' => $timeopen,
 201             'timeclose' => $timeclose,
 202             'timemodified' => $timemodified
 203         ]);
 204         $event = $this->create_quiz_calendar_event($quiz, [
 205             'userid' => $user->id,
 206             'eventtype' => QUIZ_EVENT_TYPE_OPEN,
 207             'timestart' => $newtimeopen
 208         ]);
 209         $record = (object) [
 210             'quiz' => $quiz->id,
 211             'userid' => $user->id
 212         ];
 213
 214         $DB->insert_record('quiz_overrides', $record);
 215
 216         mod_quiz_core_calendar_event_timestart_updated($event, $quiz);
 217
 218         $quiz = $DB->get_record('quiz', ['id' => $quiz->id]);
 219         // Ensure the timeopen property doesn't change.
 220         $this->assertEquals($timeopen, $quiz->timeopen);
 221         // Ensure the timeclose isn't changed.
 222         $this->assertEquals($timeclose, $quiz->timeclose);
 223         // Ensure the timemodified property has not been changed.
 224         $this->assertEquals($timemodified, $quiz->timemodified);
 225     }
 226
 227     /**
 228      * If a student somehow finds a way to update the quiz calendar event
 229      * then the callback should not update the quiz activity otherwise that
 230      * would be a security issue.
 231      */
 232     public function test_student_role_cant_update_quiz_activity() {
 233         global $DB;
 234
 235         $this->resetAfterTest();
 236         $this->setAdminUser();
 237
 238         $generator = $this->getDataGenerator();
 239         $user = $generator->create_user();
 240         $course = $generator->create_course();
 241         $context = \context_course::instance($course->id);
 242         $roleid = $generator->create_role();
 243         $now = time();
 244         $timeopen = (new \DateTime())->setTimestamp($now);
 245         $newtimeopen = (new \DateTime())->setTimestamp($now)->modify('+1 day');
 246         $quiz = $this->create_quiz_instance([
 247             'course' => $course->id,
 248             'timeopen' => $timeopen->getTimestamp()
 249         ]);
 250
 251         $generator->enrol_user($user->id, $course->id, 'student');
 252         $generator->role_assign($roleid, $user->id, $context->id);
 253
 254         $event = $this->create_quiz_calendar_event($quiz, [
 255             'eventtype' => QUIZ_EVENT_TYPE_OPEN,
 256             'timestart' => $timeopen->getTimestamp()
 257         ]);
 258
 259         assign_capability('moodle/course:manageactivities', CAP_PROHIBIT, $roleid, $context, true);
 260
 261         $this->setUser($user);
 262
 263         mod_quiz_core_calendar_event_timestart_updated($event, $quiz);
 264
 265         $newquiz = $DB->get_record('quiz', ['id' => $quiz->id]);
 266         // The time open shouldn't have changed even though we updated the calendar
 267         // event.
 268         $this->assertEquals($timeopen->getTimestamp(), $newquiz->timeopen);
 269     }
 270
 271     /**
 272      * A teacher with the capability to modify a quiz module should be
 273      * able to update the quiz activity dates by changing the calendar
 274      * event.
 275      */
 276     public function test_teacher_role_can_update_quiz_activity() {
 277         global $DB;
 278
 279         $this->resetAfterTest();
 280         $this->setAdminUser();
 281
 282         $generator = $this->getDataGenerator();
 283         $user = $generator->create_user();
 284         $course = $generator->create_course();
 285         $context = \context_course::instance($course->id);
 286         $roleid = $generator->create_role();
 287         $now = time();
 288         $timeopen = (new \DateTime())->setTimestamp($now);
 289         $newtimeopen = (new \DateTime())->setTimestamp($now)->modify('+1 day');
 290         $quiz = $this->create_quiz_instance([
 291             'course' => $course->id,
 292             'timeopen' => $timeopen->getTimestamp()
 293         ]);
 294
 295         $generator->enrol_user($user->id, $course->id, 'teacher');
 296         $generator->role_assign($roleid, $user->id, $context->id);
 297
 298         $event = $this->create_quiz_calendar_event($quiz, [
 299             'eventtype' => QUIZ_EVENT_TYPE_OPEN,
 300             'timestart' => $newtimeopen->getTimestamp()
 301         ]);
 302
 303         assign_capability('moodle/course:manageactivities', CAP_ALLOW, $roleid, $context, true);
 304
 305         $this->setUser($user);
 306
 307         // Trigger and capture the event.
 308         $sink = $this->redirectEvents();
 309
 310         mod_quiz_core_calendar_event_timestart_updated($event, $quiz);
 311
 312         $triggeredevents = $sink->get_events();
 313         $moduleupdatedevents = array_filter($triggeredevents, function($e) {
 314             return is_a($e, 'core\event\course_module_updated');
 315         });
 316
 317         $newquiz = $DB->get_record('quiz', ['id' => $quiz->id]);
 318         // The should be updated along with the event because the user has sufficient
 319         // capabilities.
 320         $this->assertEquals($newtimeopen->getTimestamp(), $newquiz->timeopen);
 321         // Confirm that a module updated event is fired when the module
 322         // is changed.
 323         $this->assertNotEmpty($moduleupdatedevents);
 324     }
 325
 326
 327     /**
 328      * An unkown event type should not have any limits
 329      */
 330     public function test_mod_quiz_core_calendar_get_valid_event_timestart_range_unknown_event() {
 331         global $DB;
 332
 333         $this->resetAfterTest(true);
 334         $this->setAdminUser();
 335         $timeopen = time();
 336         $timeclose = $timeopen + DAYSECS;
 337         $quiz = $this->create_quiz_instance([
 338             'timeopen' => $timeopen,
 339             'timeclose' => $timeclose
 340         ]);
 341         $event = $this->create_quiz_calendar_event($quiz, [
 342             'eventtype' => QUIZ_EVENT_TYPE_OPEN . "SOMETHING ELSE",
 343             'timestart' => 1
 344         ]);
 345
 346         list ($min, $max) = mod_quiz_core_calendar_get_valid_event_timestart_range($event, $quiz);
 347         $this->assertNull($min);
 348         $this->assertNull($max);
 349     }
 350
 351     /**
 352      * The open event should be limited by the quiz's timeclose property, if it's set.
 353      */
 354     public function test_mod_quiz_core_calendar_get_valid_event_timestart_range_open_event() {
 355         global $DB;
 356
 357         $this->resetAfterTest(true);
 358         $this->setAdminUser();
 359         $timeopen = time();
 360         $timeclose = $timeopen + DAYSECS;
 361         $quiz = $this->create_quiz_instance([
 362             'timeopen' => $timeopen,
 363             'timeclose' => $timeclose
 364         ]);
 365         $event = $this->create_quiz_calendar_event($quiz, [
 366             'eventtype' => QUIZ_EVENT_TYPE_OPEN,
 367             'timestart' => 1
 368         ]);
 369
 370         // The max limit should be bounded by the timeclose value.
 371         list ($min, $max) = mod_quiz_core_calendar_get_valid_event_timestart_range($event, $quiz);
 372
 373         $this->assertNull($min);
 374         $this->assertEquals($timeclose, $max[0]);
 375
 376         // No timeclose value should result in no upper limit.
 377         $quiz->timeclose = 0;
 378         list ($min, $max) = mod_quiz_core_calendar_get_valid_event_timestart_range($event, $quiz);
 379
 380         $this->assertNull($min);
 381         $this->assertNull($max);
 382     }
 383
 384     /**
 385      * An override event should not have any limits.
 386      */
 387     public function test_mod_quiz_core_calendar_get_valid_event_timestart_range_override_event() {
 388         global $DB;
 389
 390         $this->resetAfterTest(true);
 391         $this->setAdminUser();
 392         $generator = $this->getDataGenerator();
 393         $user = $generator->create_user();
 394         $course = $generator->create_course();
 395         $timeopen = time();
 396         $timeclose = $timeopen + DAYSECS;
 397         $quiz = $this->create_quiz_instance([
 398             'course' => $course->id,
 399             'timeopen' => $timeopen,
 400             'timeclose' => $timeclose
 401         ]);
 402         $event = $this->create_quiz_calendar_event($quiz, [
 403             'userid' => $user->id,
 404             'eventtype' => QUIZ_EVENT_TYPE_OPEN,
 405             'timestart' => 1
 406         ]);
 407         $record = (object) [
 408             'quiz' => $quiz->id,
 409             'userid' => $user->id
 410         ];
 411
 412         $DB->insert_record('quiz_overrides', $record);
 413
 414         list ($min, $max) = mod_quiz_core_calendar_get_valid_event_timestart_range($event, $quiz);
 415
 416         $this->assertFalse($min);
 417         $this->assertFalse($max);
 418     }
 419
 420     /**
 421      * The close event should be limited by the quiz's timeopen property, if it's set.
 422      */
 423     public function test_mod_quiz_core_calendar_get_valid_event_timestart_range_close_event() {
 424         global $DB;
 425
 426         $this->resetAfterTest(true);
 427         $this->setAdminUser();
 428         $timeopen = time();
 429         $timeclose = $timeopen + DAYSECS;
 430         $quiz = $this->create_quiz_instance([
 431             'timeopen' => $timeopen,
 432             'timeclose' => $timeclose
 433         ]);
 434         $event = $this->create_quiz_calendar_event($quiz, [
 435             'eventtype' => QUIZ_EVENT_TYPE_CLOSE,
 436             'timestart' => 1,
 437         ]);
 438
 439         // The max limit should be bounded by the timeclose value.
 440         list ($min, $max) = mod_quiz_core_calendar_get_valid_event_timestart_range($event, $quiz);
 441
 442         $this->assertEquals($timeopen, $min[0]);
 443         $this->assertNull($max);
 444
 445         // No timeclose value should result in no upper limit.
 446         $quiz->timeopen = 0;
 447         list ($min, $max) = mod_quiz_core_calendar_get_valid_event_timestart_range($event, $quiz);
 448
 449         $this->assertNull($min);
 450         $this->assertNull($max);
 451     }
 452
 453     /**
 454      * When the close date event is changed and it results in the time close value of
 455      * the quiz being updated then the open quiz attempts should also be updated.
 456      */
 457     public function test_core_calendar_event_timestart_updated_update_quiz_attempt() {
 458         global $DB;
 459
 460         $this->resetAfterTest();
 461         $this->setAdminUser();
 462
 463         $generator = $this->getDataGenerator();
 464         $teacher = $generator->create_user();
 465         $student = $generator->create_user();
 466         $course = $generator->create_course();
 467         $context = \context_course::instance($course->id);
 468         $roleid = $generator->create_role();
 469         $now = time();
 470         $timelimit = 600;
 471         $timeopen = (new \DateTime())->setTimestamp($now);
 472         $timeclose = (new \DateTime())->setTimestamp($now)->modify('+1 day');
 473         // The new close time being earlier than the time open + time limit should
 474         // result in an update to the quiz attempts.
 475         $newtimeclose = $timeopen->getTimestamp() + $timelimit - 10;
 476         $quiz = $this->create_quiz_instance([
 477             'course' => $course->id,
 478             'timeopen' => $timeopen->getTimestamp(),
 479             'timeclose' => $timeclose->getTimestamp(),
 480             'timelimit' => $timelimit
 481         ]);
 482
 483         $generator->enrol_user($student->id, $course->id, 'student');
 484         $generator->enrol_user($teacher->id, $course->id, 'teacher');
 485         $generator->role_assign($roleid, $teacher->id, $context->id);
 486
 487         $event = $this->create_quiz_calendar_event($quiz, [
 488             'eventtype' => QUIZ_EVENT_TYPE_CLOSE,
 489             'timestart' => $newtimeclose
 490         ]);
 491
 492         assign_capability('moodle/course:manageactivities', CAP_ALLOW, $roleid, $context, true);
 493
 494         $attemptid = $DB->insert_record(
 495             'quiz_attempts',
 496             [
 497                 'quiz' => $quiz->id,
 498                 'userid' => $student->id,
 499                 'state' => 'inprogress',
 500                 'timestart' => $timeopen->getTimestamp(),
 501                 'timecheckstate' => 0,
 502                 'layout' => '',
 503                 'uniqueid' => 1
 504             ]
 505         );
 506
 507         $this->setUser($teacher);
 508
 509         mod_quiz_core_calendar_event_timestart_updated($event, $quiz);
 510
 511         $quiz = $DB->get_record('quiz', ['id' => $quiz->id]);
 512         $attempt = $DB->get_record('quiz_attempts', ['id' => $attemptid]);
 513         // When the close date is changed so that it's earlier than the time open
 514         // plus the time limit of the quiz then the attempt's timecheckstate should
 515         // be updated to the new time close date of the quiz.
 516         $this->assertEquals($newtimeclose, $attempt->timecheckstate);
 517         $this->assertEquals($newtimeclose, $quiz->timeclose);
 518     }
 519 }