EnumExtensionTest::testEnumLabel() - Code Metrics - yokai-php/enum-bundle - Measure and Improve Code Quality continuously with Scrutinizer

EnumExtensionTest::testEnumLabel() A
last analyzed 2020-06-25 21:39 UTC

↳ Parent: EnumExtensionTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	29
rs	9.456
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php declare(strict_types=1);

namespace Yokai\EnumBundle\Tests\Twig\Extension;

use Prophecy\Prophecy\ObjectProphecy;
use Twig\Environment;
use Twig\Loader\ArrayLoader;
use Yokai\EnumBundle\EnumInterface;
use Yokai\EnumBundle\EnumRegistry;
use Yokai\EnumBundle\Tests\TestCase;
use Yokai\EnumBundle\Twig\Extension\EnumExtension;

/**
 * @author Yann Eugoné <[email protected]>
 */
class EnumExtensionTest extends TestCase
{
    /**
     * @var EnumRegistry|ObjectProphecy
     */
    private $registry;

    protected function setUp(): void
    {
        $this->registry = $this->prophesize(EnumRegistry::class);
    }

    public function testEnumLabel(): void
    {
        $enum = $this->prophesize(EnumInterface::class);
        $enum->getChoices()
            ->willReturn(['foo' => 'FOO', 'bar' => 'BAR']);

        $this->registry->get('test')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->willReturn($enum->reveal());

        $twig = $this->createEnvironment();

        $this->assertSame(
            'FOO',
            $twig->createTemplate("{{ 'foo'|enum_label('test') }}")->render([])
        );
        $this->assertSame(
            'BAR',
            $twig->createTemplate("{{ enum_label('bar', 'test') }}")->render([])
        );

        $this->assertSame(
            'not_exist',
            $twig->createTemplate("{{ 'not_exist'|enum_label('test') }}")->render([])
        );
        $this->assertSame(
            'not_exist',
            $twig->createTemplate("{{ enum_label('not_exist', 'test') }}")->render([])
        );
    }

    public function testEnumChoices(): void
    {
        $enum = $this->prophesize(EnumInterface::class);
        $enum->getChoices()
            ->willReturn(['foo' => 'FOO', 'bar' => 'BAR']);

        $this->registry->get('test')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->willReturn($enum->reveal());

        $twig = $this->createEnvironment();

        $this->assertSame(
            'foo,FOO|bar,BAR|',
            $twig->createTemplate("{% for value,label in enum_choices('test') %}{{ value }},{{ label }}|{% endfor %}")->render([])
        );
    }

    /**
     * @return Environment
     */
    protected function createEnvironment(): Environment
    {
        $loader = new ArrayLoader([]);
        $twig = new Environment($loader, ['debug' => true, 'cache' => false, 'autoescape' => false]);
        $twig->addExtension($this->createExtension());

        return $twig;
    }

    /**
     * @return EnumExtension
     */
    private function createExtension(): EnumExtension
    {
        return new EnumExtension($this->registry->reveal());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }
}


1			<?php declare(strict_types=1);
2
3			namespace Yokai\EnumBundle\Tests\Twig\Extension;
4
5			use Prophecy\Prophecy\ObjectProphecy;
6			use Twig\Environment;
7			use Twig\Loader\ArrayLoader;
8			use Yokai\EnumBundle\EnumInterface;
9			use Yokai\EnumBundle\EnumRegistry;
10			use Yokai\EnumBundle\Tests\TestCase;
11			use Yokai\EnumBundle\Twig\Extension\EnumExtension;
12
13			/**
14			* @author Yann Eugoné <[email protected]>
15			*/
16			class EnumExtensionTest extends TestCase
17			{
18			/**
19			* @var EnumRegistry\|ObjectProphecy
20			*/
21			private $registry;
22
23			protected function setUp(): void
24			{
25			$this->registry = $this->prophesize(EnumRegistry::class);
26			}
27
28			public function testEnumLabel(): void
29			{
30			$enum = $this->prophesize(EnumInterface::class);
31			$enum->getChoices()
32			->willReturn(['foo' => 'FOO', 'bar' => 'BAR']);
33
34			$this->registry->get('test')
			0 ignored issues – show Bug introduced 2020-06-25 21:38 UTC by Report Bug Copy Issue Report The method `get` does only exist in `Yokai\EnumBundle\EnumRegistry`, but not in `Prophecy\Prophecy\ObjectProphecy`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
35			->willReturn($enum->reveal());
36
37			$twig = $this->createEnvironment();
38
39			$this->assertSame(
40			'FOO',
41			$twig->createTemplate("{{ 'foo'\|enum_label('test') }}")->render([])
42			);
43			$this->assertSame(
44			'BAR',
45			$twig->createTemplate("{{ enum_label('bar', 'test') }}")->render([])
46			);
47
48			$this->assertSame(
49			'not_exist',
50			$twig->createTemplate("{{ 'not_exist'\|enum_label('test') }}")->render([])
51			);
52			$this->assertSame(
53			'not_exist',
54			$twig->createTemplate("{{ enum_label('not_exist', 'test') }}")->render([])
55			);
56			}
57
58			public function testEnumChoices(): void
59			{
60			$enum = $this->prophesize(EnumInterface::class);
61			$enum->getChoices()
62			->willReturn(['foo' => 'FOO', 'bar' => 'BAR']);
63
64			$this->registry->get('test')
			0 ignored issues – show Bug introduced 2020-06-25 21:38 UTC by Report Bug Copy Issue Report The method `get` does only exist in `Yokai\EnumBundle\EnumRegistry`, but not in `Prophecy\Prophecy\ObjectProphecy`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
65			->willReturn($enum->reveal());
66
67			$twig = $this->createEnvironment();
68
69			$this->assertSame(
70			'foo,FOO\|bar,BAR\|',
71			$twig->createTemplate("{% for value,label in enum_choices('test') %}{{ value }},{{ label }}\|{% endfor %}")->render([])
72			);
73			}
74
75			/**
76			* @return Environment
77			*/
78			protected function createEnvironment(): Environment
79			{
80			$loader = new ArrayLoader([]);
81			$twig = new Environment($loader, ['debug' => true, 'cache' => false, 'autoescape' => false]);
82			$twig->addExtension($this->createExtension());
83
84			return $twig;
85			}
86
87			/**
88			* @return EnumExtension
89			*/
90			private function createExtension(): EnumExtension
91			{
92			return new EnumExtension($this->registry->reveal());
			0 ignored issues – show Bug introduced 2020-06-25 21:38 UTC by Report Bug Copy Issue Report The method `reveal` does only exist in `Prophecy\Prophecy\ObjectProphecy`, but not in `Yokai\EnumBundle\EnumRegistry`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
93			}
94			}
95

yokai-php / enum-bundle

EnumExtensionTest::testEnumLabel() A last analyzed 2020-06-25 21:39 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

EnumExtensionTest::testEnumLabel() A
last analyzed 2020-06-25 21:39 UTC