mirror of
https://github.com/shlinkio/shlink.git
synced 2024-12-11 17:03:53 +03:00
113 lines
4.4 KiB
PHP
113 lines
4.4 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace ShlinkioTest\Shlink\Rest\Exception;
|
|
|
|
use Exception;
|
|
use Mezzio\ProblemDetails\Exception\ProblemDetailsExceptionInterface;
|
|
use PHPUnit\Framework\Attributes\DataProvider;
|
|
use PHPUnit\Framework\Attributes\Test;
|
|
use PHPUnit\Framework\TestCase;
|
|
use Shlinkio\Shlink\Core\Exception\DeleteShortUrlException;
|
|
use Shlinkio\Shlink\Core\Exception\DomainNotFoundException;
|
|
use Shlinkio\Shlink\Core\Exception\ForbiddenTagOperationException;
|
|
use Shlinkio\Shlink\Core\Exception\InvalidUrlException;
|
|
use Shlinkio\Shlink\Core\Exception\NonUniqueSlugException;
|
|
use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
|
|
use Shlinkio\Shlink\Core\Exception\TagConflictException;
|
|
use Shlinkio\Shlink\Core\Exception\TagNotFoundException;
|
|
use Shlinkio\Shlink\Core\Exception\ValidationException;
|
|
use Shlinkio\Shlink\Rest\Exception\BackwardsCompatibleProblemDetailsException;
|
|
use Shlinkio\Shlink\Rest\Exception\MercureException;
|
|
use Shlinkio\Shlink\Rest\Exception\MissingAuthenticationException;
|
|
use Shlinkio\Shlink\Rest\Exception\VerifyAuthenticationException;
|
|
|
|
class BackwardsCompatibleProblemDetailsExceptionTest extends TestCase
|
|
{
|
|
#[Test, DataProvider('provideTypes')]
|
|
public function typeIsRemappedOnWrappedException(
|
|
string $wrappedType,
|
|
string $expectedType,
|
|
bool $expectSameType = false,
|
|
): void {
|
|
$original = new class ($wrappedType) extends Exception implements ProblemDetailsExceptionInterface {
|
|
public function __construct(private readonly string $type)
|
|
{
|
|
parent::__construct('');
|
|
}
|
|
|
|
public function getStatus(): int
|
|
{
|
|
return 123;
|
|
}
|
|
|
|
public function getType(): string
|
|
{
|
|
return $this->type;
|
|
}
|
|
|
|
public function getTitle(): string
|
|
{
|
|
return 'title';
|
|
}
|
|
|
|
public function getDetail(): string
|
|
{
|
|
return 'detail';
|
|
}
|
|
|
|
public function getAdditionalData(): array
|
|
{
|
|
return [];
|
|
}
|
|
|
|
public function toArray(): array
|
|
{
|
|
return ['type' => $this->type];
|
|
}
|
|
|
|
public function jsonSerialize(): array
|
|
{
|
|
return ['type' => $this->type];
|
|
}
|
|
};
|
|
$e = BackwardsCompatibleProblemDetailsException::fromProblemDetails($original);
|
|
|
|
self::assertEquals($e->getType(), $expectedType);
|
|
self::assertEquals($e->toArray(), ['type' => $expectedType]);
|
|
self::assertEquals($e->jsonSerialize(), ['type' => $expectedType]);
|
|
|
|
self::assertEquals($original->getTitle(), $e->getTitle());
|
|
self::assertEquals($original->getDetail(), $e->getDetail());
|
|
self::assertEquals($original->getAdditionalData(), $e->getAdditionalData());
|
|
|
|
if ($expectSameType) {
|
|
self::assertEquals($original->getType(), $e->getType());
|
|
self::assertEquals($original->toArray(), $e->toArray());
|
|
self::assertEquals($original->jsonSerialize(), $e->jsonSerialize());
|
|
} else {
|
|
self::assertNotEquals($original->getType(), $e->getType());
|
|
self::assertNotEquals($original->toArray(), $e->toArray());
|
|
self::assertNotEquals($original->jsonSerialize(), $e->jsonSerialize());
|
|
}
|
|
}
|
|
|
|
public static function provideTypes(): iterable
|
|
{
|
|
yield ['foo', 'foo', true];
|
|
yield ['bar', 'bar', true];
|
|
yield [ValidationException::ERROR_CODE, 'INVALID_ARGUMENT'];
|
|
yield [DeleteShortUrlException::ERROR_CODE, 'INVALID_SHORT_URL_DELETION'];
|
|
yield [DomainNotFoundException::ERROR_CODE, 'DOMAIN_NOT_FOUND'];
|
|
yield [ForbiddenTagOperationException::ERROR_CODE, 'FORBIDDEN_OPERATION'];
|
|
yield [InvalidUrlException::ERROR_CODE, 'INVALID_URL'];
|
|
yield [NonUniqueSlugException::ERROR_CODE, 'INVALID_SLUG'];
|
|
yield [ShortUrlNotFoundException::ERROR_CODE, 'INVALID_SHORTCODE'];
|
|
yield [TagConflictException::ERROR_CODE, 'TAG_CONFLICT'];
|
|
yield [TagNotFoundException::ERROR_CODE, 'TAG_NOT_FOUND'];
|
|
yield [MercureException::ERROR_CODE, 'MERCURE_NOT_CONFIGURED'];
|
|
yield [MissingAuthenticationException::ERROR_CODE, 'INVALID_AUTHORIZATION'];
|
|
yield [VerifyAuthenticationException::ERROR_CODE, 'INVALID_API_KEY'];
|
|
}
|
|
}
|