From 23634d5d842dabcf5d7475e2becb7e127824239e Mon Sep 17 00:00:00 2001
From: Jeremy Benoist <jeremy.benoist@gmail.com>
Date: Wed, 1 Jun 2016 21:27:35 +0200
Subject: Jump to Symfony 3.1

---
 .../CoreBundle/Helper/ContentProxyTest.php         | 318 +++++++++++++++++++++
 tests/Wallabag/CoreBundle/Helper/RedirectTest.php  |  55 ++++
 .../CoreBundle/Helper/RuleBasedTaggerTest.php      | 212 ++++++++++++++
 3 files changed, 585 insertions(+)
 create mode 100644 tests/Wallabag/CoreBundle/Helper/ContentProxyTest.php
 create mode 100644 tests/Wallabag/CoreBundle/Helper/RedirectTest.php
 create mode 100644 tests/Wallabag/CoreBundle/Helper/RuleBasedTaggerTest.php

(limited to 'tests/Wallabag/CoreBundle/Helper')

diff --git a/tests/Wallabag/CoreBundle/Helper/ContentProxyTest.php b/tests/Wallabag/CoreBundle/Helper/ContentProxyTest.php
new file mode 100644
index 00000000..7abb0737
--- /dev/null
+++ b/tests/Wallabag/CoreBundle/Helper/ContentProxyTest.php
@@ -0,0 +1,318 @@
+<?php
+
+namespace Tests\Wallabag\CoreBundle\Helper;
+
+use Psr\Log\NullLogger;
+use Wallabag\CoreBundle\Helper\ContentProxy;
+use Wallabag\CoreBundle\Entity\Entry;
+use Wallabag\CoreBundle\Entity\Tag;
+use Wallabag\UserBundle\Entity\User;
+
+class ContentProxyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testWithBadUrl()
+    {
+        $tagger = $this->getTaggerMock();
+        $tagger->expects($this->once())
+            ->method('tag');
+
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->setMethods(['fetchContent'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $graby->expects($this->any())
+            ->method('fetchContent')
+            ->willReturn([
+                'html' => false,
+                'title' => '',
+                'url' => '',
+                'content_type' => '',
+                'language' => '',
+            ]);
+
+        $proxy = new ContentProxy($graby, $tagger, $this->getTagRepositoryMock(), $this->getLogger());
+        $entry = $proxy->updateEntry(new Entry(new User()), 'http://user@:80');
+
+        $this->assertEquals('http://user@:80', $entry->getUrl());
+        $this->assertEmpty($entry->getTitle());
+        $this->assertEquals('<p>Unable to retrieve readable content.</p>', $entry->getContent());
+        $this->assertEmpty($entry->getPreviewPicture());
+        $this->assertEmpty($entry->getMimetype());
+        $this->assertEmpty($entry->getLanguage());
+        $this->assertEquals(0.0, $entry->getReadingTime());
+        $this->assertEquals(false, $entry->getDomainName());
+    }
+
+    public function testWithEmptyContent()
+    {
+        $tagger = $this->getTaggerMock();
+        $tagger->expects($this->once())
+            ->method('tag');
+
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->setMethods(['fetchContent'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $graby->expects($this->any())
+            ->method('fetchContent')
+            ->willReturn([
+                'html' => false,
+                'title' => '',
+                'url' => '',
+                'content_type' => '',
+                'language' => '',
+            ]);
+
+        $proxy = new ContentProxy($graby, $tagger, $this->getTagRepositoryMock(), $this->getLogger());
+        $entry = $proxy->updateEntry(new Entry(new User()), 'http://0.0.0.0');
+
+        $this->assertEquals('http://0.0.0.0', $entry->getUrl());
+        $this->assertEmpty($entry->getTitle());
+        $this->assertEquals('<p>Unable to retrieve readable content.</p>', $entry->getContent());
+        $this->assertEmpty($entry->getPreviewPicture());
+        $this->assertEmpty($entry->getMimetype());
+        $this->assertEmpty($entry->getLanguage());
+        $this->assertEquals(0.0, $entry->getReadingTime());
+        $this->assertEquals('0.0.0.0', $entry->getDomainName());
+    }
+
+    public function testWithEmptyContentButOG()
+    {
+        $tagger = $this->getTaggerMock();
+        $tagger->expects($this->once())
+            ->method('tag');
+
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->setMethods(['fetchContent'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $graby->expects($this->any())
+            ->method('fetchContent')
+            ->willReturn([
+                'html' => false,
+                'title' => '',
+                'url' => '',
+                'content_type' => '',
+                'language' => '',
+                'open_graph' => [
+                    'og_title' => 'my title',
+                    'og_description' => 'desc',
+                ],
+            ]);
+
+        $proxy = new ContentProxy($graby, $tagger, $this->getTagRepositoryMock(), $this->getLogger());
+        $entry = $proxy->updateEntry(new Entry(new User()), 'http://domain.io');
+
+        $this->assertEquals('http://domain.io', $entry->getUrl());
+        $this->assertEquals('my title', $entry->getTitle());
+        $this->assertEquals('<p>Unable to retrieve readable content.</p><p><i>But we found a short description: </i></p>desc', $entry->getContent());
+        $this->assertEmpty($entry->getPreviewPicture());
+        $this->assertEmpty($entry->getLanguage());
+        $this->assertEmpty($entry->getMimetype());
+        $this->assertEquals(0.0, $entry->getReadingTime());
+        $this->assertEquals('domain.io', $entry->getDomainName());
+    }
+
+    public function testWithContent()
+    {
+        $tagger = $this->getTaggerMock();
+        $tagger->expects($this->once())
+            ->method('tag');
+
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->setMethods(['fetchContent'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $graby->expects($this->any())
+            ->method('fetchContent')
+            ->willReturn([
+                'html' => str_repeat('this is my content', 325),
+                'title' => 'this is my title',
+                'url' => 'http://1.1.1.1',
+                'content_type' => 'text/html',
+                'language' => 'fr',
+                'open_graph' => [
+                    'og_title' => 'my OG title',
+                    'og_description' => 'OG desc',
+                    'og_image' => 'http://3.3.3.3/cover.jpg',
+                ],
+            ]);
+
+        $proxy = new ContentProxy($graby, $tagger, $this->getTagRepositoryMock(), $this->getLogger());
+        $entry = $proxy->updateEntry(new Entry(new User()), 'http://0.0.0.0');
+
+        $this->assertEquals('http://1.1.1.1', $entry->getUrl());
+        $this->assertEquals('this is my title', $entry->getTitle());
+        $this->assertContains('this is my content', $entry->getContent());
+        $this->assertEquals('http://3.3.3.3/cover.jpg', $entry->getPreviewPicture());
+        $this->assertEquals('text/html', $entry->getMimetype());
+        $this->assertEquals('fr', $entry->getLanguage());
+        $this->assertEquals(4.0, $entry->getReadingTime());
+        $this->assertEquals('1.1.1.1', $entry->getDomainName());
+    }
+
+    public function testWithForcedContent()
+    {
+        $tagger = $this->getTaggerMock();
+        $tagger->expects($this->once())
+            ->method('tag');
+
+        $graby = $this->getMockBuilder('Graby\Graby')->getMock();
+
+        $proxy = new ContentProxy($graby, $tagger, $this->getTagRepositoryMock(), $this->getLogger());
+        $entry = $proxy->updateEntry(new Entry(new User()), 'http://0.0.0.0', [
+            'html' => str_repeat('this is my content', 325),
+            'title' => 'this is my title',
+            'url' => 'http://1.1.1.1',
+            'content_type' => 'text/html',
+            'language' => 'fr',
+        ]);
+
+        $this->assertEquals('http://1.1.1.1', $entry->getUrl());
+        $this->assertEquals('this is my title', $entry->getTitle());
+        $this->assertContains('this is my content', $entry->getContent());
+        $this->assertEquals('text/html', $entry->getMimetype());
+        $this->assertEquals('fr', $entry->getLanguage());
+        $this->assertEquals(4.0, $entry->getReadingTime());
+        $this->assertEquals('1.1.1.1', $entry->getDomainName());
+    }
+
+    public function testTaggerThrowException()
+    {
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $tagger = $this->getTaggerMock();
+        $tagger->expects($this->once())
+            ->method('tag')
+            ->will($this->throwException(new \Exception()));
+
+        $tagRepo = $this->getTagRepositoryMock();
+        $proxy = new ContentProxy($graby, $tagger, $tagRepo, $this->getLogger());
+
+        $entry = $proxy->updateEntry(new Entry(new User()), 'http://0.0.0.0', [
+            'html' => str_repeat('this is my content', 325),
+            'title' => 'this is my title',
+            'url' => 'http://1.1.1.1',
+            'content_type' => 'text/html',
+            'language' => 'fr',
+        ]);
+
+        $this->assertCount(0, $entry->getTags());
+    }
+
+    public function testAssignTagsWithArrayAndExtraSpaces()
+    {
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $tagRepo = $this->getTagRepositoryMock();
+        $proxy = new ContentProxy($graby, $this->getTaggerMock(), $tagRepo, $this->getLogger());
+
+        $entry = new Entry(new User());
+
+        $proxy->assignTagsToEntry($entry, ['   tag1', 'tag2   ']);
+
+        $this->assertCount(2, $entry->getTags());
+        $this->assertEquals('tag1', $entry->getTags()[0]->getLabel());
+        $this->assertEquals('tag2', $entry->getTags()[1]->getLabel());
+    }
+
+    public function testAssignTagsWithString()
+    {
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $tagRepo = $this->getTagRepositoryMock();
+        $proxy = new ContentProxy($graby, $this->getTaggerMock(), $tagRepo, $this->getLogger());
+
+        $entry = new Entry(new User());
+
+        $proxy->assignTagsToEntry($entry, 'tag1, tag2');
+
+        $this->assertCount(2, $entry->getTags());
+        $this->assertEquals('tag1', $entry->getTags()[0]->getLabel());
+        $this->assertEquals('tag2', $entry->getTags()[1]->getLabel());
+    }
+
+    public function testAssignTagsWithEmptyArray()
+    {
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $tagRepo = $this->getTagRepositoryMock();
+        $proxy = new ContentProxy($graby, $this->getTaggerMock(), $tagRepo, $this->getLogger());
+
+        $entry = new Entry(new User());
+
+        $proxy->assignTagsToEntry($entry, []);
+
+        $this->assertCount(0, $entry->getTags());
+    }
+
+    public function testAssignTagsWithEmptyString()
+    {
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $tagRepo = $this->getTagRepositoryMock();
+        $proxy = new ContentProxy($graby, $this->getTaggerMock(), $tagRepo, $this->getLogger());
+
+        $entry = new Entry(new User());
+
+        $proxy->assignTagsToEntry($entry, '');
+
+        $this->assertCount(0, $entry->getTags());
+    }
+
+    public function testAssignTagsAlreadyAssigned()
+    {
+        $graby = $this->getMockBuilder('Graby\Graby')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $tagRepo = $this->getTagRepositoryMock();
+        $proxy = new ContentProxy($graby, $this->getTaggerMock(), $tagRepo, $this->getLogger());
+
+        $tagEntity = new Tag();
+        $tagEntity->setLabel('tag1');
+
+        $entry = new Entry(new User());
+        $entry->addTag($tagEntity);
+
+        $proxy->assignTagsToEntry($entry, 'tag1, tag2');
+
+        $this->assertCount(2, $entry->getTags());
+        $this->assertEquals('tag1', $entry->getTags()[0]->getLabel());
+        $this->assertEquals('tag2', $entry->getTags()[1]->getLabel());
+    }
+
+    private function getTaggerMock()
+    {
+        return $this->getMockBuilder('Wallabag\CoreBundle\Helper\RuleBasedTagger')
+            ->setMethods(['tag'])
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    private function getTagRepositoryMock()
+    {
+        return $this->getMockBuilder('Wallabag\CoreBundle\Repository\TagRepository')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    private function getLogger()
+    {
+        return new NullLogger();
+    }
+}
diff --git a/tests/Wallabag/CoreBundle/Helper/RedirectTest.php b/tests/Wallabag/CoreBundle/Helper/RedirectTest.php
new file mode 100644
index 00000000..f339f75e
--- /dev/null
+++ b/tests/Wallabag/CoreBundle/Helper/RedirectTest.php
@@ -0,0 +1,55 @@
+<?php
+
+namespace Tests\Wallabag\CoreBundle\Helper;
+
+use Wallabag\CoreBundle\Helper\Redirect;
+
+class RedirectTest extends \PHPUnit_Framework_TestCase
+{
+    /** @var \PHPUnit_Framework_MockObject_MockObject */
+    private $routerMock;
+
+    /** @var Redirect */
+    private $redirect;
+
+    public function setUp()
+    {
+        $this->routerMock = $this->getRouterMock();
+        $this->redirect = new Redirect($this->routerMock);
+    }
+
+    public function testRedirectToNullWithFallback()
+    {
+        $redirectUrl = $this->redirect->to(null, 'fallback');
+
+        $this->assertEquals('fallback', $redirectUrl);
+    }
+
+    public function testRedirectToNullWithoutFallback()
+    {
+        $redirectUrl = $this->redirect->to(null);
+
+        $this->assertEquals($this->routerMock->generate('homepage'), $redirectUrl);
+    }
+
+    public function testRedirectToValidUrl()
+    {
+        $redirectUrl = $this->redirect->to('/unread/list');
+
+        $this->assertEquals('/unread/list', $redirectUrl);
+    }
+
+    private function getRouterMock()
+    {
+        $mock = $this->getMockBuilder('Symfony\Component\Routing\Router')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $mock->expects($this->any())
+            ->method('generate')
+            ->with('homepage')
+            ->willReturn('homepage');
+
+        return $mock;
+    }
+}
diff --git a/tests/Wallabag/CoreBundle/Helper/RuleBasedTaggerTest.php b/tests/Wallabag/CoreBundle/Helper/RuleBasedTaggerTest.php
new file mode 100644
index 00000000..17b08c2a
--- /dev/null
+++ b/tests/Wallabag/CoreBundle/Helper/RuleBasedTaggerTest.php
@@ -0,0 +1,212 @@
+<?php
+
+namespace Tests\Wallabag\CoreBundle\Helper;
+
+use Wallabag\CoreBundle\Entity\Config;
+use Wallabag\CoreBundle\Entity\Entry;
+use Wallabag\CoreBundle\Entity\Tag;
+use Wallabag\CoreBundle\Entity\TaggingRule;
+use Wallabag\CoreBundle\Helper\RuleBasedTagger;
+use Wallabag\UserBundle\Entity\User;
+
+class RuleBasedTaggerTest extends \PHPUnit_Framework_TestCase
+{
+    private $rulerz;
+    private $tagRepository;
+    private $entryRepository;
+    private $tagger;
+
+    public function setUp()
+    {
+        $this->rulerz = $this->getRulerZMock();
+        $this->tagRepository = $this->getTagRepositoryMock();
+        $this->entryRepository = $this->getEntryRepositoryMock();
+
+        $this->tagger = new RuleBasedTagger($this->rulerz, $this->tagRepository, $this->entryRepository);
+    }
+
+    public function testTagWithNoRule()
+    {
+        $entry = new Entry($this->getUser());
+
+        $this->tagger->tag($entry);
+
+        $this->assertTrue($entry->getTags()->isEmpty());
+    }
+
+    public function testTagWithNoMatchingRule()
+    {
+        $taggingRule = $this->getTaggingRule('rule as string', ['foo', 'bar']);
+        $user = $this->getUser([$taggingRule]);
+        $entry = new Entry($user);
+
+        $this->rulerz
+            ->expects($this->once())
+            ->method('satisfies')
+            ->with($entry, 'rule as string')
+            ->willReturn(false);
+
+        $this->tagger->tag($entry);
+
+        $this->assertTrue($entry->getTags()->isEmpty());
+    }
+
+    public function testTagWithAMatchingRule()
+    {
+        $taggingRule = $this->getTaggingRule('rule as string', ['foo', 'bar']);
+        $user = $this->getUser([$taggingRule]);
+        $entry = new Entry($user);
+
+        $this->rulerz
+            ->expects($this->once())
+            ->method('satisfies')
+            ->with($entry, 'rule as string')
+            ->willReturn(true);
+
+        $this->tagger->tag($entry);
+
+        $this->assertFalse($entry->getTags()->isEmpty());
+
+        $tags = $entry->getTags();
+        $this->assertSame('foo', $tags[0]->getLabel());
+        $this->assertSame('bar', $tags[1]->getLabel());
+    }
+
+    public function testTagWithAMixOfMatchingRules()
+    {
+        $taggingRule = $this->getTaggingRule('bla bla', ['hey']);
+        $otherTaggingRule = $this->getTaggingRule('rule as string', ['foo']);
+
+        $user = $this->getUser([$taggingRule, $otherTaggingRule]);
+        $entry = new Entry($user);
+
+        $this->rulerz
+            ->method('satisfies')
+            ->will($this->onConsecutiveCalls(false, true));
+
+        $this->tagger->tag($entry);
+
+        $this->assertFalse($entry->getTags()->isEmpty());
+
+        $tags = $entry->getTags();
+        $this->assertSame('foo', $tags[0]->getLabel());
+    }
+
+    public function testWhenTheTagExists()
+    {
+        $taggingRule = $this->getTaggingRule('rule as string', ['foo']);
+        $user = $this->getUser([$taggingRule]);
+        $entry = new Entry($user);
+        $tag = new Tag();
+
+        $this->rulerz
+            ->expects($this->once())
+            ->method('satisfies')
+            ->with($entry, 'rule as string')
+            ->willReturn(true);
+
+        $this->tagRepository
+            ->expects($this->once())
+            // the method `findOneByLabel` doesn't exist, EntityRepository will then call `_call` method
+            // to magically call the `findOneBy` with ['label' => 'foo']
+            ->method('__call')
+            ->willReturn($tag);
+
+        $this->tagger->tag($entry);
+
+        $this->assertFalse($entry->getTags()->isEmpty());
+
+        $tags = $entry->getTags();
+        $this->assertSame($tag, $tags[0]);
+    }
+
+    public function testSameTagWithDifferentfMatchingRules()
+    {
+        $taggingRule = $this->getTaggingRule('bla bla', ['hey']);
+        $otherTaggingRule = $this->getTaggingRule('rule as string', ['hey']);
+
+        $user = $this->getUser([$taggingRule, $otherTaggingRule]);
+        $entry = new Entry($user);
+
+        $this->rulerz
+            ->method('satisfies')
+            ->willReturn(true);
+
+        $this->tagger->tag($entry);
+
+        $this->assertFalse($entry->getTags()->isEmpty());
+
+        $tags = $entry->getTags();
+        $this->assertCount(1, $tags);
+    }
+
+    public function testTagAllEntriesForAUser()
+    {
+        $taggingRule = $this->getTaggingRule('bla bla', ['hey']);
+
+        $user = $this->getUser([$taggingRule]);
+
+        $this->rulerz
+            ->method('satisfies')
+            ->willReturn(true);
+
+        $this->rulerz
+            ->method('filter')
+            ->willReturn([new Entry($user), new Entry($user)]);
+
+        $entries = $this->tagger->tagAllForUser($user);
+
+        $this->assertCount(2, $entries);
+
+        foreach ($entries as $entry) {
+            $tags = $entry->getTags();
+
+            $this->assertCount(1, $tags);
+            $this->assertEquals('hey', $tags[0]->getLabel());
+        }
+    }
+
+    private function getUser(array $taggingRules = [])
+    {
+        $user = new User();
+        $config = new Config($user);
+
+        $user->setConfig($config);
+
+        foreach ($taggingRules as $rule) {
+            $config->addTaggingRule($rule);
+        }
+
+        return $user;
+    }
+
+    private function getTaggingRule($rule, array $tags)
+    {
+        $taggingRule = new TaggingRule();
+        $taggingRule->setRule($rule);
+        $taggingRule->setTags($tags);
+
+        return $taggingRule;
+    }
+
+    private function getRulerZMock()
+    {
+        return $this->getMockBuilder('RulerZ\RulerZ')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    private function getTagRepositoryMock()
+    {
+        return $this->getMockBuilder('Wallabag\CoreBundle\Repository\TagRepository')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    private function getEntryRepositoryMock()
+    {
+        return $this->getMockBuilder('Wallabag\CoreBundle\Repository\EntryRepository')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+}
-- 
cgit v1.2.3