[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 events subsystem.
  19   *
  20   * @package    core_event
  21   * @subpackage phpunit
  22   * @copyright  2007 onwards Martin Dougiamas (http://dougiamas.com)
  23   * @author     Petr Skoda {@link http://skodak.org}
  24   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  25   */
  26  
  27  defined('MOODLE_INTERNAL') || die();
  28  
  29  
  30  class core_eventslib_testcase extends advanced_testcase {
  31  
  32      const DEBUGGING_MSG = 'Events API using $handlers array has been deprecated in favour of Events 2 API, please use it instead.';
  33  
  34      /**
  35       * Create temporary entries in the database for these tests.
  36       * These tests have to work no matter the data currently in the database
  37       * (meaning they should run on a brand new site). This means several items of
  38       * data have to be artificially inseminated (:-) in the DB.
  39       */
  40      protected function setUp() {
  41          parent::setUp();
  42          // Set global category settings to -1 (not force).
  43          eventslib_sample_function_handler('reset');
  44          eventslib_sample_handler_class::static_method('reset');
  45  
  46          $this->resetAfterTest();
  47      }
  48  
  49      /**
  50       * Tests the installation of event handlers from file
  51       */
  52      public function test_events_update_definition__install() {
  53          global $DB;
  54  
  55          events_update_definition('unittest');
  56          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
  57  
  58          $dbcount = $DB->count_records('events_handlers', array('component'=>'unittest'));
  59          $handlers = array();
  60          require (__DIR__.'/fixtures/events.php');
  61          $this->assertCount($dbcount, $handlers, 'Equal number of handlers in file and db: %s');
  62      }
  63  
  64      /**
  65       * Tests the uninstallation of event handlers from file.
  66       */
  67      public function test_events_update_definition__uninstall() {
  68          global $DB;
  69  
  70          events_update_definition('unittest');
  71          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
  72  
  73          events_uninstall('unittest');
  74          $this->assertEquals(0, $DB->count_records('events_handlers', array('component'=>'unittest')), 'All handlers should be uninstalled: %s');
  75      }
  76  
  77      /**
  78       * Tests the update of event handlers from file.
  79       */
  80      public function test_events_update_definition__update() {
  81          global $DB;
  82  
  83          events_update_definition('unittest');
  84          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
  85  
  86          // First modify directly existing handler.
  87          $handler = $DB->get_record('events_handlers', array('component'=>'unittest', 'eventname'=>'test_instant'));
  88  
  89          $original = $handler->handlerfunction;
  90  
  91          // Change handler in db.
  92          $DB->set_field('events_handlers', 'handlerfunction', serialize('some_other_function_handler'), array('id'=>$handler->id));
  93  
  94          // Update the definition, it should revert the handler back.
  95          events_update_definition('unittest');
  96          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
  97          $handler = $DB->get_record('events_handlers', array('component'=>'unittest', 'eventname'=>'test_instant'));
  98          $this->assertSame($handler->handlerfunction, $original, 'update should sync db with file definition: %s');
  99      }
 100  
 101      /**
 102       * Tests events_trigger_is_registered() function.
 103       */
 104      public function test_events_is_registered() {
 105  
 106          events_update_definition('unittest');
 107          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 108  
 109          $this->assertTrue(events_is_registered('test_instant', 'unittest'));
 110          $this->assertDebuggingCalled('events_is_registered() has been deprecated along with all Events 1 API in favour of Events 2' .
 111              ' API, please use it instead.', DEBUG_DEVELOPER);
 112      }
 113  
 114      /**
 115       * Tests events_trigger_legacy() function.
 116       */
 117      public function test_events_trigger_legacy_instant() {
 118  
 119          events_update_definition('unittest');
 120          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 121  
 122          $this->assertEquals(0, events_trigger_legacy('test_instant', 'ok'));
 123          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 124          $this->assertEquals(0, events_trigger_legacy('test_instant', 'ok'));
 125          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 126          $this->assertEquals(2, eventslib_sample_function_handler('status'));
 127      }
 128  
 129      /**
 130       * Tests events_trigger_legacy() function.
 131       */
 132      public function test_events_trigger__cron() {
 133  
 134          events_update_definition('unittest');
 135          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 136  
 137          $this->assertEquals(0, events_trigger_legacy('test_cron', 'ok'));
 138          $this->assertEquals(0, eventslib_sample_handler_class::static_method('status'));
 139          events_cron('test_cron');
 140          // The events_cron one + one for each triggered event above (triggered in events_dispatch).
 141          $this->assertDebuggingCalledCount(2, array(self::DEBUGGING_MSG, self::DEBUGGING_MSG),
 142              array(DEBUG_DEVELOPER, DEBUG_DEVELOPER));
 143          $this->assertEquals(1, eventslib_sample_handler_class::static_method('status'));
 144      }
 145  
 146      /**
 147       * Tests events_pending_count() function.
 148       */
 149      public function test_events_pending_count() {
 150  
 151          events_update_definition('unittest');
 152          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 153  
 154          events_trigger_legacy('test_cron', 'ok');
 155          $this->assertDebuggingNotCalled();
 156          events_trigger_legacy('test_cron', 'ok');
 157          $this->assertDebuggingNotCalled();
 158          events_cron('test_cron');
 159          // The events_cron one + one for each triggered event above (triggered in events_dispatch).
 160          $this->assertDebuggingCalledCount(3);
 161          $this->assertEquals(0, events_pending_count('test_cron'), 'all messages should be already dequeued: %s');
 162          $this->assertDebuggingCalled('events_pending_count() has been deprecated along with all Events 1 API in favour of Events 2' .
 163              ' API, please use it instead.', DEBUG_DEVELOPER);
 164      }
 165  
 166      /**
 167       * Tests events_trigger_legacy() function when instant handler fails.
 168       */
 169      public function test_events_trigger__failed_instant() {
 170          global $CFG;
 171  
 172          events_update_definition('unittest');
 173          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 174  
 175          $olddebug = $CFG->debug;
 176  
 177          $this->assertEquals(1, events_trigger_legacy('test_instant', 'fail'), 'fail first event: %s');
 178          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 179          $this->assertEquals(1, events_trigger_legacy('test_instant', 'ok'), 'this one should fail too: %s');
 180          $this->assertDebuggingNotCalled();
 181  
 182          $this->assertEquals(0, events_cron('test_instant'), 'all events should stay in queue: %s');
 183          // events_cron + one for each dispatched event.
 184          $this->assertDebuggingCalledCount(3);
 185  
 186          $this->assertEquals(2, events_pending_count('test_instant'), 'two events should in queue: %s');
 187          $this->assertDebuggingCalled('events_pending_count() has been deprecated along with all Events 1 API in favour of Events 2' .
 188              ' API, please use it instead.', DEBUG_DEVELOPER);
 189  
 190          $this->assertEquals(0, eventslib_sample_function_handler('status'), 'verify no event dispatched yet: %s');
 191          eventslib_sample_function_handler('ignorefail'); // Ignore "fail" eventdata from now on.
 192          $this->assertEquals(1, events_trigger_legacy('test_instant', 'ok'), 'this one should go to queue directly: %s');
 193          $this->assertDebuggingNotCalled();
 194  
 195          $this->assertEquals(3, events_pending_count('test_instant'), 'three events should in queue: %s');
 196          $this->assertDebuggingCalled('events_pending_count() has been deprecated along with all Events 1 API in favour of Events 2' .
 197              ' API, please use it instead.', DEBUG_DEVELOPER);
 198  
 199          $this->assertEquals(0, eventslib_sample_function_handler('status'), 'verify previous event was not dispatched: %s');
 200          $this->assertEquals(3, events_cron('test_instant'), 'all events should be dispatched: %s');
 201          // events_cron + one for each dispatched event.
 202          $this->assertDebuggingCalledCount(4);
 203  
 204          $this->assertEquals(3, eventslib_sample_function_handler('status'), 'verify three events were dispatched: %s');
 205          $this->assertEquals(0, events_pending_count('test_instant'), 'no events should in queue: %s');
 206          $this->assertDebuggingCalled('events_pending_count() has been deprecated along with all Events 1 API in favour of Events 2' .
 207              ' API, please use it instead.', DEBUG_DEVELOPER);
 208  
 209          $this->assertEquals(0, events_trigger_legacy('test_instant', 'ok'), 'this event should be dispatched immediately: %s');
 210          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 211  
 212          $this->assertEquals(4, eventslib_sample_function_handler('status'), 'verify event was dispatched: %s');
 213          $this->assertEquals(0, events_pending_count('test_instant'), 'no events should in queue: %s');
 214          $this->assertDebuggingCalled('events_pending_count() has been deprecated along with all Events 1 API in favour of Events 2' .
 215              ' API, please use it instead.', DEBUG_DEVELOPER);
 216      }
 217  
 218      /**
 219       * Tests events_trigger() function.
 220       */
 221      public function test_events_trigger_debugging() {
 222  
 223          events_update_definition('unittest');
 224          $this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
 225  
 226          $this->assertEquals(0, events_trigger('test_instant', 'ok'));
 227          $debugmessages = array('events_trigger() is deprecated, please use new events instead', self::DEBUGGING_MSG);
 228          $this->assertDebuggingCalledCount(2, $debugmessages, array(DEBUG_DEVELOPER, DEBUG_DEVELOPER));
 229      }
 230  }
 231  
 232  /**
 233   * Test handler function.
 234   */
 235  function eventslib_sample_function_handler($eventdata) {
 236      static $called = 0;
 237      static $ignorefail = false;
 238  
 239      if ($eventdata == 'status') {
 240          return $called;
 241  
 242      } else if ($eventdata == 'reset') {
 243          $called = 0;
 244          $ignorefail = false;
 245          return;
 246  
 247      } else if ($eventdata == 'fail') {
 248          if ($ignorefail) {
 249              $called++;
 250              return true;
 251          } else {
 252              return false;
 253          }
 254  
 255      } else if ($eventdata == 'ignorefail') {
 256          $ignorefail = true;
 257          return;
 258  
 259      } else if ($eventdata == 'ok') {
 260          $called++;
 261          return true;
 262      }
 263  
 264      print_error('invalideventdata', '', '', $eventdata);
 265  }
 266  
 267  
 268  /**
 269   * Test handler class with static method.
 270   */
 271  class eventslib_sample_handler_class {
 272      public static function static_method($eventdata) {
 273          static $called = 0;
 274          static $ignorefail = false;
 275  
 276          if ($eventdata == 'status') {
 277              return $called;
 278  
 279          } else if ($eventdata == 'reset') {
 280              $called = 0;
 281              $ignorefail = false;
 282              return;
 283  
 284          } else if ($eventdata == 'fail') {
 285              if ($ignorefail) {
 286                  $called++;
 287                  return true;
 288              } else {
 289                  return false;
 290              }
 291  
 292          } else if ($eventdata == 'ignorefail') {
 293              $ignorefail = true;
 294              return;
 295  
 296          } else if ($eventdata == 'ok') {
 297              $called++;
 298              return true;
 299          }
 300  
 301          print_error('invalideventdata', '', '', $eventdata);
 302      }
 303  }