mirrors/shlink
1
0
Fork 0
mirror of https://github.com/shlinkio/shlink.git synced 2024-11-26 14:53:48 +03:00
Code Issues Projects Releases Packages Wiki Activity

Removed cli-related middlewares and factories

Browse source
This commit is contained in:
Alejandro Celaya 2016-07-03 09:16:56 +02:00
parent 35147fecb2
commit e09915dd21
7 changed files with 0 additions and 262 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
config/autoload/cli-routes.global.php
View file

@ -1,15 +0,0 @@
<?php
use Acelaya\UrlShortener\Middleware\CliRoutable;
return [
'routes' => [
[
'name' => 'cli-generate-shortcode',
'path' => '/generate-shortcode',
'middleware' => CliRoutable\GenerateShortcodeMiddleware::class,
'allowed_methods' => ['CLI'],
],
],
];

2
config/autoload/middleware-pipeline.global.php
View file

@ -1,5 +1,4 @@
<?php
use Acelaya\UrlShortener\Middleware\CliParamsMiddleware;
use Zend\Expressive\Container\ApplicationFactory;
use Zend\Expressive\Helper;
@ -16,7 +15,6 @@ return [
'routing' => [
'middleware' => [
ApplicationFactory::ROUTING_MIDDLEWARE,
CliParamsMiddleware::class,
Helper\UrlHelperMiddleware::class,
ApplicationFactory::DISPATCH_MIDDLEWARE,
],

2
config/autoload/services.global.php
View file

@ -43,9 +43,7 @@ return [
CliCommands\GenerateShortcodeCommand::class => AnnotatedFactory::class,
// Middleware
Middleware\CliRoutable\GenerateShortcodeMiddleware::class => AnnotatedFactory::class,
Middleware\Routable\RedirectMiddleware::class => AnnotatedFactory::class,
Middleware\CliParamsMiddleware::class => Middleware\Factory\CliParamsMiddlewareFactory::class,
],
'aliases' => [
'em' => EntityManager::class,

91
src/Middleware/CliRoutable/GenerateShortcodeMiddleware.php
View file

@ -1,91 +0,0 @@
<?php
namespace Acelaya\UrlShortener\Middleware\CliRoutable;
use Acelaya\UrlShortener\Exception\InvalidUrlException;
use Acelaya\UrlShortener\Service\UrlShortener;
use Acelaya\UrlShortener\Service\UrlShortenerInterface;
use Acelaya\ZsmAnnotatedServices\Annotation\Inject;
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Zend\Diactoros\Uri;
use Zend\Stratigility\MiddlewareInterface;
class GenerateShortcodeMiddleware implements MiddlewareInterface
{
/**
* @var UrlShortenerInterface
*/
private $urlShortener;
/**
* @var array
*/
private $domainConfig;
/**
* GenerateShortcodeMiddleware constructor.
*
* @param UrlShortenerInterface|UrlShortener $urlShortener
* @param array $domainConfig
*
* @Inject({UrlShortener::class, "config.url_shortener.domain"})
*/
public function __construct(UrlShortenerInterface $urlShortener, array $domainConfig)
{
$this->urlShortener = $urlShortener;
$this->domainConfig = $domainConfig;
}
/**
* Process an incoming request and/or response.
*
* Accepts a server-side request and a response instance, and does
* something with them.
*
* If the response is not complete and/or further processing would not
* interfere with the work done in the middleware, or if the middleware
* wants to delegate to another process, it can use the `$out` callable
* if present.
*
* If the middleware does not return a value, execution of the current
* request is considered complete, and the response instance provided will
* be considered the response to return.
*
* Alternately, the middleware may return a response instance.
*
* Often, middleware will `return $out();`, with the assumption that a
* later middleware will return a response.
*
* @param Request $request
* @param Response $response
* @param null|callable $out
* @return null|Response
*/
public function __invoke(Request $request, Response $response, callable $out = null)
{
$longUrl = $request->getAttribute('longUrl');
try {
if (! isset($longUrl)) {
$response->getBody()->write('A URL was not provided!' . PHP_EOL);
return;
}
$shortcode = $this->urlShortener->urlToShortCode(new Uri($longUrl));
$shortUrl = (new Uri())->withPath($shortcode)
->withScheme($this->domainConfig['schema'])
->withHost($this->domainConfig['hostname']);
$response->getBody()->write(
sprintf('Processed URL "%s".%sGenerated short URL "%s"', $longUrl, PHP_EOL, $shortUrl) . PHP_EOL
);
} catch (InvalidUrlException $e) {
$response->getBody()->write(
sprintf('Provided URL "%s" is invalid. Try with a different one.', $longUrl) . PHP_EOL
);
} catch (\Exception $e) {
$response->getBody()->write($e);
} finally {
return $response;
}
}
}

32
src/Middleware/Factory/CliParamsMiddlewareFactory.php
View file

@ -1,32 +0,0 @@
<?php
namespace Acelaya\UrlShortener\Middleware\Factory;
use Acelaya\UrlShortener\Middleware\CliParamsMiddleware;
use Interop\Container\ContainerInterface;
use Interop\Container\Exception\ContainerException;
use Zend\ServiceManager\Exception\ServiceNotCreatedException;
use Zend\ServiceManager\Exception\ServiceNotFoundException;
use Zend\ServiceManager\Factory\FactoryInterface;
class CliParamsMiddlewareFactory implements FactoryInterface
{
/**
* Create an object
*
* @param ContainerInterface $container
* @param string $requestedName
* @param null|array $options
* @return object
* @throws ServiceNotFoundException if unable to resolve the service.
* @throws ServiceNotCreatedException if an exception is raised when
* creating a service.
* @throws ContainerException if any other error occurs
*/
public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
{
return new CliParamsMiddleware(
isset($_SERVER['argv']) ? $_SERVER['argv'] : [],
php_sapi_name()
);
}
}

91
tests/Middleware/CliParamsMiddlewareTest.php
View file

@ -1,91 +0,0 @@
<?php
namespace AcelayaTest\UrlShortener\Middleware;
use Acelaya\UrlShortener\Middleware\CliParamsMiddleware;
use PHPUnit_Framework_TestCase as TestCase;
use Psr\Http\Message\ServerRequestInterface;
use Zend\Diactoros\Response;
use Zend\Diactoros\ServerRequestFactory;
use Zend\Expressive\Router\RouteResult;
class CliParamsMiddlewareTest extends TestCase
{
/**
* @test
*/
public function nonCliRequestsJustInvokeNextMiddleware()
{
$middleware = new CliParamsMiddleware([], 'non-cli');
$invoked = false;
$originalResponse = new Response();
$response = $middleware->__invoke(
ServerRequestFactory::fromGlobals(),
$originalResponse,
function ($req, $resp) use (&$invoked) {
$invoked = true;
return $resp;
}
);
$this->assertSame($originalResponse, $response);
$this->assertTrue($invoked);
}
/**
* @test
*/
public function nonSuccessRouteResultJustInvokesNextMiddleware()
{
$middleware = new CliParamsMiddleware([], 'cli');
$invoked = false;
$originalResponse = new Response();
$routeResult = $this->prophesize(RouteResult::class);
$routeResult->isSuccess()->willReturn(false)->shouldBeCalledTimes(1);
$response = $middleware->__invoke(
ServerRequestFactory::fromGlobals()->withAttribute(RouteResult::class, $routeResult->reveal()),
$originalResponse,
function ($req, $resp) use (&$invoked) {
$invoked = true;
return $resp;
}
);
$this->assertSame($originalResponse, $response);
$this->assertTrue($invoked);
}
/**
* @test
*/
public function properRouteWillInjectAttributeInResponse()
{
$expectedLongUrl = 'http://www.google.com';
$middleware = new CliParamsMiddleware(['foo', 'bar', $expectedLongUrl], 'cli');
$invoked = false;
$originalResponse = new Response();
$routeResult = $this->prophesize(RouteResult::class);
$routeResult->isSuccess()->willReturn(true)->shouldBeCalledTimes(1);
$routeResult->getMatchedRouteName()->willReturn('cli-generate-shortcode')->shouldBeCalledTimes(1);
/** @var ServerRequestInterface $request */
$request = null;
$response = $middleware->__invoke(
ServerRequestFactory::fromGlobals()->withAttribute(RouteResult::class, $routeResult->reveal()),
$originalResponse,
function ($req, $resp) use (&$invoked, &$request) {
$invoked = true;
$request = $req;
return $resp;
}
);
$this->assertSame($originalResponse, $response);
$this->assertEquals($expectedLongUrl, $request->getAttribute('longUrl'));
$this->assertTrue($invoked);
}
}

29
tests/Middleware/Factory/CliParamsMiddlewareFactoryTest.php
View file

@ -1,29 +0,0 @@
<?php
namespace AcelayaTest\UrlShortener\Middleware\Factory;
use Acelaya\UrlShortener\Middleware\CliParamsMiddleware;
use Acelaya\UrlShortener\Middleware\Factory\CliParamsMiddlewareFactory;
use PHPUnit_Framework_TestCase as TestCase;
use Zend\ServiceManager\ServiceManager;
class CliParamsMiddlewareFactoryTest extends TestCase
{
/**
* @var CliParamsMiddlewareFactory
*/
protected $factory;
public function setUp()
{
$this->factory = new CliParamsMiddlewareFactory();
}
/**
* @test
*/
public function serviceIsCreated()
{
$instance = $this->factory->__invoke(new ServiceManager(), '');
$this->assertInstanceOf(CliParamsMiddleware::class, $instance);
}
}