Paraunit\Parser\JSON\LogPrinter

Complexity

Total Complexity

31

Size/Duplication

Total Lines	304
Duplicated Lines	40.13 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

94.74%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	getLogDirectory()	14	14	3
A	__construct()	0	9	2
A	addError()	0	12	1
A	addWarning()	0	12	1
A	addFailure()	0	12	1
A	addIncompleteTest()	12	12	1
A	addRiskyTest()	12	12	1
A	addSkippedTest()	12	12	1
A	startTestSuite()	11	11	1
A	endTestSuite()	0	5	1
A	startTest()	11	11	2
A	endTest()	0	6	2
A	writeCase()	18	18	2
A	writeArray()	10	10	2
A	writeToLog()	8	8	3
A	getLogFilename()	14	14	4
A	convertToUtf8()	0	8	2
A	getStackTrace()	0	4	1

<?php

declare(strict_types=1);

namespace Paraunit\Parser\JSON;

use Paraunit\Configuration\EnvVariables;
use PHPUnit\Framework\AssertionFailedError;
use PHPUnit\Framework\SelfDescribing;
use PHPUnit\Framework\Test;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestFailure;
use PHPUnit\Framework\TestListener;
use PHPUnit\Framework\TestSuite;
use PHPUnit\Framework\Warning;
use PHPUnit\Runner\Version;
use PHPUnit\Util;

if (version_compare(Version::id(), '7.0.0', '<')) {
    class_alias('Paraunit\Parser\JSON\LogPrinterV6', 'Paraunit\Parser\JSON\LogPrinter');
// Using an early return instead of a else does not work when using the PHPUnit phar due to some weird PHP behavior
// (the class gets defined without executing the code before it and so the definition is not properly conditional)
} else {
    /**
     * This class comes from Util\Log_JSON.
     * It's copied and refactored here because it's deprecated in PHPUnit 5.7 and it will be dropped in PHPUnit 6
     *
     * Class LogPrinter
     * @package Paraunit\Parser\JSON
     */
    class LogPrinter extends Util\Printer implements TestListener
    {
        const STATUS_ERROR = 'error';
        const STATUS_WARNING = 'warning';
        const STATUS_FAIL = 'fail';
        const STATUS_PASS = 'pass';

        const MESSAGE_INCOMPLETE_TEST = 'Incomplete Test: ';
        const MESSAGE_RISKY_TEST = 'Risky Test: ';
        const MESSAGE_SKIPPED_TEST = 'Skipped Test: ';

        /** @var resource */
        private $logFile;

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

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

        /** @var bool */
        private $currentTestPass;

        public function __construct()
        {
            $file = fopen($this->getLogFilename(), 'wt');
            if (! \is_resource($file)) {
                throw new \RuntimeException('Unable to create log file');
            }
            $this->logFile = $file;
            $this->autoFlush = true;
        }

        /**
         * An error occurred.
         *
         * @param Test $test
         * @param \Throwable $exception
         * @param float $time
         */
        public function addError(Test $test, \Throwable $exception, float $time): void
        {
            $this->writeCase(
                self::STATUS_ERROR,
                $time,
                $this->getStackTrace($exception),
                TestFailure::exceptionToString($exception),
                $test
            );

            $this->currentTestPass = false;
        }

        /**
         * A warning occurred.
         *
         * @param Test $test
         * @param Warning $warning
         * @param float $time
         */
        public function addWarning(Test $test, Warning $warning, float $time): void
        {
            $this->writeCase(
                self::STATUS_WARNING,
                $time,
                $this->getStackTrace($warning),
                TestFailure::exceptionToString($warning),
                $test
            );

            $this->currentTestPass = false;
        }

        /**
         * A failure occurred.
         *
         * @param Test $test
         * @param AssertionFailedError $error
         * @param float $time
         */
        public function addFailure(Test $test, AssertionFailedError $error, float $time): void
        {
            $this->writeCase(
                self::STATUS_FAIL,
                $time,
                $this->getStackTrace($error),
                TestFailure::exceptionToString($error),
                $test
            );

            $this->currentTestPass = false;
        }

        /**
         * Incomplete test.
         *
         * @param Test $test
         * @param \Throwable $error
         * @param float $time
         */
        public function addIncompleteTest(Test $test, \Throwable $error, float $time): void

This method seems to be duplicated in your project.

        {
            $this->writeCase(
                self::STATUS_ERROR,
                $time,
                $this->getStackTrace($error),
                self::MESSAGE_INCOMPLETE_TEST . $error->getMessage(),
                $test
            );

            $this->currentTestPass = false;
        }

        /**
         * Risky test.
         *
         * @param Test $test
         * @param \Throwable $exception
         * @param float $time
         */
        public function addRiskyTest(Test $test, \Throwable $exception, float $time): void

This method seems to be duplicated in your project.

        {
            $this->writeCase(
                self::STATUS_ERROR,
                $time,
                $this->getStackTrace($exception),
                self::MESSAGE_RISKY_TEST . $exception->getMessage(),
                $test
            );

            $this->currentTestPass = false;
        }

        /**
         * Skipped test.
         *
         * @param Test $test
         * @param \Throwable $exception
         * @param float $time
         */
        public function addSkippedTest(Test $test, \Throwable $exception, float $time): void

This method seems to be duplicated in your project.

        {
            $this->writeCase(
                self::STATUS_ERROR,
                $time,
                $this->getStackTrace($exception),
                self::MESSAGE_SKIPPED_TEST . $exception->getMessage(),
                $test
            );

            $this->currentTestPass = false;
        }

        /**
         * A testsuite started.
         *
         * @param TestSuite $suite
         * @throws \RuntimeException
         */
        public function startTestSuite(TestSuite $suite): void

This method seems to be duplicated in your project.

        {
            $this->currentTestSuiteName = $suite->getName();
            $this->currentTestName = '';

            $this->writeArray([
                'event' => 'suiteStart',
                'suite' => $this->currentTestSuiteName,
                'tests' => count($suite),
            ]);
        }

        public function endTestSuite(TestSuite $suite): void
        {
            $this->currentTestSuiteName = '';
            $this->currentTestName = '';
        }

        public function startTest(Test $test): void

This method seems to be duplicated in your project.

        {
            $this->currentTestName = $test instanceof SelfDescribing ? $test->toString() : \get_class($test);
            $this->currentTestPass = true;

            $this->writeArray([
                'event' => 'testStart',
                'suite' => $this->currentTestSuiteName,
                'test' => $this->currentTestName,
            ]);
        }

        /**
         * A test ended.
         *
         * @param Test $test
         * @param float $time
         */
        public function endTest(Test $test, float $time): void
        {
            if ($this->currentTestPass) {
                $this->writeCase(self::STATUS_PASS, $time, '', '', $test);
            }
        }

        /**
         * @param string $status
         * @param float $time
         * @param string $trace
         * @param string $message
         * @param Test|TestCase|null $test
         */
        private function writeCase(string $status, float $time, string $trace, $message = '', $test = null)

This method seems to be duplicated in your project.

        {
            $output = '';
            if ($test instanceof TestCase) {
                $output = $test->getActualOutput();
            }

            $this->writeArray([
                'event' => 'test',
                'suite' => $this->currentTestSuiteName,
                'test' => $this->currentTestName,
                'status' => $status,
                'time' => $time,
                'trace' => $trace,
                'message' => $this->convertToUtf8($message),
                'output' => $output,
            ]);
        }

        /**
         * @param array $buffer
         */
        private function writeArray($buffer)

This method seems to be duplicated in your project.

        {
            array_walk_recursive($buffer, function (&$input) {
                if (is_string($input)) {
                    $input = $this->convertToUtf8($input);
                }
            });

            $this->writeToLog(json_encode($buffer, JSON_PRETTY_PRINT));
        }

        private function writeToLog($buffer)

This method seems to be duplicated in your project.

        {
            // ignore everything that is not a JSON object
            if ($buffer != '' && $buffer[0] === '{') {
                \fwrite($this->logFile, $buffer);
                \fflush($this->logFile);
            }
        }

        /**
         * @return string
         * @throws \RuntimeException
         * @throws \InvalidArgumentException
         */
        private function getLogFilename(): string

This method seems to be duplicated in your project.

        {
            $logDir = $this->getLogDirectory();
            if (! @mkdir($logDir, 0777, true) && ! is_dir($logDir)) {
                throw new \RuntimeException('Cannot create folder for JSON logs');
            }

            $logFilename = getenv(EnvVariables::PROCESS_UNIQUE_ID);
            if ($logFilename === false) {
                throw new \InvalidArgumentException('Log filename not received: environment variable not set');
            }

            return $logDir . $logFilename . '.json.log';
        }

        /**
         * @return string
         * @throws \InvalidArgumentException
         */
        private function getLogDirectory(): string

This method seems to be duplicated in your project.

        {
            $logDirectory = getenv(EnvVariables::LOG_DIR);

            if ($logDirectory === false) {
                throw new \InvalidArgumentException('Log directory not received: environment variable not set');
            }

            if (substr($logDirectory, -1) !== DIRECTORY_SEPARATOR) {
                $logDirectory .= DIRECTORY_SEPARATOR;
            }

            return $logDirectory;
        }

        private function convertToUtf8($string): string
        {
            if (! \mb_detect_encoding($string, 'UTF-8', true)) {
                return \mb_convert_encoding($string, 'UTF-8');
            }

            return $string;
        }

        private function getStackTrace($error): string
        {
            return Util\Filter::getFilteredStacktrace($error);
        }
    }
}