mod/wiki/tests/events_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  * Events tests.
  19  *
  20  * @package    mod_wiki
  21  * @category   phpunit
  22  * @copyright  2013 Rajesh Taneja <rajesh@moodle.com>
  23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24  */
  25
  26 defined('MOODLE_INTERNAL') || die();
  27 global $CFG;
  28 require_once($CFG->dirroot.'/mod/wiki/locallib.php');
  29 /**
  30  * Events tests class.
  31  *
  32  * @package    mod_wiki
  33  * @category   phpunit
  34  * @copyright  2013 Rajesh Taneja <rajesh@moodle.com>
  35  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  36  */
  37 class mod_wiki_events_testcase extends advanced_testcase {
  38     private $course;
  39     private $wiki;
  40     private $wikigenerator;
  41     private $student;
  42     private $teacher;
  43
  44     /**
  45      * Setup test data.
  46      */
  47     public function setUp(): void {
  48         global $DB;
  49
  50         $this->resetAfterTest();
  51         // Create course and wiki.
  52         $this->course = $this->getDataGenerator()->create_course();
  53         $this->wiki = $this->getDataGenerator()->create_module('wiki', array('course' => $this->course->id));
  54         $this->wikigenerator = $this->getDataGenerator()->get_plugin_generator('mod_wiki');
  55
  56         // Create student and teacher in course.
  57         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
  58         $teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
  59         $this->student = $this->getDataGenerator()->create_user();
  60         $this->teacher = $this->getDataGenerator()->create_user();
  61         $this->getDataGenerator()->enrol_user($this->student->id, $this->course->id, $studentrole->id);
  62         $this->getDataGenerator()->enrol_user($this->student->id, $this->course->id, $teacherrole->id);
  63         $this->setAdminUser();
  64     }
  65
  66     /**
  67      * Test comment_created event.
  68      */
  69     public function test_comment_created() {
  70         $this->setUp();
  71
  72         $page = $this->wikigenerator->create_first_page($this->wiki);
  73         $context = context_module::instance($this->wiki->cmid);
  74
  75         // Triggering and capturing the event.
  76         $sink = $this->redirectEvents();
  77         wiki_add_comment($context, $page->id, 'Test comment', $this->wiki->defaultformat);
  78         $events = $sink->get_events();
  79         $this->assertCount(1, $events);
  80         $event = reset($events);
  81
  82         // Checking that the event contains the expected values.
  83         $this->assertInstanceOf('\mod_wiki\event\comment_created', $event);
  84         $this->assertEquals($context, $event->get_context());
  85         $this->assertEquals($page->id, $event->other['itemid']);
  86         $this->assertEventContextNotUsed($event);
  87     }
  88
  89     /**
  90      * Test comment_deleted event.
  91      */
  92     public function test_comment_deleted() {
  93         $this->setUp();
  94
  95         $page = $this->wikigenerator->create_first_page($this->wiki);
  96         $context = context_module::instance($this->wiki->cmid);
  97
  98         // Add comment so we can delete it later.
  99         wiki_add_comment($context, $page->id, 'Test comment', 'html');
 100         $comment = wiki_get_comments($context->id, $page->id);
 101         $this->assertCount(1, $comment);
 102         $comment = array_shift($comment);
 103
 104         // Triggering and capturing the event.
 105         $sink = $this->redirectEvents();
 106         wiki_delete_comment($comment->id, $context, $page->id);
 107         $events = $sink->get_events();
 108         $this->assertCount(1, $events);
 109         $event = reset($events);
 110
 111         // Checking that the event contains the expected values.
 112         $this->assertInstanceOf('\mod_wiki\event\comment_deleted', $event);
 113         $this->assertEquals($context, $event->get_context());
 114         $this->assertEquals($page->id, $event->other['itemid']);
 115         $this->assertEventContextNotUsed($event);
 116     }
 117
 118     /**
 119      * Test comment_viewed event.
 120      */
 121     public function test_comment_viewed() {
 122         // There is no proper API to call or trigger this event, so simulating event
 123         // to check if event returns the right information.
 124
 125         $this->setUp();
 126         $page = $this->wikigenerator->create_first_page($this->wiki);
 127         $context = context_module::instance($this->wiki->cmid);
 128
 129         $params = array(
 130                 'context' => $context,
 131                 'objectid' => $page->id
 132                 );
 133         $event = \mod_wiki\event\comments_viewed::create($params);
 134
 135         // Triggering and capturing the event.
 136         $sink = $this->redirectEvents();
 137         $event->trigger();
 138         $events = $sink->get_events();
 139         $this->assertCount(1, $events);
 140         $event = reset($events);
 141
 142         // Checking that the event contains the expected values.
 143         $this->assertInstanceOf('\mod_wiki\event\comments_viewed', $event);
 144         $this->assertEquals($context, $event->get_context());
 145         $expected = array($this->course->id, 'wiki', 'comments', 'comments.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 146         $this->assertEventLegacyLogData($expected, $event);
 147         $this->assertEventContextNotUsed($event);
 148     }
 149
 150     /**
 151      * Test instances_list_viewed event.
 152      */
 153     public function test_course_module_instance_list_viewed() {
 154         // There is no proper API to call or trigger this event, so simulating event
 155         // to check if event returns the right information.
 156
 157         $this->setUp();
 158         $context = context_course::instance($this->course->id);
 159
 160         $params = array('context' => $context);
 161         $event = \mod_wiki\event\course_module_instance_list_viewed::create($params);
 162
 163         // Triggering and capturing the event.
 164         $sink = $this->redirectEvents();
 165         $event->trigger();
 166         $events = $sink->get_events();
 167         $this->assertCount(1, $events);
 168         $event = reset($events);
 169
 170         // Checking that the event contains the expected values.
 171         $this->assertInstanceOf('\mod_wiki\event\course_module_instance_list_viewed', $event);
 172         $this->assertEquals($context, $event->get_context());
 173         $expected = array($this->course->id, 'wiki', 'view all', 'index.php?id=' . $this->course->id, '');
 174         $this->assertEventLegacyLogData($expected, $event);
 175         $this->assertEventContextNotUsed($event);
 176     }
 177
 178     /**
 179      * Test course_module_viewed event.
 180      */
 181     public function test_course_module_viewed() {
 182         // There is no proper API to call or trigger this event, so simulating event
 183         // to check if event returns the right information.
 184
 185         $this->setUp();
 186         $context = context_module::instance($this->wiki->cmid);
 187
 188         $params = array(
 189                 'context' => $context,
 190                 'objectid' => $this->wiki->id
 191                 );
 192         $event = \mod_wiki\event\course_module_viewed::create($params);
 193
 194         // Triggering and capturing the event.
 195         $sink = $this->redirectEvents();
 196         $event->trigger();
 197         $events = $sink->get_events();
 198         $this->assertCount(1, $events);
 199         $event = reset($events);
 200
 201         // Checking that the event contains the expected values.
 202         $this->assertInstanceOf('\mod_wiki\event\course_module_viewed', $event);
 203         $this->assertEquals($context, $event->get_context());
 204         $this->assertEquals($this->wiki->id, $event->objectid);
 205         $expected = array($this->course->id, 'wiki', 'view', 'view.php?id=' . $this->wiki->cmid,
 206             $this->wiki->id, $this->wiki->cmid);
 207         $this->assertEventLegacyLogData($expected, $event);
 208         $this->assertEventContextNotUsed($event);
 209     }
 210
 211     /**
 212      * Test page_viewed event.
 213      */
 214     public function test_page_viewed() {
 215         // There is no proper API to call or trigger this event, so simulating event
 216         // to check if event returns the right information.
 217
 218         $this->setUp();
 219
 220         $page = $this->wikigenerator->create_first_page($this->wiki);
 221         $context = context_module::instance($this->wiki->cmid);
 222
 223         $params = array(
 224                 'context' => $context,
 225                 'objectid' => $page->id
 226                 );
 227         $event = \mod_wiki\event\page_viewed::create($params);
 228
 229         // Triggering and capturing the event.
 230         $sink = $this->redirectEvents();
 231         $event->trigger();
 232         $events = $sink->get_events();
 233         $this->assertCount(1, $events);
 234         $event = reset($events);
 235
 236         // Checking that the event contains the expected values.
 237         $this->assertInstanceOf('\mod_wiki\event\page_viewed', $event);
 238         $this->assertEquals($context, $event->get_context());
 239         $this->assertEquals($page->id, $event->objectid);
 240         $expected = array($this->course->id, 'wiki', 'view', 'view.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 241         $this->assertEventLegacyLogData($expected, $event);
 242         $this->assertEventContextNotUsed($event);
 243     }
 244
 245     /**
 246      * Test page_viewed event for prettypage view.
 247      */
 248     public function test_pretty_page_viewed() {
 249         // There is no proper API to call or trigger this event, so simulating event
 250         // to check if event returns the right information.
 251
 252         $this->setUp();
 253
 254         $page = $this->wikigenerator->create_first_page($this->wiki);
 255         $context = context_module::instance($this->wiki->cmid);
 256
 257         $params = array(
 258                 'context' => $context,
 259                 'objectid' => $page->id,
 260                 'other' => array('prettyview' => true)
 261                 );
 262         $event = \mod_wiki\event\page_viewed::create($params);
 263
 264         // Triggering and capturing the event.
 265         $sink = $this->redirectEvents();
 266         $event->trigger();
 267         $events = $sink->get_events();
 268         $this->assertCount(1, $events);
 269         $event = reset($events);
 270
 271         // Checking that the event contains the expected values.
 272         $this->assertInstanceOf('\mod_wiki\event\page_viewed', $event);
 273         $this->assertEquals($context, $event->get_context());
 274         $this->assertEquals($page->id, $event->objectid);
 275         $expected = array($this->course->id, 'wiki', 'view', 'prettyview.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 276         $this->assertEventLegacyLogData($expected, $event);
 277         $this->assertEventContextNotUsed($event);
 278     }
 279
 280     /**
 281      * Test page_created event.
 282      */
 283     public function test_page_created() {
 284         global $USER;
 285
 286         $this->setUp();
 287
 288         $context = context_module::instance($this->wiki->cmid);
 289
 290         // Triggering and capturing the event.
 291         $sink = $this->redirectEvents();
 292         $page = $this->wikigenerator->create_first_page($this->wiki);
 293         $events = $sink->get_events();
 294         $this->assertCount(2, $events);
 295         $event = reset($events);
 296
 297         // Checking that the event contains the expected values.
 298         $this->assertInstanceOf('\mod_wiki\event\page_created', $event);
 299         $this->assertEquals($context, $event->get_context());
 300         $this->assertEquals($page->id, $event->objectid);
 301         $expected = array($this->course->id, 'wiki', 'add page',
 302             'view.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 303         $this->assertEventLegacyLogData($expected, $event);
 304         $this->assertEventContextNotUsed($event);
 305     }
 306
 307     /**
 308      * Test page_deleted and page_version_deleted and page_locks_deleted event.
 309      */
 310     public function test_page_deleted() {
 311         global $DB;
 312
 313         $this->setUp();
 314
 315         $page = $this->wikigenerator->create_first_page($this->wiki);
 316         $context = context_module::instance($this->wiki->cmid);
 317         $oldversions = $DB->get_records('wiki_versions', array('pageid' => $page->id));
 318         $oldversion = array_shift($oldversions);
 319
 320         // Triggering and capturing the event.
 321         $sink = $this->redirectEvents();
 322         wiki_delete_pages($context, array($page->id));
 323         $events = $sink->get_events();
 324         $this->assertCount(4, $events);
 325         $event = array_shift($events);
 326
 327         // Checking that the event contains the page_version_deleted event.
 328         $this->assertInstanceOf('\mod_wiki\event\page_version_deleted', $event);
 329         $this->assertEquals($context, $event->get_context());
 330         $this->assertEquals($page->id, $event->other['pageid']);
 331         $this->assertEquals($oldversion->id, $event->objectid);
 332         $expected = array($this->course->id, 'wiki', 'admin', 'admin.php?pageid=' .  $page->id,  $page->id, $this->wiki->cmid);
 333         $this->assertEventLegacyLogData($expected, $event);
 334
 335         // Checking that the event contains the page_deleted event.
 336         $event = array_pop($events);
 337         $this->assertInstanceOf('\mod_wiki\event\page_deleted', $event);
 338         $this->assertEquals($context, $event->get_context());
 339         $this->assertEquals($page->id, $event->objectid);
 340         $expected = array($this->course->id, 'wiki', 'admin', 'admin.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 341         $this->assertEventLegacyLogData($expected, $event);
 342
 343         // Checking that the event contains the expected values.
 344         $event = array_pop($events);
 345         $this->assertInstanceOf('\mod_wiki\event\page_locks_deleted', $event);
 346         $this->assertEquals($context, $event->get_context());
 347         $this->assertEquals($page->id, $event->objectid);
 348         $expected = array($this->course->id, 'wiki', 'overridelocks', 'view.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 349         $this->assertEventLegacyLogData($expected, $event);
 350
 351         // Delete all pages.
 352         $page1 = $this->wikigenerator->create_first_page($this->wiki);
 353         $page2 = $this->wikigenerator->create_content($this->wiki);
 354         $page3 = $this->wikigenerator->create_content($this->wiki, array('title' => 'Custom title'));
 355
 356         // Triggering and capturing the event.
 357         $sink = $this->redirectEvents();
 358         wiki_delete_pages($context, array($page1->id, $page2->id));
 359         $events = $sink->get_events();
 360         $this->assertCount(8, $events);
 361         $event = array_pop($events);
 362
 363         // Checking that the event contains the expected values.
 364         $this->assertInstanceOf('\mod_wiki\event\page_deleted', $event);
 365         $this->assertEquals($context, $event->get_context());
 366         $this->assertEquals($page2->id, $event->objectid);
 367         $expected = array($this->course->id, 'wiki', 'admin', 'admin.php?pageid=' . $page2->id, $page2->id, $this->wiki->cmid);
 368         $this->assertEventLegacyLogData($expected, $event);
 369         $this->assertEventContextNotUsed($event);
 370     }
 371
 372     /**
 373      * Test page_updated event.
 374      */
 375     public function test_page_updated() {
 376         global $USER;
 377
 378         $this->setUp();
 379
 380         $page = $this->wikigenerator->create_first_page($this->wiki);
 381         $context = context_module::instance($this->wiki->cmid);
 382
 383         // Triggering and capturing the event.
 384         $sink = $this->redirectEvents();
 385         wiki_save_page($page, 'New content', $USER->id);
 386         $events = $sink->get_events();
 387         $this->assertCount(1, $events);
 388         $event = reset($events);
 389
 390         // Checking that the event contains the expected values.
 391         $this->assertInstanceOf('\mod_wiki\event\page_updated', $event);
 392         $this->assertEquals($context, $event->get_context());
 393         $this->assertEquals($page->id, $event->objectid);
 394         $expected = array($this->course->id, 'wiki', 'edit',
 395             'view.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 396         $this->assertEventLegacyLogData($expected, $event);
 397         $this->assertEventContextNotUsed($event);
 398     }
 399
 400     /**
 401      * Test page_diff_viewed event.
 402      */
 403     public function test_page_diff_viewed() {
 404         // There is no proper API to call or trigger this event, so simulating event
 405         // to check if event returns the right information.
 406
 407         $this->setUp();
 408
 409         $page = $this->wikigenerator->create_first_page($this->wiki);
 410         $context = context_module::instance($this->wiki->cmid);
 411
 412         $params = array(
 413                 'context' => $context,
 414                 'objectid' => $page->id,
 415                 'other' => array(
 416                     'comparewith' => 1,
 417                     'compare' => 2
 418                     )
 419                 );
 420         $event = \mod_wiki\event\page_diff_viewed::create($params);
 421
 422         // Triggering and capturing the event.
 423         $sink = $this->redirectEvents();
 424         $event->trigger();
 425         $events = $sink->get_events();
 426         $this->assertCount(1, $events);
 427         $event = reset($events);
 428
 429         // Checking that the event contains the expected values.
 430         $this->assertInstanceOf('\mod_wiki\event\page_diff_viewed', $event);
 431         $this->assertEquals($context, $event->get_context());
 432         $this->assertEquals($page->id, $event->objectid);
 433         $expected = array($this->course->id, 'wiki', 'diff', 'diff.php?pageid=' . $page->id . '&comparewith=' .
 434             1 . '&compare=' .  2, $page->id, $this->wiki->cmid);
 435         $this->assertEventLegacyLogData($expected, $event);
 436         $this->assertEventContextNotUsed($event);
 437     }
 438
 439     /**
 440      * Test page_history_viewed event.
 441      */
 442     public function test_page_history_viewed() {
 443         // There is no proper API to call or trigger this event, so simulating event
 444         // to check if event returns the right information.
 445
 446         $this->setUp();
 447
 448         $page = $this->wikigenerator->create_first_page($this->wiki);
 449         $context = context_module::instance($this->wiki->cmid);
 450
 451         $params = array(
 452                 'context' => $context,
 453                 'objectid' => $page->id
 454                 );
 455         $event = \mod_wiki\event\page_history_viewed::create($params);
 456
 457         // Triggering and capturing the event.
 458         $sink = $this->redirectEvents();
 459         $event->trigger();
 460         $events = $sink->get_events();
 461         $this->assertCount(1, $events);
 462         $event = reset($events);
 463
 464         // Checking that the event contains the expected values.
 465         $this->assertInstanceOf('\mod_wiki\event\page_history_viewed', $event);
 466         $this->assertEquals($context, $event->get_context());
 467         $this->assertEquals($page->id, $event->objectid);
 468         $expected = array($this->course->id, 'wiki', 'history', 'history.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 469         $this->assertEventLegacyLogData($expected, $event);
 470         $this->assertEventContextNotUsed($event);
 471     }
 472
 473     /**
 474      * Test page_map_viewed event.
 475      */
 476     public function test_page_map_viewed() {
 477         // There is no proper API to call or trigger this event, so simulating event
 478         // to check if event returns the right information.
 479
 480         $this->setUp();
 481
 482         $page = $this->wikigenerator->create_first_page($this->wiki);
 483         $context = context_module::instance($this->wiki->cmid);
 484
 485         $params = array(
 486                 'context' => $context,
 487                 'objectid' => $page->id,
 488                 'other' => array(
 489                     'option' => 0
 490                     )
 491                 );
 492         $event = \mod_wiki\event\page_map_viewed::create($params);
 493
 494         // Triggering and capturing the event.
 495         $sink = $this->redirectEvents();
 496         $event->trigger();
 497         $events = $sink->get_events();
 498         $this->assertCount(1, $events);
 499         $event = reset($events);
 500
 501         // Checking that the event contains the expected values.
 502         $this->assertInstanceOf('\mod_wiki\event\page_map_viewed', $event);
 503         $this->assertEquals($context, $event->get_context());
 504         $this->assertEquals($page->id, $event->objectid);
 505         $this->assertEquals(0, $event->other['option']);
 506         $expected = array($this->course->id, 'wiki', 'map', 'map.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 507         $this->assertEventLegacyLogData($expected, $event);
 508         $this->assertEventContextNotUsed($event);
 509     }
 510
 511     /**
 512      * Test page_version_viewed event.
 513      */
 514     public function test_page_version_viewed() {
 515         // There is no proper API to call or trigger this event, so simulating event
 516         // to check if event returns the right information.
 517
 518         $this->setUp();
 519
 520         $page = $this->wikigenerator->create_first_page($this->wiki);
 521         $context = context_module::instance($this->wiki->cmid);
 522
 523         $params = array(
 524                 'context' => $context,
 525                 'objectid' => $page->id,
 526                 'other' => array(
 527                     'versionid' => 1
 528                     )
 529                 );
 530         $event = \mod_wiki\event\page_version_viewed::create($params);
 531
 532         // Triggering and capturing the event.
 533         $sink = $this->redirectEvents();
 534         $event->trigger();
 535         $events = $sink->get_events();
 536         $this->assertCount(1, $events);
 537         $event = reset($events);
 538
 539         // Checking that the event contains the expected values.
 540         $this->assertInstanceOf('\mod_wiki\event\page_version_viewed', $event);
 541         $this->assertEquals($context, $event->get_context());
 542         $this->assertEquals($page->id, $event->objectid);
 543         $this->assertEquals(1, $event->other['versionid']);
 544         $expected = array($this->course->id, 'wiki', 'history', 'viewversion.php?pageid=' . $page->id . '&versionid=1',
 545             $page->id, $this->wiki->cmid);
 546         $this->assertEventLegacyLogData($expected, $event);
 547         $this->assertEventContextNotUsed($event);
 548     }
 549
 550     /**
 551      * Test page_version_restored event.
 552      */
 553     public function test_page_version_restored() {
 554         $this->setUp();
 555
 556         $page = $this->wikigenerator->create_first_page($this->wiki);
 557         $context = context_module::instance($this->wiki->cmid);
 558         $version = wiki_get_current_version($page->id);
 559
 560         // Triggering and capturing the event.
 561         $sink = $this->redirectEvents();
 562         wiki_restore_page($page, $version, $context);
 563         $events = $sink->get_events();
 564         $this->assertCount(2, $events);
 565         $event = array_pop($events);
 566
 567         // Checking that the event contains the expected values.
 568         $this->assertInstanceOf('\mod_wiki\event\page_version_restored', $event);
 569         $this->assertEquals($context, $event->get_context());
 570         $this->assertEquals($version->id, $event->objectid);
 571         $this->assertEquals($page->id, $event->other['pageid']);
 572         $expected = array($this->course->id, 'wiki', 'restore', 'view.php?pageid=' . $page->id, $page->id, $this->wiki->cmid);
 573         $this->assertEventLegacyLogData($expected, $event);
 574         $this->assertEventContextNotUsed($event);
 575     }
 576 }