communication/tests/processor_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/>.
  16
  17 namespace core_communication;
  18
  19 use communication_matrix\matrix_test_helper_trait;
  20
  21 defined('MOODLE_INTERNAL') || die();
  22
  23 require_once(__DIR__ . '/../provider/matrix/tests/matrix_test_helper_trait.php');
  24 require_once(__DIR__ . '/communication_test_helper_trait.php');
  25
  26 /**
  27  * Class processor_test to test the communication internal api and its associated methods.
  28  *
  29  * @package    core_communication
  30  * @category   test
  31  * @copyright  2023 Safat Shahin <safat.shahin@moodle.com>
  32  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  33  * @coversDefaultClass \core_communication\processor
  34  */
  35 class processor_test extends \advanced_testcase {
  36     use matrix_test_helper_trait;
  37     use communication_test_helper_trait;
  38
  39     public function setUp(): void {
  40         parent::setUp();
  41         $this->resetAfterTest();
  42         $this->setup_communication_configs();
  43         $this->initialise_mock_server();
  44     }
  45
  46     /**
  47      * Test create instance.
  48      *
  49      * @covers ::create_instance
  50      * @covers ::get_id
  51      * @covers ::get_instance
  52      * @covers ::get_room_name
  53      */
  54     public function test_create_instance(): void {
  55         global $DB;
  56         $this->resetAfterTest();
  57
  58         // Sample test data.
  59         $instanceid = 10;
  60         $context = \core\context\system::instance();
  61         $component = 'core';
  62         $instancetype = 'mycommunication';
  63         $selectedcommunication = 'communication_matrix';
  64         $communicationroomname = 'communicationroom';
  65
  66         $communicationprocessor = processor::create_instance(
  67             $context,
  68             $selectedcommunication,
  69             $instanceid,
  70             $component,
  71             $instancetype,
  72             $communicationroomname,
  73         );
  74
  75         // Now test the record against the database.
  76         $communicationrecord = $DB->get_record(
  77             'communication',
  78             ['instanceid' => $instanceid, 'component' => $component, 'instancetype' => $instancetype]
  79         );
  80
  81         // Test against the set data.
  82         $this->assertNotEmpty($communicationrecord);
  83         $this->assertEquals($context->id, $communicationrecord->contextid);
  84         $this->assertEquals($instanceid, $communicationrecord->instanceid);
  85         $this->assertEquals($component, $communicationrecord->component);
  86         $this->assertEquals($selectedcommunication, $communicationrecord->provider);
  87         $this->assertEquals($communicationroomname, $communicationrecord->roomname);
  88         $this->assertEquals($instancetype, $communicationrecord->instancetype);
  89
  90         // Test against the object.
  91         $this->assertEquals($context->id, $communicationprocessor->get_context_id());
  92         $this->assertEquals($context, $communicationprocessor->get_context());
  93         $this->assertEquals($communicationprocessor->get_id(), $communicationrecord->id);
  94         $this->assertEquals($communicationprocessor->get_provider(), $communicationrecord->provider);
  95         $this->assertEquals($communicationprocessor->get_room_name(), $communicationrecord->roomname);
  96     }
  97
  98     /**
  99      * Test update instance.
 100      *
 101      * @covers ::update_instance
 102      * @covers ::is_instance_active
 103      * @covers ::get_id
 104      * @covers ::get_room_name
 105      */
 106     public function test_update_instance(): void {
 107         global $DB;
 108         $this->resetAfterTest();
 109
 110         // Sameple test data.
 111         $instanceid = 10;
 112         $context = \core\context\system::instance();
 113         $component = 'core';
 114         $instancetype = 'mycommunication';
 115         $selectedcommunication = 'communication_matrix';
 116         $communicationroomname = 'communicationroom';
 117
 118         $communicationprocessor = processor::create_instance(
 119             $context,
 120             $selectedcommunication,
 121             $instanceid,
 122             $component,
 123             $instancetype,
 124             $communicationroomname,
 125         );
 126
 127         $selectedcommunication = 'none';
 128         $communicationroomname = 'communicationroomedited';
 129
 130         $communicationprocessor->update_instance(processor::PROVIDER_INACTIVE, $communicationroomname);
 131
 132         // Now test the record against the database.
 133         $communicationrecord = $DB->get_record('communication', [
 134             'instanceid' => $instanceid,
 135             'component' => $component,
 136             'instancetype' => $instancetype,
 137         ]);
 138
 139         // Test against the set data.
 140         $this->assertNotEmpty($communicationrecord);
 141         $this->assertEquals($context->id, $communicationrecord->contextid);
 142         $this->assertEquals($instanceid, $communicationrecord->instanceid);
 143         $this->assertEquals($component, $communicationrecord->component);
 144         $this->assertEquals(processor::PROVIDER_INACTIVE, $communicationrecord->active);
 145         $this->assertEquals($communicationroomname, $communicationrecord->roomname);
 146         $this->assertEquals($instancetype, $communicationrecord->instancetype);
 147
 148         // Test against the object.
 149         $this->assertEquals($context->id, $communicationprocessor->get_context_id());
 150         $this->assertEquals($context, $communicationprocessor->get_context());
 151         $this->assertEquals($communicationprocessor->get_id(), $communicationrecord->id);
 152         $this->assertEquals($communicationprocessor->is_instance_active(), $communicationrecord->active);
 153         $this->assertEquals($communicationprocessor->get_room_name(), $communicationrecord->roomname);
 154     }
 155
 156     /**
 157      * Test delete instance.
 158      *
 159      * @covers ::delete_instance
 160      * @covers ::create_instance
 161      * @covers ::load_by_instance
 162      */
 163     public function test_delete_instance(): void {
 164         global $DB;
 165         $this->resetAfterTest();
 166
 167         // Sameple test data.
 168         $instanceid = 10;
 169         $context = \core\context\system::instance();
 170         $component = 'core';
 171         $instancetype = 'mycommunication';
 172         $selectedcommunication = 'communication_matrix';
 173         $communicationroomname = 'communicationroom';
 174
 175         $communicationprocessor = processor::create_instance(
 176             $context,
 177             $selectedcommunication,
 178             $instanceid,
 179             $component,
 180             $instancetype,
 181             $communicationroomname,
 182         );
 183
 184         $communicationprocessor->delete_instance();
 185
 186         // Now test the record against the database.
 187         $communicationrecord = $DB->get_record('communication', [
 188             'instanceid' => $instanceid,
 189             'component' => $component,
 190             'instancetype' => $instancetype,
 191         ]);
 192
 193         // Test against the set data.
 194         $this->assertEmpty($communicationrecord);
 195
 196         // Test against the object.
 197         $communicationprocessor = processor::load_by_instance(
 198             context: $context,
 199             component: $component,
 200             instancetype: $instancetype,
 201             instanceid: $instanceid,
 202         );
 203         $this->assertNull($communicationprocessor);
 204     }
 205
 206     /**
 207      * Test load by id.
 208      *
 209      * @covers ::load_by_instance
 210      * @covers ::get_room_provider
 211      */
 212     public function test_load_by_instance(): void {
 213         $this->resetAfterTest();
 214         $course = $this->get_course();
 215         $context = \core\context\course::instance($course->id);
 216
 217         // Test the communication record exists.
 218         $communicationprocessor = processor::load_by_instance(
 219             context: $context,
 220             component: 'core_course',
 221             instancetype: 'coursecommunication',
 222             instanceid: $course->id,
 223         );
 224
 225         $this->assertNotNull($communicationprocessor);
 226         $this->assertInstanceOf(communication_provider::class, $communicationprocessor->get_room_provider());
 227         $this->assertInstanceOf(room_chat_provider::class, $communicationprocessor->get_room_provider());
 228         $this->assertInstanceOf(room_user_provider::class, $communicationprocessor->get_room_provider());
 229         $this->assertInstanceOf(user_provider::class, $communicationprocessor->get_room_provider());
 230     }
 231
 232     /**
 233      * Test load by id.
 234      *
 235      * @covers ::load_by_id
 236      * @covers ::get_room_provider
 237      * @covers ::load_by_instance
 238      */
 239     public function test_load_by_id(): void {
 240         $this->resetAfterTest();
 241         $course = $this->get_course();
 242         $context = \core\context\course::instance($course->id);
 243
 244         // Test the communication record exists.
 245         $communicationprocessor = processor::load_by_instance(
 246             context: $context,
 247             component: 'core_course',
 248             instancetype: 'coursecommunication',
 249             instanceid: $course->id,
 250         );
 251
 252         $communicationprocessorbyid = processor::load_by_id($communicationprocessor->get_id());
 253
 254         $this->assertNotNull($communicationprocessorbyid);
 255         $this->assertInstanceOf(communication_provider::class, $communicationprocessorbyid->get_room_provider());
 256         $this->assertInstanceOf(room_chat_provider::class, $communicationprocessorbyid->get_room_provider());
 257         $this->assertInstanceOf(room_user_provider::class, $communicationprocessorbyid->get_room_provider());
 258         $this->assertInstanceOf(user_provider::class, $communicationprocessorbyid->get_room_provider());
 259     }
 260
 261     /**
 262      * Test get component.
 263      *
 264      * @covers ::get_component
 265      * @covers ::load_by_instance
 266      */
 267     public function test_get_component(): void {
 268         $this->resetAfterTest();
 269         $course = $this->get_course();
 270         $context = \core\context\course::instance($course->id);
 271
 272         // Test the communication record exists.
 273         $communicationprocessor = processor::load_by_instance(
 274             context: $context,
 275             component: 'core_course',
 276             instancetype: 'coursecommunication',
 277             instanceid: $course->id,
 278         );
 279
 280         $this->assertEquals('core_course', $communicationprocessor->get_component());
 281     }
 282
 283     /**
 284      * Test get provider.
 285      *
 286      * @covers ::get_provider
 287      * @covers ::load_by_instance
 288      */
 289     public function test_get_provider(): void {
 290         $this->resetAfterTest();
 291         $course = $this->get_course();
 292         $context = \core\context\course::instance($course->id);
 293
 294         // Test the communication record exists when fetching the active provider.
 295         $communicationprocessor = processor::load_by_instance(
 296             context: $context,
 297             component: 'core_course',
 298             instancetype: 'coursecommunication',
 299             instanceid: $course->id,
 300         );
 301
 302         $this->assertEquals('communication_matrix', $communicationprocessor->get_provider());
 303
 304         // Test the communication record exists when specifying the provider.
 305         $communicationprocessor = processor::load_by_instance(
 306             context: $context,
 307             component: 'core_course',
 308             instancetype: 'coursecommunication',
 309             instanceid: $course->id,
 310             provider: 'communication_matrix',
 311         );
 312
 313         $this->assertEquals('communication_matrix', $communicationprocessor->get_provider());
 314
 315         // Test the communication record exists when the provider is not active.
 316         $communicationprocessor->update_instance(processor::PROVIDER_INACTIVE);
 317         $communicationprocessor = processor::load_by_instance(
 318             context: $context,
 319             component: 'core_course',
 320             instancetype: 'coursecommunication',
 321             instanceid: $course->id,
 322             provider: 'communication_matrix',
 323         );
 324
 325         $this->assertEquals('communication_matrix', $communicationprocessor->get_provider());
 326     }
 327
 328     /**
 329      * Test get room name.
 330      *
 331      * @covers ::get_room_name
 332      * @covers ::load_by_instance
 333      */
 334     public function test_get_room_name(): void {
 335         $this->resetAfterTest();
 336         $course = $this->get_course();
 337         $context = \core\context\course::instance($course->id);
 338
 339         // Test the communication record exists.
 340         $communicationprocessor = processor::load_by_instance(
 341             context: $context,
 342             component: 'core_course',
 343             instancetype: 'coursecommunication',
 344             instanceid: $course->id,
 345         );
 346
 347         $this->assertEquals('Sampleroom', $communicationprocessor->get_room_name());
 348     }
 349
 350     /**
 351      * Test get room provider.
 352      *
 353      * @covers ::get_room_provider
 354      * @covers ::require_room_features
 355      * @covers ::supports_room_features
 356      * @covers ::load_by_instance
 357      */
 358     public function test_get_room_provider(): void {
 359         $this->resetAfterTest();
 360         $course = $this->get_course();
 361         $context = \core\context\course::instance($course->id);
 362
 363         // Test the communication record exists.
 364         $communicationprocessor = processor::load_by_instance(
 365             context: $context,
 366             component: 'core_course',
 367             instancetype: 'coursecommunication',
 368             instanceid: $course->id,
 369         );
 370
 371         $this->assertInstanceOf(room_chat_provider::class, $communicationprocessor->get_room_provider());
 372     }
 373
 374     /**
 375      * Test get user provider.
 376      *
 377      * @covers ::get_user_provider
 378      * @covers ::require_user_features
 379      * @covers ::supports_user_features
 380      * @covers ::load_by_instance
 381      */
 382     public function test_get_user_provider(): void {
 383         $this->resetAfterTest();
 384         $course = $this->get_course();
 385         $context = \core\context\course::instance($course->id);
 386
 387         // Test the communication record exists.
 388         $communicationprocessor = processor::load_by_instance(
 389             context: $context,
 390             component: 'core_course',
 391             instancetype: 'coursecommunication',
 392             instanceid: $course->id,
 393         );
 394
 395         $this->assertInstanceOf(user_provider::class, $communicationprocessor->get_room_provider());
 396     }
 397
 398     /**
 399      * Test get room user provider.
 400      *
 401      * @covers ::get_room_user_provider
 402      * @covers ::require_room_features
 403      * @covers ::require_room_user_features
 404      * @covers ::supports_room_user_features
 405      * @covers ::supports_room_features
 406      * @covers ::load_by_instance
 407      */
 408     public function test_get_room_user_provider(): void {
 409         $this->resetAfterTest();
 410         $course = $this->get_course();
 411         $context = \core\context\course::instance($course->id);
 412
 413         // Test the communication record exists.
 414         $communicationprocessor = processor::load_by_instance(
 415             context: $context,
 416             component: 'core_course',
 417             instancetype: 'coursecommunication',
 418             instanceid: $course->id,
 419         );
 420
 421         $this->assertInstanceOf(room_user_provider::class, $communicationprocessor->get_room_user_provider());
 422     }
 423
 424     /**
 425      * Test get avatar.
 426      *
 427      * @covers ::get_avatar
 428      * @covers ::load_by_instance
 429      * @covers ::get_avatar_filename
 430      * @covers ::set_avatar_filename
 431      * @covers ::set_avatar_synced_flag
 432      */
 433     public function test_get_avatar(): void {
 434         $this->resetAfterTest();
 435         $this->setAdminUser();
 436
 437         global $CFG;
 438         $course = $this->get_course('Sampleroom', 'none');
 439
 440         // Sample data.
 441         $communicationroomname = 'Sampleroom';
 442         $selectedcommunication = 'communication_matrix';
 443         $avatar = $this->create_communication_file(
 444             'moodle_logo.jpg',
 445             'moodle_logo.jpg',
 446         );
 447
 448         $communication = \core_communication\api::load_by_instance(
 449             context: \core\context\course::instance($course->id),
 450             component: 'core_course',
 451             instancetype: 'coursecommunication',
 452             instanceid: $course->id,
 453             provider: $selectedcommunication,
 454         );
 455         $communication->create_and_configure_room($communicationroomname, $avatar);
 456
 457         $communicationprocessor = processor::load_by_instance(
 458             context: \core\context\course::instance($course->id),
 459             component: 'core_course',
 460             instancetype: 'coursecommunication',
 461             instanceid: $course->id,
 462         );
 463
 464         $avatar = $communicationprocessor->get_avatar();
 465
 466         $this->assertNotNull($avatar);
 467         $this->assertEquals($avatar->get_component(), 'core_communication');
 468         $this->assertEquals($avatar->get_filearea(), 'avatar');
 469         $this->assertEquals($avatar->get_itemid(), $communicationprocessor->get_id());
 470         $this->assertEquals($avatar->get_filepath(), '/');
 471         $this->assertEquals($avatar->get_filearea(), 'avatar');
 472         $this->assertEquals($avatar->get_filename(), $communicationprocessor->get_avatar_filename());
 473
 474         // Change the avatar file name to something else and check it was set.
 475         $communicationprocessor->set_avatar_filename('newname.svg');
 476
 477         $communicationprocessor = processor::load_by_instance(
 478             context: \core\context\course::instance($course->id),
 479             component: 'core_course',
 480             instancetype: 'coursecommunication',
 481             instanceid: $course->id,
 482         );
 483         $this->assertEquals($communicationprocessor->get_avatar_filename(), 'newname.svg');
 484     }
 485
 486     /**
 487      * Test if the provider is enabled and configured, or disabled.
 488      *
 489      * @covers ::is_provider_available
 490      */
 491     public function test_is_provider_available(): void {
 492         $this->resetAfterTest();
 493         $communicationprovider = 'communication_matrix';
 494         $this->assertTrue(processor::is_provider_available($communicationprovider));
 495
 496         // Now test is disabling the plugin returns false.
 497         set_config('disabled', 1, $communicationprovider);
 498         $this->assertFalse(processor::is_provider_available($communicationprovider));
 499     }
 500
 501     /**
 502      * Test delete flagged user id's return correct users.
 503      *
 504      * @covers ::get_all_delete_flagged_userids
 505      */
 506     public function test_get_all_delete_flagged_userids(): void {
 507         $this->resetAfterTest();
 508
 509         $course = $this->get_course('Sampleroom', 'none');
 510         $user1 = $this->getDataGenerator()->create_user()->id;
 511         $user2 = $this->getDataGenerator()->create_user()->id;
 512
 513         // Sample data.
 514         $communicationroomname = 'Sampleroom';
 515         $selectedcommunication = 'communication_matrix';
 516         $component = 'core_course';
 517         $instancetype = 'coursecommunication';
 518
 519         // Load the communication api.
 520         $communication = \core_communication\api::load_by_instance(
 521             context: \core\context\course::instance($course->id),
 522             component: $component,
 523             instancetype: $instancetype,
 524             instanceid: $course->id,
 525             provider: $selectedcommunication,
 526         );
 527         $communication->create_and_configure_room($communicationroomname);
 528         $communication->add_members_to_room([$user1, $user2]);
 529
 530         // Now remove user1 from the room.
 531         $communication->remove_members_from_room([$user1]);
 532
 533         // Test against the object.
 534         $communicationprocessor = processor::load_by_instance(
 535             context: \core\context\course::instance($course->id),
 536             component: $component,
 537             instancetype: $instancetype,
 538             instanceid: $course->id,
 539         );
 540
 541         $this->assertEquals([$user1], $communicationprocessor->get_all_delete_flagged_userids());
 542     }
 543 }