NunoMaduro\Collision\Adapters\Phpunit\PrinterContents

Complexity

Total Complexity

21

Size/Duplication

Total Lines	217
Duplicated Lines	7.37 %

Coupling/Cohesion

Components

1

Test Coverage

Coverage

20%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	2
A	addError()	8	8	1
A	addWarning()	0	6	1
A	addFailure()	0	17	2
A	addIncompleteTest()	0	6	1
A	addRiskyTest()	0	6	1
A	addSkippedTest()	0	6	1
A	startTestSuite()	0	6	2
A	endTestSuite()	0	11	3
A	startTest()	0	13	2
A	endTest()	8	8	2
A	write()	0	4	1
A	testCaseFromTest()	0	8	2

<?php

namespace NunoMaduro\Collision\Adapters\Phpunit;

use NunoMaduro\Collision\Exceptions\ShouldNotHappen;
use PHPUnit\Framework\AssertionFailedError;
use PHPUnit\Framework\Test;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestSuite;
use PHPUnit\Framework\Warning;
use ReflectionObject;
use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Console\Output\ConsoleOutput;
use Throwable;

trait PrinterContents
{
    /**
     * Holds an instance of the style.
     *
     * Style is a class we use to interact with output.
     *
     * @var Style
     */
    private $style;

    /**
     * Holds the duration time of the test suite.
     *
     * @var Timer
     */
    private $timer;

    /**
     * Holds the state of the test
     * suite. The number of tests, etc.
     *
     * @var State
     */
    private $state;

    /**
     * If the test suite has ended before.
     *
     * @var bool
     */
    private $ended = false;

    /**
     * Creates a new instance of the listener.
     *
     * @param  ConsoleOutput  $output
     *
     * @throws \ReflectionException
     */
    public function __construct(ConsoleOutput $output = null)
    {
        if (intval(substr(\PHPUnit\Runner\Version::id(), 0, 1)) === 8) {
            parent::__construct();
        }

        $this->timer = Timer::start();

        $output = $output ?? new ConsoleOutput();
        ConfigureIO::of(new ArgvInput(), $output);

        $this->style = new Style($output);
        $dummyTest = new class extends TestCase {
        };

        $this->state = State::from($dummyTest);

It seems like \NunoMaduro\Collision\Adapters\Phpunit\State::from($dummyTest) of type object<self> is incompatible with the declared type object<NunoMaduro\Collision\Adapters\Phpunit\State> of property $state.

    }

    /**
     * {@inheritdoc}
     */
    public function addError(Test $testCase, Throwable $throwable, float $time): void

The parameter $time is not used and could be removed.

This method seems to be duplicated in your project.

    {
        $testCase = $this->testCaseFromTest($testCase);

        $this->state->add(TestResult::fromTestCase($testCase, TestResult::FAIL));

        $this->style->writeError($this->state, $throwable);
    }

    /**
     * {@inheritdoc}
     */
    public function addWarning(Test $testCase, Warning $warning, float $time): void

The parameter $time is not used and could be removed.

    {
        $testCase = $this->testCaseFromTest($testCase);

        $this->state->add(TestResult::fromTestCase($testCase, TestResult::WARN, $warning->getMessage()));
    }

    /**
     * {@inheritdoc}
     */
    public function addFailure(Test $testCase, AssertionFailedError $error, float $time): void

The parameter $time is not used and could be removed.

    {
        $testCase = $this->testCaseFromTest($testCase);

        $this->state->add(TestResult::fromTestCase($testCase, TestResult::FAIL));

        $reflector = new ReflectionObject($error);

        if ($reflector->hasProperty('message')) {
            $message = trim((string) preg_replace("/\r|\n/", ' ', $error->getMessage()));
            $property = $reflector->getProperty('message');
            $property->setAccessible(true);
            $property->setValue($error, $message);
        }

        $this->style->writeError($this->state, $error);
    }

    /**
     * {@inheritdoc}
     */
    public function addIncompleteTest(Test $testCase, Throwable $t, float $time): void

The parameter $t is not used and could be removed.

The parameter $time is not used and could be removed.

    {
        $testCase = $this->testCaseFromTest($testCase);

        $this->state->add(TestResult::fromTestCase($testCase, TestResult::INCOMPLETE));
    }

    /**
     * {@inheritdoc}
     */
    public function addRiskyTest(Test $testCase, Throwable $t, float $time): void

The parameter $time is not used and could be removed.

    {
        $testCase = $this->testCaseFromTest($testCase);

        $this->state->add(TestResult::fromTestCase($testCase, TestResult::RISKY, $t->getMessage()));
    }

    /**
     * {@inheritdoc}
     */
    public function addSkippedTest(Test $testCase, Throwable $t, float $time): void

The parameter $time is not used and could be removed.

    {
        $testCase = $this->testCaseFromTest($testCase);

        $this->state->add(TestResult::fromTestCase($testCase, TestResult::SKIPPED, $t->getMessage()));
    }

    /**
     * {@inheritdoc}
     */
    public function startTestSuite(TestSuite $suite): void
    {
        if ($this->state->suiteTotalTests === null) {
            $this->state->suiteTotalTests = $suite->count();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function endTestSuite(TestSuite $suite): void

The parameter $suite is not used and could be removed.

    {
        if (! $this->ended && $this->state->suiteTotalTests === $this->state->testSuiteTestsCount()) {
            $this->ended = true;

            $this->style->writeCurrentRecap($this->state);

            $this->style->updateFooter($this->state);
            $this->style->writeRecap($this->timer);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function startTest(Test $testCase): void
    {
        $testCase = $this->testCaseFromTest($testCase);

        // Let's check first if the testCase is over.
        if ($this->state->testCaseHasChanged($testCase)) {
            $this->style->writeCurrentRecap($this->state);

            $this->state->moveTo($testCase);
        }

        $this->style->updateFooter($this->state, $testCase);
    }

    /**
     * {@inheritdoc}
     */
    public function endTest(Test $testCase, float $time): void

The parameter $time is not used and could be removed.

This method seems to be duplicated in your project.

    {
        $testCase = $this->testCaseFromTest($testCase);

        if (! $this->state->existsInTestCase($testCase)) {
            $this->state->add(TestResult::fromTestCase($testCase, TestResult::PASS));
        }
    }

    /**
     * Intentionally left blank as we output things on events of the listener.
     *
     * @param  string  $content
     *
     * @return  void
     */
    public function write(string $content): void

The parameter $content is not used and could be removed.

    {
        // ..
    }

    /**
     * Returns a test case from the given test.
     *
     * Note: This printer is do not work with normal Test classes - only
     * with Test Case classes. Please report an issue if you think
     * this should work any other way.
     *
     * @param  Test  $test
     *
     * @return TestCase
     */
    private function testCaseFromTest(Test $test): TestCase
    {
        if (! $test instanceof TestCase) {
            throw new ShouldNotHappen();
        }

        return $test;
    }
}