Doyo\Behat\CodeCoverage\Listener\CoverageListener

Complexity

Total Complexity

12

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Test Coverage

Coverage

71.05%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	refresh()	0	7	2
A	complete()	0	7	2
A	start()	0	11	2
A	__construct()	0	6	1
A	getSubscribedEvents()	0	9	1
A	stop()	0	19	4

<?php

/*
 * This file is part of the doyo/code-coverage project.
 *
 * (c) Anthonius Munthi <https://itstoni.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Doyo\Behat\CodeCoverage\Listener;

use Behat\Behat\EventDispatcher\Event\ExampleTested;
use Behat\Behat\EventDispatcher\Event\ScenarioTested;
use Behat\Testwork\EventDispatcher\Event\AfterTested;
use Behat\Testwork\EventDispatcher\Event\ExerciseCompleted;
use Behat\Testwork\Tester\Result\TestResult;
use Behat\Testwork\Tester\Result\TestResults;
use Doyo\Bridge\CodeCoverage\CodeCoverageInterface;
use Doyo\Bridge\CodeCoverage\TestCase;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

class CoverageListener implements EventSubscriberInterface
{
    /**
     * @var bool
     */
    private $enabled = false;

    /**
     * @var CodeCoverageInterface
     */
    private $coverage;

    public function __construct(
        CodeCoverageInterface $coverage,
        bool $enabled
    ) {
        $this->coverage = $coverage;
        $this->enabled  = $enabled;
    }

    public static function getSubscribedEvents()
    {
        return [
            ExerciseCompleted::BEFORE => 'refresh',
            ScenarioTested::BEFORE    => 'start',
            ExampleTested::BEFORE     => 'start',
            ScenarioTested::AFTER     => 'stop',
            ExampleTested::AFTER      => 'stop',
            ExerciseCompleted::AFTER  => 'complete',
        ];
    }

    public function refresh()
    {
        if (!$this->enabled) {
            return;
        }

        $this->coverage->refresh();
    }

    public function start(ScenarioTested $scenarioTested)
    {
        if (!$this->enabled) {
            return;
        }

        $scenario   = $scenarioTested->getScenario();
        $id         = $scenarioTested->getFeature()->getFile().':'.$scenario->getLine();
        $testCase   = new TestCase($id);

        $this->coverage->start($testCase);
    }

    public function stop(AfterTested $tested)
    {
        if (!$this->enabled || null === $tested->getTestResult()) {
            return;
        }

        $map           = [
            TestResult::PASSED    => TestCase::RESULT_PASSED,
            TestResult::FAILED    => TestCase::RESULT_FAILED,
            TestResult::SKIPPED   => TestCase::RESULT_SKIPPED,
            TestResult::PENDING   => TestCase::RESULT_SKIPPED,
            TestResults::NO_TESTS => TestCase::RESULT_SKIPPED,
        ];

        $result   = $map[$tested->getTestResult()->getResultCode()];
        if (null !== $result) {

The condition null !== $result is always true.

            $coverage = $this->coverage;
            $coverage->setResult($result);
            $coverage->stop();
        }
    }

    public function complete()
    {
        if (!$this->enabled) {
            return;
        }

        $this->coverage->complete();
    }
}