Renamed rest actions to use the short-url concept instead of the short-code concept

2025-02-25 18:45:27 -06:00 · 2018-09-20 19:55:24 +02:00
parent 076b0cf867
commit 1f5faee356
18 changed files with 75 additions and 73 deletions
--- a/module/Rest/test/Action/ShortUrl/CreateShortUrlActionTest.php
+++ b/module/Rest/test/Action/ShortUrl/CreateShortUrlActionTest.php
@@ -0,0 +1,124 @@
+<?php
+declare(strict_types=1);
+
+namespace ShlinkioTest\Shlink\Rest\Action\ShortUrl;
+
+use PHPUnit\Framework\TestCase;
+use Prophecy\Argument;
+use Prophecy\Prophecy\ObjectProphecy;
+use Shlinkio\Shlink\Core\Entity\ShortUrl;
+use Shlinkio\Shlink\Core\Exception\InvalidUrlException;
+use Shlinkio\Shlink\Core\Exception\NonUniqueSlugException;
+use Shlinkio\Shlink\Core\Service\UrlShortener;
+use Shlinkio\Shlink\Rest\Action\ShortUrl\CreateShortUrlAction;
+use Shlinkio\Shlink\Rest\Util\RestUtils;
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\Diactoros\Uri;
+use Zend\I18n\Translator\Translator;
+
+class CreateShortUrlActionTest extends TestCase
+{
+    /**
+     * @var CreateShortUrlAction
+     */
+    protected $action;
+    /**
+     * @var ObjectProphecy
+     */
+    protected $urlShortener;
+
+    public function setUp()
+    {
+        $this->urlShortener = $this->prophesize(UrlShortener::class);
+        $this->action = new CreateShortUrlAction($this->urlShortener->reveal(), Translator::factory([]), [
+            'schema' => 'http',
+            'hostname' => 'foo.com',
+        ]);
+    }
+
+    /**
+     * @test
+     */
+    public function missingLongUrlParamReturnsError()
+    {
+        $response = $this->action->handle(ServerRequestFactory::fromGlobals());
+        $this->assertEquals(400, $response->getStatusCode());
+    }
+
+    /**
+     * @test
+     */
+    public function properShortcodeConversionReturnsData()
+    {
+        $this->urlShortener->urlToShortCode(Argument::type(Uri::class), Argument::type('array'), Argument::cetera())
+            ->willReturn(
+                (new ShortUrl())->setShortCode('abc123')
+                                ->setLongUrl('')
+            )
+            ->shouldBeCalledTimes(1);
+
+        $request = ServerRequestFactory::fromGlobals()->withParsedBody([
+            'longUrl' => 'http://www.domain.com/foo/bar',
+        ]);
+        $response = $this->action->handle($request);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertTrue(strpos($response->getBody()->getContents(), 'http://foo.com/abc123') > 0);
+    }
+
+    /**
+     * @test
+     */
+    public function anInvalidUrlReturnsError()
+    {
+        $this->urlShortener->urlToShortCode(Argument::type(Uri::class), Argument::type('array'), Argument::cetera())
+            ->willThrow(InvalidUrlException::class)
+            ->shouldBeCalledTimes(1);
+
+        $request = ServerRequestFactory::fromGlobals()->withParsedBody([
+            'longUrl' => 'http://www.domain.com/foo/bar',
+        ]);
+        $response = $this->action->handle($request);
+        $this->assertEquals(400, $response->getStatusCode());
+        $this->assertTrue(strpos($response->getBody()->getContents(), RestUtils::INVALID_URL_ERROR) > 0);
+    }
+
+    /**
+     * @test
+     */
+    public function nonUniqueSlugReturnsError()
+    {
+        $this->urlShortener->urlToShortCode(
+            Argument::type(Uri::class),
+            Argument::type('array'),
+            null,
+            null,
+            'foo',
+            Argument::cetera()
+        )->willThrow(NonUniqueSlugException::class)->shouldBeCalledTimes(1);
+
+        $request = ServerRequestFactory::fromGlobals()->withParsedBody([
+            'longUrl' => 'http://www.domain.com/foo/bar',
+            'customSlug' => 'foo',
+        ]);
+        $response = $this->action->handle($request);
+        $this->assertEquals(400, $response->getStatusCode());
+        $this->assertContains(RestUtils::INVALID_SLUG_ERROR, (string) $response->getBody());
+    }
+
+    /**
+     * @test
+     */
+    public function aGenericExceptionWillReturnError()
+    {
+        $this->urlShortener->urlToShortCode(Argument::type(Uri::class), Argument::type('array'), Argument::cetera())
+            ->willThrow(\Exception::class)
+            ->shouldBeCalledTimes(1);
+
+        $request = ServerRequestFactory::fromGlobals()->withParsedBody([
+            'longUrl' => 'http://www.domain.com/foo/bar',
+        ]);
+        $response = $this->action->handle($request);
+        $this->assertEquals(500, $response->getStatusCode());
+        $this->assertTrue(strpos($response->getBody()->getContents(), RestUtils::UNKNOWN_ERROR) > 0);
+    }
+}
--- a/module/Rest/test/Action/ShortUrl/DeleteShortUrlActionTest.php
+++ b/module/Rest/test/Action/ShortUrl/DeleteShortUrlActionTest.php
@@ -0,0 +1,72 @@
+<?php
+declare(strict_types=1);
+
+namespace ShlinkioTest\Shlink\Rest\Action\ShortUrl;
+
+use PHPUnit\Framework\TestCase;
+use Prophecy\Argument;
+use Prophecy\Prophecy\ObjectProphecy;
+use Shlinkio\Shlink\Core\Exception;
+use Shlinkio\Shlink\Core\Service\ShortUrl\DeleteShortUrlServiceInterface;
+use Shlinkio\Shlink\Rest\Action\ShortUrl\DeleteShortUrlAction;
+use Shlinkio\Shlink\Rest\Util\RestUtils;
+use Zend\Diactoros\Response\JsonResponse;
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\I18n\Translator\Translator;
+
+class DeleteShortUrlActionTest extends TestCase
+{
+    /**
+     * @var DeleteShortUrlAction
+     */
+    private $action;
+    /**
+     * @var ObjectProphecy
+     */
+    private $service;
+
+    public function setUp()
+    {
+        $this->service = $this->prophesize(DeleteShortUrlServiceInterface::class);
+        $this->action = new DeleteShortUrlAction($this->service->reveal(), Translator::factory([]));
+    }
+
+    /**
+     * @test
+     */
+    public function emptyResponseIsReturnedIfProperlyDeleted()
+    {
+        $deleteByShortCode = $this->service->deleteByShortCode(Argument::any())->will(function () {
+        });
+
+        $resp = $this->action->handle(ServerRequestFactory::fromGlobals());
+
+        $this->assertEquals(204, $resp->getStatusCode());
+        $deleteByShortCode->shouldHaveBeenCalledTimes(1);
+    }
+
+    /**
+     * @test
+     * @dataProvider provideExceptions
+     */
+    public function returnsErrorResponseInCaseOfException(\Throwable $e, string $error, int $statusCode)
+    {
+        $deleteByShortCode = $this->service->deleteByShortCode(Argument::any())->willThrow($e);
+
+        /** @var JsonResponse $resp */
+        $resp = $this->action->handle(ServerRequestFactory::fromGlobals());
+        $payload = $resp->getPayload();
+
+        $this->assertEquals($statusCode, $resp->getStatusCode());
+        $this->assertEquals($error, $payload['error']);
+        $deleteByShortCode->shouldHaveBeenCalledTimes(1);
+    }
+
+    public function provideExceptions(): array
+    {
+        return [
+            [new Exception\InvalidShortCodeException(), RestUtils::INVALID_SHORTCODE_ERROR, 404],
+            [new Exception\DeleteShortUrlException(5), RestUtils::INVALID_SHORTCODE_DELETION_ERROR, 400],
+        ];
+    }
+}
--- a/module/Rest/test/Action/ShortUrl/EditShortUrlActionTest.php
+++ b/module/Rest/test/Action/ShortUrl/EditShortUrlActionTest.php
@@ -0,0 +1,92 @@
+<?php
+declare(strict_types=1);
+
+namespace ShlinkioTest\Shlink\Rest\Action\ShortUrl;
+
+use PHPUnit\Framework\TestCase;
+use Prophecy\Argument;
+use Prophecy\Prophecy\ObjectProphecy;
+use Shlinkio\Shlink\Core\Entity\ShortUrl;
+use Shlinkio\Shlink\Core\Exception\InvalidShortCodeException;
+use Shlinkio\Shlink\Core\Service\ShortUrlServiceInterface;
+use Shlinkio\Shlink\Rest\Action\ShortUrl\EditShortUrlAction;
+use Shlinkio\Shlink\Rest\Util\RestUtils;
+use Zend\Diactoros\Response\JsonResponse;
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\I18n\Translator\Translator;
+
+class EditShortUrlActionTest extends TestCase
+{
+    /**
+     * @var EditShortUrlAction
+     */
+    private $action;
+    /**
+     * @var ObjectProphecy
+     */
+    private $shortUrlService;
+
+    public function setUp()
+    {
+        $this->shortUrlService = $this->prophesize(ShortUrlServiceInterface::class);
+        $this->action = new EditShortUrlAction($this->shortUrlService->reveal(), Translator::factory([]));
+    }
+
+    /**
+     * @test
+     */
+    public function invalidDataReturnsError()
+    {
+        $request = ServerRequestFactory::fromGlobals()->withParsedBody([
+            'maxVisits' => 'invalid',
+        ]);
+
+        /** @var JsonResponse $resp */
+        $resp = $this->action->handle($request);
+        $payload = $resp->getPayload();
+
+        $this->assertEquals(400, $resp->getStatusCode());
+        $this->assertEquals(RestUtils::INVALID_ARGUMENT_ERROR, $payload['error']);
+        $this->assertEquals('Provided data is invalid.', $payload['message']);
+    }
+
+    /**
+     * @test
+     */
+    public function incorrectShortCodeReturnsError()
+    {
+        $request = ServerRequestFactory::fromGlobals()->withAttribute('shortCode', 'abc123')
+                                                      ->withParsedBody([
+                                                          'maxVisits' => 5,
+                                                      ]);
+        $updateMeta = $this->shortUrlService->updateMetadataByShortCode(Argument::cetera())->willThrow(
+            InvalidShortCodeException::class
+        );
+
+        /** @var JsonResponse $resp */
+        $resp = $this->action->handle($request);
+        $payload = $resp->getPayload();
+
+        $this->assertEquals(404, $resp->getStatusCode());
+        $this->assertEquals(RestUtils::INVALID_SHORTCODE_ERROR, $payload['error']);
+        $this->assertEquals('No URL found for short code "abc123"', $payload['message']);
+        $updateMeta->shouldHaveBeenCalled();
+    }
+
+    /**
+     * @test
+     */
+    public function correctShortCodeReturnsSuccess()
+    {
+        $request = ServerRequestFactory::fromGlobals()->withAttribute('shortCode', 'abc123')
+                                                      ->withParsedBody([
+                                                          'maxVisits' => 5,
+                                                      ]);
+        $updateMeta = $this->shortUrlService->updateMetadataByShortCode(Argument::cetera())->willReturn(new ShortUrl());
+
+        $resp = $this->action->handle($request);
+
+        $this->assertEquals(204, $resp->getStatusCode());
+        $updateMeta->shouldHaveBeenCalled();
+    }
+}
--- a/module/Rest/test/Action/ShortUrl/EditShortUrlTagsActionTest.php
+++ b/module/Rest/test/Action/ShortUrl/EditShortUrlTagsActionTest.php
@@ -0,0 +1,72 @@
+<?php
+declare(strict_types=1);
+
+namespace ShlinkioTest\Shlink\Rest\Action\ShortUrl;
+
+use PHPUnit\Framework\TestCase;
+use Prophecy\Prophecy\ObjectProphecy;
+use Shlinkio\Shlink\Core\Entity\ShortUrl;
+use Shlinkio\Shlink\Core\Exception\InvalidShortCodeException;
+use Shlinkio\Shlink\Core\Service\ShortUrlService;
+use Shlinkio\Shlink\Rest\Action\ShortUrl\EditShortUrlTagsAction;
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\I18n\Translator\Translator;
+
+class EditShortUrlTagsActionTest extends TestCase
+{
+    /**
+     * @var EditShortUrlTagsAction
+     */
+    protected $action;
+    /**
+     * @var ObjectProphecy
+     */
+    private $shortUrlService;
+
+    public function setUp()
+    {
+        $this->shortUrlService = $this->prophesize(ShortUrlService::class);
+        $this->action = new EditShortUrlTagsAction($this->shortUrlService->reveal(), Translator::factory([]));
+    }
+
+    /**
+     * @test
+     */
+    public function notProvidingTagsReturnsError()
+    {
+        $response = $this->action->handle(ServerRequestFactory::fromGlobals()->withAttribute('shortCode', 'abc123'));
+        $this->assertEquals(400, $response->getStatusCode());
+    }
+
+    /**
+     * @test
+     */
+    public function anInvalidShortCodeReturnsNotFound()
+    {
+        $shortCode = 'abc123';
+        $this->shortUrlService->setTagsByShortCode($shortCode, [])->willThrow(InvalidShortCodeException::class)
+                                                                  ->shouldBeCalledTimes(1);
+
+        $response = $this->action->handle(
+            ServerRequestFactory::fromGlobals()->withAttribute('shortCode', 'abc123')
+                                               ->withParsedBody(['tags' => []])
+        );
+        $this->assertEquals(404, $response->getStatusCode());
+    }
+
+    /**
+     * @test
+     */
+    public function tagsListIsReturnedIfCorrectShortCodeIsProvided()
+    {
+        $shortCode = 'abc123';
+        $this->shortUrlService->setTagsByShortCode($shortCode, [])->willReturn(new ShortUrl())
+                                                                  ->shouldBeCalledTimes(1);
+
+        $response = $this->action->handle(
+            ServerRequestFactory::fromGlobals()->withAttribute('shortCode', 'abc123')
+                                               ->withParsedBody(['tags' => []])
+        );
+        $this->assertEquals(200, $response->getStatusCode());
+    }
+}
--- a/module/Rest/test/Action/ShortUrl/ListShortUrlsActionTest.php
+++ b/module/Rest/test/Action/ShortUrl/ListShortUrlsActionTest.php
@@ -0,0 +1,64 @@
+<?php
+declare(strict_types=1);
+
+namespace ShlinkioTest\Shlink\Rest\Action\ShortUrl;
+
+use PHPUnit\Framework\TestCase;
+use Prophecy\Prophecy\ObjectProphecy;
+use Shlinkio\Shlink\Core\Service\ShortUrlService;
+use Shlinkio\Shlink\Rest\Action\ShortUrl\ListShortUrlsAction;
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\I18n\Translator\Translator;
+use Zend\Paginator\Adapter\ArrayAdapter;
+use Zend\Paginator\Paginator;
+
+class ListShortUrlsActionTest extends TestCase
+{
+    /**
+     * @var ListShortUrlsAction
+     */
+    protected $action;
+    /**
+     * @var ObjectProphecy
+     */
+    protected $service;
+
+    public function setUp()
+    {
+        $this->service = $this->prophesize(ShortUrlService::class);
+        $this->action = new ListShortUrlsAction($this->service->reveal(), Translator::factory([]), [
+            'hostname' => 'doma.in',
+            'schema' => 'https',
+        ]);
+    }
+
+    /**
+     * @test
+     */
+    public function properListReturnsSuccessResponse()
+    {
+        $page = 3;
+        $this->service->listShortUrls($page, null, [], null)->willReturn(new Paginator(new ArrayAdapter()))
+                                                            ->shouldBeCalledTimes(1);
+
+        $response = $this->action->handle(ServerRequestFactory::fromGlobals()->withQueryParams([
+            'page' => $page,
+        ]));
+        $this->assertEquals(200, $response->getStatusCode());
+    }
+
+    /**
+     * @test
+     */
+    public function anExceptionsReturnsErrorResponse()
+    {
+        $page = 3;
+        $this->service->listShortUrls($page, null, [], null)->willThrow(\Exception::class)
+                                                            ->shouldBeCalledTimes(1);
+
+        $response = $this->action->handle(ServerRequestFactory::fromGlobals()->withQueryParams([
+            'page' => $page,
+        ]));
+        $this->assertEquals(500, $response->getStatusCode());
+    }
+}
--- a/module/Rest/test/Action/ShortUrl/ResolveShortUrlActionTest.php
+++ b/module/Rest/test/Action/ShortUrl/ResolveShortUrlActionTest.php
@@ -0,0 +1,94 @@
+<?php
+declare(strict_types=1);
+
+namespace ShlinkioTest\Shlink\Rest\Action\ShortUrl;
+
+use PHPUnit\Framework\TestCase;
+use Prophecy\Prophecy\ObjectProphecy;
+use Shlinkio\Shlink\Core\Entity\ShortUrl;
+use Shlinkio\Shlink\Core\Exception\EntityDoesNotExistException;
+use Shlinkio\Shlink\Core\Exception\InvalidShortCodeException;
+use Shlinkio\Shlink\Core\Service\UrlShortener;
+use Shlinkio\Shlink\Rest\Action\ShortUrl\ResolveShortUrlAction;
+use Shlinkio\Shlink\Rest\Util\RestUtils;
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\I18n\Translator\Translator;
+
+class ResolveShortUrlActionTest extends TestCase
+{
+    /**
+     * @var ResolveShortUrlAction
+     */
+    protected $action;
+    /**
+     * @var ObjectProphecy
+     */
+    protected $urlShortener;
+
+    public function setUp()
+    {
+        $this->urlShortener = $this->prophesize(UrlShortener::class);
+        $this->action = new ResolveShortUrlAction($this->urlShortener->reveal(), Translator::factory([]), []);
+    }
+
+    /**
+     * @test
+     */
+    public function incorrectShortCodeReturnsError()
+    {
+        $shortCode = 'abc123';
+        $this->urlShortener->shortCodeToUrl($shortCode)->willThrow(EntityDoesNotExistException::class)
+                                                       ->shouldBeCalledTimes(1);
+
+        $request = ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode);
+        $response = $this->action->handle($request);
+        $this->assertEquals(404, $response->getStatusCode());
+        $this->assertTrue(strpos($response->getBody()->getContents(), RestUtils::INVALID_ARGUMENT_ERROR) > 0);
+    }
+
+    /**
+     * @test
+     */
+    public function correctShortCodeReturnsSuccess()
+    {
+        $shortCode = 'abc123';
+        $this->urlShortener->shortCodeToUrl($shortCode)->willReturn(
+            (new ShortUrl())->setLongUrl('http://domain.com/foo/bar')
+        )->shouldBeCalledTimes(1);
+
+        $request = ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode);
+        $response = $this->action->handle($request);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertTrue(strpos($response->getBody()->getContents(), 'http://domain.com/foo/bar') > 0);
+    }
+
+    /**
+     * @test
+     */
+    public function invalidShortCodeExceptionReturnsError()
+    {
+        $shortCode = 'abc123';
+        $this->urlShortener->shortCodeToUrl($shortCode)->willThrow(InvalidShortCodeException::class)
+                                                       ->shouldBeCalledTimes(1);
+
+        $request = ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode);
+        $response = $this->action->handle($request);
+        $this->assertEquals(400, $response->getStatusCode());
+        $this->assertTrue(strpos($response->getBody()->getContents(), RestUtils::INVALID_SHORTCODE_ERROR) > 0);
+    }
+
+    /**
+     * @test
+     */
+    public function unexpectedExceptionWillReturnError()
+    {
+        $shortCode = 'abc123';
+        $this->urlShortener->shortCodeToUrl($shortCode)->willThrow(\Exception::class)
+                                                       ->shouldBeCalledTimes(1);
+
+        $request = ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode);
+        $response = $this->action->handle($request);
+        $this->assertEquals(500, $response->getStatusCode());
+        $this->assertTrue(strpos($response->getBody()->getContents(), RestUtils::UNKNOWN_ERROR) > 0);
+    }
+}
--- a/module/Rest/test/Action/ShortUrl/SingleStepCreateShortUrlActionTest.php
+++ b/module/Rest/test/Action/ShortUrl/SingleStepCreateShortUrlActionTest.php
@@ -0,0 +1,124 @@
+<?php
+declare(strict_types=1);
+
+namespace ShlinkioTest\Shlink\Rest\Action\ShortUrl;
+
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\TestCase;
+use Prophecy\Argument;
+use Prophecy\Prophecy\ObjectProphecy;
+use Psr\Http\Message\UriInterface;
+use Shlinkio\Shlink\Core\Entity\ShortUrl;
+use Shlinkio\Shlink\Core\Service\UrlShortenerInterface;
+use Shlinkio\Shlink\Rest\Action\ShortUrl\SingleStepCreateShortUrlAction;
+use Shlinkio\Shlink\Rest\Entity\ApiKey;
+use Shlinkio\Shlink\Rest\Service\ApiKeyServiceInterface;
+use Zend\Diactoros\Response\JsonResponse;
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\I18n\Translator\Translator;
+
+class SingleStepCreateShortUrlActionTest extends TestCase
+{
+    /**
+     * @var SingleStepCreateShortUrlAction
+     */
+    private $action;
+    /**
+     * @var ObjectProphecy
+     */
+    private $urlShortener;
+    /**
+     * @var ObjectProphecy
+     */
+    private $apiKeyService;
+
+    public function setUp()
+    {
+        $this->urlShortener = $this->prophesize(UrlShortenerInterface::class);
+        $this->apiKeyService = $this->prophesize(ApiKeyServiceInterface::class);
+
+        $this->action = new SingleStepCreateShortUrlAction(
+            $this->urlShortener->reveal(),
+            Translator::factory([]),
+            $this->apiKeyService->reveal(),
+            [
+                'schema' => 'http',
+                'hostname' => 'foo.com',
+            ]
+        );
+    }
+
+    /**
+     * @test
+     * @dataProvider provideInvalidApiKeys
+     */
+    public function errorResponseIsReturnedIfInvalidApiKeyIsProvided(?ApiKey $apiKey)
+    {
+        $request = ServerRequestFactory::fromGlobals()->withQueryParams(['apiKey' => 'abc123']);
+        $findApiKey = $this->apiKeyService->getByKey('abc123')->willReturn($apiKey);
+
+        /** @var JsonResponse $resp */
+        $resp = $this->action->handle($request);
+        $payload = $resp->getPayload();
+
+        $this->assertEquals(400, $resp->getStatusCode());
+        $this->assertEquals('INVALID_ARGUMENT', $payload['error']);
+        $this->assertEquals('No API key was provided or it is not valid', $payload['message']);
+        $findApiKey->shouldHaveBeenCalled();
+    }
+
+    public function provideInvalidApiKeys(): array
+    {
+        return [
+            [null],
+            [(new ApiKey())->disable()],
+        ];
+    }
+
+    /**
+     * @test
+     */
+    public function errorResponseIsReturnedIfNoUrlIsProvided()
+    {
+        $request = ServerRequestFactory::fromGlobals()->withQueryParams(['apiKey' => 'abc123']);
+        $findApiKey = $this->apiKeyService->getByKey('abc123')->willReturn(new ApiKey());
+
+        /** @var JsonResponse $resp */
+        $resp = $this->action->handle($request);
+        $payload = $resp->getPayload();
+
+        $this->assertEquals(400, $resp->getStatusCode());
+        $this->assertEquals('INVALID_ARGUMENT', $payload['error']);
+        $this->assertEquals('A URL was not provided', $payload['message']);
+        $findApiKey->shouldHaveBeenCalled();
+    }
+
+    /**
+     * @test
+     */
+    public function properDataIsPassedWhenGeneratingShortCode()
+    {
+        $request = ServerRequestFactory::fromGlobals()->withQueryParams([
+            'apiKey' => 'abc123',
+            'longUrl' => 'http://foobar.com',
+        ]);
+        $findApiKey = $this->apiKeyService->getByKey('abc123')->willReturn(new ApiKey());
+        $generateShortCode = $this->urlShortener->urlToShortCode(
+            Argument::that(function (UriInterface $argument) {
+                Assert::assertEquals('http://foobar.com', (string) $argument);
+                return $argument;
+            }),
+            [],
+            null,
+            null,
+            null,
+            null
+        )->willReturn((new ShortUrl())->setLongUrl(''));
+
+        $resp = $this->action->handle($request);
+
+        $this->assertEquals(200, $resp->getStatusCode());
+        $findApiKey->shouldHaveBeenCalled();
+        $generateShortCode->shouldHaveBeenCalled();
+    }
+}