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