Doyo\Bridge\CodeCoverage\Controller\RemoteController

Complexity

Total Complexity

13

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Test Coverage

Coverage

50.6%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	unsupportedMethodAction()	0	12	1
A	getResponse()	0	11	2
A	notFoundAction()	0	7	1
A	initAction()	0	29	4
A	readAction()	0	29	4
A	create()	0	3	1

<?php

/*
 * This file is part of the doyo/code-coverage project.
 *
 * (c) Anthonius Munthi <me@itstoni.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Doyo\Bridge\CodeCoverage\Controller;

use Doyo\Bridge\CodeCoverage\Session\RemoteSession;
use Spec\Doyo\Bridge\CodeCoverage\ResponseTrait;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Test\Constraint\ResponseHasCookie;

class RemoteController
{
    const SERIALIZED_OBJECT_CONTENT_TYPE = 'application/php-serialized-object';

    /**
     * @return static
     */
    public static function create()
    {
        return new static();
    }

    /**
     * @return Response
     */
    public function getResponse()
    {
        $request  = Request::createFromGlobals();
        $action   = $request->get('action').'Action';
        $callable = [$this, $action];

        if (!method_exists($this, $action)) {
            $callable = [$this, 'notFoundAction'];
        }

        return \call_user_func_array($callable, [$request]);
    }

    /**
     * @return JsonResponse
     */
    public function notFoundAction()
    {
        $data = [
            'message' => 'The page you requested is not exists',
        ];

        return new JsonResponse($data, 404);
    }

    public function unsupportedMethodAction(Request $request, $supportedMethod)
    {
        $data = [
            'message' => sprintf(
                'action: %s not support method: %s. Supported method: %s',
                $request->get('action'),
                $request->getMethod(),
                $supportedMethod
            ),
        ];

        return new JsonResponse($data, Response::HTTP_METHOD_NOT_ALLOWED);
    }

    public function initAction(Request $request)
    {
        if (!$request->isMethod(Request::METHOD_POST)) {
            return $this->unsupportedMethodAction($request, 'POST');
        }
        $name   = $request->get('session');
        $config = $request->getContent();
        $config = json_decode($config, true);
        $error = 'Failed to create session: <comment>'.$name.'</comment>';

        try{
            $created = RemoteSession::init($name, $config);

Are you sure the assignment to $created is correct as Doyo\Bridge\CodeCoverage\Session\RemoteSession::init($name, $config) targeting Doyo\Bridge\CodeCoverage\Session\AbstractSession::init() seems to always return null.

It seems like $name can also be of type null; however, parameter $config of Doyo\Bridge\CodeCoverage\Session\AbstractSession::init() does only seem to accept array, maybe add an additional type check?

The method Doyo\Bridge\CodeCoverage\Session\AbstractSession::init() is not static, but was called statically.

The call to Doyo\Bridge\CodeCoverage\Session\AbstractSession::init() has too many arguments starting with $config.

        }catch (\Exception $e){
            $error = $e->getMessage();
            $created = false;
        }

        $status = Response::HTTP_ACCEPTED;
        if($created){

$created is of type false|null, thus it always evaluated to false.

            $data = [
                'message' => 'coverage session: '.$name.' initialized.',
            ];
        }else{
            $data = [
                'message' => $error
            ];
        }

        return new JsonResponse($data, $status);
    }

    public function readAction(Request $request)
    {
        if (!$request->isMethod(Request::METHOD_GET)) {
            return $this->unsupportedMethodAction($request, Request::METHOD_GET);
        }

        if (!$request->get('session')) {
            $data = [
                'message' => 'code coverage session not exists',
            ];

            return new JsonResponse($data, Response::HTTP_NOT_FOUND);
        }
        $session = $request->get('session');
        $session = new RemoteSession($session);

It seems like $session can also be of type null; however, parameter $name of Doyo\Bridge\CodeCoverage\Session\RemoteSession::__construct() does only seem to accept string, maybe add an additional type check?

        $data    = serialize($session);

        if (null === $session->getProcessor()) {

Are you sure the usage of $session->getProcessor() targeting Doyo\Bridge\CodeCoverage\Session\AbstractSession::getProcessor() seems to always return null.

The condition null === $session->getProcessor() is always true.

            $data = [
                'message' => 'Session '.$session->getName().' is not initialized.',
            ];

            return new JsonResponse($data, Response::HTTP_NOT_FOUND);
        }

        $response =  new Response($data, Response::HTTP_OK);
        $response->headers->set('Content-Type', static::SERIALIZED_OBJECT_CONTENT_TYPE);

        return $response;
    }
}