diff options
Diffstat (limited to 'src/Wallabag/CoreBundle/Tests/Controller')
9 files changed, 0 insertions, 2025 deletions
diff --git a/src/Wallabag/CoreBundle/Tests/Controller/ConfigControllerTest.php b/src/Wallabag/CoreBundle/Tests/Controller/ConfigControllerTest.php deleted file mode 100644 index 8cdedfda..00000000 --- a/src/Wallabag/CoreBundle/Tests/Controller/ConfigControllerTest.php +++ /dev/null | |||
@@ -1,652 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | namespace Wallabag\CoreBundle\Tests\Controller; | ||
4 | |||
5 | use Wallabag\CoreBundle\Tests\WallabagCoreTestCase; | ||
6 | |||
7 | class ConfigControllerTest extends WallabagCoreTestCase | ||
8 | { | ||
9 | public function testLogin() | ||
10 | { | ||
11 | $client = $this->getClient(); | ||
12 | |||
13 | $client->request('GET', '/new'); | ||
14 | |||
15 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
16 | $this->assertContains('login', $client->getResponse()->headers->get('location')); | ||
17 | } | ||
18 | |||
19 | public function testIndex() | ||
20 | { | ||
21 | $this->logInAs('admin'); | ||
22 | $client = $this->getClient(); | ||
23 | |||
24 | $crawler = $client->request('GET', '/config'); | ||
25 | |||
26 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
27 | |||
28 | $this->assertCount(1, $crawler->filter('button[id=config_save]')); | ||
29 | $this->assertCount(1, $crawler->filter('button[id=change_passwd_save]')); | ||
30 | $this->assertCount(1, $crawler->filter('button[id=update_user_save]')); | ||
31 | $this->assertCount(1, $crawler->filter('button[id=new_user_save]')); | ||
32 | $this->assertCount(1, $crawler->filter('button[id=rss_config_save]')); | ||
33 | } | ||
34 | |||
35 | public function testUpdate() | ||
36 | { | ||
37 | $this->logInAs('admin'); | ||
38 | $client = $this->getClient(); | ||
39 | |||
40 | $crawler = $client->request('GET', '/config'); | ||
41 | |||
42 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
43 | |||
44 | $form = $crawler->filter('button[id=config_save]')->form(); | ||
45 | |||
46 | $data = [ | ||
47 | 'config[theme]' => 'baggy', | ||
48 | 'config[items_per_page]' => '30', | ||
49 | 'config[reading_speed]' => '0.5', | ||
50 | 'config[language]' => 'en', | ||
51 | ]; | ||
52 | |||
53 | $client->submit($form, $data); | ||
54 | |||
55 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
56 | |||
57 | $crawler = $client->followRedirect(); | ||
58 | |||
59 | $this->assertGreaterThan(1, $alert = $crawler->filter('div.messages.success')->extract(['_text'])); | ||
60 | $this->assertContains('flashes.config.notice.config_saved', $alert[0]); | ||
61 | } | ||
62 | |||
63 | public function testChangeReadingSpeed() | ||
64 | { | ||
65 | $this->logInAs('admin'); | ||
66 | $client = $this->getClient(); | ||
67 | |||
68 | $crawler = $client->request('GET', '/unread/list'); | ||
69 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
70 | $dataFilters = [ | ||
71 | 'entry_filter[readingTime][right_number]' => 22, | ||
72 | 'entry_filter[readingTime][left_number]' => 22, | ||
73 | ]; | ||
74 | $crawler = $client->submit($form, $dataFilters); | ||
75 | $this->assertCount(1, $crawler->filter('div[class=entry]')); | ||
76 | |||
77 | // Change reading speed | ||
78 | $crawler = $client->request('GET', '/config'); | ||
79 | $form = $crawler->filter('button[id=config_save]')->form(); | ||
80 | $data = [ | ||
81 | 'config[reading_speed]' => '2', | ||
82 | ]; | ||
83 | $client->submit($form, $data); | ||
84 | |||
85 | // Is the entry still available via filters? | ||
86 | $crawler = $client->request('GET', '/unread/list'); | ||
87 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
88 | $crawler = $client->submit($form, $dataFilters); | ||
89 | $this->assertCount(0, $crawler->filter('div[class=entry]')); | ||
90 | |||
91 | // Restore old configuration | ||
92 | $crawler = $client->request('GET', '/config'); | ||
93 | $form = $crawler->filter('button[id=config_save]')->form(); | ||
94 | $data = [ | ||
95 | 'config[reading_speed]' => '0.5', | ||
96 | ]; | ||
97 | $client->submit($form, $data); | ||
98 | } | ||
99 | |||
100 | public function dataForUpdateFailed() | ||
101 | { | ||
102 | return [ | ||
103 | [[ | ||
104 | 'config[theme]' => 'baggy', | ||
105 | 'config[items_per_page]' => '', | ||
106 | 'config[language]' => 'en', | ||
107 | ]], | ||
108 | ]; | ||
109 | } | ||
110 | |||
111 | /** | ||
112 | * @dataProvider dataForUpdateFailed | ||
113 | */ | ||
114 | public function testUpdateFailed($data) | ||
115 | { | ||
116 | $this->logInAs('admin'); | ||
117 | $client = $this->getClient(); | ||
118 | |||
119 | $crawler = $client->request('GET', '/config'); | ||
120 | |||
121 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
122 | |||
123 | $form = $crawler->filter('button[id=config_save]')->form(); | ||
124 | |||
125 | $crawler = $client->submit($form, $data); | ||
126 | |||
127 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
128 | |||
129 | $this->assertGreaterThan(1, $alert = $crawler->filter('body')->extract(['_text'])); | ||
130 | $this->assertContains('This value should not be blank', $alert[0]); | ||
131 | } | ||
132 | |||
133 | public function dataForChangePasswordFailed() | ||
134 | { | ||
135 | return [ | ||
136 | [ | ||
137 | [ | ||
138 | 'change_passwd[old_password]' => 'material', | ||
139 | 'change_passwd[new_password][first]' => '', | ||
140 | 'change_passwd[new_password][second]' => '', | ||
141 | ], | ||
142 | 'validator.password_wrong_value', | ||
143 | ], | ||
144 | [ | ||
145 | [ | ||
146 | 'change_passwd[old_password]' => 'mypassword', | ||
147 | 'change_passwd[new_password][first]' => '', | ||
148 | 'change_passwd[new_password][second]' => '', | ||
149 | ], | ||
150 | 'This value should not be blank', | ||
151 | ], | ||
152 | [ | ||
153 | [ | ||
154 | 'change_passwd[old_password]' => 'mypassword', | ||
155 | 'change_passwd[new_password][first]' => 'hop', | ||
156 | 'change_passwd[new_password][second]' => '', | ||
157 | ], | ||
158 | 'validator.password_must_match', | ||
159 | ], | ||
160 | [ | ||
161 | [ | ||
162 | 'change_passwd[old_password]' => 'mypassword', | ||
163 | 'change_passwd[new_password][first]' => 'hop', | ||
164 | 'change_passwd[new_password][second]' => 'hop', | ||
165 | ], | ||
166 | 'validator.password_too_short', | ||
167 | ], | ||
168 | ]; | ||
169 | } | ||
170 | |||
171 | /** | ||
172 | * @dataProvider dataForChangePasswordFailed | ||
173 | */ | ||
174 | public function testChangePasswordFailed($data, $expectedMessage) | ||
175 | { | ||
176 | $this->logInAs('admin'); | ||
177 | $client = $this->getClient(); | ||
178 | |||
179 | $crawler = $client->request('GET', '/config'); | ||
180 | |||
181 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
182 | |||
183 | $form = $crawler->filter('button[id=change_passwd_save]')->form(); | ||
184 | |||
185 | $crawler = $client->submit($form, $data); | ||
186 | |||
187 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
188 | |||
189 | $this->assertGreaterThan(1, $alert = $crawler->filter('body')->extract(['_text'])); | ||
190 | $this->assertContains($expectedMessage, $alert[0]); | ||
191 | } | ||
192 | |||
193 | public function testChangePassword() | ||
194 | { | ||
195 | $this->logInAs('admin'); | ||
196 | $client = $this->getClient(); | ||
197 | |||
198 | $crawler = $client->request('GET', '/config'); | ||
199 | |||
200 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
201 | |||
202 | $form = $crawler->filter('button[id=change_passwd_save]')->form(); | ||
203 | |||
204 | $data = [ | ||
205 | 'change_passwd[old_password]' => 'mypassword', | ||
206 | 'change_passwd[new_password][first]' => 'mypassword', | ||
207 | 'change_passwd[new_password][second]' => 'mypassword', | ||
208 | ]; | ||
209 | |||
210 | $client->submit($form, $data); | ||
211 | |||
212 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
213 | |||
214 | $crawler = $client->followRedirect(); | ||
215 | |||
216 | $this->assertGreaterThan(1, $alert = $crawler->filter('div.messages.success')->extract(['_text'])); | ||
217 | $this->assertContains('flashes.config.notice.password_updated', $alert[0]); | ||
218 | } | ||
219 | |||
220 | public function dataForUserFailed() | ||
221 | { | ||
222 | return [ | ||
223 | [ | ||
224 | [ | ||
225 | 'update_user[name]' => '', | ||
226 | 'update_user[email]' => '', | ||
227 | ], | ||
228 | 'fos_user.email.blank', | ||
229 | ], | ||
230 | [ | ||
231 | [ | ||
232 | 'update_user[name]' => '', | ||
233 | 'update_user[email]' => 'test', | ||
234 | ], | ||
235 | 'fos_user.email.invalid', | ||
236 | ], | ||
237 | ]; | ||
238 | } | ||
239 | |||
240 | /** | ||
241 | * @dataProvider dataForUserFailed | ||
242 | */ | ||
243 | public function testUserFailed($data, $expectedMessage) | ||
244 | { | ||
245 | $this->logInAs('admin'); | ||
246 | $client = $this->getClient(); | ||
247 | |||
248 | $crawler = $client->request('GET', '/config'); | ||
249 | |||
250 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
251 | |||
252 | $form = $crawler->filter('button[id=update_user_save]')->form(); | ||
253 | |||
254 | $crawler = $client->submit($form, $data); | ||
255 | |||
256 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
257 | |||
258 | $this->assertGreaterThan(1, $alert = $crawler->filter('body')->extract(['_text'])); | ||
259 | $this->assertContains($expectedMessage, $alert[0]); | ||
260 | } | ||
261 | |||
262 | public function testUserUpdate() | ||
263 | { | ||
264 | $this->logInAs('admin'); | ||
265 | $client = $this->getClient(); | ||
266 | |||
267 | $crawler = $client->request('GET', '/config'); | ||
268 | |||
269 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
270 | |||
271 | $form = $crawler->filter('button[id=update_user_save]')->form(); | ||
272 | |||
273 | $data = [ | ||
274 | 'update_user[name]' => 'new name', | ||
275 | 'update_user[email]' => 'admin@wallabag.io', | ||
276 | ]; | ||
277 | |||
278 | $client->submit($form, $data); | ||
279 | |||
280 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
281 | |||
282 | $crawler = $client->followRedirect(); | ||
283 | |||
284 | $this->assertGreaterThan(1, $alert = $crawler->filter('body')->extract(['_text'])); | ||
285 | $this->assertContains('flashes.config.notice.user_updated', $alert[0]); | ||
286 | } | ||
287 | |||
288 | public function dataForNewUserFailed() | ||
289 | { | ||
290 | return [ | ||
291 | [ | ||
292 | [ | ||
293 | 'new_user[username]' => '', | ||
294 | 'new_user[plainPassword][first]' => '', | ||
295 | 'new_user[plainPassword][second]' => '', | ||
296 | 'new_user[email]' => '', | ||
297 | ], | ||
298 | 'fos_user.username.blank', | ||
299 | ], | ||
300 | [ | ||
301 | [ | ||
302 | 'new_user[username]' => 'a', | ||
303 | 'new_user[plainPassword][first]' => 'mypassword', | ||
304 | 'new_user[plainPassword][second]' => 'mypassword', | ||
305 | 'new_user[email]' => '', | ||
306 | ], | ||
307 | 'fos_user.username.short', | ||
308 | ], | ||
309 | [ | ||
310 | [ | ||
311 | 'new_user[username]' => 'wallace', | ||
312 | 'new_user[plainPassword][first]' => 'mypassword', | ||
313 | 'new_user[plainPassword][second]' => 'mypassword', | ||
314 | 'new_user[email]' => 'test', | ||
315 | ], | ||
316 | 'fos_user.email.invalid', | ||
317 | ], | ||
318 | [ | ||
319 | [ | ||
320 | 'new_user[username]' => 'admin', | ||
321 | 'new_user[plainPassword][first]' => 'wallacewallace', | ||
322 | 'new_user[plainPassword][second]' => 'wallacewallace', | ||
323 | 'new_user[email]' => 'wallace@wallace.me', | ||
324 | ], | ||
325 | 'fos_user.username.already_used', | ||
326 | ], | ||
327 | [ | ||
328 | [ | ||
329 | 'new_user[username]' => 'wallace', | ||
330 | 'new_user[plainPassword][first]' => 'mypassword1', | ||
331 | 'new_user[plainPassword][second]' => 'mypassword2', | ||
332 | 'new_user[email]' => 'wallace@wallace.me', | ||
333 | ], | ||
334 | 'validator.password_must_match', | ||
335 | ], | ||
336 | ]; | ||
337 | } | ||
338 | |||
339 | /** | ||
340 | * @dataProvider dataForNewUserFailed | ||
341 | */ | ||
342 | public function testNewUserFailed($data, $expectedMessage) | ||
343 | { | ||
344 | $this->logInAs('admin'); | ||
345 | $client = $this->getClient(); | ||
346 | |||
347 | $crawler = $client->request('GET', '/config'); | ||
348 | |||
349 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
350 | |||
351 | $form = $crawler->filter('button[id=new_user_save]')->form(); | ||
352 | |||
353 | $crawler = $client->submit($form, $data); | ||
354 | |||
355 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
356 | |||
357 | $this->assertGreaterThan(1, $alert = $crawler->filter('body')->extract(['_text'])); | ||
358 | $this->assertContains($expectedMessage, $alert[0]); | ||
359 | } | ||
360 | |||
361 | public function testNewUserCreated() | ||
362 | { | ||
363 | $this->logInAs('admin'); | ||
364 | $client = $this->getClient(); | ||
365 | |||
366 | $crawler = $client->request('GET', '/config'); | ||
367 | |||
368 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
369 | |||
370 | $form = $crawler->filter('button[id=new_user_save]')->form(); | ||
371 | |||
372 | $data = [ | ||
373 | 'new_user[username]' => 'wallace', | ||
374 | 'new_user[plainPassword][first]' => 'wallace1', | ||
375 | 'new_user[plainPassword][second]' => 'wallace1', | ||
376 | 'new_user[email]' => 'wallace@wallace.me', | ||
377 | ]; | ||
378 | |||
379 | $client->submit($form, $data); | ||
380 | |||
381 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
382 | |||
383 | $crawler = $client->followRedirect(); | ||
384 | |||
385 | $this->assertGreaterThan(1, $alert = $crawler->filter('div.messages.success')->extract(['_text'])); | ||
386 | $this->assertContains('flashes.config.notice.user_added', $alert[0]); | ||
387 | |||
388 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
389 | $user = $em | ||
390 | ->getRepository('WallabagUserBundle:User') | ||
391 | ->findOneByUsername('wallace'); | ||
392 | |||
393 | $this->assertTrue(false !== $user); | ||
394 | $this->assertTrue($user->isEnabled()); | ||
395 | $this->assertEquals('material', $user->getConfig()->getTheme()); | ||
396 | $this->assertEquals(12, $user->getConfig()->getItemsPerPage()); | ||
397 | $this->assertEquals(50, $user->getConfig()->getRssLimit()); | ||
398 | $this->assertEquals('en', $user->getConfig()->getLanguage()); | ||
399 | $this->assertEquals(1, $user->getConfig()->getReadingSpeed()); | ||
400 | } | ||
401 | |||
402 | public function testRssUpdateResetToken() | ||
403 | { | ||
404 | $this->logInAs('admin'); | ||
405 | $client = $this->getClient(); | ||
406 | |||
407 | // reset the token | ||
408 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
409 | $user = $em | ||
410 | ->getRepository('WallabagUserBundle:User') | ||
411 | ->findOneByUsername('admin'); | ||
412 | |||
413 | if (!$user) { | ||
414 | $this->markTestSkipped('No user found in db.'); | ||
415 | } | ||
416 | |||
417 | $config = $user->getConfig(); | ||
418 | $config->setRssToken(null); | ||
419 | $em->persist($config); | ||
420 | $em->flush(); | ||
421 | |||
422 | $crawler = $client->request('GET', '/config'); | ||
423 | |||
424 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
425 | |||
426 | $this->assertGreaterThan(1, $body = $crawler->filter('body')->extract(['_text'])); | ||
427 | $this->assertContains('config.form_rss.no_token', $body[0]); | ||
428 | |||
429 | $client->request('GET', '/generate-token'); | ||
430 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
431 | |||
432 | $crawler = $client->followRedirect(); | ||
433 | |||
434 | $this->assertGreaterThan(1, $body = $crawler->filter('body')->extract(['_text'])); | ||
435 | $this->assertNotContains('config.form_rss.no_token', $body[0]); | ||
436 | } | ||
437 | |||
438 | public function testGenerateTokenAjax() | ||
439 | { | ||
440 | $this->logInAs('admin'); | ||
441 | $client = $this->getClient(); | ||
442 | |||
443 | $client->request( | ||
444 | 'GET', | ||
445 | '/generate-token', | ||
446 | [], | ||
447 | [], | ||
448 | ['HTTP_X-Requested-With' => 'XMLHttpRequest'] | ||
449 | ); | ||
450 | |||
451 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
452 | $content = json_decode($client->getResponse()->getContent(), true); | ||
453 | $this->assertArrayHasKey('token', $content); | ||
454 | } | ||
455 | |||
456 | public function testRssUpdate() | ||
457 | { | ||
458 | $this->logInAs('admin'); | ||
459 | $client = $this->getClient(); | ||
460 | |||
461 | $crawler = $client->request('GET', '/config'); | ||
462 | |||
463 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
464 | |||
465 | $form = $crawler->filter('button[id=rss_config_save]')->form(); | ||
466 | |||
467 | $data = [ | ||
468 | 'rss_config[rss_limit]' => 12, | ||
469 | ]; | ||
470 | |||
471 | $client->submit($form, $data); | ||
472 | |||
473 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
474 | |||
475 | $crawler = $client->followRedirect(); | ||
476 | |||
477 | $this->assertGreaterThan(1, $alert = $crawler->filter('div.messages.success')->extract(['_text'])); | ||
478 | $this->assertContains('flashes.config.notice.rss_updated', $alert[0]); | ||
479 | } | ||
480 | |||
481 | public function dataForRssFailed() | ||
482 | { | ||
483 | return [ | ||
484 | [ | ||
485 | [ | ||
486 | 'rss_config[rss_limit]' => 0, | ||
487 | ], | ||
488 | 'This value should be 1 or more.', | ||
489 | ], | ||
490 | [ | ||
491 | [ | ||
492 | 'rss_config[rss_limit]' => 1000000000000, | ||
493 | ], | ||
494 | 'validator.rss_limit_too_hight', | ||
495 | ], | ||
496 | ]; | ||
497 | } | ||
498 | |||
499 | /** | ||
500 | * @dataProvider dataForRssFailed | ||
501 | */ | ||
502 | public function testRssFailed($data, $expectedMessage) | ||
503 | { | ||
504 | $this->logInAs('admin'); | ||
505 | $client = $this->getClient(); | ||
506 | |||
507 | $crawler = $client->request('GET', '/config'); | ||
508 | |||
509 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
510 | |||
511 | $form = $crawler->filter('button[id=rss_config_save]')->form(); | ||
512 | |||
513 | $crawler = $client->submit($form, $data); | ||
514 | |||
515 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
516 | |||
517 | $this->assertGreaterThan(1, $alert = $crawler->filter('body')->extract(['_text'])); | ||
518 | $this->assertContains($expectedMessage, $alert[0]); | ||
519 | } | ||
520 | |||
521 | public function testTaggingRuleCreation() | ||
522 | { | ||
523 | $this->logInAs('admin'); | ||
524 | $client = $this->getClient(); | ||
525 | |||
526 | $crawler = $client->request('GET', '/config'); | ||
527 | |||
528 | $this->assertTrue($client->getResponse()->isSuccessful()); | ||
529 | |||
530 | $form = $crawler->filter('button[id=tagging_rule_save]')->form(); | ||
531 | |||
532 | $data = [ | ||
533 | 'tagging_rule[rule]' => 'readingTime <= 3', | ||
534 | 'tagging_rule[tags]' => 'short reading', | ||
535 | ]; | ||
536 | |||
537 | $client->submit($form, $data); | ||
538 | |||
539 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
540 | |||
541 | $crawler = $client->followRedirect(); | ||
542 | |||
543 | $this->assertGreaterThan(1, $alert = $crawler->filter('div.messages.success')->extract(['_text'])); | ||
544 | $this->assertContains('flashes.config.notice.tagging_rules_updated', $alert[0]); | ||
545 | |||
546 | $deleteLink = $crawler->filter('.delete')->last()->link(); | ||
547 | |||
548 | $crawler = $client->click($deleteLink); | ||
549 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
550 | |||
551 | $crawler = $client->followRedirect(); | ||
552 | $this->assertGreaterThan(1, $alert = $crawler->filter('div.messages.success')->extract(['_text'])); | ||
553 | $this->assertContains('flashes.config.notice.tagging_rules_deleted', $alert[0]); | ||
554 | } | ||
555 | |||
556 | public function dataForTaggingRuleFailed() | ||
557 | { | ||
558 | return [ | ||
559 | [ | ||
560 | [ | ||
561 | 'tagging_rule[rule]' => 'unknownVar <= 3', | ||
562 | 'tagging_rule[tags]' => 'cool tag', | ||
563 | ], | ||
564 | [ | ||
565 | 'The variable', | ||
566 | 'does not exist.', | ||
567 | ], | ||
568 | ], | ||
569 | [ | ||
570 | [ | ||
571 | 'tagging_rule[rule]' => 'length(domainName) <= 42', | ||
572 | 'tagging_rule[tags]' => 'cool tag', | ||
573 | ], | ||
574 | [ | ||
575 | 'The operator', | ||
576 | 'does not exist.', | ||
577 | ], | ||
578 | ], | ||
579 | ]; | ||
580 | } | ||
581 | |||
582 | /** | ||
583 | * @dataProvider dataForTaggingRuleFailed | ||
584 | */ | ||
585 | public function testTaggingRuleCreationFail($data, $messages) | ||
586 | { | ||
587 | $this->logInAs('admin'); | ||
588 | $client = $this->getClient(); | ||
589 | |||
590 | $crawler = $client->request('GET', '/config'); | ||
591 | |||
592 | $this->assertTrue($client->getResponse()->isSuccessful()); | ||
593 | |||
594 | $form = $crawler->filter('button[id=tagging_rule_save]')->form(); | ||
595 | |||
596 | $crawler = $client->submit($form, $data); | ||
597 | |||
598 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
599 | |||
600 | $this->assertGreaterThan(1, $body = $crawler->filter('body')->extract(['_text'])); | ||
601 | |||
602 | foreach ($messages as $message) { | ||
603 | $this->assertContains($message, $body[0]); | ||
604 | } | ||
605 | } | ||
606 | |||
607 | public function testDeletingTaggingRuleFromAnOtherUser() | ||
608 | { | ||
609 | $this->logInAs('bob'); | ||
610 | $client = $this->getClient(); | ||
611 | |||
612 | $rule = $client->getContainer()->get('doctrine.orm.entity_manager') | ||
613 | ->getRepository('WallabagCoreBundle:TaggingRule') | ||
614 | ->findAll()[0]; | ||
615 | |||
616 | $crawler = $client->request('GET', '/tagging-rule/delete/'.$rule->getId()); | ||
617 | |||
618 | $this->assertEquals(403, $client->getResponse()->getStatusCode()); | ||
619 | $this->assertGreaterThan(1, $body = $crawler->filter('body')->extract(['_text'])); | ||
620 | $this->assertContains('You can not access this tagging rule', $body[0]); | ||
621 | } | ||
622 | |||
623 | public function testDemoMode() | ||
624 | { | ||
625 | $this->logInAs('admin'); | ||
626 | $client = $this->getClient(); | ||
627 | |||
628 | $config = $client->getContainer()->get('craue_config'); | ||
629 | $config->set('demo_mode_enabled', 1); | ||
630 | $config->set('demo_mode_username', 'admin'); | ||
631 | |||
632 | $crawler = $client->request('GET', '/config'); | ||
633 | |||
634 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
635 | |||
636 | $form = $crawler->filter('button[id=change_passwd_save]')->form(); | ||
637 | |||
638 | $data = [ | ||
639 | 'change_passwd[old_password]' => 'mypassword', | ||
640 | 'change_passwd[new_password][first]' => 'mypassword', | ||
641 | 'change_passwd[new_password][second]' => 'mypassword', | ||
642 | ]; | ||
643 | |||
644 | $client->submit($form, $data); | ||
645 | |||
646 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
647 | $this->assertContains('flashes.config.notice.password_not_updated_demo', $client->getContainer()->get('session')->getFlashBag()->get('notice')[0]); | ||
648 | |||
649 | $config->set('demo_mode_enabled', 0); | ||
650 | $config->set('demo_mode_username', 'wallabag'); | ||
651 | } | ||
652 | } | ||
diff --git a/src/Wallabag/CoreBundle/Tests/Controller/DeveloperControllerTest.php b/src/Wallabag/CoreBundle/Tests/Controller/DeveloperControllerTest.php deleted file mode 100644 index fc220b85..00000000 --- a/src/Wallabag/CoreBundle/Tests/Controller/DeveloperControllerTest.php +++ /dev/null | |||
@@ -1,71 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | namespace Wallabag\CoreBundle\Tests\Controller; | ||
4 | |||
5 | use Wallabag\CoreBundle\Tests\WallabagCoreTestCase; | ||
6 | |||
7 | class DeveloperControllerTest extends WallabagCoreTestCase | ||
8 | { | ||
9 | public function testCreateClient() | ||
10 | { | ||
11 | $this->logInAs('admin'); | ||
12 | $client = $this->getClient(); | ||
13 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
14 | $nbClients = $em->getRepository('WallabagApiBundle:Client')->findAll(); | ||
15 | |||
16 | $crawler = $client->request('GET', '/developer/client/create'); | ||
17 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
18 | |||
19 | $form = $crawler->filter('button[type=submit]')->form(); | ||
20 | |||
21 | $client->submit($form); | ||
22 | |||
23 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
24 | |||
25 | $newNbClients = $em->getRepository('WallabagApiBundle:Client')->findAll(); | ||
26 | $this->assertGreaterThan(count($nbClients), count($newNbClients)); | ||
27 | } | ||
28 | |||
29 | public function testListingClient() | ||
30 | { | ||
31 | $this->logInAs('admin'); | ||
32 | $client = $this->getClient(); | ||
33 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
34 | $nbClients = $em->getRepository('WallabagApiBundle:Client')->findAll(); | ||
35 | |||
36 | $crawler = $client->request('GET', '/developer'); | ||
37 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
38 | $this->assertEquals(count($nbClients), $crawler->filter('ul[class=collapsible] li')->count()); | ||
39 | } | ||
40 | |||
41 | public function testDeveloperHowto() | ||
42 | { | ||
43 | $this->logInAs('admin'); | ||
44 | $client = $this->getClient(); | ||
45 | |||
46 | $crawler = $client->request('GET', '/developer/howto/first-app'); | ||
47 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
48 | } | ||
49 | |||
50 | public function testRemoveClient() | ||
51 | { | ||
52 | $this->logInAs('admin'); | ||
53 | $client = $this->getClient(); | ||
54 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
55 | $nbClients = $em->getRepository('WallabagApiBundle:Client')->findAll(); | ||
56 | |||
57 | $crawler = $client->request('GET', '/developer'); | ||
58 | |||
59 | $link = $crawler | ||
60 | ->filter('div[class=collapsible-body] p a') | ||
61 | ->eq(0) | ||
62 | ->link() | ||
63 | ; | ||
64 | |||
65 | $client->click($link); | ||
66 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
67 | |||
68 | $newNbClients = $em->getRepository('WallabagApiBundle:Client')->findAll(); | ||
69 | $this->assertGreaterThan(count($newNbClients), count($nbClients)); | ||
70 | } | ||
71 | } | ||
diff --git a/src/Wallabag/CoreBundle/Tests/Controller/EntryControllerTest.php b/src/Wallabag/CoreBundle/Tests/Controller/EntryControllerTest.php deleted file mode 100644 index 5ce893c1..00000000 --- a/src/Wallabag/CoreBundle/Tests/Controller/EntryControllerTest.php +++ /dev/null | |||
@@ -1,665 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | namespace Wallabag\CoreBundle\Tests\Controller; | ||
4 | |||
5 | use Wallabag\CoreBundle\Tests\WallabagCoreTestCase; | ||
6 | use Wallabag\CoreBundle\Entity\Entry; | ||
7 | |||
8 | class EntryControllerTest extends WallabagCoreTestCase | ||
9 | { | ||
10 | public $url = 'http://www.lemonde.fr/pixels/article/2015/03/28/plongee-dans-l-univers-d-ingress-le-jeu-de-google-aux-frontieres-du-reel_4601155_4408996.html'; | ||
11 | |||
12 | public function testLogin() | ||
13 | { | ||
14 | $client = $this->getClient(); | ||
15 | |||
16 | $client->request('GET', '/new'); | ||
17 | |||
18 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
19 | $this->assertContains('login', $client->getResponse()->headers->get('location')); | ||
20 | } | ||
21 | |||
22 | public function testQuickstart() | ||
23 | { | ||
24 | $this->logInAs('empty'); | ||
25 | $client = $this->getClient(); | ||
26 | |||
27 | $client->request('GET', '/unread/list'); | ||
28 | $crawler = $client->followRedirect(); | ||
29 | |||
30 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
31 | $this->assertGreaterThan(1, $body = $crawler->filter('body')->extract(['_text'])); | ||
32 | $this->assertContains('quickstart.intro.paragraph_1', $body[0]); | ||
33 | |||
34 | // Test if quickstart is disabled when user has 1 entry | ||
35 | $crawler = $client->request('GET', '/new'); | ||
36 | |||
37 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
38 | |||
39 | $form = $crawler->filter('form[name=entry]')->form(); | ||
40 | |||
41 | $data = [ | ||
42 | 'entry[url]' => $this->url, | ||
43 | ]; | ||
44 | |||
45 | $client->submit($form, $data); | ||
46 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
47 | $client->followRedirect(); | ||
48 | |||
49 | $crawler = $client->request('GET', '/unread/list'); | ||
50 | $this->assertGreaterThan(1, $body = $crawler->filter('body')->extract(['_text'])); | ||
51 | $this->assertContains('entry.list.number_on_the_page', $body[0]); | ||
52 | } | ||
53 | |||
54 | public function testGetNew() | ||
55 | { | ||
56 | $this->logInAs('admin'); | ||
57 | $client = $this->getClient(); | ||
58 | |||
59 | $crawler = $client->request('GET', '/new'); | ||
60 | |||
61 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
62 | |||
63 | $this->assertCount(1, $crawler->filter('input[type=url]')); | ||
64 | $this->assertCount(1, $crawler->filter('form[name=entry]')); | ||
65 | } | ||
66 | |||
67 | public function testPostNewViaBookmarklet() | ||
68 | { | ||
69 | $this->logInAs('admin'); | ||
70 | $client = $this->getClient(); | ||
71 | |||
72 | $crawler = $client->request('GET', '/'); | ||
73 | |||
74 | $this->assertCount(4, $crawler->filter('div[class=entry]')); | ||
75 | |||
76 | // Good URL | ||
77 | $client->request('GET', '/bookmarklet', ['url' => $this->url]); | ||
78 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
79 | $client->followRedirect(); | ||
80 | $crawler = $client->request('GET', '/'); | ||
81 | $this->assertCount(5, $crawler->filter('div[class=entry]')); | ||
82 | |||
83 | $em = $client->getContainer() | ||
84 | ->get('doctrine.orm.entity_manager'); | ||
85 | $entry = $em | ||
86 | ->getRepository('WallabagCoreBundle:Entry') | ||
87 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
88 | $em->remove($entry); | ||
89 | $em->flush(); | ||
90 | } | ||
91 | |||
92 | public function testPostNewEmpty() | ||
93 | { | ||
94 | $this->logInAs('admin'); | ||
95 | $client = $this->getClient(); | ||
96 | |||
97 | $crawler = $client->request('GET', '/new'); | ||
98 | |||
99 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
100 | |||
101 | $form = $crawler->filter('form[name=entry]')->form(); | ||
102 | |||
103 | $crawler = $client->submit($form); | ||
104 | |||
105 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
106 | $this->assertCount(1, $alert = $crawler->filter('form ul li')->extract(['_text'])); | ||
107 | $this->assertEquals('This value should not be blank.', $alert[0]); | ||
108 | } | ||
109 | |||
110 | /** | ||
111 | * This test will require an internet connection. | ||
112 | */ | ||
113 | public function testPostNewOk() | ||
114 | { | ||
115 | $this->logInAs('admin'); | ||
116 | $client = $this->getClient(); | ||
117 | |||
118 | $crawler = $client->request('GET', '/new'); | ||
119 | |||
120 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
121 | |||
122 | $form = $crawler->filter('form[name=entry]')->form(); | ||
123 | |||
124 | $data = [ | ||
125 | 'entry[url]' => $this->url, | ||
126 | ]; | ||
127 | |||
128 | $client->submit($form, $data); | ||
129 | |||
130 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
131 | |||
132 | $content = $client->getContainer() | ||
133 | ->get('doctrine.orm.entity_manager') | ||
134 | ->getRepository('WallabagCoreBundle:Entry') | ||
135 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
136 | |||
137 | $this->assertInstanceOf('Wallabag\CoreBundle\Entity\Entry', $content); | ||
138 | $this->assertEquals($this->url, $content->getUrl()); | ||
139 | $this->assertContains('Google', $content->getTitle()); | ||
140 | } | ||
141 | |||
142 | public function testPostNewOkUrlExist() | ||
143 | { | ||
144 | $this->logInAs('admin'); | ||
145 | $client = $this->getClient(); | ||
146 | |||
147 | $crawler = $client->request('GET', '/new'); | ||
148 | |||
149 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
150 | |||
151 | $form = $crawler->filter('form[name=entry]')->form(); | ||
152 | |||
153 | $data = [ | ||
154 | 'entry[url]' => $this->url, | ||
155 | ]; | ||
156 | |||
157 | $client->submit($form, $data); | ||
158 | |||
159 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
160 | $this->assertContains('/view/', $client->getResponse()->getTargetUrl()); | ||
161 | } | ||
162 | |||
163 | /** | ||
164 | * This test will require an internet connection. | ||
165 | */ | ||
166 | public function testPostNewThatWillBeTagged() | ||
167 | { | ||
168 | $this->logInAs('admin'); | ||
169 | $client = $this->getClient(); | ||
170 | |||
171 | $crawler = $client->request('GET', '/new'); | ||
172 | |||
173 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
174 | |||
175 | $form = $crawler->filter('form[name=entry]')->form(); | ||
176 | |||
177 | $data = [ | ||
178 | 'entry[url]' => $url = 'https://github.com/wallabag/wallabag', | ||
179 | ]; | ||
180 | |||
181 | $client->submit($form, $data); | ||
182 | |||
183 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
184 | $this->assertContains('/', $client->getResponse()->getTargetUrl()); | ||
185 | |||
186 | $em = $client->getContainer() | ||
187 | ->get('doctrine.orm.entity_manager'); | ||
188 | $entry = $em | ||
189 | ->getRepository('WallabagCoreBundle:Entry') | ||
190 | ->findOneByUrl($url); | ||
191 | $tags = $entry->getTags(); | ||
192 | |||
193 | $this->assertCount(1, $tags); | ||
194 | $this->assertEquals('wallabag', $tags[0]->getLabel()); | ||
195 | |||
196 | $em->remove($entry); | ||
197 | $em->flush(); | ||
198 | |||
199 | // and now re-submit it to test the cascade persistence for tags after entry removal | ||
200 | // related https://github.com/wallabag/wallabag/issues/2121 | ||
201 | $crawler = $client->request('GET', '/new'); | ||
202 | |||
203 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
204 | |||
205 | $form = $crawler->filter('form[name=entry]')->form(); | ||
206 | |||
207 | $data = [ | ||
208 | 'entry[url]' => $url = 'https://github.com/wallabag/wallabag/tree/master', | ||
209 | ]; | ||
210 | |||
211 | $client->submit($form, $data); | ||
212 | |||
213 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
214 | $this->assertContains('/', $client->getResponse()->getTargetUrl()); | ||
215 | |||
216 | $entry = $em | ||
217 | ->getRepository('WallabagCoreBundle:Entry') | ||
218 | ->findOneByUrl($url); | ||
219 | |||
220 | $tags = $entry->getTags(); | ||
221 | |||
222 | $this->assertCount(1, $tags); | ||
223 | $this->assertEquals('wallabag', $tags[0]->getLabel()); | ||
224 | |||
225 | $em->remove($entry); | ||
226 | $em->flush(); | ||
227 | } | ||
228 | |||
229 | public function testArchive() | ||
230 | { | ||
231 | $this->logInAs('admin'); | ||
232 | $client = $this->getClient(); | ||
233 | |||
234 | $client->request('GET', '/archive/list'); | ||
235 | |||
236 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
237 | } | ||
238 | |||
239 | public function testStarred() | ||
240 | { | ||
241 | $this->logInAs('admin'); | ||
242 | $client = $this->getClient(); | ||
243 | |||
244 | $client->request('GET', '/starred/list'); | ||
245 | |||
246 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
247 | } | ||
248 | |||
249 | public function testRangeException() | ||
250 | { | ||
251 | $this->logInAs('admin'); | ||
252 | $client = $this->getClient(); | ||
253 | |||
254 | $client->request('GET', '/all/list/900'); | ||
255 | |||
256 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
257 | $this->assertEquals('/all/list', $client->getResponse()->getTargetUrl()); | ||
258 | } | ||
259 | |||
260 | /** | ||
261 | * @depends testPostNewOk | ||
262 | */ | ||
263 | public function testView() | ||
264 | { | ||
265 | $this->logInAs('admin'); | ||
266 | $client = $this->getClient(); | ||
267 | |||
268 | $content = $client->getContainer() | ||
269 | ->get('doctrine.orm.entity_manager') | ||
270 | ->getRepository('WallabagCoreBundle:Entry') | ||
271 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
272 | |||
273 | $crawler = $client->request('GET', '/view/'.$content->getId()); | ||
274 | |||
275 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
276 | $this->assertGreaterThan(1, $body = $crawler->filter('body')->extract(['_text'])); | ||
277 | $this->assertContains($content->getTitle(), $body[0]); | ||
278 | } | ||
279 | |||
280 | /** | ||
281 | * @depends testPostNewOk | ||
282 | * | ||
283 | * This test will require an internet connection. | ||
284 | */ | ||
285 | public function testReload() | ||
286 | { | ||
287 | $this->logInAs('admin'); | ||
288 | $client = $this->getClient(); | ||
289 | |||
290 | $content = $client->getContainer() | ||
291 | ->get('doctrine.orm.entity_manager') | ||
292 | ->getRepository('WallabagCoreBundle:Entry') | ||
293 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
294 | |||
295 | // empty content | ||
296 | $content->setContent(''); | ||
297 | $client->getContainer()->get('doctrine.orm.entity_manager')->persist($content); | ||
298 | $client->getContainer()->get('doctrine.orm.entity_manager')->flush(); | ||
299 | |||
300 | $client->request('GET', '/reload/'.$content->getId()); | ||
301 | |||
302 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
303 | |||
304 | $content = $client->getContainer() | ||
305 | ->get('doctrine.orm.entity_manager') | ||
306 | ->getRepository('WallabagCoreBundle:Entry') | ||
307 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
308 | |||
309 | $this->assertNotEmpty($content->getContent()); | ||
310 | } | ||
311 | |||
312 | public function testEdit() | ||
313 | { | ||
314 | $this->logInAs('admin'); | ||
315 | $client = $this->getClient(); | ||
316 | |||
317 | $content = $client->getContainer() | ||
318 | ->get('doctrine.orm.entity_manager') | ||
319 | ->getRepository('WallabagCoreBundle:Entry') | ||
320 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
321 | |||
322 | $crawler = $client->request('GET', '/edit/'.$content->getId()); | ||
323 | |||
324 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
325 | |||
326 | $this->assertCount(1, $crawler->filter('input[id=entry_title]')); | ||
327 | $this->assertCount(1, $crawler->filter('button[id=entry_save]')); | ||
328 | } | ||
329 | |||
330 | public function testEditUpdate() | ||
331 | { | ||
332 | $this->logInAs('admin'); | ||
333 | $client = $this->getClient(); | ||
334 | |||
335 | $content = $client->getContainer() | ||
336 | ->get('doctrine.orm.entity_manager') | ||
337 | ->getRepository('WallabagCoreBundle:Entry') | ||
338 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
339 | |||
340 | $crawler = $client->request('GET', '/edit/'.$content->getId()); | ||
341 | |||
342 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
343 | |||
344 | $form = $crawler->filter('button[type=submit]')->form(); | ||
345 | |||
346 | $data = [ | ||
347 | 'entry[title]' => 'My updated title hehe :)', | ||
348 | ]; | ||
349 | |||
350 | $client->submit($form, $data); | ||
351 | |||
352 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
353 | |||
354 | $crawler = $client->followRedirect(); | ||
355 | |||
356 | $this->assertGreaterThan(1, $alert = $crawler->filter('div[id=article] h1')->extract(['_text'])); | ||
357 | $this->assertContains('My updated title hehe :)', $alert[0]); | ||
358 | } | ||
359 | |||
360 | public function testToggleArchive() | ||
361 | { | ||
362 | $this->logInAs('admin'); | ||
363 | $client = $this->getClient(); | ||
364 | |||
365 | $content = $client->getContainer() | ||
366 | ->get('doctrine.orm.entity_manager') | ||
367 | ->getRepository('WallabagCoreBundle:Entry') | ||
368 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
369 | |||
370 | $client->request('GET', '/archive/'.$content->getId()); | ||
371 | |||
372 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
373 | |||
374 | $res = $client->getContainer() | ||
375 | ->get('doctrine.orm.entity_manager') | ||
376 | ->getRepository('WallabagCoreBundle:Entry') | ||
377 | ->find($content->getId()); | ||
378 | |||
379 | $this->assertEquals($res->isArchived(), true); | ||
380 | } | ||
381 | |||
382 | public function testToggleStar() | ||
383 | { | ||
384 | $this->logInAs('admin'); | ||
385 | $client = $this->getClient(); | ||
386 | |||
387 | $content = $client->getContainer() | ||
388 | ->get('doctrine.orm.entity_manager') | ||
389 | ->getRepository('WallabagCoreBundle:Entry') | ||
390 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
391 | |||
392 | $client->request('GET', '/star/'.$content->getId()); | ||
393 | |||
394 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
395 | |||
396 | $res = $client->getContainer() | ||
397 | ->get('doctrine.orm.entity_manager') | ||
398 | ->getRepository('WallabagCoreBundle:Entry') | ||
399 | ->findOneById($content->getId()); | ||
400 | |||
401 | $this->assertEquals($res->isStarred(), true); | ||
402 | } | ||
403 | |||
404 | public function testDelete() | ||
405 | { | ||
406 | $this->logInAs('admin'); | ||
407 | $client = $this->getClient(); | ||
408 | |||
409 | $content = $client->getContainer() | ||
410 | ->get('doctrine.orm.entity_manager') | ||
411 | ->getRepository('WallabagCoreBundle:Entry') | ||
412 | ->findByUrlAndUserId($this->url, $this->getLoggedInUserId()); | ||
413 | |||
414 | $client->request('GET', '/delete/'.$content->getId()); | ||
415 | |||
416 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
417 | |||
418 | $client->request('GET', '/delete/'.$content->getId()); | ||
419 | |||
420 | $this->assertEquals(404, $client->getResponse()->getStatusCode()); | ||
421 | } | ||
422 | |||
423 | /** | ||
424 | * It will create a new entry. | ||
425 | * Browse to it. | ||
426 | * Then remove it. | ||
427 | * | ||
428 | * And it'll check that user won't be redirected to the view page of the content when it had been removed | ||
429 | */ | ||
430 | public function testViewAndDelete() | ||
431 | { | ||
432 | $this->logInAs('admin'); | ||
433 | $client = $this->getClient(); | ||
434 | |||
435 | // add a new content to be removed later | ||
436 | $user = $client->getContainer() | ||
437 | ->get('doctrine.orm.entity_manager') | ||
438 | ->getRepository('WallabagUserBundle:User') | ||
439 | ->findOneByUserName('admin'); | ||
440 | |||
441 | $content = new Entry($user); | ||
442 | $content->setUrl('http://1.1.1.1/entry'); | ||
443 | $content->setReadingTime(12); | ||
444 | $content->setDomainName('domain.io'); | ||
445 | $content->setMimetype('text/html'); | ||
446 | $content->setTitle('test title entry'); | ||
447 | $content->setContent('This is my content /o/'); | ||
448 | $content->setArchived(true); | ||
449 | $content->setLanguage('fr'); | ||
450 | |||
451 | $client->getContainer() | ||
452 | ->get('doctrine.orm.entity_manager') | ||
453 | ->persist($content); | ||
454 | $client->getContainer() | ||
455 | ->get('doctrine.orm.entity_manager') | ||
456 | ->flush(); | ||
457 | |||
458 | $client->request('GET', '/view/'.$content->getId()); | ||
459 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
460 | |||
461 | $client->request('GET', '/delete/'.$content->getId()); | ||
462 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
463 | |||
464 | $client->followRedirect(); | ||
465 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
466 | } | ||
467 | |||
468 | public function testViewOtherUserEntry() | ||
469 | { | ||
470 | $this->logInAs('admin'); | ||
471 | $client = $this->getClient(); | ||
472 | |||
473 | $content = $client->getContainer() | ||
474 | ->get('doctrine.orm.entity_manager') | ||
475 | ->getRepository('WallabagCoreBundle:Entry') | ||
476 | ->findOneByUsernameAndNotArchived('bob'); | ||
477 | |||
478 | $client->request('GET', '/view/'.$content->getId()); | ||
479 | |||
480 | $this->assertEquals(403, $client->getResponse()->getStatusCode()); | ||
481 | } | ||
482 | |||
483 | public function testFilterOnReadingTime() | ||
484 | { | ||
485 | $this->logInAs('admin'); | ||
486 | $client = $this->getClient(); | ||
487 | |||
488 | $crawler = $client->request('GET', '/unread/list'); | ||
489 | |||
490 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
491 | |||
492 | $data = [ | ||
493 | 'entry_filter[readingTime][right_number]' => 22, | ||
494 | 'entry_filter[readingTime][left_number]' => 22, | ||
495 | ]; | ||
496 | |||
497 | $crawler = $client->submit($form, $data); | ||
498 | |||
499 | $this->assertCount(1, $crawler->filter('div[class=entry]')); | ||
500 | } | ||
501 | |||
502 | public function testFilterOnUnreadStatus() | ||
503 | { | ||
504 | $this->logInAs('admin'); | ||
505 | $client = $this->getClient(); | ||
506 | |||
507 | $crawler = $client->request('GET', '/all/list'); | ||
508 | |||
509 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
510 | |||
511 | $data = [ | ||
512 | 'entry_filter[isUnread]' => true, | ||
513 | ]; | ||
514 | |||
515 | $crawler = $client->submit($form, $data); | ||
516 | |||
517 | $this->assertCount(4, $crawler->filter('div[class=entry]')); | ||
518 | } | ||
519 | |||
520 | public function testFilterOnCreationDate() | ||
521 | { | ||
522 | $this->logInAs('admin'); | ||
523 | $client = $this->getClient(); | ||
524 | |||
525 | $crawler = $client->request('GET', '/unread/list'); | ||
526 | |||
527 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
528 | |||
529 | $data = [ | ||
530 | 'entry_filter[createdAt][left_date]' => date('d/m/Y'), | ||
531 | 'entry_filter[createdAt][right_date]' => date('d/m/Y', strtotime('+1 day')), | ||
532 | ]; | ||
533 | |||
534 | $crawler = $client->submit($form, $data); | ||
535 | |||
536 | $this->assertCount(5, $crawler->filter('div[class=entry]')); | ||
537 | |||
538 | $data = [ | ||
539 | 'entry_filter[createdAt][left_date]' => date('d/m/Y'), | ||
540 | 'entry_filter[createdAt][right_date]' => date('d/m/Y'), | ||
541 | ]; | ||
542 | |||
543 | $crawler = $client->submit($form, $data); | ||
544 | |||
545 | $this->assertCount(5, $crawler->filter('div[class=entry]')); | ||
546 | |||
547 | $data = [ | ||
548 | 'entry_filter[createdAt][left_date]' => '01/01/1970', | ||
549 | 'entry_filter[createdAt][right_date]' => '01/01/1970', | ||
550 | ]; | ||
551 | |||
552 | $crawler = $client->submit($form, $data); | ||
553 | |||
554 | $this->assertCount(0, $crawler->filter('div[class=entry]')); | ||
555 | } | ||
556 | |||
557 | public function testPaginationWithFilter() | ||
558 | { | ||
559 | $this->logInAs('admin'); | ||
560 | $client = $this->getClient(); | ||
561 | $crawler = $client->request('GET', '/config'); | ||
562 | |||
563 | $form = $crawler->filter('button[id=config_save]')->form(); | ||
564 | |||
565 | $data = [ | ||
566 | 'config[items_per_page]' => '1', | ||
567 | ]; | ||
568 | |||
569 | $client->submit($form, $data); | ||
570 | |||
571 | $parameters = '?entry_filter%5BreadingTime%5D%5Bleft_number%5D=&entry_filter%5BreadingTime%5D%5Bright_number%5D='; | ||
572 | |||
573 | $client->request('GET', 'unread/list'.$parameters); | ||
574 | |||
575 | $this->assertContains($parameters, $client->getResponse()->getContent()); | ||
576 | |||
577 | // reset pagination | ||
578 | $crawler = $client->request('GET', '/config'); | ||
579 | $form = $crawler->filter('button[id=config_save]')->form(); | ||
580 | $data = [ | ||
581 | 'config[items_per_page]' => '12', | ||
582 | ]; | ||
583 | $client->submit($form, $data); | ||
584 | } | ||
585 | |||
586 | public function testFilterOnDomainName() | ||
587 | { | ||
588 | $this->logInAs('admin'); | ||
589 | $client = $this->getClient(); | ||
590 | |||
591 | $crawler = $client->request('GET', '/unread/list'); | ||
592 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
593 | $data = [ | ||
594 | 'entry_filter[domainName]' => 'domain', | ||
595 | ]; | ||
596 | |||
597 | $crawler = $client->submit($form, $data); | ||
598 | $this->assertCount(5, $crawler->filter('div[class=entry]')); | ||
599 | |||
600 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
601 | $data = [ | ||
602 | 'entry_filter[domainName]' => 'wallabag', | ||
603 | ]; | ||
604 | |||
605 | $crawler = $client->submit($form, $data); | ||
606 | $this->assertCount(0, $crawler->filter('div[class=entry]')); | ||
607 | } | ||
608 | |||
609 | public function testFilterOnStatus() | ||
610 | { | ||
611 | $this->logInAs('admin'); | ||
612 | $client = $this->getClient(); | ||
613 | |||
614 | $crawler = $client->request('GET', '/unread/list'); | ||
615 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
616 | $form['entry_filter[isArchived]']->tick(); | ||
617 | $form['entry_filter[isStarred]']->untick(); | ||
618 | |||
619 | $crawler = $client->submit($form); | ||
620 | $this->assertCount(1, $crawler->filter('div[class=entry]')); | ||
621 | |||
622 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
623 | $form['entry_filter[isArchived]']->untick(); | ||
624 | $form['entry_filter[isStarred]']->tick(); | ||
625 | |||
626 | $crawler = $client->submit($form); | ||
627 | $this->assertCount(1, $crawler->filter('div[class=entry]')); | ||
628 | } | ||
629 | |||
630 | public function testPreviewPictureFilter() | ||
631 | { | ||
632 | $this->logInAs('admin'); | ||
633 | $client = $this->getClient(); | ||
634 | |||
635 | $crawler = $client->request('GET', '/unread/list'); | ||
636 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
637 | $form['entry_filter[previewPicture]']->tick(); | ||
638 | |||
639 | $crawler = $client->submit($form); | ||
640 | $this->assertCount(1, $crawler->filter('div[class=entry]')); | ||
641 | } | ||
642 | |||
643 | public function testFilterOnLanguage() | ||
644 | { | ||
645 | $this->logInAs('admin'); | ||
646 | $client = $this->getClient(); | ||
647 | |||
648 | $crawler = $client->request('GET', '/unread/list'); | ||
649 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
650 | $data = [ | ||
651 | 'entry_filter[language]' => 'fr', | ||
652 | ]; | ||
653 | |||
654 | $crawler = $client->submit($form, $data); | ||
655 | $this->assertCount(2, $crawler->filter('div[class=entry]')); | ||
656 | |||
657 | $form = $crawler->filter('button[id=submit-filter]')->form(); | ||
658 | $data = [ | ||
659 | 'entry_filter[language]' => 'en', | ||
660 | ]; | ||
661 | |||
662 | $crawler = $client->submit($form, $data); | ||
663 | $this->assertCount(2, $crawler->filter('div[class=entry]')); | ||
664 | } | ||
665 | } | ||
diff --git a/src/Wallabag/CoreBundle/Tests/Controller/ExportControllerTest.php b/src/Wallabag/CoreBundle/Tests/Controller/ExportControllerTest.php deleted file mode 100644 index 76c98055..00000000 --- a/src/Wallabag/CoreBundle/Tests/Controller/ExportControllerTest.php +++ /dev/null | |||
@@ -1,251 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | namespace Wallabag\CoreBundle\Tests\Controller; | ||
4 | |||
5 | use Wallabag\CoreBundle\Tests\WallabagCoreTestCase; | ||
6 | |||
7 | class ExportControllerTest extends WallabagCoreTestCase | ||
8 | { | ||
9 | public function testLogin() | ||
10 | { | ||
11 | $client = $this->getClient(); | ||
12 | |||
13 | $client->request('GET', '/export/unread.csv'); | ||
14 | |||
15 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
16 | $this->assertContains('login', $client->getResponse()->headers->get('location')); | ||
17 | } | ||
18 | |||
19 | public function testUnknownCategoryExport() | ||
20 | { | ||
21 | $this->logInAs('admin'); | ||
22 | $client = $this->getClient(); | ||
23 | |||
24 | $client->request('GET', '/export/awesomeness.epub'); | ||
25 | |||
26 | $this->assertEquals(404, $client->getResponse()->getStatusCode()); | ||
27 | } | ||
28 | |||
29 | public function testUnknownFormatExport() | ||
30 | { | ||
31 | $this->logInAs('admin'); | ||
32 | $client = $this->getClient(); | ||
33 | |||
34 | $client->request('GET', '/export/unread.xslx'); | ||
35 | |||
36 | $this->assertEquals(404, $client->getResponse()->getStatusCode()); | ||
37 | } | ||
38 | |||
39 | public function testUnsupportedFormatExport() | ||
40 | { | ||
41 | $this->logInAs('admin'); | ||
42 | $client = $this->getClient(); | ||
43 | |||
44 | $client->request('GET', '/export/unread.doc'); | ||
45 | $this->assertEquals(404, $client->getResponse()->getStatusCode()); | ||
46 | |||
47 | $content = $client->getContainer() | ||
48 | ->get('doctrine.orm.entity_manager') | ||
49 | ->getRepository('WallabagCoreBundle:Entry') | ||
50 | ->findOneByUsernameAndNotArchived('admin'); | ||
51 | |||
52 | $client->request('GET', '/export/'.$content->getId().'.doc'); | ||
53 | $this->assertEquals(404, $client->getResponse()->getStatusCode()); | ||
54 | } | ||
55 | |||
56 | public function testBadEntryId() | ||
57 | { | ||
58 | $this->logInAs('admin'); | ||
59 | $client = $this->getClient(); | ||
60 | |||
61 | $client->request('GET', '/export/0.mobi'); | ||
62 | |||
63 | $this->assertEquals(404, $client->getResponse()->getStatusCode()); | ||
64 | } | ||
65 | |||
66 | public function testEpubExport() | ||
67 | { | ||
68 | $this->logInAs('admin'); | ||
69 | $client = $this->getClient(); | ||
70 | |||
71 | ob_start(); | ||
72 | $crawler = $client->request('GET', '/export/archive.epub'); | ||
73 | ob_end_clean(); | ||
74 | |||
75 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
76 | |||
77 | $headers = $client->getResponse()->headers; | ||
78 | $this->assertEquals('application/epub+zip', $headers->get('content-type')); | ||
79 | $this->assertEquals('attachment; filename="Archive articles.epub"', $headers->get('content-disposition')); | ||
80 | $this->assertEquals('binary', $headers->get('content-transfer-encoding')); | ||
81 | } | ||
82 | |||
83 | public function testMobiExport() | ||
84 | { | ||
85 | $this->logInAs('admin'); | ||
86 | $client = $this->getClient(); | ||
87 | |||
88 | $content = $client->getContainer() | ||
89 | ->get('doctrine.orm.entity_manager') | ||
90 | ->getRepository('WallabagCoreBundle:Entry') | ||
91 | ->findOneByUsernameAndNotArchived('admin'); | ||
92 | |||
93 | ob_start(); | ||
94 | $crawler = $client->request('GET', '/export/'.$content->getId().'.mobi'); | ||
95 | ob_end_clean(); | ||
96 | |||
97 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
98 | |||
99 | $headers = $client->getResponse()->headers; | ||
100 | $this->assertEquals('application/x-mobipocket-ebook', $headers->get('content-type')); | ||
101 | $this->assertEquals('attachment; filename="'.preg_replace('/[^A-Za-z0-9\-]/', '', $content->getTitle()).'.mobi"', $headers->get('content-disposition')); | ||
102 | $this->assertEquals('binary', $headers->get('content-transfer-encoding')); | ||
103 | } | ||
104 | |||
105 | public function testPdfExport() | ||
106 | { | ||
107 | $this->logInAs('admin'); | ||
108 | $client = $this->getClient(); | ||
109 | |||
110 | ob_start(); | ||
111 | $crawler = $client->request('GET', '/export/all.pdf'); | ||
112 | ob_end_clean(); | ||
113 | |||
114 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
115 | |||
116 | $headers = $client->getResponse()->headers; | ||
117 | $this->assertEquals('application/pdf', $headers->get('content-type')); | ||
118 | $this->assertEquals('attachment; filename="All articles.pdf"', $headers->get('content-disposition')); | ||
119 | $this->assertEquals('binary', $headers->get('content-transfer-encoding')); | ||
120 | } | ||
121 | |||
122 | public function testTxtExport() | ||
123 | { | ||
124 | $this->logInAs('admin'); | ||
125 | $client = $this->getClient(); | ||
126 | |||
127 | ob_start(); | ||
128 | $crawler = $client->request('GET', '/export/all.txt'); | ||
129 | ob_end_clean(); | ||
130 | |||
131 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
132 | |||
133 | $headers = $client->getResponse()->headers; | ||
134 | $this->assertEquals('text/plain; charset=UTF-8', $headers->get('content-type')); | ||
135 | $this->assertEquals('attachment; filename="All articles.txt"', $headers->get('content-disposition')); | ||
136 | $this->assertEquals('UTF-8', $headers->get('content-transfer-encoding')); | ||
137 | } | ||
138 | |||
139 | public function testCsvExport() | ||
140 | { | ||
141 | $this->logInAs('admin'); | ||
142 | $client = $this->getClient(); | ||
143 | |||
144 | // to be sure results are the same | ||
145 | $contentInDB = $client->getContainer() | ||
146 | ->get('doctrine.orm.entity_manager') | ||
147 | ->getRepository('WallabagCoreBundle:Entry') | ||
148 | ->createQueryBuilder('e') | ||
149 | ->leftJoin('e.user', 'u') | ||
150 | ->where('u.username = :username')->setParameter('username', 'admin') | ||
151 | ->andWhere('e.isArchived = true') | ||
152 | ->getQuery() | ||
153 | ->getArrayResult(); | ||
154 | |||
155 | ob_start(); | ||
156 | $crawler = $client->request('GET', '/export/archive.csv'); | ||
157 | ob_end_clean(); | ||
158 | |||
159 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
160 | |||
161 | $headers = $client->getResponse()->headers; | ||
162 | $this->assertEquals('application/csv', $headers->get('content-type')); | ||
163 | $this->assertEquals('attachment; filename="Archive articles.csv"', $headers->get('content-disposition')); | ||
164 | $this->assertEquals('UTF-8', $headers->get('content-transfer-encoding')); | ||
165 | |||
166 | $csv = str_getcsv($client->getResponse()->getContent(), "\n"); | ||
167 | |||
168 | $this->assertGreaterThan(1, $csv); | ||
169 | // +1 for title line | ||
170 | $this->assertEquals(count($contentInDB) + 1, count($csv)); | ||
171 | $this->assertEquals('Title;URL;Content;Tags;"MIME Type";Language', $csv[0]); | ||
172 | } | ||
173 | |||
174 | public function testJsonExport() | ||
175 | { | ||
176 | $this->logInAs('admin'); | ||
177 | $client = $this->getClient(); | ||
178 | |||
179 | // to be sure results are the same | ||
180 | $contentInDB = $client->getContainer() | ||
181 | ->get('doctrine.orm.entity_manager') | ||
182 | ->getRepository('WallabagCoreBundle:Entry') | ||
183 | ->createQueryBuilder('e') | ||
184 | ->leftJoin('e.user', 'u') | ||
185 | ->where('u.username = :username')->setParameter('username', 'admin') | ||
186 | ->getQuery() | ||
187 | ->getArrayResult(); | ||
188 | |||
189 | ob_start(); | ||
190 | $crawler = $client->request('GET', '/export/all.json'); | ||
191 | ob_end_clean(); | ||
192 | |||
193 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
194 | |||
195 | $headers = $client->getResponse()->headers; | ||
196 | $this->assertEquals('application/json', $headers->get('content-type')); | ||
197 | $this->assertEquals('attachment; filename="All articles.json"', $headers->get('content-disposition')); | ||
198 | $this->assertEquals('UTF-8', $headers->get('content-transfer-encoding')); | ||
199 | |||
200 | $content = json_decode($client->getResponse()->getContent(), true); | ||
201 | $this->assertEquals(count($contentInDB), count($content)); | ||
202 | $this->assertArrayHasKey('id', $content[0]); | ||
203 | $this->assertArrayHasKey('title', $content[0]); | ||
204 | $this->assertArrayHasKey('url', $content[0]); | ||
205 | $this->assertArrayHasKey('is_archived', $content[0]); | ||
206 | $this->assertArrayHasKey('is_starred', $content[0]); | ||
207 | $this->assertArrayHasKey('content', $content[0]); | ||
208 | $this->assertArrayHasKey('mimetype', $content[0]); | ||
209 | $this->assertArrayHasKey('language', $content[0]); | ||
210 | $this->assertArrayHasKey('reading_time', $content[0]); | ||
211 | $this->assertArrayHasKey('domain_name', $content[0]); | ||
212 | $this->assertArrayHasKey('tags', $content[0]); | ||
213 | } | ||
214 | |||
215 | public function testXmlExport() | ||
216 | { | ||
217 | $this->logInAs('admin'); | ||
218 | $client = $this->getClient(); | ||
219 | |||
220 | // to be sure results are the same | ||
221 | $contentInDB = $client->getContainer() | ||
222 | ->get('doctrine.orm.entity_manager') | ||
223 | ->getRepository('WallabagCoreBundle:Entry') | ||
224 | ->createQueryBuilder('e') | ||
225 | ->leftJoin('e.user', 'u') | ||
226 | ->where('u.username = :username')->setParameter('username', 'admin') | ||
227 | ->andWhere('e.isArchived = false') | ||
228 | ->getQuery() | ||
229 | ->getArrayResult(); | ||
230 | |||
231 | ob_start(); | ||
232 | $crawler = $client->request('GET', '/export/unread.xml'); | ||
233 | ob_end_clean(); | ||
234 | |||
235 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
236 | |||
237 | $headers = $client->getResponse()->headers; | ||
238 | $this->assertEquals('application/xml', $headers->get('content-type')); | ||
239 | $this->assertEquals('attachment; filename="Unread articles.xml"', $headers->get('content-disposition')); | ||
240 | $this->assertEquals('UTF-8', $headers->get('content-transfer-encoding')); | ||
241 | |||
242 | $content = new \SimpleXMLElement($client->getResponse()->getContent()); | ||
243 | $this->assertGreaterThan(0, $content->count()); | ||
244 | $this->assertEquals(count($contentInDB), $content->count()); | ||
245 | $this->assertNotEmpty('id', (string) $content->entry[0]->id); | ||
246 | $this->assertNotEmpty('title', (string) $content->entry[0]->title); | ||
247 | $this->assertNotEmpty('url', (string) $content->entry[0]->url); | ||
248 | $this->assertNotEmpty('content', (string) $content->entry[0]->content); | ||
249 | $this->assertNotEmpty('domain_name', (string) $content->entry[0]->domain_name); | ||
250 | } | ||
251 | } | ||
diff --git a/src/Wallabag/CoreBundle/Tests/Controller/RssControllerTest.php b/src/Wallabag/CoreBundle/Tests/Controller/RssControllerTest.php deleted file mode 100644 index 87a01b8e..00000000 --- a/src/Wallabag/CoreBundle/Tests/Controller/RssControllerTest.php +++ /dev/null | |||
@@ -1,126 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | namespace Wallabag\CoreBundle\Tests\Controller; | ||
4 | |||
5 | use Wallabag\CoreBundle\Tests\WallabagCoreTestCase; | ||
6 | |||
7 | class RssControllerTest extends WallabagCoreTestCase | ||
8 | { | ||
9 | public function validateDom($xml, $nb = null) | ||
10 | { | ||
11 | $doc = new \DOMDocument(); | ||
12 | $doc->loadXML($xml); | ||
13 | |||
14 | $xpath = new \DOMXpath($doc); | ||
15 | |||
16 | if (null === $nb) { | ||
17 | $this->assertGreaterThan(0, $xpath->query('//item')->length); | ||
18 | } else { | ||
19 | $this->assertEquals($nb, $xpath->query('//item')->length); | ||
20 | } | ||
21 | |||
22 | $this->assertEquals(1, $xpath->query('/rss')->length); | ||
23 | $this->assertEquals(1, $xpath->query('/rss/channel')->length); | ||
24 | |||
25 | foreach ($xpath->query('//item') as $item) { | ||
26 | $this->assertEquals(1, $xpath->query('title', $item)->length); | ||
27 | $this->assertEquals(1, $xpath->query('source', $item)->length); | ||
28 | $this->assertEquals(1, $xpath->query('link', $item)->length); | ||
29 | $this->assertEquals(1, $xpath->query('guid', $item)->length); | ||
30 | $this->assertEquals(1, $xpath->query('pubDate', $item)->length); | ||
31 | $this->assertEquals(1, $xpath->query('description', $item)->length); | ||
32 | } | ||
33 | } | ||
34 | |||
35 | public function dataForBadUrl() | ||
36 | { | ||
37 | return [ | ||
38 | [ | ||
39 | '/admin/YZIOAUZIAO/unread.xml', | ||
40 | ], | ||
41 | [ | ||
42 | '/wallace/YZIOAUZIAO/starred.xml', | ||
43 | ], | ||
44 | [ | ||
45 | '/wallace/YZIOAUZIAO/archives.xml', | ||
46 | ], | ||
47 | ]; | ||
48 | } | ||
49 | |||
50 | /** | ||
51 | * @dataProvider dataForBadUrl | ||
52 | */ | ||
53 | public function testBadUrl($url) | ||
54 | { | ||
55 | $client = $this->getClient(); | ||
56 | |||
57 | $client->request('GET', $url); | ||
58 | |||
59 | $this->assertEquals(404, $client->getResponse()->getStatusCode()); | ||
60 | } | ||
61 | |||
62 | public function testUnread() | ||
63 | { | ||
64 | $client = $this->getClient(); | ||
65 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
66 | $user = $em | ||
67 | ->getRepository('WallabagUserBundle:User') | ||
68 | ->findOneByUsername('admin'); | ||
69 | |||
70 | $config = $user->getConfig(); | ||
71 | $config->setRssToken('SUPERTOKEN'); | ||
72 | $config->setRssLimit(2); | ||
73 | $em->persist($config); | ||
74 | $em->flush(); | ||
75 | |||
76 | $client->request('GET', '/admin/SUPERTOKEN/unread.xml'); | ||
77 | |||
78 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
79 | |||
80 | $this->validateDom($client->getResponse()->getContent(), 2); | ||
81 | } | ||
82 | |||
83 | public function testStarred() | ||
84 | { | ||
85 | $client = $this->getClient(); | ||
86 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
87 | $user = $em | ||
88 | ->getRepository('WallabagUserBundle:User') | ||
89 | ->findOneByUsername('admin'); | ||
90 | |||
91 | $config = $user->getConfig(); | ||
92 | $config->setRssToken('SUPERTOKEN'); | ||
93 | $config->setRssLimit(1); | ||
94 | $em->persist($config); | ||
95 | $em->flush(); | ||
96 | |||
97 | $client = $this->getClient(); | ||
98 | $client->request('GET', '/admin/SUPERTOKEN/starred.xml'); | ||
99 | |||
100 | $this->assertEquals(200, $client->getResponse()->getStatusCode(), 1); | ||
101 | |||
102 | $this->validateDom($client->getResponse()->getContent()); | ||
103 | } | ||
104 | |||
105 | public function testArchives() | ||
106 | { | ||
107 | $client = $this->getClient(); | ||
108 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
109 | $user = $em | ||
110 | ->getRepository('WallabagUserBundle:User') | ||
111 | ->findOneByUsername('admin'); | ||
112 | |||
113 | $config = $user->getConfig(); | ||
114 | $config->setRssToken('SUPERTOKEN'); | ||
115 | $config->setRssLimit(null); | ||
116 | $em->persist($config); | ||
117 | $em->flush(); | ||
118 | |||
119 | $client = $this->getClient(); | ||
120 | $client->request('GET', '/admin/SUPERTOKEN/archive.xml'); | ||
121 | |||
122 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
123 | |||
124 | $this->validateDom($client->getResponse()->getContent()); | ||
125 | } | ||
126 | } | ||
diff --git a/src/Wallabag/CoreBundle/Tests/Controller/SecurityControllerTest.php b/src/Wallabag/CoreBundle/Tests/Controller/SecurityControllerTest.php deleted file mode 100644 index 2910fa4f..00000000 --- a/src/Wallabag/CoreBundle/Tests/Controller/SecurityControllerTest.php +++ /dev/null | |||
@@ -1,72 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | namespace Wallabag\CoreBundle\Tests\Controller; | ||
4 | |||
5 | use Wallabag\CoreBundle\Tests\WallabagCoreTestCase; | ||
6 | |||
7 | class SecurityControllerTest extends WallabagCoreTestCase | ||
8 | { | ||
9 | public function testLoginWithout2Factor() | ||
10 | { | ||
11 | $this->logInAs('admin'); | ||
12 | $client = $this->getClient(); | ||
13 | $client->followRedirects(); | ||
14 | |||
15 | $crawler = $client->request('GET', '/config'); | ||
16 | $this->assertContains('config.form_rss.description', $crawler->filter('body')->extract(['_text'])[0]); | ||
17 | } | ||
18 | |||
19 | public function testLoginWith2Factor() | ||
20 | { | ||
21 | $client = $this->getClient(); | ||
22 | |||
23 | if (!$client->getContainer()->getParameter('twofactor_auth')) { | ||
24 | $this->markTestSkipped('twofactor_auth is not enabled.'); | ||
25 | |||
26 | return; | ||
27 | } | ||
28 | |||
29 | $client->followRedirects(); | ||
30 | |||
31 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
32 | $user = $em | ||
33 | ->getRepository('WallabagUserBundle:User') | ||
34 | ->findOneByUsername('admin'); | ||
35 | $user->setTwoFactorAuthentication(true); | ||
36 | $em->persist($user); | ||
37 | $em->flush(); | ||
38 | |||
39 | $this->logInAs('admin'); | ||
40 | $crawler = $client->request('GET', '/config'); | ||
41 | $this->assertContains('scheb_two_factor.trusted', $crawler->filter('body')->extract(['_text'])[0]); | ||
42 | |||
43 | // restore user | ||
44 | $user = $em | ||
45 | ->getRepository('WallabagUserBundle:User') | ||
46 | ->findOneByUsername('admin'); | ||
47 | $user->setTwoFactorAuthentication(false); | ||
48 | $em->persist($user); | ||
49 | $em->flush(); | ||
50 | } | ||
51 | |||
52 | public function testTrustedComputer() | ||
53 | { | ||
54 | $client = $this->getClient(); | ||
55 | |||
56 | if (!$client->getContainer()->getParameter('twofactor_auth')) { | ||
57 | $this->markTestSkipped('twofactor_auth is not enabled.'); | ||
58 | |||
59 | return; | ||
60 | } | ||
61 | |||
62 | $em = $client->getContainer()->get('doctrine.orm.entity_manager'); | ||
63 | $user = $em | ||
64 | ->getRepository('WallabagUserBundle:User') | ||
65 | ->findOneByUsername('admin'); | ||
66 | |||
67 | $date = new \DateTime(); | ||
68 | $user->addTrustedComputer('ABCDEF', $date->add(new \DateInterval('P1M'))); | ||
69 | $this->assertTrue($user->isTrustedComputer('ABCDEF')); | ||
70 | $this->assertFalse($user->isTrustedComputer('FEDCBA')); | ||
71 | } | ||
72 | } | ||
diff --git a/src/Wallabag/CoreBundle/Tests/Controller/SettingsControllerTest.php b/src/Wallabag/CoreBundle/Tests/Controller/SettingsControllerTest.php deleted file mode 100644 index fd698b3e..00000000 --- a/src/Wallabag/CoreBundle/Tests/Controller/SettingsControllerTest.php +++ /dev/null | |||
@@ -1,32 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | namespace Wallabag\CoreBundle\Tests\Controller; | ||
4 | |||
5 | use Wallabag\CoreBundle\Tests\WallabagCoreTestCase; | ||
6 | |||
7 | /** | ||
8 | * The controller `SettingsController` does not exist. | ||
9 | * This test cover security against the internal settings page managed by CraueConfigBundle. | ||
10 | */ | ||
11 | class SettingsControllerTest extends WallabagCoreTestCase | ||
12 | { | ||
13 | public function testSettingsWithAdmin() | ||
14 | { | ||
15 | $this->logInAs('admin'); | ||
16 | $client = $this->getClient(); | ||
17 | |||
18 | $crawler = $client->request('GET', '/settings'); | ||
19 | |||
20 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
21 | } | ||
22 | |||
23 | public function testSettingsWithNormalUser() | ||
24 | { | ||
25 | $this->logInAs('bob'); | ||
26 | $client = $this->getClient(); | ||
27 | |||
28 | $crawler = $client->request('GET', '/settings'); | ||
29 | |||
30 | $this->assertEquals(403, $client->getResponse()->getStatusCode()); | ||
31 | } | ||
32 | } | ||
diff --git a/src/Wallabag/CoreBundle/Tests/Controller/StaticControllerTest.php b/src/Wallabag/CoreBundle/Tests/Controller/StaticControllerTest.php deleted file mode 100644 index 6d7976c4..00000000 --- a/src/Wallabag/CoreBundle/Tests/Controller/StaticControllerTest.php +++ /dev/null | |||
@@ -1,28 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | namespace Wallabag\CoreBundle\Tests\Controller; | ||
4 | |||
5 | use Wallabag\CoreBundle\Tests\WallabagCoreTestCase; | ||
6 | |||
7 | class StaticControllerTest extends WallabagCoreTestCase | ||
8 | { | ||
9 | public function testAbout() | ||
10 | { | ||
11 | $this->logInAs('admin'); | ||
12 | $client = $this->getClient(); | ||
13 | |||
14 | $client->request('GET', '/about'); | ||
15 | |||
16 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
17 | } | ||
18 | |||
19 | public function testHowto() | ||
20 | { | ||
21 | $this->logInAs('admin'); | ||
22 | $client = $this->getClient(); | ||
23 | |||
24 | $client->request('GET', '/howto'); | ||
25 | |||
26 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
27 | } | ||
28 | } | ||
diff --git a/src/Wallabag/CoreBundle/Tests/Controller/TagControllerTest.php b/src/Wallabag/CoreBundle/Tests/Controller/TagControllerTest.php deleted file mode 100644 index 8af37ea4..00000000 --- a/src/Wallabag/CoreBundle/Tests/Controller/TagControllerTest.php +++ /dev/null | |||
@@ -1,128 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | namespace Wallabag\CoreBundle\Tests\Controller; | ||
4 | |||
5 | use Wallabag\CoreBundle\Tests\WallabagCoreTestCase; | ||
6 | |||
7 | class TagControllerTest extends WallabagCoreTestCase | ||
8 | { | ||
9 | public $tagName = 'opensource'; | ||
10 | |||
11 | public function testList() | ||
12 | { | ||
13 | $this->logInAs('admin'); | ||
14 | $client = $this->getClient(); | ||
15 | |||
16 | $client->request('GET', '/tag/list'); | ||
17 | |||
18 | $this->assertEquals(200, $client->getResponse()->getStatusCode()); | ||
19 | } | ||
20 | |||
21 | public function testAddTagToEntry() | ||
22 | { | ||
23 | $this->logInAs('admin'); | ||
24 | $client = $this->getClient(); | ||
25 | |||
26 | $entry = $client->getContainer() | ||
27 | ->get('doctrine.orm.entity_manager') | ||
28 | ->getRepository('WallabagCoreBundle:Entry') | ||
29 | ->findOneByUsernameAndNotArchived('admin'); | ||
30 | |||
31 | $crawler = $client->request('GET', '/view/'.$entry->getId()); | ||
32 | |||
33 | $form = $crawler->filter('form[name=tag]')->form(); | ||
34 | |||
35 | $data = [ | ||
36 | 'tag[label]' => $this->tagName, | ||
37 | ]; | ||
38 | |||
39 | $client->submit($form, $data); | ||
40 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
41 | |||
42 | $this->assertEquals(1, count($entry->getTags())); | ||
43 | |||
44 | # tag already exists and already assigned | ||
45 | $client->submit($form, $data); | ||
46 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
47 | |||
48 | $newEntry = $client->getContainer() | ||
49 | ->get('doctrine.orm.entity_manager') | ||
50 | ->getRepository('WallabagCoreBundle:Entry') | ||
51 | ->find($entry->getId()); | ||
52 | |||
53 | $this->assertEquals(1, count($newEntry->getTags())); | ||
54 | |||
55 | # tag already exists but still not assigned to this entry | ||
56 | $data = [ | ||
57 | 'tag[label]' => 'foo', | ||
58 | ]; | ||
59 | |||
60 | $client->submit($form, $data); | ||
61 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
62 | |||
63 | $newEntry = $client->getContainer() | ||
64 | ->get('doctrine.orm.entity_manager') | ||
65 | ->getRepository('WallabagCoreBundle:Entry') | ||
66 | ->find($entry->getId()); | ||
67 | |||
68 | $this->assertEquals(2, count($newEntry->getTags())); | ||
69 | } | ||
70 | |||
71 | public function testAddMultipleTagToEntry() | ||
72 | { | ||
73 | $this->logInAs('admin'); | ||
74 | $client = $this->getClient(); | ||
75 | |||
76 | $entry = $client->getContainer() | ||
77 | ->get('doctrine.orm.entity_manager') | ||
78 | ->getRepository('WallabagCoreBundle:Entry') | ||
79 | ->findOneByUsernameAndNotArchived('admin'); | ||
80 | |||
81 | $crawler = $client->request('GET', '/view/'.$entry->getId()); | ||
82 | |||
83 | $form = $crawler->filter('form[name=tag]')->form(); | ||
84 | |||
85 | $data = [ | ||
86 | 'tag[label]' => 'foo2, bar2', | ||
87 | ]; | ||
88 | |||
89 | $client->submit($form, $data); | ||
90 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
91 | |||
92 | $newEntry = $client->getContainer() | ||
93 | ->get('doctrine.orm.entity_manager') | ||
94 | ->getRepository('WallabagCoreBundle:Entry') | ||
95 | ->find($entry->getId()); | ||
96 | |||
97 | $tags = $newEntry->getTags()->toArray(); | ||
98 | $this->assertGreaterThanOrEqual(2, count($tags)); | ||
99 | $this->assertNotEquals(false, array_search('foo2', $tags), 'Tag foo2 is assigned to the entry'); | ||
100 | $this->assertNotEquals(false, array_search('bar2', $tags), 'Tag bar2 is assigned to the entry'); | ||
101 | } | ||
102 | |||
103 | public function testRemoveTagFromEntry() | ||
104 | { | ||
105 | $this->logInAs('admin'); | ||
106 | $client = $this->getClient(); | ||
107 | |||
108 | $entry = $client->getContainer() | ||
109 | ->get('doctrine.orm.entity_manager') | ||
110 | ->getRepository('WallabagCoreBundle:Entry') | ||
111 | ->findOneByUsernameAndNotArchived('admin'); | ||
112 | |||
113 | $tag = $client->getContainer() | ||
114 | ->get('doctrine.orm.entity_manager') | ||
115 | ->getRepository('WallabagCoreBundle:Tag') | ||
116 | ->findOneByEntryAndTagLabel($entry, $this->tagName); | ||
117 | |||
118 | $client->request('GET', '/remove-tag/'.$entry->getId().'/'.$tag->getId()); | ||
119 | |||
120 | $this->assertEquals(302, $client->getResponse()->getStatusCode()); | ||
121 | |||
122 | $this->assertNotContains($this->tagName, $entry->getTags()); | ||
123 | |||
124 | $client->request('GET', '/remove-tag/'.$entry->getId().'/'.$tag->getId()); | ||
125 | |||
126 | $this->assertEquals(404, $client->getResponse()->getStatusCode()); | ||
127 | } | ||
128 | } | ||