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 mod_feedback\external;

use core_external\external_api;

use externallib_advanced_testcase;

use feedback_item_multichoice;

use mod_feedback_external;

use moodle_exception;

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

global $CFG;

require_once($CFG->dirroot . '/webservice/tests/helpers.php');

require_once($CFG->dirroot . '/mod/feedback/lib.php');

/**

 * Feedback module external functions tests

 *

 * @package    mod_feedback

 * @category   external

 * @copyright  2017 Juan Leyva <juan@moodle.com>

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 * @since      Moodle 3.3

 * @covers     \mod_feedback_external

 */

final class external_test extends externallib_advanced_testcase {

    // TODO These should be removed.

    // Testcase classes should not have any properties or store state.

    protected $course;

    protected $feedback;

    protected $context;

    protected $cm;

    protected $student;

    protected $teacher;

    protected $studentrole;

    protected $teacherrole;

    /**

     * Set up for every test

     */

    public function setUp(): void {

        global $DB;

        $this->resetAfterTest();

        $this->setAdminUser();

        // Setup test data.

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

        $this->feedback = $this->getDataGenerator()->create_module('feedback',

            array('course' => $this->course->id, 'email_notification' => 1));

        $this->context = \context_module::instance($this->feedback->cmid);

        $this->cm = get_coursemodule_from_instance('feedback', $this->feedback->id);

        // Create users.

        $this->student = self::getDataGenerator()->create_user();

        $this->teacher = self::getDataGenerator()->create_user();

        // Users enrolments.

        $this->studentrole = $DB->get_record('role', array('shortname' => 'student'));

        $this->teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));

        $this->getDataGenerator()->enrol_user($this->student->id, $this->course->id, $this->studentrole->id, 'manual');

        $this->getDataGenerator()->enrol_user($this->teacher->id, $this->course->id, $this->teacherrole->id, 'manual');

    }

    /**

     * Helper method to add items to an existing feedback.

     *

     * @param \stdClass $feedback feedback instance

     * @param integer $pagescount the number of pages we want in the feedback

     * @return array list of items created

     */

    public function populate_feedback($feedback, $pagescount = 1) {

        $feedbackgenerator = $this->getDataGenerator()->get_plugin_generator('mod_feedback');

        $itemscreated = [];

        // Create at least one page.

        $itemscreated[] = $feedbackgenerator->create_item_label($feedback);

        $itemscreated[] = $feedbackgenerator->create_item_info($feedback);

        $itemscreated[] = $feedbackgenerator->create_item_numeric($feedback);

        // Check if we want more pages.

        for ($i = 1; $i < $pagescount; $i++) {

            $itemscreated[] = $feedbackgenerator->create_item_pagebreak($feedback);

            $itemscreated[] = $feedbackgenerator->create_item_multichoice($feedback);

            $itemscreated[] = $feedbackgenerator->create_item_multichoicerated($feedback);

            $itemscreated[] = $feedbackgenerator->create_item_textarea($feedback);

            $itemscreated[] = $feedbackgenerator->create_item_textfield($feedback);

            $itemscreated[] = $feedbackgenerator->create_item_numeric($feedback);

        }

        return $itemscreated;

    }

    /**

     * Test test_mod_feedback_get_feedbacks_by_courses

     */

    public function test_mod_feedback_get_feedbacks_by_courses(): void {

        // Create additional course.

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

        // Second feedback.

        $record = new \stdClass();

        $record->course = $course2->id;

        $feedback2 = self::getDataGenerator()->create_module('feedback', $record);

        // Execute real Moodle enrolment as we'll call unenrol() method on the instance later.

        $enrol = enrol_get_plugin('manual');

        $enrolinstances = enrol_get_instances($course2->id, true);

        $instance2 = (object) [];

        foreach ($enrolinstances as $courseenrolinstance) {

            if ($courseenrolinstance->enrol == "manual") {

                $instance2 = $courseenrolinstance;

                break;

            }

        }

        $enrol->enrol_user($instance2, $this->student->id, $this->studentrole->id);

        self::setUser($this->student);

        $returndescription = mod_feedback_external::get_feedbacks_by_courses_returns();

        // Create what we expect to be returned when querying the two courses.

        // First for the student user.

        $expectedfields = array('id', 'coursemodule', 'course', 'name', 'intro', 'introformat', 'introfiles', 'lang', 'anonymous',

            'multiple_submit', 'autonumbering', 'page_after_submitformat', 'publish_stats', 'completionsubmit');

        $properties = feedback_summary_exporter::read_properties_definition();

        // Add expected coursemodule and data.

        $feedback1 = $this->feedback;

        $feedback1->coursemodule = $feedback1->cmid;

        $feedback1->introformat = 1;

        $feedback1->introfiles = [];

        $feedback1->lang = '';

        $feedback2->coursemodule = $feedback2->cmid;

        $feedback2->introformat = 1;

        $feedback2->introfiles = [];

        $feedback2->lang = '';

        foreach ($expectedfields as $field) {

            if (!empty($properties[$field]) && $properties[$field]['type'] == PARAM_BOOL) {

                $feedback1->{$field} = (bool) $feedback1->{$field};

                $feedback2->{$field} = (bool) $feedback2->{$field};

            }

            $expected1[$field] = $feedback1->{$field};

            $expected2[$field] = $feedback2->{$field};

        }

        $expectedfeedbacks = array($expected2, $expected1);

        // Call the external function passing course ids.

        $result = mod_feedback_external::get_feedbacks_by_courses(array($course2->id, $this->course->id));

        $result = external_api::clean_returnvalue($returndescription, $result);

        $this->assertEquals($expectedfeedbacks, $result['feedbacks']);

        $this->assertCount(0, $result['warnings']);

        // Call the external function without passing course id.

        $result = mod_feedback_external::get_feedbacks_by_courses();

        $result = external_api::clean_returnvalue($returndescription, $result);

        $this->assertEquals($expectedfeedbacks, $result['feedbacks']);

        $this->assertCount(0, $result['warnings']);

        // Unenrol user from second course and alter expected feedbacks.

        $enrol->unenrol_user($instance2, $this->student->id);

        array_shift($expectedfeedbacks);

        // Call the external function without passing course id.

        $result = mod_feedback_external::get_feedbacks_by_courses();

        $result = external_api::clean_returnvalue($returndescription, $result);

        $this->assertEquals($expectedfeedbacks, $result['feedbacks']);

        // Call for the second course we unenrolled the user from, expected warning.

        $result = mod_feedback_external::get_feedbacks_by_courses(array($course2->id));

        $this->assertCount(1, $result['warnings']);

        $this->assertEquals('1', $result['warnings'][0]['warningcode']);

        $this->assertEquals($course2->id, $result['warnings'][0]['itemid']);

        // Now, try as a teacher for getting all the additional fields.

        self::setUser($this->teacher);

        $additionalfields = array('email_notification', 'site_after_submit', 'page_after_submit', 'timeopen', 'timeclose',

            'timemodified', 'pageaftersubmitfiles');

        $feedback1->pageaftersubmitfiles = [];

        foreach ($additionalfields as $field) {

            if (!empty($properties[$field]) && $properties[$field]['type'] == PARAM_BOOL) {

                $feedback1->{$field} = (bool) $feedback1->{$field};

            }

            $expectedfeedbacks[0][$field] = $feedback1->{$field};

        }

        $expectedfeedbacks[0]['page_after_submitformat'] = 1;

        $result = mod_feedback_external::get_feedbacks_by_courses();

        $result = external_api::clean_returnvalue($returndescription, $result);

        $this->assertEquals($expectedfeedbacks, $result['feedbacks']);

        // Admin also should get all the information.

        self::setAdminUser();

        $result = mod_feedback_external::get_feedbacks_by_courses(array($this->course->id));

        $result = external_api::clean_returnvalue($returndescription, $result);

        $this->assertEquals($expectedfeedbacks, $result['feedbacks']);

    }

    /**

     * Test get_feedback_access_information function with basic defaults for student.

     */

    public function test_get_feedback_access_information_student(): void {

        self::setUser($this->student);

        $result = mod_feedback_external::get_feedback_access_information($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_feedback_access_information_returns(), $result);

        $this->assertFalse($result['canviewanalysis']);

        $this->assertFalse($result['candeletesubmissions']);

        $this->assertFalse($result['canviewreports']);

        $this->assertFalse($result['canedititems']);

        $this->assertTrue($result['cancomplete']);

        $this->assertTrue($result['cansubmit']);

        $this->assertTrue($result['isempty']);

        $this->assertTrue($result['isopen']);

        $this->assertTrue($result['isanonymous']);

        $this->assertFalse($result['isalreadysubmitted']);

    }

    /**

     * Test get_feedback_access_information function with basic defaults for teacher.

     */

    public function test_get_feedback_access_information_teacher(): void {

        self::setUser($this->teacher);

        $result = mod_feedback_external::get_feedback_access_information($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_feedback_access_information_returns(), $result);

        $this->assertTrue($result['canviewanalysis']);

        $this->assertTrue($result['canviewreports']);

        $this->assertTrue($result['canedititems']);

        $this->assertTrue($result['candeletesubmissions']);

        $this->assertFalse($result['cancomplete']);

        $this->assertTrue($result['cansubmit']);

        $this->assertTrue($result['isempty']);

        $this->assertTrue($result['isopen']);

        $this->assertTrue($result['isanonymous']);

        $this->assertFalse($result['isalreadysubmitted']);

        // Add some items to the feedback and check is not empty any more.

        self::populate_feedback($this->feedback);

        $result = mod_feedback_external::get_feedback_access_information($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_feedback_access_information_returns(), $result);

        $this->assertFalse($result['isempty']);

    }

    /**

     * Test view_feedback invalid id.

     */

    public function test_view_feedback_invalid_id(): void {

        // Test invalid instance id.

        $this->expectException(moodle_exception::class);

        mod_feedback_external::view_feedback(0);

    }

    /**

     * Test view_feedback not enrolled user.

     */

    public function test_view_feedback_not_enrolled_user(): void {

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

        $this->setUser($usernotenrolled);

        $this->expectException(moodle_exception::class);

        mod_feedback_external::view_feedback(0);

    }

    /**

     * Test view_feedback no capabilities.

     */

    public function test_view_feedback_no_capabilities(): void {

        // Test user with no capabilities.

        // We need a explicit prohibit since this capability is allowed for students by default.

        assign_capability('mod/feedback:view', CAP_PROHIBIT, $this->studentrole->id, $this->context->id);

        accesslib_clear_all_caches_for_unit_testing();

        $this->expectException(moodle_exception::class);

        mod_feedback_external::view_feedback(0);

    }

    /**

     * Test view_feedback.

     */

    public function test_view_feedback(): void {

        // Test user with full capabilities.

        $this->setUser($this->student);

        // Trigger and capture the event.

        $sink = $this->redirectEvents();

        $result = mod_feedback_external::view_feedback($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::view_feedback_returns(), $result);

        $events = $sink->get_events();

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

        $event = array_shift($events);

        // Checking that the event contains the expected values.

        $this->assertInstanceOf('\mod_feedback\event\course_module_viewed', $event);

        $this->assertEquals($this->context, $event->get_context());

        $moodledata = new \moodle_url('/mod/feedback/view.php', array('id' => $this->cm->id));

        $this->assertEquals($moodledata, $event->get_url());

        $this->assertEventContextNotUsed($event);

        $this->assertNotEmpty($event->get_name());

    }

    /**

     * Test get_current_completed_tmp.

     */

    public function test_get_current_completed_tmp(): void {

        global $DB;

        // Force non anonymous.

        $DB->set_field('feedback', 'anonymous', FEEDBACK_ANONYMOUS_NO, array('id' => $this->feedback->id));

        // Add a completed_tmp record.

        $record = [

            'feedback' => $this->feedback->id,

            'userid' => $this->student->id,

            'guestid' => '',

            'timemodified' => time() - DAYSECS,

            'random_response' => 0,

            'anonymous_response' => FEEDBACK_ANONYMOUS_NO,

            'courseid' => $this->course->id,

        ];

        $record['id'] = $DB->insert_record('feedback_completedtmp', (object) $record);

        // Test user with full capabilities.

        $this->setUser($this->student);

        $result = mod_feedback_external::get_current_completed_tmp($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_current_completed_tmp_returns(), $result);

        $this->assertEquals($record['id'], $result['feedback']['id']);

    }

    /**

     * Test get_items.

     */

    public function test_get_items(): void {

        // Test user with full capabilities.

        $this->setUser($this->student);

        // Add questions to the feedback, we are adding 2 pages of questions.

        $itemscreated = self::populate_feedback($this->feedback, 2);

        $result = mod_feedback_external::get_items($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_items_returns(), $result);

        $this->assertCount(count($itemscreated), $result['items']);

        $index = 1;

        foreach ($result['items'] as $key => $item) {

            if (is_numeric($itemscreated[$key])) {

                continue; // Page break.

            }

            // Cannot compare directly the exporter and the db object (exporter have more fields).

            $this->assertEquals($itemscreated[$key]->id, $item['id']);

            $this->assertEquals($itemscreated[$key]->typ, $item['typ']);

            $this->assertEquals($itemscreated[$key]->name, $item['name']);

            $this->assertEquals($itemscreated[$key]->label, $item['label']);

            if ($item['hasvalue']) {

                $this->assertEquals($index, $item['itemnumber']);

                $index++;

            }

        }

    }

    /**

     * Test get_items, to confirm validation is done too.

     *

     * @dataProvider items_provider

     * @param string $role Whether the current user should be a student or a teacher.

     * @param array $info Settings to create the feedback.

     * @param string|null $warning The warning message to display or null if warnings result is empty.

     */

    public function test_get_items_validation(string $role, array $info, ?string $warning): void {

        global $DB;

        // Test user with full capabilities.

        if ($role === 'teacher') {

            $this->setUser($this->teacher);

        } else {

            $this->setUser($this->student);

        }

        // Create the feedback.

        $data = ['course' => $this->course->id];

        if (array_key_exists('closed', $info) && $info['closed']) {

            $data['timeopen'] = time() + DAYSECS;

        }

        $feedback = $this->getDataGenerator()->create_module('feedback', $data);

        $empty = true;

        if (!array_key_exists('empty', $info) || !$info['empty']) {

            $empty = false;

            /** @var \mod_feedback_generator $feedbackgenerator */

            $feedbackgenerator = $this->getDataGenerator()->get_plugin_generator('mod_feedback');

            // Add,at least, one item to the feedback.

            $feedbackgenerator->create_item_label($feedback);

        }

        if (array_key_exists('complete', $info) && !$info['complete']) {

            $studentrole = $DB->get_record('role', array('shortname' => 'student'));

            $coursecontext = \context_course::instance($this->course->id);

            assign_capability('mod/feedback:complete', CAP_PROHIBIT, $studentrole->id, $coursecontext->id);

            // Empty all the caches that may be affected by this change.

            accesslib_clear_all_caches_for_unit_testing();

            \course_modinfo::clear_instance_cache();

        }

        $result = mod_feedback_external::get_items($feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_items_returns(), $result);

        if ($warning) {

            $this->assertEmpty($result['items']);

            $this->assertCount(1, $result['warnings']);

            $resultwarning = reset($result['warnings']);

            if ($warning == 'required_capability_exception') {

                $this->assertStringContainsString('error/nopermission', $resultwarning['message']);

            } else {

                $this->assertEquals($warning, $resultwarning['message']);

            }

        } else {

            if ($empty) {

                $this->assertEmpty($result['items']);

            } else {

                $this->assertCount(1, $result['items']);

            }

            $this->assertEmpty($result['warnings']);

        }

    }

    /**

     * Data provider for test_get_items_validation() and test_get_page_items_validation().

     *

     * @return array

     */

    public static function items_provider(): array {

        return [

            'Valid feedback (as student)' => [

                'role' => 'student',

                'info' => [],

                'warning' => null,

            ],

            'Closed feedback (as student)' => [

                'role' => 'student',

                'info' => ['closed' => true],

                'warning' => get_string('feedback_is_not_open', 'feedback'),

            ],

            'Empty feedback (as student)' => [

                'role' => 'student',

                'info' => ['empty' => true],

                'warning' => get_string('no_items_available_yet', 'feedback'),

            ],

            'Cannot complete feedback (as student)' => [

                'role' => 'student',

                'info' => ['complete' => false],

                'warning' => 'required_capability_exception',

            ],

            'Valid feedback (as teacher)' => [

                'role' => 'teacher',

                'info' => [],

                'warning' => null,

            ],

            'Closed feedback (as teacher)' => [

                'role' => 'teacher',

                'info' => ['closed' => true],

                'warning' => null,

            ],

            'Empty feedback (as teacher)' => [

                'role' => 'teacher',

                'info' => ['empty' => true],

                'warning' => null,

            ],

            'Cannot complete feedback (as teacher)' => [

                'role' => 'teacher',

                'info' => ['complete' => false],

                'warning' => null,

            ],

        ];

    }

    /**

     * Test launch_feedback.

     */

    public function test_launch_feedback(): void {

        global $DB;

        // Test user with full capabilities.

        $this->setUser($this->student);

        // Add questions to the feedback, we are adding 2 pages of questions.

        $itemscreated = self::populate_feedback($this->feedback, 2);

        // First try a feedback we didn't attempt.

        $result = mod_feedback_external::launch_feedback($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::launch_feedback_returns(), $result);

        $this->assertEquals(0, $result['gopage']);

        // Now, try a feedback that we attempted.

        // Force non anonymous.

        $DB->set_field('feedback', 'anonymous', FEEDBACK_ANONYMOUS_NO, array('id' => $this->feedback->id));

        // Add a completed_tmp record.

        $record = [

            'feedback' => $this->feedback->id,

            'userid' => $this->student->id,

            'guestid' => '',

            'timemodified' => time() - DAYSECS,

            'random_response' => 0,

            'anonymous_response' => FEEDBACK_ANONYMOUS_NO,

            'courseid' => $this->course->id,

        ];

        $record['id'] = $DB->insert_record('feedback_completedtmp', (object) $record);

        // Add a response to the feedback for each question type with possible values.

        $response = [

            'course_id' => $this->course->id,

            'item' => $itemscreated[1]->id, // First item is the info question.

            'completed' => $record['id'],

            'tmp_completed' => $record['id'],

            'value' => 'A',

        ];

        $DB->insert_record('feedback_valuetmp', (object) $response);

        $response = [

            'course_id' => $this->course->id,

            'item' => $itemscreated[2]->id, // Second item is the numeric question.

            'completed' => $record['id'],

            'tmp_completed' => $record['id'],

            'value' => 5,

        ];

        $DB->insert_record('feedback_valuetmp', (object) $response);

        $result = mod_feedback_external::launch_feedback($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::launch_feedback_returns(), $result);

        $this->assertEquals(1, $result['gopage']);

    }

    /**

     * Test get_page_items.

     */

    public function test_get_page_items(): void {

        // Test user with full capabilities.

        $this->setUser($this->student);

        // Add questions to the feedback, we are adding 2 pages of questions.

        $itemscreated = self::populate_feedback($this->feedback, 2);

        // Retrieve first page.

        $result = mod_feedback_external::get_page_items($this->feedback->id, 0);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_page_items_returns(), $result);

        $this->assertCount(3, $result['items']);    // The first page has 3 items.

        $this->assertTrue($result['hasnextpage']);

        $this->assertFalse($result['hasprevpage']);

        // Retrieve second page.

        $result = mod_feedback_external::get_page_items($this->feedback->id, 1);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_page_items_returns(), $result);

        $this->assertCount(5, $result['items']);    // The second page has 5 items (page break doesn't count).

        $this->assertFalse($result['hasnextpage']);

        $this->assertTrue($result['hasprevpage']);

    }

    /**

     * Test get_page_items, to confirm validation is done too.

     *

     * @dataProvider items_provider

     * @param string $role Whether the current user should be a student or a teacher.

     * @param array $info Settings to create the feedback.

     * @param string|null $warning The warning message to display or null if warnings result is empty.

     */

    public function test_get_page_items_validation(string $role, array $info, ?string $warning): void {

        global $DB;

        // Test user with full capabilities.

        if ($role === 'teacher') {

            $this->setUser($this->teacher);

        } else {

            $this->setUser($this->student);

        }

        // Create the feedback.

        $data = ['course' => $this->course->id];

        if (array_key_exists('closed', $info) && $info['closed']) {

            $data['timeopen'] = time() + DAYSECS;

        }

        $feedback = $this->getDataGenerator()->create_module('feedback', $data);

        $empty = true;

        if (!array_key_exists('empty', $info) || !$info['empty']) {

            $empty = false;

            /** @var \mod_feedback_generator $feedbackgenerator */

            $feedbackgenerator = $this->getDataGenerator()->get_plugin_generator('mod_feedback');

            // Add,at least, one item to the feedback.

            $feedbackgenerator->create_item_label($feedback);

        }

        if (array_key_exists('complete', $info) && !$info['complete']) {

            $studentrole = $DB->get_record('role', array('shortname' => 'student'));

            $coursecontext = \context_course::instance($this->course->id);

            assign_capability('mod/feedback:complete', CAP_PROHIBIT, $studentrole->id, $coursecontext->id);

            // Empty all the caches that may be affected by this change.

            accesslib_clear_all_caches_for_unit_testing();

            \course_modinfo::clear_instance_cache();

        }

        $result = mod_feedback_external::get_page_items($feedback->id, 0);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_items_returns(), $result);

        if ($warning) {

            $this->assertEmpty($result['items']);

            $this->assertCount(1, $result['warnings']);

            $resultwarning = reset($result['warnings']);

            if ($warning == 'required_capability_exception') {

                $this->assertStringContainsString('error/nopermission', $resultwarning['message']);

            } else {

                $this->assertEquals($warning, $resultwarning['message']);

            }

        } else {

            if ($empty) {

                $this->assertEmpty($result['items']);

            } else {

                $this->assertCount(1, $result['items']);

            }

            $this->assertEmpty($result['warnings']);

        }

    }

    /**

     * Test process_page.

     */

    public function test_process_page(): void {

        global $DB;

        // Test user with full capabilities.

        $this->setUser($this->student);

        $pagecontents = 'You finished it!';

        $DB->set_field('feedback', 'page_after_submit', $pagecontents, array('id' => $this->feedback->id));

        // Add questions to the feedback, we are adding 2 pages of questions.

        $itemscreated = self::populate_feedback($this->feedback, 2);

        $data = [];

        foreach ($itemscreated as $item) {

            if (empty($item->hasvalue)) {

                continue;

            }

            switch ($item->typ) {

                case 'textarea':

                case 'textfield':

                    $value = 'Lorem ipsum';

                    break;

                case 'numeric':

                    $value = 5;

                    break;

                case 'multichoice':

                    $value = '1';

                    break;

                case 'multichoicerated':

                    $value = '1';

                    break;

                case 'info':

                    $value = format_string($this->course->shortname, true, array('context' => $this->context));

                    break;

                default:

                    $value = '';

            }

            $data[] = ['name' => $item->typ . '_' . $item->id, 'value' => $value];

        }

        // Process first page.

        $firstpagedata = [$data[0], $data[1]];

        $result = mod_feedback_external::process_page($this->feedback->id, 0, $firstpagedata);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertEquals(1, $result['jumpto']);

        $this->assertFalse($result['completed']);

        // Now, process the second page. But first we are going back to the first page.

        $secondpagedata = [$data[2], $data[3], $data[4], $data[5], $data[6]];

        $result = mod_feedback_external::process_page($this->feedback->id, 1, $secondpagedata, true);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertFalse($result['completed']);

        $this->assertEquals(0, $result['jumpto']);  // We jumped to the first page.

        // Check the values were correctly saved.

        $tmpitems = $DB->get_records('feedback_valuetmp');

        $this->assertCount(7, $tmpitems);   // 2 from the first page + 5 from the second page.

        // Go forward again (sending the same data).

        $result = mod_feedback_external::process_page($this->feedback->id, 0, $firstpagedata);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertEquals(1, $result['jumpto']);

        $this->assertFalse($result['completed']);

        $tmpitems = $DB->get_records('feedback_valuetmp');

        $this->assertCount(7, $tmpitems);   // 2 from the first page + 5 from the second page.

        // And finally, save everything! We are going to modify one previous recorded value.

        $messagessink = $this->redirectMessages();

        $data[2]['value'] = 2; // 2 is value of the option 'b'.

        $secondpagedata = [$data[2], $data[3], $data[4], $data[5], $data[6]];

        $result = mod_feedback_external::process_page($this->feedback->id, 1, $secondpagedata);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertTrue($result['completed']);

        $this->assertTrue(strpos($result['completionpagecontents'], $pagecontents) !== false);

        // Check all the items were saved.

        $items = $DB->get_records('feedback_value');

        $this->assertCount(7, $items);

        // Check if the one we modified was correctly saved.

        $itemid = $itemscreated[4]->id;

        $itemsaved = $DB->get_field('feedback_value', 'value', array('item' => $itemid));

        $mcitem = new feedback_item_multichoice();

        $itemval = $mcitem->get_printval($itemscreated[4], (object) ['value' => $itemsaved]);

        $this->assertEquals('b', $itemval);

        // Check that the answers are saved for course 0.

        foreach ($items as $item) {

            $this->assertEquals(0, $item->course_id);

        }

        $completed = $DB->get_record('feedback_completed', []);

        $this->assertEquals(0, $completed->courseid);

        // Test notifications sent.

        $messages = $messagessink->get_messages();

        $messagessink->close();

        // Test customdata.

        $customdata = json_decode($messages[0]->customdata);

        $this->assertEquals($this->feedback->id, $customdata->instance);

        $this->assertEquals($this->feedback->cmid, $customdata->cmid);

        $this->assertObjectHasProperty('notificationiconurl', $customdata);

    }

    /**

     * Test process_page for a site feedback.

     */

    public function test_process_page_site_feedback(): void {

        global $DB;

        $pagecontents = 'You finished it!';

        $this->feedback = $this->getDataGenerator()->create_module('feedback',

            array('course' => SITEID, 'page_after_submit' => $pagecontents));

        // Test user with full capabilities.

        $this->setUser($this->student);

        // Add questions to the feedback, we are adding 2 pages of questions.

        $itemscreated = self::populate_feedback($this->feedback, 2);

        $data = [];

        foreach ($itemscreated as $item) {

            if (empty($item->hasvalue)) {

                continue;

            }

            switch ($item->typ) {

                case 'textarea':

                case 'textfield':

                    $value = 'Lorem ipsum';

                    break;

                case 'numeric':

                    $value = 5;

                    break;

                case 'multichoice':

                    $value = '1';

                    break;

                case 'multichoicerated':

                    $value = '1';

                    break;

                case 'info':

                    $value = format_string($this->course->shortname, true, array('context' => $this->context));

                    break;

                default:

                    $value = '';

            }

            $data[] = ['name' => $item->typ . '_' . $item->id, 'value' => $value];

        }

        // Process first page.

        $firstpagedata = [$data[0], $data[1]];

        $result = mod_feedback_external::process_page($this->feedback->id, 0, $firstpagedata, false, $this->course->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertEquals(1, $result['jumpto']);

        $this->assertFalse($result['completed']);

        // Process second page.

        $data[2]['value'] = 2; // 2 is value of the option 'b';

        $secondpagedata = [$data[2], $data[3], $data[4], $data[5], $data[6]];

        $result = mod_feedback_external::process_page($this->feedback->id, 1, $secondpagedata, false, $this->course->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertTrue($result['completed']);

        $this->assertTrue(strpos($result['completionpagecontents'], $pagecontents) !== false);

        // Check all the items were saved.

        $items = $DB->get_records('feedback_value');

        $this->assertCount(7, $items);

        // Check if the one we modified was correctly saved.

        $itemid = $itemscreated[4]->id;

        $itemsaved = $DB->get_field('feedback_value', 'value', array('item' => $itemid));

        $mcitem = new feedback_item_multichoice();

        $itemval = $mcitem->get_printval($itemscreated[4], (object) ['value' => $itemsaved]);

        $this->assertEquals('b', $itemval);

        // Check that the answers are saved for the correct course.

        foreach ($items as $item) {

            $this->assertEquals($this->course->id, $item->course_id);

        }

        $completed = $DB->get_record('feedback_completed', []);

        $this->assertEquals($this->course->id, $completed->courseid);

    }

    /**

     * Test get_analysis.

     */

    public function test_get_analysis(): void {

        // Test user with full capabilities.

        $this->setUser($this->student);

        // Create a very simple feedback.

        $feedbackgenerator = $this->getDataGenerator()->get_plugin_generator('mod_feedback');

        $numericitem = $feedbackgenerator->create_item_numeric($this->feedback);

        $textfielditem = $feedbackgenerator->create_item_textfield($this->feedback);

        $pagedata = [

            ['name' => $numericitem->typ .'_'. $numericitem->id, 'value' => 5],

            ['name' => $textfielditem->typ .'_'. $textfielditem->id, 'value' => 'abc'],

        ];

        // Process the feedback, there is only one page so the feedback will be completed.

        $result = mod_feedback_external::process_page($this->feedback->id, 0, $pagedata);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertTrue($result['completed']);

        // Retrieve analysis.

        $this->setUser($this->teacher);

        $result = mod_feedback_external::get_analysis($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_analysis_returns(), $result);

        $this->assertEquals(1, $result['completedcount']);  // 1 feedback completed.

        $this->assertEquals(2, $result['itemscount']);  // 2 items in the feedback.

        $this->assertCount(2, $result['itemsdata']);

        $this->assertCount(1, $result['itemsdata'][0]['data']); // There are 1 response per item.

        $this->assertCount(1, $result['itemsdata'][1]['data']);

        // Check we receive the info the students filled.

        foreach ($result['itemsdata'] as $data) {

            if ($data['item']['id'] == $numericitem->id) {

                $this->assertEquals(5, $data['data'][0]);

            } else {

                $this->assertEquals('abc', $data['data'][0]);

            }

        }

        // Create another user / response.

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

        $this->getDataGenerator()->enrol_user($anotherstudent->id, $this->course->id, $this->studentrole->id, 'manual');

        $this->setUser($anotherstudent);

        // Process the feedback, there is only one page so the feedback will be completed.

        $result = mod_feedback_external::process_page($this->feedback->id, 0, $pagedata);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertTrue($result['completed']);

        // Retrieve analysis.

        $this->setUser($this->teacher);

        $result = mod_feedback_external::get_analysis($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_analysis_returns(), $result);

        $this->assertEquals(2, $result['completedcount']);  // 2 feedback completed.

        $this->assertEquals(2, $result['itemscount']);

        $this->assertCount(2, $result['itemsdata'][0]['data']); // There are 2 responses per item.

        $this->assertCount(2, $result['itemsdata'][1]['data']);

    }

    /**

     * Test get_unfinished_responses.

     */

    public function test_get_unfinished_responses(): void {

        // Test user with full capabilities.

        $this->setUser($this->student);

        // Create a very simple feedback.

        $feedbackgenerator = $this->getDataGenerator()->get_plugin_generator('mod_feedback');

        $numericitem = $feedbackgenerator->create_item_numeric($this->feedback);

        $textfielditem = $feedbackgenerator->create_item_textfield($this->feedback);

        $feedbackgenerator->create_item_pagebreak($this->feedback);

        $labelitem = $feedbackgenerator->create_item_label($this->feedback);

        $numericitem2 = $feedbackgenerator->create_item_numeric($this->feedback);

        $pagedata = [

            ['name' => $numericitem->typ .'_'. $numericitem->id, 'value' => 5],

            ['name' => $textfielditem->typ .'_'. $textfielditem->id, 'value' => 'abc'],

        ];

        // Process the feedback, there are two pages so the feedback will be unfinished yet.

        $result = mod_feedback_external::process_page($this->feedback->id, 0, $pagedata);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertFalse($result['completed']);

        // Retrieve the unfinished responses.

        $result = mod_feedback_external::get_unfinished_responses($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_unfinished_responses_returns(), $result);

        // Check that ids and responses match.

        foreach ($result['responses'] as $r) {

            if ($r['item'] == $numericitem->id) {

                $this->assertEquals(5, $r['value']);

            } else {

                $this->assertEquals($textfielditem->id, $r['item']);

                $this->assertEquals('abc', $r['value']);

            }

        }

    }

    /**

     * Test get_finished_responses.

     */

    public function test_get_finished_responses(): void {

        // Test user with full capabilities.

        $this->setUser($this->student);

        // Create a very simple feedback.

        $feedbackgenerator = $this->getDataGenerator()->get_plugin_generator('mod_feedback');

        $numericitem = $feedbackgenerator->create_item_numeric($this->feedback);

        $textfielditem = $feedbackgenerator->create_item_textfield($this->feedback);

        $pagedata = [

            ['name' => $numericitem->typ .'_'. $numericitem->id, 'value' => 5],

            ['name' => $textfielditem->typ .'_'. $textfielditem->id, 'value' => 'abc'],

        ];

        // Process the feedback, there is only one page so the feedback will be completed.

        $result = mod_feedback_external::process_page($this->feedback->id, 0, $pagedata);

        $result = external_api::clean_returnvalue(mod_feedback_external::process_page_returns(), $result);

        $this->assertTrue($result['completed']);

        // Retrieve the responses.

        $result = mod_feedback_external::get_finished_responses($this->feedback->id);

        $result = external_api::clean_returnvalue(mod_feedback_external::get_finished_responses_returns(), $result);

        // Check that ids and responses match.

        foreach ($result['responses'] as $r) {

            if ($r['item'] == $numericitem->id) {

                $this->assertEquals(5, $r['value']);

            } else {

                $this->assertEquals($textfielditem->id, $r['item']);

                $this->assertEquals('abc', $r['value']);

            }

        }

    }

    /**

     * Test get_non_respondents (student trying to get this information).

     */

    public function test_get_non_respondents_no_permissions(): void {

        $this->setUser($this->student);

        $this->expectException(moodle_exception::class);

        mod_feedback_external::get_non_respondents($this->feedback->id);

    }

    /**

     * Test get_non_respondents from an anonymous feedback.

     */

    public function test_get_non_respondents_from_anonymous_feedback(): void {

        $this->setUser($this->student);

        $this->expectException(moodle_exception::class);

        $this->expectExceptionMessage(get_string('anonymous', 'feedback'));

        mod_feedback_external::get_non_respondents($this->feedback->id);

    }

    /**

     * Test get_non_respondents.

     */

    public function test_get_non_respondents(): void {

        global $DB;

        // Force non anonymous.

        $DB->set_field('feedback', 'anonymous', FEEDBACK_ANONYMOUS_NO, array('id' => $this->feedback->id));

        // Create another student.

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

        $this->getDataGenerator()->enrol_user($anotherstudent->id, $this->course->id, $this->studentrole->id, 'manual');

        $this->setUser($anotherstudent);

        // Test user with full capabilities.

        $this->setUser($this->student);

        // Create a very simple feedback.

        $feedbackgenerator = $this->getDataGenerator()->get_plugin_generator('mod_feedback');

        $numericitem = $feedbackgenerator->create_item_numeric($this->feedback);

        $pagedata = [

            ['name' => $numericitem->typ .'_'. $numericitem->id, 'value' => 5],

        ];