]>
Commit | Line | Data |
---|---|---|
7b8a6f28 A |
1 | <?php |
2 | ||
3 | declare(strict_types=1); | |
4 | ||
5d8de758 | 5 | namespace Shaarli\Front\Controller\Admin\ShaareManageControllerTest; |
7b8a6f28 | 6 | |
7b8a6f28 A |
7 | use Shaarli\Bookmark\Bookmark; |
8 | use Shaarli\Bookmark\Exception\BookmarkNotFoundException; | |
9 | use Shaarli\Formatter\BookmarkFormatter; | |
10 | use Shaarli\Formatter\BookmarkRawFormatter; | |
11 | use Shaarli\Formatter\FormatterFactory; | |
12 | use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper; | |
5d8de758 | 13 | use Shaarli\Front\Controller\Admin\ShaareManageController; |
7b8a6f28 A |
14 | use Shaarli\Http\HttpAccess; |
15 | use Shaarli\Security\SessionManager; | |
a5a9cf23 | 16 | use Shaarli\TestCase; |
7b8a6f28 A |
17 | use Slim\Http\Request; |
18 | use Slim\Http\Response; | |
19 | ||
20 | class ChangeVisibilityBookmarkTest extends TestCase | |
21 | { | |
22 | use FrontAdminControllerMockHelper; | |
23 | ||
5d8de758 | 24 | /** @var ShaareManageController */ |
7b8a6f28 A |
25 | protected $controller; |
26 | ||
27 | public function setUp(): void | |
28 | { | |
29 | $this->createContainer(); | |
30 | ||
31 | $this->container->httpAccess = $this->createMock(HttpAccess::class); | |
5d8de758 | 32 | $this->controller = new ShaareManageController($this->container); |
7b8a6f28 A |
33 | } |
34 | ||
35 | /** | |
36 | * Change bookmark visibility - Set private - Single public bookmark with valid parameters | |
37 | */ | |
38 | public function testSetSingleBookmarkPrivate(): void | |
39 | { | |
40 | $parameters = ['id' => '123', 'newVisibility' => 'private']; | |
41 | ||
42 | $request = $this->createMock(Request::class); | |
43 | $request | |
44 | ->method('getParam') | |
45 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | |
46 | return $parameters[$key] ?? null; | |
47 | }) | |
48 | ; | |
49 | $response = new Response(); | |
50 | ||
51 | $bookmark = (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(false); | |
52 | ||
53 | static::assertFalse($bookmark->isPrivate()); | |
54 | ||
55 | $this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark); | |
56 | $this->container->bookmarkService->expects(static::once())->method('set')->with($bookmark, false); | |
57 | $this->container->bookmarkService->expects(static::once())->method('save'); | |
58 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | |
59 | $this->container->formatterFactory | |
60 | ->expects(static::once()) | |
61 | ->method('getFormatter') | |
62 | ->with('raw') | |
63 | ->willReturnCallback(function () use ($bookmark): BookmarkFormatter { | |
64 | return new BookmarkRawFormatter($this->container->conf, true); | |
65 | }) | |
66 | ; | |
67 | ||
68 | // Make sure that PluginManager hook is triggered | |
69 | $this->container->pluginManager | |
70 | ->expects(static::once()) | |
71 | ->method('executeHooks') | |
72 | ->with('save_link') | |
73 | ; | |
74 | ||
75 | $result = $this->controller->changeVisibility($request, $response); | |
76 | ||
77 | static::assertTrue($bookmark->isPrivate()); | |
78 | ||
79 | static::assertSame(302, $result->getStatusCode()); | |
80 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | |
81 | } | |
82 | ||
83 | /** | |
84 | * Change bookmark visibility - Set public - Single private bookmark with valid parameters | |
85 | */ | |
86 | public function testSetSingleBookmarkPublic(): void | |
87 | { | |
88 | $parameters = ['id' => '123', 'newVisibility' => 'public']; | |
89 | ||
90 | $request = $this->createMock(Request::class); | |
91 | $request | |
92 | ->method('getParam') | |
93 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | |
94 | return $parameters[$key] ?? null; | |
95 | }) | |
96 | ; | |
97 | $response = new Response(); | |
98 | ||
99 | $bookmark = (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(true); | |
100 | ||
101 | static::assertTrue($bookmark->isPrivate()); | |
102 | ||
103 | $this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark); | |
104 | $this->container->bookmarkService->expects(static::once())->method('set')->with($bookmark, false); | |
105 | $this->container->bookmarkService->expects(static::once())->method('save'); | |
106 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | |
107 | $this->container->formatterFactory | |
108 | ->expects(static::once()) | |
109 | ->method('getFormatter') | |
110 | ->with('raw') | |
111 | ->willReturn(new BookmarkRawFormatter($this->container->conf, true)) | |
112 | ; | |
113 | ||
114 | // Make sure that PluginManager hook is triggered | |
115 | $this->container->pluginManager | |
116 | ->expects(static::once()) | |
117 | ->method('executeHooks') | |
118 | ->with('save_link') | |
119 | ; | |
120 | ||
121 | $result = $this->controller->changeVisibility($request, $response); | |
122 | ||
123 | static::assertFalse($bookmark->isPrivate()); | |
124 | ||
125 | static::assertSame(302, $result->getStatusCode()); | |
126 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | |
127 | } | |
128 | ||
129 | /** | |
130 | * Change bookmark visibility - Set private on single already private bookmark | |
131 | */ | |
132 | public function testSetSinglePrivateBookmarkPrivate(): void | |
133 | { | |
134 | $parameters = ['id' => '123', 'newVisibility' => 'private']; | |
135 | ||
136 | $request = $this->createMock(Request::class); | |
137 | $request | |
138 | ->method('getParam') | |
139 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | |
140 | return $parameters[$key] ?? null; | |
141 | }) | |
142 | ; | |
143 | $response = new Response(); | |
144 | ||
145 | $bookmark = (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(true); | |
146 | ||
147 | static::assertTrue($bookmark->isPrivate()); | |
148 | ||
149 | $this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark); | |
150 | $this->container->bookmarkService->expects(static::once())->method('set')->with($bookmark, false); | |
151 | $this->container->bookmarkService->expects(static::once())->method('save'); | |
152 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | |
153 | $this->container->formatterFactory | |
154 | ->expects(static::once()) | |
155 | ->method('getFormatter') | |
156 | ->with('raw') | |
157 | ->willReturn(new BookmarkRawFormatter($this->container->conf, true)) | |
158 | ; | |
159 | ||
160 | // Make sure that PluginManager hook is triggered | |
161 | $this->container->pluginManager | |
162 | ->expects(static::once()) | |
163 | ->method('executeHooks') | |
164 | ->with('save_link') | |
165 | ; | |
166 | ||
167 | $result = $this->controller->changeVisibility($request, $response); | |
168 | ||
169 | static::assertTrue($bookmark->isPrivate()); | |
170 | ||
171 | static::assertSame(302, $result->getStatusCode()); | |
172 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | |
173 | } | |
174 | ||
175 | /** | |
176 | * Change bookmark visibility - Set multiple bookmarks private | |
177 | */ | |
178 | public function testSetMultipleBookmarksPrivate(): void | |
179 | { | |
180 | $parameters = ['id' => '123 456 789', 'newVisibility' => 'private']; | |
181 | ||
182 | $request = $this->createMock(Request::class); | |
183 | $request | |
184 | ->method('getParam') | |
185 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | |
186 | return $parameters[$key] ?? null; | |
187 | }) | |
188 | ; | |
189 | $response = new Response(); | |
190 | ||
191 | $bookmarks = [ | |
192 | (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(false), | |
193 | (new Bookmark())->setId(456)->setUrl('http://domain.tld')->setTitle('Title 456')->setPrivate(true), | |
194 | (new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789')->setPrivate(false), | |
195 | ]; | |
196 | ||
197 | $this->container->bookmarkService | |
198 | ->expects(static::exactly(3)) | |
199 | ->method('get') | |
200 | ->withConsecutive([123], [456], [789]) | |
201 | ->willReturnOnConsecutiveCalls(...$bookmarks) | |
202 | ; | |
203 | $this->container->bookmarkService | |
204 | ->expects(static::exactly(3)) | |
205 | ->method('set') | |
206 | ->withConsecutive(...array_map(function (Bookmark $bookmark): array { | |
207 | return [$bookmark, false]; | |
208 | }, $bookmarks)) | |
209 | ; | |
210 | $this->container->bookmarkService->expects(static::once())->method('save'); | |
211 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | |
212 | $this->container->formatterFactory | |
213 | ->expects(static::once()) | |
214 | ->method('getFormatter') | |
215 | ->with('raw') | |
216 | ->willReturn(new BookmarkRawFormatter($this->container->conf, true)) | |
217 | ; | |
218 | ||
219 | // Make sure that PluginManager hook is triggered | |
220 | $this->container->pluginManager | |
221 | ->expects(static::exactly(3)) | |
222 | ->method('executeHooks') | |
223 | ->with('save_link') | |
224 | ; | |
225 | ||
226 | $result = $this->controller->changeVisibility($request, $response); | |
227 | ||
228 | static::assertTrue($bookmarks[0]->isPrivate()); | |
229 | static::assertTrue($bookmarks[1]->isPrivate()); | |
230 | static::assertTrue($bookmarks[2]->isPrivate()); | |
231 | ||
232 | static::assertSame(302, $result->getStatusCode()); | |
233 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | |
234 | } | |
235 | ||
236 | /** | |
237 | * Change bookmark visibility - Single bookmark not found. | |
238 | */ | |
239 | public function testChangeVisibilitySingleBookmarkNotFound(): void | |
240 | { | |
241 | $parameters = ['id' => '123', 'newVisibility' => 'private']; | |
242 | ||
243 | $request = $this->createMock(Request::class); | |
244 | $request | |
245 | ->method('getParam') | |
246 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | |
247 | return $parameters[$key] ?? null; | |
248 | }) | |
249 | ; | |
250 | $response = new Response(); | |
251 | ||
252 | $this->container->bookmarkService | |
253 | ->expects(static::once()) | |
254 | ->method('get') | |
255 | ->willThrowException(new BookmarkNotFoundException()) | |
256 | ; | |
257 | $this->container->bookmarkService->expects(static::never())->method('set'); | |
258 | $this->container->bookmarkService->expects(static::never())->method('save'); | |
259 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | |
260 | $this->container->formatterFactory | |
261 | ->expects(static::once()) | |
262 | ->method('getFormatter') | |
263 | ->with('raw') | |
264 | ->willReturn(new BookmarkRawFormatter($this->container->conf, true)) | |
265 | ; | |
266 | ||
267 | // Make sure that PluginManager hook is not triggered | |
268 | $this->container->pluginManager | |
269 | ->expects(static::never()) | |
270 | ->method('executeHooks') | |
271 | ->with('save_link') | |
272 | ; | |
273 | ||
274 | $result = $this->controller->changeVisibility($request, $response); | |
275 | ||
276 | static::assertSame(302, $result->getStatusCode()); | |
277 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | |
278 | } | |
279 | ||
280 | /** | |
281 | * Change bookmark visibility - Multiple bookmarks with one not found. | |
282 | */ | |
283 | public function testChangeVisibilityMultipleBookmarksOneNotFound(): void | |
284 | { | |
285 | $parameters = ['id' => '123 456 789', 'newVisibility' => 'public']; | |
286 | ||
287 | $request = $this->createMock(Request::class); | |
288 | $request | |
289 | ->method('getParam') | |
290 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | |
291 | return $parameters[$key] ?? null; | |
292 | }) | |
293 | ; | |
294 | $response = new Response(); | |
295 | ||
296 | $bookmarks = [ | |
297 | (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(true), | |
298 | (new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789')->setPrivate(false), | |
299 | ]; | |
300 | ||
301 | $this->container->bookmarkService | |
302 | ->expects(static::exactly(3)) | |
303 | ->method('get') | |
304 | ->withConsecutive([123], [456], [789]) | |
305 | ->willReturnCallback(function (int $id) use ($bookmarks): Bookmark { | |
306 | if ($id === 123) { | |
307 | return $bookmarks[0]; | |
308 | } | |
309 | if ($id === 789) { | |
310 | return $bookmarks[1]; | |
311 | } | |
312 | throw new BookmarkNotFoundException(); | |
313 | }) | |
314 | ; | |
315 | $this->container->bookmarkService | |
316 | ->expects(static::exactly(2)) | |
317 | ->method('set') | |
318 | ->withConsecutive(...array_map(function (Bookmark $bookmark): array { | |
319 | return [$bookmark, false]; | |
320 | }, $bookmarks)) | |
321 | ; | |
322 | $this->container->bookmarkService->expects(static::once())->method('save'); | |
323 | ||
324 | // Make sure that PluginManager hook is not triggered | |
325 | $this->container->pluginManager | |
326 | ->expects(static::exactly(2)) | |
327 | ->method('executeHooks') | |
328 | ->with('save_link') | |
329 | ; | |
330 | ||
331 | $this->container->sessionManager | |
332 | ->expects(static::once()) | |
333 | ->method('setSessionParameter') | |
334 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier 456 could not be found.']) | |
335 | ; | |
336 | ||
337 | $result = $this->controller->changeVisibility($request, $response); | |
338 | ||
339 | static::assertSame(302, $result->getStatusCode()); | |
340 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | |
341 | } | |
342 | ||
343 | /** | |
344 | * Change bookmark visibility - Invalid ID | |
345 | */ | |
346 | public function testChangeVisibilityInvalidId(): void | |
347 | { | |
348 | $parameters = ['id' => 'nope not an ID', 'newVisibility' => 'private']; | |
349 | ||
350 | $request = $this->createMock(Request::class); | |
351 | $request | |
352 | ->method('getParam') | |
353 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | |
354 | return $parameters[$key] ?? null; | |
355 | }) | |
356 | ; | |
357 | $response = new Response(); | |
358 | ||
359 | $this->container->sessionManager | |
360 | ->expects(static::once()) | |
361 | ->method('setSessionParameter') | |
362 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.']) | |
363 | ; | |
364 | ||
365 | $result = $this->controller->changeVisibility($request, $response); | |
366 | ||
367 | static::assertSame(302, $result->getStatusCode()); | |
368 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | |
369 | } | |
370 | ||
371 | /** | |
372 | * Change bookmark visibility - Empty ID | |
373 | */ | |
374 | public function testChangeVisibilityEmptyId(): void | |
375 | { | |
376 | $request = $this->createMock(Request::class); | |
377 | $response = new Response(); | |
378 | ||
379 | $this->container->sessionManager | |
380 | ->expects(static::once()) | |
381 | ->method('setSessionParameter') | |
382 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.']) | |
383 | ; | |
384 | ||
385 | $result = $this->controller->changeVisibility($request, $response); | |
386 | ||
387 | static::assertSame(302, $result->getStatusCode()); | |
388 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | |
389 | } | |
390 | ||
391 | /** | |
392 | * Change bookmark visibility - with invalid visibility | |
393 | */ | |
394 | public function testChangeVisibilityWithInvalidVisibility(): void | |
395 | { | |
396 | $parameters = ['id' => '123', 'newVisibility' => 'invalid']; | |
397 | ||
398 | $request = $this->createMock(Request::class); | |
399 | $request | |
400 | ->method('getParam') | |
401 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | |
402 | return $parameters[$key] ?? null; | |
403 | }) | |
404 | ; | |
405 | $response = new Response(); | |
406 | ||
407 | $this->container->sessionManager | |
408 | ->expects(static::once()) | |
409 | ->method('setSessionParameter') | |
410 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid visibility provided.']) | |
411 | ; | |
412 | ||
413 | $result = $this->controller->changeVisibility($request, $response); | |
414 | ||
415 | static::assertSame(302, $result->getStatusCode()); | |
416 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | |
417 | } | |
418 | } |