Paraunit\Parser\JSONLogParser

Complexity

Total Complexity

13

Size/Duplication

Total Lines	104
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

95.24%

Importance

Changes	8
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	addParser()	0	4	1
A	getParsersForPrinting()	0	4	1
A	getAbnormalTerminatedOutputContainer()	0	4	1
A	onProcessTerminated()	0	4	1
B	parse()	0	29	5
A	extractTestResult()	0	10	3

<?php

namespace Paraunit\Parser;

use Paraunit\Exception\JSONLogNotFoundException;
use Paraunit\Exception\RecoverableTestErrorException;
use Paraunit\Lifecycle\ProcessEvent;
use Paraunit\Printer\OutputContainerInterface;
use Paraunit\Process\ParaunitProcessAbstract;
use Paraunit\Process\ProcessResultInterface;

/**
 * Class JSONLogParser
 * @package Paraunit\Parser
 */
class JSONLogParser
{
    /** @var  JSONLogFetcher */
    private $logLocator;

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

    /** @var  OutputContainerInterface */
    private $abnormalTerminatedOutputContainer;

    /**
     * JSONLogParser constructor.
     * @param JSONLogFetcher $logLocator
     * @param OutputContainerInterface $abnormalTerminatedOutputContainer
     */
    public function __construct(JSONLogFetcher $logLocator, OutputContainerInterface $abnormalTerminatedOutputContainer)
    {
        $this->logLocator = $logLocator;
        $this->abnormalTerminatedOutputContainer = $abnormalTerminatedOutputContainer;
        $this->parsers = array();
    }

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

    /**
     * @return JSONParserChainElementInterface[]
     */
    public function getParsersForPrinting()
    {
        return array_reverse($this->parsers);
    }

    /**
     * @return OutputContainerInterface
     */
    public function getAbnormalTerminatedOutputContainer()
    {
        return $this->abnormalTerminatedOutputContainer;
    }

    /**
     * @param ProcessEvent $processEvent
     */
    public function onProcessTerminated(ProcessEvent $processEvent)
    {
        $this->parse($processEvent->getProcess());
    }

    /**
     * @param ParaunitProcessAbstract $process
     */
    public function parse(ParaunitProcessAbstract $process)
    {
        try {
            $logs = $this->logLocator->fetch($process);
        } catch (JSONLogNotFoundException $exception) {
            $process->addTestResult('X');
            $process->reportAbnormalTerminationInFunction('Unknown function -- test log not found');
            $this->getAbnormalTerminatedOutputContainer()->addToOutputBuffer($process, $process->getOutput());

            return;
        }

        $expectingTestResult = false;

        foreach ($logs as $singleLog) {
            if ($singleLog->event == 'test') {
                $expectingTestResult = false;
                $this->extractTestResult($process, $singleLog);
            } else {
                $expectingTestResult = true;
            }
        }

        if ($expectingTestResult) {
            $process->addTestResult('X');
            $process->reportAbnormalTerminationInFunction($singleLog->test);

The variable $singleLog seems to be defined by a foreach iteration on line 88. Are you sure the iterator is never empty, otherwise this variable is not defined?

            $this->getAbnormalTerminatedOutputContainer()->addToOutputBuffer($process, $process->getOutput());
        }
    }

    /**
     * @param ProcessResultInterface $process
     * @param \stdClass $logItem
     * @return bool False if the parsing is still waiting for a test to give results
     */
    private function extractTestResult(ProcessResultInterface $process, \stdClass $logItem)
    {
        foreach ($this->parsers as $parser) {
            if ($parser->parsingFoundResult($process, $logItem)) {
                return true;
            }
        }

        return false;
    }
}