tests/Wallabag/CoreBundle/Helper/ContentProxyTest.php

   1 <?php
   2
   3 namespace Tests\Wallabag\CoreBundle\Helper;
   4
   5 use Psr\Log\NullLogger;
   6 use Monolog\Logger;
   7 use Monolog\Handler\TestHandler;
   8 use Wallabag\CoreBundle\Helper\ContentProxy;
   9 use Wallabag\CoreBundle\Entity\Entry;
  10 use Wallabag\CoreBundle\Entity\Tag;
  11 use Wallabag\UserBundle\Entity\User;
  12 use Wallabag\CoreBundle\Helper\RuleBasedTagger;
  13 use Graby\Graby;
  14
  15 class ContentProxyTest extends \PHPUnit_Framework_TestCase
  16 {
  17     private $fetchingErrorMessage = 'wallabag can\'t retrieve contents for this article. Please <a href="http://doc.wallabag.org/en/user/errors_during_fetching.html#how-can-i-help-to-fix-that">troubleshoot this issue</a>.';
  18
  19     public function testWithBadUrl()
  20     {
  21         $tagger = $this->getTaggerMock();
  22         $tagger->expects($this->once())
  23             ->method('tag');
  24
  25         $graby = $this->getMockBuilder('Graby\Graby')
  26             ->setMethods(['fetchContent'])
  27             ->disableOriginalConstructor()
  28             ->getMock();
  29
  30         $graby->expects($this->any())
  31             ->method('fetchContent')
  32             ->willReturn([
  33                 'html' => false,
  34                 'title' => '',
  35                 'url' => '',
  36                 'content_type' => '',
  37                 'language' => '',
  38             ]);
  39
  40         $proxy = new ContentProxy($graby, $tagger, $this->getLogger(), $this->fetchingErrorMessage);
  41         $entry = new Entry(new User());
  42         $proxy->updateEntry($entry, 'http://user@:80');
  43
  44         $this->assertEquals('http://user@:80', $entry->getUrl());
  45         $this->assertEmpty($entry->getTitle());
  46         $this->assertEquals($this->fetchingErrorMessage, $entry->getContent());
  47         $this->assertEmpty($entry->getPreviewPicture());
  48         $this->assertEmpty($entry->getMimetype());
  49         $this->assertEmpty($entry->getLanguage());
  50         $this->assertEquals(0.0, $entry->getReadingTime());
  51         $this->assertEquals(false, $entry->getDomainName());
  52     }
  53
  54     public function testWithEmptyContent()
  55     {
  56         $tagger = $this->getTaggerMock();
  57         $tagger->expects($this->once())
  58             ->method('tag');
  59
  60         $graby = $this->getMockBuilder('Graby\Graby')
  61             ->setMethods(['fetchContent'])
  62             ->disableOriginalConstructor()
  63             ->getMock();
  64
  65         $graby->expects($this->any())
  66             ->method('fetchContent')
  67             ->willReturn([
  68                 'html' => false,
  69                 'title' => '',
  70                 'url' => '',
  71                 'content_type' => '',
  72                 'language' => '',
  73             ]);
  74
  75         $proxy = new ContentProxy($graby, $tagger, $this->getLogger(), $this->fetchingErrorMessage);
  76         $entry = new Entry(new User());
  77         $proxy->updateEntry($entry, 'http://0.0.0.0');
  78
  79         $this->assertEquals('http://0.0.0.0', $entry->getUrl());
  80         $this->assertEmpty($entry->getTitle());
  81         $this->assertEquals($this->fetchingErrorMessage, $entry->getContent());
  82         $this->assertEmpty($entry->getPreviewPicture());
  83         $this->assertEmpty($entry->getMimetype());
  84         $this->assertEmpty($entry->getLanguage());
  85         $this->assertEquals(0.0, $entry->getReadingTime());
  86         $this->assertEquals('0.0.0.0', $entry->getDomainName());
  87     }
  88
  89     public function testWithEmptyContentButOG()
  90     {
  91         $tagger = $this->getTaggerMock();
  92         $tagger->expects($this->once())
  93             ->method('tag');
  94
  95         $graby = $this->getMockBuilder('Graby\Graby')
  96             ->setMethods(['fetchContent'])
  97             ->disableOriginalConstructor()
  98             ->getMock();
  99
 100         $graby->expects($this->any())
 101             ->method('fetchContent')
 102             ->willReturn([
 103                 'html' => false,
 104                 'title' => '',
 105                 'url' => '',
 106                 'content_type' => '',
 107                 'language' => '',
 108                 'status' => '',
 109                 'open_graph' => [
 110                     'og_title' => 'my title',
 111                     'og_description' => 'desc',
 112                 ],
 113             ]);
 114
 115         $proxy = new ContentProxy($graby, $tagger, $this->getLogger(), $this->fetchingErrorMessage);
 116         $entry = new Entry(new User());
 117         $proxy->updateEntry($entry, 'http://domain.io');
 118
 119         $this->assertEquals('http://domain.io', $entry->getUrl());
 120         $this->assertEquals('my title', $entry->getTitle());
 121         $this->assertEquals($this->fetchingErrorMessage.'<p><i>But we found a short description: </i></p>desc', $entry->getContent());
 122         $this->assertEmpty($entry->getPreviewPicture());
 123         $this->assertEmpty($entry->getLanguage());
 124         $this->assertEmpty($entry->getHttpStatus());
 125         $this->assertEmpty($entry->getMimetype());
 126         $this->assertEquals(0.0, $entry->getReadingTime());
 127         $this->assertEquals('domain.io', $entry->getDomainName());
 128     }
 129
 130     public function testWithContent()
 131     {
 132         $tagger = $this->getTaggerMock();
 133         $tagger->expects($this->once())
 134             ->method('tag');
 135
 136         $graby = $this->getMockBuilder('Graby\Graby')
 137             ->setMethods(['fetchContent'])
 138             ->disableOriginalConstructor()
 139             ->getMock();
 140
 141         $graby->expects($this->any())
 142             ->method('fetchContent')
 143             ->willReturn([
 144                 'html' => str_repeat('this is my content', 325),
 145                 'title' => 'this is my title',
 146                 'url' => 'http://1.1.1.1',
 147                 'content_type' => 'text/html',
 148                 'language' => 'fr',
 149                 'status' => '200',
 150                 'open_graph' => [
 151                     'og_title' => 'my OG title',
 152                     'og_description' => 'OG desc',
 153                     'og_image' => 'http://3.3.3.3/cover.jpg',
 154                 ],
 155             ]);
 156
 157         $proxy = new ContentProxy($graby, $tagger, $this->getLogger(), $this->fetchingErrorMessage);
 158         $entry = new Entry(new User());
 159         $proxy->updateEntry($entry, 'http://0.0.0.0');
 160
 161         $this->assertEquals('http://1.1.1.1', $entry->getUrl());
 162         $this->assertEquals('this is my title', $entry->getTitle());
 163         $this->assertContains('this is my content', $entry->getContent());
 164         $this->assertEquals('http://3.3.3.3/cover.jpg', $entry->getPreviewPicture());
 165         $this->assertEquals('text/html', $entry->getMimetype());
 166         $this->assertEquals('fr', $entry->getLanguage());
 167         $this->assertEquals('200', $entry->getHttpStatus());
 168         $this->assertEquals(4.0, $entry->getReadingTime());
 169         $this->assertEquals('1.1.1.1', $entry->getDomainName());
 170     }
 171
 172     public function testWithContentAndNoOgImage()
 173     {
 174         $tagger = $this->getTaggerMock();
 175         $tagger->expects($this->once())
 176             ->method('tag');
 177
 178         $graby = $this->getMockBuilder('Graby\Graby')
 179             ->setMethods(['fetchContent'])
 180             ->disableOriginalConstructor()
 181             ->getMock();
 182
 183         $graby->expects($this->any())
 184             ->method('fetchContent')
 185             ->willReturn([
 186                 'html' => str_repeat('this is my content', 325),
 187                 'title' => 'this is my title',
 188                 'url' => 'http://1.1.1.1',
 189                 'content_type' => 'text/html',
 190                 'language' => 'fr',
 191                 'status' => '200',
 192                 'open_graph' => [
 193                     'og_title' => 'my OG title',
 194                     'og_description' => 'OG desc',
 195                     'og_image' => false,
 196                 ],
 197             ]);
 198
 199         $proxy = new ContentProxy($graby, $tagger, $this->getLogger(), $this->fetchingErrorMessage);
 200         $entry = new Entry(new User());
 201         $proxy->updateEntry($entry, 'http://0.0.0.0');
 202
 203         $this->assertEquals('http://1.1.1.1', $entry->getUrl());
 204         $this->assertEquals('this is my title', $entry->getTitle());
 205         $this->assertContains('this is my content', $entry->getContent());
 206         $this->assertNull($entry->getPreviewPicture());
 207         $this->assertEquals('text/html', $entry->getMimetype());
 208         $this->assertEquals('fr', $entry->getLanguage());
 209         $this->assertEquals('200', $entry->getHttpStatus());
 210         $this->assertEquals(4.0, $entry->getReadingTime());
 211         $this->assertEquals('1.1.1.1', $entry->getDomainName());
 212     }
 213
 214     public function testWithForcedContent()
 215     {
 216         $tagger = $this->getTaggerMock();
 217         $tagger->expects($this->once())
 218             ->method('tag');
 219
 220         $proxy = new ContentProxy((new Graby()), $tagger, $this->getLogger(), $this->fetchingErrorMessage);
 221         $entry = new Entry(new User());
 222         $proxy->updateEntry(
 223             $entry,
 224             'http://0.0.0.0',
 225             [
 226                 'html' => str_repeat('this is my content', 325),
 227                 'title' => 'this is my title',
 228                 'url' => 'http://1.1.1.1',
 229                 'content_type' => 'text/html',
 230                 'language' => 'fr',
 231                 'date' => '1395635872',
 232                 'authors' => ['Jeremy', 'Nico', 'Thomas'],
 233                 'all_headers' => [
 234                     'Cache-Control' => 'no-cache',
 235                 ],
 236             ]
 237         );
 238
 239         $this->assertEquals('http://1.1.1.1', $entry->getUrl());
 240         $this->assertEquals('this is my title', $entry->getTitle());
 241         $this->assertContains('this is my content', $entry->getContent());
 242         $this->assertEquals('text/html', $entry->getMimetype());
 243         $this->assertEquals('fr', $entry->getLanguage());
 244         $this->assertEquals(4.0, $entry->getReadingTime());
 245         $this->assertEquals('1.1.1.1', $entry->getDomainName());
 246         $this->assertEquals('24/03/2014', $entry->getPublishedAt()->format('d/m/Y'));
 247         $this->assertContains('Jeremy', $entry->getPublishedBy());
 248         $this->assertContains('Nico', $entry->getPublishedBy());
 249         $this->assertContains('Thomas', $entry->getPublishedBy());
 250         $this->assertContains('no-cache', $entry->getHeaders());
 251     }
 252
 253     public function testWithForcedContentAndDatetime()
 254     {
 255         $tagger = $this->getTaggerMock();
 256         $tagger->expects($this->once())
 257             ->method('tag');
 258
 259         $logHandler = new TestHandler();
 260         $logger = new Logger('test', [$logHandler]);
 261
 262         $proxy = new ContentProxy((new Graby()), $tagger, $logger, $this->fetchingErrorMessage);
 263         $entry = new Entry(new User());
 264         $proxy->updateEntry(
 265             $entry,
 266             'http://1.1.1.1',
 267             [
 268                 'html' => str_repeat('this is my content', 325),
 269                 'title' => 'this is my title',
 270                 'url' => 'http://1.1.1.1',
 271                 'content_type' => 'text/html',
 272                 'language' => 'fr',
 273                 'date' => '2016-09-08T11:55:58+0200',
 274             ]
 275         );
 276
 277         $this->assertEquals('http://1.1.1.1', $entry->getUrl());
 278         $this->assertEquals('this is my title', $entry->getTitle());
 279         $this->assertContains('this is my content', $entry->getContent());
 280         $this->assertEquals('text/html', $entry->getMimetype());
 281         $this->assertEquals('fr', $entry->getLanguage());
 282         $this->assertEquals(4.0, $entry->getReadingTime());
 283         $this->assertEquals('1.1.1.1', $entry->getDomainName());
 284         $this->assertEquals('08/09/2016', $entry->getPublishedAt()->format('d/m/Y'));
 285     }
 286
 287     public function testWithForcedContentAndBadDate()
 288     {
 289         $tagger = $this->getTaggerMock();
 290         $tagger->expects($this->once())
 291             ->method('tag');
 292
 293         $logger = new Logger('foo');
 294         $handler = new TestHandler();
 295         $logger->pushHandler($handler);
 296
 297         $proxy = new ContentProxy((new Graby()), $tagger, $logger, $this->fetchingErrorMessage);
 298         $entry = new Entry(new User());
 299         $proxy->updateEntry(
 300             $entry,
 301             'http://1.1.1.1',
 302             [
 303                 'html' => str_repeat('this is my content', 325),
 304                 'title' => 'this is my title',
 305                 'url' => 'http://1.1.1.1',
 306                 'content_type' => 'text/html',
 307                 'language' => 'fr',
 308                 'date' => '01 02 2012',
 309             ]
 310         );
 311
 312         $this->assertEquals('http://1.1.1.1', $entry->getUrl());
 313         $this->assertEquals('this is my title', $entry->getTitle());
 314         $this->assertContains('this is my content', $entry->getContent());
 315         $this->assertEquals('text/html', $entry->getMimetype());
 316         $this->assertEquals('fr', $entry->getLanguage());
 317         $this->assertEquals(4.0, $entry->getReadingTime());
 318         $this->assertEquals('1.1.1.1', $entry->getDomainName());
 319         $this->assertNull($entry->getPublishedAt());
 320
 321         $records = $handler->getRecords();
 322
 323         $this->assertCount(1, $records);
 324         $this->assertContains('Error while defining date', $records[0]['message']);
 325     }
 326
 327     public function testTaggerThrowException()
 328     {
 329         $tagger = $this->getTaggerMock();
 330         $tagger->expects($this->once())
 331             ->method('tag')
 332             ->will($this->throwException(new \Exception()));
 333
 334         $proxy = new ContentProxy((new Graby()), $tagger, $this->getLogger(), $this->fetchingErrorMessage);
 335         $entry = new Entry(new User());
 336         $proxy->updateEntry(
 337             $entry,
 338             'http://1.1.1.1',
 339             [
 340                 'html' => str_repeat('this is my content', 325),
 341                 'title' => 'this is my title',
 342                 'url' => 'http://1.1.1.1',
 343                 'content_type' => 'text/html',
 344                 'language' => 'fr',
 345             ]
 346         );
 347
 348         $this->assertCount(0, $entry->getTags());
 349     }
 350
 351     public function dataForCrazyHtml()
 352     {
 353         return [
 354             'script and comment' => [
 355                 '<strong>Script inside:</strong> <!--[if gte IE 4]><script>alert(\'lol\');</script><![endif]--><br />',
 356                 'lol',
 357             ],
 358             'script' => [
 359                 '<strong>Script inside:</strong><script>alert(\'lol\');</script>',
 360                 'script',
 361             ],
 362         ];
 363     }
 364
 365     /**
 366      * @dataProvider dataForCrazyHtml
 367      */
 368     public function testWithCrazyHtmlContent($html, $escapedString)
 369     {
 370         $tagger = $this->getTaggerMock();
 371         $tagger->expects($this->once())
 372             ->method('tag');
 373
 374         $proxy = new ContentProxy((new Graby()), $tagger, $this->getLogger(), $this->fetchingErrorMessage);
 375         $entry = new Entry(new User());
 376         $proxy->updateEntry(
 377             $entry,
 378             'http://1.1.1.1',
 379             [
 380                 'html' => $html,
 381                 'title' => 'this is my title',
 382                 'url' => 'http://1.1.1.1',
 383                 'content_type' => 'text/html',
 384                 'language' => 'fr',
 385                 'status' => '200',
 386                 'open_graph' => [
 387                     'og_title' => 'my OG title',
 388                     'og_description' => 'OG desc',
 389                     'og_image' => 'http://3.3.3.3/cover.jpg',
 390                 ],
 391             ]
 392         );
 393
 394         $this->assertEquals('http://1.1.1.1', $entry->getUrl());
 395         $this->assertEquals('this is my title', $entry->getTitle());
 396         $this->assertNotContains($escapedString, $entry->getContent());
 397         $this->assertEquals('http://3.3.3.3/cover.jpg', $entry->getPreviewPicture());
 398         $this->assertEquals('text/html', $entry->getMimetype());
 399         $this->assertEquals('fr', $entry->getLanguage());
 400         $this->assertEquals('200', $entry->getHttpStatus());
 401         $this->assertEquals('1.1.1.1', $entry->getDomainName());
 402     }
 403
 404     private function getTaggerMock()
 405     {
 406         return $this->getMockBuilder(RuleBasedTagger::class)
 407             ->setMethods(['tag'])
 408             ->disableOriginalConstructor()
 409             ->getMock();
 410     }
 411
 412     private function getLogger()
 413     {
 414         return new NullLogger();
 415     }
 416 }