UrlShortenerTest::whenCustomSlugIsProvidedItIsUsed() - Code Metrics - Inspection of "Feature/allow check duplicates" - shlinkio/shlink - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#343)

by Alejandro

created 2019-02-03 10:24 UTC

whenCustomSlugIsProvidedItIsUsed() A

↳ Parent: UrlShortenerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	7
nc	1
nop	0
dl	0
loc	14
rs	10
c	0
b	0
f	0

<?php
declare(strict_types=1);

namespace ShlinkioTest\Shlink\Core\Service;

use Cake\Chronos\Chronos;
use Doctrine\Common\Collections\ArrayCollection;
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\MethodProphecy;
use Prophecy\Prophecy\ObjectProphecy;
use Shlinkio\Shlink\Core\Entity\ShortUrl;
use Shlinkio\Shlink\Core\Entity\Tag;
use Shlinkio\Shlink\Core\Exception\NonUniqueSlugException;
use Shlinkio\Shlink\Core\Model\ShortUrlMeta;
use Shlinkio\Shlink\Core\Options\UrlShortenerOptions;
use Shlinkio\Shlink\Core\Repository\ShortUrlRepository;
use Shlinkio\Shlink\Core\Repository\ShortUrlRepositoryInterface;
use Shlinkio\Shlink\Core\Service\UrlShortener;
use Zend\Diactoros\Uri;

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

    public function setUp(): void
    {
        $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(ShortUrlRepository::class);
        $repo->count(Argument::any())->willReturn(0);
        $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());

        $this->setUrlShortener(false);
    }

    public function setUrlShortener(bool $urlValidationEnabled): void
    {
        $this->urlShortener = new UrlShortener(
            $this->httpClient->reveal(),
            $this->em->reveal(),
            new UrlShortenerOptions(['validate_url' => $urlValidationEnabled])
        );
    }

    /**
     * @test
     */
    public function urlIsProperlyShortened(): void
    {
        // 10 -> 12C1c
        $shortUrl = $this->urlShortener->urlToShortCode(
            new Uri('http://foobar.com/12345/hello?foo=bar'),
            [],
            ShortUrlMeta::createEmpty()
        );
        $this->assertEquals('12C1c', $shortUrl->getShortCode());
    }

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

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

    /**
     * @test
     * @expectedException \Shlinkio\Shlink\Core\Exception\InvalidUrlException
     */
    public function exceptionIsThrownWhenUrlDoesNotExist(): void
    {
        $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'),
            [],
            ShortUrlMeta::createEmpty()
        );
    }

    /**
     * @test
     */
    public function exceptionIsThrownWhenNonUniqueSlugIsProvided(): void
    {
        $repo = $this->prophesize(ShortUrlRepository::class);
        $countBySlug = $repo->count(['shortCode' => 'custom-slug'])->willReturn(1);
        $repo->findOneBy(Argument::cetera())->willReturn(null);
        /** @var MethodProphecy $getRepo */
        $getRepo = $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());

        $countBySlug->shouldBeCalledOnce();
        $getRepo->shouldBeCalled();
        $this->expectException(NonUniqueSlugException::class);

        $this->urlShortener->urlToShortCode(
            new Uri('http://foobar.com/12345/hello?foo=bar'),
            [],
            ShortUrlMeta::createFromRawData(['customSlug' => 'custom-slug'])
        );
    }

    /**
     * @test
     * @dataProvider provideExsitingShortUrls
     */
    public function existingShortUrlIsReturnedWhenRequested(
        string $url,
        array $tags,
        ShortUrlMeta $meta,
        ?ShortUrl $expected
    ): void {
        $repo = $this->prophesize(ShortUrlRepository::class);
        $findExisting = $repo->findOneBy(Argument::any())->willReturn($expected);
        $getRepo = $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());

        $result = $this->urlShortener->urlToShortCode(new Uri($url), $tags, $meta);

        $this->assertSame($expected, $result);
        $findExisting->shouldHaveBeenCalledOnce();
        $getRepo->shouldHaveBeenCalledOnce();
    }

    public function provideExsitingShortUrls(): array
    {
        $url = 'http://foo.com';

        return [
            [$url, [], ShortUrlMeta::createFromRawData(['findIfExists' => true]), new ShortUrl($url)],
            [$url, [], ShortUrlMeta::createFromRawData(
                ['findIfExists' => true, 'customSlug' => 'foo']
            ), new ShortUrl($url)],
            [
                $url,
                ['foo', 'bar'],
                ShortUrlMeta::createFromRawData(['findIfExists' => true]),
                (new ShortUrl($url))->setTags(new ArrayCollection([new Tag('bar'), new Tag('foo')])),
            ],
            [
                $url,
                [],
                ShortUrlMeta::createFromRawData(['findIfExists' => true, 'maxVisits' => 3]),
                new ShortUrl($url, ShortUrlMeta::createFromRawData(['maxVisits' => 3])),
            ],
            [
                $url,
                [],
                ShortUrlMeta::createFromRawData(['findIfExists' => true, 'validSince' => Chronos::parse('2017-01-01')]),
                new ShortUrl($url, ShortUrlMeta::createFromRawData(['validSince' => Chronos::parse('2017-01-01')])),
            ],
            [
                $url,
                [],
                ShortUrlMeta::createFromRawData(['findIfExists' => true, 'validUntil' => Chronos::parse('2017-01-01')]),
                new ShortUrl($url, ShortUrlMeta::createFromRawData(['validUntil' => Chronos::parse('2017-01-01')])),
            ],
            [
                $url,
                ['baz', 'foo', 'bar'],
                ShortUrlMeta::createFromRawData([
                    'findIfExists' => true,
                    'validUntil' => Chronos::parse('2017-01-01'),
                    'maxVisits' => 4,
                ]),
                (new ShortUrl($url, ShortUrlMeta::createFromRawData([
                    'validUntil' => Chronos::parse('2017-01-01'),
                    'maxVisits' => 4,
                ])))->setTags(new ArrayCollection([new Tag('foo'), new Tag('bar'), new Tag('baz')])),
            ],
        ];
    }

    /**
     * @test
     */
    public function shortCodeIsProperlyParsed(): void
    {
        // 12C1c -> 10
        $shortCode = '12C1c';
        $shortUrl = new ShortUrl('expected_url');
        $shortUrl->setShortCode($shortCode);

        $repo = $this->prophesize(ShortUrlRepositoryInterface::class);
        $repo->findOneByShortCode($shortCode)->willReturn($shortUrl);
        $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());

        $url = $this->urlShortener->shortCodeToUrl($shortCode);
        $this->assertSame($shortUrl, $url);
    }

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


1			<?php
2			declare(strict_types=1);
3
4			namespace ShlinkioTest\Shlink\Core\Service;
5
6			use Cake\Chronos\Chronos;
7			use Doctrine\Common\Collections\ArrayCollection;
8			use Doctrine\DBAL\Connection;
9			use Doctrine\ORM\EntityManagerInterface;
10			use Doctrine\ORM\ORMException;
11			use GuzzleHttp\ClientInterface;
12			use GuzzleHttp\Exception\ClientException;
13			use GuzzleHttp\Psr7\Request;
14			use PHPUnit\Framework\TestCase;
15			use Prophecy\Argument;
16			use Prophecy\Prophecy\MethodProphecy;
17			use Prophecy\Prophecy\ObjectProphecy;
18			use Shlinkio\Shlink\Core\Entity\ShortUrl;
19			use Shlinkio\Shlink\Core\Entity\Tag;
20			use Shlinkio\Shlink\Core\Exception\NonUniqueSlugException;
21			use Shlinkio\Shlink\Core\Model\ShortUrlMeta;
22			use Shlinkio\Shlink\Core\Options\UrlShortenerOptions;
23			use Shlinkio\Shlink\Core\Repository\ShortUrlRepository;
24			use Shlinkio\Shlink\Core\Repository\ShortUrlRepositoryInterface;
25			use Shlinkio\Shlink\Core\Service\UrlShortener;
26			use Zend\Diactoros\Uri;
27
28			class UrlShortenerTest extends TestCase
29			{
30			/** @var UrlShortener */
31			private $urlShortener;
32			/** @var ObjectProphecy */
33			private $em;
34			/** @var ObjectProphecy */
35			private $httpClient;
36
37			public function setUp(): void
38			{
39			$this->httpClient = $this->prophesize(ClientInterface::class);
40
41			$this->em = $this->prophesize(EntityManagerInterface::class);
42			$conn = $this->prophesize(Connection::class);
43			$conn->isTransactionActive()->willReturn(false);
44			$this->em->getConnection()->willReturn($conn->reveal());
45			$this->em->flush()->willReturn(null);
46			$this->em->commit()->willReturn(null);
47			$this->em->beginTransaction()->willReturn(null);
48			$this->em->persist(Argument::any())->will(function ($arguments) {
49			/** @var ShortUrl $shortUrl */
50			$shortUrl = $arguments[0];
51			$shortUrl->setId('10');
52			});
53			$repo = $this->prophesize(ShortUrlRepository::class);
54			$repo->count(Argument::any())->willReturn(0);
55			$this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
56
57			$this->setUrlShortener(false);
58			}
59
60			public function setUrlShortener(bool $urlValidationEnabled): void
61			{
62			$this->urlShortener = new UrlShortener(
63			$this->httpClient->reveal(),
64			$this->em->reveal(),
65			new UrlShortenerOptions(['validate_url' => $urlValidationEnabled])
66			);
67			}
68
69			/**
70			* @test
71			*/
72			public function urlIsProperlyShortened(): void
73			{
74			// 10 -> 12C1c
75			$shortUrl = $this->urlShortener->urlToShortCode(
76			new Uri('http://foobar.com/12345/hello?foo=bar'),
77			[],
78			ShortUrlMeta::createEmpty()
79			);
80			$this->assertEquals('12C1c', $shortUrl->getShortCode());
81			}
82
83			/**
84			* @test
85			* @expectedException \Shlinkio\Shlink\Core\Exception\RuntimeException
86			*/
87			public function exceptionIsThrownWhenOrmThrowsException(): void
88			{
89			$conn = $this->prophesize(Connection::class);
90			$conn->isTransactionActive()->willReturn(true);
91			$this->em->getConnection()->willReturn($conn->reveal());
92			$this->em->rollback()->shouldBeCalledOnce();
93			$this->em->close()->shouldBeCalledOnce();
94
95			$this->em->flush()->willThrow(new ORMException());
96			$this->urlShortener->urlToShortCode(
97			new Uri('http://foobar.com/12345/hello?foo=bar'),
98			[],
99			ShortUrlMeta::createEmpty()
100			);
101			}
102
103			/**
104			* @test
105			* @expectedException \Shlinkio\Shlink\Core\Exception\InvalidUrlException
106			*/
107			public function exceptionIsThrownWhenUrlDoesNotExist(): void
108			{
109			$this->setUrlShortener(true);
110
111			$this->httpClient->request(Argument::cetera())->willThrow(
112			new ClientException('', $this->prophesize(Request::class)->reveal())
113			);
114			$this->urlShortener->urlToShortCode(
115			new Uri('http://foobar.com/12345/hello?foo=bar'),
116			[],
117			ShortUrlMeta::createEmpty()
118			);
119			}
120
121			/**
122			* @test
123			*/
124			public function exceptionIsThrownWhenNonUniqueSlugIsProvided(): void
125			{
126			$repo = $this->prophesize(ShortUrlRepository::class);
127			$countBySlug = $repo->count(['shortCode' => 'custom-slug'])->willReturn(1);
128			$repo->findOneBy(Argument::cetera())->willReturn(null);
129			/** @var MethodProphecy $getRepo */
130			$getRepo = $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
131
132			$countBySlug->shouldBeCalledOnce();
133			$getRepo->shouldBeCalled();
134			$this->expectException(NonUniqueSlugException::class);
135
136			$this->urlShortener->urlToShortCode(
137			new Uri('http://foobar.com/12345/hello?foo=bar'),
138			[],
139			ShortUrlMeta::createFromRawData(['customSlug' => 'custom-slug'])
140			);
141			}
142
143			/**
144			* @test
145			* @dataProvider provideExsitingShortUrls
146			*/
147			public function existingShortUrlIsReturnedWhenRequested(
148			string $url,
149			array $tags,
150			ShortUrlMeta $meta,
151			?ShortUrl $expected
152			): void {
153			$repo = $this->prophesize(ShortUrlRepository::class);
154			$findExisting = $repo->findOneBy(Argument::any())->willReturn($expected);
155			$getRepo = $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
156
157			$result = $this->urlShortener->urlToShortCode(new Uri($url), $tags, $meta);
158
159			$this->assertSame($expected, $result);
160			$findExisting->shouldHaveBeenCalledOnce();
161			$getRepo->shouldHaveBeenCalledOnce();
162			}
163
164			public function provideExsitingShortUrls(): array
165			{
166			$url = 'http://foo.com';
167
168			return [
169			[$url, [], ShortUrlMeta::createFromRawData(['findIfExists' => true]), new ShortUrl($url)],
170			[$url, [], ShortUrlMeta::createFromRawData(
171			['findIfExists' => true, 'customSlug' => 'foo']
172			), new ShortUrl($url)],
173			[
174			$url,
175			['foo', 'bar'],
176			ShortUrlMeta::createFromRawData(['findIfExists' => true]),
177			(new ShortUrl($url))->setTags(new ArrayCollection([new Tag('bar'), new Tag('foo')])),
178			],
179			[
180			$url,
181			[],
182			ShortUrlMeta::createFromRawData(['findIfExists' => true, 'maxVisits' => 3]),
183			new ShortUrl($url, ShortUrlMeta::createFromRawData(['maxVisits' => 3])),
184			],
185			[
186			$url,
187			[],
188			ShortUrlMeta::createFromRawData(['findIfExists' => true, 'validSince' => Chronos::parse('2017-01-01')]),
189			new ShortUrl($url, ShortUrlMeta::createFromRawData(['validSince' => Chronos::parse('2017-01-01')])),
190			],
191			[
192			$url,
193			[],
194			ShortUrlMeta::createFromRawData(['findIfExists' => true, 'validUntil' => Chronos::parse('2017-01-01')]),
195			new ShortUrl($url, ShortUrlMeta::createFromRawData(['validUntil' => Chronos::parse('2017-01-01')])),
196			],
197			[
198			$url,
199			['baz', 'foo', 'bar'],
200			ShortUrlMeta::createFromRawData([
201			'findIfExists' => true,
202			'validUntil' => Chronos::parse('2017-01-01'),
203			'maxVisits' => 4,
204			]),
205			(new ShortUrl($url, ShortUrlMeta::createFromRawData([
206			'validUntil' => Chronos::parse('2017-01-01'),
207			'maxVisits' => 4,
208			])))->setTags(new ArrayCollection([new Tag('foo'), new Tag('bar'), new Tag('baz')])),
209			],
210			];
211			}
212
213			/**
214			* @test
215			*/
216			public function shortCodeIsProperlyParsed(): void
217			{
218			// 12C1c -> 10
219			$shortCode = '12C1c';
220			$shortUrl = new ShortUrl('expected_url');
221			$shortUrl->setShortCode($shortCode);
222
223			$repo = $this->prophesize(ShortUrlRepositoryInterface::class);
224			$repo->findOneByShortCode($shortCode)->willReturn($shortUrl);
225			$this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
226
227			$url = $this->urlShortener->shortCodeToUrl($shortCode);
228			$this->assertSame($shortUrl, $url);
229			}
230
231			/**
232			* @test
233			* @expectedException \Shlinkio\Shlink\Core\Exception\InvalidShortCodeException
234			*/
235			public function invalidCharSetThrowsException(): void
236			{
237			$this->urlShortener->shortCodeToUrl('&/(');
238			}
239			}
240

shlinkio / shlink

Pull Request — master (#343)

whenCustomSlugIsProvidedItIsUsed() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like