MDL-67673 phpunit: Remove deprecated assertContains() uses on strings
[moodle.git] / calendar / 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/>.
17 /**
18  * This file contains the class that handles testing of the calendar events.
19  *
20  * @package core_calendar
21  * @copyright 2014 Ankit Agarwal <ankit.agrr@gmail.com>
22  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 defined('MOODLE_INTERNAL') || die();
26 global $CFG;
27 require_once($CFG->dirroot . '/calendar/tests/externallib_test.php');
29 /**
30  * This file contains the class that handles testing of the calendar events.
31  *
32  * @package core_calendar
33  * @copyright 2014 Ankit Agarwal <ankit.agrr@gmail.com>
34  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
35  */
36 class core_calendar_events_testcase extends advanced_testcase {
38     /**
39      * The test user.
40      */
41     private $user;
43     /**
44      * The test course.
45      */
46     private $course;
48     /**
49      * Test set up.
50      */
51     protected function setUp(): void {
52         global $USER;
53         // The user we are going to test this on.
54         $this->setAdminUser();
55         $this->user = $USER;
56         $this->course = self::getDataGenerator()->create_course();
57     }
59     /**
60      * Tests for calendar_event_created event.
61      */
62     public function test_calendar_event_created() {
64         $this->resetAfterTest();
66         // Catch the events.
67         $sink = $this->redirectEvents();
69         // Create a calendar event.
70         $record = new stdClass();
71         $record->courseid = 0;
72         $time = time();
73         $calevent = core_calendar_externallib_testcase::create_calendar_event('event', $this->user->id, 'user', 0, $time,
74                 $record); // User event.
76         // Capture the event.
77         $events = $sink->get_events();
78         $sink->clear();
80         // Validate the event.
81         $event = $events[0];
82         $this->assertInstanceOf('\core\event\calendar_event_created', $event);
83         $this->assertEquals('event', $event->objecttable);
84         $this->assertEquals(0, $event->courseid);
85         $this->assertEquals($calevent->context, $event->get_context());
86         $expectedlog = array(0, 'calendar', 'add', 'event.php?action=edit&amp;id=' . $calevent->id , $calevent->name);
87         $other = array('repeatid' => 0, 'timestart' => $time, 'name' => 'event');
88         $this->assertEquals($other, $event->other);
89         $this->assertEventLegacyLogData($expectedlog, $event);
90         $this->assertEventContextNotUsed($event);
92         // Now we create a repeated course event.
93         $record = new stdClass();
94         $record->courseid = $this->course->id;
95         $calevent = core_calendar_externallib_testcase::create_calendar_event('course', $this->user->id, 'course', 10, $time,
96                 $record);
97         $events = $sink->get_events();
98         $sink->close();
100         $this->assertEquals(10, count($events));
101         foreach ($events as $event) {
102             $this->assertInstanceOf('\core\event\calendar_event_created', $event);
103             $this->assertEquals('event', $event->objecttable);
104             $this->assertEquals($this->course->id, $event->courseid);
105             $this->assertEquals($calevent->context, $event->get_context());
106         }
107     }
109     /**
110      * Tests for event validations related to calendar_event_created event.
111      */
112     public function test_calendar_event_created_validations() {
113         $this->resetAfterTest();
114         $context = context_user::instance($this->user->id);
116         // Test not setting other['repeatid'].
117         try {
118             \core\event\calendar_event_created::create(array(
119                 'context'  => $context,
120                 'objectid' => 2,
121                 'other' => array(
122                     'timestart' => time(),
123                     'name' => 'event'
124                 )
125             ));
126             $this->fail("Event validation should not allow \\core\\event\\calendar_event_created to be triggered without
127                     other['repeatid']");
128         } catch (coding_exception $e) {
129             $this->assertStringContainsString('The \'repeatid\' value must be set in other.', $e->getMessage());
130         }
132         // Test not setting other['name'].
133         try {
134             \core\event\calendar_event_created::create(array(
135                 'context'  => $context,
136                 'objectid' => 2,
137                 'other' => array(
138                     'repeatid' => 0,
139                     'timestart' => time(),
140                 )
141             ));
142             $this->fail("Event validation should not allow \\core\\event\\calendar_event_created to be triggered without
143                     other['name']");
144         } catch (coding_exception $e) {
145             $this->assertStringContainsString('The \'name\' value must be set in other.', $e->getMessage());
146         }
148         // Test not setting other['timestart'].
149         try {
150             \core\event\calendar_event_created::create(array(
151                 'context'  => $context,
152                 'objectid' => 2,
153                 'other' => array(
154                     'name' => 'event',
155                     'repeatid' => 0,
156                 )
157             ));
158             $this->fail("Event validation should not allow \\core\\event\\calendar_event_deleted to be triggered without
159                     other['timestart']");
160         } catch (coding_exception $e) {
161             $this->assertStringContainsString('The \'timestart\' value must be set in other.', $e->getMessage());
162         }
163     }
165     /**
166      * Tests for calendar_event_updated event.
167      */
168     public function test_calendar_event_updated() {
170         $this->resetAfterTest();
172         // Create a calendar event.
173         $record = new stdClass();
174         $record->courseid = 0;
175         $time = time();
176         $calevent = core_calendar_externallib_testcase::create_calendar_event('event', $this->user->id, 'user', 0, $time,
177                 $record); // User event.
179         // Catch the events.
180         $sink = $this->redirectEvents();
181         $prop = new stdClass();
182         $prop->name = 'new event';
183         $calevent->update($prop); // Update calender event.
184         // Capture the event.
185         $events = $sink->get_events();
187         // Validate the event.
188         $event = $events[0];
189         $this->assertInstanceOf('\core\event\calendar_event_updated', $event);
190         $this->assertEquals('event', $event->objecttable);
191         $this->assertEquals(0, $event->courseid);
192         $this->assertEquals($calevent->context, $event->get_context());
193         $expectedlog = array(0, 'calendar', 'edit', 'event.php?action=edit&amp;id=' . $calevent->id , $calevent->name);
194         $this->assertEventLegacyLogData($expectedlog, $event);
195         $other = array('repeatid' => 0, 'timestart' => $time, 'name' => 'new event');
196         $this->assertEquals($other, $event->other);
197         $this->assertEventContextNotUsed($event);
199         // Now we create a repeated course event and update it.
200         $record = new stdClass();
201         $record->courseid = $this->course->id;
202         $calevent = core_calendar_externallib_testcase::create_calendar_event('course', $this->user->id, 'course', 10, time(),
203                 $record);
205         $sink->clear();
206         $prop = new stdClass();
207         $prop->name = 'new event';
208         $prop->repeateditall = true;
209         $calevent->update($prop); // Update calender event.
210         $events = $sink->get_events();
211         $sink->close();
213         $this->assertEquals(10, count($events));
214         foreach ($events as $event) {
215             $this->assertInstanceOf('\core\event\calendar_event_updated', $event);
216             $this->assertEquals('event', $event->objecttable);
217             $this->assertEquals($this->course->id, $event->courseid);
218             $this->assertEquals($calevent->context, $event->get_context());
219         }
220     }
222     /**
223      * Tests for calendar_event_updated event.
224      */
225     public function test_calendar_event_updated_toggle_visibility() {
226         global $DB, $SITE;
228         $this->resetAfterTest();
230         // Create a calendar event.
231         $time = time();
232         $calevent = core_calendar_externallib_testcase::create_calendar_event('Some wickedly awesome event yo!',
233             $this->user->id, 'user', 0, $time);
235         // Updated the visibility of the calendar event.
236         $sink = $this->redirectEvents();
237         $calevent->toggle_visibility();
238         $dbrecord = $DB->get_record('event', array('id' => $calevent->id), '*', MUST_EXIST);
239         $events = $sink->get_events();
241         // Validate the calendar_event_updated event.
242         $event = $events[0];
243         $this->assertInstanceOf('\core\event\calendar_event_updated', $event);
244         $this->assertEquals('event', $event->objecttable);
245         $this->assertEquals($SITE->id, $event->courseid);
246         $this->assertEquals($calevent->context, $event->get_context());
247         $expectedlog = array($SITE->id, 'calendar', 'edit', 'event.php?action=edit&amp;id=' . $calevent->id ,
248             $calevent->name);
249         $this->assertEventLegacyLogData($expectedlog, $event);
250         $other = array('repeatid' => 0, 'timestart' => $time, 'name' => 'Some wickedly awesome event yo!');
251         $this->assertEquals($other, $event->other);
252         $this->assertEventContextNotUsed($event);
253         $this->assertEquals($dbrecord, $event->get_record_snapshot('event', $event->objectid));
255     }
257     /**
258      * Tests for event validations related to calendar_event_created event.
259      */
260     public function test_calendar_event_updated_validations() {
261         $this->resetAfterTest();
262         $context = context_user::instance($this->user->id);
264         // Test not setting other['repeatid'].
265         try {
266             \core\event\calendar_event_updated::create(array(
267                 'context'  => $context,
268                 'objectid' => 2,
269                 'other' => array(
270                     'timestart' => time(),
271                     'name' => 'event'
272                 )
273             ));
274             $this->fail("Event validation should not allow \\core\\event\\calendar_event_updated to be triggered without
275                     other['repeatid']");
276         } catch (coding_exception $e) {
277             $this->assertStringContainsString('The \'repeatid\' value must be set in other.', $e->getMessage());
278         }
280         // Test not setting other['name'].
281         try {
282             \core\event\calendar_event_updated::create(array(
283                 'context'  => $context,
284                 'objectid' => 2,
285                 'other' => array(
286                     'repeatid' => 0,
287                     'timestart' => time(),
288                 )
289             ));
290             $this->fail("Event validation should not allow \\core\\event\\calendar_event_updated to be triggered without
291                     other['name']");
292         } catch (coding_exception $e) {
293             $this->assertStringContainsString('The \'name\' value must be set in other.', $e->getMessage());
294         }
296         // Test not setting other['timestart'].
297         try {
298             \core\event\calendar_event_updated::create(array(
299                 'context'  => $context,
300                 'objectid' => 2,
301                 'other' => array(
302                     'name' => 'event',
303                     'repeatid' => 0,
304                 )
305             ));
306             $this->fail("Event validation should not allow \\core\\event\\calendar_event_deleted to be triggered without
307                     other['timestart']");
308         } catch (coding_exception $e) {
309             $this->assertStringContainsString('The \'timestart\' value must be set in other.', $e->getMessage());
310         }
311     }
313     /**
314      * Tests for calendar_event_deleted event.
315      */
316     public function test_calendar_event_deleted() {
317         global $DB;
319         $this->resetAfterTest();
321         // Create a calendar event.
322         $record = new stdClass();
323         $record->courseid = 0;
324         $record->repeatid = 0;
325         $time = time();
326         $calevent = core_calendar_externallib_testcase::create_calendar_event('event', $this->user->id, 'user', 0, $time,
327             $record); // User event.
328         $dbrecord = $DB->get_record('event', array('id' => $calevent->id), '*', MUST_EXIST);
330         // Catch the events.
331         $sink = $this->redirectEvents();
332         $calevent->delete(false);
333         $events = $sink->get_events();
335         // Validate the event.
336         $event = $events[0];
337         $this->assertInstanceOf('\core\event\calendar_event_deleted', $event);
338         $this->assertEquals('event', $event->objecttable);
339         $this->assertEquals(0, $event->courseid);
340         $this->assertEquals($calevent->context, $event->get_context());
341         $other = array('repeatid' => 0, 'timestart' => $time, 'name' => 'event');
342         $this->assertEquals($other, $event->other);
343         $this->assertEventContextNotUsed($event);
344         $this->assertEquals($dbrecord, $event->get_record_snapshot('event', $event->objectid));
346         // Now we create a repeated course event and delete it.
347         $record = new stdClass();
348         $record->courseid = $this->course->id;
349         $calevent = core_calendar_externallib_testcase::create_calendar_event('course', $this->user->id, 'course', 10, time(),
350             $record);
352         $sink->clear();
353         $prop = new stdClass();
354         $prop->name = 'new event';
355         $prop->repeateditall = true;
356         $calevent->delete(true);
357         $events = $sink->get_events();
358         $sink->close();
360         $this->assertEquals(10, count($events));
361         foreach ($events as $event) {
362             $this->assertInstanceOf('\core\event\calendar_event_deleted', $event);
363             $this->assertEquals('event', $event->objecttable);
364             $this->assertEquals($this->course->id, $event->courseid);
365             $this->assertEquals($calevent->context, $event->get_context());
366         }
367     }
369     /**
370      * Tests for event validations related to calendar_event_deleted event.
371      */
372     public function test_calendar_event_deleted_validations() {
373         $this->resetAfterTest();
374         $context = context_user::instance($this->user->id);
376         // Test not setting other['repeatid'].
377         try {
378             \core\event\calendar_event_deleted::create(array(
379                 'context'  => $context,
380                 'objectid' => 2,
381                 'other' => array(
382                     'timestart' => time(),
383                     'name' => 'event'
384                 )
385             ));
386             $this->fail("Event validation should not allow \\core\\event\\calendar_event_deleted to be triggered without
387                     other['repeatid']");
388         } catch (coding_exception $e) {
389             $this->assertStringContainsString('The \'repeatid\' value must be set in other.', $e->getMessage());
390         }
392         // Test not setting other['name'].
393         try {
394             \core\event\calendar_event_deleted::create(array(
395                 'context'  => $context,
396                 'objectid' => 2,
397                 'other' => array(
398                     'repeatid' => 0,
399                     'timestart' => time(),
400                 )
401             ));
402             $this->fail("Event validation should not allow \\core\\event\\calendar_event_deleted to be triggered without
403                     other['name']");
404         } catch (coding_exception $e) {
405             $this->assertStringContainsString('The \'name\' value must be set in other.', $e->getMessage());
406         }
408         // Test not setting other['timestart'].
409         try {
410             \core\event\calendar_event_deleted::create(array(
411                 'context'  => $context,
412                 'objectid' => 2,
413                 'other' => array(
414                     'name' => 'event',
415                     'repeatid' => 0,
416                 )
417             ));
418             $this->fail("Event validation should not allow \\core\\event\\calendar_event_deleted to be triggered without
419                     other['timestart']");
420         } catch (coding_exception $e) {
421             $this->assertStringContainsString('The \'timestart\' value must be set in other.', $e->getMessage());
422         }
423     }
425     /**
426      * Tests for calendar_subscription_added event for a site subscription.
427      */
428     public function test_calendar_subscription_created_site() {
429         global $CFG;
430         require_once($CFG->dirroot . '/calendar/lib.php');
431         $this->resetAfterTest(true);
433         // Create a mock subscription.
434         $subscription = new stdClass();
435         $subscription->eventtype = 'site';
436         $subscription->name = 'test';
437         $subscription->courseid = $this->course->id;
439         // Trigger and capture the event.
440         $sink = $this->redirectEvents();
441         $id = calendar_add_subscription($subscription);
443         $events = $sink->get_events();
444         $event = reset($events);
445         // Check that the event data is valid.
446         $this->assertInstanceOf('\core\event\calendar_subscription_created', $event);
447         $this->assertEquals($id, $event->objectid);
448         $this->assertEquals($subscription->courseid, $event->other['courseid']);
449         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
450         $this->assertArrayNotHasKey('categoryid', $event->other);
451         $this->assertArrayNotHasKey('groupid', $event->other);
452         $this->assertDebuggingNotCalled();
453         $sink->close();
454     }
456     /**
457      * Tests for calendar_subscription_added event for a category subscription.
458      */
459     public function test_calendar_subscription_created_category() {
460         global $CFG;
461         require_once($CFG->dirroot . '/calendar/lib.php');
462         $this->resetAfterTest(true);
464         $categoryid = $this->course->category;
466         // Create a mock subscription.
467         $subscription = new stdClass();
468         $subscription->eventtype = 'category';
469         $subscription->name = 'test';
470         $subscription->categoryid = $categoryid;
472         // Trigger and capture the event.
473         $sink = $this->redirectEvents();
474         $id = calendar_add_subscription($subscription);
476         $events = $sink->get_events();
477         $event = reset($events);
478         // Check that the event data is valid.
479         $this->assertInstanceOf('\core\event\calendar_subscription_created', $event);
480         $this->assertEquals($id, $event->objectid);
481         $this->assertEquals($categoryid, $event->other['categoryid']);
482         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
483         $this->assertArrayNotHasKey('courseid', $event->other);
484         $this->assertArrayNotHasKey('groupid', $event->other);
485         $this->assertDebuggingNotCalled();
486         $sink->close();
487     }
489     /**
490      * Tests for calendar_subscription_added event for a course subscription.
491      */
492     public function test_calendar_subscription_created_course() {
493         global $CFG;
494         require_once($CFG->dirroot . '/calendar/lib.php');
495         $this->resetAfterTest(true);
497         // Create a mock subscription.
498         $subscription = new stdClass();
499         $subscription->eventtype = 'course';
500         $subscription->name = 'test';
501         $subscription->courseid = $this->course->id;
503         // Trigger and capture the event.
504         $sink = $this->redirectEvents();
505         $id = calendar_add_subscription($subscription);
507         $events = $sink->get_events();
508         $event = reset($events);
509         // Check that the event data is valid.
510         $this->assertInstanceOf('\core\event\calendar_subscription_created', $event);
511         $this->assertEquals($id, $event->objectid);
512         $this->assertEquals($subscription->courseid, $event->other['courseid']);
513         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
514         $this->assertArrayNotHasKey('categoryid', $event->other);
515         $this->assertArrayNotHasKey('groupid', $event->other);
516         $this->assertDebuggingNotCalled();
517         $sink->close();
519     }
521     /**
522      * Tests for calendar_subscription_added event for a group subscription.
523      */
524     public function test_calendar_subscription_created_group() {
525         global $CFG;
526         require_once($CFG->dirroot . '/calendar/lib.php');
527         $this->resetAfterTest(true);
529         $courseid = $this->course->id;
530         $groupid = 42;
532         // Create a mock subscription.
533         $subscription = new stdClass();
534         $subscription->eventtype = 'group';
535         $subscription->name = 'test';
536         $subscription->courseid = $courseid;
537         $subscription->groupid = $groupid;
539         // Trigger and capture the event.
540         $sink = $this->redirectEvents();
541         $id = calendar_add_subscription($subscription);
543         $events = $sink->get_events();
544         $event = reset($events);
545         // Check that the event data is valid.
546         $this->assertInstanceOf('\core\event\calendar_subscription_created', $event);
547         $this->assertEquals($id, $event->objectid);
548         $this->assertEquals($courseid, $event->other['courseid']);
549         $this->assertEquals($groupid, $event->other['groupid']);
550         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
551         $this->assertArrayNotHasKey('categoryid', $event->other);
552         $this->assertDebuggingNotCalled();
553         $sink->close();
554     }
556     /**
557      * Tests for calendar_subscription_updated event for a site subscription.
558      */
559     public function test_calendar_subscription_updated_site() {
560         global $CFG;
561         require_once($CFG->dirroot . '/calendar/lib.php');
562         $this->resetAfterTest(true);
564         // Create a mock subscription.
565         $subscription = new stdClass();
566         $subscription->eventtype = 'site';
567         $subscription->name = 'test';
568         $subscription->courseid = $this->course->id;
569         $subscription->id = calendar_add_subscription($subscription);
570         // Now edit it.
571         $subscription->name = 'awesome';
573         // Trigger and capture the event.
574         $sink = $this->redirectEvents();
575         calendar_update_subscription($subscription);
576         $events = $sink->get_events();
577         $event = reset($events);
578         // Check that the event data is valid.
579         $this->assertInstanceOf('\core\event\calendar_subscription_updated', $event);
580         $this->assertEquals($subscription->id, $event->objectid);
581         $this->assertEquals($subscription->courseid, $event->other['courseid']);
582         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
583         $this->assertArrayNotHasKey('categoryid', $event->other);
584         $this->assertArrayNotHasKey('groupid', $event->other);
585         $this->assertDebuggingNotCalled();
586         $sink->close();
587     }
589     /**
590      * Tests for calendar_subscription_updated event for a category subscription.
591      */
592     public function test_calendar_subscription_updated_category() {
593         global $CFG;
594         require_once($CFG->dirroot . '/calendar/lib.php');
595         $this->resetAfterTest(true);
597         $categoryid = $this->course->category;
599         // Create a mock subscription.
600         $subscription = new stdClass();
601         $subscription->eventtype = 'category';
602         $subscription->name = 'test';
603         $subscription->categoryid = $categoryid;
604         $subscription->id = calendar_add_subscription($subscription);
605         // Now edit it.
606         $subscription->name = 'awesome';
608         // Trigger and capture the event.
609         $sink = $this->redirectEvents();
610         calendar_update_subscription($subscription);
611         $events = $sink->get_events();
612         $event = reset($events);
613         // Check that the event data is valid.
614         $this->assertInstanceOf('\core\event\calendar_subscription_updated', $event);
615         $this->assertEquals($subscription->id, $event->objectid);
616         $this->assertEquals($categoryid, $event->other['categoryid']);
617         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
618         $this->assertArrayNotHasKey('courseid', $event->other);
619         $this->assertArrayNotHasKey('groupid', $event->other);
620         $this->assertDebuggingNotCalled();
621         $sink->close();
622     }
624     /**
625      * Tests for calendar_subscription_updated event for a group subscription.
626      */
627     public function test_calendar_subscription_updated_course() {
628         global $CFG;
629         require_once($CFG->dirroot . '/calendar/lib.php');
630         $this->resetAfterTest(true);
632         // Create a mock subscription.
633         $subscription = new stdClass();
634         $subscription->eventtype = 'course';
635         $subscription->name = 'test';
636         $subscription->courseid = $this->course->id;
637         $subscription->id = calendar_add_subscription($subscription);
638         // Now edit it.
639         $subscription->name = 'awesome';
641         // Trigger and capture the event.
642         $sink = $this->redirectEvents();
643         calendar_update_subscription($subscription);
644         $events = $sink->get_events();
645         $event = reset($events);
646         // Check that the event data is valid.
647         $this->assertInstanceOf('\core\event\calendar_subscription_updated', $event);
648         $this->assertEquals($subscription->id, $event->objectid);
649         $this->assertEquals($this->course->id, $event->other['courseid']);
650         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
651         $this->assertArrayNotHasKey('categoryid', $event->other);
652         $this->assertArrayNotHasKey('groupid', $event->other);
653         $this->assertDebuggingNotCalled();
654         $sink->close();
655     }
657     /**
658      * Tests for calendar_subscription_updated event for a course subscription.
659      */
660     public function test_calendar_subscription_updated_group() {
661         global $CFG;
662         require_once($CFG->dirroot . '/calendar/lib.php');
663         $this->resetAfterTest(true);
665         $courseid = $this->course->id;
666         $groupid = 42;
668         // Create a mock subscription.
669         $subscription = new stdClass();
670         $subscription->eventtype = 'group';
671         $subscription->name = 'test';
672         $subscription->courseid = $courseid;
673         $subscription->groupid = $groupid;
675         $subscription->id = calendar_add_subscription($subscription);
676         // Now edit it.
677         $subscription->name = 'awesome';
679         // Trigger and capture the event.
680         $sink = $this->redirectEvents();
681         calendar_update_subscription($subscription);
682         $events = $sink->get_events();
683         $event = reset($events);
684         // Check that the event data is valid.
685         $this->assertInstanceOf('\core\event\calendar_subscription_updated', $event);
686         $this->assertEquals($subscription->id, $event->objectid);
687         $this->assertEquals($this->course->id, $event->other['courseid']);
688         $this->assertEquals($groupid, $event->other['groupid']);
689         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
690         $this->assertArrayNotHasKey('categoryid', $event->other);
691         $this->assertDebuggingNotCalled();
692         $sink->close();
693     }
695     /**
696      * Tests for calendar_subscription_deleted event for a site subscription.
697      */
698     public function test_calendar_subscription_deleted_site() {
699         global $CFG;
700         require_once($CFG->dirroot . '/calendar/lib.php');
701         $this->resetAfterTest(true);
703         // Create a mock subscription.
704         $subscription = new stdClass();
705         $subscription->eventtype = 'site';
706         $subscription->name = 'test';
707         $subscription->courseid = $this->course->id;
708         $subscription->id = calendar_add_subscription($subscription);
710         // Trigger and capture the event.
711         $sink = $this->redirectEvents();
712         calendar_delete_subscription($subscription);
713         $events = $sink->get_events();
714         $event = reset($events);
715         // Check that the event data is valid.
716         $this->assertInstanceOf('\core\event\calendar_subscription_deleted', $event);
717         $this->assertEquals($subscription->id, $event->objectid);
718         $this->assertEquals($subscription->courseid, $event->other['courseid']);
719         $this->assertDebuggingNotCalled();
720         $sink->close();
722     }
724     /**
725      * Tests for calendar_subscription_deleted event for a category subscription.
726      */
727     public function test_calendar_subscription_deleted_category() {
728         global $CFG;
729         require_once($CFG->dirroot . '/calendar/lib.php');
730         $this->resetAfterTest(true);
732         $categoryid = $this->course->category;
734         // Create a mock subscription.
735         $subscription = new stdClass();
736         $subscription->eventtype = 'category';
737         $subscription->name = 'test';
738         $subscription->categoryid = $categoryid;
739         $subscription->id = calendar_add_subscription($subscription);
741         // Trigger and capture the event.
742         $sink = $this->redirectEvents();
743         calendar_delete_subscription($subscription);
744         $events = $sink->get_events();
745         $event = reset($events);
746         // Check that the event data is valid.
747         $this->assertInstanceOf('\core\event\calendar_subscription_deleted', $event);
748         $this->assertEquals($subscription->id, $event->objectid);
749         $this->assertEquals($categoryid, $event->other['categoryid']);
750         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
751         $this->assertArrayNotHasKey('courseid', $event->other);
752         $this->assertArrayNotHasKey('groupid', $event->other);
753         $this->assertDebuggingNotCalled();
754         $sink->close();
755     }
757     /**
758      * Tests for calendar_subscription_deleted event for a course.
759      */
760     public function test_calendar_subscription_deleted_course() {
761         global $CFG;
762         require_once($CFG->dirroot . '/calendar/lib.php');
763         $this->resetAfterTest(true);
765         // Create a mock subscription.
766         $subscription = new stdClass();
767         $subscription->eventtype = 'course';
768         $subscription->name = 'test';
769         $subscription->courseid = $this->course->id;
770         $subscription->id = calendar_add_subscription($subscription);
772         // Trigger and capture the event.
773         $sink = $this->redirectEvents();
774         calendar_delete_subscription($subscription);
775         $events = $sink->get_events();
776         $event = reset($events);
777         // Check that the event data is valid.
778         $this->assertInstanceOf('\core\event\calendar_subscription_deleted', $event);
779         $this->assertEquals($subscription->id, $event->objectid);
780         $this->assertEquals($this->course->id, $event->other['courseid']);
781         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
782         $this->assertArrayNotHasKey('categoryid', $event->other);
783         $this->assertArrayNotHasKey('groupid', $event->other);
784         $this->assertDebuggingNotCalled();
785         $sink->close();
786     }
788     /**
789      * Tests for calendar_subscription_deleted event for a group.
790      */
791     public function test_calendar_subscription_deleted_group() {
792         global $CFG;
793         require_once($CFG->dirroot . '/calendar/lib.php');
794         $this->resetAfterTest(true);
796         $courseid = $this->course->id;
797         $groupid = 42;
799         // Create a mock subscription.
800         $subscription = new stdClass();
801         $subscription->eventtype = 'group';
802         $subscription->name = 'test';
803         $subscription->groupid = $groupid;
804         $subscription->courseid = $courseid;
805         $subscription->id = calendar_add_subscription($subscription);
807         // Trigger and capture the event.
808         $sink = $this->redirectEvents();
809         calendar_delete_subscription($subscription);
810         $events = $sink->get_events();
811         $event = reset($events);
812         // Check that the event data is valid.
813         $this->assertInstanceOf('\core\event\calendar_subscription_deleted', $event);
814         $this->assertEquals($subscription->id, $event->objectid);
815         $this->assertEquals($this->course->id, $event->other['courseid']);
816         $this->assertEquals($groupid, $event->other['groupid']);
817         $this->assertEquals($subscription->eventtype, $event->other['eventtype']);
818         $this->assertArrayNotHasKey('categoryid', $event->other);
819         $this->assertDebuggingNotCalled();
820         $sink->close();
821     }