Jasny\Codeception\Connector

Complexity

Total Complexity

19

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setRouter()	0	4	1
A	getRouter()	0	4	1
A	useGlobalEnvironment()	0	8	2
A	buildFullUri()	0	12	2
A	createPsrRequest()	0	10	2
A	convertRequest()	0	23	3
A	convertResponse()	0	8	1
B	convertUploadedFiles()	0	16	5
A	doRequest()	0	13	2

<?php

namespace Jasny\Codeception;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\UploadedFileInterface;
use Jasny\HttpMessage\Response;
use Jasny\HttpMessage\ServerRequest;
use Jasny\HttpMessage\UploadedFile;
use Jasny\HttpMessage\Uri;
use Jasny\HttpMessage\Stream;
use Jasny\Router;
use Symfony\Component\BrowserKit\Client;
use Symfony\Component\BrowserKit\Request as BrowserKitRequest;
use Symfony\Component\BrowserKit\Response as BrowserKitResponse;

/**
 * Codeception connector for Jasny\MVC
 */
class Connector extends Client
{
    /**
     * @var Router
     */
    protected $router;
    
    /**
     * @var false
     */
    protected $useGlobalEnvironment = false;
    
    
    /**
     * Set the router
     * 
     * @param Router $router
     * @param string $legacy

There is no parameter named $legacy. Was it maybe removed?

     */
    public function setRouter(Router $router)
    {
        $this->router = $router;
    }
    
    /**
     * Get the router
     * 
     * @return Router
     */
    public function getRouter()
    {
        return $this->router;
    }
    
    
    /**
     * Get or set the global environment flag
     * 
     * @param boolean $enable
     */
    public function useGlobalEnvironment($enable = null)
    {
        if (isset($enable)) {
            $this->useGlobalEnvironment = $enable;

The property $useGlobalEnvironment was declared of type false, but $enable is of type boolean. Maybe add a type cast?

        }
        
        return $this->useGlobalEnvironment;
    }


    /**
     * Build a full URI from a request
     * 
     * @param BrowserKitRequest $request
     * @return array [Uri, queryParams]
     */
    protected function buildFullUri(BrowserKitRequest $request)
    {
        $uri = new Uri($request->getUri());
        parse_str($uri->getQuery(), $queryParams);
        
        if ($request->getMethod() === 'GET') {
            $queryParams = array_merge($queryParams, $request->getParameters());
            $uri = $uri->withQuery(http_build_query($queryParams));
        }
        
        return [$uri, $queryParams];
    }
    
    /**
     * Create a PSR-7 Server request object.
     * 
     * @return ServerRequest
     */
    protected function createPsrRequest()
    {
        $psrRequest = new ServerRequest();
        
        if ($this->useGlobalEnvironment) {
            $psrRequest = $psrRequest->withGlobalEnvironment(true);
        }
        
        return $psrRequest;
    }
    
    /**
     * Convert a codeception request to a Jasny PSR-7 server request
     * 
     * @param BrowserKitRequest $request
     * @return ServerRequest
     */
    protected function convertRequest(BrowserKitRequest $request)
    {
        list($uri, $queryParams) = $this->buildFullUri($request);
        
        $stream = fopen('php://temp', 'r+');
        fwrite($stream, $request->getContent());
        
        $psrRequest = $this->createPsrRequest()
            ->withServerParams($request->getServer())
            ->withMethod($request->getMethod())
            ->withRequestTarget((string)($uri->withScheme('')->withHost('')->withPort('')->withUserInfo('')))
            ->withCookieParams($request->getCookies())
            ->withUri($uri)
            ->withQueryParams($queryParams)

It seems like $queryParams can also be of type null; however, Jasny\HttpMessage\ServerRequest\QueryParams::withQueryParams() does only seem to accept array, maybe add an additional type check?

            ->withBody(new Stream($stream))
            ->withUploadedFiles($this->convertUploadedFiles($request->getFiles()));
        
        if ($request->getMethod() !== 'GET' && $request->getParameters() !== null) {
            $psrRequest = $psrRequest->withParsedBody($request->getParameters());
        }
        
        return $psrRequest;
    }
    
    /**
     * Convert a Jasny PSR-7 response to a codeception response
     * 
     * @param ResponseInterface $psrResponse
     * @return BrowserKitResponse
     */
    protected function convertResponse(ResponseInterface $psrResponse)
    {
        return new BrowserKitResponse(
            (string)$psrResponse->getBody(),
            $psrResponse->getStatusCode(),
            $psrResponse->getHeaders()
        );
    }
    
    /**
     * Convert a list of uploaded files to a Jasny PSR-7 uploaded files
     * 
     * @param array $files
     * @return UploadedFile[]|array
     */
    protected function convertUploadedFiles(array $files)
    {
        $fileObjects = [];
        
        foreach ($files as $fieldName => $file) {
            if ($file instanceof UploadedFileInterface) {
                $fileObjects[$fieldName] = $file;
            } elseif (!isset($file['tmp_name']) && !isset($file['name'])) {
                $fileObjects[$fieldName] = $this->convertUploadedFiles($file);
            } else {
                $fileObjects[$fieldName] = new UploadedFile($file);
            }
        }
        
        return $fileObjects;
    }
    
    
    /**
     * Makes a request.
     * 
     * @param BrowserKitRequest $request
     * @return BrowserKitResponse
     */
    protected function doRequest($request)
    {
        if ($this->getRouter() === null) {
            throw new \Exception("Router not set");
        }
        
        $psrRequest = $this->convertRequest($request);
        
        $router = $this->getRouter();
        $psrResponse = $router->handle($psrRequest, new Response());
        
        return $this->convertResponse($psrResponse);
    }
}