lib/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/>.
  16
  17 /**
  18  * Tests for messagelib.php.
  19  *
  20  * @package    core_message
  21  * @category   phpunit
  22  * @copyright  2012 The Open Universtiy
  23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24  */
  25
  26 defined('MOODLE_INTERNAL') || die();
  27
  28 class core_messagelib_testcase extends advanced_testcase {
  29
  30     public function test_message_provider_disabled() {
  31         $this->resetAfterTest();
  32         $this->preventResetByRollback();
  33
  34         // Disable instantmessage provider.
  35         $disableprovidersetting = 'moodle_instantmessage_disable';
  36         set_config($disableprovidersetting, 1, 'message');
  37         $preferences = get_message_output_default_preferences();
  38         $this->assertTrue($preferences->$disableprovidersetting == 1);
  39
  40         $message = new stdClass();
  41         $message->component         = 'moodle';
  42         $message->name              = 'instantmessage';
  43         $message->userfrom          = get_admin();
  44         $message->userto            = $this->getDataGenerator()->create_user();;
  45         $message->subject           = 'message subject 1';
  46         $message->fullmessage       = 'message body';
  47         $message->fullmessageformat = FORMAT_MARKDOWN;
  48         $message->fullmessagehtml   = '<p>message body</p>';
  49         $message->smallmessage      = 'small message';
  50         $message->notification      = 0;
  51
  52         // Check message is not sent.
  53         $sink = $this->redirectEmails();
  54         message_send($message);
  55         $emails = $sink->get_messages();
  56         $this->assertEmpty($emails);
  57
  58         // Check message is sent.
  59         set_config($disableprovidersetting, 0, 'message');
  60         $preferences = get_message_output_default_preferences();
  61         $this->assertTrue($preferences->$disableprovidersetting == 0);
  62
  63         $sink = $this->redirectEmails();
  64         message_send($message);
  65         $emails = $sink->get_messages();
  66         $email = reset($emails);
  67         $this->assertEquals($email->subject, 'message subject 1');
  68     }
  69     public function test_message_get_providers_for_user() {
  70         global $CFG, $DB;
  71
  72         $this->resetAfterTest();
  73
  74         $generator = $this->getDataGenerator();
  75
  76         // Create a course category and course.
  77         $cat = $generator->create_category(array('parent' => 0));
  78         $course = $generator->create_course(array('category' => $cat->id));
  79         $quiz = $generator->create_module('quiz', array('course' => $course->id));
  80         $user = $generator->create_user();
  81
  82         $coursecontext = context_course::instance($course->id);
  83         $quizcontext = context_module::instance($quiz->cmid);
  84         $frontpagecontext = context_course::instance(SITEID);
  85
  86         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
  87
  88         // The user is a student in a course, and has the capability for quiz
  89         // confirmation emails in one quiz in that course.
  90         role_assign($studentrole->id, $user->id, $coursecontext->id);
  91         assign_capability('mod/quiz:emailconfirmsubmission', CAP_ALLOW, $studentrole->id, $quizcontext->id);
  92
  93         // Give this message type to the front page role.
  94         assign_capability('mod/quiz:emailwarnoverdue', CAP_ALLOW, $CFG->defaultfrontpageroleid, $frontpagecontext->id);
  95
  96         $providers = message_get_providers_for_user($user->id);
  97         $this->assertTrue($this->message_type_present('mod_forum', 'posts', $providers));
  98         $this->assertTrue($this->message_type_present('mod_quiz', 'confirmation', $providers));
  99         $this->assertTrue($this->message_type_present('mod_quiz', 'attempt_overdue', $providers));
 100         $this->assertFalse($this->message_type_present('mod_quiz', 'submission', $providers));
 101
 102         // A user is a student in a different course, they should not get confirmation.
 103         $course2 = $generator->create_course(array('category' => $cat->id));
 104         $user2 = $generator->create_user();
 105         $coursecontext2 = context_course::instance($course2->id);
 106         role_assign($studentrole->id, $user2->id, $coursecontext2->id);
 107         accesslib_clear_all_caches_for_unit_testing();
 108         $providers = message_get_providers_for_user($user2->id);
 109         $this->assertTrue($this->message_type_present('mod_forum', 'posts', $providers));
 110         $this->assertFalse($this->message_type_present('mod_quiz', 'confirmation', $providers));
 111
 112         // Now remove the frontpage role id, and attempt_overdue message should go away.
 113         unset_config('defaultfrontpageroleid');
 114         accesslib_clear_all_caches_for_unit_testing();
 115
 116         $providers = message_get_providers_for_user($user->id);
 117         $this->assertTrue($this->message_type_present('mod_quiz', 'confirmation', $providers));
 118         $this->assertFalse($this->message_type_present('mod_quiz', 'attempt_overdue', $providers));
 119         $this->assertFalse($this->message_type_present('mod_quiz', 'submission', $providers));
 120     }
 121
 122     public function test_message_get_providers_for_user_more() {
 123         global $DB;
 124
 125         $this->resetAfterTest();
 126
 127         // Create a course.
 128         $course = $this->getDataGenerator()->create_course();
 129         $coursecontext = context_course::instance($course->id);
 130
 131         // It would probably be better to use a quiz instance as it has capability controlled messages
 132         // however mod_quiz doesn't have a data generator.
 133         // Instead we're going to use backup notifications and give and take away the capability at various levels.
 134         $assign = $this->getDataGenerator()->create_module('assign', array('course'=>$course->id));
 135         $modulecontext = context_module::instance($assign->cmid);
 136
 137         // Create and enrol a teacher.
 138         $teacherrole = $DB->get_record('role', array('shortname'=>'editingteacher'), '*', MUST_EXIST);
 139         $teacher = $this->getDataGenerator()->create_user();
 140         role_assign($teacherrole->id, $teacher->id, $coursecontext);
 141         $enrolplugin = enrol_get_plugin('manual');
 142         $enrolplugin->add_instance($course);
 143         $enrolinstances = enrol_get_instances($course->id, false);
 144         foreach ($enrolinstances as $enrolinstance) {
 145             if ($enrolinstance->enrol === 'manual') {
 146                 break;
 147             }
 148         }
 149         $enrolplugin->enrol_user($enrolinstance, $teacher->id);
 150
 151         // Make the teacher the current user.
 152         $this->setUser($teacher);
 153
 154         // Teacher shouldn't have the required capability so they shouldn't be able to see the backup message.
 155         $this->assertFalse(has_capability('moodle/site:config', $modulecontext));
 156         $providers = message_get_providers_for_user($teacher->id);
 157         $this->assertFalse($this->message_type_present('moodle', 'backup', $providers));
 158
 159         // Give the user the required capability in an activity module.
 160         // They should now be able to see the backup message.
 161         assign_capability('moodle/site:config', CAP_ALLOW, $teacherrole->id, $modulecontext->id, true);
 162         accesslib_clear_all_caches_for_unit_testing();
 163         $modulecontext = context_module::instance($assign->cmid);
 164         $this->assertTrue(has_capability('moodle/site:config', $modulecontext));
 165
 166         $providers = message_get_providers_for_user($teacher->id);
 167         $this->assertTrue($this->message_type_present('moodle', 'backup', $providers));
 168
 169         // Prohibit the capability for the user at the course level.
 170         // This overrules the CAP_ALLOW at the module level.
 171         // They should not be able to see the backup message.
 172         assign_capability('moodle/site:config', CAP_PROHIBIT, $teacherrole->id, $coursecontext->id, true);
 173         accesslib_clear_all_caches_for_unit_testing();
 174         $modulecontext = context_module::instance($assign->cmid);
 175         $this->assertFalse(has_capability('moodle/site:config', $modulecontext));
 176
 177         $providers = message_get_providers_for_user($teacher->id);
 178         // Actually, handling PROHIBITs would be too expensive. We do not
 179         // care if users with PROHIBITs see a few more preferences than they should.
 180         // $this->assertFalse($this->message_type_present('moodle', 'backup', $providers));
 181     }
 182
 183     public function test_send_message_redirection() {
 184         global $DB;
 185
 186         $this->resetAfterTest();
 187
 188         $user1 = $this->getDataGenerator()->create_user();
 189         $user2 = $this->getDataGenerator()->create_user();
 190
 191         // Test basic message redirection.
 192         $message = new stdClass();
 193         $message->component = 'moodle';
 194         $message->name = 'instantmessage';
 195         $message->userfrom = $user1;
 196         $message->userto = $user2;
 197         $message->subject = 'message subject 1';
 198         $message->fullmessage = 'message body';
 199         $message->fullmessageformat = FORMAT_MARKDOWN;
 200         $message->fullmessagehtml = '<p>message body</p>';
 201         $message->smallmessage = 'small message';
 202         $message->notification = '0';
 203
 204         $sink = $this->redirectMessages();
 205         $this->setCurrentTimeStart();
 206         $messageid = message_send($message);
 207         $savedmessages = $sink->get_messages();
 208         $this->assertCount(1, $savedmessages);
 209         $savedmessage = reset($savedmessages);
 210         $this->assertEquals($messageid, $savedmessage->id);
 211         $this->assertEquals($user1->id, $savedmessage->useridfrom);
 212         $this->assertEquals($user2->id, $savedmessage->useridto);
 213         $this->assertEquals($message->fullmessage, $savedmessage->fullmessage);
 214         $this->assertEquals($message->fullmessageformat, $savedmessage->fullmessageformat);
 215         $this->assertEquals($message->fullmessagehtml, $savedmessage->fullmessagehtml);
 216         $this->assertEquals($message->smallmessage, $savedmessage->smallmessage);
 217         $this->assertEquals($message->smallmessage, $savedmessage->smallmessage);
 218         $this->assertEquals($message->notification, $savedmessage->notification);
 219         $this->assertNull($savedmessage->contexturl);
 220         $this->assertNull($savedmessage->contexturlname);
 221         $this->assertTimeCurrent($savedmessage->timecreated);
 222         $record = $DB->get_record('message_read', array('id' => $savedmessage->id), '*', MUST_EXIST);
 223         $this->assertEquals($record, $savedmessage);
 224         $sink->clear();
 225         $this->assertFalse($DB->record_exists('message', array()));
 226         $DB->delete_records('message_read', array());
 227
 228         $message = new stdClass();
 229         $message->component = 'moodle';
 230         $message->name = 'instantmessage';
 231         $message->userfrom = $user1->id;
 232         $message->userto = $user2->id;
 233         $message->subject = 'message subject 1';
 234         $message->fullmessage = 'message body';
 235         $message->fullmessageformat = FORMAT_MARKDOWN;
 236         $message->fullmessagehtml = '<p>message body</p>';
 237         $message->smallmessage = 'small message';
 238         $message->notification = '0';
 239         $message->contexturl = new moodle_url('/');
 240         $message->contexturlname = 'front';
 241         $sink = $this->redirectMessages();
 242         $messageid = message_send($message);
 243         $savedmessages = $sink->get_messages();
 244         $this->assertCount(1, $savedmessages);
 245         $savedmessage = reset($savedmessages);
 246         $this->assertEquals($messageid, $savedmessage->id);
 247         $this->assertEquals($user1->id, $savedmessage->useridfrom);
 248         $this->assertEquals($user2->id, $savedmessage->useridto);
 249         $this->assertEquals($message->fullmessage, $savedmessage->fullmessage);
 250         $this->assertEquals($message->fullmessageformat, $savedmessage->fullmessageformat);
 251         $this->assertEquals($message->fullmessagehtml, $savedmessage->fullmessagehtml);
 252         $this->assertEquals($message->smallmessage, $savedmessage->smallmessage);
 253         $this->assertEquals($message->smallmessage, $savedmessage->smallmessage);
 254         $this->assertEquals($message->notification, $savedmessage->notification);
 255         $this->assertEquals($message->contexturl->out(), $savedmessage->contexturl);
 256         $this->assertEquals($message->contexturlname, $savedmessage->contexturlname);
 257         $this->assertTimeCurrent($savedmessage->timecreated);
 258         $record = $DB->get_record('message_read', array('id' => $savedmessage->id), '*', MUST_EXIST);
 259         $this->assertEquals($record, $savedmessage);
 260         $sink->clear();
 261         $this->assertFalse($DB->record_exists('message', array()));
 262         $DB->delete_records('message_read', array());
 263
 264         // Test phpunit problem detection.
 265
 266         $message = new stdClass();
 267         $message->component = 'xxxxx';
 268         $message->name = 'instantmessage';
 269         $message->userfrom = $user1;
 270         $message->userto = $user2;
 271         $message->subject = 'message subject 1';
 272         $message->fullmessage = 'message body';
 273         $message->fullmessageformat = FORMAT_MARKDOWN;
 274         $message->fullmessagehtml = '<p>message body</p>';
 275         $message->smallmessage = 'small message';
 276         $message->notification = '0';
 277
 278         $sink = $this->redirectMessages();
 279         try {
 280             message_send($message);
 281         } catch (moodle_exception $e) {
 282             $this->assertInstanceOf('coding_exception', $e);
 283         }
 284         $this->assertCount(0, $sink->get_messages());
 285
 286         $message->component = 'moodle';
 287         $message->name = 'xxx';
 288         $sink = $this->redirectMessages();
 289         try {
 290             message_send($message);
 291         } catch (moodle_exception $e) {
 292             $this->assertInstanceOf('coding_exception', $e);
 293         }
 294         $this->assertCount(0, $sink->get_messages());
 295         $sink->close();
 296         $this->assertFalse($DB->record_exists('message', array()));
 297         $this->assertFalse($DB->record_exists('message_read', array()));
 298
 299         // Invalid users.
 300
 301         $message = new stdClass();
 302         $message->component = 'moodle';
 303         $message->name = 'instantmessage';
 304         $message->userfrom = $user1;
 305         $message->userto = -1;
 306         $message->subject = 'message subject 1';
 307         $message->fullmessage = 'message body';
 308         $message->fullmessageformat = FORMAT_MARKDOWN;
 309         $message->fullmessagehtml = '<p>message body</p>';
 310         $message->smallmessage = 'small message';
 311         $message->notification = '0';
 312
 313         $messageid = message_send($message);
 314         $this->assertFalse($messageid);
 315         $this->assertDebuggingCalled('Attempt to send msg to unknown user');
 316
 317         $message = new stdClass();
 318         $message->component = 'moodle';
 319         $message->name = 'instantmessage';
 320         $message->userfrom = -1;
 321         $message->userto = $user2;
 322         $message->subject = 'message subject 1';
 323         $message->fullmessage = 'message body';
 324         $message->fullmessageformat = FORMAT_MARKDOWN;
 325         $message->fullmessagehtml = '<p>message body</p>';
 326         $message->smallmessage = 'small message';
 327         $message->notification = '0';
 328
 329         $messageid = message_send($message);
 330         $this->assertFalse($messageid);
 331         $this->assertDebuggingCalled('Attempt to send msg from unknown user');
 332
 333         $message = new stdClass();
 334         $message->component = 'moodle';
 335         $message->name = 'instantmessage';
 336         $message->userfrom = $user1;
 337         $message->userto = core_user::NOREPLY_USER;
 338         $message->subject = 'message subject 1';
 339         $message->fullmessage = 'message body';
 340         $message->fullmessageformat = FORMAT_MARKDOWN;
 341         $message->fullmessagehtml = '<p>message body</p>';
 342         $message->smallmessage = 'small message';
 343         $message->notification = '0';
 344
 345         $messageid = message_send($message);
 346         $this->assertFalse($messageid);
 347         $this->assertDebuggingCalled('Attempt to send msg to internal (noreply) user');
 348
 349         // Some debugging hints for devs.
 350
 351         unset($user2->emailstop);
 352         $message = new stdClass();
 353         $message->component = 'moodle';
 354         $message->name = 'instantmessage';
 355         $message->userfrom = $user1;
 356         $message->userto = $user2;
 357         $message->subject = 'message subject 1';
 358         $message->fullmessage = 'message body';
 359         $message->fullmessageformat = FORMAT_MARKDOWN;
 360         $message->fullmessagehtml = '<p>message body</p>';
 361         $message->smallmessage = 'small message';
 362         $message->notification = '0';
 363
 364         $sink = $this->redirectMessages();
 365         $messageid = message_send($message);
 366         $savedmessages = $sink->get_messages();
 367         $this->assertCount(1, $savedmessages);
 368         $savedmessage = reset($savedmessages);
 369         $this->assertEquals($messageid, $savedmessage->id);
 370         $this->assertEquals($user1->id, $savedmessage->useridfrom);
 371         $this->assertEquals($user2->id, $savedmessage->useridto);
 372         $this->assertDebuggingCalled('Necessary properties missing in userto object, fetching full record');
 373         $sink->clear();
 374         $user2->emailstop = '0';
 375     }
 376
 377     public function test_send_message() {
 378         global $DB, $CFG;
 379         $this->preventResetByRollback();
 380         $this->resetAfterTest();
 381
 382         $user1 = $this->getDataGenerator()->create_user();
 383         $user2 = $this->getDataGenerator()->create_user();
 384
 385         // Test basic email redirection.
 386         $this->assertFileExists("$CFG->dirroot/message/output/email/version.php");
 387         $this->assertFileExists("$CFG->dirroot/message/output/popup/version.php");
 388
 389         $DB->set_field_select('message_processors', 'enabled', 0, "name <> 'email' AND name <> 'popup'");
 390         get_message_processors(true, true);
 391
 392         $eventsink = $this->redirectEvents();
 393
 394         set_user_preference('message_provider_moodle_instantmessage_loggedoff', 'none', $user2);
 395
 396         $message = new stdClass();
 397         $message->component         = 'moodle';
 398         $message->name              = 'instantmessage';
 399         $message->userfrom          = $user1;
 400         $message->userto            = $user2;
 401         $message->subject           = 'message subject 1';
 402         $message->fullmessage       = 'message body';
 403         $message->fullmessageformat = FORMAT_MARKDOWN;
 404         $message->fullmessagehtml   = '<p>message body</p>';
 405         $message->smallmessage      = 'small message';
 406         $message->notification      = '0';
 407
 408         $sink = $this->redirectEmails();
 409         $messageid = message_send($message);
 410         $emails = $sink->get_messages();
 411         $this->assertCount(0, $emails);
 412         $savedmessage = $DB->get_record('message', array('id' => $messageid), '*', MUST_EXIST);
 413         $sink->clear();
 414         $this->assertFalse($DB->record_exists('message_read', array()));
 415         $DB->delete_records('message', array());
 416         $events = $eventsink->get_events();
 417         $this->assertCount(1, $events);
 418         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 419         $eventsink->clear();
 420
 421         $CFG->messaging = 0;
 422
 423         $message = new stdClass();
 424         $message->component         = 'moodle';
 425         $message->name              = 'instantmessage';
 426         $message->userfrom          = $user1;
 427         $message->userto            = $user2;
 428         $message->subject           = 'message subject 1';
 429         $message->fullmessage       = 'message body';
 430         $message->fullmessageformat = FORMAT_MARKDOWN;
 431         $message->fullmessagehtml   = '<p>message body</p>';
 432         $message->smallmessage      = 'small message';
 433         $message->notification      = '0';
 434
 435         $messageid = message_send($message);
 436         $emails = $sink->get_messages();
 437         $this->assertCount(0, $emails);
 438         $savedmessage = $DB->get_record('message_read', array('id' => $messageid), '*', MUST_EXIST);
 439         $sink->clear();
 440         $this->assertFalse($DB->record_exists('message', array()));
 441         $DB->delete_records('message_read', array());
 442         $events = $eventsink->get_events();
 443         $this->assertCount(2, $events);
 444         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 445         $this->assertInstanceOf('\core\event\message_viewed', $events[1]);
 446         $eventsink->clear();
 447
 448         $CFG->messaging = 1;
 449
 450         $message = new stdClass();
 451         $message->component         = 'moodle';
 452         $message->name              = 'instantmessage';
 453         $message->userfrom          = $user1;
 454         $message->userto            = $user2;
 455         $message->subject           = 'message subject 1';
 456         $message->fullmessage       = 'message body';
 457         $message->fullmessageformat = FORMAT_MARKDOWN;
 458         $message->fullmessagehtml   = '<p>message body</p>';
 459         $message->smallmessage      = 'small message';
 460         $message->notification      = '1';
 461
 462         $messageid = message_send($message);
 463         $emails = $sink->get_messages();
 464         $this->assertCount(0, $emails);
 465         $savedmessage = $DB->get_record('message_read', array('id' => $messageid), '*', MUST_EXIST);
 466         $sink->clear();
 467         $this->assertFalse($DB->record_exists('message', array()));
 468         $DB->delete_records('message_read', array());
 469         $events = $eventsink->get_events();
 470         $this->assertCount(2, $events);
 471         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 472         $this->assertInstanceOf('\core\event\message_viewed', $events[1]);
 473         $eventsink->clear();
 474
 475         set_user_preference('message_provider_moodle_instantmessage_loggedoff', 'email', $user2);
 476
 477         $message = new stdClass();
 478         $message->component         = 'moodle';
 479         $message->name              = 'instantmessage';
 480         $message->userfrom          = $user1;
 481         $message->userto            = $user2;
 482         $message->subject           = 'message subject 1';
 483         $message->fullmessage       = 'message body';
 484         $message->fullmessageformat = FORMAT_MARKDOWN;
 485         $message->fullmessagehtml   = '<p>message body</p>';
 486         $message->smallmessage      = 'small message';
 487         $message->notification      = '0';
 488
 489         $user2->emailstop = '1';
 490
 491         $sink = $this->redirectEmails();
 492         $messageid = message_send($message);
 493         $emails = $sink->get_messages();
 494         $this->assertCount(0, $emails);
 495         $savedmessage = $DB->get_record('message', array('id' => $messageid), '*', MUST_EXIST);
 496         $sink->clear();
 497         $this->assertFalse($DB->record_exists('message_read', array()));
 498         $DB->delete_records('message', array());
 499         $events = $eventsink->get_events();
 500         $this->assertCount(1, $events);
 501         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 502         $eventsink->clear();
 503         $user2->emailstop = '0';
 504
 505         set_user_preference('message_provider_moodle_instantmessage_loggedoff', 'email', $user2);
 506
 507         $message = new stdClass();
 508         $message->component         = 'moodle';
 509         $message->name              = 'instantmessage';
 510         $message->userfrom          = $user1;
 511         $message->userto            = $user2;
 512         $message->subject           = 'message subject 1';
 513         $message->fullmessage       = 'message body';
 514         $message->fullmessageformat = FORMAT_MARKDOWN;
 515         $message->fullmessagehtml   = '<p>message body</p>';
 516         $message->smallmessage      = 'small message';
 517         $message->notification      = '0';
 518
 519         $messageid = message_send($message);
 520         $emails = $sink->get_messages();
 521         $this->assertCount(1, $emails);
 522         $email = reset($emails);
 523         $savedmessage = $DB->get_record('message_read', array('id' => $messageid), '*', MUST_EXIST);
 524         $this->assertSame($user1->email, $email->from);
 525         $this->assertSame($user2->email, $email->to);
 526         $this->assertSame($message->subject, $email->subject);
 527         $this->assertNotEmpty($email->header);
 528         $this->assertNotEmpty($email->body);
 529         $sink->clear();
 530         $this->assertFalse($DB->record_exists('message', array()));
 531         $DB->delete_records('message_read', array());
 532         $events = $eventsink->get_events();
 533         $this->assertCount(2, $events);
 534         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 535         $this->assertInstanceOf('\core\event\message_viewed', $events[1]);
 536         $eventsink->clear();
 537
 538         set_user_preference('message_provider_moodle_instantmessage_loggedoff', 'email,popup', $user2);
 539
 540         $message = new stdClass();
 541         $message->component         = 'moodle';
 542         $message->name              = 'instantmessage';
 543         $message->userfrom          = $user1;
 544         $message->userto            = $user2;
 545         $message->subject           = 'message subject 1';
 546         $message->fullmessage       = 'message body';
 547         $message->fullmessageformat = FORMAT_MARKDOWN;
 548         $message->fullmessagehtml   = '<p>message body</p>';
 549         $message->smallmessage      = 'small message';
 550         $message->notification      = '0';
 551
 552         $messageid = message_send($message);
 553         $emails = $sink->get_messages();
 554         $this->assertCount(1, $emails);
 555         $email = reset($emails);
 556         $savedmessage = $DB->get_record('message', array('id' => $messageid), '*', MUST_EXIST);
 557         $working = $DB->get_record('message_working', array('unreadmessageid' => $messageid), '*', MUST_EXIST);
 558         $this->assertSame($user1->email, $email->from);
 559         $this->assertSame($user2->email, $email->to);
 560         $this->assertSame($message->subject, $email->subject);
 561         $this->assertNotEmpty($email->header);
 562         $this->assertNotEmpty($email->body);
 563         $sink->clear();
 564         $this->assertFalse($DB->record_exists('message_read', array()));
 565         $DB->delete_records('message', array());
 566         $events = $eventsink->get_events();
 567         $this->assertCount(1, $events);
 568         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 569         $eventsink->clear();
 570
 571         set_user_preference('message_provider_moodle_instantmessage_loggedoff', 'popup', $user2);
 572
 573         $message = new stdClass();
 574         $message->component         = 'moodle';
 575         $message->name              = 'instantmessage';
 576         $message->userfrom          = $user1;
 577         $message->userto            = $user2;
 578         $message->subject           = 'message subject 1';
 579         $message->fullmessage       = 'message body';
 580         $message->fullmessageformat = FORMAT_MARKDOWN;
 581         $message->fullmessagehtml   = '<p>message body</p>';
 582         $message->smallmessage      = 'small message';
 583         $message->notification      = '0';
 584
 585         $messageid = message_send($message);
 586         $emails = $sink->get_messages();
 587         $this->assertCount(0, $emails);
 588         $savedmessage = $DB->get_record('message', array('id' => $messageid), '*', MUST_EXIST);
 589         $working = $DB->get_record('message_working', array('unreadmessageid' => $messageid), '*', MUST_EXIST);
 590         $sink->clear();
 591         $this->assertFalse($DB->record_exists('message_read', array()));
 592         $DB->delete_records('message', array());
 593         $events = $eventsink->get_events();
 594         $this->assertCount(1, $events);
 595         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 596         $eventsink->clear();
 597
 598         $this->assertFalse($DB->is_transaction_started());
 599         $transaction = $DB->start_delegated_transaction();
 600         if (!$DB->is_transaction_started()) {
 601             $this->markTestSkipped('Databases that do not support transactions should not be used at all!');
 602         }
 603         $transaction->allow_commit();
 604
 605         set_user_preference('message_provider_moodle_instantmessage_loggedoff', 'none', $user2);
 606
 607         $message = new stdClass();
 608         $message->component         = 'moodle';
 609         $message->name              = 'instantmessage';
 610         $message->userfrom          = $user1;
 611         $message->userto            = $user2;
 612         $message->subject           = 'message subject 1';
 613         $message->fullmessage       = 'message body';
 614         $message->fullmessageformat = FORMAT_MARKDOWN;
 615         $message->fullmessagehtml   = '<p>message body</p>';
 616         $message->smallmessage      = 'small message';
 617         $message->notification      = '0';
 618
 619         $transaction = $DB->start_delegated_transaction();
 620         $sink = $this->redirectEmails();
 621         $messageid = message_send($message);
 622         $emails = $sink->get_messages();
 623         $this->assertCount(0, $emails);
 624         $savedmessage = $DB->get_record('message', array('id' => $messageid), '*', MUST_EXIST);
 625         $sink->clear();
 626         $this->assertFalse($DB->record_exists('message_read', array()));
 627         $DB->delete_records('message', array());
 628         $events = $eventsink->get_events();
 629         $this->assertCount(1, $events);
 630         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 631         $eventsink->clear();
 632         $transaction->allow_commit();
 633         $events = $eventsink->get_events();
 634         $this->assertCount(0, $events);
 635
 636         set_user_preference('message_provider_moodle_instantmessage_loggedoff', 'email', $user2);
 637
 638         $message = new stdClass();
 639         $message->component         = 'moodle';
 640         $message->name              = 'instantmessage';
 641         $message->userfrom          = $user1;
 642         $message->userto            = $user2;
 643         $message->subject           = 'message subject 1';
 644         $message->fullmessage       = 'message body';
 645         $message->fullmessageformat = FORMAT_MARKDOWN;
 646         $message->fullmessagehtml   = '<p>message body</p>';
 647         $message->smallmessage      = 'small message';
 648         $message->notification      = '0';
 649
 650         $transaction = $DB->start_delegated_transaction();
 651         $sink = $this->redirectEmails();
 652         $messageid = message_send($message);
 653         $emails = $sink->get_messages();
 654         $this->assertCount(0, $emails);
 655         $savedmessage = $DB->get_record('message', array('id' => $messageid), '*', MUST_EXIST);
 656         $sink->clear();
 657         $this->assertFalse($DB->record_exists('message_read', array()));
 658         $events = $eventsink->get_events();
 659         $this->assertCount(0, $events);
 660         $transaction->allow_commit();
 661         $events = $eventsink->get_events();
 662         $this->assertCount(2, $events);
 663         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 664         $this->assertInstanceOf('\core\event\message_viewed', $events[1]);
 665         $eventsink->clear();
 666
 667         $transaction = $DB->start_delegated_transaction();
 668         message_send($message);
 669         message_send($message);
 670         $this->assertCount(2, $DB->get_records('message'));
 671         $this->assertCount(1, $DB->get_records('message_read'));
 672         $events = $eventsink->get_events();
 673         $this->assertCount(0, $events);
 674         $transaction->allow_commit();
 675         $events = $eventsink->get_events();
 676         $this->assertCount(4, $events);
 677         $this->assertInstanceOf('\core\event\message_sent', $events[0]);
 678         $this->assertInstanceOf('\core\event\message_viewed', $events[1]);
 679         $this->assertInstanceOf('\core\event\message_sent', $events[2]);
 680         $this->assertInstanceOf('\core\event\message_viewed', $events[3]);
 681         $eventsink->clear();
 682         $DB->delete_records('message', array());
 683         $DB->delete_records('message_read', array());
 684
 685         $transaction = $DB->start_delegated_transaction();
 686         message_send($message);
 687         message_send($message);
 688         $this->assertCount(2, $DB->get_records('message'));
 689         $this->assertCount(0, $DB->get_records('message_read'));
 690         $events = $eventsink->get_events();
 691         $this->assertCount(0, $events);
 692         try {
 693             $transaction->rollback(new Exception('ignore'));
 694         } catch (Exception $e) {
 695             $this->assertSame('ignore', $e->getMessage());
 696         }
 697         $events = $eventsink->get_events();
 698         $this->assertCount(0, $events);
 699         $this->assertCount(0, $DB->get_records('message'));
 700         $this->assertCount(0, $DB->get_records('message_read'));
 701         message_send($message);
 702         $this->assertCount(0, $DB->get_records('message'));
 703         $this->assertCount(1, $DB->get_records('message_read'));
 704         $events = $eventsink->get_events();
 705         $this->assertCount(2, $events);
 706         $sink->clear();
 707         $DB->delete_records('message_read', array());
 708     }
 709
 710     public function test_rollback() {
 711         global $DB;
 712
 713         $this->resetAfterTest();
 714         $this->preventResetByRollback();
 715
 716         $user1 = $this->getDataGenerator()->create_user();
 717         $user2 = $this->getDataGenerator()->create_user();
 718
 719         $message = new stdClass();
 720         $message->component         = 'moodle';
 721         $message->name              = 'instantmessage';
 722         $message->userfrom          = $user1;
 723         $message->userto            = $user2;
 724         $message->subject           = 'message subject 1';
 725         $message->fullmessage       = 'message body';
 726         $message->fullmessageformat = FORMAT_MARKDOWN;
 727         $message->fullmessagehtml   = '<p>message body</p>';
 728         $message->smallmessage      = 'small message';
 729         $message->notification      = '0';
 730
 731         $mailsink = $this->redirectEmails();
 732
 733         // Sending outside of a transaction is fine.
 734         message_send($message);
 735         $this->assertEquals(1, $mailsink->count());
 736
 737         $transaction1 = $DB->start_delegated_transaction();
 738
 739         $mailsink->clear();
 740         message_send($message);
 741         $this->assertEquals(0, $mailsink->count());
 742
 743         $transaction2 = $DB->start_delegated_transaction();
 744
 745         $mailsink->clear();
 746         message_send($message);
 747         $this->assertEquals(0, $mailsink->count());
 748
 749         try {
 750             $transaction2->rollback(new Exception('x'));
 751             $this->fail('Expecting exception');
 752         } catch (Exception $e) {}
 753         $this->assertDebuggingNotCalled();
 754         $this->assertEquals(0, $mailsink->count());
 755
 756         $this->assertTrue($DB->is_transaction_started());
 757
 758         try {
 759             $transaction1->rollback(new Exception('x'));
 760             $this->fail('Expecting exception');
 761         } catch (Exception $e) {}
 762         $this->assertDebuggingNotCalled();
 763         $this->assertEquals(0, $mailsink->count());
 764
 765         $this->assertFalse($DB->is_transaction_started());
 766
 767         message_send($message);
 768         $this->assertEquals(1, $mailsink->count());
 769     }
 770
 771     public function test_forced_rollback() {
 772         global $DB;
 773
 774         $this->resetAfterTest();
 775         $this->preventResetByRollback();
 776         set_config('noemailever', 1);
 777
 778         $user1 = $this->getDataGenerator()->create_user();
 779         $user2 = $this->getDataGenerator()->create_user();
 780
 781         $message = new stdClass();
 782         $message->component         = 'moodle';
 783         $message->name              = 'instantmessage';
 784         $message->userfrom          = $user1;
 785         $message->userto            = $user2;
 786         $message->subject           = 'message subject 1';
 787         $message->fullmessage       = 'message body';
 788         $message->fullmessageformat = FORMAT_MARKDOWN;
 789         $message->fullmessagehtml   = '<p>message body</p>';
 790         $message->smallmessage      = 'small message';
 791         $message->notification      = '0';
 792
 793         message_send($message);
 794         $this->assertDebuggingCalled('Not sending email due to $CFG->noemailever config setting');
 795
 796         $transaction1 = $DB->start_delegated_transaction();
 797
 798         message_send($message);
 799         $this->assertDebuggingNotCalled();
 800
 801         $transaction2 = $DB->start_delegated_transaction();
 802
 803         message_send($message);
 804         $this->assertDebuggingNotCalled();
 805
 806         $DB->force_transaction_rollback();
 807         $this->assertFalse($DB->is_transaction_started());
 808         $this->assertDebuggingNotCalled();
 809
 810         message_send($message);
 811         $this->assertDebuggingCalled('Not sending email due to $CFG->noemailever config setting');
 812     }
 813
 814     public function test_message_attachment_send() {
 815         global $CFG;
 816         $this->preventResetByRollback();
 817         $this->resetAfterTest();
 818
 819         // Set config setting to allow attachments.
 820         $CFG->allowattachments = true;
 821         unset_config('noemailever');
 822
 823         $user = $this->getDataGenerator()->create_user();
 824         $context = context_user::instance($user->id);
 825
 826         // Create a test file.
 827         $fs = get_file_storage();
 828         $filerecord = array(
 829                 'contextid' => $context->id,
 830                 'component' => 'core',
 831                 'filearea'  => 'unittest',
 832                 'itemid'    => 99999,
 833                 'filepath'  => '/',
 834                 'filename'  => 'emailtest.txt'
 835         );
 836         $file = $fs->create_file_from_string($filerecord, 'Test content');
 837
 838         $message = new stdClass();
 839         $message->component         = 'moodle';
 840         $message->name              = 'instantmessage';
 841         $message->userfrom          = get_admin();
 842         $message->userto            = $user;
 843         $message->subject           = 'message subject 1';
 844         $message->fullmessage       = 'message body';
 845         $message->fullmessageformat = FORMAT_MARKDOWN;
 846         $message->fullmessagehtml   = '<p>message body</p>';
 847         $message->smallmessage      = 'small message';
 848         $message->attachment        = $file;
 849         $message->attachname        = 'emailtest.txt';
 850         $message->notification      = 0;
 851
 852         // Make sure we are redirecting emails.
 853         $sink = $this->redirectEmails();
 854         message_send($message);
 855
 856         // Get the email that we just sent.
 857         $emails = $sink->get_messages();
 858         $email = reset($emails);
 859         $this->assertTrue(strpos($email->body, 'Content-Disposition: attachment;') !== false);
 860         $this->assertTrue(strpos($email->body, 'emailtest.txt') !== false);
 861
 862         // Check if the stored file still exists after remove the temporary attachment.
 863         $storedfileexists = $fs->file_exists($filerecord['contextid'], $filerecord['component'], $filerecord['filearea'],
 864                                              $filerecord['itemid'], $filerecord['filepath'], $filerecord['filename']);
 865         $this->assertTrue($storedfileexists);
 866     }
 867
 868     /**
 869      * Is a particular message type in the list of message types.
 870      * @param string $component
 871      * @param string $name a message name.
 872      * @param array $providers as returned by message_get_providers_for_user.
 873      * @return bool whether the message type is present.
 874      */
 875     protected function message_type_present($component, $name, $providers) {
 876         foreach ($providers as $provider) {
 877             if ($provider->component == $component && $provider->name == $name) {
 878                 return true;
 879             }
 880         }
 881         return false;
 882     }
 883 }