on-demand release 4.0dev+
[moodle.git] / question / type / essay / tests / question_test.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Unit tests for the essay question definition class.
19  *
20  * @package    qtype
21  * @subpackage essay
22  * @copyright  2009 The Open University
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
27 defined('MOODLE_INTERNAL') || die();
29 global $CFG;
30 require_once($CFG->dirroot . '/question/engine/tests/helpers.php');
33 /**
34  * Unit tests for the matching question definition class.
35  *
36  * @copyright  2009 The Open University
37  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
38  */
39 class qtype_essay_question_test extends advanced_testcase {
40     public function test_get_question_summary() {
41         $essay = test_question_maker::make_an_essay_question();
42         $essay->questiontext = 'Hello <img src="http://example.com/globe.png" alt="world" />';
43         $this->assertEquals('Hello [world]', $essay->get_question_summary());
44     }
46     /**
47      * Test summarise_response() when teachers view quiz attempts and then
48      * review them to see what has been saved in the response history table.
49      *
50      * @dataProvider summarise_response_provider
51      * @param int $responserequired
52      * @param int $attachmentsrequired
53      * @param string $answertext
54      * @param int $attachmentuploaded
55      * @param string $expected
56      */
57     public function test_summarise_response(int $responserequired, int $attachmentsrequired,
58                                             string $answertext, int $attachmentuploaded, string $expected): void {
59         $this->resetAfterTest();
61         // If number of allowed attachments is set to 'Unlimited', generate 10 attachments for testing purpose.
62         $numberofattachments = ($attachmentsrequired === -1) ? 10 : $attachmentsrequired;
64         // Create sample attachments.
65         $attachments = $this->create_user_and_sample_attachments($numberofattachments);
67         // Create the essay question under test.
68         $essay = test_question_maker::make_an_essay_question();
69         $essay->start_attempt(new question_attempt_step(), 1);
71         $essay->responseformat = 'editor';
72         $essay->responserequired = $responserequired;
73         $essay->attachmentsrequired = $attachmentsrequired;
75         $this->assertEquals($expected, $essay->summarise_response(
76             ['answer' => $answertext, 'answerformat' => FORMAT_HTML,  'attachments' => $attachments[$attachmentuploaded]]));
77     }
79     /**
80      * Data provider for summarise_response() test cases.
81      *
82      * @return array List of data sets (test cases)
83      */
84     public function summarise_response_provider(): array {
85         return [
86             'text input required, not attachments required'  =>
87                 [1, 0, 'This is the text input for this essay.', 0, 'This is the text input for this essay.'],
88             'Text input required, one attachments required, one uploaded'  =>
89                 [1, 1, 'This is the text input for this essay.', 1, 'This is the text input for this essay.Attachments: 0 (1 bytes)'],
90             'Text input is optional, four attachments required, one uploaded'  => [0, 4, '', 1, 'Attachments: 0 (1 bytes)'],
91             'Text input is optional, four attachments required, two uploaded'  => [0, 4, '', 2, 'Attachments: 0 (1 bytes), 1 (1 bytes)'],
92             'Text input is optional, four attachments required, three uploaded'  => [0, 4, '', 3, 'Attachments: 0 (1 bytes), 1 (1 bytes), 2 (1 bytes)'],
93             'Text input is optional, four attachments required, four uploaded'  => [0, 4, 'I have attached 4 files.', 4,
94                 'I have attached 4 files.Attachments: 0 (1 bytes), 1 (1 bytes), 2 (1 bytes), 3 (1 bytes)'],
95             'Text input is optional, unlimited attachments required, one uploaded'  => [0, -1, '', 1, 'Attachments: 0 (1 bytes)'],
96             'Text input is optional, unlimited attachments required, five uploaded'  => [0, -1, 'I have attached 5 files.', 5,
97                 'I have attached 5 files.Attachments: 0 (1 bytes), 1 (1 bytes), 2 (1 bytes), 3 (1 bytes), 4 (1 bytes)'],
98             'Text input is optional, unlimited attachments required, ten uploaded'  =>
99                 [0, -1, '', 10, 'Attachments: 0 (1 bytes), 1 (1 bytes), 2 (1 bytes), 3 (1 bytes), 4 (1 bytes), ' .
100                     '5 (1 bytes), 6 (1 bytes), 7 (1 bytes), 8 (1 bytes), 9 (1 bytes)']
101         ];
102     }
104     public function test_is_same_response() {
105         $essay = test_question_maker::make_an_essay_question();
107         $essay->responsetemplate = '';
109         $essay->start_attempt(new question_attempt_step(), 1);
111         $this->assertTrue($essay->is_same_response(
112                 array(),
113                 array('answer' => '')));
115         $this->assertTrue($essay->is_same_response(
116                 array('answer' => ''),
117                 array('answer' => '')));
119         $this->assertTrue($essay->is_same_response(
120                 array('answer' => ''),
121                 array()));
123         $this->assertFalse($essay->is_same_response(
124                 array('answer' => 'Hello'),
125                 array()));
127         $this->assertFalse($essay->is_same_response(
128                 array('answer' => 'Hello'),
129                 array('answer' => '')));
131         $this->assertFalse($essay->is_same_response(
132                 array('answer' => 0),
133                 array('answer' => '')));
135         $this->assertFalse($essay->is_same_response(
136                 array('answer' => ''),
137                 array('answer' => 0)));
139         $this->assertFalse($essay->is_same_response(
140                 array('answer' => '0'),
141                 array('answer' => '')));
143         $this->assertFalse($essay->is_same_response(
144                 array('answer' => ''),
145                 array('answer' => '0')));
146     }
148     public function test_is_same_response_with_template() {
149         $essay = test_question_maker::make_an_essay_question();
151         $essay->responsetemplate = 'Once upon a time';
153         $essay->start_attempt(new question_attempt_step(), 1);
155         $this->assertTrue($essay->is_same_response(
156                 array(),
157                 array('answer' => 'Once upon a time')));
159         $this->assertTrue($essay->is_same_response(
160                 array('answer' => ''),
161                 array('answer' => 'Once upon a time')));
163         $this->assertTrue($essay->is_same_response(
164                 array('answer' => 'Once upon a time'),
165                 array('answer' => '')));
167         $this->assertTrue($essay->is_same_response(
168                 array('answer' => ''),
169                 array()));
171         $this->assertTrue($essay->is_same_response(
172                 array('answer' => 'Once upon a time'),
173                 array()));
175         $this->assertFalse($essay->is_same_response(
176                 array('answer' => 0),
177                 array('answer' => '')));
179         $this->assertFalse($essay->is_same_response(
180                 array('answer' => ''),
181                 array('answer' => 0)));
183         $this->assertFalse($essay->is_same_response(
184                 array('answer' => '0'),
185                 array('answer' => '')));
187         $this->assertFalse($essay->is_same_response(
188                 array('answer' => ''),
189                 array('answer' => '0')));
190     }
192     public function test_is_complete_response() {
193         $this->resetAfterTest(true);
195         // Create sample attachments.
196         $attachments = $this->create_user_and_sample_attachments();
198         // Create the essay question under test.
199         $essay = test_question_maker::make_an_essay_question();
200         $essay->start_attempt(new question_attempt_step(), 1);
202         // Test the "traditional" case, where we must receive a response from the user.
203         $essay->responserequired = 1;
204         $essay->attachmentsrequired = 0;
205         $essay->responseformat = 'editor';
207         // The empty string should be considered an incomplete response, as should a lack of a response.
208         $this->assertFalse($essay->is_complete_response(array('answer' => '')));
209         $this->assertFalse($essay->is_complete_response(array()));
211         // Any nonempty string should be considered a complete response.
212         $this->assertTrue($essay->is_complete_response(array('answer' => 'A student response.')));
213         $this->assertTrue($essay->is_complete_response(array('answer' => '0 times.')));
214         $this->assertTrue($essay->is_complete_response(array('answer' => '0')));
216         // Test case for minimum and/or maximum word limit.
217         $response = [];
218         $response['answer'] = 'In this essay, I will be testing a function called check_input_word_count().';
220         $essay->minwordlimit = 50; // The answer is shorter than the required minimum word limit.
221         $this->assertFalse($essay->is_complete_response($response));
223         $essay->minwordlimit = 10; // The  word count  meets the required minimum word limit.
224         $this->assertTrue($essay->is_complete_response($response));
226         // The word count meets the required minimum  and maximum word limit.
227         $essay->minwordlimit = 10;
228         $essay->maxwordlimit = 15;
229         $this->assertTrue($essay->is_complete_response($response));
231         // Unset the minwordlimit/maxwordlimit variables to avoid the extra check in is_complete_response() for further tests.
232         $essay->minwordlimit = null;
233         $essay->maxwordlimit = null;
235         // Test the case where two files are required.
236         $essay->attachmentsrequired = 2;
238         // Attaching less than two files should result in an incomplete response.
239         $this->assertFalse($essay->is_complete_response(array('answer' => 'A')));
240         $this->assertFalse($essay->is_complete_response(
241                 array('answer' => 'A', 'attachments' => $attachments[0])));
242         $this->assertFalse($essay->is_complete_response(
243                 array('answer' => 'A', 'attachments' => $attachments[1])));
245         // Anything without response text should result in an incomplete response.
246         $this->assertFalse($essay->is_complete_response(
247                 array('answer' => '', 'attachments' => $attachments[2])));
249         // Attaching two or more files should result in a complete response.
250         $this->assertTrue($essay->is_complete_response(
251                 array('answer' => 'A', 'attachments' => $attachments[2])));
252         $this->assertTrue($essay->is_complete_response(
253                 array('answer' => 'A', 'attachments' => $attachments[3])));
255         // Test the case in which two files are required, but the inline
256         // response is optional.
257         $essay->responserequired = 0;
259         $this->assertFalse($essay->is_complete_response(
260                 array('answer' => '', 'attachments' => $attachments[1])));
262         $this->assertTrue($essay->is_complete_response(
263                 array('answer' => '', 'attachments' => $attachments[2])));
265         // Test the case in which both the response and online text are optional.
266         $essay->attachmentsrequired = 0;
268         // Providing no answer and no attachment should result in an incomplete
269         // response.
270         $this->assertFalse($essay->is_complete_response(
271                 array('answer' => '')));
272         $this->assertFalse($essay->is_complete_response(
273                 array('answer' => '', 'attachments' => $attachments[0])));
275         // Providing an answer _or_ an attachment should result in a complete
276         // response.
277         $this->assertTrue($essay->is_complete_response(
278                 array('answer' => '', 'attachments' => $attachments[1])));
279         $this->assertTrue($essay->is_complete_response(
280                 array('answer' => 'Answer text.', 'attachments' => $attachments[0])));
282         // Test the case in which we're in "no inline response" mode,
283         // in which the response is not required (as it's not provided).
284         $essay->reponserequired = 0;
285         $essay->responseformat = 'noinline';
286         $essay->attachmensrequired = 1;
288         $this->assertFalse($essay->is_complete_response(
289                 array()));
290         $this->assertFalse($essay->is_complete_response(
291                 array('attachments' => $attachments[0])));
293         // Providing an attachment should result in a complete response.
294         $this->assertTrue($essay->is_complete_response(
295                 array('attachments' => $attachments[1])));
297         // Ensure that responserequired is ignored when we're in inline response mode.
298         $essay->reponserequired = 1;
299         $this->assertTrue($essay->is_complete_response(
300                 array('attachments' => $attachments[1])));
301     }
303     /**
304      * test_get_question_definition_for_external_rendering
305      */
306     public function test_get_question_definition_for_external_rendering() {
307         $this->resetAfterTest();
309         $essay = test_question_maker::make_an_essay_question();
310         $essay->minwordlimit = 15;
311         $essay->start_attempt(new question_attempt_step(), 1);
312         $qa = test_question_maker::get_a_qa($essay);
313         $displayoptions = new question_display_options();
315         $options = $essay->get_question_definition_for_external_rendering($qa, $displayoptions);
316         $this->assertNotEmpty($options);
317         $this->assertEquals('editor', $options['responseformat']);
318         $this->assertEquals(1, $options['responserequired']);
319         $this->assertEquals(15, $options['responsefieldlines']);
320         $this->assertEquals(0, $options['attachments']);
321         $this->assertEquals(0, $options['attachmentsrequired']);
322         $this->assertNull($options['maxbytes']);
323         $this->assertNull($options['filetypeslist']);
324         $this->assertEquals('', $options['responsetemplate']);
325         $this->assertEquals(FORMAT_MOODLE, $options['responsetemplateformat']);
326         $this->assertEquals($essay->minwordlimit, $options['minwordlimit']);
327         $this->assertNull($options['maxwordlimit']);
328     }
330     /**
331      * Test get_validation_error when users submit their input text.
332      *
333      * (The tests are done with a fixed 14-word response.)
334      *
335      * @dataProvider get_min_max_wordlimit_test_cases()
336      * @param  int $responserequired whether response required (yes = 1, no = 0)
337      * @param  int $minwordlimit minimum word limit
338      * @param  int $maxwordlimit maximum word limit
339      * @param  string $expected error message | null
340      */
341     public function test_get_validation_error(int $responserequired,
342                                               int $minwordlimit, int $maxwordlimit, string $expected): void {
343         $question = test_question_maker::make_an_essay_question();
344         $response = ['answer' => 'One two three four five six seven eight nine ten eleven twelve thirteen fourteen.'];
345         $question->responserequired = $responserequired;
346         $question->minwordlimit = $minwordlimit;
347         $question->maxwordlimit = $maxwordlimit;
348         $actual = $question->get_validation_error($response);
349         $this->assertEquals($expected, $actual);
350     }
352     /**
353      * Data provider for get_validation_error test.
354      *
355      * @return array the test cases.
356      */
357     public function get_min_max_wordlimit_test_cases(): array {
358         return [
359             'text input required, min/max word limit not set'  => [1, 0, 0, ''],
360             'text input required, min/max word limit valid (within the boundaries)'  => [1, 10, 25, ''],
361             'text input required, min word limit not reached'  => [1, 15, 25,
362                 get_string('minwordlimitboundary', 'qtype_essay', ['count' => 14, 'limit' => 15])],
363             'text input required, max word limit is exceeded'  => [1, 5, 12,
364                 get_string('maxwordlimitboundary', 'qtype_essay', ['count' => 14, 'limit' => 12])],
365             'text input not required, min/max word limit not set'  => [0, 5, 12, ''],
366         ];
367     }
369     /**
370      * Test get_word_count_message_for_review when users submit their input text.
371      *
372      * (The tests are done with a fixed 14-word response.)
373      *
374      * @dataProvider get_word_count_message_for_review_test_cases()
375      * @param int|null $minwordlimit minimum word limit
376      * @param int|null $maxwordlimit maximum word limit
377      * @param string $expected error message | null
378      */
379     public function test_get_word_count_message_for_review(?int $minwordlimit, ?int $maxwordlimit, string $expected): void {
380         $question = test_question_maker::make_an_essay_question();
381         $question->minwordlimit = $minwordlimit;
382         $question->maxwordlimit = $maxwordlimit;
384         $response = ['answer' => 'One two three four five six seven eight nine ten eleven twelve thirteen fourteen.'];
385         $this->assertEquals($expected, $question->get_word_count_message_for_review($response));
386     }
388     /**
389      * Data provider for test_get_word_count_message_for_review.
390      *
391      * @return array the test cases.
392      */
393     public function get_word_count_message_for_review_test_cases() {
394         return [
395             'No limit' =>
396                     [null, null, ''],
397             'min and max, answer within range' =>
398                     [10, 25, get_string('wordcount', 'qtype_essay', 14)],
399             'min and max, answer too short' =>
400                     [15, 25, get_string('wordcounttoofew', 'qtype_essay', ['count' => 14, 'limit' => 15])],
401             'min and max, answer too long' =>
402                     [5, 12, get_string('wordcounttoomuch', 'qtype_essay', ['count' => 14, 'limit' => 12])],
403             'min only, answer within range' =>
404                     [14, null, get_string('wordcount', 'qtype_essay', 14)],
405             'min only, answer too short' =>
406                     [15, null, get_string('wordcounttoofew', 'qtype_essay', ['count' => 14, 'limit' => 15])],
407             'max only, answer within range' =>
408                     [null, 14, get_string('wordcount', 'qtype_essay', 14)],
409             'max only, answer too short' =>
410                     [null, 13, get_string('wordcounttoomuch', 'qtype_essay', ['count' => 14, 'limit' => 13])],
411         ];
412     }
414     /**
415      * Create sample attachemnts and retun generated attachments.
416      * @param int $numberofattachments
417      * @return array
418      */
419     private function create_user_and_sample_attachments($numberofattachments = 4) {
420         // Create a new logged-in user, so we can test responses with attachments.
421         $user = $this->getDataGenerator()->create_user();
422         $this->setUser($user);
424         // Create sample attachments to use in testing.
425         $helper = test_question_maker::get_test_helper('essay');
426         $attachments = [];
427         for ($i = 0; $i < ($numberofattachments + 1); ++$i) {
428             $attachments[$i] = $helper->make_attachments_saver($i);
429         }
430         return $attachments;
431     }