Paraunit\Parser\JSONLogParser

Complexity

Total Complexity

15

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.92%

Importance

Changes	10
Bugs	0	Features	0

9 Methods

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

<?php

namespace Paraunit\Parser;

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

/**
 * Class JSONLogParser
 * @package Paraunit\Parser
 */
class JSONLogParser implements OutputContainerBearerInterface
{
    /** @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 getOutputContainer()
    {
        return $this->getAbnormalTerminatedOutputContainer();
    }

    /**
     * @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) {
            $this->reportAbnormalTermination($process);

            return;
        }

        $expectingTestResult = false;

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

        if ($expectingTestResult) {
            $this->reportAbnormalTermination($process, $singleLog->test);
        }
    }

    /**
     * @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;
    }

    /**
     * @param ParaunitProcessAbstract $process
     * @param string $culpableFunctionName
     */
    private function reportAbnormalTermination(ParaunitProcessAbstract $process, $culpableFunctionName = 'Unknown function -- test log not found')
    {
        $process->addTestResult('X');
        $process->reportAbnormalTermination();
        $this->getAbnormalTerminatedOutputContainer()->addToOutputBuffer(
            $process,
            'Culpable test function: ' . $culpableFunctionName . " -- complete test output:\n\n" . $process->getOutput()
        );
    }
}