LogPrinter::getStackTrace() - Code Metrics - Inspection of "Merge pull request #105 from facile-it/phpstan" - facile-it/paraunit - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b70c49...e834bf )

by Alessandro

created 2017-11-09 15:56 UTC

LogPrinter::getStackTrace() A

↳ Parent: LogPrinter

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	7
ccs	0
cts	0
cp	0
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	1
crap	2

<?php
declare(strict_types=1);

namespace Paraunit\Parser\JSON;

use Paraunit\Configuration\EnvVariables;
use PHPUnit\Framework\AssertionFailedError;
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\Util;

/**
 * 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()
    {
        $this->logFile = fopen($this->getLogFilename(), 'wt');
        $this->autoFlush = true;
    }

    /**
     * An error occurred.
     *
     * @param Test $test
     * @param \Exception $exception
     * @param float $time
     */
    public function addError(Test $test, \Exception $exception, $time)

    {
        $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, $time)

    {
        $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, $time)

    {
        $this->writeCase(
            self::STATUS_FAIL,
            $time,
            $this->getStackTrace($error),
            TestFailure::exceptionToString($error),
            $test
        );

        $this->currentTestPass = false;
    }

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

    {
        $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 \Exception $exception
     * @param float $time
     */
    public function addRiskyTest(Test $test, \Exception $exception, $time)

    {
        $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 \Exception $exception
     * @param float $time
     */
    public function addSkippedTest(Test $test, \Exception $exception, $time)

    {
        $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)
    {
        $this->currentTestSuiteName = $suite->getName();
        $this->currentTestName = '';

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

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

    public function startTest(Test $test)
    {
        $this->currentTestName = Util\Test::describe($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, $time)
    {
        if ($this->currentTestPass) {
            $this->writeCase(self::STATUS_PASS, $time, [], '', $test);
        }
    }

    /**
     * @param string $status
     * @param float $time
     * @param array $trace
     * @param string $message
     * @param Test|TestCase|null $test
     */
    private function writeCase($status, $time, array $trace = [], $message = '', $test = null)
    {
        $output = '';
        // take care of TestSuite producing error (e.g. by running into exception) as TestSuite doesn't have hasOutput
        if ($test !== null && method_exists($test, 'hasOutput') && $test->hasOutput()) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            $output = $test->getActualOutput();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }
        $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)
    {
        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)
    {
        // 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
    {
        $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
    {
        $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): array
    {
        /** @var string[] $trace */
        $trace = Util\Filter::getFilteredStacktrace($error, false);
        
        return $trace;
    }
}


Push — master ( b70c49...e834bf )

LogPrinter::getStackTrace() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

1			<?php
2			declare(strict_types=1);
3
4			namespace Paraunit\Parser\JSON;
5
6			use Paraunit\Configuration\EnvVariables;
7			use PHPUnit\Framework\AssertionFailedError;
8			use PHPUnit\Framework\Test;
9			use PHPUnit\Framework\TestCase;
10			use PHPUnit\Framework\TestFailure;
11			use PHPUnit\Framework\TestListener;
12			use PHPUnit\Framework\TestSuite;
13			use PHPUnit\Framework\Warning;
14			use PHPUnit\Util;
15
16			/**
17			* This class comes from Util\Log_JSON.
18			* It's copied and refactored here because it's deprecated in PHPUnit 5.7 and it will be dropped in PHPUnit 6
19			*
20			* Class LogPrinter
21			* @package Paraunit\Parser\JSON
22			*/
23			class LogPrinter extends Util\Printer implements TestListener
24			{
25			const STATUS_ERROR = 'error';
26			const STATUS_WARNING = 'warning';
27			const STATUS_FAIL = 'fail';
28			const STATUS_PASS = 'pass';
29
30			const MESSAGE_INCOMPLETE_TEST = 'Incomplete Test: ';
31			const MESSAGE_RISKY_TEST = 'Risky Test: ';
32			const MESSAGE_SKIPPED_TEST = 'Skipped Test: ';
33
34			/** @var resource */
35			private $logFile;
36
37			/** @var string */
38			private $currentTestSuiteName;
39
40			/** @var string */

facile-it / paraunit

Push — master ( b70c49...e834bf )

LogPrinter::getStackTrace() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like