shlink/module/Core/test/Action/QrCodeActionTest.php

256 lines
9.6 KiB
PHP
Raw Normal View History

2016-08-09 07:18:20 -05:00
<?php
2019-10-05 10:26:10 -05:00
2017-10-12 03:13:20 -05:00
declare(strict_types=1);
2016-08-09 07:18:20 -05:00
namespace ShlinkioTest\Shlink\Core\Action;
2020-01-01 14:11:53 -06:00
use Laminas\Diactoros\Response;
use Laminas\Diactoros\ServerRequest;
use Laminas\Diactoros\ServerRequestFactory;
2017-03-24 14:34:18 -05:00
use PHPUnit\Framework\TestCase;
2016-08-09 07:18:20 -05:00
use Prophecy\Argument;
2020-11-02 04:50:19 -06:00
use Prophecy\PhpUnit\ProphecyTrait;
2016-08-09 07:18:20 -05:00
use Prophecy\Prophecy\ObjectProphecy;
use Psr\Http\Message\ServerRequestInterface;
2018-03-26 12:02:41 -05:00
use Psr\Http\Server\RequestHandlerInterface;
use Psr\Log\NullLogger;
2016-08-09 07:18:20 -05:00
use Shlinkio\Shlink\Common\Response\QrCodeResponse;
use Shlinkio\Shlink\Core\Action\QrCodeAction;
use Shlinkio\Shlink\Core\Entity\ShortUrl;
use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
use Shlinkio\Shlink\Core\Options\QrCodeOptions;
use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;
use Shlinkio\Shlink\Core\ShortUrl\Helper\ShortUrlStringifier;
use Shlinkio\Shlink\Core\ShortUrl\Model\ShortUrlIdentifier;
2016-08-09 07:18:20 -05:00
use function getimagesizefromstring;
use function imagecolorat;
use function imagecreatefromstring;
2016-08-09 07:18:20 -05:00
class QrCodeActionTest extends TestCase
{
2020-11-02 04:50:19 -06:00
use ProphecyTrait;
private const WHITE = 0xFFFFFF;
private const BLACK = 0x0;
private ObjectProphecy $urlResolver;
2016-08-09 07:18:20 -05:00
protected function setUp(): void
2016-08-09 07:18:20 -05:00
{
$this->urlResolver = $this->prophesize(ShortUrlResolverInterface::class);
2016-08-09 07:18:20 -05:00
}
2019-02-17 13:28:34 -06:00
/** @test */
2019-10-22 12:52:28 -05:00
public function aNotFoundShortCodeWillDelegateIntoNextMiddleware(): void
2016-08-09 07:18:20 -05:00
{
$shortCode = 'abc123';
$this->urlResolver->resolveEnabledShortUrl(ShortUrlIdentifier::fromShortCodeAndDomain($shortCode, ''))
->willThrow(ShortUrlNotFoundException::class)
->shouldBeCalledOnce();
2018-03-26 12:02:41 -05:00
$delegate = $this->prophesize(RequestHandlerInterface::class);
$process = $delegate->handle(Argument::any())->willReturn(new Response());
2016-08-09 07:18:20 -05:00
$this->action()->process((new ServerRequest())->withAttribute('shortCode', $shortCode), $delegate->reveal());
2018-11-11 06:18:21 -06:00
$process->shouldHaveBeenCalledOnce();
2016-08-09 07:18:20 -05:00
}
2019-02-17 13:28:34 -06:00
/** @test */
2019-10-22 12:52:28 -05:00
public function aCorrectRequestReturnsTheQrCodeResponse(): void
2016-08-09 07:18:20 -05:00
{
$shortCode = 'abc123';
$this->urlResolver->resolveEnabledShortUrl(ShortUrlIdentifier::fromShortCodeAndDomain($shortCode, ''))
->willReturn(ShortUrl::createEmpty())
->shouldBeCalledOnce();
2018-03-26 12:02:41 -05:00
$delegate = $this->prophesize(RequestHandlerInterface::class);
2016-08-09 07:18:20 -05:00
$resp = $this->action()->process(
(new ServerRequest())->withAttribute('shortCode', $shortCode),
2020-01-01 13:48:31 -06:00
$delegate->reveal(),
2016-08-09 07:18:20 -05:00
);
2020-10-03 17:35:14 -05:00
self::assertInstanceOf(QrCodeResponse::class, $resp);
self::assertEquals(200, $resp->getStatusCode());
2018-03-26 12:02:41 -05:00
$delegate->handle(Argument::any())->shouldHaveBeenCalledTimes(0);
2016-08-09 07:18:20 -05:00
}
2020-09-21 15:54:05 -05:00
/**
* @test
* @dataProvider provideQueries
*/
public function imageIsReturnedWithExpectedContentTypeBasedOnProvidedFormat(
string $defaultFormat,
2020-09-21 15:54:05 -05:00
array $query,
string $expectedContentType,
2020-09-21 15:54:05 -05:00
): void {
$code = 'abc123';
$this->urlResolver->resolveEnabledShortUrl(ShortUrlIdentifier::fromShortCodeAndDomain($code, ''))->willReturn(
ShortUrl::createEmpty(),
);
2020-09-21 15:54:05 -05:00
$delegate = $this->prophesize(RequestHandlerInterface::class);
$req = (new ServerRequest())->withAttribute('shortCode', $code)->withQueryParams($query);
$resp = $this->action(new QrCodeOptions(format: $defaultFormat))->process($req, $delegate->reveal());
2020-09-21 15:54:05 -05:00
2020-10-03 17:35:14 -05:00
self::assertEquals($expectedContentType, $resp->getHeaderLine('Content-Type'));
2020-09-21 15:54:05 -05:00
}
public function provideQueries(): iterable
{
yield 'no format, png default' => ['png', [], 'image/png'];
yield 'no format, svg default' => ['svg', [], 'image/svg+xml'];
yield 'png format, png default' => ['png', ['format' => 'png'], 'image/png'];
yield 'png format, svg default' => ['svg', ['format' => 'png'], 'image/png'];
yield 'svg format, png default' => ['png', ['format' => 'svg'], 'image/svg+xml'];
yield 'svg format, svg default' => ['svg', ['format' => 'svg'], 'image/svg+xml'];
yield 'unsupported format, png default' => ['png', ['format' => 'jpg'], 'image/png'];
yield 'unsupported format, svg default' => ['svg', ['format' => 'jpg'], 'image/svg+xml'];
2020-09-21 15:54:05 -05:00
}
/**
* @test
* @dataProvider provideRequestsWithSize
*/
public function imageIsReturnedWithExpectedSize(
QrCodeOptions $defaultOptions,
ServerRequestInterface $req,
int $expectedSize,
): void {
$code = 'abc123';
$this->urlResolver->resolveEnabledShortUrl(ShortUrlIdentifier::fromShortCodeAndDomain($code, ''))->willReturn(
ShortUrl::createEmpty(),
);
$delegate = $this->prophesize(RequestHandlerInterface::class);
$resp = $this->action($defaultOptions)->process($req->withAttribute('shortCode', $code), $delegate->reveal());
[$size] = getimagesizefromstring($resp->getBody()->__toString());
self::assertEquals($expectedSize, $size);
}
public function provideRequestsWithSize(): iterable
{
yield 'different margin and size defaults' => [
new QrCodeOptions(size: 660, margin: 40),
ServerRequestFactory::fromGlobals(),
740,
];
yield 'no size' => [new QrCodeOptions(), ServerRequestFactory::fromGlobals(), 300];
yield 'no size, different default' => [new QrCodeOptions(size: 500), ServerRequestFactory::fromGlobals(), 500];
yield 'size in query' => [
new QrCodeOptions(),
ServerRequestFactory::fromGlobals()->withQueryParams(['size' => '123']),
123,
];
yield 'size in query, default margin' => [
new QrCodeOptions(margin: 25),
ServerRequestFactory::fromGlobals()->withQueryParams(['size' => '123']),
173,
];
yield 'margin' => [
new QrCodeOptions(),
ServerRequestFactory::fromGlobals()->withQueryParams(['margin' => '35']),
370,
];
yield 'margin and different default' => [
new QrCodeOptions(size: 400),
ServerRequestFactory::fromGlobals()->withQueryParams(['margin' => '35']),
470,
];
yield 'margin and size' => [
new QrCodeOptions(),
ServerRequestFactory::fromGlobals()->withQueryParams(['margin' => '100', 'size' => '200']),
400,
];
yield 'negative margin' => [
new QrCodeOptions(),
ServerRequestFactory::fromGlobals()->withQueryParams(['margin' => '-50']),
300,
];
yield 'negative margin, default margin' => [
new QrCodeOptions(margin: 10),
ServerRequestFactory::fromGlobals()->withQueryParams(['margin' => '-50']),
300,
];
yield 'non-numeric margin' => [
new QrCodeOptions(),
ServerRequestFactory::fromGlobals()->withQueryParams(['margin' => 'foo']),
300,
];
yield 'negative margin and size' => [
new QrCodeOptions(),
ServerRequestFactory::fromGlobals()->withQueryParams(['margin' => '-1', 'size' => '150']),
150,
];
yield 'negative margin and size, default margin' => [
new QrCodeOptions(margin: 5),
ServerRequestFactory::fromGlobals()->withQueryParams(['margin' => '-1', 'size' => '150']),
150,
];
yield 'non-numeric margin and size' => [
new QrCodeOptions(),
ServerRequestFactory::fromGlobals()->withQueryParams(['margin' => 'foo', 'size' => '538']),
538,
];
}
/**
* @test
* @dataProvider provideRoundBlockSize
*/
public function imageCanRemoveExtraMarginWhenBlockRoundIsDisabled(
QrCodeOptions $defaultOptions,
?string $roundBlockSize,
int $expectedColor,
): void {
$code = 'abc123';
$req = ServerRequestFactory::fromGlobals()
->withQueryParams(['size' => 250, 'roundBlockSize' => $roundBlockSize])
->withAttribute('shortCode', $code);
$this->urlResolver->resolveEnabledShortUrl(ShortUrlIdentifier::fromShortCodeAndDomain($code, ''))->willReturn(
ShortUrl::withLongUrl('https://shlink.io'),
);
$delegate = $this->prophesize(RequestHandlerInterface::class);
$resp = $this->action($defaultOptions)->process($req, $delegate->reveal());
$image = imagecreatefromstring($resp->getBody()->__toString());
$color = imagecolorat($image, 1, 1);
self::assertEquals($color, $expectedColor);
}
public function provideRoundBlockSize(): iterable
{
yield 'no round block param' => [new QrCodeOptions(), null, self::WHITE];
yield 'no round block param, but disabled by default' => [
new QrCodeOptions(roundBlockSize: false),
null,
self::BLACK,
];
yield 'round block: "true"' => [new QrCodeOptions(), 'true', self::WHITE];
yield 'round block: "true", but disabled by default' => [
new QrCodeOptions(roundBlockSize: false),
'true',
self::WHITE,
];
yield 'round block: "false"' => [new QrCodeOptions(), 'false', self::BLACK];
yield 'round block: "false", but enabled by default' => [
new QrCodeOptions(roundBlockSize: true),
'false',
self::BLACK,
];
}
public function action(?QrCodeOptions $options = null): QrCodeAction
{
return new QrCodeAction(
$this->urlResolver->reveal(),
new ShortUrlStringifier(['domain' => 'doma.in']),
new NullLogger(),
$options ?? new QrCodeOptions(),
);
}
2016-08-09 07:18:20 -05:00
}