CreateShortUrlActionTest::provideIdn() - Code Metrics - Inspection of "Handled IDN domains also on internal redirections..." - shlinkio/shlink - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#548)

by Alejandro

created 2019-11-16 11:39 UTC

CreateShortUrlActionTest::provideIdn() A

↳ Parent: CreateShortUrlActionTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

namespace ShlinkioApiTest\Shlink\Rest\Action;

use Cake\Chronos\Chronos;
use GuzzleHttp\RequestOptions;
use Shlinkio\Shlink\Rest\Util\RestUtils;
use Shlinkio\Shlink\TestUtils\ApiTest\ApiTestCase;

use function Functional\map;
use function range;

class CreateShortUrlActionTest extends ApiTestCase
{
    /** @test */
    public function createsNewShortUrlWhenOnlyLongUrlIsProvided(): void
    {
        $expectedKeys = ['shortCode', 'shortUrl', 'longUrl', 'dateCreated', 'visitsCount', 'tags'];
        [$statusCode, $payload] = $this->createShortUrl();

        $this->assertEquals(self::STATUS_OK, $statusCode);
        foreach ($expectedKeys as $key) {
            $this->assertArrayHasKey($key, $payload);
        }
    }

    /** @test */
    public function createsNewShortUrlWithCustomSlug(): void
    {
        [$statusCode, $payload] = $this->createShortUrl(['customSlug' => 'my cool slug']);

        $this->assertEquals(self::STATUS_OK, $statusCode);
        $this->assertEquals('my-cool-slug', $payload['shortCode']);
    }

    /**
     * @test
     * @dataProvider provideConflictingSlugs
     */
    public function failsToCreateShortUrlWithDuplicatedSlug(string $slug, ?string $domain): void
    {
        [$statusCode, $payload] = $this->createShortUrl(['customSlug' => $slug, 'domain' => $domain]);

        $this->assertEquals(self::STATUS_BAD_REQUEST, $statusCode);
        $this->assertEquals(RestUtils::INVALID_SLUG_ERROR, $payload['error']);
    }

    /** @test */
    public function createsNewShortUrlWithTags(): void
    {
        [$statusCode, ['tags' => $tags]] = $this->createShortUrl(['tags' => ['foo', 'bar', 'baz']]);

        $this->assertEquals(self::STATUS_OK, $statusCode);
        $this->assertEquals(['foo', 'bar', 'baz'], $tags);
    }

    /**
     * @test
     * @dataProvider provideMaxVisits
     */
    public function createsNewShortUrlWithVisitsLimit(int $maxVisits): void
    {
        [$statusCode, ['shortCode' => $shortCode]] = $this->createShortUrl(['maxVisits' => $maxVisits]);

        $this->assertEquals(self::STATUS_OK, $statusCode);

        // Last request to the short URL will return a 404, and the rest, a 302
        for ($i = 0; $i < $maxVisits; $i++) {
            $this->assertEquals(self::STATUS_FOUND, $this->callShortUrl($shortCode)->getStatusCode());
        }
        $lastResp = $this->callShortUrl($shortCode);
        $this->assertEquals(self::STATUS_NOT_FOUND, $lastResp->getStatusCode());
    }

    public function provideMaxVisits(): array
    {
        return map(range(10, 15), function (int $i) {
            return [$i];
        });
    }

    /** @test */
    public function createsShortUrlWithValidSince(): void
    {
        [$statusCode, ['shortCode' => $shortCode]] = $this->createShortUrl([
            'validSince' => Chronos::now()->addDay()->toAtomString(),
        ]);

        $this->assertEquals(self::STATUS_OK, $statusCode);

        // Request to the short URL will return a 404 since it's not valid yet
        $lastResp = $this->callShortUrl($shortCode);
        $this->assertEquals(self::STATUS_NOT_FOUND, $lastResp->getStatusCode());
    }

    /** @test */
    public function createsShortUrlWithValidUntil(): void
    {
        [$statusCode, ['shortCode' => $shortCode]] = $this->createShortUrl([
            'validUntil' => Chronos::now()->subDay()->toAtomString(),
        ]);

        $this->assertEquals(self::STATUS_OK, $statusCode);

        // Request to the short URL will return a 404 since it's no longer valid
        $lastResp = $this->callShortUrl($shortCode);
        $this->assertEquals(self::STATUS_NOT_FOUND, $lastResp->getStatusCode());
    }

    /**
     * @test
     * @dataProvider provideMatchingBodies
     */
    public function returnsAnExistingShortUrlWhenRequested(array $body): void
    {
        [$firstStatusCode, ['shortCode' => $firstShortCode]] = $this->createShortUrl($body);

        $body['findIfExists'] = true;
        [$secondStatusCode, ['shortCode' => $secondShortCode]] = $this->createShortUrl($body);

        $this->assertEquals(self::STATUS_OK, $firstStatusCode);
        $this->assertEquals(self::STATUS_OK, $secondStatusCode);
        $this->assertEquals($firstShortCode, $secondShortCode);
    }

    public function provideMatchingBodies(): iterable
    {
        $longUrl = 'https://www.alejandrocelaya.com';

        yield 'only long URL' => [['longUrl' => $longUrl]];
        yield 'long URL and tags' => [['longUrl' => $longUrl, 'tags' => ['boo', 'far']]];
        yield 'long URL and custom slug' => [['longUrl' => $longUrl, 'customSlug' => 'my cool slug']];
        yield 'several params' => [[
            'longUrl' => $longUrl,
            'tags' => ['boo', 'far'],
            'validSince' => Chronos::now()->toAtomString(),
            'maxVisits' => 7,
        ]];
    }

    /**
     * @test
     * @dataProvider provideConflictingSlugs
     */
    public function returnsErrorWhenRequestingReturnExistingButCustomSlugIsInUse(string $slug, ?string $domain): void
    {
        $longUrl = 'https://www.alejandrocelaya.com';

        [$firstStatusCode] = $this->createShortUrl(['longUrl' => $longUrl]);
        [$secondStatusCode] = $this->createShortUrl([
            'longUrl' => $longUrl,
            'customSlug' => $slug,
            'findIfExists' => true,
            'domain' => $domain,
        ]);

        $this->assertEquals(self::STATUS_OK, $firstStatusCode);
        $this->assertEquals(self::STATUS_BAD_REQUEST, $secondStatusCode);
    }

    public function provideConflictingSlugs(): iterable
    {
        yield 'without domain' => ['custom', null];
        yield 'with domain' => ['custom-with-domain', 'some-domain.com'];
    }

    /** @test */
    public function createsNewShortUrlIfRequestedToFindButThereIsNoMatch(): void
    {
        [$firstStatusCode, ['shortCode' => $firstShortCode]] = $this->createShortUrl([
            'longUrl' => 'https://www.alejandrocelaya.com',
        ]);
        [$secondStatusCode, ['shortCode' => $secondShortCode]] = $this->createShortUrl([
            'longUrl' => 'https://www.alejandrocelaya.com/projects',
            'findIfExists' => true,
        ]);

        $this->assertEquals(self::STATUS_OK, $firstStatusCode);
        $this->assertEquals(self::STATUS_OK, $secondStatusCode);
        $this->assertNotEquals($firstShortCode, $secondShortCode);
    }

    /**
     * @test
     * @dataProvider provideIdn
     */
    public function createsNewShortUrlWithInternationalizedDomainName(string $longUrl): void
    {
        [$statusCode, ['longUrl' => $expectedLongUrl]] = $this->createShortUrl(['longUrl' => $longUrl]);

        $this->assertEquals(self::STATUS_OK, $statusCode);
        $this->assertEquals($expectedLongUrl, $longUrl);
    }

    public function provideIdn(): iterable
    {
        // TODO Create some shlink IDN domains to test this instead of using public ones
        return [['https://cédric.laubacher.io/'], ['https://laubacher.io/']]; // Second one redirects to first
    }

    /**
     * @return array {
     *     @var int $statusCode
     *     @var array $payload
     * }
     */
    private function createShortUrl(array $body = []): array
    {
        if (! isset($body['longUrl'])) {
            $body['longUrl'] = 'https://app.shlink.io';
        }
        $resp = $this->callApiWithKey(self::METHOD_POST, '/short-urls', [RequestOptions::JSON => $body]);
        $payload = $this->getJsonResponsePayload($resp);

        return [$resp->getStatusCode(), $payload];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ShlinkioApiTest\Shlink\Rest\Action;
6
7			use Cake\Chronos\Chronos;
8			use GuzzleHttp\RequestOptions;
9			use Shlinkio\Shlink\Rest\Util\RestUtils;
10			use Shlinkio\Shlink\TestUtils\ApiTest\ApiTestCase;
11
12			use function Functional\map;
13			use function range;
14
15			class CreateShortUrlActionTest extends ApiTestCase
16			{
17			/** @test */
18			public function createsNewShortUrlWhenOnlyLongUrlIsProvided(): void
19			{
20			$expectedKeys = ['shortCode', 'shortUrl', 'longUrl', 'dateCreated', 'visitsCount', 'tags'];
21			[$statusCode, $payload] = $this->createShortUrl();
22
23			$this->assertEquals(self::STATUS_OK, $statusCode);
24			foreach ($expectedKeys as $key) {
25			$this->assertArrayHasKey($key, $payload);
26			}
27			}
28
29			/** @test */
30			public function createsNewShortUrlWithCustomSlug(): void
31			{
32			[$statusCode, $payload] = $this->createShortUrl(['customSlug' => 'my cool slug']);
33
34			$this->assertEquals(self::STATUS_OK, $statusCode);
35			$this->assertEquals('my-cool-slug', $payload['shortCode']);
36			}
37
38			/**
39			* @test
40			* @dataProvider provideConflictingSlugs
41			*/
42			public function failsToCreateShortUrlWithDuplicatedSlug(string $slug, ?string $domain): void
43			{
44			[$statusCode, $payload] = $this->createShortUrl(['customSlug' => $slug, 'domain' => $domain]);
45
46			$this->assertEquals(self::STATUS_BAD_REQUEST, $statusCode);
47			$this->assertEquals(RestUtils::INVALID_SLUG_ERROR, $payload['error']);
48			}
49
50			/** @test */
51			public function createsNewShortUrlWithTags(): void
52			{
53			[$statusCode, ['tags' => $tags]] = $this->createShortUrl(['tags' => ['foo', 'bar', 'baz']]);
54
55			$this->assertEquals(self::STATUS_OK, $statusCode);
56			$this->assertEquals(['foo', 'bar', 'baz'], $tags);
57			}
58
59			/**
60			* @test
61			* @dataProvider provideMaxVisits
62			*/
63			public function createsNewShortUrlWithVisitsLimit(int $maxVisits): void
64			{
65			[$statusCode, ['shortCode' => $shortCode]] = $this->createShortUrl(['maxVisits' => $maxVisits]);
66
67			$this->assertEquals(self::STATUS_OK, $statusCode);
68
69			// Last request to the short URL will return a 404, and the rest, a 302
70			for ($i = 0; $i < $maxVisits; $i++) {
71			$this->assertEquals(self::STATUS_FOUND, $this->callShortUrl($shortCode)->getStatusCode());
72			}
73			$lastResp = $this->callShortUrl($shortCode);
74			$this->assertEquals(self::STATUS_NOT_FOUND, $lastResp->getStatusCode());
75			}
76
77			public function provideMaxVisits(): array
78			{
79			return map(range(10, 15), function (int $i) {
80			return [$i];
81			});
82			}
83
84			/** @test */
85			public function createsShortUrlWithValidSince(): void
86			{
87			[$statusCode, ['shortCode' => $shortCode]] = $this->createShortUrl([
88			'validSince' => Chronos::now()->addDay()->toAtomString(),
89			]);
90
91			$this->assertEquals(self::STATUS_OK, $statusCode);
92
93			// Request to the short URL will return a 404 since it's not valid yet
94			$lastResp = $this->callShortUrl($shortCode);
95			$this->assertEquals(self::STATUS_NOT_FOUND, $lastResp->getStatusCode());
96			}
97
98			/** @test */
99			public function createsShortUrlWithValidUntil(): void
100			{
101			[$statusCode, ['shortCode' => $shortCode]] = $this->createShortUrl([
102			'validUntil' => Chronos::now()->subDay()->toAtomString(),
103			]);
104
105			$this->assertEquals(self::STATUS_OK, $statusCode);
106
107			// Request to the short URL will return a 404 since it's no longer valid
108			$lastResp = $this->callShortUrl($shortCode);
109			$this->assertEquals(self::STATUS_NOT_FOUND, $lastResp->getStatusCode());
110			}
111
112			/**
113			* @test
114			* @dataProvider provideMatchingBodies
115			*/
116			public function returnsAnExistingShortUrlWhenRequested(array $body): void
117			{
118			[$firstStatusCode, ['shortCode' => $firstShortCode]] = $this->createShortUrl($body);
119
120			$body['findIfExists'] = true;
121			[$secondStatusCode, ['shortCode' => $secondShortCode]] = $this->createShortUrl($body);
122
123			$this->assertEquals(self::STATUS_OK, $firstStatusCode);
124			$this->assertEquals(self::STATUS_OK, $secondStatusCode);
125			$this->assertEquals($firstShortCode, $secondShortCode);
126			}
127
128			public function provideMatchingBodies(): iterable
129			{
130			$longUrl = 'https://www.alejandrocelaya.com';
131
132			yield 'only long URL' => [['longUrl' => $longUrl]];
133			yield 'long URL and tags' => [['longUrl' => $longUrl, 'tags' => ['boo', 'far']]];
134			yield 'long URL and custom slug' => [['longUrl' => $longUrl, 'customSlug' => 'my cool slug']];
135			yield 'several params' => [[
136			'longUrl' => $longUrl,
137			'tags' => ['boo', 'far'],
138			'validSince' => Chronos::now()->toAtomString(),
139			'maxVisits' => 7,
140			]];
141			}
142
143			/**
144			* @test
145			* @dataProvider provideConflictingSlugs
146			*/
147			public function returnsErrorWhenRequestingReturnExistingButCustomSlugIsInUse(string $slug, ?string $domain): void
148			{
149			$longUrl = 'https://www.alejandrocelaya.com';
150
151			[$firstStatusCode] = $this->createShortUrl(['longUrl' => $longUrl]);
152			[$secondStatusCode] = $this->createShortUrl([
153			'longUrl' => $longUrl,
154			'customSlug' => $slug,
155			'findIfExists' => true,
156			'domain' => $domain,
157			]);
158
159			$this->assertEquals(self::STATUS_OK, $firstStatusCode);
160			$this->assertEquals(self::STATUS_BAD_REQUEST, $secondStatusCode);
161			}
162
163			public function provideConflictingSlugs(): iterable
164			{
165			yield 'without domain' => ['custom', null];
166			yield 'with domain' => ['custom-with-domain', 'some-domain.com'];
167			}
168
169			/** @test */
170			public function createsNewShortUrlIfRequestedToFindButThereIsNoMatch(): void
171			{
172			[$firstStatusCode, ['shortCode' => $firstShortCode]] = $this->createShortUrl([
173			'longUrl' => 'https://www.alejandrocelaya.com',
174			]);
175			[$secondStatusCode, ['shortCode' => $secondShortCode]] = $this->createShortUrl([
176			'longUrl' => 'https://www.alejandrocelaya.com/projects',
177			'findIfExists' => true,
178			]);
179
180			$this->assertEquals(self::STATUS_OK, $firstStatusCode);
181			$this->assertEquals(self::STATUS_OK, $secondStatusCode);
182			$this->assertNotEquals($firstShortCode, $secondShortCode);
183			}
184
185			/**
186			* @test
187			* @dataProvider provideIdn
188			*/
189			public function createsNewShortUrlWithInternationalizedDomainName(string $longUrl): void
190			{
191			[$statusCode, ['longUrl' => $expectedLongUrl]] = $this->createShortUrl(['longUrl' => $longUrl]);
192
193			$this->assertEquals(self::STATUS_OK, $statusCode);
194			$this->assertEquals($expectedLongUrl, $longUrl);
195			}
196
197			public function provideIdn(): iterable
198			{
199			// TODO Create some shlink IDN domains to test this instead of using public ones
200			return [['https://cédric.laubacher.io/'], ['https://laubacher.io/']]; // Second one redirects to first
201			}
202
203			/**
204			* @return array {
205			* @var int $statusCode
206			* @var array $payload
207			* }
208			*/
209			private function createShortUrl(array $body = []): array
210			{
211			if (! isset($body['longUrl'])) {
212			$body['longUrl'] = 'https://app.shlink.io';
213			}
214			$resp = $this->callApiWithKey(self::METHOD_POST, '/short-urls', [RequestOptions::JSON => $body]);
215			$payload = $this->getJsonResponsePayload($resp);
216
217			return [$resp->getStatusCode(), $payload];
218			}
219			}
220

shlinkio / shlink

Pull Request — master (#548)

CreateShortUrlActionTest::provideIdn() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like