Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
  • Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
  • PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.

Differences Between: [Versions 311 and 400] [Versions 311 and 401] [Versions 311 and 402] [Versions 311 and 403]

   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  /**
  18   * Privacy provider tests.
  19   *
  20   * @package    core_message
  21   * @copyright  2018 Mark Nelson <markn@moodle.com>
  22   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  namespace core_message\privacy;
  25  
  26  use core_privacy\local\metadata\collection;
  27  use core_message\privacy\provider;
  28  use core_privacy\local\request\contextlist;
  29  use core_privacy\local\request\writer;
  30  use core_privacy\local\request\transform;
  31  use core_message\tests\helper as testhelper;
  32  
  33  defined('MOODLE_INTERNAL') || die();
  34  
  35  /**
  36   * Privacy provider tests class.
  37   *
  38   * @package    core_message
  39   * @copyright  2018 Mark Nelson <markn@moodle.com>
  40   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  41   */
  42  class provider_test extends \core_privacy\tests\provider_testcase {
  43  
  44      /**
  45       * Test for provider::get_metadata().
  46       */
  47      public function test_get_metadata() {
  48          $collection = new collection('core_message');
  49          $newcollection = provider::get_metadata($collection);
  50          $itemcollection = $newcollection->get_collection();
  51          $this->assertCount(10, $itemcollection);
  52  
  53          $messagestable = array_shift($itemcollection);
  54          $this->assertEquals('messages', $messagestable->get_name());
  55  
  56          $messageuseractionstable = array_shift($itemcollection);
  57          $this->assertEquals('message_user_actions', $messageuseractionstable->get_name());
  58  
  59          $messageconversationmemberstable = array_shift($itemcollection);
  60          $this->assertEquals('message_conversation_members', $messageconversationmemberstable->get_name());
  61  
  62          $messageconversationactions = array_shift($itemcollection);
  63          $this->assertEquals('message_conversation_actions', $messageconversationactions->get_name());
  64  
  65          $messagecontacts = array_shift($itemcollection);
  66          $this->assertEquals('message_contacts', $messagecontacts->get_name());
  67  
  68          $messagecontactrequests = array_shift($itemcollection);
  69          $this->assertEquals('message_contact_requests', $messagecontactrequests->get_name());
  70  
  71          $messageusersblocked = array_shift($itemcollection);
  72          $this->assertEquals('message_users_blocked', $messageusersblocked->get_name());
  73  
  74          $notificationstable = array_shift($itemcollection);
  75          $this->assertEquals('notifications', $notificationstable->get_name());
  76  
  77          $usersettings = array_shift($itemcollection);
  78          $this->assertEquals('core_message_messageprovider_settings', $usersettings->get_name());
  79  
  80          $favouriteconversations = array_shift($itemcollection);
  81          $this->assertEquals('core_favourites', $favouriteconversations->get_name());
  82          $this->assertEquals('privacy:metadata:core_favourites', $favouriteconversations->get_summary());
  83  
  84          $privacyfields = $messagestable->get_privacy_fields();
  85          $this->assertArrayHasKey('useridfrom', $privacyfields);
  86          $this->assertArrayHasKey('conversationid', $privacyfields);
  87          $this->assertArrayHasKey('subject', $privacyfields);
  88          $this->assertArrayHasKey('fullmessage', $privacyfields);
  89          $this->assertArrayHasKey('fullmessageformat', $privacyfields);
  90          $this->assertArrayHasKey('fullmessagehtml', $privacyfields);
  91          $this->assertArrayHasKey('smallmessage', $privacyfields);
  92          $this->assertArrayHasKey('timecreated', $privacyfields);
  93          $this->assertArrayHasKey('customdata', $privacyfields);
  94          $this->assertEquals('privacy:metadata:messages', $messagestable->get_summary());
  95  
  96          $privacyfields = $messageuseractionstable->get_privacy_fields();
  97          $this->assertArrayHasKey('userid', $privacyfields);
  98          $this->assertArrayHasKey('messageid', $privacyfields);
  99          $this->assertArrayHasKey('action', $privacyfields);
 100          $this->assertArrayHasKey('timecreated', $privacyfields);
 101          $this->assertEquals('privacy:metadata:message_user_actions', $messageuseractionstable->get_summary());
 102  
 103          $privacyfields = $messageconversationmemberstable->get_privacy_fields();
 104          $this->assertArrayHasKey('conversationid', $privacyfields);
 105          $this->assertArrayHasKey('userid', $privacyfields);
 106          $this->assertArrayHasKey('timecreated', $privacyfields);
 107          $this->assertEquals('privacy:metadata:message_conversation_members', $messageconversationmemberstable->get_summary());
 108  
 109          $privacyfields = $messagecontacts->get_privacy_fields();
 110          $this->assertArrayHasKey('userid', $privacyfields);
 111          $this->assertArrayHasKey('contactid', $privacyfields);
 112          $this->assertArrayHasKey('timecreated', $privacyfields);
 113          $this->assertEquals('privacy:metadata:message_contacts', $messagecontacts->get_summary());
 114  
 115          $privacyfields = $messagecontactrequests->get_privacy_fields();
 116          $this->assertArrayHasKey('userid', $privacyfields);
 117          $this->assertArrayHasKey('requesteduserid', $privacyfields);
 118          $this->assertArrayHasKey('timecreated', $privacyfields);
 119          $this->assertEquals('privacy:metadata:message_contact_requests', $messagecontactrequests->get_summary());
 120  
 121          $privacyfields = $messageusersblocked->get_privacy_fields();
 122          $this->assertArrayHasKey('userid', $privacyfields);
 123          $this->assertArrayHasKey('blockeduserid', $privacyfields);
 124          $this->assertArrayHasKey('timecreated', $privacyfields);
 125          $this->assertEquals('privacy:metadata:message_users_blocked', $messageusersblocked->get_summary());
 126  
 127          $privacyfields = $notificationstable->get_privacy_fields();
 128          $this->assertArrayHasKey('useridfrom', $privacyfields);
 129          $this->assertArrayHasKey('useridto', $privacyfields);
 130          $this->assertArrayHasKey('subject', $privacyfields);
 131          $this->assertArrayHasKey('fullmessage', $privacyfields);
 132          $this->assertArrayHasKey('fullmessageformat', $privacyfields);
 133          $this->assertArrayHasKey('fullmessagehtml', $privacyfields);
 134          $this->assertArrayHasKey('smallmessage', $privacyfields);
 135          $this->assertArrayHasKey('component', $privacyfields);
 136          $this->assertArrayHasKey('eventtype', $privacyfields);
 137          $this->assertArrayHasKey('contexturl', $privacyfields);
 138          $this->assertArrayHasKey('contexturlname', $privacyfields);
 139          $this->assertArrayHasKey('timeread', $privacyfields);
 140          $this->assertArrayHasKey('timecreated', $privacyfields);
 141          $this->assertArrayHasKey('customdata', $privacyfields);
 142          $this->assertEquals('privacy:metadata:notifications', $notificationstable->get_summary());
 143      }
 144  
 145      /**
 146       * Test for provider::export_user_preferences().
 147       */
 148      public function test_export_user_preferences_no_pref() {
 149          $this->resetAfterTest();
 150  
 151          $user = $this->getDataGenerator()->create_user();
 152          provider::export_user_preferences($user->id);
 153  
 154          $writer = writer::with_context(\context_system::instance());
 155  
 156          $this->assertFalse($writer->has_any_data());
 157      }
 158  
 159      /**
 160       * Test for provider::export_user_preferences().
 161       */
 162      public function test_export_user_preferences() {
 163          global $USER;
 164  
 165          $this->resetAfterTest();
 166  
 167          $this->setAdminUser();
 168  
 169          // Create another user to set a preference for who we won't be exporting.
 170          $user = $this->getDataGenerator()->create_user();
 171  
 172          // Set some message user preferences.
 173          set_user_preference('message_provider_moodle_instantmessage_loggedin', 'airnotifier', $USER->id);
 174          set_user_preference('message_provider_moodle_instantmessage_loggedoff', 'popup', $USER->id);
 175          set_user_preference('message_blocknoncontacts', \core_message\api::MESSAGE_PRIVACY_ONLYCONTACTS, $USER->id);
 176          set_user_preference('message_entertosend', true, $USER->id);
 177          set_user_preference('message_provider_moodle_instantmessage_loggedoff', 'inbound', $user->id);
 178  
 179          // Set an unrelated preference.
 180          set_user_preference('some_unrelated_preference', 'courses', $USER->id);
 181  
 182          provider::export_user_preferences($USER->id);
 183  
 184          $writer = writer::with_context(\context_system::instance());
 185  
 186          $this->assertTrue($writer->has_any_data());
 187  
 188          $prefs = (array) $writer->get_user_preferences('core_message');
 189  
 190          // Check only 3 preferences exist.
 191          $this->assertCount(4, $prefs);
 192          $this->assertArrayHasKey('message_provider_moodle_instantmessage_loggedin', $prefs);
 193          $this->assertArrayHasKey('message_provider_moodle_instantmessage_loggedoff', $prefs);
 194          $this->assertArrayHasKey('message_blocknoncontacts', $prefs);
 195          $this->assertArrayHasKey('message_entertosend', $prefs);
 196  
 197          foreach ($prefs as $key => $pref) {
 198              if ($key == 'message_provider_moodle_instantmessage_loggedin') {
 199                  $this->assertEquals('airnotifier', $pref->value);
 200              } else if ($key == 'message_provider_moodle_instantmessage_loggedoff') {
 201                  $this->assertEquals('popup', $pref->value);
 202              } else {
 203                  $this->assertEquals(1, $pref->value);
 204              }
 205          }
 206      }
 207  
 208      /**
 209       * Test for provider::get_contexts_for_userid() when there is no message or notification.
 210       */
 211      public function test_get_contexts_for_userid_no_data() {
 212          $this->resetAfterTest();
 213  
 214          $user = $this->getDataGenerator()->create_user();
 215  
 216          $contextlist = provider::get_contexts_for_userid($user->id);
 217          $this->assertCount(1, $contextlist);
 218  
 219          $this->remove_user_self_conversation($user->id);
 220  
 221          $contextlist = provider::get_contexts_for_userid($user->id);
 222          $this->assertEmpty($contextlist);
 223      }
 224  
 225      /**
 226       * Test for provider::get_contexts_for_userid() when there is a private message between users.
 227       */
 228      public function test_get_contexts_for_userid_with_private_messages() {
 229          $this->resetAfterTest();
 230  
 231          $user1 = $this->getDataGenerator()->create_user();
 232          $user2 = $this->getDataGenerator()->create_user();
 233          $user3 = $this->getDataGenerator()->create_user();
 234  
 235          // Remove user self-conversations.
 236          $this->remove_user_self_conversation($user1->id);
 237          $this->remove_user_self_conversation($user2->id);
 238          $this->remove_user_self_conversation($user3->id);
 239  
 240          // Test nothing is found before group conversations is created or message is sent.
 241          $contextlist = provider::get_contexts_for_userid($user1->id);
 242          $this->assertCount(0, $contextlist);
 243          $contextlist = provider::get_contexts_for_userid($user2->id);
 244          $this->assertCount(0, $contextlist);
 245  
 246          // Send some private messages.
 247          $pm1id = $this->create_message($user1->id, $user2->id, time() - (9 * DAYSECS));
 248  
 249          // Test for the sender (user1).
 250          $contextlist = provider::get_contexts_for_userid($user1->id);
 251          $this->assertCount(1, $contextlist);
 252          $contextforuser = $contextlist->current();
 253          $this->assertEquals(
 254                  \context_user::instance($user1->id)->id,
 255                  $contextforuser->id);
 256  
 257          // Test for the receiver (user2).
 258          $contextlist = provider::get_contexts_for_userid($user2->id);
 259          $this->assertCount(1, $contextlist);
 260          $contextforuser = $contextlist->current();
 261          $this->assertEquals(
 262                  \context_user::instance($user2->id)->id,
 263                  $contextforuser->id);
 264  
 265          // Test for user3 (no private messages).
 266          $contextlist = provider::get_contexts_for_userid($user3->id);
 267          $this->assertCount(0, $contextlist);
 268      }
 269  
 270      /**
 271       * Test for provider::get_contexts_for_userid() when there is several messages (private and group).
 272       */
 273      public function test_get_contexts_for_userid_with_messages() {
 274          $this->resetAfterTest();
 275          $this->setAdminUser();
 276  
 277          $user1 = $this->getDataGenerator()->create_user();
 278          $user2 = $this->getDataGenerator()->create_user();
 279          $user3 = $this->getDataGenerator()->create_user();
 280          $user4 = $this->getDataGenerator()->create_user();
 281  
 282          // Remove user self-conversations.
 283          $this->remove_user_self_conversation($user1->id);
 284          $this->remove_user_self_conversation($user2->id);
 285          $this->remove_user_self_conversation($user3->id);
 286          $this->remove_user_self_conversation($user4->id);
 287  
 288          // Test nothing is found before group conversations is created or message is sent.
 289          $contextlist = provider::get_contexts_for_userid($user1->id);
 290          $this->assertCount(0, $contextlist);
 291          $contextlist = provider::get_contexts_for_userid($user2->id);
 292          $this->assertCount(0, $contextlist);
 293  
 294          // Create course.
 295          $course1 = $this->getDataGenerator()->create_course();
 296          $coursecontext1 = \context_course::instance($course1->id);
 297  
 298          // Enrol users to courses.
 299          $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
 300          $this->getDataGenerator()->enrol_user($user2->id, $course1->id);
 301          $this->getDataGenerator()->enrol_user($user3->id, $course1->id);
 302  
 303          // Create groups (only one with enablemessaging = 1).
 304          $group1a = $this->getDataGenerator()->create_group(array('courseid' => $course1->id, 'enablemessaging' => 1));
 305  
 306          // Add users to groups.
 307          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user1->id));
 308          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user2->id));
 309          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user3->id));
 310  
 311          // Get conversation.
 312          $component = 'core_group';
 313          $itemtype = 'groups';
 314          $conversation1 = \core_message\api::get_conversation_by_area(
 315              $component,
 316              $itemtype,
 317              $group1a->id,
 318              $coursecontext1->id
 319          );
 320  
 321          // Send some messages to the group conversation.
 322          $now = time();
 323          $m1id = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 1', $now + 1);
 324          $m2id = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 2', $now + 2);
 325          $m3id = testhelper::send_fake_message_to_conversation($user2, $conversation1->id, 'Message 3', $now + 3);
 326  
 327          // Test for user1 (although is member of the conversation, hasn't any private message).
 328          $contextlist = provider::get_contexts_for_userid($user1->id);
 329          $this->assertCount(0, $contextlist);
 330  
 331          // Test for user2 (although is member of the conversation, hasn't any private message).
 332          $contextlist = provider::get_contexts_for_userid($user2->id);
 333          $this->assertCount(0, $contextlist);
 334  
 335          // Test for user3 (although is member of the conversation, hasn't any private message).
 336          $contextlist = provider::get_contexts_for_userid($user3->id);
 337          $this->assertCount(0, $contextlist);
 338  
 339          // Test for user4 (doesn't belong to the conversation).
 340          $contextlist = provider::get_contexts_for_userid($user4->id);
 341          $this->assertCount(0, $contextlist);
 342  
 343          // Send some private messages.
 344          $pm1id = $this->create_message($user1->id, $user2->id, time() - (9 * DAYSECS));
 345  
 346          // Test user1 now has the user context because of the private message.
 347          $contextlist = provider::get_contexts_for_userid($user1->id);
 348          $this->assertCount(1, $contextlist);
 349          $contextforuser = $contextlist->current();
 350          $this->assertEquals(
 351                  \context_user::instance($user1->id)->id,
 352                  $contextforuser->id);
 353  
 354          // Test user2 now has the user context because of the private message.
 355          $contextlist = provider::get_contexts_for_userid($user2->id);
 356          $this->assertCount(1, $contextlist);
 357          $contextforuser = $contextlist->current();
 358          $this->assertEquals(
 359                  \context_user::instance($user2->id)->id,
 360                  $contextforuser->id);
 361  
 362          // Test for user3 (although is member of the conversation, hasn't still any private message).
 363          $contextlist = provider::get_contexts_for_userid($user3->id);
 364          $this->assertCount(0, $contextlist);
 365  
 366          // Test for user4 (doesn't belong to the conversation and hasn't any private message).
 367          $contextlist = provider::get_contexts_for_userid($user4->id);
 368          $this->assertCount(0, $contextlist);
 369      }
 370  
 371      /**
 372       * Test for provider::get_contexts_for_userid() when there is a notification between users.
 373       */
 374      public function test_get_contexts_for_userid_with_notification() {
 375          $this->resetAfterTest();
 376  
 377          $user1 = $this->getDataGenerator()->create_user();
 378          $user2 = $this->getDataGenerator()->create_user();
 379  
 380          // Remove user self-conversations.
 381          $this->remove_user_self_conversation($user1->id);
 382          $this->remove_user_self_conversation($user2->id);
 383  
 384          // Test nothing is found before notification is created.
 385          $contextlist = provider::get_contexts_for_userid($user1->id);
 386          $this->assertCount(0, $contextlist);
 387          $contextlist = provider::get_contexts_for_userid($user2->id);
 388          $this->assertCount(0, $contextlist);
 389  
 390          $this->create_notification($user1->id, $user2->id, time() - (9 * DAYSECS));
 391  
 392          // Test for the sender.
 393          $contextlist = provider::get_contexts_for_userid($user1->id);
 394          $this->assertCount(1, $contextlist);
 395          $contextforuser = $contextlist->current();
 396          $this->assertEquals(
 397                  \context_user::instance($user1->id)->id,
 398                  $contextforuser->id);
 399  
 400          // Test for the receiver.
 401          $contextlist = provider::get_contexts_for_userid($user2->id);
 402          $this->assertCount(1, $contextlist);
 403          $contextforuser = $contextlist->current();
 404          $this->assertEquals(
 405                  \context_user::instance($user2->id)->id,
 406                  $contextforuser->id);
 407      }
 408  
 409      /**
 410       * Test for provider::get_contexts_for_userid() when a users has a contact.
 411       */
 412      public function test_get_contexts_for_userid_with_contact() {
 413          $this->resetAfterTest();
 414  
 415          $user1 = $this->getDataGenerator()->create_user();
 416          $user2 = $this->getDataGenerator()->create_user();
 417  
 418          // Remove user self-conversations.
 419          $this->remove_user_self_conversation($user1->id);
 420          $this->remove_user_self_conversation($user2->id);
 421  
 422          // Test nothing is found before contact is created.
 423          $contextlist = provider::get_contexts_for_userid($user1->id);
 424          $this->assertCount(0, $contextlist);
 425          $contextlist = provider::get_contexts_for_userid($user2->id);
 426          $this->assertCount(0, $contextlist);
 427  
 428          \core_message\api::add_contact($user1->id, $user2->id);
 429  
 430          // Test for the user adding the contact.
 431          $contextlist = provider::get_contexts_for_userid($user1->id);
 432          $this->assertCount(1, $contextlist);
 433          $contextforuser = $contextlist->current();
 434          $this->assertEquals(
 435                  \context_user::instance($user1->id)->id,
 436                  $contextforuser->id);
 437  
 438          // Test for the user who is the contact.
 439          $contextlist = provider::get_contexts_for_userid($user2->id);
 440          $this->assertCount(1, $contextlist);
 441          $contextforuser = $contextlist->current();
 442          $this->assertEquals(
 443                  \context_user::instance($user2->id)->id,
 444                  $contextforuser->id);
 445      }
 446  
 447      /**
 448       * Test for provider::get_contexts_for_userid() when a user makes a contact request.
 449       */
 450      public function test_get_contexts_for_userid_with_contact_request() {
 451          $this->resetAfterTest();
 452  
 453          $user1 = $this->getDataGenerator()->create_user();
 454          $user2 = $this->getDataGenerator()->create_user();
 455  
 456          // Remove user self-conversations.
 457          $this->remove_user_self_conversation($user1->id);
 458          $this->remove_user_self_conversation($user2->id);
 459  
 460          // Test nothing is found before request is created.
 461          $contextlist = provider::get_contexts_for_userid($user1->id);
 462          $this->assertCount(0, $contextlist);
 463          $contextlist = provider::get_contexts_for_userid($user2->id);
 464          $this->assertCount(0, $contextlist);
 465  
 466          \core_message\api::create_contact_request($user1->id, $user2->id);
 467  
 468          // Test for the user requesting the contact.
 469          $contextlist = provider::get_contexts_for_userid($user1->id);
 470          $this->assertCount(1, $contextlist);
 471          $contextforuser = $contextlist->current();
 472          $this->assertEquals(
 473                  \context_user::instance($user1->id)->id,
 474                  $contextforuser->id);
 475  
 476          // Test for the user receiving the contact request.
 477          $contextlist = provider::get_contexts_for_userid($user2->id);
 478          $this->assertCount(1, $contextlist);
 479          $contextforuser = $contextlist->current();
 480          $this->assertEquals(
 481                  \context_user::instance($user2->id)->id,
 482                  $contextforuser->id);
 483      }
 484  
 485      /**
 486       * Test for provider::get_contexts_for_userid() when a user is blocked.
 487       */
 488      public function test_get_contexts_for_userid_with_blocked_contact() {
 489          $this->resetAfterTest();
 490  
 491          $user1 = $this->getDataGenerator()->create_user();
 492          $user2 = $this->getDataGenerator()->create_user();
 493  
 494          // Remove user self-conversations.
 495          $this->remove_user_self_conversation($user1->id);
 496          $this->remove_user_self_conversation($user2->id);
 497  
 498          // Test nothing is found before user is blocked.
 499          $contextlist = provider::get_contexts_for_userid($user1->id);
 500          $this->assertCount(0, $contextlist);
 501          $contextlist = provider::get_contexts_for_userid($user2->id);
 502          $this->assertCount(0, $contextlist);
 503  
 504          \core_message\api::block_user($user1->id, $user2->id);
 505  
 506          // Test for the blocking user.
 507          $contextlist = provider::get_contexts_for_userid($user1->id);
 508          $this->assertCount(1, $contextlist);
 509          $contextforuser = $contextlist->current();
 510          $this->assertEquals(
 511                  \context_user::instance($user1->id)->id,
 512                  $contextforuser->id);
 513  
 514          // Test for the user who is blocked.
 515          $contextlist = provider::get_contexts_for_userid($user2->id);
 516          $this->assertCount(1, $contextlist);
 517          $contextforuser = $contextlist->current();
 518          $this->assertEquals(
 519                  \context_user::instance($user2->id)->id,
 520                  $contextforuser->id);
 521      }
 522  
 523      /**
 524       * Test for provider::export_user_data().
 525       */
 526      public function test_export_for_context_with_contacts() {
 527          $this->resetAfterTest();
 528  
 529          // Create users to test with.
 530          $user1 = $this->getDataGenerator()->create_user();
 531          $user2 = $this->getDataGenerator()->create_user();
 532          $user3 = $this->getDataGenerator()->create_user();
 533          $user4 = $this->getDataGenerator()->create_user();
 534  
 535          // Remove user self-conversations.
 536          $this->remove_user_self_conversation($user1->id);
 537          $this->remove_user_self_conversation($user2->id);
 538          $this->remove_user_self_conversation($user3->id);
 539          $this->remove_user_self_conversation($user4->id);
 540  
 541          \core_message\api::add_contact($user1->id, $user2->id);
 542          \core_message\api::add_contact($user1->id, $user3->id);
 543          \core_message\api::add_contact($user1->id, $user4->id);
 544  
 545          $user1context = \context_user::instance($user1->id);
 546  
 547          $this->export_context_data_for_user($user1->id, $user1context, 'core_message');
 548  
 549          $writer = writer::with_context($user1context);
 550  
 551          $contacts = (array) $writer->get_data([get_string('contacts', 'core_message')]);
 552          usort($contacts, ['static', 'sort_contacts']);
 553  
 554          $this->assertCount(3, $contacts);
 555  
 556          $contact1 = array_shift($contacts);
 557          $this->assertEquals($user2->id, $contact1->contact);
 558  
 559          $contact2 = array_shift($contacts);
 560          $this->assertEquals($user3->id, $contact2->contact);
 561  
 562          $contact3 = array_shift($contacts);
 563          $this->assertEquals($user4->id, $contact3->contact);
 564      }
 565  
 566      /**
 567       * Test for provider::export_user_data().
 568       */
 569      public function test_export_for_context_with_contact_requests() {
 570          $this->resetAfterTest();
 571  
 572          // Create users to test with.
 573          $user1 = $this->getDataGenerator()->create_user();
 574          $user2 = $this->getDataGenerator()->create_user();
 575          $user3 = $this->getDataGenerator()->create_user();
 576          $user4 = $this->getDataGenerator()->create_user();
 577  
 578          // Remove user self-conversations.
 579          $this->remove_user_self_conversation($user1->id);
 580          $this->remove_user_self_conversation($user2->id);
 581          $this->remove_user_self_conversation($user3->id);
 582          $this->remove_user_self_conversation($user4->id);
 583  
 584          \core_message\api::create_contact_request($user1->id, $user2->id);
 585          \core_message\api::create_contact_request($user3->id, $user1->id);
 586          \core_message\api::create_contact_request($user1->id, $user4->id);
 587  
 588          $user1context = \context_user::instance($user1->id);
 589  
 590          $this->export_context_data_for_user($user1->id, $user1context, 'core_message');
 591  
 592          $writer = writer::with_context($user1context);
 593  
 594          $contactrequests = (array) $writer->get_data([get_string('contactrequests', 'core_message')]);
 595  
 596          $this->assertCount(3, $contactrequests);
 597  
 598          $contactrequest1 = array_shift($contactrequests);
 599          $this->assertEquals($user2->id, $contactrequest1->contactrequest);
 600          $this->assertEquals(get_string('yes'), $contactrequest1->maderequest);
 601  
 602          $contactrequest2 = array_shift($contactrequests);
 603          $this->assertEquals($user3->id, $contactrequest2->contactrequest);
 604          $this->assertEquals(get_string('no'), $contactrequest2->maderequest);
 605  
 606          $contactrequest3 = array_shift($contactrequests);
 607          $this->assertEquals($user4->id, $contactrequest3->contactrequest);
 608          $this->assertEquals(get_string('yes'), $contactrequest3->maderequest);
 609      }
 610  
 611      /**
 612       * Test for provider::export_user_data().
 613       */
 614      public function test_export_for_context_with_blocked_users() {
 615          $this->resetAfterTest();
 616  
 617          // Create users to test with.
 618          $user1 = $this->getDataGenerator()->create_user();
 619          $user2 = $this->getDataGenerator()->create_user();
 620          $user3 = $this->getDataGenerator()->create_user();
 621          $user4 = $this->getDataGenerator()->create_user();
 622  
 623          // Remove user self-conversations.
 624          $this->remove_user_self_conversation($user1->id);
 625          $this->remove_user_self_conversation($user2->id);
 626          $this->remove_user_self_conversation($user3->id);
 627          $this->remove_user_self_conversation($user4->id);
 628  
 629          \core_message\api::block_user($user1->id, $user2->id);
 630          \core_message\api::block_user($user1->id, $user3->id);
 631          \core_message\api::block_user($user1->id, $user4->id);
 632  
 633          $user1context = \context_user::instance($user1->id);
 634  
 635          $this->export_context_data_for_user($user1->id, $user1context, 'core_message');
 636  
 637          $writer = writer::with_context($user1context);
 638  
 639          $blockedusers = (array) $writer->get_data([get_string('blockedusers', 'core_message')]);
 640  
 641          $this->assertCount(3, $blockedusers);
 642  
 643          $blockeduser1 = array_shift($blockedusers);
 644          $this->assertEquals($user2->id, $blockeduser1->blockeduser);
 645  
 646          $blockeduser2 = array_shift($blockedusers);
 647          $this->assertEquals($user3->id, $blockeduser2->blockeduser);
 648  
 649          $blockeduser3 = array_shift($blockedusers);
 650          $this->assertEquals($user4->id, $blockeduser3->blockeduser);
 651      }
 652  
 653      /**
 654       * Test for provider::export_user_data().
 655       */
 656      public function test_export_for_context_with_private_messages() {
 657          global $DB;
 658  
 659          $this->resetAfterTest();
 660  
 661          // Create users to test with.
 662          $user1 = $this->getDataGenerator()->create_user();
 663          $user2 = $this->getDataGenerator()->create_user();
 664          $user3 = $this->getDataGenerator()->create_user();
 665  
 666          // Remove user self-conversations.
 667          $this->remove_user_self_conversation($user1->id);
 668          $this->remove_user_self_conversation($user2->id);
 669          $this->remove_user_self_conversation($user3->id);
 670  
 671          $now = time();
 672  
 673          // Send messages from user 1 to user 2.
 674          $m1 = $this->create_message($user1->id, $user2->id, $now - (9 * DAYSECS), true);
 675          $m2 = $this->create_message($user2->id, $user1->id, $now - (8 * DAYSECS));
 676          $m3 = $this->create_message($user1->id, $user2->id, $now - (7 * DAYSECS));
 677  
 678          // Send messages from user 3 to user 1.
 679          $m4 = $this->create_message($user3->id, $user1->id, $now - (6 * DAYSECS), true);
 680          $m5 = $this->create_message($user1->id, $user3->id, $now - (5 * DAYSECS));
 681          $m6 = $this->create_message($user3->id, $user1->id, $now - (4 * DAYSECS));
 682  
 683          // Send messages from user 3 to user 2 - these should not be included in the export.
 684          $m7 = $this->create_message($user3->id, $user2->id, $now - (3 * DAYSECS), true);
 685          $m8 = $this->create_message($user2->id, $user3->id, $now - (2 * DAYSECS));
 686          $m9 = $this->create_message($user3->id, $user2->id, $now - (1 * DAYSECS));
 687  
 688          // Mark message 2 and 5 as deleted.
 689          \core_message\api::delete_message($user1->id, $m2);
 690          \core_message\api::delete_message($user1->id, $m5);
 691  
 692          $user1context = \context_user::instance($user1->id);
 693  
 694          $this->export_context_data_for_user($user1->id, $user1context, 'core_message');
 695  
 696          $writer = writer::with_context($user1context);
 697  
 698          $this->assertTrue($writer->has_any_data());
 699  
 700          // Confirm the messages with user 2 are correct.
 701          $messages = (array) $writer->get_data([get_string('messages', 'core_message'), $user2->id]);
 702          $this->assertCount(3, $messages);
 703  
 704          $dbm1 = $DB->get_record('messages', ['id' => $m1]);
 705          $dbm2 = $DB->get_record('messages', ['id' => $m2]);
 706          $dbm3 = $DB->get_record('messages', ['id' => $m3]);
 707  
 708          usort($messages, ['static', 'sort_messages']);
 709          $m1 = array_shift($messages);
 710          $m2 = array_shift($messages);
 711          $m3 = array_shift($messages);
 712  
 713          $this->assertEquals(get_string('yes'), $m1->issender);
 714          $this->assertEquals(message_format_message_text($dbm1), $m1->message);
 715          $this->assertEquals(transform::datetime($now - (9 * DAYSECS)), $m1->timecreated);
 716          $this->assertEquals('-', $m1->timeread);
 717          $this->assertArrayNotHasKey('timedeleted', (array) $m1);
 718  
 719          $this->assertEquals(get_string('no'), $m2->issender);
 720          $this->assertEquals(message_format_message_text($dbm2), $m2->message);
 721          $this->assertEquals(transform::datetime($now - (8 * DAYSECS)), $m2->timecreated);
 722          $this->assertEquals('-', $m2->timeread);
 723          $this->assertArrayHasKey('timedeleted', (array) $m2);
 724  
 725          $this->assertEquals(get_string('yes'), $m3->issender);
 726          $this->assertEquals(message_format_message_text($dbm3), $m3->message);
 727          $this->assertEquals(transform::datetime($now - (7 * DAYSECS)), $m3->timecreated);
 728          $this->assertEquals('-', $m3->timeread);
 729  
 730          // Confirm the messages with user 3 are correct.
 731          $messages = (array) $writer->get_data([get_string('messages', 'core_message'), $user3->id]);
 732          $this->assertCount(3, $messages);
 733  
 734          $dbm4 = $DB->get_record('messages', ['id' => $m4]);
 735          $dbm5 = $DB->get_record('messages', ['id' => $m5]);
 736          $dbm6 = $DB->get_record('messages', ['id' => $m6]);
 737  
 738          usort($messages, ['static', 'sort_messages']);
 739          $m4 = array_shift($messages);
 740          $m5 = array_shift($messages);
 741          $m6 = array_shift($messages);
 742  
 743          $this->assertEquals(get_string('no'), $m4->issender);
 744          $this->assertEquals(message_format_message_text($dbm4), $m4->message);
 745          $this->assertEquals(transform::datetime($now - (6 * DAYSECS)), $m4->timecreated);
 746          $this->assertNotEquals('-', $m4->timeread);
 747          $this->assertArrayNotHasKey('timedeleted', (array) $m4);
 748  
 749          $this->assertEquals(get_string('yes'), $m5->issender);
 750          $this->assertEquals(message_format_message_text($dbm5), $m5->message);
 751          $this->assertEquals(transform::datetime($now - (5 * DAYSECS)), $m5->timecreated);
 752          $this->assertEquals('-', $m5->timeread);
 753          $this->assertArrayHasKey('timedeleted', (array) $m5);
 754  
 755          $this->assertEquals(get_string('no'), $m6->issender);
 756          $this->assertEquals(message_format_message_text($dbm6), $m6->message);
 757          $this->assertEquals(transform::datetime($now - (4 * DAYSECS)), $m6->timecreated);
 758          $this->assertEquals('-', $m6->timeread);
 759      }
 760  
 761      /**
 762       * Test for provider::export_user_data().
 763       */
 764      public function test_export_for_context_with_messages() {
 765          global $DB;
 766  
 767          $this->resetAfterTest();
 768          $this->setAdminUser();
 769          $now = time();
 770          $systemcontext = \context_system::instance();
 771  
 772          // Create users to test with.
 773          $user1 = $this->getDataGenerator()->create_user();
 774          $user2 = $this->getDataGenerator()->create_user();
 775          $user3 = $this->getDataGenerator()->create_user();
 776          $user1context = \context_user::instance($user1->id);
 777  
 778          // Remove user self-conversations.
 779          $this->remove_user_self_conversation($user1->id);
 780          $this->remove_user_self_conversation($user2->id);
 781          $this->remove_user_self_conversation($user3->id);
 782  
 783          $course1 = $this->getDataGenerator()->create_course();
 784          $course2 = $this->getDataGenerator()->create_course();
 785          $coursecontext1 = \context_course::instance($course1->id);
 786          $coursecontext2 = \context_course::instance($course2->id);
 787  
 788          // Enrol users to courses.
 789          $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
 790          $this->getDataGenerator()->enrol_user($user2->id, $course1->id);
 791          $this->getDataGenerator()->enrol_user($user3->id, $course1->id);
 792          $this->getDataGenerator()->enrol_user($user1->id, $course2->id);
 793  
 794          // Create course groups with group messaging enabled.
 795          $group1a = $this->getDataGenerator()->create_group(array('courseid' => $course1->id, 'enablemessaging' => 1));
 796          $group2a = $this->getDataGenerator()->create_group(array('courseid' => $course2->id, 'enablemessaging' => 1));
 797  
 798          // Add users to groups.
 799          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user1->id));
 800          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user2->id));
 801          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user3->id));
 802          $this->getDataGenerator()->create_group_member(array('groupid' => $group2a->id, 'userid' => $user1->id));
 803  
 804          // Get conversation.
 805          $component = 'core_group';
 806          $itemtype = 'groups';
 807          $conversation = \core_message\api::get_conversation_by_area(
 808              $component,
 809              $itemtype,
 810              $group1a->id,
 811              $coursecontext1->id
 812          );
 813  
 814          // Send some private messages between user 1 and user 2.
 815          $pm1id = $this->create_message($user1->id, $user2->id, $now);
 816  
 817          $dbpm1 = $DB->get_record('messages', ['id' => $pm1id]);
 818  
 819          // Send some messages to the conversation.
 820          $m1 = testhelper::send_fake_message_to_conversation($user1, $conversation->id, 'Message 1', $now + 1);
 821          $m2 = testhelper::send_fake_message_to_conversation($user1, $conversation->id, 'Message 2', $now + 2);
 822          $m3 = testhelper::send_fake_message_to_conversation($user2, $conversation->id, 'Message 3', $now + 3);
 823  
 824          $dbm1 = $DB->get_record('messages', ['id' => $m1]);
 825          $dbm2 = $DB->get_record('messages', ['id' => $m2]);
 826          $dbm3 = $DB->get_record('messages', ['id' => $m3]);
 827  
 828          // Mark as read and delete some messages.
 829          \core_message\api::mark_message_as_read($user2->id, $dbm1);
 830          \core_message\api::delete_message($user1->id, $m2);
 831  
 832          // Confirm the user1 has no data in any course context because private messages are related to user context.
 833          $this->export_context_data_for_user($user1->id, $coursecontext2, 'core_message');
 834  
 835          // Check that system context hasn't been exported.
 836          $writer = writer::with_context($systemcontext);
 837          $this->assertFalse($writer->has_any_data());
 838  
 839          // Check that course1 context hasn't been exported.
 840          $writer = writer::with_context($coursecontext1);
 841          $this->assertFalse($writer->has_any_data());
 842  
 843          // Check that course2 context has been exported and contains data.
 844          $writer = writer::with_context($coursecontext2);
 845          $this->assertFalse($writer->has_any_data());
 846  
 847          // Confirm the user1 has only private messages in the user context.
 848          $this->export_context_data_for_user($user1->id, $user1context, 'core_message');
 849          $writer = writer::with_context($user1context);
 850          $this->assertTrue($writer->has_any_data());
 851  
 852          // Confirm the messages with user 2 are correct.
 853          $messages = (array) $writer->get_data([get_string('messages', 'core_message'), $user2->id]);
 854          $this->assertCount(1, $messages);
 855          $m1 = reset($messages);
 856  
 857          $this->assertEquals(get_string('yes'), $m1->issender);
 858          $this->assertEquals(message_format_message_text($dbpm1), $m1->message);
 859          $this->assertEquals(transform::datetime($now), $m1->timecreated);
 860          $this->assertEquals('-', $m1->timeread);
 861          $this->assertArrayNotHasKey('timedeleted', (array) $m1);
 862  
 863          // Confirm the messages with user 3 are correct.
 864          $messages = (array) $writer->get_data([get_string('messages', 'core_message'), fullname($user3)]);
 865          $this->assertCount(0, $messages);
 866      }
 867  
 868      /**
 869       * Test for provider::export_user_data().
 870       */
 871      public function test_export_for_context_with_notifications() {
 872          $this->resetAfterTest();
 873  
 874          // Create users to test with.
 875          $user1 = $this->getDataGenerator()->create_user();
 876          $user2 = $this->getDataGenerator()->create_user();
 877          $user3 = $this->getDataGenerator()->create_user();
 878  
 879          // Remove user self-conversations.
 880          $this->remove_user_self_conversation($user1->id);
 881          $this->remove_user_self_conversation($user2->id);
 882          $this->remove_user_self_conversation($user3->id);
 883  
 884          $now = time();
 885          $timeread = $now - DAYSECS;
 886  
 887          // Send notifications from user 1 to user 2.
 888          $this->create_notification($user1->id, $user2->id, $now + (9 * DAYSECS), $timeread);
 889          $this->create_notification($user2->id, $user1->id, $now + (8 * DAYSECS));
 890          $this->create_notification($user1->id, $user2->id, $now + (7 * DAYSECS));
 891  
 892          // Send notifications from user 3 to user 1.
 893          $this->create_notification($user3->id, $user1->id, $now + (6 * DAYSECS), $timeread);
 894          $this->create_notification($user1->id, $user3->id, $now + (5 * DAYSECS));
 895          $this->create_notification($user3->id, $user1->id, $now + (4 * DAYSECS));
 896  
 897          // Send notifications from user 3 to user 2 - should not be part of the export.
 898          $this->create_notification($user3->id, $user2->id, $now + (3 * DAYSECS), $timeread);
 899          $this->create_notification($user2->id, $user3->id, $now + (2 * DAYSECS));
 900          $this->create_notification($user3->id, $user2->id, $now + (1 * DAYSECS));
 901  
 902          $user1context = \context_user::instance($user1->id);
 903  
 904          $this->export_context_data_for_user($user1->id, $user1context, 'core_message');
 905  
 906          $writer = writer::with_context($user1context);
 907  
 908          $this->assertTrue($writer->has_any_data());
 909  
 910          // Confirm the notifications.
 911          $notifications = (array) $writer->get_data([get_string('notifications', 'core_message')]);
 912  
 913          $this->assertCount(6, $notifications);
 914      }
 915  
 916      /**
 917       * Test for provider::delete_data_for_all_users_in_context().
 918       */
 919      public function test_delete_data_for_all_users_in_context() {
 920          global $DB;
 921  
 922          $this->resetAfterTest();
 923  
 924          // Create users to test with.
 925          $user1 = $this->getDataGenerator()->create_user();
 926          $user2 = $this->getDataGenerator()->create_user();
 927          $user3 = $this->getDataGenerator()->create_user();
 928          $user4 = $this->getDataGenerator()->create_user();
 929          $user5 = $this->getDataGenerator()->create_user();
 930  
 931          $now = time();
 932          $timeread = $now - DAYSECS;
 933  
 934          $user1context = \context_user::instance($user1->id);
 935  
 936          // Create contacts.
 937          \core_message\api::add_contact($user1->id, $user2->id);
 938          \core_message\api::add_contact($user2->id, $user3->id);
 939  
 940          // Create contact requests.
 941          \core_message\api::create_contact_request($user1->id, $user3->id);
 942          \core_message\api::create_contact_request($user2->id, $user4->id);
 943  
 944          // Block a user.
 945          \core_message\api::block_user($user1->id, $user3->id);
 946          \core_message\api::block_user($user3->id, $user4->id);
 947  
 948          // Create messages.
 949          $m1 = $this->create_message($user1->id, $user2->id, $now + (9 * DAYSECS), true);
 950          $m2 = $this->create_message($user2->id, $user1->id, $now + (8 * DAYSECS));
 951          $m3 = $this->create_message($user2->id, $user3->id, $now + (7 * DAYSECS));
 952  
 953          // Create notifications.
 954          $n1 = $this->create_notification($user1->id, $user2->id, $now + (9 * DAYSECS), $timeread);
 955          $n2 = $this->create_notification($user2->id, $user1->id, $now + (8 * DAYSECS));
 956          $n3 = $this->create_notification($user2->id, $user3->id, $now + (7 * DAYSECS));
 957  
 958          // Delete one of the messages.
 959          \core_message\api::delete_message($user1->id, $m2);
 960  
 961          // There should be 2 contacts.
 962          $this->assertEquals(2, $DB->count_records('message_contacts'));
 963  
 964          // There should be 2 contact requests.
 965          $this->assertEquals(2, $DB->count_records('message_contact_requests'));
 966  
 967          // There should be 2 blocked users.
 968          $this->assertEquals(2, $DB->count_records('message_users_blocked'));
 969  
 970          // There should be 3 messages.
 971          $this->assertEquals(3, $DB->count_records('messages'));
 972  
 973          // There should be 2 user actions - one for reading the message, one for deleting.
 974          $this->assertEquals(2, $DB->count_records('message_user_actions'));
 975  
 976          // There should be 4 conversation members + 5 self-conversations.
 977          $this->assertEquals(9, $DB->count_records('message_conversation_members'));
 978  
 979          // There should be 5 notifications (3 from create_notification and 2 from create_contact_request).
 980          $this->assertEquals(5, $DB->count_records('notifications'));
 981  
 982          provider::delete_data_for_all_users_in_context($user1context);
 983  
 984          // Confirm there is only 1 contact left.
 985          $this->assertEquals(1, $DB->count_records('message_contacts'));
 986          // And it is not related to user1.
 987          $this->assertEquals(0,
 988                  $DB->count_records_select('message_contacts', 'userid = ? OR contactid = ?', [$user1->id, $user1->id]));
 989  
 990          // Confirm there is only 1 contact request left.
 991          $this->assertEquals(1, $DB->count_records('message_contact_requests'));
 992          // And it is not related to user1.
 993          $this->assertEquals(0,
 994                  $DB->count_records_select('message_contact_requests', 'userid = ? OR requesteduserid = ?',
 995                          [$user1->id, $user1->id]));
 996  
 997          // Confirm there is only 1 blocked user left.
 998          $this->assertEquals(1, $DB->count_records('message_users_blocked'));
 999          // And it is not related to user1.
1000          $this->assertEquals(0,
1001                  $DB->count_records_select('message_users_blocked', 'userid = ? OR blockeduserid = ?', [$user1->id, $user1->id]));
1002  
1003          // Confirm there are only 2 messages left.
1004          $this->assertEquals(2, $DB->count_records('messages'));
1005          // And none of them are from user1.
1006          $this->assertEquals(0, $DB->count_records('messages', ['useridfrom' => $user1->id]));
1007  
1008          // Confirm there is 0 user action left.
1009          $this->assertEquals(0, $DB->count_records('message_user_actions'));
1010          // And it is not for user1.
1011          $this->assertEquals(0, $DB->count_records('message_user_actions', ['userid' => $user1->id]));
1012  
1013          // Confirm there are only 3 conversation members left + 4 self-conversations.
1014          $this->assertEquals(7, $DB->count_records('message_conversation_members'));
1015          // And user1 is not in any conversation.
1016          $this->assertEquals(0, $DB->count_records('message_conversation_members', ['userid' => $user1->id]));
1017  
1018          // Confirm there are only 2 notifications.
1019          $this->assertEquals(2, $DB->count_records('notifications'));
1020          // And it is not related to user1.
1021          $this->assertEquals(0,
1022                  $DB->count_records_select('notifications', 'useridfrom = ? OR useridto = ? ', [$user1->id, $user1->id]));
1023  
1024          // Delete user self-conversations.
1025          $this->remove_user_self_conversation($user2->id);
1026          $this->remove_user_self_conversation($user3->id);
1027          $this->remove_user_self_conversation($user4->id);
1028          $this->remove_user_self_conversation($user5->id);
1029  
1030          // Confirm there are only 3 conversation members left.
1031          $this->assertEquals(3, $DB->count_records('message_conversation_members'));
1032          // And user1 is not in any conversation.
1033          $this->assertEquals(0, $DB->count_records('message_conversation_members', ['userid' => $user1->id]));
1034  
1035      }
1036  
1037      /**
1038       * Test for provider::delete_data_for_user().
1039       */
1040      public function test_delete_data_for_user() {
1041          global $DB;
1042  
1043          $this->resetAfterTest();
1044  
1045          // Create users to test with.
1046          $user1 = $this->getDataGenerator()->create_user();
1047          $user2 = $this->getDataGenerator()->create_user();
1048          $user3 = $this->getDataGenerator()->create_user();
1049          $user4 = $this->getDataGenerator()->create_user();
1050          $user5 = $this->getDataGenerator()->create_user();
1051          $user6 = $this->getDataGenerator()->create_user();
1052  
1053          $now = time();
1054          $timeread = $now - DAYSECS;
1055  
1056          // Create contacts.
1057          \core_message\api::add_contact($user1->id, $user2->id);
1058          \core_message\api::add_contact($user2->id, $user3->id);
1059  
1060          // Create contact requests.
1061          \core_message\api::create_contact_request($user1->id, $user3->id);
1062          \core_message\api::create_contact_request($user2->id, $user4->id);
1063  
1064          // Block users.
1065          \core_message\api::block_user($user1->id, $user5->id);
1066          \core_message\api::block_user($user2->id, $user6->id);
1067  
1068          // Create messages.
1069          $m1 = $this->create_message($user1->id, $user2->id, $now + (9 * DAYSECS), $timeread);
1070          $m2 = $this->create_message($user2->id, $user1->id, $now + (8 * DAYSECS));
1071  
1072          // Create notifications.
1073          $n1 = $this->create_notification($user1->id, $user2->id, $now + (9 * DAYSECS), $timeread);
1074          $n2 = $this->create_notification($user2->id, $user1->id, $now + (8 * DAYSECS));
1075          $n2 = $this->create_notification($user2->id, $user3->id, $now + (8 * DAYSECS));
1076  
1077          // Delete one of the messages.
1078          \core_message\api::delete_message($user1->id, $m2);
1079  
1080          // There should be 2 contacts.
1081          $this->assertEquals(2, $DB->count_records('message_contacts'));
1082  
1083          // There should be 1 contact request.
1084          $this->assertEquals(2, $DB->count_records('message_contact_requests'));
1085  
1086          // There should be 1 blocked user.
1087          $this->assertEquals(2, $DB->count_records('message_users_blocked'));
1088  
1089          // There should be two messages.
1090          $this->assertEquals(2, $DB->count_records('messages'));
1091  
1092          // There should be two user actions - one for reading the message, one for deleting.
1093          $this->assertEquals(2, $DB->count_records('message_user_actions'));
1094  
1095          // There should be two conversation members + 6 self-conversations.
1096          $this->assertEquals(8, $DB->count_records('message_conversation_members'));
1097  
1098          // There should be 5 notifications (3 from create_notification and 2 from create_contact_request).
1099          $this->assertEquals(5, $DB->count_records('notifications'));
1100  
1101          $user1context = \context_user::instance($user1->id);
1102          $contextlist = new \core_privacy\local\request\approved_contextlist($user1, 'core_message',
1103              [$user1context->id]);
1104          provider::delete_data_for_user($contextlist);
1105  
1106          // Confirm the user 2 data still exists.
1107          $contacts = $DB->get_records('message_contacts');
1108          $contactrequests = $DB->get_records('message_contact_requests');
1109          $blockedusers = $DB->get_records('message_users_blocked');
1110          $messages = $DB->get_records('messages');
1111          $muas = $DB->get_records('message_user_actions');
1112          $mcms = $DB->get_records('message_conversation_members');
1113          $notifications = $DB->get_records('notifications');
1114  
1115          $this->assertCount(1, $contacts);
1116          $contact = reset($contacts);
1117          $this->assertEquals($user2->id, $contact->userid);
1118          $this->assertEquals($user3->id, $contact->contactid);
1119  
1120          $this->assertCount(1, $contactrequests);
1121          $contactrequest = reset($contactrequests);
1122          $this->assertEquals($user2->id, $contactrequest->userid);
1123          $this->assertEquals($user4->id, $contactrequest->requesteduserid);
1124  
1125          $this->assertCount(1, $blockedusers);
1126          $blockeduser = reset($blockedusers);
1127          $this->assertEquals($user2->id, $blockeduser->userid);
1128          $this->assertEquals($user6->id, $blockeduser->blockeduserid);
1129  
1130          $this->assertCount(1, $messages);
1131          $message = reset($messages);
1132          $this->assertEquals($m2, $message->id);
1133  
1134          $this->assertCount(0, $muas);
1135  
1136          $this->assertCount(6, $mcms);
1137          $members = array_map(function($member) {
1138              return $member->userid;
1139          }, $mcms);
1140          $this->assertContains($user2->id, $members);
1141  
1142          $this->assertCount(2, $notifications);
1143          ksort($notifications);
1144  
1145          $notification = array_pop($notifications);
1146          $this->assertEquals($user2->id, $notification->useridfrom);
1147          $this->assertEquals($user3->id, $notification->useridto);
1148      }
1149  
1150      /**
1151       * Test for provider::get_users_in_context() when there is no message or notification.
1152       */
1153      public function test_get_users_in_context_no_data() {
1154          $this->resetAfterTest();
1155  
1156          $user = $this->getDataGenerator()->create_user();
1157          $usercontext = \context_user::instance($user->id);
1158          $this->remove_user_self_conversation($user->id);
1159  
1160          $userlist = new \core_privacy\local\request\userlist($usercontext, 'core_message');
1161          \core_message\privacy\provider::get_users_in_context($userlist);
1162  
1163          $this->assertEmpty($userlist->get_userids());
1164      }
1165  
1166      /**
1167       * Test for provider::get_users_in_context() when there is a message between users.
1168       */
1169      public function test_get_users_in_context_with_message() {
1170          $this->resetAfterTest();
1171  
1172          $user1 = $this->getDataGenerator()->create_user();
1173          $user2 = $this->getDataGenerator()->create_user();
1174  
1175          $user1context = \context_user::instance($user1->id);
1176          $user2context = \context_user::instance($user2->id);
1177  
1178          // Delete user self-conversations.
1179          $this->remove_user_self_conversation($user1->id);
1180          $this->remove_user_self_conversation($user2->id);
1181  
1182          // Test nothing is found before message is sent.
1183          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1184          \core_message\privacy\provider::get_users_in_context($userlist);
1185          $this->assertCount(0, $userlist);
1186          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1187          \core_message\privacy\provider::get_users_in_context($userlist);
1188          $this->assertCount(0, $userlist);
1189  
1190          $this->create_message($user1->id, $user2->id, time() - (9 * DAYSECS));
1191  
1192          // Test for the sender.
1193          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1194          \core_message\privacy\provider::get_users_in_context($userlist);
1195          $this->assertCount(1, $userlist);
1196          $userincontext = $userlist->current();
1197          $this->assertEquals($user1->id, $userincontext->id);
1198  
1199          // Test for the receiver.
1200          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1201          \core_message\privacy\provider::get_users_in_context($userlist);
1202          $this->assertCount(1, $userlist);
1203          $userincontext = $userlist->current();
1204          $this->assertEquals($user2->id, $userincontext->id);
1205      }
1206  
1207      /**
1208       * Test for provider::get_users_in_context() when there is a notification between users.
1209       */
1210      public function test_get_users_in_context_with_notification() {
1211          $this->resetAfterTest();
1212  
1213          $user1 = $this->getDataGenerator()->create_user();
1214          $user2 = $this->getDataGenerator()->create_user();
1215  
1216          $user1context = \context_user::instance($user1->id);
1217          $user2context = \context_user::instance($user2->id);
1218  
1219          // Delete user self-conversations.
1220          $this->remove_user_self_conversation($user1->id);
1221          $this->remove_user_self_conversation($user2->id);
1222  
1223          // Test nothing is found before notification is created.
1224          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1225          \core_message\privacy\provider::get_users_in_context($userlist);
1226          $this->assertCount(0, $userlist);
1227          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1228          \core_message\privacy\provider::get_users_in_context($userlist);
1229          $this->assertCount(0, $userlist);
1230  
1231          $this->create_notification($user1->id, $user2->id, time() - (9 * DAYSECS));
1232  
1233          // Test for the sender.
1234          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1235          \core_message\privacy\provider::get_users_in_context($userlist);
1236          $this->assertCount(1, $userlist);
1237          $userincontext = $userlist->current();
1238          $this->assertEquals($user1->id, $userincontext->id);
1239  
1240          // Test for the receiver.
1241          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1242          \core_message\privacy\provider::get_users_in_context($userlist);
1243          $this->assertCount(1, $userlist);
1244          $userincontext = $userlist->current();
1245          $this->assertEquals($user2->id, $userincontext->id);
1246      }
1247  
1248      /**
1249       * Test for provider::get_users_in_context() when a users has a contact.
1250       */
1251      public function test_get_users_in_context_with_contact() {
1252          $this->resetAfterTest();
1253  
1254          $user1 = $this->getDataGenerator()->create_user();
1255          $user2 = $this->getDataGenerator()->create_user();
1256  
1257          $user1context = \context_user::instance($user1->id);
1258          $user2context = \context_user::instance($user2->id);
1259  
1260          // Delete user self-conversations.
1261          $this->remove_user_self_conversation($user1->id);
1262          $this->remove_user_self_conversation($user2->id);
1263  
1264          // Test nothing is found before contact is created.
1265          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1266          \core_message\privacy\provider::get_users_in_context($userlist);
1267          $this->assertCount(0, $userlist);
1268          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1269          \core_message\privacy\provider::get_users_in_context($userlist);
1270          $this->assertCount(0, $userlist);
1271  
1272          \core_message\api::add_contact($user1->id, $user2->id);
1273  
1274          // Test for the user adding the contact.
1275          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1276          \core_message\privacy\provider::get_users_in_context($userlist);
1277          $this->assertCount(1, $userlist);
1278          $userincontext = $userlist->current();
1279          $this->assertEquals($user1->id, $userincontext->id);
1280  
1281          // Test for the user who is the contact.
1282          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1283          \core_message\privacy\provider::get_users_in_context($userlist);
1284          $this->assertCount(1, $userlist);
1285          $userincontext = $userlist->current();
1286          $this->assertEquals($user2->id, $userincontext->id);
1287      }
1288  
1289      /**
1290       * Test for provider::get_users_in_context() when a user makes a contact request.
1291       */
1292      public function test_get_users_in_context_with_contact_request() {
1293          $this->resetAfterTest();
1294  
1295          $user1 = $this->getDataGenerator()->create_user();
1296          $user2 = $this->getDataGenerator()->create_user();
1297  
1298          $user1context = \context_user::instance($user1->id);
1299          $user2context = \context_user::instance($user2->id);
1300  
1301          // Delete user self-conversations.
1302          $this->remove_user_self_conversation($user1->id);
1303          $this->remove_user_self_conversation($user2->id);
1304  
1305          // Test nothing is found before request is created.
1306          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1307          \core_message\privacy\provider::get_users_in_context($userlist);
1308          $this->assertCount(0, $userlist);
1309          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1310          \core_message\privacy\provider::get_users_in_context($userlist);
1311          $this->assertCount(0, $userlist);
1312  
1313          \core_message\api::create_contact_request($user1->id, $user2->id);
1314  
1315          // Test for the user requesting the contact.
1316          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1317          \core_message\privacy\provider::get_users_in_context($userlist);
1318          $this->assertCount(1, $userlist);
1319          $userincontext = $userlist->current();
1320          $this->assertEquals($user1->id, $userincontext->id);
1321  
1322          // Test for the user receiving the contact request.
1323          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1324          \core_message\privacy\provider::get_users_in_context($userlist);
1325          $this->assertCount(1, $userlist);
1326          $userincontext = $userlist->current();
1327          $this->assertEquals($user2->id, $userincontext->id);
1328      }
1329  
1330      /**
1331       * Test for provider::get_users_in_context() when a user is blocked.
1332       */
1333      public function test_get_users_in_context_with_blocked_contact() {
1334          $this->resetAfterTest();
1335  
1336          $user1 = $this->getDataGenerator()->create_user();
1337          $user2 = $this->getDataGenerator()->create_user();
1338  
1339          $user1context = \context_user::instance($user1->id);
1340          $user2context = \context_user::instance($user2->id);
1341  
1342          // Delete user self-conversations.
1343          $this->remove_user_self_conversation($user1->id);
1344          $this->remove_user_self_conversation($user2->id);
1345  
1346          // Test nothing is found before user is blocked.
1347          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1348          \core_message\privacy\provider::get_users_in_context($userlist);
1349          $this->assertCount(0, $userlist);
1350          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1351          \core_message\privacy\provider::get_users_in_context($userlist);
1352          $this->assertCount(0, $userlist);
1353  
1354          \core_message\api::block_user($user1->id, $user2->id);
1355  
1356          // Test for the blocking user.
1357          $userlist = new \core_privacy\local\request\userlist($user1context, 'core_message');
1358          \core_message\privacy\provider::get_users_in_context($userlist);
1359          $this->assertCount(1, $userlist);
1360          $userincontext = $userlist->current();
1361          $this->assertEquals($user1->id, $userincontext->id);
1362  
1363          // Test for the user who is blocked.
1364          $userlist = new \core_privacy\local\request\userlist($user2context, 'core_message');
1365          \core_message\privacy\provider::get_users_in_context($userlist);
1366          $this->assertCount(1, $userlist);
1367          $userincontext = $userlist->current();
1368          $this->assertEquals($user2->id, $userincontext->id);
1369      }
1370  
1371      /**
1372       * Test for provider::delete_data_for_users().
1373       */
1374      public function test_delete_data_for_users() {
1375          global $DB;
1376  
1377          $this->resetAfterTest();
1378  
1379          // Create users to test with.
1380          $user1 = $this->getDataGenerator()->create_user();
1381          $user2 = $this->getDataGenerator()->create_user();
1382          $user3 = $this->getDataGenerator()->create_user();
1383          $user4 = $this->getDataGenerator()->create_user();
1384          $user5 = $this->getDataGenerator()->create_user();
1385          $user6 = $this->getDataGenerator()->create_user();
1386  
1387          $now = time();
1388          $timeread = $now - DAYSECS;
1389  
1390          // Create contacts.
1391          \core_message\api::add_contact($user1->id, $user2->id);
1392          \core_message\api::add_contact($user2->id, $user3->id);
1393  
1394          // Create contact requests.
1395          \core_message\api::create_contact_request($user1->id, $user3->id);
1396          \core_message\api::create_contact_request($user2->id, $user4->id);
1397  
1398          // Block users.
1399          \core_message\api::block_user($user1->id, $user5->id);
1400          \core_message\api::block_user($user2->id, $user6->id);
1401  
1402          // Create messages.
1403          $m1 = $this->create_message($user1->id, $user2->id, $now + (9 * DAYSECS), $timeread);
1404          $m2 = $this->create_message($user2->id, $user1->id, $now + (8 * DAYSECS));
1405  
1406          // Create notifications.
1407          $n1 = $this->create_notification($user1->id, $user2->id, $now + (9 * DAYSECS), $timeread);
1408          $n2 = $this->create_notification($user2->id, $user1->id, $now + (8 * DAYSECS));
1409          $n2 = $this->create_notification($user2->id, $user3->id, $now + (8 * DAYSECS));
1410  
1411          // Delete one of the messages.
1412          \core_message\api::delete_message($user1->id, $m2);
1413  
1414          // There should be 2 contacts.
1415          $this->assertEquals(2, $DB->count_records('message_contacts'));
1416  
1417          // There should be 1 contact request.
1418          $this->assertEquals(2, $DB->count_records('message_contact_requests'));
1419  
1420          // There should be 1 blocked user.
1421          $this->assertEquals(2, $DB->count_records('message_users_blocked'));
1422  
1423          // There should be two messages.
1424          $this->assertEquals(2, $DB->count_records('messages'));
1425  
1426          // There should be two user actions - one for reading the message, one for deleting.
1427          $this->assertEquals(2, $DB->count_records('message_user_actions'));
1428  
1429          // There should be two conversation members + 6 self-conversations.
1430          $this->assertEquals(8, $DB->count_records('message_conversation_members'));
1431  
1432          // There should be three notifications + two for the contact requests.
1433          $this->assertEquals(5, $DB->count_records('notifications'));
1434  
1435          $user1context = \context_user::instance($user1->id);
1436          $approveduserlist = new \core_privacy\local\request\approved_userlist($user1context, 'core_message',
1437                  [$user1->id, $user2->id]);
1438          provider::delete_data_for_users($approveduserlist);
1439  
1440          // Only user1's data should be deleted. User2 should be skipped as user2 is an invalid user for user1context.
1441  
1442          // Confirm the user 2 data still exists.
1443          $contacts = $DB->get_records('message_contacts');
1444          $contactrequests = $DB->get_records('message_contact_requests');
1445          $blockedusers = $DB->get_records('message_users_blocked');
1446          $messages = $DB->get_records('messages');
1447          $muas = $DB->get_records('message_user_actions');
1448          $mcms = $DB->get_records('message_conversation_members');
1449          $notifications = $DB->get_records('notifications');
1450  
1451          $this->assertCount(1, $contacts);
1452          $contact = reset($contacts);
1453          $this->assertEquals($user2->id, $contact->userid);
1454          $this->assertEquals($user3->id, $contact->contactid);
1455  
1456          $this->assertCount(1, $contactrequests);
1457          $contactrequest = reset($contactrequests);
1458          $this->assertEquals($user2->id, $contactrequest->userid);
1459          $this->assertEquals($user4->id, $contactrequest->requesteduserid);
1460  
1461          $this->assertCount(1, $blockedusers);
1462          $blockeduser = reset($blockedusers);
1463          $this->assertEquals($user2->id, $blockeduser->userid);
1464          $this->assertEquals($user6->id, $blockeduser->blockeduserid);
1465  
1466          $this->assertCount(1, $messages);
1467          $message = reset($messages);
1468          $this->assertEquals($m2, $message->id);
1469  
1470          $this->assertCount(0, $muas);
1471  
1472          $this->assertCount(6, $mcms);
1473          $memberids = array_map(function($convmember) {
1474                  return $convmember->userid;
1475          }, $mcms);
1476          $this->assertContains($user2->id, $memberids);
1477  
1478          $this->assertCount(2, $notifications);
1479          ksort($notifications);
1480  
1481          $notification = array_pop($notifications);
1482          $this->assertEquals($user2->id, $notification->useridfrom);
1483          $this->assertEquals($user3->id, $notification->useridto);
1484      }
1485  
1486      /**
1487       * Test for provider::add_contexts_for_conversations().
1488       */
1489      public function test_add_contexts_for_conversations() {
1490          $this->resetAfterTest();
1491          $this->setAdminUser();
1492          $component = 'core_group';
1493          $itemtype = 'groups';
1494  
1495          $user1 = $this->getDataGenerator()->create_user();
1496          $user2 = $this->getDataGenerator()->create_user();
1497          $user3 = $this->getDataGenerator()->create_user();
1498          $user4 = $this->getDataGenerator()->create_user();
1499  
1500          // Delete user self-conversations.
1501          $this->remove_user_self_conversation($user1->id);
1502          $this->remove_user_self_conversation($user2->id);
1503          $this->remove_user_self_conversation($user3->id);
1504          $this->remove_user_self_conversation($user4->id);
1505  
1506          // Test nothing is found before group conversations is created or message is sent.
1507          $contextlist = new contextlist();
1508          provider::add_contexts_for_conversations($contextlist, $user1->id, $component, $itemtype);
1509          $this->assertCount(0, $contextlist);
1510          provider::add_contexts_for_conversations($contextlist, $user2->id, $component, $itemtype);
1511          $this->assertCount(0, $contextlist);
1512  
1513          // Create courses.
1514          $course1 = $this->getDataGenerator()->create_course();
1515          $course2 = $this->getDataGenerator()->create_course();
1516          $coursecontext1 = \context_course::instance($course1->id);
1517          $coursecontext2 = \context_course::instance($course2->id);
1518  
1519          // Enrol users to courses.
1520          $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
1521          $this->getDataGenerator()->enrol_user($user2->id, $course1->id);
1522          $this->getDataGenerator()->enrol_user($user3->id, $course1->id);
1523          $this->getDataGenerator()->enrol_user($user1->id, $course2->id);
1524          $this->getDataGenerator()->enrol_user($user2->id, $course2->id);
1525  
1526          // Create course groups with messaging enabled.
1527          $group1a = $this->getDataGenerator()->create_group(array('courseid' => $course1->id, 'enablemessaging' => 1));
1528          $group2a = $this->getDataGenerator()->create_group(array('courseid' => $course2->id, 'enablemessaging' => 1));
1529  
1530          // Add users to groups.
1531          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user1->id));
1532          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user2->id));
1533          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user3->id));
1534          $this->getDataGenerator()->create_group_member(array('groupid' => $group2a->id, 'userid' => $user1->id));
1535  
1536          // Get conversation.
1537          $conversation1 = \core_message\api::get_conversation_by_area(
1538              $component,
1539              $itemtype,
1540              $group1a->id,
1541              $coursecontext1->id
1542          );
1543  
1544          // Send some messages to the group conversation.
1545          $now = time();
1546          $m1id = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 1', $now + 1);
1547          $m2id = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 2', $now + 2);
1548          $m3id = testhelper::send_fake_message_to_conversation($user2, $conversation1->id, 'Message 3', $now + 3);
1549  
1550          // Test for user1 (is member of the conversation and has sent a message).
1551          $contextlist = new contextlist();
1552          provider::add_contexts_for_conversations($contextlist, $user1->id, $component, $itemtype);
1553          $this->assertCount(2, $contextlist);
1554          $this->assertContainsEquals($coursecontext1->id, $contextlist->get_contextids());
1555          $this->assertContainsEquals($coursecontext2->id, $contextlist->get_contextids());
1556  
1557          // Test for user2 (is member of the conversation and has sent a message).
1558          $contextlist = new contextlist();
1559          provider::add_contexts_for_conversations($contextlist, $user2->id, $component, $itemtype);
1560          $this->assertCount(1, $contextlist);
1561          $this->assertEquals($coursecontext1, $contextlist->current());
1562  
1563          // Test for user3 (is member of the conversation).
1564          $contextlist = new contextlist();
1565          provider::add_contexts_for_conversations($contextlist, $user3->id, $component, $itemtype);
1566          $this->assertCount(1, $contextlist);
1567          $this->assertEquals($coursecontext1, $contextlist->current());
1568  
1569          // Test for user4 (doesn't belong to the conversation).
1570          $contextlist = new contextlist();
1571          provider::add_contexts_for_conversations($contextlist, $user4->id, $component, $itemtype);
1572          $this->assertCount(0, $contextlist);
1573      }
1574  
1575      /**
1576       * Test for provider::add_conversations_in_context().
1577       */
1578      public function test_add_conversations_in_context() {
1579          $this->resetAfterTest();
1580          $this->setAdminUser();
1581          $component = 'core_group';
1582          $itemtype = 'groups';
1583  
1584          $user1 = $this->getDataGenerator()->create_user();
1585          $user2 = $this->getDataGenerator()->create_user();
1586          $user3 = $this->getDataGenerator()->create_user();
1587          $user4 = $this->getDataGenerator()->create_user();
1588  
1589          // Create courses.
1590          $course1 = $this->getDataGenerator()->create_course();
1591          $course2 = $this->getDataGenerator()->create_course();
1592          $coursecontext1 = \context_course::instance($course1->id);
1593          $coursecontext2 = \context_course::instance($course2->id);
1594  
1595          // Test nothing is found before group conversations is created or message is sent.
1596          $userlist1 = new \core_privacy\local\request\userlist($coursecontext1, 'core_message');
1597          provider::add_conversations_in_context($userlist1, $component, $itemtype);
1598          $this->assertCount(0, $userlist1);
1599  
1600          // Enrol users to courses.
1601          $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
1602          $this->getDataGenerator()->enrol_user($user2->id, $course1->id);
1603          $this->getDataGenerator()->enrol_user($user3->id, $course1->id);
1604          $this->getDataGenerator()->enrol_user($user4->id, $course1->id);
1605          $this->getDataGenerator()->enrol_user($user1->id, $course2->id);
1606          $this->getDataGenerator()->enrol_user($user2->id, $course2->id);
1607  
1608          // Create course groups with messaging enabled.
1609          $group1a = $this->getDataGenerator()->create_group(array('courseid' => $course1->id, 'enablemessaging' => 1));
1610          $group2a = $this->getDataGenerator()->create_group(array('courseid' => $course2->id, 'enablemessaging' => 1));
1611  
1612          // Add users to groups.
1613          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user1->id));
1614          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user2->id));
1615          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user3->id));
1616          $this->getDataGenerator()->create_group_member(array('groupid' => $group2a->id, 'userid' => $user1->id));
1617  
1618          // Get conversation.
1619          $conversation1 = \core_message\api::get_conversation_by_area(
1620              $component,
1621              $itemtype,
1622              $group1a->id,
1623              $coursecontext1->id
1624          );
1625  
1626          // Send some messages to the group conversation.
1627          $now = time();
1628          $m1id = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 1', $now + 1);
1629          $m2id = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 2', $now + 2);
1630          $m3id = testhelper::send_fake_message_to_conversation($user2, $conversation1->id, 'Message 3', $now + 3);
1631  
1632          // Test for users with any group conversation in course1.
1633          provider::add_conversations_in_context($userlist1, $component, $itemtype);
1634          $this->assertCount(3, $userlist1);
1635          $this->assertEqualsCanonicalizing([$user1->id, $user2->id, $user3->id], $userlist1->get_userids());
1636  
1637          // Test for users with any group conversation in course2.
1638          $userlist2 = new \core_privacy\local\request\userlist($coursecontext2, 'core_message');
1639          provider::add_conversations_in_context($userlist2, $component, $itemtype);
1640          $this->assertCount(1, $userlist2);
1641          $this->assertEquals(
1642                  [$user1->id],
1643                  $userlist2->get_userids());
1644      }
1645  
1646      /**
1647       * Test for provider::export_conversations().
1648       */
1649      public function test_export_conversations() {
1650          global $DB;
1651  
1652          $this->resetAfterTest();
1653          $this->setAdminUser();
1654          $now = time();
1655          $systemcontext = \context_system::instance();
1656  
1657          // Create users to test with.
1658          $user1 = $this->getDataGenerator()->create_user();
1659          $user2 = $this->getDataGenerator()->create_user();
1660          $user3 = $this->getDataGenerator()->create_user();
1661          $user1context = \context_user::instance($user1->id);
1662  
1663          $course1 = $this->getDataGenerator()->create_course();
1664          $course2 = $this->getDataGenerator()->create_course();
1665          $coursecontext1 = \context_course::instance($course1->id);
1666          $coursecontext2 = \context_course::instance($course2->id);
1667  
1668          // Enrol users to courses.
1669          $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
1670          $this->getDataGenerator()->enrol_user($user2->id, $course1->id);
1671          $this->getDataGenerator()->enrol_user($user3->id, $course1->id);
1672          $this->getDataGenerator()->enrol_user($user1->id, $course2->id);
1673  
1674          // Create course groups with group messaging enabled.
1675          $group1a = $this->getDataGenerator()->create_group(array('courseid' => $course1->id, 'enablemessaging' => 1));
1676          $group2a = $this->getDataGenerator()->create_group(array('courseid' => $course2->id, 'enablemessaging' => 1));
1677  
1678          // Add users to groups.
1679          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user1->id));
1680          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user2->id));
1681          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user3->id));
1682          $this->getDataGenerator()->create_group_member(array('groupid' => $group2a->id, 'userid' => $user1->id));
1683  
1684          // Send some private messages between user 1 and user 2.
1685          $pm1id = $this->create_message($user1->id, $user2->id, $now);
1686  
1687          // Get conversation.
1688          $iconversation1id = \core_message\api::get_conversation_between_users([$user1->id, $user2->id]);
1689          $component = 'core_group';
1690          $itemtype = 'groups';
1691          $conversation1 = \core_message\api::get_conversation_by_area(
1692              $component,
1693              $itemtype,
1694              $group1a->id,
1695              $coursecontext1->id
1696          );
1697  
1698          // Make favourite some conversations.
1699          \core_message\api::set_favourite_conversation($conversation1->id, $user1->id);
1700          \core_message\api::set_favourite_conversation($iconversation1id, $user2->id);
1701  
1702          // Mute some conversations.
1703          \core_message\api::mute_conversation($user1->id, $conversation1->id);
1704          \core_message\api::mute_conversation($user2->id, $iconversation1id);
1705  
1706          // Send some messages to the conversation.
1707          $m1 = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 1', $now + 1);
1708          $m2 = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 2', $now + 2);
1709          $m3 = testhelper::send_fake_message_to_conversation($user2, $conversation1->id, 'Message 3', $now + 3);
1710  
1711          $dbm1 = $DB->get_record('messages', ['id' => $m1]);
1712          $dbm2 = $DB->get_record('messages', ['id' => $m2]);
1713          $dbm3 = $DB->get_record('messages', ['id' => $m3]);
1714  
1715          // Mark as read and delete some messages.
1716          \core_message\api::mark_message_as_read($user1->id, $dbm3, $now + 5);
1717          \core_message\api::delete_message($user1->id, $m2);
1718  
1719          // Export all the conversations related to the groups in course1 for user1.
1720          provider::export_conversations($user1->id, 'core_group', 'groups', $coursecontext1);
1721  
1722          // Check that system context hasn't been exported.
1723          $writer = writer::with_context($systemcontext);
1724          $this->assertFalse($writer->has_any_data());
1725  
1726          // Check that course2 context hasn't been exported.
1727          $writer = writer::with_context($coursecontext2);
1728          $this->assertFalse($writer->has_any_data());
1729  
1730          // Check that course1 context has been exported for user1 and contains data.
1731          $writer = writer::with_context($coursecontext1);
1732          $this->assertTrue($writer->has_any_data());
1733  
1734          // Confirm the messages for conversation1 are correct.
1735          $messages = (array) $writer->get_data([
1736              get_string('messages', 'core_message'),
1737              get_string($conversation1->itemtype, $conversation1->component),
1738              get_string('privacy:export:conversationprefix', 'core_message') . $conversation1->name
1739          ]);
1740          $this->assertCount(3, $messages);
1741  
1742          usort($messages, ['static', 'sort_messages']);
1743          $m1 = array_shift($messages);
1744          $m2 = array_shift($messages);
1745          $m3 = array_shift($messages);
1746  
1747          // Check message 1 is correct.
1748          $this->assertEquals(get_string('yes'), $m1->issender);
1749          $this->assertEquals(message_format_message_text($dbm1), $m1->message);
1750          $this->assertEquals(transform::datetime($now + 1), $m1->timecreated);
1751          $this->assertEquals('-', $m1->timeread);
1752          $this->assertArrayNotHasKey('timedeleted', (array) $m1);
1753  
1754          // Check message 2 is correct.
1755          $this->assertEquals(get_string('yes'), $m2->issender);
1756          $this->assertEquals(message_format_message_text($dbm2), $m2->message);
1757          $this->assertEquals(transform::datetime($now + 2), $m2->timecreated);
1758          $this->assertEquals('-', $m2->timeread);
1759          $this->assertArrayHasKey('timedeleted', (array) $m2);
1760  
1761          // Check message 3 is correct.
1762          $this->assertEquals(get_string('no'), $m3->issender);
1763          $this->assertEquals(message_format_message_text($dbm3), $m3->message);
1764          $this->assertEquals(transform::datetime($now + 3), $m3->timecreated);
1765          $this->assertEquals(transform::datetime($now + 5), $m3->timeread);
1766          $this->assertArrayNotHasKey('timedeleted', (array) $m3);
1767  
1768          // Confirm the muted group conversation is correct.
1769          $mutedconversations = (array) $writer->get_related_data([
1770              get_string('messages', 'core_message'),
1771              get_string($conversation1->itemtype, $conversation1->component),
1772              get_string('privacy:export:conversationprefix', 'core_message') . $conversation1->name
1773          ], 'muted');
1774          $this->assertCount(2, $mutedconversations);
1775          $this->assertEquals(get_string('yes'), $mutedconversations['muted']);
1776  
1777          // Confirm the favourite group conversation is correct.
1778          $favourite = (array) $writer->get_related_data([
1779              get_string('messages', 'core_message'),
1780              get_string($conversation1->itemtype, $conversation1->component),
1781              get_string('privacy:export:conversationprefix', 'core_message') . $conversation1->name
1782          ], 'starred');
1783          $this->assertCount(4, $favourite);
1784          $this->assertEquals(get_string('yes'), $favourite['starred']);
1785  
1786          // Reset writer before exporting conversations for user2.
1787          writer::reset();
1788  
1789          // Export all the conversations related to the groups in course1 for user2.
1790          provider::export_conversations($user2->id, 'core_group', 'groups', $coursecontext1);
1791  
1792          // Check that system context hasn't been exported.
1793          $writer = writer::with_context($systemcontext);
1794          $this->assertFalse($writer->has_any_data());
1795  
1796          // Check that course2 context hasn't been exported.
1797          $writer = writer::with_context($coursecontext2);
1798          $this->assertFalse($writer->has_any_data());
1799  
1800          // Check that course1 context has been exported for user2 and contains data.
1801          $writer = writer::with_context($coursecontext1);
1802          $this->assertTrue($writer->has_any_data());
1803  
1804          // Confirm the messages for conversation1 are correct.
1805          $messages = (array) $writer->get_data([
1806              get_string('messages', 'core_message'),
1807              get_string($conversation1->itemtype, $conversation1->component),
1808              get_string('privacy:export:conversationprefix', 'core_message') . $conversation1->name
1809          ]);
1810          $this->assertCount(3, $messages);
1811  
1812          usort($messages, ['static', 'sort_messages']);
1813          $m1 = array_shift($messages);
1814          $m2 = array_shift($messages);
1815          $m3 = array_shift($messages);
1816  
1817          // Check message 1 is correct.
1818          $this->assertEquals(get_string('no'), $m1->issender);
1819          $this->assertEquals(message_format_message_text($dbm1), $m1->message);
1820          $this->assertEquals(transform::datetime($now + 1), $m1->timecreated);
1821          $this->assertEquals('-', $m1->timeread);
1822          $this->assertArrayNotHasKey('timedeleted', (array) $m1);
1823  
1824          // Check message 2 is correct.
1825          $this->assertEquals(get_string('no'), $m2->issender);
1826          $this->assertEquals(message_format_message_text($dbm2), $m2->message);
1827          $this->assertEquals(transform::datetime($now + 2), $m2->timecreated);
1828          $this->assertEquals('-', $m2->timeread);
1829          $this->assertArrayNotHasKey('timedeleted', (array) $m2);
1830  
1831          // Check message 3 is correct.
1832          $this->assertEquals(get_string('yes'), $m3->issender);
1833          $this->assertEquals(message_format_message_text($dbm3), $m3->message);
1834          $this->assertEquals(transform::datetime($now + 3), $m3->timecreated);
1835          $this->assertEquals('-', $m3->timeread);
1836          $this->assertArrayNotHasKey('timedeleted', (array) $m3);
1837  
1838          // Confirm the muted group conversation is correct.
1839          $mutedconversations = (array) $writer->get_related_data([
1840              get_string('messages', 'core_message'),
1841              get_string($conversation1->itemtype, $conversation1->component),
1842              $conversation1->name
1843          ], 'muted');
1844          $this->assertCount(0, $mutedconversations);
1845  
1846          // Confirm there are no favourite group conversation for user2.
1847          $favourite = (array) $writer->get_related_data([
1848              get_string('messages', 'core_message'),
1849              get_string($conversation1->itemtype, $conversation1->component),
1850              $conversation1->name
1851          ], 'starred');
1852          $this->assertCount(0, $favourite);
1853      }
1854  
1855      /**
1856       * Test for provider::delete_conversations_for_all_users().
1857       */
1858      public function test_delete_conversations_for_all_users() {
1859          global $DB;
1860  
1861          $this->resetAfterTest();
1862          $this->setAdminUser();
1863          $now = time();
1864          $timeread = $now - DAYSECS;
1865          $component = 'core_group';
1866          $itemtype = 'groups';
1867  
1868          // Create users to test with.
1869          $user1 = $this->getDataGenerator()->create_user();
1870          $user2 = $this->getDataGenerator()->create_user();
1871          $user3 = $this->getDataGenerator()->create_user();
1872          $user4 = $this->getDataGenerator()->create_user();
1873          $user5 = $this->getDataGenerator()->create_user();
1874          $user1context = \context_user::instance($user1->id);
1875  
1876          // Create contacts.
1877          \core_message\api::add_contact($user1->id, $user2->id);
1878          \core_message\api::add_contact($user2->id, $user3->id);
1879  
1880          // Create contact requests.
1881          \core_message\api::create_contact_request($user1->id, $user3->id);
1882          \core_message\api::create_contact_request($user2->id, $user4->id);
1883  
1884          // Block a user.
1885          \core_message\api::block_user($user1->id, $user3->id);
1886          \core_message\api::block_user($user3->id, $user4->id);
1887  
1888          // Create individual messages.
1889          $im1 = $this->create_message($user1->id, $user2->id, $now + (9 * DAYSECS), true);
1890          $im2 = $this->create_message($user2->id, $user1->id, $now + (8 * DAYSECS), true);
1891          $im3 = $this->create_message($user2->id, $user3->id, $now + (7 * DAYSECS));
1892  
1893          // Create notifications.
1894          $n1 = $this->create_notification($user1->id, $user2->id, $now + (9 * DAYSECS), $timeread);
1895          $n2 = $this->create_notification($user2->id, $user1->id, $now + (8 * DAYSECS));
1896          $n3 = $this->create_notification($user2->id, $user3->id, $now + (7 * DAYSECS));
1897  
1898          // Delete one of the messages.
1899          \core_message\api::delete_message($user1->id, $im2);
1900  
1901          // Create course2.
1902          $course1 = $this->getDataGenerator()->create_course();
1903          $course2 = $this->getDataGenerator()->create_course();
1904          $coursecontext1 = \context_course::instance($course1->id);
1905          $coursecontext2 = \context_course::instance($course2->id);
1906  
1907          // Enrol users to courses.
1908          $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
1909          $this->getDataGenerator()->enrol_user($user2->id, $course1->id);
1910          $this->getDataGenerator()->enrol_user($user3->id, $course1->id);
1911          $this->getDataGenerator()->enrol_user($user1->id, $course2->id);
1912          $this->getDataGenerator()->enrol_user($user2->id, $course2->id);
1913  
1914          // Create course groups with group messaging enabled.
1915          $group1a = $this->getDataGenerator()->create_group(array('courseid' => $course1->id, 'enablemessaging' => 1));
1916          $group2a = $this->getDataGenerator()->create_group(array('courseid' => $course2->id, 'enablemessaging' => 1));
1917  
1918          // Add users to groups.
1919          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user1->id));
1920          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user2->id));
1921          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user3->id));
1922          $this->getDataGenerator()->create_group_member(array('groupid' => $group2a->id, 'userid' => $user1->id));
1923          $this->getDataGenerator()->create_group_member(array('groupid' => $group2a->id, 'userid' => $user2->id));
1924  
1925          // Get conversations.
1926          $iconversation1id = \core_message\api::get_conversation_between_users([$user1->id, $user2->id]);
1927          $conversation1 = \core_message\api::get_conversation_by_area(
1928              $component,
1929              $itemtype,
1930              $group1a->id,
1931              $coursecontext1->id
1932          );
1933          $conversation2 = \core_message\api::get_conversation_by_area(
1934              $component,
1935              $itemtype,
1936              $group2a->id,
1937              $coursecontext2->id
1938          );
1939  
1940          // Make favourite some conversations.
1941          \core_message\api::set_favourite_conversation($iconversation1id, $user1->id);
1942          \core_message\api::set_favourite_conversation($conversation1->id, $user1->id);
1943          \core_message\api::set_favourite_conversation($conversation1->id, $user2->id);
1944  
1945          // Send some messages to the conversation.
1946          $gm1 = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 1.1', $now + 1);
1947          $gm2 = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 1.2', $now + 2);
1948          $gm3 = testhelper::send_fake_message_to_conversation($user2, $conversation1->id, 'Message 1.3', $now + 3);
1949          $gm4 = testhelper::send_fake_message_to_conversation($user1, $conversation2->id, 'Message 2.1', $now + 4);
1950          $gm5 = testhelper::send_fake_message_to_conversation($user2, $conversation2->id, 'Message 2.2', $now + 5);
1951  
1952          $dbgm1 = $DB->get_record('messages', ['id' => $gm1]);
1953          $dbgm2 = $DB->get_record('messages', ['id' => $gm2]);
1954          $dbgm3 = $DB->get_record('messages', ['id' => $gm3]);
1955          $dbgm4 = $DB->get_record('messages', ['id' => $gm4]);
1956          $dbgm5 = $DB->get_record('messages', ['id' => $gm5]);
1957  
1958          // Mark as read one of the conversation messages.
1959          \core_message\api::mark_message_as_read($user1->id, $dbgm3, $now + 5);
1960  
1961          // Mark some conversations as muted by two users.
1962          \core_message\api::mute_conversation($user1->id, $iconversation1id);
1963          \core_message\api::mute_conversation($user1->id, $conversation1->id);
1964          \core_message\api::mute_conversation($user2->id, $conversation1->id);
1965  
1966          // There should be 2 contacts.
1967          $this->assertEquals(2, $DB->count_records('message_contacts'));
1968  
1969          // There should be 2 contact requests.
1970          $this->assertEquals(2, $DB->count_records('message_contact_requests'));
1971  
1972          // There should be 2 blocked users.
1973          $this->assertEquals(2, $DB->count_records('message_users_blocked'));
1974  
1975          // There should be 8 messages.
1976          $this->assertEquals(8, $DB->count_records('messages'));
1977  
1978          // There should be 4 user actions - 3 for reading the message, 1 for deleting.
1979          $this->assertEquals(4, $DB->count_records('message_user_actions'));
1980  
1981          // There should be 3 muted conversations.
1982          $this->assertEquals(3, $DB->count_records('message_conversation_actions'));
1983  
1984          // There should be 4 conversations - 2 individual + 2 group + 5 self-conversations.
1985          $this->assertEquals(9, $DB->count_records('message_conversations'));
1986  
1987          // There should be 9 conversation members - (2 + 2) individual + (3 + 2) group + 5 self-conversations.
1988          $this->assertEquals(14 , $DB->count_records('message_conversation_members'));
1989  
1990          // There should be 5 notifications (3 from create_notification and 2 from create_contact_request).
1991          $this->assertEquals(5, $DB->count_records('notifications'));
1992  
1993          // There should be 3 favourite conversations + 5 self-conversations.
1994          $this->assertEquals(8, $DB->count_records('favourite'));
1995  
1996          // Delete conversations for all users in course1.
1997          provider::delete_conversations_for_all_users($coursecontext1, $component, $itemtype);
1998  
1999          // There should be still 2 contacts.
2000          $this->assertEquals(2, $DB->count_records('message_contacts'));
2001  
2002          // There should be still 2 contact requests.
2003          $this->assertEquals(2, $DB->count_records('message_contact_requests'));
2004  
2005          // There should be still 2 blocked users.
2006          $this->assertEquals(2, $DB->count_records('message_users_blocked'));
2007  
2008          // There should be 1 muted conversation.
2009          $this->assertEquals(1, $DB->count_records('message_conversation_actions'));
2010  
2011          // There should be 3 notifications.
2012          $this->assertEquals(5, $DB->count_records('notifications'));
2013  
2014          // There should be 5 messages - 3 individual - 2 group (course2).
2015          $this->assertEquals(5, $DB->count_records('messages'));
2016          $messages = $DB->get_records('messages');
2017          $this->assertArrayHasKey($im1, $messages);
2018          $this->assertArrayHasKey($im2, $messages);
2019          $this->assertArrayHasKey($im3, $messages);
2020          $this->assertArrayHasKey($gm4, $messages);
2021          $this->assertArrayHasKey($gm5, $messages);
2022  
2023          // There should be 3 user actions - 2 for reading the message, 1 for deleting.
2024          $this->assertEquals(3, $DB->count_records('message_user_actions'));
2025          $useractions = $DB->get_records('message_user_actions');
2026          $useractions = array_map(function($action) {
2027                  return $action->messageid;
2028          }, $useractions);
2029          $this->assertNotContains($gm3, $useractions);
2030  
2031          // There should be 3 conversations - 2 individual + 1 group (course2) + 5 self-conversations.
2032          $this->assertEquals(8, $DB->count_records('message_conversations'));
2033          $conversations = $DB->get_records('message_conversations');
2034          $this->assertArrayNotHasKey($conversation1->id, $conversations);
2035  
2036          // There should be 6 conversation members - (2 + 2) individual + 2 group + 5 self-conversations.
2037          $this->assertEquals(11, $DB->count_records('message_conversation_members'));
2038  
2039          // There should be 1 favourite conversation - the individual one + 5 self-conversations.
2040          $this->assertEquals(6, $DB->count_records('favourite'));
2041      }
2042  
2043      /**
2044       * Test for provider::delete_conversations_for_all_users() in the system context.
2045       */
2046      public function test_delete_conversations_for_all_users_systemcontext() {
2047          global $DB;
2048  
2049          $this->resetAfterTest();
2050          $this->setAdminUser();
2051          $now = time();
2052          $timeread = $now - DAYSECS;
2053          $systemcontext = \context_system::instance();
2054          $component = 'core_group';
2055          $itemtype = 'groups';
2056  
2057          // Create users to test with.
2058          $user1 = $this->getDataGenerator()->create_user();
2059          $user2 = $this->getDataGenerator()->create_user();
2060          $user3 = $this->getDataGenerator()->create_user();
2061          $user4 = $this->getDataGenerator()->create_user();
2062          $user5 = $this->getDataGenerator()->create_user();
2063  
2064          // Create contacts.
2065          \core_message\api::add_contact($user1->id, $user2->id);
2066          \core_message\api::add_contact($user2->id, $user3->id);
2067  
2068          // Create contact requests.
2069          \core_message\api::create_contact_request($user1->id, $user3->id);
2070          \core_message\api::create_contact_request($user2->id, $user4->id);
2071  
2072          // Block a user.
2073          \core_message\api::block_user($user1->id, $user3->id);
2074          \core_message\api::block_user($user3->id, $user4->id);
2075  
2076          // Create individual messages.
2077          $im1 = $this->create_message($user1->id, $user2->id, $now + (9 * DAYSECS), true);
2078          $im2 = $this->create_message($user2->id, $user1->id, $now + (8 * DAYSECS), true);
2079          $im3 = $this->create_message($user2->id, $user3->id, $now + (7 * DAYSECS));
2080  
2081          // Create notifications.
2082          $n1 = $this->create_notification($user1->id, $user2->id, $now + (9 * DAYSECS), $timeread);
2083          $n2 = $this->create_notification($user2->id, $user1->id, $now + (8 * DAYSECS));
2084          $n3 = $this->create_notification($user2->id, $user3->id, $now + (7 * DAYSECS));
2085  
2086          // Delete one of the messages.
2087          \core_message\api::delete_message($user1->id, $im2);
2088  
2089          // Create course2.
2090          $course1 = $this->getDataGenerator()->create_course();
2091          $course2 = $this->getDataGenerator()->create_course();
2092          $coursecontext1 = \context_course::instance($course1->id);
2093          $coursecontext2 = \context_course::instance($course2->id);
2094  
2095          // Enrol users to courses.
2096          $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
2097          $this->getDataGenerator()->enrol_user($user2->id, $course1->id);
2098          $this->getDataGenerator()->enrol_user($user3->id, $course1->id);
2099          $this->getDataGenerator()->enrol_user($user1->id, $course2->id);
2100          $this->getDataGenerator()->enrol_user($user2->id, $course2->id);
2101  
2102          // Create course groups with group messaging enabled.
2103          $group1a = $this->getDataGenerator()->create_group(array('courseid' => $course1->id, 'enablemessaging' => 1));
2104          $group2a = $this->getDataGenerator()->create_group(array('courseid' => $course2->id, 'enablemessaging' => 1));
2105  
2106          // Add users to groups.
2107          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user1->id));
2108          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user2->id));
2109          $this->getDataGenerator()->create_group_member(array('groupid' => $group1a->id, 'userid' => $user3->id));
2110          $this->getDataGenerator()->create_group_member(array('groupid' => $group2a->id, 'userid' => $user1->id));
2111          $this->getDataGenerator()->create_group_member(array('groupid' => $group2a->id, 'userid' => $user2->id));
2112  
2113          // Get conversations.
2114          $iconversation1id = \core_message\api::get_conversation_between_users([$user1->id, $user2->id]);
2115          $conversation1 = \core_message\api::get_conversation_by_area(
2116              $component,
2117              $itemtype,
2118              $group1a->id,
2119              $coursecontext1->id
2120          );
2121          $conversation2 = \core_message\api::get_conversation_by_area(
2122              $component,
2123              $itemtype,
2124              $group2a->id,
2125              $coursecontext2->id
2126          );
2127  
2128          // Make favourite some conversations.
2129          \core_message\api::set_favourite_conversation($iconversation1id, $user1->id);
2130          \core_message\api::set_favourite_conversation($conversation1->id, $user1->id);
2131          \core_message\api::set_favourite_conversation($conversation1->id, $user2->id);
2132  
2133          // Send some messages to the conversation.
2134          $gm1 = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 1.1', $now + 1);
2135          $gm2 = testhelper::send_fake_message_to_conversation($user1, $conversation1->id, 'Message 1.2', $now + 2);
2136          $gm3 = testhelper::send_fake_message_to_conversation($user2, $conversation1->id, 'Message 1.3', $now + 3);
2137          $gm4 = testhelper::send_fake_message_to_conversation($user1, $conversation2->id, 'Message 2.1', $now + 4);
2138          $gm5 = testhelper::send_fake_message_to_conversation($user2, $conversation2->id, 'Message 2.2', $now + 5);
2139  
2140          $dbgm3 = $DB->get_record('messages', ['id' => $gm3]);
2141  
2142          // Mark some conversations as muted by two users.
2143          \core_message\api::mute_conversation($user1->id, $iconversation1id);
2144          \core_message\api::mute_conversation($user1->id, $conversation1->id);
2145          \core_message\api::mute_conversation($user2->id, $conversation1->id);
2146  
2147          // Mark as read one of the conversation messages.
2148          \core_message\api::mark_message_as_read($user1->id, $dbgm3, $now + 5);
2149  
2150          // There should be 2 contacts.
2151          $this->assertEquals(2, $DB->count_records('message_contacts'));
2152  
2153          // There should be 2 contact requests.
2154          $this->assertEquals(2, $DB->count_records('message_contact_requests'));
2155  
2156          // There should be 2 blocked users.
2157          $this->assertEquals(2, $DB->count_records('message_users_blocked'));
2158  
2159          // There should be 8 messages.
2160          $this->assertEquals(8, $DB->count_records('messages'));
2161  
2162          // There should be 4 user actions - 3 for reading the message, 1 for deleting.
2163          $this->assertEquals(4, $DB->count_records('message_user_actions'));
2164  
2165          // There should be 3 muted conversations.
2166          $this->assertEquals(3, $DB->count_records('message_conversation_actions'));
2167  
2168          // There should be 4 conversations - 2 individual + 2 group + 5 self-conversations.
2169          $this->assertEquals(9, $DB->count_records('message_conversations'));
2170  
2171          // There should be 9 conversation members - (2 + 2) individual + (3 + 2) group + 5 self-conversations.
2172          $this->assertEquals(14, $DB->count_records('message_conversation_members'));
2173  
2174          // There should be 5 notifications (3 from create_notification and 2 from create_contact_request).
2175          $this->assertEquals(5, $DB->count_records('notifications'));
2176  
2177          // There should be 3 favourite conversations + 5 self-conversations.
2178          $this->assertEquals(8, $DB->count_records('favourite'));
2179  
2180          // Delete group conversations for all users in system context.
2181          provider::delete_conversations_for_all_users($systemcontext, $component, $itemtype);
2182  
2183          // No conversations should be removed, because they are in the course context.
2184          $this->assertEquals(2, $DB->count_records('message_contacts'));
2185          $this->assertEquals(2, $DB->count_records('message_contact_requests'));
2186          $this->assertEquals(2, $DB->count_records('message_users_blocked'));
2187          $this->assertEquals(8, $DB->count_records('messages'));
2188          $this->assertEquals(4, $DB->count_records('message_user_actions'));
2189          $this->assertEquals(3, $DB->count_records('message_conversation_actions'));
2190          $this->assertEquals(9, $DB->count_records('message_conversations'));
2191          $this->assertEquals(14, $DB->count_records('message_conversation_members'));
2192          $this->assertEquals(5, $DB->count_records('notifications'));
2193          $this->assertEquals(8, $DB->count_records('favourite'));
2194  
2195          // Delete individual conversations for all users in system context.
2196          provider::delete_conversations_for_all_users($systemcontext, '', '');
2197  
2198          // No conversations should be removed, because they've been moved to user context.
2199          $this->assertEquals(2, $DB->count_records('message_contacts'));
2200          $this->assertEquals(2, $DB->count_records('message_contact_requests'));
2201          $this->assertEquals(2, $DB->count_records('message_users_blocked'));
2202          $this->assertEquals(8, $DB->count_records('messages'));
2203          $this->assertEquals(4, $DB->count_records('message_user_actions'));
2204          $this->assertEquals(3, $DB->count_records('message_conversation_actions'));
2205          $this->assertEquals(9, $DB->count_records('message_conversations'));
2206          $this->assertEquals(14, $DB->count_records('message_conversation_members'));
2207          $this->assertEquals(5, $DB->count_records('notifications'));
2208          $this->assertEquals(8, $DB->count_records('favourite'));
2209      }
2210  
2211      /**
2212       * Test for provider::delete_conversations_for_all_users() in the user context.
2213       */
2214      public function test_delete_conversations_for_all_users_usercontext() {
2215          global $DB;
2216  
2217          $this->resetAfterTest();
2218          $this->setAdminUser();
2219          $now = time();
2220          $timeread = $now - DAYSECS;
2221          $component = 'core_group';
2222          $itemtype = 'groups';
2223  
2224          // Create users to test with.
2225          $user1 = $this->getDataGenerator()->create_user();
2226          $user2 = $this->getDataGenerator()->create_user();
2227          $user3 = $this->getDataGenerator()->create_user();
2228          $user4 = $this->getDataGenerator()->create_user();
2229          $user5 = $this->getDataGenerator()->create_user();
2230          $user1context = \context_user::instance($user1->id);
2231  
2232          // Create contacts.
2233          \core_message\api::add_contact($user1->id, $user2->id);
2234          \core_message\api::add_contact($user2->id, $user3->id);
2235  
2236          // Create contact requests.
2237          \core_message\api::create_contact_request($user1->id, $user3->id);
2238          \core_message\api::create_contact_request($user2->id, $user4->id);
2239  
2240          // Block a user.
2241          \core_message\api::block_user($user1->id, $user3->id);
2242          \core_message\api::block_user($user3->id, $user4->id);
2243  
2244          // Create individual messages.
2245          $im1 = $this->create_message($user1->id, $user2->id, $now + (9 * DAYSECS), true);
2246          $im2 = $this->create_message($user2->id, $user1->id, $now + (8 * DAYSECS), true);
2247          $im3 = $this->create_message($user2->id, $user3->id, $now + (7 * DAYSECS));
2248  
2249          // Create notifications.
2250          $n1 = $this->create_notification($user1->id, $user2->id, $now + (9 * DAYSECS), $timeread);
2251          $n2 = $this->create_notification($user2->id, $user1->id, $now + (8 * DAYSECS));
2252          $n3 = $this->create_notification($user2->id, $user3->id, $now + (7 * DAYSECS));
2253  
2254          // Delete one of the messages.
2255          \core_message\api::delete_message($user1->id, $im2);
2256  
2257          // Create course2.
2258          $course1 = $this->getDataGenerator()->create_course();
2259          $course2 = $this->getDataGenerator()->create_course();
2260          $coursecontext1 = \context_course::instance($course1->id);
2261          $coursecontext2 = \context_course::instance($course2->id);
2262  
2263          // Enrol users to courses.
2264          $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
2265          $this->getDataGenerator()->enrol_user($user2->id, $course1->id);
2266          $this->getDataGenerator()->enrol_user($user3->id, $course1->id);
2267          $this->getDataGenerator()->enrol_user($user1->id, $course2->id);
2268          $this->getDataGenerator()->enrol_user($user2->id, $course2->id);
2269  
2270          // Create course groups with group messaging enabled.
2271          $group1a = $this->getDataGenerator()->create_group(array('courseid' => $course1->id, 'enablemessaging' => 1));
2272          $group2a = $this->getDataGenerator()->create_group(array('courseid' => $course2->id, 'enablemessaging' => 1));
2273