[Summary view]

   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  }