Proyectos de Subversion Moodle

namespace core_question;

use context_course;

use mod_quiz\quiz_settings;

use moodle_url;

defined('MOODLE_INTERNAL') || die();

use backup;

use core_question\local\bank\question_bank_helper;

 * @covers     \restore_qtype_plugin

 * @covers     \restore_create_categories_and_questions

 * @covers     \restore_move_module_questions_categories

    /**

     * Makes a backup of a course module.

     *

     * @param int $modid The course_module id.

     * @return string Unique identifier for this backup.

     */

    protected function backup_course_module(int $modid) {

        global $CFG, $USER;

        // Turn off file logging, otherwise it can't delete the file (Windows).

        $CFG->backup_file_logger_level = \backup::LOG_NONE;

        // Do backup with default settings. MODE_IMPORT means it will just

        // create the directory and not zip it.

        $bc = new \backup_controller(\backup::TYPE_1ACTIVITY, $modid,

            \backup::FORMAT_MOODLE, \backup::INTERACTIVE_NO, \backup::MODE_IMPORT,

            $USER->id);

        $backupid = $bc->get_backupid();

        $bc->execute_plan();

        $bc->destroy();

        return $backupid;

    }

        $coursefullname = $course->fullname;

        // Restore the backup we had made earlier into a new course.

        $courseid2 = \restore_dbops::create_new_course($coursefullname, $courseshortname . '_2', $category1->id);

        $this->restore_to_course($backupid1, $courseid2);

        $modinfo = get_fast_modinfo($courseid2);

        $qbanks = $modinfo->get_instances_of('qbank');

        $qbanks = array_filter($qbanks, static fn($qbank) => $qbank->get_name() === 'Question bank 1');

        $this->assertCount(1, $qbanks);

        $qbank = reset($qbanks);

        $qbankcontext = \context_module::instance($qbank->id);

        $cats = $DB->get_records_select('question_categories', 'parent <> 0 AND contextid = ?', [$qbankcontext->id]);

        $this->assertCount(1, $cats);

        // Restore to a new course in the new course category.

        $courseid3 = \restore_dbops::create_new_course($coursefullname, $courseshortname . '_3', $category2->id);

        $this->restore_to_course($backupid2, $courseid3);

        $modinfo = get_fast_modinfo($courseid3);

        $qbanks = $modinfo->get_instances_of('qbank');

        $qbanks = array_filter($qbanks, static fn($qbank) => $qbank->get_name() === 'Question bank 1');

    public function test_backup_and_restore_recodes_links_in_questions(): void {

        global $DB, $USER, $CFG;

        $this->resetAfterTest();

        $this->setAdminUser();

        // Create a course and a category.

        $course = $this->getDataGenerator()->create_course();

        $qbank = self::getDataGenerator()->create_module('qbank', ['course' => $course->id]);

        $category = $this->getDataGenerator()->create_category();

        // Create a question with links in all the places that should be recoded.

        $testlink = new moodle_url('/course/view.php', ['id' => $course->id]);

        $testcontent = 'Look at <a href="' . $testlink . '">the course</a>.';

        $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');

        $questioncategory = $questiongenerator->create_question_category(

            ['contextid' => \context_module::instance($qbank->cmid)->id]);

        $question = $questiongenerator->create_question('multichoice', null, [

            'name' => 'Test question',

            'category' => $questioncategory->id,

            'questiontext' => ['text' => 'This is the question. ' . $testcontent],

            'generalfeedback' => ['text' => 'Why is this right? ' . $testcontent],

            'answer' => [

                '0' => ['text' => 'Choose me! ' . $testcontent],

            ],

            'feedback' => [

                '0' => ['text' => 'The reason: ' . $testcontent],

            ],

            'hint' => [

                '0' => ['text' => 'Hint: ' . $testcontent],

            ],

        ]);

        // Create a quiz and add the question.

        $quiz = $this->getDataGenerator()->create_module('quiz', ['course' => $course->id]);

        quiz_add_quiz_question($question->id, $quiz);

        // Backup and restore the course.

        $backupid = $this->backup_course($course);

        $newcourse = $this->getDataGenerator()->create_course();

        $this->restore_to_course($backupid, $newcourse->id);

        $modinfo = get_fast_modinfo($newcourse);

        $qbanks = $modinfo->get_instances_of('qbank');

        $qbank = reset($qbanks);

        // Get the question from the restored course - we are expecting just one, but that is not the real test here.

        $restoredquestions = $DB->get_records_sql("

                SELECT q.id, q.name

                  FROM {question} q

                  JOIN {question_versions} qv ON qv.questionid = q.id

                  JOIN {question_bank_entries} qbe ON qbe.id = qv.questionbankentryid

                  JOIN {question_categories} qc ON qc.id = qbe.questioncategoryid

                 WHERE qc.contextid = ?

            ", [\context_module::instance($qbank->id)->id]);

        $this->assertCount(1, $restoredquestions);

        $questionid = array_key_first($restoredquestions);

        $this->assertEquals('Test question', $restoredquestions[$questionid]->name);

        // Verify the links have been recoded.

        $restoredquestion = question_bank::load_question_data($questionid);

        $recodedlink = new moodle_url('/course/view.php', ['id' => $newcourse->id]);

        $recodedcontent = 'Look at <a href="' . $recodedlink . '">the course</a>.';

        $firstanswerid = array_key_first($restoredquestion->options->answers);

        $firsthintid = array_key_first($restoredquestion->hints);

        $this->assertEquals('This is the question. ' . $recodedcontent, $restoredquestion->questiontext);

        $this->assertEquals('Why is this right? ' . $recodedcontent, $restoredquestion->generalfeedback);

        $this->assertEquals('Choose me! ' . $recodedcontent, $restoredquestion->options->answers[$firstanswerid]->answer);

        $this->assertEquals('The reason: ' . $recodedcontent, $restoredquestion->options->answers[$firstanswerid]->feedback);

        $this->assertEquals('Hint: ' . $recodedcontent, $restoredquestion->hints[$firsthintid]->hint);

    }

    /**

     * Boilerplate setup for the tests. Creates a course, a quiz, and a qbank module. It adds a category to each module context

     * and adds a question to each category. Finally, it adds the 2 questions to the quiz.

     *

     * @return \stdClass

     */

    private function add_course_quiz_and_qbank() {

        $qgen = self::getDataGenerator()->get_plugin_generator('core_question');

        // Create a new course.

        $course = self::getDataGenerator()->create_course();

        // Create a question bank module instance, a category for that module, and a question for that category.

        $qbank = self::getDataGenerator()->create_module(

            'qbank',

            ['type' => question_bank_helper::TYPE_STANDARD, 'course' => $course->id]

        );

        $qbankcontext = \context_module::instance($qbank->cmid);

        $bankqcat = question_get_default_category($qbankcontext->id);

        $bankquestion = $qgen->create_question('shortanswer',

            null,

            ['name' => 'bank question', 'category' => $bankqcat->id, 'idnumber' => 'bankq1']

        );

        // Create a quiz module instance, a category for that module, and a question for that category.

        $quiz = self::getDataGenerator()->create_module('quiz', ['course' => $course->id]);

        $quizcontext = \context_module::instance($quiz->cmid);

        $quizqcat = question_get_default_category($quizcontext->id);

        $quizquestion = $qgen->create_question('shortanswer',

            null,

            ['name' => 'quiz question', 'category' => $quizqcat->id, 'idnumber' => 'quizq1']

        );

        quiz_add_quiz_question($bankquestion->id, $quiz);

        quiz_add_quiz_question($quizquestion->id, $quiz);

        $data = new \stdClass();

        $data->course = $course;

        $data->qbank = $qbank;

        $data->qbankcategory = $bankqcat;

        $data->qbankquestion = $bankquestion;

        $data->quiz = $quiz;

        $data->quizcategory = $quizqcat;

        $data->quizquestion = $quizquestion;

        return $data;

    }

    /**

     * If the backup contains ONLY a quiz but that quiz uses questions from a qbank module and itself,

     * and the original course does not exist on the target system,

     * then the non-quiz context categories and questions should restore to a default qbank module on the new course

     * if the old qbank no longer exists.

     */

    public function test_quiz_activity_restore_to_new_course(): void {

        global $DB;

        $this->resetAfterTest();

        self::setAdminUser();

        // Create a course to make a backup.

        $data = $this->add_course_quiz_and_qbank();

        $oldquiz = $data->quiz;

        // Backup ONLY the quiz module.

        $backupid = $this->backup_course_module($oldquiz->cmid);

        // Create a new course to restore to.

        $newcourse = self::getDataGenerator()->create_course();

        delete_course($data->course->id, false);

        $this->restore_to_course($backupid, $newcourse->id);

        $modinfo = get_fast_modinfo($newcourse);

        // Assert we have our quiz including the category and question.

        $newquizzes = $modinfo->get_instances_of('quiz');

        $this->assertCount(1, $newquizzes);

        $newquiz = reset($newquizzes);

        $newquizcontext = \context_module::instance($newquiz->id);

        $quizcats = $DB->get_records_select('question_categories',

            'parent <> 0 AND contextid = :contextid',

            ['contextid' => $newquizcontext->id]

        );

        $this->assertCount(1, $quizcats);

        $quizcat = reset($quizcats);

        $quizcatqs = get_questions_category($quizcat, false);

        $this->assertCount(1, $quizcatqs);

        $quizq = reset($quizcatqs);

        $this->assertEquals('quiz question', $quizq->name);

        // The backup did not contain the qbank that held the categories, but it is dependant.

        // So make sure the categories and questions got restored to a 'system' type default qbank module on the course.

        $defaultbanks = $modinfo->get_instances_of('qbank');

        $this->assertCount(1, $defaultbanks);

        $defaultbank = reset($defaultbanks);

        $defaultbankcontext = \context_module::instance($defaultbank->id);

        $bankcats = $DB->get_records_select('question_categories',

            'parent <> 0 AND contextid = :contextid',

            ['contextid' => $defaultbankcontext->id]

        );

        $bankcat = reset($bankcats);

        $bankqs = get_questions_category($bankcat, false);

        $this->assertCount(1, $bankqs);

        $bankq = reset($bankqs);

        $this->assertEquals('bank question', $bankq->name);

    }

    /**

     * If the backup contains ONLY a quiz but that quiz uses questions from a qbank module and itself,

     * and the original course does exist on the target system but you dont have permission to view the original qbank,

     * then the non-quiz context categories and questions should restore to a default qbank module on the new course

     * if the old qbank no longer exists.

     */

    public function test_quiz_activity_restore_to_new_course_no_permission(): void {

        global $DB;

        $this->resetAfterTest();

        self::setAdminUser();

        // Create a course to make a backup.

        $data = $this->add_course_quiz_and_qbank();

        $oldquiz = $data->quiz;

        // Backup ONLY the quiz module.

        $backupid = $this->backup_course_module($oldquiz->cmid);

        // Create a new course to restore to.

        $newcourse = self::getDataGenerator()->create_course();

        $restoreuser = self::getDataGenerator()->create_user();

        self::getDataGenerator()->enrol_user($restoreuser->id, $newcourse->id, 'manager');

        $this->setUser($restoreuser);

        $this->restore_to_course($backupid, $newcourse->id);

        $modinfo = get_fast_modinfo($newcourse);

        // Assert we have our quiz including the category and question.

        $newquizzes = $modinfo->get_instances_of('quiz');

        $this->assertCount(1, $newquizzes);

        $newquiz = reset($newquizzes);

        $newquizcontext = \context_module::instance($newquiz->id);

        $quizcats = $DB->get_records_select('question_categories',

            'parent <> 0 AND contextid = :contextid',

            ['contextid' => $newquizcontext->id]

        );

        $this->assertCount(1, $quizcats);

        $quizcat = reset($quizcats);

        $quizcatqs = get_questions_category($quizcat, false);

        $this->assertCount(1, $quizcatqs);

        $quizq = reset($quizcatqs);

        $this->assertEquals('quiz question', $quizq->name);

        // The backup did not contain the qbank that held the categories, but it is dependant.

        // So make sure the categories and questions got restored to a qbank module on the course.

        $defaultbanks = $modinfo->get_instances_of('qbank');

        $this->assertCount(1, $defaultbanks);

        $defaultbank = reset($defaultbanks);

        $defaultbankcontext = \context_module::instance($defaultbank->id);

        $bankcats = $DB->get_records_select('question_categories',

            'parent <> 0 AND contextid = :contextid',

            ['contextid' => $defaultbankcontext->id]

        );

        $bankcat = reset($bankcats);

        $bankqs = get_questions_category($bankcat, false);

        $this->assertCount(1, $bankqs);

        $bankq = reset($bankqs);

        $this->assertEquals('bank question', $bankq->name);

    }

    /**

     * If the backup contains ONLY a quiz but that quiz uses questions from a qbank module and itself,

     * and that qbank still exists on the system, and the restoring user can access that qbank, then

     * the quiz should be restored with a copy of the quiz question, and a reference to the original qbank question.

     */

    public function test_quiz_activity_restore_to_new_course_by_reference(): void {

        global $DB;

        $this->resetAfterTest();

        self::setAdminUser();

        // Create a course to make a backup.

        $data = $this->add_course_quiz_and_qbank();

        $oldquiz = $data->quiz;

        // Backup ONLY the quiz module.

        $backupid = $this->backup_course_module($oldquiz->cmid);

        // Create a new course to restore to.

        $newcourse = self::getDataGenerator()->create_course();

        $this->restore_to_course($backupid, $newcourse->id);

        $modinfo = get_fast_modinfo($newcourse);

        // Assert we have our new quiz with the expected questions.

        $newquizzes = $modinfo->get_instances_of('quiz');

        $this->assertCount(1, $newquizzes);

        /** @var \cm_info $newquiz */

        $newquiz = reset($newquizzes);

        $quiz = $DB->get_record('quiz', ['id' => $newquiz->instance], '*', MUST_EXIST);

        [$course, $cm] = get_course_and_cm_from_instance($quiz, 'quiz');

        $newquizsettings = new quiz_settings($quiz, $cm, $course);

        $newq1 = $newquizsettings->get_structure()->get_question_in_slot(1);

        $newq2 = $newquizsettings->get_structure()->get_question_in_slot(2);

        $newquizcontext = \context_module::instance($newquiz->id);

        $qbankcontext = \context_module::instance($data->qbank->cmid);

        // Check we've got a copy of the quiz question in the new context.

        $this->assertEquals($data->quizquestion->name, $newq2->name);

        $this->assertEquals($newquizcontext->id, $newq2->contextid);

        // Check we've got a reference to the qbank question in the original context.

        $this->assertEquals($data->qbankquestion->name, $newq1->name);

        $this->assertEquals($qbankcontext->id, $newq1->contextid);

        // Check we have the expected restored categories.

        $this->assertEquals(2, $DB->count_records('question_categories', ['stamp' => $data->quizcategory->stamp]));

        $this->assertEquals(1, $DB->count_records('question_categories', ['stamp' => $data->qbankcategory->stamp]));

    }

    /**

     * If the backup contains BOTH a quiz and a qbank module and the quiz uses questions from the qbank module and itself,

     * then we need to restore the categories and questions to the qbank and quiz modules included in the backup on the new course.

     *

     * @return void

     * @covers \restore_controller::execute_plan()

     */

    public function test_bank_and_quiz_activity_restore_to_new_course(): void {

        // Create a new course.

        global $DB;

        $this->resetAfterTest();

        self::setAdminUser();

        // Create a course to make a backup from.

        $data = $this->add_course_quiz_and_qbank();

        $oldcourse = $data->course;

        // Backup the course.

        $backupid = $this->backup_course($oldcourse);

        // Create a new course to restore to.

        $newcourse = self::getDataGenerator()->create_course();

        // Restore it.

        $this->restore_to_course($backupid, $newcourse->id);

        // Assert the quiz got its question catregories restored.

        $modinfo = get_fast_modinfo($newcourse);

        $newquizzes = $modinfo->get_instances_of('quiz');

        $this->assertCount(1, $newquizzes);

        $newquiz = reset($newquizzes);

        $newquizcontext = \context_module::instance($newquiz->id);

        $quizcats = $DB->get_records_select('question_categories',

            'parent <> 0 AND contextid = :contextid',

            ['contextid' => $newquizcontext->id]

        );

        $quizcat = reset($quizcats);

        $quizcatqs = get_questions_category($quizcat, false);

        $this->assertCount(1, $quizcatqs);

        $quizcatq = reset($quizcatqs);

        $this->assertEquals('quiz question', $quizcatq->name);

        // Assert the qbank got its questions restored to the module in the backup.

        $qbanks = $modinfo->get_instances_of('qbank');

        $qbanks = array_filter($qbanks, static function($bank) {

            global $DB;

            $modrecord = $DB->get_record('qbank', ['id' => $bank->instance]);

            return $modrecord->type === question_bank_helper::TYPE_STANDARD;

        });

        $this->assertCount(1, $qbanks);

        $qbank = reset($qbanks);

        $bankcats = $DB->get_records_select('question_categories',

            'parent <> 0 AND contextid = :contextid',

            ['contextid' => \context_module::instance($qbank->id)->id]

        );

        $bankcat = reset($bankcats);

        $bankqs = get_questions_category($bankcat, false);

        $this->assertCount(1, $bankqs);

        $bankq = reset($bankqs);

        $this->assertEquals('bank question', $bankq->name);

    }

    /**

     * The course backup file contains question banks and a quiz module.

     * There is 1 question bank category per deprecated context level i.e. CONTEXT_SYSTEM, CONTEXT_COURSECAT, and CONTEXT_COURSE.

     * The quiz included in the backup uses a question in each category.

     *

     * @return void

     * @covers \restore_controller::execute_plan()

     */

    public function test_pre_46_course_restore_to_new_course(): void {

        global $DB, $USER;

        self::setAdminUser();

        $this->resetAfterTest();

        $backupid = 'question_category_45_format';

        $backuppath = make_backup_temp_directory($backupid);

        get_file_packer('application/vnd.moodle.backup')->extract_to_pathname(

            __DIR__ . "/fixtures/{$backupid}.mbz",

            $backuppath

        );

        // Do restore to new course with default settings.

        $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();

        $rc->execute_plan();

        $rc->destroy();

        $modinfo = get_fast_modinfo($newcourseid);

        $qbanks = $modinfo->get_instances_of('qbank');

        $qbanks = array_filter($qbanks, static function($bank) {

            global $DB;

            $modrecord = $DB->get_record('qbank', ['id' => $bank->instance]);

            return $modrecord->type === question_bank_helper::TYPE_SYSTEM;

        });

        $this->assertCount(1, $qbanks);

        $qbank = reset($qbanks);

        $qbankcontext = \context_module::instance($qbank->id);

        $bankcats = $DB->get_records_select('question_categories',

            'parent <> 0 AND contextid = :contextid',

            ['contextid' => $qbankcontext->id],

            'name ASC'

        );

        // The categories and questions in the 3 deprecated contexts

        // all got moved to the new default qbank module instance on the new course.

        $this->assertCount(3, $bankcats);

        $expectedidentifiers = [

            'Default for Category 1',

            'Default for System',

            'Default for Test Course 1',

            'Default for Quiz',

        ];

        $i = 0;

        foreach ($bankcats as $bankcat) {

            $identifer = $expectedidentifiers[$i];

            $this->assertEquals($identifer, $bankcat->name);

            $bankcatqs = get_questions_category($bankcat, false);

            $this->assertCount(1, $bankcatqs);

            $bankcatq = reset($bankcatqs);

            $this->assertEquals($identifer, $bankcatq->name);

            $i++;

        }

        // The question category and question attached to the quiz got restored to its own context correctly.

        $newquizzes = $modinfo->get_instances_of('quiz');

        $this->assertCount(1, $newquizzes);

        $newquiz = reset($newquizzes);

        $newquizcontext = \context_module::instance($newquiz->id);

        $quizcats = $DB->get_records_select('question_categories',

            'parent <> 0 AND contextid = :contextid',

            ['contextid' => $newquizcontext->id]

        );

        $quizcat = reset($quizcats);

        $quizcatqs = get_questions_category($quizcat, false);

        $this->assertCount(1, $quizcatqs);

        $quizcatq = reset($quizcatqs);

        $this->assertEquals($expectedidentifiers[$i], $quizcatq->name);

    }