ShlinkioTest\Shlink\Core\Service\UrlShortenerTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
B	setUp()	0	24	1
A	setUrlShortener()	0	10	1
A	urlIsProperlyShortened()	0	6	1
A	exceptionIsThrownWhenOrmThrowsException()	0	11	1
A	exceptionIsThrownWhenUrlDoesNotExist()	0	9	1
A	whenShortUrlExistsItsShortcodeIsReturned()	0	11	1
A	shortCodeIsProperlyParsed()	0	17	1
A	invalidCharSetThrowsException()	0	4	1
A	cachedShortCodeDoesNotHitDatabase()	0	10	1

<?php
namespace ShlinkioTest\Shlink\Core\Service;

use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Cache\Cache;
use Doctrine\Common\Persistence\ObjectRepository;
use Doctrine\DBAL\Connection;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\ORMException;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Psr7\Request;
use PHPUnit\Framework\TestCase;
use Prophecy\Argument;
use Prophecy\Prophecy\ObjectProphecy;
use Shlinkio\Shlink\Core\Entity\ShortUrl;
use Shlinkio\Shlink\Core\Service\UrlShortener;
use Zend\Diactoros\Uri;

class UrlShortenerTest extends TestCase
{
    /**
     * @var UrlShortener
     */
    protected $urlShortener;
    /**
     * @var ObjectProphecy
     */
    protected $em;
    /**
     * @var ObjectProphecy
     */
    protected $httpClient;
    /**
     * @var Cache
     */
    protected $cache;

    public function setUp()
    {
        $this->httpClient = $this->prophesize(ClientInterface::class);

        $this->em = $this->prophesize(EntityManagerInterface::class);
        $conn = $this->prophesize(Connection::class);
        $conn->isTransactionActive()->willReturn(false);
        $this->em->getConnection()->willReturn($conn->reveal());
        $this->em->flush()->willReturn(null);
        $this->em->commit()->willReturn(null);
        $this->em->beginTransaction()->willReturn(null);
        $this->em->persist(Argument::any())->will(function ($arguments) {
            /** @var ShortUrl $shortUrl */
            $shortUrl = $arguments[0];
            $shortUrl->setId(10);
        });
        $repo = $this->prophesize(ObjectRepository::class);
        $repo->findOneBy(Argument::any())->willReturn(null);
        $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());

        $this->cache = new ArrayCache();

        $this->setUrlShortener(false);
    }

    /**
     * @param bool $isUrlValidationExists
     */
    public function setUrlShortener($isUrlValidationExists)
    {
        $this->urlShortener = new UrlShortener(
            $this->httpClient->reveal(),
            $this->em->reveal(),
            $this->cache,
            UrlShortener::DEFAULT_CHARS,
            $isUrlValidationExists
        );
    }

    /**
     * @test
     */
    public function urlIsProperlyShortened()
    {
        // 10 -> 12C1c

43% of this comment could be valid code. Did you maybe forget this after debugging?

        $shortCode = $this->urlShortener->urlToShortCode(new Uri('http://foobar.com/12345/hello?foo=bar'));
        $this->assertEquals('12C1c', $shortCode);
    }

    /**
     * @test
     * @expectedException \Shlinkio\Shlink\Common\Exception\RuntimeException
     */
    public function exceptionIsThrownWhenOrmThrowsException()
    {
        $conn = $this->prophesize(Connection::class);
        $conn->isTransactionActive()->willReturn(true);
        $this->em->getConnection()->willReturn($conn->reveal());
        $this->em->rollback()->shouldBeCalledTimes(1);
        $this->em->close()->shouldBeCalledTimes(1);

        $this->em->flush()->willThrow(new ORMException());
        $this->urlShortener->urlToShortCode(new Uri('http://foobar.com/12345/hello?foo=bar'));
    }

    /**
     * @test
     * @expectedException \Shlinkio\Shlink\Core\Exception\InvalidUrlException
     */
    public function exceptionIsThrownWhenUrlDoesNotExist()
    {
        $this->setUrlShortener(true);

        $this->httpClient->request(Argument::cetera())->willThrow(
            new ClientException('', $this->prophesize(Request::class)->reveal())
        );
        $this->urlShortener->urlToShortCode(new Uri('http://foobar.com/12345/hello?foo=bar'));
    }

    /**
     * @test
     */
    public function whenShortUrlExistsItsShortcodeIsReturned()
    {
        $shortUrl = new ShortUrl();
        $shortUrl->setShortCode('expected_shortcode');
        $repo = $this->prophesize(ObjectRepository::class);
        $repo->findOneBy(Argument::any())->willReturn($shortUrl);
        $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());

        $shortCode = $this->urlShortener->urlToShortCode(new Uri('http://foobar.com/12345/hello?foo=bar'));
        $this->assertEquals($shortUrl->getShortCode(), $shortCode);
    }

    /**
     * @test
     */
    public function shortCodeIsProperlyParsed()
    {
        // 12C1c -> 10

43% of this comment could be valid code. Did you maybe forget this after debugging?

        $shortCode = '12C1c';
        $shortUrl = new ShortUrl();
        $shortUrl->setShortCode($shortCode)
                 ->setOriginalUrl('expected_url');

        $repo = $this->prophesize(ObjectRepository::class);
        $repo->findOneBy(['shortCode' => $shortCode])->willReturn($shortUrl);
        $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());

        $this->assertFalse($this->cache->contains($shortCode . '_longUrl'));
        $url = $this->urlShortener->shortCodeToUrl($shortCode);
        $this->assertEquals($shortUrl->getOriginalUrl(), $url);
        $this->assertTrue($this->cache->contains($shortCode . '_longUrl'));
    }

    /**
     * @test
     * @expectedException \Shlinkio\Shlink\Core\Exception\InvalidShortCodeException
     */
    public function invalidCharSetThrowsException()
    {
        $this->urlShortener->shortCodeToUrl('&/(');
    }

    /**
     * @test
     */
    public function cachedShortCodeDoesNotHitDatabase()
    {
        $shortCode = '12C1c';
        $expectedUrl = 'expected_url';
        $this->cache->save($shortCode . '_longUrl', $expectedUrl);
        $this->em->getRepository(ShortUrl::class)->willReturn(null)->shouldBeCalledTimes(0);

        $url = $this->urlShortener->shortCodeToUrl($shortCode);
        $this->assertEquals($expectedUrl, $url);
    }
}