b1961007abdfbeaa25c2fa048b6bc20c6f80a71b
[moodle.git] / webservice / tests / events.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  * Unit tests for Web service events.
19  *
20  * @package    webservice
21  * @category   phpunit
22  * @copyright  2013 Frédéric Massart
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 /**
29  * Unit tests for Web service events.
30  *
31  * @package    webservice
32  * @category   phpunit
33  * @copyright  2013 Frédéric Massart
34  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
35  */
36 class webservice_events_testcase extends advanced_testcase {
38     public function setUp() {
39         $this->resetAfterTest();
40     }
42     public function test_function_called() {
43         // The Web service API doesn't allow the testing of the events directly by
44         // calling some functions which trigger the events, so what we are going here
45         // is just checking that the event returns the expected information.
47         $sink = $this->redirectEvents();
49         $fakelogdata = array(1, 'B', true, null);
50         $params = array(
51             'other' => array(
52                 'function' => 'A function'
53             )
54         );
55         $event = \core\event\webservice_function_called::create($params);
56         $event->set_legacy_logdata($fakelogdata);
57         $event->trigger();
59         $events = $sink->get_events();
60         $this->assertCount(1, $events);
61         $event = reset($events);
63         $this->assertEquals(context_system::instance(), $event->get_context());
64         $this->assertEquals('A function', $event->other['function']);
65         $this->assertEventLegacyLogData($fakelogdata, $event);
66     }
68     public function test_login_failed() {
69         // The Web service API doesn't allow the testing of the events directly by
70         // calling some functions which trigger the events, so what we are going here
71         // is just checking that the event returns the expected information.
73         $sink = $this->redirectEvents();
75         $fakelogdata = array(1, 'B', true, null);
76         $params = array(
77             'other' => array(
78                 'reason' => 'Unit Test',
79                 'method' => 'Some method',
80                 'token' => 'A fake token'
81             )
82         );
83         $event = \core\event\webservice_login_failed::create($params);
84         $event->set_legacy_logdata($fakelogdata);
85         $event->trigger();
87         $events = $sink->get_events();
88         $this->assertCount(1, $events);
89         $event = reset($events);
91         $this->assertEquals(context_system::instance(), $event->get_context());
92         $this->assertEquals($params['other']['reason'], $event->other['reason']);
93         $this->assertEquals($params['other']['method'], $event->other['method']);
94         $this->assertEquals($params['other']['token'], $event->other['token']);
95         $this->assertEventLegacyLogData($fakelogdata, $event);
96     }
98     public function test_service_created() {
99         global $CFG, $DB;
101         // The Web service API doesn't allow the testing of the events directly by
102         // calling some functions which trigger the events, so what we are going here
103         // is just checking that the event returns the expected information.
105         $sink = $this->redirectEvents();
107         // Creating a fake service.
108         $service = (object) array(
109             'name' => 'Test',
110             'enabled' => 1,
111             'requiredcapability' => '',
112             'restrictedusers' => 0,
113             'component' => null,
114             'timecreated' => time(),
115             'timemodified' => time(),
116             'shortname' => null,
117             'downloadfiles' => 0,
118             'uploadfiles' => 0
119         );
120         $service->id = $DB->insert_record('external_services', $service);
122         // Trigger the event.
123         $params = array(
124             'objectid' => $service->id,
125         );
126         $event = \core\event\webservice_service_created::create($params);
127         $event->add_record_snapshot('external_services', $service);
128         $event->trigger();
130         $events = $sink->get_events();
131         $this->assertCount(1, $events);
132         $event = reset($events);
134         // Assert that the event contains the right information.
135         $this->assertEquals(context_system::instance(), $event->get_context());
136         $this->assertEquals($service->id, $event->objectid);
137         $returnurl = $CFG->wwwroot . "/" . $CFG->admin . "/settings.php?section=externalservices";
138         $expected = array(SITEID, 'webservice', 'add', $returnurl, get_string('addservice', 'webservice', $service));
139         $this->assertEventLegacyLogData($expected, $event);
140     }
142     public function test_service_updated() {
143         global $CFG, $DB;
145         // The Web service API doesn't allow the testing of the events directly by
146         // calling some functions which trigger the events, so what we are going here
147         // is just checking that the event returns the expected information.
149         $sink = $this->redirectEvents();
151         // Creating a fake service.
152         $service = (object) array(
153             'name' => 'Test',
154             'enabled' => 1,
155             'requiredcapability' => '',
156             'restrictedusers' => 0,
157             'component' => null,
158             'timecreated' => time(),
159             'timemodified' => time(),
160             'shortname' => null,
161             'downloadfiles' => 0,
162             'uploadfiles' => 0
163         );
164         $service->id = $DB->insert_record('external_services', $service);
166         // Trigger the event.
167         $params = array(
168             'objectid' => $service->id,
169         );
170         $event = \core\event\webservice_service_updated::create($params);
171         $event->add_record_snapshot('external_services', $service);
172         $event->trigger();
174         $events = $sink->get_events();
175         $this->assertCount(1, $events);
176         $event = reset($events);
178         // Assert that the event contains the right information.
179         $this->assertEquals(context_system::instance(), $event->get_context());
180         $this->assertEquals($service->id, $event->objectid);
181         $returnurl = $CFG->wwwroot . "/" . $CFG->admin . "/settings.php?section=externalservices";
182         $expected = array(SITEID, 'webservice', 'edit', $returnurl, get_string('editservice', 'webservice', $service));
183         $this->assertEventLegacyLogData($expected, $event);
184     }
186     public function test_service_deleted() {
187         global $CFG, $DB;
189         // The Web service API doesn't allow the testing of the events directly by
190         // calling some functions which trigger the events, so what we are going here
191         // is just checking that the event returns the expected information.
193         $sink = $this->redirectEvents();
195         // Creating a fake service.
196         $service = (object) array(
197             'name' => 'Test',
198             'enabled' => 1,
199             'requiredcapability' => '',
200             'restrictedusers' => 0,
201             'component' => null,
202             'timecreated' => time(),
203             'timemodified' => time(),
204             'shortname' => null,
205             'downloadfiles' => 0,
206             'uploadfiles' => 0
207         );
208         $service->id = $DB->insert_record('external_services', $service);
210         // Trigger the event.
211         $params = array(
212             'objectid' => $service->id,
213         );
214         $event = \core\event\webservice_service_deleted::create($params);
215         $event->add_record_snapshot('external_services', $service);
216         $event->trigger();
218         $events = $sink->get_events();
219         $this->assertCount(1, $events);
220         $event = reset($events);
222         // Assert that the event contains the right information.
223         $this->assertEquals(context_system::instance(), $event->get_context());
224         $this->assertEquals($service->id, $event->objectid);
225         $returnurl = $CFG->wwwroot . "/" . $CFG->admin . "/settings.php?section=externalservices";
226         $expected = array(SITEID, 'webservice', 'delete', $returnurl, get_string('deleteservice', 'webservice', $service));
227         $this->assertEventLegacyLogData($expected, $event);
228     }
230     public function test_service_user_added() {
231         global $CFG;
233         // The Web service API doesn't allow the testing of the events directly by
234         // calling some functions which trigger the events, so what we are going here
235         // is just checking that the event returns the expected information.
237         $sink = $this->redirectEvents();
239         $params = array(
240             'objectid' => 1,
241             'relateduserid' => 2
242         );
243         $event = \core\event\webservice_service_user_added::create($params);
244         $event->trigger();
246         $events = $sink->get_events();
247         $this->assertCount(1, $events);
248         $event = reset($events);
250         $this->assertEquals(context_system::instance(), $event->get_context());
251         $this->assertEquals(1, $event->objectid);
252         $this->assertEquals(2, $event->relateduserid);
253         $expected = array(SITEID, 'core', 'assign', $CFG->admin . '/webservice/service_users.php?id=' . $params['objectid'],
254             'add', '', $params['relateduserid']);
255         $this->assertEventLegacyLogData($expected, $event);
256     }
258     public function test_service_user_removed() {
259         global $CFG;
261         // The Web service API doesn't allow the testing of the events directly by
262         // calling some functions which trigger the events, so what we are going here
263         // is just checking that the event returns the expected information.
265         $sink = $this->redirectEvents();
267         $params = array(
268             'objectid' => 1,
269             'relateduserid' => 2
270         );
271         $event = \core\event\webservice_service_user_removed::create($params);
272         $event->trigger();
274         $events = $sink->get_events();
275         $this->assertCount(1, $events);
276         $event = reset($events);
278         $this->assertEquals(context_system::instance(), $event->get_context());
279         $this->assertEquals(1, $event->objectid);
280         $this->assertEquals(2, $event->relateduserid);
281         $expected = array(SITEID, 'core', 'assign', $CFG->admin . '/webservice/service_users.php?id=' . $params['objectid'],
282             'remove', '', $params['relateduserid']);
283         $this->assertEventLegacyLogData($expected, $event);
284     }
286     public function test_token_created() {
287         // The Web service API doesn't allow the testing of the events directly by
288         // calling some functions which trigger the events, so what we are going here
289         // is just checking that the event returns the expected information.
291         $sink = $this->redirectEvents();
293         $params = array(
294             'objectid' => 1,
295             'relateduserid' => 2,
296             'other' => array(
297                 'auto' => true
298             )
299         );
300         $event = \core\event\webservice_token_created::create($params);
301         $event->trigger();
303         $events = $sink->get_events();
304         $this->assertCount(1, $events);
305         $event = reset($events);
307         $this->assertEquals(context_system::instance(), $event->get_context());
308         $this->assertEquals(1, $event->objectid);
309         $this->assertEquals(2, $event->relateduserid);
310         $expected = array(SITEID, 'webservice', 'automatically create user token', '' , 'User ID: ' . 2);
311         $this->assertEventLegacyLogData($expected, $event);
312     }
314     public function test_token_sent() {
315         $user = $this->getDataGenerator()->create_user();
316         $this->setUser($user);
318         // The Web service API doesn't allow the testing of the events directly by
319         // calling some functions which trigger the events, so what we are going here
320         // is just checking that the event returns the expected information.
322         $sink = $this->redirectEvents();
324         $params = array(
325             'objectid' => 1,
326             'other' => array(
327                 'auto' => true
328             )
329         );
330         $event = \core\event\webservice_token_sent::create($params);
331         $event->trigger();
333         $events = $sink->get_events();
334         $this->assertCount(1, $events);
335         $event = reset($events);
337         $this->assertEquals(context_system::instance(), $event->get_context());
338         $this->assertEquals(1, $event->objectid);
339         $expected = array(SITEID, 'webservice', 'sending requested user token', '' , 'User ID: ' . $user->id);
340         $this->assertEventLegacyLogData($expected, $event);
341     }