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.02%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
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	getLogDirectory()	14	14	3
A	convertToUtf8()	0	8	2
A	getStackTrace()	0	4	1

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 31 and the first side effect is on line 20.

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);
        }
    }
}