ShlinkioTest\Shlink\Core\Entity\ShortUrlTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	67
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	regenerateShortCodeProperlyChangesTheValueOnValidShortUrls()	0	8	1
A	provideValidShortUrls()	0	5	1
A	regenerateShortCodeThrowsExceptionIfStateIsInvalid()	0	8	1
A	provideInvalidShortUrls()	0	9	1
A	shortCodesHaveExpectedLength()	0	7	1
A	provideLengths()	0	4	1

<?php

declare(strict_types=1);

namespace ShlinkioTest\Shlink\Core\Entity;

use Cake\Chronos\Chronos;
use PHPUnit\Framework\TestCase;
use Shlinkio\Shlink\Core\Entity\ShortUrl;
use Shlinkio\Shlink\Core\Exception\ShortCodeCannotBeRegeneratedException;
use Shlinkio\Shlink\Core\Model\ShortUrlMeta;
use Shlinkio\Shlink\Core\Validation\ShortUrlMetaInputFilter;
use Shlinkio\Shlink\Importer\Model\ImportedShlinkUrl;

use function Functional\map;
use function range;
use function strlen;

use const Shlinkio\Shlink\Core\DEFAULT_SHORT_CODES_LENGTH;

The constant Shlinkio\Shlink\Core\DEFAULT_SHORT_CODES_LENGTH was not found. Maybe you did not declare it correctly or list all dependencies?

class ShortUrlTest extends TestCase
{
    /**
     * @test
     * @dataProvider provideInvalidShortUrls
     */
    public function regenerateShortCodeThrowsExceptionIfStateIsInvalid(
        ShortUrl $shortUrl,
        string $expectedMessage
    ): void {
        $this->expectException(ShortCodeCannotBeRegeneratedException::class);
        $this->expectExceptionMessage($expectedMessage);

        $shortUrl->regenerateShortCode();
    }

    public function provideInvalidShortUrls(): iterable
    {
        yield 'with custom slug' => [
            new ShortUrl('', ShortUrlMeta::fromRawData(['customSlug' => 'custom-slug'])),
            'The short code cannot be regenerated on ShortUrls where a custom slug was provided.',
        ];
        yield 'already persisted' => [
            (new ShortUrl(''))->setId('1'),
            'The short code can be regenerated only on new ShortUrls which have not been persisted yet.',
        ];
    }

    /**
     * @test
     * @dataProvider provideValidShortUrls
     */
    public function regenerateShortCodeProperlyChangesTheValueOnValidShortUrls(ShortUrl $shortUrl): void
    {
        $firstShortCode = $shortUrl->getShortCode();

        $shortUrl->regenerateShortCode();
        $secondShortCode = $shortUrl->getShortCode();

        self::assertNotEquals($firstShortCode, $secondShortCode);
    }

    public function provideValidShortUrls(): iterable
    {
        yield 'no custom slug' => [new ShortUrl('')];
        yield 'imported with custom slug' => [
            ShortUrl::fromImport(new ImportedShlinkUrl('', '', [], Chronos::now(), null, 'custom-slug'), true),
        ];
    }

    /**
     * @test
     * @dataProvider provideLengths
     */
    public function shortCodesHaveExpectedLength(?int $length, int $expectedLength): void
    {
        $shortUrl = new ShortUrl('', ShortUrlMeta::fromRawData(
            [ShortUrlMetaInputFilter::SHORT_CODE_LENGTH => $length],
        ));

        self::assertEquals($expectedLength, strlen($shortUrl->getShortCode()));
    }

    public function provideLengths(): iterable
    {
        yield [null, DEFAULT_SHORT_CODES_LENGTH];
        yield from map(range(4, 10), fn (int $value) => [$value, $value]);
    }
}