/**
* @param ContainerInterface $app
* @throws \InvalidArgumentException
*/
public function register(ContainerInterface $app)
{
$app->singleton([Logger::class => 'Logger'], function () use($app) {
$logger = new Logger($app['Config']['logger.name']);
if (!$app['Config']->offsetExists('logger.handler')) {
throw new \InvalidArgumentException('expected at least one logger handler in array(class, array config) format');
}
/**
* register logger handler
*/
foreach ($app['Config']['logger.handler'] as $class => $config) {
$handler = (new \ReflectionClass($class))->newInstanceArgs($config['args']);
if (!$handler instanceof HandlerInterface) {
throw new \InvalidArgumentException(sprintf('logger handler must implement %s', HandlerInterface::class));
}
$formatter = (new \ReflectionClass(key($config['formatter'])))->newInstance($config['formatter'][key($config['formatter'])]);
if (!$formatter instanceof FormatterInterface) {
throw new InvalidArgumentException(sprintf('logger formatter must implement %s', FormatterInterface::class));
}
$handler->setFormatter($formatter);
$logger->pushHandler($handler);
}
return $logger;
});
$app->bind(LoggerInterface::class, 'Logger');
}
/**
* @param ContainerInterface $app
*/
public function register(ContainerInterface $app)
{
$this->app = $app;
$app->singleton('MiddlewareResolver', function () {
return [$this, 'middlewareResolver'];
});
$app->singleton([RelayBuilder::class => 'RelayBuilder'], function () use($app) {
return new RelayBuilder($app['MiddlewareResolver']);
});
}
public function it_should_able_handle_exception(ContainerInterface $container, ResponseInterface $response, StreamInterface $stream, ServerResponderInterface $serverResponder, ConfigurationInterface $config, StreamInterface $stream, LoggerInterface $logger, \Exception $e)
{
$container->offsetGet('Response')->willReturn($response);
$container->offsetGet('ServerResponder')->willReturn($serverResponder);
$container->offsetGet('Logger')->willReturn($logger);
$container->offsetGet('Config')->willReturn($config);
$response->getBody()->willReturn($stream);
$response->withHeader('Content-Type', 'text/html')->willReturn($response);
$response->withStatus('500')->willReturn($response);
$this->handleException($e);
}
public function it_should_handle_class_when_route_is_match(ServerRequestInterface $request, UriInterface $uri, ResponseInterface $response, GroupCountBased $dispatcher, ContainerInterface $container)
{
$request->getMethod()->willReturn('GET');
$request->getUri()->willReturn($uri);
$uri->getPath()->willReturn('/');
$dispatcher->dispatch('GET', '/')->willReturn([Dispatcher::FOUND, 'Controller', []]);
$request->withAttribute('param', [])->willReturn($request);
$container->offsetGet('Controller')->willReturn(new Controller());
$this->__invoke($request, $response, function ($request, $response) {
return $response;
})->shouldReturn($response);
}
public function it_should_able_send_output_to_client(ContainerInterface $container, ResponseInterface $response, \swoole_http_response $swoole_res, ConfigurationInterface $config)
{
$response->getHeaders()->willReturn(['Content-Type' => ['text/html']]);
$container->offsetGet('SwooleResponder')->willReturn($swoole_res);
$swoole_res->header('Content-Type', 'text/html')->shouldBeCalled();
$container->offsetGet('Config')->willReturn($config);
$config->offsetExists('server.gzip')->willReturn(true);
$config->offsetGet('server.gzip')->willReturn(3);
$swoole_res->gzip(3)->shouldBeCalled();
$swoole_res->status(200)->shouldBeCalled();
$swoole_res->header('Server', 'vinnige-app-server')->shouldBeCalled();
$response->getBody()->willReturn('hello world');
$response->getStatusCode()->willReturn(200);
$swoole_res->end('hello world')->shouldBeCalled();
$this->send($response);
}
private function registerEventDispatcherProvider()
{
$this->app->singleton([EventDispatcher::class => 'EventDispatcher'], function () {
return new EventDispatcher();
});
$this->app->bind(EventDispatcherInterface::class, 'EventDispatcher');
}
/**
* @return bool
* @throws \RuntimeException
*/
public function isServerExist()
{
if (!$this->container->offsetExists('Server')) {
throw new \RuntimeException('server must be set in container');
}
return true;
}
/**
* @param ContainerInterface $application
* @throws \InvalidArgumentException
*/
public function register(ContainerInterface $application)
{
$this->app = $application;
/**
* register whoops when debug mode enabled
*/
$this->app->singleton([ErrorHandler::class => 'ErrorHandler'], function () {
if ($this->errorHandler instanceof PrettyPageHandler) {
$this->errorHandler->handleUnconditionally(true);
}
$this->whoops = new Run();
$this->whoops->allowQuit(false);
$this->whoops->pushHandler($this->errorHandler);
return new ErrorHandler($this->app, $this->whoops, $this->contentType);
});
/**
* catch fatal error
*/
register_shutdown_function([$this->app['ErrorHandler'], 'handleError']);
}
/**
* @param ContainerInterface $app
*/
public function register(ContainerInterface $app)
{
$app->singleton([RouteParser::class => 'RouteParser']);
$app->singleton([DataGenerator::class => 'DataGenerator']);
$app->singleton([RouteCollector::class => 'RouteCollector']);
/**
* contextual binding
*/
$app->bind(RouteParserInterface::class, 'RouteParser');
$app->bind(DataGeneratorInterface::class, 'DataGenerator');
/**
* register routing dispatcher
*/
$app->singleton([RouteDispatcher::class => 'RouteDispatcher'], function () use($app) {
return new RouteDispatcher($app['RouteCollector']->getData());
});
}
public function it_should_throw_exception_when_given_invalid_middleware_dispatcher(\swoole_http_request $swoole_req, \swoole_http_response $swoole_res, ServerRequestInterface $request, ResponseInterface $response, RelayBuilder $relayBuilder, ContainerInterface $container)
{
unset($GLOBALS['_COOKIE']);
unset($GLOBALS['_GET']);
unset($GLOBALS['_POST']);
unset($GLOBALS['_FILES']);
$container->offsetSet('SwooleResponder', $swoole_res)->shouldBeCalled();
$container->offsetGet('Request')->willReturn($request);
$container->offsetGet('Response')->willReturn($response);
$container->offsetGet('RelayBuilder')->willReturn($relayBuilder);
$container->offsetGet('Middlewares')->willReturn([]);
$relayBuilder->newInstance([])->willReturn(null);
$this->shouldThrow('\\RuntimeException')->duringHandleRequest($swoole_req, $swoole_res);
}
/**
* @param ContainerInterface $app
*/
public function register(ContainerInterface $app)
{
/**
* swoole server
*/
$app->singleton('Server', function () use($app) {
return new Server($app);
});
/**
* swoole server request handler
*/
$app->singleton('ServerRequestHandler', function () use($app) {
return new ServerRequestHandler($app, $app['EventDispatcher']);
});
/**
* swoole server responder
*/
$app->singleton('ServerResponder', function () use($app) {
return new ServerResponder($app);
});
$app->bind(ServerInterface::class, 'Server');
$app->bind(ServerRequestHandlerInterface::class, 'ServerRequestHandler');
$app->bind(ServerResponderInterface::class, 'ServerResponder');
}
public function it_should_able_to_run(ContainerInterface $container, RouteCollector $collector, ServerInterface $server, EventDispatcherInterface $event)
{
/**
* predictions
*/
$container->offsetSet('Middlewares', [])->shouldBeCalled();
$container->offsetSet('ServiceProviders', [])->shouldBeCalled();
$container->offsetSet('Routes', [])->shouldBeCalled();
$collector->addRoute('GET', '/', 'test')->shouldBeCalled();
$server->run()->shouldBeCalled();
/**
* mocks
*/
$container->offsetGet('Routes')->willReturn([['method' => 'GET', 'route' => '/', 'handler' => 'test']]);
$container->offsetGet('Server')->willReturn($server);
$container->offsetGet('RouteCollector')->willReturn($collector);
$container->offsetGet('EventDispatcher')->willReturn($event);
/**
* test method
*/
$this->run();
}
