Paraunit\Parser\JSON\LogParser

Complexity

Total Complexity

14

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

92.31%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	getSubscribedEvents()	0	6	1
A	addParser()	0	4	1
A	getParsers()	0	4	1
A	onProcessTerminated()	0	15	2
A	processLogs()	0	10	3
A	processLog()	0	9	3
A	noTestsExecuted()	0	4	2

<?php

declare(strict_types=1);

namespace Paraunit\Parser\JSON;

use Paraunit\Lifecycle\ProcessEvent;
use Paraunit\Process\AbstractParaunitProcess;
use Paraunit\TestResult\Interfaces\TestResultHandlerInterface;
use Paraunit\TestResult\Interfaces\TestResultInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

/**
 * Class LogParser
 * @package Paraunit\Parser\JSON
 */
class LogParser implements EventSubscriberInterface
{
    /** @var LogFetcher */
    private $logLocator;

    /** @var TestResultHandlerInterface */
    private $noTestExecutedResultContainer;

    /** @var EventDispatcherInterface */
    private $eventDispatcher;

    /** @var RetryParser */
    private $retryParser;

    /** @var ParserChainElementInterface[] */
    private $parsers;

    /**
     * LogParser constructor.
     * @param LogFetcher $logLocator
     * @param TestResultHandlerInterface $noTestExecutedResultContainer
     * @param EventDispatcherInterface $eventDispatcher
     * @param RetryParser $retryParser
     */
    public function __construct(
        LogFetcher $logLocator,
        TestResultHandlerInterface $noTestExecutedResultContainer,
        EventDispatcherInterface $eventDispatcher,
        RetryParser $retryParser
    ) {
        $this->logLocator = $logLocator;
        $this->noTestExecutedResultContainer = $noTestExecutedResultContainer;
        $this->eventDispatcher = $eventDispatcher;
        $this->retryParser = $retryParser;
        $this->parsers = [];
    }

    public static function getSubscribedEvents(): array
    {
        return [
            ProcessEvent::PROCESS_TERMINATED => 'onProcessTerminated',
        ];
    }

    /**
     * @param ParserChainElementInterface $container
     */
    public function addParser(ParserChainElementInterface $container)
    {
        $this->parsers[] = $container;
    }

    /**
     * @return ParserChainElementInterface[]
     */
    public function getParsers(): array
    {
        return $this->parsers;
    }

    /**
     * @param ProcessEvent $processEvent
     */
    public function onProcessTerminated(ProcessEvent $processEvent)
    {
        $process = $processEvent->getProcess();
        $logs = $this->logLocator->fetch($process);

        if ($this->noTestsExecuted($process, $logs)) {
            $this->noTestExecutedResultContainer->addProcessToFilenames($process);

            return;
        }

        $this->processLogs($process, $logs);

        $this->eventDispatcher->dispatch(ProcessEvent::PROCESS_PARSING_COMPLETED, new ProcessEvent($process));
    }

    /**
     * @param AbstractParaunitProcess $process
     * @param \stdClass[] $logs
     */
    private function processLogs(AbstractParaunitProcess $process, array $logs)
    {
        if ($this->retryParser->processWillBeRetried($process, $logs)) {
            return;
        }

        foreach ($logs as $singleLog) {
            $this->processLog($process, $singleLog);
        }
    }

    /**
     * @param AbstractParaunitProcess $process
     * @param \stdClass $logItem
     */
    private function processLog(AbstractParaunitProcess $process, \stdClass $logItem)
    {
        /** @var ParserChainElementInterface $resultContainer */
        foreach ($this->parsers as $resultContainer) {
            if ($resultContainer->handleLogItem($process, $logItem) instanceof TestResultInterface) {
                return;
            }
        }
    }

    /**
     * @param AbstractParaunitProcess $process
     * @param array $logs
     * @return bool
     */
    private function noTestsExecuted(AbstractParaunitProcess $process, array $logs): bool
    {
        return $process->getExitCode() === 0 && count($logs) === 1;
    }
}