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 core_communication;

use communication_matrix\matrix_test_helper_trait;

use core_communication\task\add_members_to_room_task;

use core_communication\task\create_and_configure_room_task;

use core_communication\task\delete_room_task;

use core_communication\task\update_room_membership_task;

use core_communication\task\update_room_task;

use core_communication\processor as communication_processor;

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

require_once(__DIR__ . '/../provider/matrix/tests/matrix_test_helper_trait.php');

require_once(__DIR__ . '/communication_test_helper_trait.php');

/**

 * Test communication hook listeners.

 *

 * @package    core_communication

 * @copyright  2023 Safat Shahin <safat.shahin@moodle.com>

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

 * @covers     \core_communication\hook_listener

 */

final class hook_listener_test extends \advanced_testcase {

    use communication_test_helper_trait;

    use matrix_test_helper_trait;

    public function setUp(): void {

        parent::setUp();

        $this->resetAfterTest();

        $this->setup_communication_configs();

        $this->initialise_mock_server();

    }

    /**

     * Test create_group_communication.

     */

    public function test_create_update_delete_group_communication(): void {

        global $DB;

        $course = $this->get_course(

            roomname: 'Test room name',

            extrafields: ['groupmode' => SEPARATEGROUPS],

        );

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

        $user1 = $this->getDataGenerator()->create_user();

        $user2 = $this->getDataGenerator()->create_user();

        // Enrol user1 as teacher.

        $teacherrole = $DB->get_record(

            table: 'role',

            conditions: ['shortname' => 'manager'],

        );

        $this->getDataGenerator()->enrol_user(

            userid: $user1->id,

            courseid: $course->id,

        );

        role_assign(

            roleid: $teacherrole->id,

            userid: $user1->id,

            contextid: $coursecontext->id,

        );

        // Enrol user2 as student.

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

        $this->getDataGenerator()->enrol_user(

            userid: $user2->id,

            courseid: $course->id,

        );

        role_assign(

            roleid: $studentrole->id,

            userid: $user2->id,

            contextid: $coursecontext->id,

        );

        $group = $this->getDataGenerator()->create_group(['courseid' => $course->id]);

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

        $groupcommunication = helper::load_by_group(

            groupid: $group->id,

            context: $context,

        );

        $this->assertInstanceOf(

            expected: communication_processor::class,

            actual: $groupcommunication->get_processor(),

        );

        $this->assertEquals(

            expected: $group->id,

            actual: $groupcommunication->get_processor()->get_instance_id(),

        );

        // Task to create room should be added.

        $adhoctask = \core\task\manager::get_adhoc_tasks(create_and_configure_room_task::class);

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

        // Task to add members to room should not be there as the room is yet to be created.

        $adhoctask = \core\task\manager::get_adhoc_tasks(add_members_to_room_task::class);

        $this->assertCount(0, $adhoctask);

        // Only users with access to all groups should be added to the room at this point.

        $groupcommunicationusers = $groupcommunication->get_processor()->get_all_userids_for_instance();

        $this->assertEquals(

            expected: [$user1->id],

            actual: $groupcommunicationusers,

        );

        // Now delete all the ad-hoc tasks.

        $DB->delete_records('task_adhoc');

        // Now cann the update group but don't change the group name.

        groups_update_group($group);

        // No task should be added as nothing changed.

        $adhoctask = \core\task\manager::get_adhoc_tasks(update_room_task::class);

        $this->assertCount(0, $adhoctask);

        // Now change the group name.

        $group->name = 'Changed group name';

        groups_update_group($group);

        // Now one task should be there to update the group room name.

        $adhoctask = \core\task\manager::get_adhoc_tasks(update_room_task::class);

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

        $groupcommunication->reload();

        $this->assertEquals(

            expected: 'Changed group name (Test room name)',

            actual: $groupcommunication->get_processor()->get_room_name(),

        );

        // Now delete the group.

        groups_delete_group($group->id);

        $adhoctask = \core\task\manager::get_adhoc_tasks(delete_room_task::class);

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

    }

    /**

     * Test inactive users are not included when being mapped to a new communication instance.

     */

    public function test_inactive_users_are_not_mapped_to_new_communication(): void {

        // Create a course without a communication provider set.

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

        // Enrol some users that are both active and inactive (suspended).

        $user1 = $this->getDataGenerator()->create_user();

        $user2 = $this->getDataGenerator()->create_user();

        $user3 = $this->getDataGenerator()->create_user();

        $user4 = $this->getDataGenerator()->create_user();

        $this->getDataGenerator()->enrol_user(

            userid: $user1->id,

            courseid: $course->id,

            roleidorshortname: 'teacher',

        );

        $this->getDataGenerator()->enrol_user(

            userid: $user2->id,

            courseid: $course->id,

            roleidorshortname: 'student',

        );

        $this->getDataGenerator()->enrol_user(

            userid: $user3->id,

            courseid: $course->id,

            roleidorshortname: 'teacher',

            status: ENROL_USER_SUSPENDED,

        );

        $this->getDataGenerator()->enrol_user(

            userid: $user4->id,

            courseid: $course->id,

            roleidorshortname: 'student',

            status: ENROL_USER_SUSPENDED,

        );

        // Set Matrix as the communication provider and update.

        $course->selectedcommunication = 'communication_matrix';

        $course->communication_matrixroomname = 'testroom';

        update_course($course);

        helper::update_course_communication_instance(

            course: $course,

            changesincoursecat: false,

        );

        // Load the communication instance and check that only the 2 active users are returned.

        $communication = helper::load_by_course(

            courseid: $course->id,

            context: \context_course::instance($course->id),

        );

        $userids = $communication->get_processor()->get_all_userids_for_instance();

        $this->assertEquals(

            expected: 2,

            actual: count($userids),

        );

        $this->assertContains(

            needle: $user1->id,

            haystack: $userids,

        );

        $this->assertContains(

            needle: $user2->id,

            haystack: $userids,

        );

    }

    /**

     * Test inactive users are not included when being mapped to a new communication instance using groups.

     */

    public function test_inactive_users_are_not_mapped_to_new_group_communication(): void {

        // Create a course without a communication provider set.

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

            options: ['groupmode' => SEPARATEGROUPS],

        );

        // Enrol some users that are both active and inactive (suspended).

        $user1 = $this->getDataGenerator()->create_user();

        $user2 = $this->getDataGenerator()->create_user();

        $user3 = $this->getDataGenerator()->create_user();

        $user4 = $this->getDataGenerator()->create_user();

        $this->getDataGenerator()->enrol_user(

            userid: $user1->id,

            courseid: $course->id,

            roleidorshortname: 'teacher',

        );

        $this->getDataGenerator()->enrol_user(

            userid: $user2->id,

            courseid: $course->id,

            roleidorshortname: 'student',

        );

        $this->getDataGenerator()->enrol_user(

            userid: $user3->id,

            courseid: $course->id,

            roleidorshortname: 'teacher',

            status: ENROL_USER_SUSPENDED,

        );

        $this->getDataGenerator()->enrol_user(

            userid: $user4->id,

            courseid: $course->id,

            roleidorshortname: 'student',

            status: ENROL_USER_SUSPENDED,

        );

        // Create a group and add all users to it.

        $group = $this->getDataGenerator()->create_group(['courseid' => $course->id]);

        groups_add_member(

            grouporid: $group,

            userorid: $user1,

        );

        groups_add_member(

            grouporid: $group,

            userorid: $user2,

        );

        groups_add_member(

            grouporid: $group,

            userorid: $user3,

        );

        groups_add_member(

            grouporid: $group,

            userorid: $user4,

        );

        // Set Matrix as the communication provider and update.

        $course->selectedcommunication = 'communication_matrix';

        $course->communication_matrixroomname = 'testroom';

        update_course($course);

        helper::update_group_communication_instances_for_course(

            course: $course,

            provider: 'communication_matrix',

        );

        // Load the communication instance and check that only the 2 active users are returned.

        $communication = helper::load_by_group(

            groupid: $group->id,

            context: \context_course::instance($course->id),

        );

        $userids = $communication->get_processor()->get_all_userids_for_instance();

        $this->assertEquals(

            expected: 2,

            actual: count($userids),

        );

        $this->assertContains(

            needle: $user1->id,

            haystack: $userids,

        );

        $this->assertContains(

            needle: $user2->id,

            haystack: $userids,

        );

    }

    /**

     * Test add_members_to_group_room.

     */

    public function test_add_members_to_group_room(): void {

        global $DB;

        $course = $this->get_course(

            extrafields: ['groupmode' => SEPARATEGROUPS],

        );

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

        $user1 = $this->getDataGenerator()->create_user();

        $user2 = $this->getDataGenerator()->create_user();

        // Enrol user1 as teacher.

        $teacherrole = $DB->get_record(

            table: 'role',

            conditions: ['shortname' => 'manager'],

        );

        $this->getDataGenerator()->enrol_user(

            userid: $user1->id,

            courseid: $course->id,

        );

        role_assign(

            roleid: $teacherrole->id,

            userid: $user1->id,

            contextid: $coursecontext->id,

        );

        // Enrol user2 as student.

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

        $this->getDataGenerator()->enrol_user(

            userid: $user2->id,

            courseid: $course->id,

        );

        role_assign(

            roleid: $studentrole->id,

            userid: $user2->id,

            contextid: $coursecontext->id,

        );

        $group = $this->getDataGenerator()->create_group(['courseid' => $course->id]);

        // Now check if the teacher is added to the group room as the teacher has access to all groups.

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

        $groupcommunication = helper::load_by_group(

            groupid: $group->id,

            context: $context,

        );

        // Now the communication instance should not have the student added yet.

        $this->assertNotContains(

            needle: $user2->id,

            haystack: $groupcommunication->get_processor()->get_all_userids_for_instance(),

        );

        groups_add_member(

            grouporid: $group,

            userorid: $user2,

        );

        // Now it should have the student.

        $this->assertContains(

            needle: $user2->id,

            haystack: $groupcommunication->get_processor()->get_all_userids_for_instance(),

        );

    }

    /**

     * Test if the course instances are created properly for course default provider.

     */

    public function test_course_default_provider(): void {

        $defaultprovider = 'communication_matrix';

        // Set the default communication for course.

        set_config(

            name: 'coursecommunicationprovider',

            value: $defaultprovider,

            plugin: 'moodlecourse',

        );

        // Test that the default communication is created for course mode.

        $course = $this->get_course();

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

        $coursecommunication = helper::load_by_course(

            courseid: $course->id,

            context: $coursecontext,

        );

        $this->assertEquals(

            expected: $defaultprovider,

            actual: $coursecommunication->get_provider(),

        );

        $this->assertEquals(

            expected: 'core_course',

            actual: $coursecommunication->get_processor()->get_component(),

        );

        $this->assertEquals(

            expected: $course->id,

            actual: $coursecommunication->get_processor()->get_instance_id(),

        );

    }

    /**

     * Test update_course_communication.

     */

    public function test_update_course_communication(): void {

        global $DB;

        // Set up the data with course, group, user etc.

        $user = $this->getDataGenerator()->create_user();

        $course = $this->get_course();

        $group = $this->getDataGenerator()->create_group(record: ['courseid' => $course->id]);

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

        $teacherrole = $DB->get_record(

            table: 'role',

            conditions: ['shortname' => 'teacher'],

        );

        $this->getDataGenerator()->enrol_user(

            userid: $user->id,

            courseid: $course->id,

        );

        role_assign(

            roleid: $teacherrole->id,

            userid: $user->id,

            contextid: $coursecontext->id,

        );

        groups_add_member(

            grouporid: $group->id,

            userorid: $user->id,

        );

        // Now test that there is communication instances for the course and the user added for that instance.

        $coursecommunication = helper::load_by_course(

            courseid: $course->id,

            context: $coursecontext,

        );

        $this->assertInstanceOf(

            expected: communication_processor::class,

            actual: $coursecommunication->get_processor(),

        );

        // Check the user is added for course communication instance.

        $courseusers = $coursecommunication->get_processor()->get_all_userids_for_instance();

        $courseusers = reset($courseusers);

        $this->assertEquals(

            expected: $user->id,

            actual: $courseusers,

        );

        // Group should not have any instance yet.

        $groupcommunication = helper::load_by_group(

            groupid: $group->id,

            context: $coursecontext,

        );

        $this->assertNull(actual: $groupcommunication->get_processor());

        // Now update the course.

        $course->groupmode = SEPARATEGROUPS;

        $course->selectedcommunication = 'communication_matrix';

        update_course(data: $course);

        // Now there should be a group communication instance.

        $groupcommunication->reload();

        $this->assertInstanceOf(

            expected: communication_processor::class,

            actual: $groupcommunication->get_processor(),

        );

        // The course communication instance must be active.

        $coursecommunication->reload();

        $this->assertInstanceOf(

            expected: communication_processor::class,

            actual: $coursecommunication->get_processor(),

        );

        // All the course instance users must be marked as deleted.

        $coursecommunication->reload();

        $courseusers = $coursecommunication->get_processor()->get_all_delete_flagged_userids();

        $courseusers = reset($courseusers);

        $this->assertEquals(

            expected: $user->id,

            actual: $courseusers,

        );

        // Group instance should have the user.

        $groupusers = $groupcommunication->get_processor()->get_all_userids_for_instance();

        $groupusers = reset($groupusers);

        $this->assertEquals(

            expected: $user->id,

            actual: $groupusers,

        );

        // Now disable the communication instance for the course.

        $course->selectedcommunication = communication_processor::PROVIDER_NONE;

        update_course(data: $course);

        // Now both course and group instance should be disabled.

        $coursecommunication->reload();

        $this->assertNull(actual: $coursecommunication->get_processor());

        $groupcommunication->reload();

        $this->assertNull(actual: $groupcommunication->get_processor());

    }

    /**

     * Test create_course_communication_instance.

     */

    public function test_create_course_communication_instance(): void {

        $course = $this->get_course();

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

        $coursecommunication = helper::load_by_course(

            courseid: $course->id,

            context: $coursecontext,

        );

        $processor = $coursecommunication->get_processor();

        $this->assertEquals(

            expected: 'communication_matrix',

            actual: $processor->get_provider(),

        );

        $this->assertEquals(

            expected: 'Sampleroom',

            actual: $processor->get_room_name(),

        );

    }

    /**

     * Test delete_course_communication.

     */

    public function test_delete_course_communication(): void {

        $course = $this->get_course();

        delete_course(

            courseorid: $course,

            showfeedback: false,

        );

        $adhoctask = \core\task\manager::get_adhoc_tasks(delete_room_task::class);

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

    }

    /**

     * Test update of room membership when user changes occur.

     */

    public function test_update_user_room_memberships(): void {

        global $DB;

        $user = $this->getDataGenerator()->create_user();

        $course = $this->get_course();

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

        $teacherrole = $DB->get_record('role', ['shortname' => 'teacher']);

        $this->getDataGenerator()->enrol_user($user->id, $course->id);

        role_assign($teacherrole->id, $user->id, $coursecontext->id);

        $coursecommunication = helper::load_by_course($course->id, $coursecontext);

        $courseusers = $coursecommunication->get_processor()->get_all_userids_for_instance();

        $courseusers = reset($courseusers);

        $this->assertEquals($user->id, $courseusers);

        $user->suspended = 1;

        user_update_user($user, false);

        $coursecommunication->reload();

        $courseusers = $coursecommunication->get_processor()->get_all_delete_flagged_userids();

        $courseusers = reset($courseusers);

        $this->assertEquals($user->id, $courseusers);

    }

    /**

     * Test deletion of user room memberships when a user is deleted.

     */

    public function test_delete_user_room_memberships(): void {

        global $DB;

        $user = $this->getDataGenerator()->create_user();

        $course = $this->get_course();

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

        $teacherrole = $DB->get_record('role', ['shortname' => 'teacher']);

        $this->getDataGenerator()->enrol_user($user->id, $course->id);

        role_assign($teacherrole->id, $user->id, $coursecontext->id);

        delete_user($user);

        $coursecommunication = helper::load_by_course($course->id, $coursecontext);

        $courseusers = $coursecommunication->get_processor()->get_all_userids_for_instance();

        $this->assertEmpty($courseusers);

    }

    /**

     * Test user room membership updates with role changes in a course.

     */

    public function test_update_user_membership_for_role_changes(): void {

        global $DB;

        $user = $this->getDataGenerator()->create_user();

        $course = $this->get_course();

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

        $teacherrole = $DB->get_record('role', ['shortname' => 'teacher']);

        $this->getDataGenerator()->enrol_user($user->id, $course->id);

        $adhoctask = \core\task\manager::get_adhoc_tasks(update_room_membership_task::class);

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

        role_assign($teacherrole->id, $user->id, $coursecontext->id);

        $adhoctask = \core\task\manager::get_adhoc_tasks(update_room_membership_task::class);

        $this->assertCount(2, $adhoctask);

    }

}