David Woloszyn
572 lines
18 KiB
PHP
572 lines
18 KiB
PHP
<?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 communication_matrix;
|
|
|
|
use core\context;
|
|
use core_communication\api;
|
|
use core_communication\communication_test_helper_trait;
|
|
use core_communication\processor;
|
|
use stored_file;
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
require_once(__DIR__ . '/matrix_test_helper_trait.php');
|
|
require_once(__DIR__ . '/../../../tests/communication_test_helper_trait.php');
|
|
|
|
/**
|
|
* Class communication_feature_test to test the matrix features implemented using the core interfaces.
|
|
*
|
|
* @package communication_matrix
|
|
* @category test
|
|
* @copyright 2023 Safat Shahin <safat.shahin@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
* @covers \communication_matrix\communication_feature
|
|
* @coversDefaultClass \communication_matrix\communication_feature
|
|
*/
|
|
class communication_feature_test extends \advanced_testcase {
|
|
use matrix_test_helper_trait;
|
|
use communication_test_helper_trait;
|
|
|
|
public function setUp(): void {
|
|
parent::setUp();
|
|
$this->resetAfterTest();
|
|
$this->setup_communication_configs();
|
|
$this->initialise_mock_server();
|
|
}
|
|
|
|
/**
|
|
* Test create or update chat room.
|
|
*
|
|
* @covers ::create_chat_room
|
|
*/
|
|
public function test_create_chat_room(): void {
|
|
// Set up the test data first.
|
|
$communication = \core_communication\api::load_by_instance(
|
|
context: \core\context\system::instance(),
|
|
component: 'communication_matrix',
|
|
instancetype: 'example',
|
|
instanceid: 1,
|
|
provider: 'communication_matrix',
|
|
);
|
|
|
|
$communication->create_and_configure_room(
|
|
communicationroomname: 'Room name',
|
|
instance: (object) [
|
|
'matrixroomtopic' => 'A fun topic',
|
|
],
|
|
);
|
|
|
|
// phpcs:ignore moodle.Commenting.InlineComment.DocBlock
|
|
/** @var communication_feature */
|
|
$provider = $communication->get_room_provider();
|
|
$this->assertInstanceOf(
|
|
communication_feature::class,
|
|
$provider,
|
|
);
|
|
|
|
// Run the create_chat_room task.
|
|
$result = $provider->create_chat_room();
|
|
$this->assertTrue($result);
|
|
|
|
// Ensure that a room_id was set.
|
|
$this->assertNotEmpty($provider->get_room_id());
|
|
|
|
// Fetch the back office room data.
|
|
$remoteroom = $this->backoffice_get_room();
|
|
|
|
// The roomid set in the database must match the one set on the remote server.
|
|
$this->assertEquals(
|
|
$remoteroom->room_id,
|
|
$provider->get_room_id(),
|
|
);
|
|
|
|
// The name is a feature of the communication API itself.
|
|
$this->assertEquals(
|
|
'Room name',
|
|
$communication->get_room_name(),
|
|
);
|
|
$this->assertEquals(
|
|
$communication->get_room_name(),
|
|
$remoteroom->name,
|
|
);
|
|
|
|
// The topic is a Matrix feature.
|
|
$roomconfig = $provider->get_room_configuration();
|
|
$this->assertEquals(
|
|
'A fun topic',
|
|
$roomconfig->get_topic(),
|
|
);
|
|
$this->assertEquals(
|
|
$remoteroom->topic,
|
|
$roomconfig->get_topic(),
|
|
);
|
|
|
|
// The avatar features are checked in a separate test.
|
|
}
|
|
|
|
/**
|
|
* Test update of a chat room.
|
|
*
|
|
* @covers ::update_chat_room
|
|
*/
|
|
public function test_update_chat_room(): void {
|
|
$communication = $this->create_room(
|
|
roomname: 'Our room name',
|
|
roomtopic: 'Our room topic',
|
|
);
|
|
|
|
// phpcs:ignore moodle.Commenting.InlineComment.DocBlock
|
|
/** @var communication_feature */
|
|
$provider = $communication->get_room_provider();
|
|
$this->assertInstanceOf(
|
|
communication_feature::class,
|
|
$provider,
|
|
);
|
|
|
|
// Update the room name.
|
|
// Note: We have to update the record via the API, and then call the provider update method.
|
|
// That's because the update is performed asynchronously.
|
|
$communication->update_room(
|
|
communicationroomname: 'Our updated room name',
|
|
);
|
|
$provider->reload();
|
|
|
|
// Now call the provider's update method.
|
|
$provider->update_chat_room();
|
|
|
|
// And assert that it was updated remotely.
|
|
$remoteroom = $this->backoffice_get_room();
|
|
|
|
$this->assertEquals(
|
|
'Our updated room name',
|
|
$communication->get_room_name(),
|
|
);
|
|
$this->assertEquals(
|
|
$communication->get_room_name(),
|
|
$remoteroom->name,
|
|
);
|
|
// The remote topic should not have changed.
|
|
$this->assertEquals(
|
|
'Our room topic',
|
|
$remoteroom->topic,
|
|
);
|
|
|
|
// Now update just the topic.
|
|
// First in the local API.
|
|
$communication->update_room(
|
|
instance: (object) [
|
|
'matrixroomtopic' => 'Our updated room topic',
|
|
],
|
|
);
|
|
|
|
$provider->reload();
|
|
|
|
// Then call the provider's update method to actually perform the change.
|
|
$provider->update_chat_room();
|
|
|
|
// And assert that it was updated remotely.
|
|
$remoteroom = $this->backoffice_get_room();
|
|
|
|
$this->assertEquals(
|
|
'Our updated room topic',
|
|
$provider->get_room_configuration()->get_topic(),
|
|
);
|
|
|
|
// The remote topic should have been updated.
|
|
$this->assertEquals(
|
|
'Our updated room topic',
|
|
$remoteroom->topic,
|
|
);
|
|
|
|
// The name should not have changed.
|
|
$this->assertEquals(
|
|
'Our updated room name',
|
|
$communication->get_room_name(),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test delete chat room.
|
|
*
|
|
* @covers ::delete_chat_room
|
|
*/
|
|
public function test_delete_chat_room(): void {
|
|
$communication = $this->create_room();
|
|
|
|
$processor = $communication->get_processor();
|
|
$provider = $communication->get_room_provider();
|
|
$room = matrix_room::load_by_processor_id($processor->get_id());
|
|
|
|
// Run the delete method.
|
|
$this->assertTrue($provider->delete_chat_room());
|
|
|
|
// The record of the room should have been removed.
|
|
$this->assertNull(matrix_room::load_by_processor_id($processor->get_id()));
|
|
|
|
// But the room itself shoudl exist.
|
|
$matrixroomdata = $this->get_matrix_room_data($room->get_room_id());
|
|
|
|
$this->assertNotEmpty($matrixroomdata);
|
|
$this->assertEquals($processor->get_room_name(), $matrixroomdata->name);
|
|
$this->assertEquals($room->get_topic(), $matrixroomdata->topic);
|
|
}
|
|
|
|
/**
|
|
* Test update room avatar.
|
|
*
|
|
* @covers ::update_room_avatar
|
|
* @dataProvider avatar_provider
|
|
*/
|
|
public function test_update_room_avatar(
|
|
?string $before,
|
|
?string $after,
|
|
): void {
|
|
$this->setAdminUser();
|
|
|
|
// Create a new draft file.
|
|
$logo = $this->create_communication_file('moodle_logo.jpg', 'logo.jpg');
|
|
$circle = $this->create_communication_file('circle.png', 'circle.png');
|
|
|
|
if ($before === 'logo') {
|
|
$before = $logo;
|
|
} else if ($before === 'circle') {
|
|
$before = $circle;
|
|
}
|
|
|
|
if ($after === 'logo') {
|
|
$after = $logo;
|
|
} else if ($after === 'circle') {
|
|
$after = $circle;
|
|
}
|
|
|
|
$communication = $this->create_matrix_room(
|
|
component: 'communication_matrix',
|
|
itemtype: 'example_room',
|
|
itemid: 1,
|
|
roomname: 'Example room name',
|
|
roomavatar: $before,
|
|
);
|
|
|
|
// Confirm that the avatar was set remotely.
|
|
$remoteroom = $this->backoffice_get_room();
|
|
|
|
if ($before) {
|
|
$this->assertStringEndsWith($before->get_filename(), $remoteroom->avatar);
|
|
$avatarcontent = download_file_content($remoteroom->avatar);
|
|
$this->assertEquals($before->get_content(), $avatarcontent);
|
|
} else {
|
|
$this->assertEmpty($remoteroom->avatar);
|
|
}
|
|
|
|
// Reload the API instance as the information stored has changed.
|
|
$communication->reload();
|
|
|
|
// Update the avatar with the 'after' avatar.
|
|
$communication->update_room(
|
|
avatar: $after,
|
|
);
|
|
$this->run_all_adhoc_tasks();
|
|
|
|
// Confirm that the avatar was updated remotely.
|
|
$remoteroom = $this->backoffice_get_room();
|
|
|
|
if ($after) {
|
|
$this->assertStringEndsWith($after->get_filename(), $remoteroom->avatar);
|
|
$avatarcontent = download_file_content($remoteroom->avatar);
|
|
$this->assertEquals($after->get_content(), $avatarcontent);
|
|
} else {
|
|
$this->assertEmpty($remoteroom->avatar);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests for setting and updating the room avatar.
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function avatar_provider(): array {
|
|
return [
|
|
'Empty to avatar' => [
|
|
null,
|
|
'circle',
|
|
],
|
|
'Avatar to empty' => [
|
|
'circle',
|
|
null,
|
|
],
|
|
'Avatar to new avatar' => [
|
|
'circle',
|
|
'logo',
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Test get chat room url.
|
|
*
|
|
* @covers ::get_chat_room_url
|
|
*/
|
|
public function test_get_chat_room_url(): void {
|
|
$communication = $this->create_room();
|
|
|
|
$provider = $communication->get_room_provider();
|
|
|
|
$url = $provider->get_chat_room_url();
|
|
$this->assertNotNull($url);
|
|
|
|
// Fetch the room information from the server.
|
|
$remoteroom = $this->backoffice_get_room();
|
|
|
|
$this->assertStringEndsWith(
|
|
$remoteroom->room_id,
|
|
$url,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test create members.
|
|
*
|
|
* @covers ::create_members
|
|
* @covers ::add_registered_matrix_user_to_room
|
|
*/
|
|
public function test_create_members(): void {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
|
|
$communication = $this->create_room(
|
|
members: [
|
|
$user->id,
|
|
],
|
|
);
|
|
|
|
$remoteroom = $this->backoffice_get_room();
|
|
$this->assertCount(1, $remoteroom->members);
|
|
$member = reset($remoteroom->members);
|
|
$this->assertStringStartsWith("@{$user->username}", $member->userid);
|
|
}
|
|
|
|
/**
|
|
* Test add/remove members from room.
|
|
*
|
|
* @covers ::remove_members_from_room
|
|
* @covers ::add_members_to_room
|
|
* @covers ::add_registered_matrix_user_to_room
|
|
* @covers ::check_room_membership
|
|
* @covers ::set_matrix_power_levels
|
|
*/
|
|
public function test_add_and_remove_members_from_room(): void {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$user2 = $this->getDataGenerator()->create_user();
|
|
|
|
$communication = $this->create_room();
|
|
$provider = $communication->get_room_user_provider();
|
|
|
|
$remoteroom = $this->backoffice_get_room();
|
|
$this->assertCount(0, $remoteroom->members);
|
|
|
|
// Add the members to the room.
|
|
$provider->add_members_to_room([$user->id, $user2->id]);
|
|
|
|
// Ensure that they have been created.
|
|
$remoteroom = $this->backoffice_get_room();
|
|
$this->assertCount(2, $remoteroom->members);
|
|
|
|
$userids = array_map(fn($member) => $member->userid, $remoteroom->members);
|
|
$userids = array_map(fn($userid) => substr($userid, 0, strpos($userid, ':')), $userids);
|
|
$this->assertContains("@{$user->username}", $userids);
|
|
$this->assertContains("@{$user2->username}", $userids);
|
|
|
|
// Remove member from matrix room.
|
|
$provider->remove_members_from_room([$user->id]);
|
|
|
|
// Ensure that they have been removed.
|
|
$remoteroom = $this->backoffice_get_room();
|
|
$members = (array) $remoteroom->members;
|
|
$this->assertCount(1, $members);
|
|
$userids = array_map(fn ($member) => $member->userid, $members);
|
|
$userids = array_map(fn ($userid) => substr($userid, 0, strpos($userid, ':')), $userids);
|
|
$this->assertNotContains("@{$user->username}", $userids);
|
|
$this->assertContains("@{$user2->username}", $userids);
|
|
}
|
|
|
|
/**
|
|
* Test update of room membership.
|
|
*
|
|
* @covers ::update_room_membership
|
|
* @covers ::set_matrix_power_levels
|
|
* @covers ::is_power_levels_update_required
|
|
* @covers ::get_user_allowed_power_level
|
|
*/
|
|
public function test_update_room_membership(): void {
|
|
$this->resetAfterTest();
|
|
|
|
global $DB;
|
|
|
|
// Create a new room.
|
|
$course = $this->get_course('Sampleroom', 'none');
|
|
$coursecontext = \context_course::instance($course->id);
|
|
$user = $this->get_user();
|
|
|
|
$communication = $this->create_room(
|
|
component: 'core_course',
|
|
itemtype: 'coursecommunication',
|
|
itemid: $course->id,
|
|
roomname: 'sampleroom',
|
|
roomtopic: 'sampltopic',
|
|
roomavatar: null,
|
|
members: [$user->id],
|
|
context: $coursecontext,
|
|
);
|
|
|
|
$provider = $communication->get_room_user_provider();
|
|
|
|
// Add the members to the room.
|
|
$provider->add_members_to_room([$user->id]);
|
|
|
|
// Assign teacher role to the user.
|
|
$teacherrole = $DB->get_record('role', ['shortname' => 'teacher']);
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id);
|
|
role_assign($teacherrole->id, $user->id, $coursecontext->id);
|
|
|
|
// Test the tasks added as the role is a teacher.
|
|
$provider->update_room_membership([$user->id]);
|
|
|
|
$processor = \core_communication\processor::load_by_instance(
|
|
context: $coursecontext,
|
|
component: 'core_course',
|
|
instancetype: 'coursecommunication',
|
|
instanceid: $course->id,
|
|
);
|
|
$synceduser = $processor->get_instance_userids(
|
|
synced: true,
|
|
);
|
|
$synceduser = reset($synceduser);
|
|
|
|
// Test if the communication user record is synced.
|
|
$this->assertEquals($user->id, $synceduser);
|
|
}
|
|
|
|
/**
|
|
* Test the user power level allocation according to context.
|
|
*
|
|
* @covers ::get_user_allowed_power_level
|
|
*/
|
|
public function test_get_user_allowed_power_level(): void {
|
|
$this->resetAfterTest();
|
|
global $DB;
|
|
|
|
// Create users.
|
|
$user1 = $this->getDataGenerator()->create_user();
|
|
$user2 = $this->getDataGenerator()->create_user();
|
|
|
|
$course = $this->get_course();
|
|
$coursecontext = \context_course::instance($course->id);
|
|
$teacherrole = $DB->get_record('role', ['shortname' => 'editingteacher']);
|
|
$studentrole = $DB->get_record('role', ['shortname' => 'student']);
|
|
$this->getDataGenerator()->enrol_user($user1->id, $course->id);
|
|
$this->getDataGenerator()->enrol_user($user2->id, $course->id);
|
|
// Assign roles.
|
|
role_assign($teacherrole->id, $user1->id, $coursecontext->id);
|
|
role_assign($studentrole->id, $user2->id, $coursecontext->id);
|
|
|
|
$communicationprocessor = processor::load_by_instance(
|
|
context: \core\context\course::instance($course->id),
|
|
component: 'core_course',
|
|
instancetype: 'coursecommunication',
|
|
instanceid: $course->id
|
|
);
|
|
|
|
// Test if the power level is set according to the context.
|
|
$this->assertEquals(
|
|
matrix_constants::POWER_LEVEL_MOODLE_MODERATOR,
|
|
$communicationprocessor->get_room_provider()->get_user_allowed_power_level($user1->id)
|
|
);
|
|
$this->assertEquals(
|
|
matrix_constants::POWER_LEVEL_DEFAULT,
|
|
$communicationprocessor->get_room_provider()->get_user_allowed_power_level($user2->id)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Helper to create a room.
|
|
*
|
|
* @param null|string $component
|
|
* @param null|string $itemtype
|
|
* @param null|int $itemid
|
|
* @param null|string $roomname
|
|
* @param null|string $roomtopic
|
|
* @param null|stored_file $roomavatar
|
|
* @param array $members
|
|
* @return api
|
|
*/
|
|
protected function create_room(
|
|
?string $component = 'communication_matrix',
|
|
?string $itemtype = 'example',
|
|
?int $itemid = 1,
|
|
?string $roomname = null,
|
|
?string $roomtopic = null,
|
|
?\stored_file $roomavatar = null,
|
|
array $members = [],
|
|
?context $context = null,
|
|
): \core_communication\api {
|
|
// Create a new room.
|
|
$communication = \core_communication\api::load_by_instance(
|
|
context: $context ?? \core\context\system::instance(),
|
|
component: $component,
|
|
instancetype: $itemtype,
|
|
instanceid: $itemid,
|
|
provider: 'communication_matrix',
|
|
);
|
|
|
|
$communication->create_and_configure_room(
|
|
communicationroomname: $roomname ?? 'Room name',
|
|
avatar: $roomavatar,
|
|
instance: (object) [
|
|
'matrixroomtopic' => $roomtopic ?? 'A fun topic',
|
|
],
|
|
);
|
|
|
|
$communication->add_members_to_room($members);
|
|
|
|
// Run the adhoc task.
|
|
$this->run_all_adhoc_tasks();
|
|
|
|
$communication->reload();
|
|
return $communication;
|
|
}
|
|
|
|
/**
|
|
* Test if the selected provider is configured.
|
|
*
|
|
* @covers ::is_configured
|
|
*/
|
|
public function test_is_configured(): void {
|
|
$course = $this->get_course();
|
|
$communicationprocessor = processor::load_by_instance(
|
|
context: \core\context\course::instance($course->id),
|
|
component: 'core_course',
|
|
instancetype: 'coursecommunication',
|
|
instanceid: $course->id
|
|
);
|
|
$this->assertTrue($communicationprocessor->get_room_provider()->is_configured());
|
|
|
|
// Unset communication_matrix settings.
|
|
unset_config('matrixhomeserverurl', 'communication_matrix');
|
|
unset_config('matrixaccesstoken', 'communication_matrix');
|
|
$this->assertFalse($communicationprocessor->get_room_provider()->is_configured());
|
|
}
|
|
}
|