[Summary view] [Print] [Text view]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  /**
  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  }