MDL-52347 behat: fix random failures on fast computer
[moodle.git] / message / tests / messagelib_test.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Test api's in message lib.
19  *
20  * @package core_message
21  * @category test
22  * @copyright 2014 Rajesh Taneja <rajesh@moodle.com>
23  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 global $CFG;
29 require_once($CFG->dirroot . '/message/lib.php');
31 /**
32  * Test api's in message lib.
33  *
34  * @package core_message
35  * @category test
36  * @copyright 2014 Rajesh Taneja <rajesh@moodle.com>
37  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
38  */
39 class core_message_messagelib_testcase extends advanced_testcase {
41     /** @var phpunit_message_sink keep track of messages. */
42     protected $messagesink = null;
44     /**
45      * Test set up.
46      *
47      * This is executed before running any test in this file.
48      */
49     public function setUp() {
50         $this->preventResetByRollback(); // Messaging is not compatible with transactions.
51         $this->messagesink = $this->redirectMessages();
52         $this->resetAfterTest();
53     }
55     /**
56      * Send a fake message.
57      *
58      * {@link message_send()} does not support transaction, this function will simulate a message
59      * sent from a user to another. We should stop using it once {@link message_send()} will support
60      * transactions. This is not clean at all, this is just used to add rows to the table.
61      *
62      * @param stdClass $userfrom user object of the one sending the message.
63      * @param stdClass $userto user object of the one receiving the message.
64      * @param string $message message to send.
65      * @return int the id of the message
66      */
67     protected function send_fake_message($userfrom, $userto, $message = 'Hello world!') {
68         global $DB;
70         $record = new stdClass();
71         $record->useridfrom = $userfrom->id;
72         $record->useridto = $userto->id;
73         $record->subject = 'No subject';
74         $record->fullmessage = $message;
75         $record->smallmessage = $message;
76         $record->timecreated = time();
78         return $DB->insert_record('message', $record);
79     }
81     /**
82      * Test message_get_blocked_users.
83      */
84     public function test_message_get_blocked_users() {
85         // Set this user as the admin.
86         $this->setAdminUser();
88         // Create a user to add to the admin's contact list.
89         $user1 = $this->getDataGenerator()->create_user();
90         $user2 = $this->getDataGenerator()->create_user();
92         // Add users to the admin's contact list.
93         message_add_contact($user1->id);
94         message_add_contact($user2->id, 1);
96         $this->assertCount(1, message_get_blocked_users());
98         // Block other user.
99         message_block_contact($user1->id);
100         $this->assertCount(2, message_get_blocked_users());
102         // Test deleting users.
103         delete_user($user1);
104         $this->assertCount(1, message_get_blocked_users());
105     }
107     /**
108      * Test message_get_contacts.
109      */
110     public function test_message_get_contacts() {
111         global $USER, $CFG;
113         // Set this user as the admin.
114         $this->setAdminUser();
116         $noreplyuser = core_user::get_noreply_user();
117         $supportuser = core_user::get_support_user();
119         // Create a user to add to the admin's contact list.
120         $user1 = $this->getDataGenerator()->create_user();
121         $user2 = $this->getDataGenerator()->create_user();
122         $user3 = $this->getDataGenerator()->create_user(); // Stranger.
124         // Add users to the admin's contact list.
125         message_add_contact($user1->id);
126         message_add_contact($user2->id);
128         // Send some messages.
129         $this->send_fake_message($user1, $USER);
130         $this->send_fake_message($user2, $USER);
131         $this->send_fake_message($user3, $USER);
133         list($onlinecontacts, $offlinecontacts, $strangers) = message_get_contacts();
134         $this->assertCount(0, $onlinecontacts);
135         $this->assertCount(2, $offlinecontacts);
136         $this->assertCount(1, $strangers);
138         // Send message from noreply and support users.
139         $this->send_fake_message($noreplyuser, $USER);
140         $this->send_fake_message($supportuser, $USER);
141         list($onlinecontacts, $offlinecontacts, $strangers) = message_get_contacts();
142         $this->assertCount(0, $onlinecontacts);
143         $this->assertCount(2, $offlinecontacts);
144         $this->assertCount(3, $strangers);
146         // Block 1 user.
147         message_block_contact($user2->id);
148         list($onlinecontacts, $offlinecontacts, $strangers) = message_get_contacts();
149         $this->assertCount(0, $onlinecontacts);
150         $this->assertCount(1, $offlinecontacts);
151         $this->assertCount(3, $strangers);
153         // Noreply user being valid user.
154         core_user::reset_internal_users();
155         $CFG->noreplyuserid = $user3->id;
156         $noreplyuser = core_user::get_noreply_user();
157         list($onlinecontacts, $offlinecontacts, $strangers) = message_get_contacts();
158         $this->assertCount(0, $onlinecontacts);
159         $this->assertCount(1, $offlinecontacts);
160         $this->assertCount(2, $strangers);
162         // Test deleting users.
163         delete_user($user1);
164         delete_user($user3);
166         list($onlinecontacts, $offlinecontacts, $strangers) = message_get_contacts();
167         $this->assertCount(0, $onlinecontacts);
168         $this->assertCount(0, $offlinecontacts);
169         $this->assertCount(1, $strangers);
170     }
172     /**
173      * Test message_count_messages.
174      */
175     public function test_message_count_messages() {
176         global $DB;
178         // Create users to send and receive message.
179         $userfrom = $this->getDataGenerator()->create_user();
180         $userto = $this->getDataGenerator()->create_user();
182         message_post_message($userfrom, $userto, 'Message 1', FORMAT_PLAIN);
183         message_post_message($userfrom, $userto, 'Message 2', FORMAT_PLAIN);
184         message_post_message($userto, $userfrom, 'Message 3', FORMAT_PLAIN);
186         // Return 0 when no message.
187         $messages = array();
188         $this->assertEquals(0, message_count_messages($messages, 'Test', 'Test'));
190         // Check number of messages from userfrom and userto.
191         $messages = $this->messagesink->get_messages();
192         $this->assertEquals(2, message_count_messages($messages, 'useridfrom', $userfrom->id));
193         $this->assertEquals(1, message_count_messages($messages, 'useridfrom', $userto->id));
194     }
196     /**
197      * Test message_count_unread_messages.
198      */
199     public function test_message_count_unread_messages() {
200         // Create users to send and receive message.
201         $userfrom1 = $this->getDataGenerator()->create_user();
202         $userfrom2 = $this->getDataGenerator()->create_user();
203         $userto = $this->getDataGenerator()->create_user();
205         $this->assertEquals(0, message_count_unread_messages($userto));
207         // Send fake messages.
208         $this->send_fake_message($userfrom1, $userto);
209         $this->send_fake_message($userfrom2, $userto);
211         $this->assertEquals(2, message_count_unread_messages($userto));
212         $this->assertEquals(1, message_count_unread_messages($userto, $userfrom1));
213     }
215     /**
216      * Test message_count_blocked_users.
217      *
218      */
219     public function test_message_count_blocked_users() {
220         // Set this user as the admin.
221         $this->setAdminUser();
223         // Create users to add to the admin's contact list.
224         $user1 = $this->getDataGenerator()->create_user();
225         $user2 = $this->getDataGenerator()->create_user();
227         $this->assertEquals(0, message_count_blocked_users());
229         // Add 1 blocked and 1 normal contact to admin's contact list.
230         message_add_contact($user1->id);
231         message_add_contact($user2->id, 1);
233         $this->assertEquals(0, message_count_blocked_users($user2));
234         $this->assertEquals(1, message_count_blocked_users());
235     }
237     /**
238      * Test message_add_contact.
239      */
240     public function test_message_add_contact() {
241         // Set this user as the admin.
242         $this->setAdminUser();
244         // Create a user to add to the admin's contact list.
245         $user1 = $this->getDataGenerator()->create_user();
246         $user2 = $this->getDataGenerator()->create_user();
247         $user3 = $this->getDataGenerator()->create_user();
249         message_add_contact($user1->id);
250         message_add_contact($user2->id, 0);
251         // Add duplicate contact and make sure only 1 record exists.
252         message_add_contact($user2->id, 1);
254         $this->assertNotEmpty(message_get_contact($user1->id));
255         $this->assertNotEmpty(message_get_contact($user2->id));
256         $this->assertEquals(false, message_get_contact($user3->id));
257         $this->assertEquals(1, message_count_blocked_users());
258     }
260     /**
261      * Test message_remove_contact.
262      */
263     public function test_message_remove_contact() {
264         // Set this user as the admin.
265         $this->setAdminUser();
267         // Create a user to add to the admin's contact list.
268         $user = $this->getDataGenerator()->create_user();
270         // Add the user to the admin's contact list.
271         message_add_contact($user->id);
272         $this->assertNotEmpty(message_get_contact($user->id));
274         // Remove user from admin's contact list.
275         message_remove_contact($user->id);
276         $this->assertEquals(false, message_get_contact($user->id));
277     }
279     /**
280      * Test message_block_contact.
281      */
282     public function test_message_block_contact() {
283         // Set this user as the admin.
284         $this->setAdminUser();
286         // Create a user to add to the admin's contact list.
287         $user1 = $this->getDataGenerator()->create_user();
288         $user2 = $this->getDataGenerator()->create_user();
290         // Add users to the admin's contact list.
291         message_add_contact($user1->id);
292         message_add_contact($user2->id);
294         $this->assertEquals(0, message_count_blocked_users());
296         // Block 1 user.
297         message_block_contact($user2->id);
298         $this->assertEquals(1, message_count_blocked_users());
300     }
302     /**
303      * Test message_unblock_contact.
304      */
305     public function test_message_unblock_contact() {
306         // Set this user as the admin.
307         $this->setAdminUser();
309         // Create a user to add to the admin's contact list.
310         $user1 = $this->getDataGenerator()->create_user();
311         $user2 = $this->getDataGenerator()->create_user();
313         // Add users to the admin's contact list.
314         message_add_contact($user1->id);
315         message_add_contact($user2->id, 1); // Add blocked contact.
317         $this->assertEquals(1, message_count_blocked_users());
319         // Unblock user.
320         message_unblock_contact($user2->id);
321         $this->assertEquals(0, message_count_blocked_users());
322     }
324     /**
325      * Test message_search_users.
326      */
327     public function test_message_search_users() {
328         // Set this user as the admin.
329         $this->setAdminUser();
331         // Create a user to add to the admin's contact list.
332         $user1 = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'user1'));
333         $user2 = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'user2'));
335         // Add users to the admin's contact list.
336         message_add_contact($user1->id);
337         message_add_contact($user2->id); // Add blocked contact.
339         $this->assertCount(1, message_search_users(0, 'Test1'));
340         $this->assertCount(2, message_search_users(0, 'Test'));
341         $this->assertCount(1, message_search_users(0, 'user1'));
342         $this->assertCount(2, message_search_users(0, 'user'));
343     }
345     /**
346      * Test message_search.
347      */
348     public function test_message_search() {
349         global $USER;
351         // Set this user as the admin.
352         $this->setAdminUser();
354         // Create a user to add to the admin's contact list.
355         $user1 = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'user1'));
356         $user2 = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'user2'));
358         // Send few messages, real (read).
359         message_post_message($user1, $USER, 'Message 1', FORMAT_PLAIN);
360         message_post_message($USER, $user1, 'Message 2', FORMAT_PLAIN);
361         message_post_message($USER, $user2, 'Message 3', FORMAT_PLAIN);
363         $this->assertCount(2, message_search(array('Message'), true, false));
364         $this->assertCount(3, message_search(array('Message'), true, true));
366         // Send fake message (not-read).
367         $this->send_fake_message($USER, $user1, 'Message 4');
368         $this->send_fake_message($user1, $USER, 'Message 5');
369         $this->assertCount(3, message_search(array('Message'), true, false));
370         $this->assertCount(5, message_search(array('Message'), true, true));
372         // If courseid given then should be 0.
373         $this->assertEquals(false, message_search(array('Message'), true, true, ''));
374         $this->assertEquals(false, message_search(array('Message'), true, true, 2));
375         $this->assertCount(5, message_search(array('Message'), true, true, SITEID));
376     }
378     /**
379      * The data provider for message_get_recent_conversations.
380      *
381      * This provides sets of data to for testing.
382      * @return array
383      */
384     public function message_get_recent_conversations_provider() {
385         return array(
386             array(
387                 // Test that conversations with multiple contacts is correctly ordered.
388                 'users' => array(
389                     'user1',
390                     'user2',
391                     'user3',
392                 ),
393                 'messages' => array(
394                     array(
395                         'from'          => 'user1',
396                         'to'            => 'user2',
397                         'state'         => 'unread',
398                         'subject'       => 'S1',
399                     ),
400                     array(
401                         'from'          => 'user2',
402                         'to'            => 'user1',
403                         'state'         => 'unread',
404                         'subject'       => 'S2',
405                     ),
406                     array(
407                         'from'          => 'user1',
408                         'to'            => 'user2',
409                         'state'         => 'unread',
410                         'timecreated'   => 0,
411                         'subject'       => 'S3',
412                     ),
413                     array(
414                         'from'          => 'user1',
415                         'to'            => 'user3',
416                         'state'         => 'read',
417                         'timemodifier'  => 1,
418                         'subject'       => 'S4',
419                     ),
420                     array(
421                         'from'          => 'user3',
422                         'to'            => 'user1',
423                         'state'         => 'read',
424                         'timemodifier'  => 1,
425                         'subject'       => 'S5',
426                     ),
427                     array(
428                         'from'          => 'user1',
429                         'to'            => 'user3',
430                         'state'         => 'read',
431                         'timecreated'   => 0,
432                         'subject'       => 'S6',
433                     ),
434                 ),
435                 'expectations' => array(
436                     'user1' => array(
437                         // User1 has conversed most recently with user3. The most recent message is M5.
438                         array(
439                             'messageposition'   => 0,
440                             'with'              => 'user3',
441                             'subject'           => 'S5',
442                         ),
443                         // User1 has also conversed with user2. The most recent message is S2.
444                         array(
445                             'messageposition'   => 1,
446                             'with'              => 'user2',
447                             'subject'           => 'S2',
448                         ),
449                     ),
450                     'user2' => array(
451                         // User2 has only conversed with user1. Their most recent shared message was S2.
452                         array(
453                             'messageposition'   => 0,
454                             'with'              => 'user1',
455                             'subject'           => 'S2',
456                         ),
457                     ),
458                     'user3' => array(
459                         // User3 has only conversed with user1. Their most recent shared message was S5.
460                         array(
461                             'messageposition'   => 0,
462                             'with'              => 'user1',
463                             'subject'           => 'S5',
464                         ),
465                     ),
466                 ),
467             ),
468             array(
469                 // Test conversations with a single user, where some messages are read and some are not.
470                 'users' => array(
471                     'user1',
472                     'user2',
473                 ),
474                 'messages' => array(
475                     array(
476                         'from'          => 'user1',
477                         'to'            => 'user2',
478                         'state'         => 'read',
479                         'subject'       => 'S1',
480                     ),
481                     array(
482                         'from'          => 'user2',
483                         'to'            => 'user1',
484                         'state'         => 'read',
485                         'subject'       => 'S2',
486                     ),
487                     array(
488                         'from'          => 'user1',
489                         'to'            => 'user2',
490                         'state'         => 'unread',
491                         'timemodifier'  => 1,
492                         'subject'       => 'S3',
493                     ),
494                     array(
495                         'from'          => 'user1',
496                         'to'            => 'user2',
497                         'state'         => 'unread',
498                         'timemodifier'  => 1,
499                         'subject'       => 'S4',
500                     ),
501                 ),
502                 'expectations' => array(
503                     // The most recent message between user1 and user2 was S4.
504                     'user1' => array(
505                         array(
506                             'messageposition'   => 0,
507                             'with'              => 'user2',
508                             'subject'           => 'S4',
509                         ),
510                     ),
511                     'user2' => array(
512                         // The most recent message between user1 and user2 was S4.
513                         array(
514                             'messageposition'   => 0,
515                             'with'              => 'user1',
516                             'subject'           => 'S4',
517                         ),
518                     ),
519                 ),
520             ),
521             array(
522                 // Test conversations with a single user, where some messages are read and some are not, and messages
523                 // are out of order.
524                 // This can happen through a combination of factors including multi-master DB replication with messages
525                 // read somehow (e.g. API).
526                 'users' => array(
527                     'user1',
528                     'user2',
529                 ),
530                 'messages' => array(
531                     array(
532                         'from'          => 'user1',
533                         'to'            => 'user2',
534                         'state'         => 'read',
535                         'subject'       => 'S1',
536                         'timemodifier'  => 1,
537                     ),
538                     array(
539                         'from'          => 'user2',
540                         'to'            => 'user1',
541                         'state'         => 'read',
542                         'subject'       => 'S2',
543                         'timemodifier'  => 2,
544                     ),
545                     array(
546                         'from'          => 'user1',
547                         'to'            => 'user2',
548                         'state'         => 'unread',
549                         'subject'       => 'S3',
550                     ),
551                     array(
552                         'from'          => 'user1',
553                         'to'            => 'user2',
554                         'state'         => 'unread',
555                         'subject'       => 'S4',
556                     ),
557                 ),
558                 'expectations' => array(
559                     // The most recent message between user1 and user2 was S2, even though later IDs have not been read.
560                     'user1' => array(
561                         array(
562                             'messageposition'   => 0,
563                             'with'              => 'user2',
564                             'subject'           => 'S2',
565                         ),
566                     ),
567                     'user2' => array(
568                         array(
569                             'messageposition'   => 0,
570                             'with'              => 'user1',
571                             'subject'           => 'S2',
572                         ),
573                     ),
574                 ),
575             ),
576         );
577     }
579     /**
580      * Test message_get_recent_conversations with a mixture of messages.
581      *
582      * @dataProvider message_get_recent_conversations_provider
583      * @param array $usersdata The list of users to create for this test.
584      * @param array $messagesdata The list of messages to create.
585      * @param array $expectations The list of expected outcomes.
586      */
587     public function test_message_get_recent_conversations($usersdata, $messagesdata, $expectations) {
588         global $DB;
590         // Create all of the users.
591         $users = array();
592         foreach ($usersdata as $username) {
593             $users[$username] = $this->getDataGenerator()->create_user(array('username' => $username));
594         }
596         $defaulttimecreated = time();
597         foreach ($messagesdata as $messagedata) {
598             $from       = $users[$messagedata['from']];
599             $to         = $users[$messagedata['to']];
600             $subject    = $messagedata['subject'];
602             if (isset($messagedata['state']) && $messagedata['state'] == 'unread') {
603                 $table = 'message';
604                 $messageid = $this->send_fake_message($from, $to, $subject, FORMAT_PLAIN);
605             } else {
606                 // If there is no state, or the state is not 'unread', assume the message is read.
607                 $table = 'message_read';
608                 $messageid = message_post_message($from, $to, $subject, FORMAT_PLAIN);
609             }
611             $updatemessage = new stdClass();
612             $updatemessage->id = $messageid;
613             if (isset($messagedata['timecreated'])) {
614                 $updatemessage->timecreated = $messagedata['timecreated'];
615             } else if (isset($messagedata['timemodifier'])) {
616                 $updatemessage->timecreated = $defaulttimecreated + $messagedata['timemodifier'];
617             } else {
618                 $updatemessage->timecreated = $defaulttimecreated;
619             }
620             $DB->update_record($table, $updatemessage);
621         }
623         foreach ($expectations as $username => $data) {
624             // Get the recent conversations for the specified user.
625             $user = $users[$username];
626             $conversations = message_get_recent_conversations($user);
627             foreach ($data as $expectation) {
628                 $otheruser = $users[$expectation['with']];
629                 $conversation = $conversations[$expectation['messageposition']];
630                 $this->assertEquals($otheruser->id, $conversation->id);
631                 $this->assertEquals($expectation['subject'], $conversation->smallmessage);
632             }
633         }
634     }
636     /**
637      * Test message_get_recent_notifications.
638      */
639     public function test_message_get_recent_notifications() {
640         global $DB, $USER;
642         // Set this user as the admin.
643         $this->setAdminUser();
645         // Create a user to send messages from.
646         $user1 = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'user1'));
648         // Add two messages - will mark them as notifications later.
649         $m1 = message_post_message($user1, $USER, 'Message 1', FORMAT_PLAIN);
650         $m2 = message_post_message($user1, $USER, 'Message 2', FORMAT_PLAIN);
652         // Mark the second message as a notification.
653         $updatemessage = new stdClass();
654         $updatemessage->id = $m2;
655         $updatemessage->notification = 1;
656         $DB->update_record('message_read', $updatemessage);
658         // Mark the first message as a notification and change the timecreated to 0.
659         $updatemessage->id = $m1;
660         $updatemessage->notification = 1;
661         $updatemessage->timecreated = 0;
662         $DB->update_record('message_read', $updatemessage);
664         $notifications = message_get_recent_notifications($USER);
666         // Get the messages.
667         $firstmessage = array_shift($notifications);
668         $secondmessage = array_shift($notifications);
670         // Confirm that we have received the notifications with the maximum timecreated, rather than the max id.
671         $this->assertEquals('Message 2', $firstmessage->smallmessage);
672         $this->assertEquals('Message 1', $secondmessage->smallmessage);
673     }
675     /**
676      * Test that message_can_post_message returns false if the sender does not have the
677      * moode/site:sendmessage capability.
678      */
679     public function test_message_can_post_message_returns_false_without_capability() {
680         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
681         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
682         $context = context_system::instance();
683         $roleid = $this->getDataGenerator()->create_role();
684         $this->getDataGenerator()->role_assign($roleid, $sender->id, $context->id);
686         assign_capability('moodle/site:sendmessage', CAP_PROHIBIT, $roleid, $context);
688         $this->assertFalse(message_can_post_message($recipient, $sender));
689     }
691     /**
692      * Test that message_can_post_message returns false if the receiver only accepts
693      * messages from contacts and the sender isn't a contact.
694      */
695     public function test_message_can_post_message_returns_false_non_contact_blocked() {
696         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
697         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
699         set_user_preference('message_blocknoncontacts', true, $recipient);
701         $this->assertFalse(message_can_post_message($recipient, $sender));
702     }
704     /**
705      * Test that message_can_post_message returns false if the receiver has blocked the
706      * sender from messaging them.
707      */
708     public function test_message_can_post_message_returns_false_if_blocked() {
709         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
710         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
712         $this->setUser($recipient);
713         message_block_contact($sender->id);
715         $this->assertFalse(message_can_post_message($recipient, $sender));
716     }
718     /**
719      * Test that message_can_post_message returns false if the receiver has blocked the
720      * sender from messaging them.
721      */
722     public function test_message_can_post_message_returns_true() {
723         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
724         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
726         $this->assertTrue(message_can_post_message($recipient, $sender));
727     }
729     /**
730      * Test that message_is_user_non_contact_blocked returns false if the recipient allows
731      * messages from non-contacts.
732      */
733     public function test_message_is_user_non_contact_blocked_false_without_preference() {
734         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
735         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
737         set_user_preference('message_blocknoncontacts', false, $recipient);
739         $this->assertFalse(message_is_user_non_contact_blocked($recipient, $sender));
740     }
742     /**
743      * Test that message_is_user_non_contact_blocked returns true if the recipient doesn't
744      * allow messages from non-contacts and the sender isn't a contact.
745      */
746     public function test_message_is_user_non_contact_blocked_true_with_preference() {
747         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
748         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
750         set_user_preference('message_blocknoncontacts', true, $recipient);
752         $this->assertTrue(message_is_user_non_contact_blocked($recipient, $sender));
753     }
755     /**
756      * Test that message_is_user_non_contact_blocked returns false if the recipient doesn't
757      * allow messages from non-contacts but the sender is a contact.
758      */
759     public function test_message_is_user_non_contact_blocked_false_with_if_contact() {
760         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
761         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
763         $this->setUser($recipient);
764         set_user_preference('message_blocknoncontacts', true, $recipient);
765         message_add_contact($sender->id);
767         $this->assertFalse(message_is_user_non_contact_blocked($recipient, $sender));
768     }
770     /**
771      * Test that message_is_user_blocked returns false if the sender is not a contact of
772      * the recipient.
773      */
774     public function test_message_is_user_blocked_false_no_contact() {
775         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
776         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
778         $this->assertFalse(message_is_user_blocked($recipient, $sender));
779     }
781     /**
782      * Test that message_is_user_blocked returns false if the sender is a contact that is
783      * blocked by the recipient but has the moodle/site:readallmessages capability.
784      */
785     public function test_message_is_user_blocked_false_if_readallmessages() {
786         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
787         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
789         $this->setUser($recipient);
790         message_block_contact($sender->id);
792         $context = context_system::instance();
793         $roleid = $this->getDataGenerator()->create_role();
794         $this->getDataGenerator()->role_assign($roleid, $sender->id, $context->id);
796         assign_capability('moodle/site:readallmessages', CAP_ALLOW, $roleid, $context);
798         $this->assertFalse(message_is_user_blocked($recipient, $sender));
799     }
801     /**
802      * Test that message_is_user_blocked returns true if the sender is a contact that is
803      * blocked by the recipient and does not have the moodle/site:readallmessages capability.
804      */
805     public function test_message_is_user_blocked_true_if_blocked() {
806         $sender = $this->getDataGenerator()->create_user(array('firstname' => 'Test1', 'lastname' => 'User1'));
807         $recipient = $this->getDataGenerator()->create_user(array('firstname' => 'Test2', 'lastname' => 'User2'));
809         $this->setUser($recipient);
810         message_block_contact($sender->id);
812         $context = context_system::instance();
813         $roleid = $this->getDataGenerator()->create_role();
814         $this->getDataGenerator()->role_assign($roleid, $sender->id, $context->id);
816         assign_capability('moodle/site:readallmessages', CAP_PROHIBIT, $roleid, $context);
818         $this->assertTrue(message_is_user_blocked($recipient, $sender));
819     }