Proyectos de Subversion Moodle

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

namespace qtype_missingtype;

use qbehaviour_deferredfeedback;
use qtype_missingtype;
use qtype_missingtype_question;
use question_attempt_step;
use question_bank;
use question_contains_tag_with_attribute;
use question_display_options;
use question_state;
use testable_question_attempt;

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

global $CFG;
require_once(__DIR__ . '/../../../engine/tests/helpers.php');
require_once(__DIR__ . '/../../../behaviour/deferredfeedback/behaviour.php');
require_once(__DIR__ . '/../question.php');
require_once($CFG->dirroot . '/question/type/missingtype/questiontype.php');

/**
 * Unit tests for the 'missing' question type.
 *
 * @package    qtype_missingtype
 * @copyright  2010 The Open University
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
final class missingtype_test extends \question_testcase {

    protected function get_unknown_questiondata() {
        $questiondata = new \stdClass();
        $questiondata->id = 0;
        $questiondata->category = 0;
        $questiondata->contextid = 0;
        $questiondata->parent = 0;
        $questiondata->name = 'Test';
        $questiondata->questiontext = 'This is the question text.';
        $questiondata->questiontextformat = FORMAT_HTML;
        $questiondata->generalfeedback = 'This is the general feedback.';
        $questiondata->generalfeedbackformat = FORMAT_HTML;
        $questiondata->defaultmark = 1;
        $questiondata->penalty = 0.3333333;
        $questiondata->qtype = 'strange_unknown';
        $questiondata->length = 1;
        $questiondata->stamp = make_unique_id_code();
        $questiondata->status = \core_question\local\bank\question_version_status::QUESTION_STATUS_READY;
        $questiondata->version = 1;
        $questiondata->versionid = 0;
        $questiondata->questionbankentryid = 0;
        $questiondata->idnumber = null;
        $questiondata->timecreated = 0;
        $questiondata->timemodified = 0;
        $questiondata->createdby = 0;
        $questiondata->modifiedby = 0;

        return $questiondata;
    }

    public function test_cannot_grade(): void {
        $q = new qtype_missingtype_question();
        $this->expectException(\moodle_exception::class);
        $q->grade_response(array());
    }

    public function test_load_qtype_strict(): void {
        $this->expectException(\moodle_exception::class);
        $qtype = question_bank::get_qtype('strange_unknown');
    }

    public function test_load_qtype_lax(): void {
        $qtype = question_bank::get_qtype('strange_unknown', false);
        $this->assertInstanceOf('qtype_missingtype', $qtype);
    }

    public function test_make_question(): void {
        $questiondata = $this->get_unknown_questiondata();
        $q = question_bank::make_question($questiondata);
        $this->assertInstanceOf('qtype_missingtype_question', $q);
        $this->assertEquals($q->questiontext, \html_writer::tag('div',
                get_string('missingqtypewarning', 'qtype_missingtype'),
                array('class' => 'warning missingqtypewarning')) .
                $questiondata->questiontext);
    }

    public function test_render_missing(): void {
        $questiondata = $this->get_unknown_questiondata();
        $q = question_bank::make_question($questiondata);
        $qa = new testable_question_attempt($q, 0);

        $step = new question_attempt_step(array('answer' => 'frog'));
        $step->set_state(question_state::$todo);
        $qa->add_step($step);
        $qa->set_behaviour(new qbehaviour_deferredfeedback($qa, 'deferredfeedback'));

        $output = $qa->render(new question_display_options(), '1');

        $this->assertMatchesRegularExpression('/' .
                preg_quote($qa->get_question(false)->questiontext, '/') . '/', $output);
        $this->assertMatchesRegularExpression('/' .
                preg_quote(get_string('missingqtypewarning', 'qtype_missingtype'), '/') . '/', $output);
        $this->assert(new question_contains_tag_with_attribute(
                'div', 'class', 'warning missingqtypewarning'), $output);
    }

    public function test_get_question_summary(): void {
        $q = new qtype_missingtype_question();
        $q->questiontext = '<b>Test</b>';
        $this->assertEquals('TEST', $q->get_question_summary());
    }

    public function test_summarise_response(): void {
        $q = new qtype_missingtype_question();
        $this->assertNull($q->summarise_response(array('a' => 'irrelevant')));
    }

    public function test_can_analyse_responses(): void {
        $qtype = new qtype_missingtype();
        $this->assertFalse($qtype->can_analyse_responses());
    }

    public function test_get_random_guess_score(): void {
        $qtype = new qtype_missingtype();
        $this->assertNull($qtype->get_random_guess_score(null));
    }

    public function test_get_possible_responses(): void {
        $qtype = new qtype_missingtype();
        $this->assertEquals(array(), $qtype->get_possible_responses(null));
    }

    /**
     * Test moving a question category from one context to another when it contains questions of an invalid type
     *
     * @covers ::question_move_category_to_context
     */
    public function test_move_question_category_with_missing_question_types(): void {

        global $DB;

        $this->resetAfterTest();

        // Create a course we can move the category to.
        $course = $this->getDataGenerator()->create_course();

        // Create a quiz module to attach the question category to.
        $module1 = $this->getDataGenerator()->create_module('quiz', ['course' => $course->id]);

        // And another one to move things to.
        $module2 = $this->getDataGenerator()->create_module('quiz', ['course' => $course->id]);

        // Create a question category on the system context.
        $generator = $this->getDataGenerator()->get_plugin_generator('core_question');
        $category = $generator->create_question_category([
            'contextid' => \core\context\module::instance($module1->cmid)->id,
        ]);

        // Create a question of an invalid type and put it in the category.
        $question = $generator->create_question('missingtype', null, ['category' => $category->id]);

        // Update the question to set an invalid qtype, as "missingtype" is actually installed and won't fail.
        $question->qtype = 'invalid';
        $DB->update_record('question', $question);

        // We just want to assert that no exception is thrown.
        $this->expectNotToPerformAssertions();

        // Try and move the categories.
        question_move_category_to_context(
            $category->id,
            \core\context\module::instance($module1->cmid)->id,
            \core\context\module::instance($module2->cmid)->id,
        );

    }

}