WebSVN – Moodle – Diff – /mod/quiz/tests/quiz_question_restore_test.php

 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+namespace mod_quiz;
-namespace mod_quiz;
+use core\exception\coding_exception;
 use core_question\local\bank\random_question_loader;
 use core_question\question_reference_manager;
  * @package    mod_quiz
  * @category   test
  * @copyright  2021 Catalyst IT Australia Pty Ltd
  * @author     Safat Shahin <safatshahin@catalyst-au.net>
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @covers \mod_quiz\question\bank\qbank_helper
+ * @covers \restore_quiz_activity_structure_step
+ * @covers \restore_question_set_reference_data_trait
  */
-class quiz_question_restore_test extends \advanced_testcase {
+final class quiz_question_restore_test extends \advanced_testcase {
     use \quiz_question_helper_test_trait;
     /**
      * @var \stdClass test student user.
         $this->student = $this->getDataGenerator()->create_user();
         $this->user = $USER;
+    }
     /**
-     * Test a quiz backup and restore in a different course without attempts for course question bank.
+     * Create a quiz with 2 questions and 1 random question, using question categories in the provided context.
      *
+     * @param int $questioncontextid Context to create question categories in.
-     * @covers \mod_quiz\question\bank\qbank_helper::get_question_structure
+     * @return array The quiz, slots, random questions in each slot that has them, and the quiz context.
      */
-    public function test_quiz_restore_in_a_different_course_using_course_question_bank(): void {
-        $this->resetAfterTest();
-        // Create the test quiz.
+    public function create_quiz_with_questions(int $questioncontextid): array {
         $quiz = $this->create_test_quiz($this->course);
+        $quizcontext = \context_module::instance($quiz->cmid);
         $oldquizcontext = \context_module::instance($quiz->cmid);
-        // Test for questions from a different context.
-        $coursecontext = \context_course::instance($this->course->id);
+        // Test for questions from a different context.
         $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');
-        $this->add_two_regular_questions($questiongenerator, $quiz, ['contextid' => $coursecontext->id]);
+        $this->add_two_regular_questions($questiongenerator, $quiz, ['contextid' => $questioncontextid]);
+        $this->add_one_random_question($questiongenerator, $quiz, ['contextid' => $questioncontextid]);
+        $slots = \mod_quiz\question\bank\qbank_helper::get_question_structure(
+            $quiz->id, $quizcontext);
+        $randomquestions = [];
+        $loader = new random_question_loader(new \qubaid_list([]));
+        foreach ($slots as $number => $slot) {
+            if (!empty($slot->filtercondition)) {
+                $randomquestions[$number] = $loader->get_filtered_questions($slot->filtercondition['filter']);
+            }
+        }
+        return [
+            $quiz,
+            $slots,
+            $randomquestions,
+            $quizcontext,
+        ];
+    }
+    /**
+     * Verify the layout of the quiz on the provided course matches (or doesn't match) the expected layout.
+     *
+     * For $expectedslots, the value should be provided as an array keyed by slot number. Each slot can be provided as a single
+     * number, which will considered a question ID, or an array with 'filter' and 'randomquestionids' which will be considered
+     * a random question.
+     *
+     * For example,
+     * [
+     *  [1] => 123,
+     *  [2] => [
+     *           'filter' => ['name' => 'category', 'values' => ['345']],
+     *           'randomquestionids' => ['101', '102'],
+     *         ],
+     *  [3] => 124,
+     * ]
+     * Will assert that the quiz contains (or doesn't contain if $expectequal is false):
+     * - A question in slot 1 with ID 123,
+     * - A random question in slot 2 with a filter for category ID 345, which matches questions with IDs 101 and 102,
+     * - A question in slot 3 with ID 124.
+     *
+     * @param int $courseid The ID of the course to pick the quiz from.
+     * @param array $expectedslots The layout of slots to compare to, see above for details of the structure.
+     * @param bool $expectequal If true, assert that each slot is equal to the expected value. Otherwise assert it's not equal.
+     */
+    public function verify_restored_quiz_layout(
+        int $courseid,
+        array $expectedslots,
+        bool $expectequal
+    ): void {
+        $loader = new random_question_loader(new \qubaid_list([]));
+        $modules = get_fast_modinfo($courseid)->get_instances_of('quiz');
+        $module = reset($modules);
+        $newslots = \mod_quiz\question\bank\qbank_helper::get_question_structure(
+            $module->instance, $module->context);
+        $this->assertCount(count($expectedslots), $newslots);
+        foreach ($newslots as $number => $slot) {
+            $randomquestionids = null;
+            if (is_array($expectedslots[$number])) {
+                // A random question, compare filters and filtered question ids.
+                $actualcontents = $slot->filtercondition['filter'];
+                $expectedcontents = $expectedslots[$number]['filter'];
+                $randomquestions = $loader->get_filtered_questions($slot->filtercondition['filter']);
+                $randomquestionids = array_keys($randomquestions);
+                sort($randomquestionids);
+                sort($expectedslots[$number]['randomquestionids']);
+            } else if (is_numeric($expectedslots[$number])) {
+                // A normal question, compare IDs.
+                $actualcontents = $slot->questionid;
+                $expectedcontents = $expectedslots[$number];
+            } else {
+                throw new coding_exception('Slots must either be a number or an array.');
+            }
+            if ($expectequal) {
+                $this->assertEquals($expectedcontents, $actualcontents);
+                if (!is_null($randomquestionids)) {
+                    $this->assertEquals($expectedslots[$number]['randomquestionids'], $randomquestionids);
+                }
+            } else {
+                $this->assertNotEquals($expectedcontents, $actualcontents);
+                if (!is_null($randomquestionids)) {
+                    $this->assertNotEquals($expectedslots[$number]['randomquestionids'], $randomquestionids);
+                }
+            }
+        }
+    }
+    /**
+     * Restore a quiz that used questions from a shared question bank on the same course, after the course is deleted.
+     *
+     * The restored quiz should use new copies of the questions.
+     */
+    public function test_quiz_restore_in_a_different_course_using_question_bank(): void {
+        $this->resetAfterTest();
+        // Create the test quiz.
+        $qbank = self::getDataGenerator()->create_module('qbank', ['course' => $this->course]);
+        $qbankcontext = \context_module::instance($qbank->cmid);
-        $this->add_one_random_question($questiongenerator, $quiz, ['contextid' => $coursecontext->id]);
+        [$quiz, $originalslots, $randomquestions, $quizcontext] = $this->create_quiz_with_questions($qbankcontext->id);
         // Make the backup.
         $backupid = $this->backup_quiz($quiz, $this->user);
         // Delete the current course to make sure there is no data.
+        delete_course($this->course, false);
+        // Check if the questions and associated data are deleted properly.
+        $this->assertEquals(0, count(\mod_quiz\question\bank\qbank_helper::get_question_structure($quiz->id, $quizcontext)));
+        // Restore the course.
+        $newcourse = $this->getDataGenerator()->create_course();
+        $this->restore_quiz($backupid, $newcourse, $this->user);
-        delete_course($this->course, false);
+        $this->verify_restored_quiz_layout(
+            courseid: $newcourse->id,
+            expectedslots: [
+=> $originalslots[1]->questionid,
+=> $originalslots[2]->questionid,
+=> [
+                    'filter' => $originalslots[3]->filtercondition['filter'],
+                    'randomquestionids' => array_keys($randomquestions[3]),
+                ],
+            ],
+            expectequal: false,
+        );
+    }
+    /**
+     * Restore a quiz that used questions from a shared question bank on the same course.
+     *
+     * The restored quiz should reference the questions in the original question bank.
+     */
+    public function test_quiz_restore_in_a_different_course_reference_original_question_bank(): void {
+        $this->resetAfterTest();
+        // Create the test quiz.
+        $qbank = self::getDataGenerator()->create_module('qbank', ['course' => $this->course]);
+        $qbankcontext = \context_module::instance($qbank->cmid);
         [$quiz, $originalslots, $randomquestions] = $this->create_quiz_with_questions($qbankcontext->id);
         // Check if the questions and associated data are deleted properly.
-        $this->assertEquals(0, count(\mod_quiz\question\bank\qbank_helper::get_question_structure(
+        // Make the backup.
+        $backupid = $this->backup_quiz($quiz, $this->user);
+        // Restore the course.
+        $newcourse = $this->getDataGenerator()->create_course();
+        $this->restore_quiz($backupid, $newcourse, $this->user);
+        $this->verify_restored_quiz_layout(
+            courseid: $newcourse->id,
+            expectedslots: [
+=> $originalslots[1]->questionid,
+=> $originalslots[2]->questionid,
+=> [
+                    'filter' => $originalslots[3]->filtercondition['filter'],
+                    'randomquestionids' => array_keys($randomquestions[3]),
+                ],
+            ],
+            expectequal: true,
+        );
+    }
+    /**
+     * Restore a quiz that used questions from a shared question bank on the same course, as a user who cannot access the course.
+     *
+     * The restored quiz should use new copies of the questions.
+     */
+    public function test_quiz_restore_in_a_different_course_cant_use_original_question_bank(): void {
+        $this->resetAfterTest();
+        // Create the test quiz.
+        $qbank = self::getDataGenerator()->create_module('qbank', ['course' => $this->course]);
+        $qbankcontext = \context_module::instance($qbank->cmid);
+        [$quiz, $originalslots, $randomquestions] = $this->create_quiz_with_questions($qbankcontext->id);
+        // Make the backup.
+        $backupid = $this->backup_quiz($quiz, $this->user);
+        // Restore the course as a new user without access to the original course.
+        $newcourse = $this->getDataGenerator()->create_course();
+        $newuser = self::getDataGenerator()->create_user();
+        self::getDataGenerator()->enrol_user($newuser->id, $newcourse->id, 'manager');
+        $this->setUser($newuser);
+        $this->restore_quiz($backupid, $newcourse, $newuser);
+        $this->verify_restored_quiz_layout(
+            courseid: $newcourse->id,
+            expectedslots: [
+=> $originalslots[1]->questionid,
+=> $originalslots[2]->questionid,
+=> [
+                    'filter' => $originalslots[3]->filtercondition['filter'],
+                    'randomquestionids' => array_keys($randomquestions[3]),
+                ],
+            ],
+            expectequal: false,
+        );
+    }
+    /**
+     * Restore a quiz that used questions from a shared question bank on another course, after that other course is deleted.
+     *
+     * The restored quiz should use new copies of the questions.
+     */
+    public function test_quiz_restore_in_a_different_course_question_course_has_been_deleted(): void {
+        $this->resetAfterTest();
+        // Create the test quiz.
+        $qbankcourse = self::getDataGenerator()->create_course();
+        $qbank = self::getDataGenerator()->create_module('qbank', ['course' => $qbankcourse]);
+        $qbankcontext = \context_module::instance($qbank->cmid);
+        [$quiz, $originalslots, $randomquestions] = $this->create_quiz_with_questions($qbankcontext->id);
+        // Make the backup.
+        $backupid = $this->backup_quiz($quiz, $this->user);
+        // Delete the qbank course.
-                $quiz->id, $oldquizcontext)));
+        delete_course($qbankcourse, false);
+        // Restore the course as a new copy.
-        // Restore the course.
+        $newcourse = $this->getDataGenerator()->create_course();
-        $newcourse = $this->getDataGenerator()->create_course();
+        $this->restore_quiz($backupid, $newcourse, $this->user);
-        $this->restore_quiz($backupid, $newcourse, $this->user);
+        // Verify.
+        $this->verify_restored_quiz_layout(
+            courseid: $newcourse->id,
+            expectedslots: [
+=> $originalslots[1]->questionid,
+=> $originalslots[2]->questionid,
+=> [
-        // Verify.
+                    'filter' => $originalslots[3]->filtercondition['filter'],
-        $modules = get_fast_modinfo($newcourse->id)->get_instances_of('quiz');
+                    'randomquestionids' => array_keys($randomquestions[3]),
-        $module = reset($modules);
+                ],
-        $questions = \mod_quiz\question\bank\qbank_helper::get_question_structure(
+            ],
               WHERE qc.contextid = ?
               $extracondition", [$contextid]);
+    }
     /**
-     * Test if a duplicate does not duplicate questions in course question bank.
+     * Duplicate a quiz that uses questions from a shared bank on the same course.
      *
-     * @covers ::duplicate_module
+     * The new quiz should reference the same questions.
      */
-    public function test_quiz_duplicate_does_not_duplicate_course_question_bank_questions(): void {
+    public function test_quiz_duplicate_does_not_duplicate_questions_from_shared_banks(): void {
-        $this->resetAfterTest();
-        $quiz = $this->create_test_quiz($this->course);
+        $this->resetAfterTest();
-        // Test for questions from a different context.
+        // Test for questions from a qbank context.
-        $context = \context_course::instance($this->course->id);
+        $qbankcourse = self::getDataGenerator()->create_course();
-        $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');
+        $qbank = self::getDataGenerator()->create_module('qbank', ['course' => $qbankcourse]);
-        $this->add_two_regular_questions($questiongenerator, $quiz, ['contextid' => $context->id]);
+        $context = \context_module::instance($qbank->cmid);
-        $this->add_one_random_question($questiongenerator, $quiz, ['contextid' => $context->id]);
+        [$quiz, $originalslots, $randomquestions] = $this->create_quiz_with_questions($context->id);
-        // Count the questions in course context.
+        // Count the questions in qbank context.
+        $this->assertEquals(7, $this->question_count($context->id));
-        $this->assertEquals(7, $this->question_count($context->id));
+        $this->assertCount(3, $originalslots);
         $newquiz = $this->duplicate_quiz($this->course, $quiz);
         $this->assertEquals(7, $this->question_count($context->id));
-        $context = \context_module::instance($newquiz->id);
+        $newquizcontext = \context_module::instance($newquiz->id);
         // Count the questions in the quiz context.
+        $this->assertEquals(0, $this->question_count($newquizcontext->id));
+        $this->verify_restored_quiz_layout(
+            courseid: $this->course->id,
+            expectedslots: [
+=> $originalslots[1]->questionid,
+=> $originalslots[2]->questionid,
+=> [
+                    'filter' => $originalslots[3]->filtercondition['filter'],
+                    'randomquestionids' => array_keys($randomquestions[3]),
+                ],
+            ],
+            expectequal: true,
-        $this->assertEquals(0, $this->question_count($context->id));
+        );
+    }
     /**
         $categoryid = $DB->get_field_sql("SELECT MIN(id) FROM {course_categories}");
         $newcourseid = \restore_dbops::create_new_course('Test fullname', 'Test shortname', $categoryid);
         $rc = new \restore_controller($backupid, $newcourseid, \backup::INTERACTIVE_NO, \backup::MODE_GENERAL, $USER->id,
             \backup::TARGET_NEW_COURSE);
+        $rc->execute_precheck();
+        $results = $rc->get_precheck_results();
+        // Backup contains categories attached to deprecated contexts so the results should only contain warnings for these.
+        $this->assertCount(2, $results['warnings']);
+        foreach ($results['warnings'] as $warning) {
+            $this->assertStringContainsString('will be created at a question bank module context by restore', $warning);
+        }
+        $this->assertArrayNotHasKey('errors', $results);
         $this->assertTrue($rc->execute_precheck());
         $rc->execute_plan();
         $rc->destroy();
+        // Get the information about the resulting course and check that it is set up correctly.
+        $modinfo = get_fast_modinfo($newcourseid);
+        $qbanks = $modinfo->get_instances_of('qbank');
+        $this->assertCount(1, $qbanks);
-        // Get the information about the resulting course and check that it is set up correctly.
+        $qbank = reset($qbanks);
-        $modinfo = get_fast_modinfo($newcourseid);
+        $this->assertEquals(get_string('systembank', 'question'), $qbank->name);
         $quiz = array_values($modinfo->get_instances_of('quiz'))[0];
         $quizobj = \mod_quiz\quiz_settings::create($quiz->instance);
         $quizobj->preload_questions();
         $quizobj->load_questions();
         $questions = $quizobj->get_questions();
         $this->assertCount(1, $questions);
-        // Count the questions for course question bank.
+        // Count the questions for new course mod_qbank question bank.
-        $this->assertEquals(6, $this->question_count(\context_course::instance($newcourseid)->id));
+        $this->assertEquals(6, $this->question_count(\context_module::instance($qbank->id)->id));
-        $this->assertEquals(6, $this->question_count(\context_course::instance($newcourseid)->id,
-            "AND q.qtype <> 'random'"));
+        $this->assertEquals(6, $this->question_count(\context_module::instance($qbank->id)->id, "AND q.qtype <> 'random'"));
         // Count the questions in quiz qbank.
         $categoryid = $DB->get_field_sql("SELECT MIN(id) FROM {course_categories}");
         $newcourseid = \restore_dbops::create_new_course('Test fullname', 'Test shortname', $categoryid);
         $rc = new \restore_controller($backupid, $newcourseid, \backup::INTERACTIVE_NO, \backup::MODE_GENERAL, $USER->id,
                 \backup::TARGET_NEW_COURSE);
+        $rc->execute_precheck();
+        $results = $rc->get_precheck_results();
+        // Backup contains categories attached to deprecated contexts, so we should only have warnings for those.
+        $this->assertCount(1, $results['warnings']);
+        $this->assertStringContainsString('will be created at a question bank module context by restore', $results['warnings'][0]);
+        $this->assertArrayNotHasKey('errors', $results);
         $this->assertTrue($rc->execute_precheck());
         $rc->execute_plan();
         $rc->destroy();
         // Get the information about the resulting course and check that it is set up correctly.
+        // Each quiz should contain an instance of the random question.
-        // Each quiz should contain an instance of the random question.
+        $modinfo = get_fast_modinfo($newcourseid);
-        $modinfo = get_fast_modinfo($newcourseid);
+        $qbank = array_values($modinfo->get_instances_of('qbank'))[0];
         $quizzes = $modinfo->get_instances_of('quiz');
         $this->assertCount(2, $quizzes);
         foreach ($quizzes as $quiz) {
             $quizobj->load_questions();
             $questions = $quizobj->get_questions();
             $this->assertCount(1, $questions);
+        }
-        // Count the questions for course question bank.
+        // Count the questions for new course mod_qbank question bank.
         // We should have a single question, the random question should have been deleted after the restore.
-        $this->assertEquals(1, $this->question_count(\context_course::instance($newcourseid)->id));
+        $this->assertEquals(1, $this->question_count(\context_module::instance($qbank->id)->id));
-        $this->assertEquals(1, $this->question_count(\context_course::instance($newcourseid)->id,
+        $this->assertEquals(1, $this->question_count(\context_module::instance($qbank->id)->id,
                 "AND q.qtype <> 'random'"));
         // Count the questions in quiz qbank.

Proyectos de Subversion Moodle

(root)/mod/quiz/tests/quiz_question_restore_test.php – Rev 11 → 1441