Commit | Line | Data |
---|---|---|
77105132 JD |
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 | * Testing the service layer within core_favourites. | |
19 | * | |
20 | * @package core_favourites | |
21 | * @category test | |
22 | * @copyright 2018 Jake Dallimore <jrhdallimore@gmail.com> | |
23 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
24 | */ | |
25 | ||
26 | defined('MOODLE_INTERNAL') || die(); | |
27 | ||
28 | /** | |
29 | * Test class covering the user_favourites_service within the service layer of favourites. | |
30 | * | |
31 | * @copyright 2018 Jake Dallimore <jrhdallimore@gmail.com> | |
32 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
33 | */ | |
34 | class user_favourites_service_testcase extends advanced_testcase { | |
35 | ||
36 | public function setUp() { | |
37 | $this->resetAfterTest(); | |
38 | } | |
39 | ||
40 | // Basic setup stuff to be reused in most tests. | |
41 | protected function setup_users_and_courses() { | |
42 | $user1 = self::getDataGenerator()->create_user(); | |
43 | $user1context = \context_user::instance($user1->id); | |
44 | $user2 = self::getDataGenerator()->create_user(); | |
45 | $user2context = \context_user::instance($user2->id); | |
46 | $course1 = self::getDataGenerator()->create_course(); | |
47 | $course2 = self::getDataGenerator()->create_course(); | |
48 | $course1context = context_course::instance($course1->id); | |
49 | $course2context = context_course::instance($course2->id); | |
50 | return [$user1context, $user2context, $course1context, $course2context]; | |
51 | } | |
52 | ||
53 | /** | |
54 | * Generates an in-memory repository for testing, using an array store for CRUD stuff. | |
55 | * | |
56 | * @param array $mockstore | |
57 | * @return \PHPUnit\Framework\MockObject\MockObject | |
58 | */ | |
59 | protected function get_mock_repository(array $mockstore) { | |
60 | // This mock will just store data in an array. | |
4a02aae5 | 61 | $mockrepo = $this->getMockBuilder(\core_favourites\local\repository\ifavourites_repository::class) |
77105132 JD |
62 | ->setMethods([]) |
63 | ->getMock(); | |
64 | $mockrepo->expects($this->any()) | |
65 | ->method('add') | |
66 | ->will($this->returnCallback(function(\stdclass $favourite) use (&$mockstore) { | |
67 | // Mock implementation of repository->add(), where an array is used instead of the DB. | |
68 | // Duplicates are confirmed via the unique key, and exceptions thrown just like a real repo. | |
69 | $key = $favourite->userid . $favourite->component . $favourite->itemtype . $favourite->itemid | |
70 | . $favourite->contextid; | |
71 | ||
72 | // Check the objects for the unique key. | |
73 | foreach ($mockstore as $item) { | |
74 | if ($item->uniquekey == $key) { | |
75 | throw new \moodle_exception('Favourite already exists'); | |
76 | } | |
77 | } | |
78 | $index = count($mockstore); // Integer index. | |
79 | $favourite->uniquekey = $key; // Simulate the unique key constraint. | |
80 | $favourite->id = $index; | |
81 | $mockstore[$index] = $favourite; | |
82 | return $mockstore[$index]; | |
83 | }) | |
84 | ); | |
85 | $mockrepo->expects($this->any()) | |
86 | ->method('find_by') | |
8ffbe9c1 | 87 | ->will($this->returnCallback(function(array $criteria, int $limitfrom = 0, int $limitnum = 0) use (&$mockstore) { |
77105132 JD |
88 | // Check the mockstore for all objects with properties matching the key => val pairs in $criteria. |
89 | foreach ($mockstore as $index => $mockrow) { | |
90 | $mockrowarr = (array)$mockrow; | |
91 | if (array_diff($criteria, $mockrowarr) == []) { | |
92 | $returns[$index] = $mockrow; | |
93 | } | |
94 | } | |
8ffbe9c1 JD |
95 | // Return a subset of the records, according to the paging options, if set. |
96 | if ($limitnum != 0) { | |
97 | return array_slice($returns, $limitfrom, $limitnum); | |
98 | } | |
99 | // Otherwise, just return the full set. | |
77105132 JD |
100 | return $returns; |
101 | }) | |
102 | ); | |
103 | $mockrepo->expects($this->any()) | |
104 | ->method('find_favourite') | |
105 | ->will($this->returnCallback(function(int $userid, string $comp, string $type, int $id, int $ctxid) use (&$mockstore) { | |
106 | // Check the mockstore for all objects with properties matching the key => val pairs in $criteria. | |
107 | $crit = ['userid' => $userid, 'component' => $comp, 'itemtype' => $type, 'itemid' => $id, 'contextid' => $ctxid]; | |
108 | foreach ($mockstore as $fakerow) { | |
109 | $fakerowarr = (array)$fakerow; | |
110 | if (array_diff($crit, $fakerowarr) == []) { | |
111 | return $fakerow; | |
112 | } | |
113 | } | |
114 | throw new \moodle_exception("Item not found"); | |
115 | }) | |
116 | ); | |
117 | $mockrepo->expects($this->any()) | |
118 | ->method('find') | |
119 | ->will($this->returnCallback(function(int $id) use (&$mockstore) { | |
120 | return $mockstore[$id]; | |
121 | }) | |
122 | ); | |
123 | $mockrepo->expects($this->any()) | |
124 | ->method('exists') | |
125 | ->will($this->returnCallback(function(int $id) use (&$mockstore) { | |
126 | return array_key_exists($id, $mockstore); | |
127 | }) | |
128 | ); | |
129 | $mockrepo->expects($this->any()) | |
130 | ->method('delete') | |
131 | ->will($this->returnCallback(function(int $id) use (&$mockstore) { | |
132 | foreach ($mockstore as $mockrow) { | |
133 | if ($mockrow->id == $id) { | |
134 | unset($mockstore[$id]); | |
135 | } | |
136 | } | |
137 | }) | |
138 | ); | |
139 | return $mockrepo; | |
140 | } | |
141 | ||
142 | /** | |
143 | * Test getting a user_favourites_service from the static locator. | |
144 | */ | |
145 | public function test_get_service_for_user_context() { | |
146 | list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses(); | |
147 | $userservice = \core_favourites\services::get_service_for_user_context($user1context); | |
4a02aae5 | 148 | $this->assertInstanceOf(\core_favourites\local\service\user_favourites_service::class, $userservice); |
77105132 JD |
149 | } |
150 | ||
151 | /** | |
152 | * Test confirming an item can be favourited only once. | |
153 | */ | |
154 | public function test_create_favourite_basic() { | |
155 | list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses(); | |
156 | ||
157 | // Get a user_favourites_service for a user. | |
158 | $repo = $this->get_mock_repository([]); // Mock repository, using the array as a mock DB. | |
4a02aae5 | 159 | $user1service = new \core_favourites\local\service\user_favourites_service($user1context, $repo); |
77105132 JD |
160 | |
161 | // Favourite a course. | |
162 | $favourite1 = $user1service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context); | |
163 | $this->assertObjectHasAttribute('id', $favourite1); | |
164 | ||
165 | // Try to favourite the same course again. | |
166 | $this->expectException('moodle_exception'); | |
167 | $user1service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context); | |
168 | } | |
169 | ||
170 | /** | |
171 | * Test confirming that an exception is thrown if trying to favourite an item for a non-existent component. | |
172 | */ | |
173 | public function test_create_favourite_nonexistent_component() { | |
174 | list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses(); | |
175 | ||
176 | // Get a user_favourites_service for the user. | |
177 | $repo = $this->get_mock_repository([]); // Mock repository, using the array as a mock DB. | |
4a02aae5 | 178 | $user1service = new \core_favourites\local\service\user_favourites_service($user1context, $repo); |
77105132 JD |
179 | |
180 | // Try to favourite something in a non-existent component. | |
181 | $this->expectException('moodle_exception'); | |
182 | $user1service->create_favourite('core_cccourse', 'my_area', $course1context->instanceid, $course1context); | |
183 | } | |
184 | ||
185 | /** | |
186 | * Test fetching favourites for single user, by area. | |
187 | */ | |
188 | public function test_find_favourites_by_type_single_user() { | |
189 | list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses(); | |
190 | ||
191 | // Get a user_favourites_service for the user. | |
192 | $repo = $this->get_mock_repository([]); // Mock repository, using the array as a mock DB. | |
4a02aae5 | 193 | $service = new \core_favourites\local\service\user_favourites_service($user1context, $repo); |
77105132 JD |
194 | |
195 | // Favourite 2 courses, in separate areas. | |
196 | $fav1 = $service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context); | |
197 | $fav2 = $service->create_favourite('core_course', 'anothertype', $course2context->instanceid, $course2context); | |
198 | ||
199 | // Verify we can get favourites by area. | |
200 | $favourites = $service->find_favourites_by_type('core_course', 'course'); | |
201 | $this->assertInternalType('array', $favourites); | |
202 | $this->assertCount(1, $favourites); // We only get favourites for the 'core_course/course' area. | |
203 | $this->assertAttributeEquals($fav1->id, 'id', $favourites[$fav1->id]); | |
204 | ||
205 | $favourites = $service->find_favourites_by_type('core_course', 'anothertype'); | |
206 | $this->assertInternalType('array', $favourites); | |
207 | $this->assertCount(1, $favourites); // We only get favourites for the 'core_course/course' area. | |
208 | $this->assertAttributeEquals($fav2->id, 'id', $favourites[$fav2->id]); | |
209 | } | |
210 | ||
211 | /** | |
212 | * Make sure the find_favourites_by_type() method only returns favourites for the scoped user. | |
213 | */ | |
214 | public function test_find_favourites_by_type_multiple_users() { | |
215 | list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses(); | |
216 | ||
217 | // Get a user_favourites_service for 2 users. | |
218 | $repo = $this->get_mock_repository([]); | |
4a02aae5 JD |
219 | $user1service = new \core_favourites\local\service\user_favourites_service($user1context, $repo); |
220 | $user2service = new \core_favourites\local\service\user_favourites_service($user2context, $repo); | |
77105132 JD |
221 | |
222 | // Now, as each user, favourite the same course. | |
223 | $fav1 = $user1service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context); | |
224 | $fav2 = $user2service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context); | |
225 | ||
226 | // Verify find_favourites_by_type only returns results for the user to which the service is scoped. | |
227 | $user1favourites = $user1service->find_favourites_by_type('core_course', 'course'); | |
228 | $this->assertInternalType('array', $user1favourites); | |
229 | $this->assertCount(1, $user1favourites); // We only get favourites for the 'core_course/course' area for $user1. | |
230 | $this->assertAttributeEquals($fav1->id, 'id', $user1favourites[$fav1->id]); | |
231 | ||
232 | $user2favourites = $user2service->find_favourites_by_type('core_course', 'course'); | |
233 | $this->assertInternalType('array', $user2favourites); | |
234 | $this->assertCount(1, $user2favourites); // We only get favourites for the 'core_course/course' area for $user2. | |
235 | $this->assertAttributeEquals($fav2->id, 'id', $user2favourites[$fav2->id]); | |
236 | } | |
237 | ||
238 | /** | |
239 | * Test confirming that an exception is thrown if trying to get favourites for a non-existent component. | |
240 | */ | |
241 | public function test_find_favourites_by_type_nonexistent_component() { | |
242 | list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses(); | |
243 | ||
244 | // Get a user_favourites_service for the user. | |
245 | $repo = $this->get_mock_repository([]); | |
4a02aae5 | 246 | $service = new \core_favourites\local\service\user_favourites_service($user1context, $repo); |
77105132 JD |
247 | |
248 | // Verify we get an exception if we try to search for favourites in an invalid component. | |
249 | $this->expectException('moodle_exception'); | |
250 | $service->find_favourites_by_type('cccore_notreal', 'something'); | |
251 | } | |
252 | ||
8ffbe9c1 JD |
253 | /** |
254 | * Test confirming the pagination support for the find_favourites_by_type() method. | |
255 | */ | |
256 | public function test_find_favourites_by_type_pagination() { | |
257 | list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses(); | |
258 | ||
259 | // Get a user_favourites_service for the user. | |
260 | $repo = $this->get_mock_repository([]); | |
261 | $service = new \core_favourites\local\service\user_favourites_service($user1context, $repo); | |
262 | ||
263 | // Favourite 10 arbitrary items. | |
264 | foreach (range(1, 10) as $i) { | |
265 | $service->create_favourite('core_course', 'course', $i, $course1context); | |
266 | } | |
267 | ||
268 | // Verify we have 10 favourites. | |
269 | $this->assertCount(10, $service->find_favourites_by_type('core_course', 'course')); | |
270 | ||
271 | // Verify we get back 5 favourites for page 1. | |
272 | $favourites = $service->find_favourites_by_type('core_course', 'course', 0, 5); | |
273 | $this->assertCount(5, $favourites); | |
274 | ||
275 | // Verify we get back 5 favourites for page 2. | |
276 | $favourites = $service->find_favourites_by_type('core_course', 'course', 5, 5); | |
277 | $this->assertCount(5, $favourites); | |
278 | ||
279 | // Verify we get back an empty array if querying page 3. | |
280 | $favourites = $service->find_favourites_by_type('core_course', 'course', 10, 5); | |
281 | $this->assertCount(0, $favourites); | |
282 | } | |
283 | ||
77105132 JD |
284 | /** |
285 | * Test confirming the basic deletion behaviour. | |
286 | */ | |
287 | public function test_delete_favourite_basic() { | |
288 | list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses(); | |
289 | ||
290 | // Get a user_favourites_service for the user. | |
291 | $repo = $this->get_mock_repository([]); | |
4a02aae5 | 292 | $service = new \core_favourites\local\service\user_favourites_service($user1context, $repo); |
77105132 JD |
293 | |
294 | // Favourite a course. | |
295 | $fav1 = $service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context); | |
296 | $this->assertTrue($repo->exists($fav1->id)); | |
297 | ||
298 | // Delete the favourite. | |
299 | $service->delete_favourite('core_course', 'course', $course1context->instanceid, $course1context); | |
300 | ||
301 | // Verify the favourite doesn't exist. | |
302 | $this->assertFalse($repo->exists($fav1->id)); | |
303 | ||
304 | // Try to delete a favourite which we know doesn't exist. | |
305 | $this->expectException(\moodle_exception::class); | |
306 | $service->delete_favourite('core_course', 'course', $course1context->instanceid, $course1context); | |
307 | } | |
308 | } |