helpers.php 53.3 KB
Newer Older
Petr Skoda's avatar
Petr Skoda committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?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/>.

/**
 * This file contains helper classes for testing the question engine.
 *
 * @package    moodlecore
 * @subpackage questionengine
 * @copyright  2009 The Open University
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */


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

global $CFG;
30
31
require_once(__DIR__ . '/../lib.php');
require_once($CFG->dirroot . '/lib/phpunit/lib.php');
Petr Skoda's avatar
Petr Skoda committed
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


/**
 * Makes some protected methods of question_attempt public to facilitate testing.
 *
 * @copyright  2009 The Open University
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class testable_question_attempt extends question_attempt {
    public function add_step(question_attempt_step $step) {
        parent::add_step($step);
    }
    public function set_min_fraction($fraction) {
        $this->minfraction = $fraction;
    }
47
48
49
    public function set_max_fraction($fraction) {
        $this->maxfraction = $fraction;
    }
Petr Skoda's avatar
Petr Skoda committed
50
51
52
53
54
55
    public function set_behaviour(question_behaviour $behaviour) {
        $this->behaviour = $behaviour;
    }
}


56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/**
 * Test subclass to allow access to some protected data so that the correct
 * behaviour can be verified.
 *
 * @copyright  2012 The Open University
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class testable_question_engine_unit_of_work extends question_engine_unit_of_work {
    public function get_modified() {
        return $this->modified;
    }

    public function get_attempts_added() {
        return $this->attemptsadded;
    }

    public function get_attempts_modified() {
        return $this->attemptsmodified;
    }

    public function get_steps_added() {
        return $this->stepsadded;
    }

    public function get_steps_modified() {
        return $this->stepsmodified;
    }

    public function get_steps_deleted() {
        return $this->stepsdeleted;
    }
87
88
89
90
91
92
93
94

    public function get_metadata_added() {
        return $this->metadataadded;
    }

    public function get_metadata_modified() {
        return $this->metadatamodified;
    }
95
96
97
}


Petr Skoda's avatar
Petr Skoda committed
98
99
100
101
102
103
104
105
106
107
108
109
110
/**
 * Base class for question type test helpers.
 *
 * @copyright  2011 The Open University
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
abstract class question_test_helper {
    /**
     * @return array of example question names that can be passed as the $which
     * argument of {@link test_question_maker::make_question} when $qtype is
     * this question type.
     */
    abstract public function get_test_questions();
Jamie Pratt's avatar
Jamie Pratt committed
111
112
113
114
115
116
117
118
119
120
121

    /**
     * Set up a form to create a question in $cat. This method also sets cat and contextid on $questiondata object.
     * @param object $cat the category
     * @param object $questiondata form initialisation requires question data.
     * @return moodleform
     */
    public static function get_question_editing_form($cat, $questiondata) {
        $catcontext = context::instance_by_id($cat->contextid, MUST_EXIST);
        $contexts = new question_edit_contexts($catcontext);
        $dataforformconstructor = new stdClass();
122
        $dataforformconstructor->createdby = $questiondata->createdby;
Jamie Pratt's avatar
Jamie Pratt committed
123
124
125
126
127
128
129
130
131
132
133
        $dataforformconstructor->qtype = $questiondata->qtype;
        $dataforformconstructor->contextid = $questiondata->contextid = $catcontext->id;
        $dataforformconstructor->category = $questiondata->category = $cat->id;
        $dataforformconstructor->formoptions = new stdClass();
        $dataforformconstructor->formoptions->canmove = true;
        $dataforformconstructor->formoptions->cansaveasnew = true;
        $dataforformconstructor->formoptions->canedit = true;
        $dataforformconstructor->formoptions->repeatelements = true;
        $qtype = question_bank::get_qtype($questiondata->qtype);
        return  $qtype->create_editing_form('question.php', $dataforformconstructor, $cat, $contexts, true);
    }
Petr Skoda's avatar
Petr Skoda committed
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
}


/**
 * This class creates questions of various types, which can then be used when
 * testing.
 *
 * @copyright  2009 The Open University
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class test_question_maker {
    const STANDARD_OVERALL_CORRECT_FEEDBACK = 'Well done!';
    const STANDARD_OVERALL_PARTIALLYCORRECT_FEEDBACK =
        'Parts, but only parts, of your response are correct.';
    const STANDARD_OVERALL_INCORRECT_FEEDBACK = 'That is not right at all.';

    /** @var array qtype => qtype test helper class. */
    protected static $testhelpers = array();

    /**
     * Just make a question_attempt at a question. Useful for unit tests that
     * need to pass a $qa to methods that call format_text. Probably not safe
     * to use for anything beyond that.
     * @param question_definition $question a question.
     * @param number $maxmark the max mark to set.
     * @return question_attempt the question attempt.
     */
    public static function get_a_qa($question, $maxmark = 3) {
        return new question_attempt($question, 13, null, $maxmark);
    }

    /**
     * Initialise the common fields of a question of any type.
     */
    public static function initialise_a_question($q) {
        global $USER;

        $q->id = 0;
        $q->category = 0;
173
        $q->idnumber = null;
Petr Skoda's avatar
Petr Skoda committed
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
        $q->parent = 0;
        $q->questiontextformat = FORMAT_HTML;
        $q->generalfeedbackformat = FORMAT_HTML;
        $q->defaultmark = 1;
        $q->penalty = 0.3333333;
        $q->length = 1;
        $q->stamp = make_unique_id_code();
        $q->version = make_unique_id_code();
        $q->hidden = 0;
        $q->timecreated = time();
        $q->timemodified = time();
        $q->createdby = $USER->id;
        $q->modifiedby = $USER->id;
    }

    public static function initialise_question_data($qdata) {
        global $USER;

        $qdata->id = 0;
        $qdata->category = 0;
194
        $qdata->idnumber = null;
Petr Skoda's avatar
Petr Skoda committed
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
        $qdata->contextid = 0;
        $qdata->parent = 0;
        $qdata->questiontextformat = FORMAT_HTML;
        $qdata->generalfeedbackformat = FORMAT_HTML;
        $qdata->defaultmark = 1;
        $qdata->penalty = 0.3333333;
        $qdata->length = 1;
        $qdata->stamp = make_unique_id_code();
        $qdata->version = make_unique_id_code();
        $qdata->hidden = 0;
        $qdata->timecreated = time();
        $qdata->timemodified = time();
        $qdata->createdby = $USER->id;
        $qdata->modifiedby = $USER->id;
        $qdata->hints = array();
    }

    /**
     * Get the test helper class for a particular question type.
     * @param $qtype the question type name, e.g. 'multichoice'.
     * @return question_test_helper the test helper class.
     */
    public static function get_test_helper($qtype) {
        global $CFG;

        if (array_key_exists($qtype, self::$testhelpers)) {
            return self::$testhelpers[$qtype];
        }

224
        $file = core_component::get_plugin_directory('qtype', $qtype) . '/tests/helper.php';
Petr Skoda's avatar
Petr Skoda committed
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
        if (!is_readable($file)) {
            throw new coding_exception('Question type ' . $qtype .
                ' does not have test helper code.');
        }
        include_once($file);

        $class = 'qtype_' . $qtype . '_test_helper';
        if (!class_exists($class)) {
            throw new coding_exception('Class ' . $class . ' is not defined in ' . $file);
        }

        self::$testhelpers[$qtype] = new $class();
        return self::$testhelpers[$qtype];
    }

    /**
     * Call a method on a qtype_{$qtype}_test_helper class and return the result.
     *
     * @param string $methodtemplate e.g. 'make_{qtype}_question_{which}';
     * @param string $qtype the question type to get a test question for.
     * @param string $which one of the names returned by the get_test_questions
     *      method of the relevant qtype_{$qtype}_test_helper class.
     * @param unknown_type $which
     */
    protected static function call_question_helper_method($methodtemplate, $qtype, $which = null) {
        $helper = self::get_test_helper($qtype);

        $available = $helper->get_test_questions();

        if (is_null($which)) {
            $which = reset($available);
        } else if (!in_array($which, $available)) {
            throw new coding_exception('Example question ' . $which . ' of type ' .
                $qtype . ' does not exist.');
        }

        $method = str_replace(array('{qtype}', '{which}'),
            array($qtype,    $which), $methodtemplate);

        if (!method_exists($helper, $method)) {
265
            throw new coding_exception('Method ' . $method . ' does not exist on the ' .
Petr Skoda's avatar
Petr Skoda committed
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
                $qtype . ' question type test helper class.');
        }

        return $helper->$method();
    }

    /**
     * Question types can provide a number of test question defintions.
     * They do this by creating a qtype_{$qtype}_test_helper class that extends
     * question_test_helper. The get_test_questions method returns the list of
     * test questions available for this question type.
     *
     * @param string $qtype the question type to get a test question for.
     * @param string $which one of the names returned by the get_test_questions
     *      method of the relevant qtype_{$qtype}_test_helper class.
     * @return question_definition the requested question object.
     */
    public static function make_question($qtype, $which = null) {
        return self::call_question_helper_method('make_{qtype}_question_{which}',
            $qtype, $which);
    }

    /**
     * Like {@link make_question()} but returns the datastructure from
     * get_question_options instead of the question_definition object.
     *
     * @param string $qtype the question type to get a test question for.
     * @param string $which one of the names returned by the get_test_questions
     *      method of the relevant qtype_{$qtype}_test_helper class.
     * @return stdClass the requested question object.
     */
    public static function get_question_data($qtype, $which = null) {
        return self::call_question_helper_method('get_{qtype}_question_data_{which}',
            $qtype, $which);
    }

    /**
     * Like {@link make_question()} but returns the data what would be saved from
     * the question editing form instead of the question_definition object.
     *
     * @param string $qtype the question type to get a test question for.
     * @param string $which one of the names returned by the get_test_questions
     *      method of the relevant qtype_{$qtype}_test_helper class.
     * @return stdClass the requested question object.
     */
    public static function get_question_form_data($qtype, $which = null) {
        return self::call_question_helper_method('get_{qtype}_question_form_data_{which}',
            $qtype, $which);
    }

    /**
     * Makes a multichoice question with choices 'A', 'B' and 'C' shuffled. 'A'
     * is correct, defaultmark 1.
     * @return qtype_multichoice_single_question
     */
    public static function make_a_multichoice_single_question() {
        question_bank::load_question_definition_classes('multichoice');
        $mc = new qtype_multichoice_single_question();
        self::initialise_a_question($mc);
        $mc->name = 'Multi-choice question, single response';
        $mc->questiontext = 'The answer is A.';
        $mc->generalfeedback = 'You should have selected A.';
        $mc->qtype = question_bank::get_qtype('multichoice');

        $mc->shuffleanswers = 1;
        $mc->answernumbering = 'abc';
332
        $mc->showstandardinstruction = 0;
Petr Skoda's avatar
Petr Skoda committed
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358

        $mc->answers = array(
            13 => new question_answer(13, 'A', 1, 'A is right', FORMAT_HTML),
            14 => new question_answer(14, 'B', -0.3333333, 'B is wrong', FORMAT_HTML),
            15 => new question_answer(15, 'C', -0.3333333, 'C is wrong', FORMAT_HTML),
        );

        return $mc;
    }

    /**
     * Makes a multichoice question with choices 'A', 'B', 'C' and 'D' shuffled.
     * 'A' and 'C' is correct, defaultmark 1.
     * @return qtype_multichoice_multi_question
     */
    public static function make_a_multichoice_multi_question() {
        question_bank::load_question_definition_classes('multichoice');
        $mc = new qtype_multichoice_multi_question();
        self::initialise_a_question($mc);
        $mc->name = 'Multi-choice question, multiple response';
        $mc->questiontext = 'The answer is A and C.';
        $mc->generalfeedback = 'You should have selected A and C.';
        $mc->qtype = question_bank::get_qtype('multichoice');

        $mc->shuffleanswers = 1;
        $mc->answernumbering = 'abc';
359
        $mc->showstandardinstruction = 0;
Petr Skoda's avatar
Petr Skoda committed
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379

        self::set_standard_combined_feedback_fields($mc);

        $mc->answers = array(
            13 => new question_answer(13, 'A', 0.5, 'A is part of the right answer', FORMAT_HTML),
            14 => new question_answer(14, 'B', -1, 'B is wrong', FORMAT_HTML),
            15 => new question_answer(15, 'C', 0.5, 'C is part of the right answer', FORMAT_HTML),
            16 => new question_answer(16, 'D', -1, 'D is wrong', FORMAT_HTML),
        );

        return $mc;
    }

    /**
     * Makes a matching question to classify 'Dog', 'Frog', 'Toad' and 'Cat' as
     * 'Mammal', 'Amphibian' or 'Insect'.
     * defaultmark 1. Stems are shuffled by default.
     * @return qtype_match_question
     */
    public static function make_a_matching_question() {
380
        return self::make_question('match');
Petr Skoda's avatar
Petr Skoda committed
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
    }

    /**
     * Makes a truefalse question with correct ansewer true, defaultmark 1.
     * @return qtype_essay_question
     */
    public static function make_an_essay_question() {
        question_bank::load_question_definition_classes('essay');
        $essay = new qtype_essay_question();
        self::initialise_a_question($essay);
        $essay->name = 'Essay question';
        $essay->questiontext = 'Write an essay.';
        $essay->generalfeedback = 'I hope you wrote an interesting essay.';
        $essay->penalty = 0;
        $essay->qtype = question_bank::get_qtype('essay');

        $essay->responseformat = 'editor';
398
        $essay->responserequired = 1;
Petr Skoda's avatar
Petr Skoda committed
399
400
        $essay->responsefieldlines = 15;
        $essay->attachments = 0;
401
402
403
        $essay->attachmentsrequired = 0;
        $essay->responsetemplate = '';
        $essay->responsetemplateformat = FORMAT_MOODLE;
Petr Skoda's avatar
Petr Skoda committed
404
405
406
407
408
409
410
411
412
413
        $essay->graderinfo = '';
        $essay->graderinfoformat = FORMAT_MOODLE;

        return $essay;
    }

    /**
     * Add some standard overall feedback to a question. You need to use these
     * specific feedback strings for the corresponding contains_..._feedback
     * methods in {@link qbehaviour_walkthrough_test_base} to works.
414
     * @param question_definition|stdClass $q the question to add the feedback to.
Petr Skoda's avatar
Petr Skoda committed
415
416
417
418
419
420
421
422
423
424
     */
    public static function set_standard_combined_feedback_fields($q) {
        $q->correctfeedback = self::STANDARD_OVERALL_CORRECT_FEEDBACK;
        $q->correctfeedbackformat = FORMAT_HTML;
        $q->partiallycorrectfeedback = self::STANDARD_OVERALL_PARTIALLYCORRECT_FEEDBACK;
        $q->partiallycorrectfeedbackformat = FORMAT_HTML;
        $q->shownumcorrect = true;
        $q->incorrectfeedback = self::STANDARD_OVERALL_INCORRECT_FEEDBACK;
        $q->incorrectfeedbackformat = FORMAT_HTML;
    }
Jamie Pratt's avatar
Jamie Pratt committed
425
426
427
428
429
430
431
432
433
434
435
436
437

    /**
     * Add some standard overall feedback to a question's form data.
     */
    public static function set_standard_combined_feedback_form_data($form) {
        $form->correctfeedback = array('text' => self::STANDARD_OVERALL_CORRECT_FEEDBACK,
                                    'format' => FORMAT_HTML);
        $form->partiallycorrectfeedback = array('text' => self::STANDARD_OVERALL_PARTIALLYCORRECT_FEEDBACK,
                                             'format' => FORMAT_HTML);
        $form->shownumcorrect = true;
        $form->incorrectfeedback = array('text' => self::STANDARD_OVERALL_INCORRECT_FEEDBACK,
                                    'format' => FORMAT_HTML);
    }
Petr Skoda's avatar
Petr Skoda committed
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
}


/**
 * Helper for tests that need to simulate records loaded from the database.
 *
 * @copyright  2009 The Open University
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
abstract class testing_db_record_builder {
    public static function build_db_records(array $table) {
        $columns = array_shift($table);
        $records = array();
        foreach ($table as $row) {
            if (count($row) != count($columns)) {
                throw new coding_exception("Row contains the wrong number of fields.");
            }
            $rec = new stdClass();
            foreach ($columns as $i => $name) {
                $rec->$name = $row[$i];
            }
            $records[] = $rec;
        }
        return $records;
    }
}


/**
 * Helper base class for tests that need to simulate records loaded from the
 * database.
 *
 * @copyright  2009 The Open University
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
473
abstract class data_loading_method_test_base extends advanced_testcase {
Petr Skoda's avatar
Petr Skoda committed
474
475
476
477
478
479
    public function build_db_records(array $table) {
        return testing_db_record_builder::build_db_records($table);
    }
}


480
abstract class question_testcase extends advanced_testcase {
Petr Skoda's avatar
Petr Skoda committed
481

482
    public function assert($expectation, $compare, $notused = '') {
Petr Skoda's avatar
Petr Skoda committed
483
484

        if (get_class($expectation) === 'question_pattern_expectation') {
485
486
            $this->assertRegExp($expectation->pattern, $compare,
                    'Expected regex ' . $expectation->pattern . ' not found in ' . $compare);
Petr Skoda's avatar
Petr Skoda committed
487
488
489
            return;

        } else if (get_class($expectation) === 'question_no_pattern_expectation') {
490
491
            $this->assertNotRegExp($expectation->pattern, $compare,
                    'Unexpected regex ' . $expectation->pattern . ' found in ' . $compare);
Petr Skoda's avatar
Petr Skoda committed
492
493
494
            return;

        } else if (get_class($expectation) === 'question_contains_tag_with_attributes') {
495
496
            $this->assertTag(array('tag'=>$expectation->tag, 'attributes'=>$expectation->expectedvalues), $compare,
                    'Looking for a ' . $expectation->tag . ' with attributes ' . html_writer::attributes($expectation->expectedvalues) . ' in ' . $compare);
Petr Skoda's avatar
Petr Skoda committed
497
498
499
            foreach ($expectation->forbiddenvalues as $k=>$v) {
                $attr = $expectation->expectedvalues;
                $attr[$k] = $v;
500
501
                $this->assertNotTag(array('tag'=>$expectation->tag, 'attributes'=>$attr), $compare,
                        $expectation->tag . ' had a ' . $k . ' attribute that should not be there in ' . $compare);
Petr Skoda's avatar
Petr Skoda committed
502
503
504
505
506
            }
            return;

        } else if (get_class($expectation) === 'question_contains_tag_with_attribute') {
            $attr = array($expectation->attribute=>$expectation->value);
507
508
            $this->assertTag(array('tag'=>$expectation->tag, 'attributes'=>$attr), $compare,
                    'Looking for a ' . $expectation->tag . ' with attribute ' . html_writer::attributes($attr) . ' in ' . $compare);
Petr Skoda's avatar
Petr Skoda committed
509
510
511
            return;

        } else if (get_class($expectation) === 'question_does_not_contain_tag_with_attributes') {
512
513
            $this->assertNotTag(array('tag'=>$expectation->tag, 'attributes'=>$expectation->attributes), $compare,
                    'Unexpected ' . $expectation->tag . ' with attributes ' . html_writer::attributes($expectation->attributes) . ' found in ' . $compare);
Petr Skoda's avatar
Petr Skoda committed
514
515
516
517
518
            return;

        } else if (get_class($expectation) === 'question_contains_select_expectation') {
            $tag = array('tag'=>'select', 'attributes'=>array('name'=>$expectation->name),
                'children'=>array('count'=>count($expectation->choices)));
519
            if ($expectation->enabled === false) {
Petr Skoda's avatar
Petr Skoda committed
520
                $tag['attributes']['disabled'] = 'disabled';
521
522
            } else if ($expectation->enabled === true) {
                // TODO
Petr Skoda's avatar
Petr Skoda committed
523
524
525
526
527
528
529
530
            }
            foreach(array_keys($expectation->choices) as $value) {
                if ($expectation->selected === $value) {
                    $tag['child'] = array('tag'=>'option', 'attributes'=>array('value'=>$value, 'selected'=>'selected'));
                } else {
                    $tag['child'] = array('tag'=>'option', 'attributes'=>array('value'=>$value));
                }
            }
531
532

            $this->assertTag($tag, $compare, 'expected select not found in ' . $compare);
Petr Skoda's avatar
Petr Skoda committed
533
534
535
536
537
538
539
            return;

        } else if (get_class($expectation) === 'question_check_specified_fields_expectation') {
            $expect = (array)$expectation->expect;
            $compare = (array)$compare;
            foreach ($expect as $k=>$v) {
                if (!array_key_exists($k, $compare)) {
540
                    $this->fail("Property {$k} does not exist");
Petr Skoda's avatar
Petr Skoda committed
541
542
                }
                if ($v != $compare[$k]) {
543
                    $this->fail("Property {$k} is different");
Petr Skoda's avatar
Petr Skoda committed
544
545
546
547
548
549
                }
            }
            $this->assertTrue(true);
            return;

        } else if (get_class($expectation) === 'question_contains_tag_with_contents') {
550
551
            $this->assertTag(array('tag'=>$expectation->tag, 'content'=>$expectation->content), $compare,
                    'Looking for a ' . $expectation->tag . ' with content ' . $expectation->content . ' in ' . $compare);
Petr Skoda's avatar
Petr Skoda committed
552
553
554
555
556
            return;
        }

        throw new coding_exception('Unknown expectiontion:'.get_class($expectation));
    }
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598

    /**
     * Use this function rather than assert when checking the value of options within a select element.
     *
     * @param question_contains_select_expectation $expectation The select expectation class
     * @param string $html The rendered output to check against
     */
    public function assert_select_options($expectation, $html) {
        if (get_class($expectation) !== 'question_contains_select_expectation') {
            throw new coding_exception('Unsuitable expectiontion: '.get_class($expectation));
        }
        $dom = new DOMDocument();
        $dom->loadHTML($html);
        $selects = $dom->getElementsByTagName('select');
        foreach ($selects as $select) {
            if ($select->getAttribute('name') == $expectation->name) {
                $options = $select->getElementsByTagName('option');
                foreach ($options as $key => $option) {
                    if ($key == 0) {
                        // Check the value of the first option. This is often 'Choose...' or a nbsp.
                        // Note it is necessary to pass a nbsp character in the test here and not just ' '.
                        // Many tests do not require checking of this option.
                        if (isset($expectation->choices[$option->getAttribute('value')])) {
                            $this->assertEquals($expectation->choices[$option->getAttribute('value')], $option->textContent);
                        }
                        continue;
                    }
                    // Check the value of the options in the select.
                    $this->assertEquals($expectation->choices[$option->getAttribute('value')], $option->textContent);
                    if ($expectation->selected && $option->getAttribute('value') == $expectation->selected) {
                        // Check the right option is selected.
                        $this->assertTrue(!empty($option->getAttribute('selected')));
                    }
                }
                if ($expectation->enabled) {
                    // Check the select element is enabled.
                    $this->assertTrue(!$select->getAttribute('disabled'));
                }
            }
        }
        return;
    }
Petr Skoda's avatar
Petr Skoda committed
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
}


class question_contains_tag_with_contents {
    public $tag;
    public $content;
    public $message;

    public function __construct($tag, $content, $message = '') {
        $this->tag = $tag;
        $this->content = $content;
        $this->message = $message;
    }

}

class question_check_specified_fields_expectation {
    public $expect;
    public $message;

    function __construct($expected, $message = '') {
        $this->expect = $expected;
        $this->message = $message;
    }
}


class question_contains_select_expectation {
    public $name;
    public $choices;
    public $selected;
    public $enabled;
    public $message;

    public function __construct($name, $choices, $selected = null, $enabled = null, $message = '') {
        $this->name = $name;
        $this->choices = $choices;
        $this->selected = $selected;
        $this->enabled = $enabled;
        $this->message = $message;
    }
}


class question_does_not_contain_tag_with_attributes {
    public $tag;
    public $attributes;
    public $message;

    public function __construct($tag, $attributes, $message = '') {
        $this->tag = $tag;
        $this->attributes = $attributes;
        $this->message = $message;
    }
}


class question_contains_tag_with_attribute {
    public $tag;
    public $attribute;
    public $value;
    public $message;

    public function __construct($tag, $attribute, $value, $message = '') {
        $this->tag = $tag;
        $this->attribute = $attribute;
        $this->value = $value;
        $this->message = $message;
    }
}


class question_contains_tag_with_attributes {
    public $tag;
    public $expectedvalues = array();
    public $forbiddenvalues = array();
    public $message;

    public function __construct($tag, $expectedvalues, $forbiddenvalues=array(), $message = '') {
        $this->tag = $tag;
        $this->expectedvalues = $expectedvalues;
        $this->forbiddenvalues = $forbiddenvalues;
        $this->message = $message;
    }
}


class question_pattern_expectation {
    public $pattern;
    public $message;

    public function __construct($pattern, $message = '') {
        $this->pattern = $pattern;
        $this->message = $message;
    }
}


class question_no_pattern_expectation {
    public $pattern;
    public $message;

    public function __construct($pattern, $message = '') {
        $this->pattern = $pattern;
        $this->message = $message;
    }
}


/**
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
 * Helper base class for question walk-through tests.
 *
 * The purpose of tests that use this base class is to simulate the entire
 * interaction of a student making an attempt at a question. Therefore,
 * these are not really unit tests. They would more accurately be described
 * as integration tests. However, whether they are unit tests or not,
 * it works well to implement them in PHPUnit.
 *
 * Historically, tests like this were made because Moodle did not have anything
 * like Behat for end-to-end testing. Even though we do now have Behat, it makes
 * sense to keep these walk-through tests. They run massively faster than Behat
 * tests, which gives you a much faster feedback loop while doing development.
 * They also make it quite easy to test things like regrading the attempt after
 * the question has been edited, which would be possible but very fiddly in Behat.
 *
 * Ideally, the full set of tests for the question class of a question type would be:
 *
 * 1. A lot of unit tests for each qtype_myqtype_question class method
 *    like grade_response, is_complete_response, is_same_response, ...
 *
 * 2. Several of these walk-through tests, to test the end-to-end interaction
 *    of a student with a question, for example with different behaviours.
 *
 * 3. Just one Behat test, using question preview, to verify that everything
 *    is plugged together correctly and works when used through the UI.
 *
 * What one would expect to see in one of these walk-through tests is:
 *
 * // 1. Set up a question: $q.
 *
 * // 2. A call to $this->start_attempt_at_question($q, ...); with the relevant options.
 *
 * // 3. Some number of calls to $this->process_submission passing an array of simulated
 * //    POST data that matches what would be sent back be submitting a form that contains
 * //    the form fields that are output by rendering the question. This is like clicking
 * //    the 'Check' button in a question, or navigating to the next page in a quiz.
 *
 * // 4. A call to $this->finish(); which is the equivalent of clicking
 * //    'Submit all and finish' in the quiz.
 *
 * // 5. After each of steps 2-4 above, one would expect to see a certain amount of
 * //    validation of the state of the question and how the question is rendered,
 * //    using methods like $this->check_current_state(), $this->check_current_output, etc.
 *
 * The best way to work out how to write tests like this is probably to look at
 * some examples in other question types or question behaviours.
 *
 * In writing these tests, it is worth noting the following points:
 *
 * a) The easiest mistake to make is at step 3. You need to ensure that your
 *    simulated post data actually matches what gets sent back when the
 *    question is submitted in the browser. Try checking it against the
 *    HTTP POST requests you see in your browser when the question is submitted.
 *    Some question types have a $q->prepare_simulated_post_data() method that
 *    can help with this.
 *
 * b) In the past, tests like these used to contain even more repetitive code,
 *    and so they were re-factored to add the helper methods like
 *    start_attempt_at_question, process_submission, finish. That change had
 *    good effects, like reducing duplicate code. However, there were down-sides.
 *    The extra layers of indirection hide what is going on, which means these
 *    tests are harder to understand until you know what the helpers are doing.
 *    If you want an interesting exercise, take one of the walk-through tests,
 *    and inline all the helpers. This might be a good way to understand more about
 *    the question engine API. However, having made the everything-inlined code
 *    and learned from the process, you should then just throw it away.
 *
 * c) The way check_current_output works is weird. When these tests were first written
 *    Moodle used SimpleTest for unit tests and check_current_output os written in a
 *    style that made sense there. When we moved to PHPUnit, a quick and dirty
 *    conversion was done. That was a pragmatic move at the time, and we just have
 *    to live with the result. Sorry. (And: don't copy that style for new things.)
Petr Skoda's avatar
Petr Skoda committed
781
782
783
784
 *
 * @copyright  2009 The Open University
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
785
abstract class qbehaviour_walkthrough_test_base extends question_testcase {
Petr Skoda's avatar
Petr Skoda committed
786
787
788
789
    /** @var question_display_options */
    protected $displayoptions;
    /** @var question_usage_by_activity */
    protected $quba;
790
791
    /** @var integer */

Petr Skoda's avatar
Petr Skoda committed
792
    protected $slot;
793
794
795
796
797
    /**
     * @var string after {@link render()} has been called, this contains the
     * display of the question in its current state.
     */
    protected $currentoutput = '';
Petr Skoda's avatar
Petr Skoda committed
798
799
800
801
802
803
804

    protected function setUp() {
        parent::setUp();
        $this->resetAfterTest(true);

        $this->displayoptions = new question_display_options();
        $this->quba = question_engine::make_questions_usage_by_activity('unit_test',
805
            context_system::instance());
Petr Skoda's avatar
Petr Skoda committed
806
807
808
809
810
811
812
813
814
815
816
817
818
819
    }

    protected function tearDown() {
        $this->displayoptions = null;
        $this->quba = null;
        parent::tearDown();
    }

    protected function start_attempt_at_question($question, $preferredbehaviour,
                                                 $maxmark = null, $variant = 1) {
        $this->quba->set_preferred_behaviour($preferredbehaviour);
        $this->slot = $this->quba->add_question($question, $maxmark);
        $this->quba->start_question($this->slot, $variant);
    }
820

821
822
823
824
825
826
    /**
     * Convert an array of data destined for one question to the equivalent POST data.
     * @param array $data the data for the quetsion.
     * @return array the complete post data.
     */
    protected function response_data_to_post($data) {
827
828
829
        $prefix = $this->quba->get_field_prefix($this->slot);
        $fulldata = array(
            'slots' => $this->slot,
830
            $prefix . ':sequencecheck' => $this->get_question_attempt()->get_sequence_check_count(),
831
832
833
834
        );
        foreach ($data as $name => $value) {
            $fulldata[$prefix . $name] = $value;
        }
835
836
837
838
839
840
841
842
843
844
845
        return $fulldata;
    }

    protected function process_submission($data) {
        // Backwards compatibility.
        reset($data);
        if (count($data) == 1 && key($data) === '-finish') {
            $this->finish();
        }

        $this->quba->process_all_actions(time(), $this->response_data_to_post($data));
846
847
848
    }

    protected function process_autosave($data) {
849
        $this->quba->process_all_autosaves(null, $this->response_data_to_post($data));
850
851
852
853
    }

    protected function finish() {
        $this->quba->finish_all_questions();
Petr Skoda's avatar
Petr Skoda committed
854
855
    }

856
857
    protected function manual_grade($comment, $mark, $commentformat = null) {
        $this->quba->manual_grade($this->slot, $comment, $mark, $commentformat);
Petr Skoda's avatar
Petr Skoda committed
858
859
    }

860
861
862
863
864
865
866
867
868
869
870
871
872
    protected function save_quba(moodle_database $db = null) {
        question_engine::save_questions_usage_by_activity($this->quba, $db);
    }

    protected function load_quba(moodle_database $db = null) {
        $this->quba = question_engine::load_questions_usage_by_activity($this->quba->get_id(), $db);
    }

    protected function delete_quba() {
        question_engine::delete_questions_usage_by_activity($this->quba->get_id());
        $this->quba = null;
    }

873
874
875
876
877
878
879
880
881
882
883
884
885
886
    /**
     * Asserts if the manual comment for the question is equal to the provided arguments.
     * @param $comment Comment text
     * @param $commentformat Comment format
     */
    protected function check_comment($comment, $commentformat) {
        $actualcomment = $this->quba->get_question_attempt($this->slot)->get_manual_comment();

        $this->assertEquals(
                [$comment, $commentformat],
                [$actualcomment[0], $actualcomment[1]]
        );
    }

Petr Skoda's avatar
Petr Skoda committed
887
    protected function check_current_state($state) {
888
889
        $this->assertEquals($state, $this->quba->get_question_state($this->slot),
            'Questions is in the wrong state.');
Petr Skoda's avatar
Petr Skoda committed
890
891
892
893
894
895
896
897
898
899
900
901
    }

    protected function check_current_mark($mark) {
        if (is_null($mark)) {
            $this->assertNull($this->quba->get_question_mark($this->slot));
        } else {
            if ($mark == 0) {
                // PHP will think a null mark and a mark of 0 are equal,
                // so explicity check not null in this case.
                $this->assertNotNull($this->quba->get_question_mark($this->slot));
            }
            $this->assertEquals($mark, $this->quba->get_question_mark($this->slot),
902
                'Expected mark and actual mark differ.', 0.000001);
Petr Skoda's avatar
Petr Skoda committed
903
904
905
        }
    }

906
907
908
909
910
911
912
913
    /**
     * Generate the HTML rendering of the question in its current state in
     * $this->currentoutput so that it can be verified.
     */
    protected function render() {
        $this->currentoutput = $this->quba->render_question($this->slot, $this->displayoptions);
    }

914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
    protected function check_output_contains_text_input($name, $value = null, $enabled = true) {
        $attributes = array(
            'type' => 'text',
            'name' => $this->quba->get_field_prefix($this->slot) . $name,
        );
        if (!is_null($value)) {
            $attributes['value'] = $value;
        }
        if (!$enabled) {
            $attributes['readonly'] = 'readonly';
        }
        $matcher = $this->get_tag_matcher('input', $attributes);
        $this->assertTag($matcher, $this->currentoutput,
                'Looking for an input with attributes ' . html_writer::attributes($attributes) . ' in ' . $this->currentoutput);

        if ($enabled) {
            $matcher['attributes']['readonly'] = 'readonly';
            $this->assertNotTag($matcher, $this->currentoutput,
                    'input with attributes ' . html_writer::attributes($attributes) .
                    ' should not be read-only in ' . $this->currentoutput);
        }
    }

937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
    protected function check_output_contains_text_input_with_class($name, $class = null) {
        $attributes = array(
            'type' => 'text',
            'name' => $this->quba->get_field_prefix($this->slot) . $name,
        );
        if (!is_null($class)) {
            $attributes['class'] = 'regexp:/\b' . $class . '\b/';
        }

        $matcher = $this->get_tag_matcher('input', $attributes);
        $this->assertTag($matcher, $this->currentoutput,
                'Looking for an input with attributes ' . html_writer::attributes($attributes) . ' in ' . $this->currentoutput);
    }

    protected function check_output_does_not_contain_text_input_with_class($name, $class = null) {
        $attributes = array(
            'type' => 'text',
            'name' => $this->quba->get_field_prefix($this->slot) . $name,
        );
        if (!is_null($class)) {
            $attributes['class'] = 'regexp:/\b' . $class . '\b/';
        }

        $matcher = $this->get_tag_matcher('input', $attributes);
        $this->assertNotTag($matcher, $this->currentoutput,
                'Unexpected input with attributes ' . html_writer::attributes($attributes) . ' found in ' . $this->currentoutput);
    }

965
966
967
968
969
970
971
972
973
974
    protected function check_output_contains_hidden_input($name, $value) {
        $attributes = array(
            'type' => 'hidden',
            'name' => $this->quba->get_field_prefix($this->slot) . $name,
            'value' => $value,
        );
        $this->assertTag($this->get_tag_matcher('input', $attributes), $this->currentoutput,
                'Looking for a hidden input with attributes ' . html_writer::attributes($attributes) . ' in ' . $this->currentoutput);
    }

975
    protected function check_output_contains($string) {
976
977
978
979
980
        $this->render();
        $this->assertContains($string, $this->currentoutput,
                'Expected string ' . $string . ' not found in ' . $this->currentoutput);
    }

981
982
983
984
985
986
987
988
989
990
    protected function check_output_does_not_contain($string) {
        $this->render();
        $this->assertNotContains($string, $this->currentoutput,
                'String ' . $string . ' unexpectedly found in ' . $this->currentoutput);
    }

    protected function check_output_contains_lang_string($identifier, $component = '', $a = null) {
        $this->check_output_contains(get_string($identifier, $component, $a));
    }

991
992
993
994
995
996
997
    protected function get_tag_matcher($tag, $attributes) {
        return array(
            'tag' => $tag,
            'attributes' => $attributes,
        );
    }

Petr Skoda's avatar
Petr Skoda committed
998
999
1000
    /**
     * @param $condition one or more Expectations. (users varargs).
     */
For faster browsing, not all history is shown. View entire blame