Doyo\Bridge\CodeCoverage\Listener\RemoteListener

Complexity

Total Complexity

8

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Test Coverage

Coverage

59.7%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getSubscribedEvents()	0	5	1
A	__construct()	0	13	1
A	complete()	0	33	4
A	refresh()	0	19	2

<?php


namespace Doyo\Bridge\CodeCoverage\Listener;


use Doyo\Bridge\CodeCoverage\Event\CoverageEvent;
use Doyo\Bridge\CodeCoverage\Exception\HttpException;
use Doyo\Bridge\CodeCoverage\Http\ClientInterface;
use Doyo\Bridge\CodeCoverage\Session\SessionInterface;

class RemoteListener extends AbstractSessionListener
{
    /**
     * @var ClientInterface
     */
    private $httpClient;

    /**
     * @var array
     */
    private $config;

    /**
     * @var string
     */
    private $coverageUrl;

    /**
     * @var \Exception[]
     */
    private $exceptions;

    public function __construct(
        SessionInterface $session,
        ClientInterface $httpClient,
        string $coverageUrl,
        array $config
    )
    {
        parent::__construct($session);

        $this->httpClient = $httpClient;
        $this->coverageUrl = $coverageUrl;
        $this->config = $config;
        $this->exceptions = [];
    }

    public static function getSubscribedEvents()
    {
        return [
            CoverageEvent::refresh => 'refresh',
            CoverageEvent::complete => 'complete'
        ];
    }

    public function refresh()
    {
        $client = $this->httpClient;
        $session = $this->session;
        $body = json_encode($this->config);
        $coverageUrl = $this->coverageUrl;

        $options = [
            'body' => $body,
            'query' => [
                'action' => 'init',
                'session' => $session->getName()
            ]
        ];

        try{
            $client->request('POST', $coverageUrl, $options);
        }catch (\Exception $exception){
            $this->exceptions[] = $exception;
        }
    }

    public function complete(CoverageEvent $event)
    {
        $coverageUrl = $this->coverageUrl;
        $client = $this->httpClient;
        $session = $this->session;
        $consoleIO = $event->getConsoleIO();

        $options = [
            'query' => [
                'action' => 'read',
                'session' => $session->getName()
            ]
        ];

        try{
            /* @var SessionInterface $remoteSession */
            $response = $client->request('GET', $coverageUrl, $options);
            $remoteSession = $response->getBody()->getContents();
            $remoteSession = unserialize($remoteSession);
            $event->getProcessor()->merge($remoteSession->getProcessor());
        }catch (\Exception $exception){
            $this->exceptions[] = $exception;
        }

        $exceptions = array_merge($this->exceptions, $remoteSession->getExceptions());

The variable $remoteSession does not seem to be defined for all execution paths leading up to this point.

        $ids = [];
        foreach($exceptions as $exception){
            $message = $exception->getMessage();
            $id = md5($message);
            if(!in_array($id,$ids)){
                $ids[] = $id;
                $consoleIO->coverageInfo($message);
            }
        }
    }
}