anonymous//tests/InjectionStrategy/NamedMethodStrategyTest.php$1 ➔ testInject()

Complexity

Conditions

1

Size

Total Lines

32

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	NamedMethodStrategyTest.php$1 ➔ someLongProperty()	0	3	1
A	NamedMethodStrategyTest.php$1 ➔ foo()	0	3	1
A	NamedMethodStrategyTest.php$1 ➔ b()	0	3	1
A	NamedMethodStrategyTest.php$1 ➔ getB()	0	3	1

<?php
declare(strict_types = 1);

namespace Tests\Innmind\Reflection\InjectionStrategy;

use Innmind\Reflection\{
    InjectionStrategy\NamedMethodStrategy,
    InjectionStrategy,
    Exception\LogicException,
};
use Fixtures\Innmind\Reflection\Foo;
use PHPUnit\Framework\TestCase;

class NamedMethodStrategyTest extends TestCase
{
    public function testInterface()
    {
        $this->assertInstanceOf(
            InjectionStrategy::class,
            new NamedMethodStrategy
        );
    }

    public function testSupports()
    {
        $s = new NamedMethodStrategy;
        $o = new class {
            private $a;

The private property $a is not used, and could be removed.

            private $b;

            public function b($b)
            {
                $this->b = $b;
            }

            public function someLongProperty($foo)

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

            {
            }

            private function foo($foo)

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

            {
            }

            private function bar($bar)

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

            {
            }
        };

        $this->assertTrue($s->supports($o, 'b', null));
        $this->assertTrue($s->supports($o, 'some_long_property', null));
        $this->assertFalse($s->supports($o, 'a', null));
        $this->assertFalse($s->supports($o, 'foo', null));
        $this->assertFalse($s->supports($o, 'bar', null));
    }

    public function testInject()
    {
        $s = new NamedMethodStrategy;
        $o = new class {
            private $b;
            private $foo;

            public function b($b)
            {
                $this->b = $b;
            }

            public function getB()
            {
                return $this->b;
            }

            public function someLongProperty($foo)
            {
                $this->foo = $foo;
            }

            public function foo()
            {
                return $this->foo;
            }
        };

        $this->assertSame($o, $s->inject($o, 'b', 'bar'));
        $this->assertSame('bar', $o->getB());
        $this->assertSame($o, $s->inject($o, 'some_long_property', 42));
        $this->assertSame(42, $o->foo());
    }

    public function testThrowWhenInjectingUnsupportedProperty()
    {
        $s = new NamedMethodStrategy;
        $o = new class {
            public $a;
        };

        $this->expectException(LogicException::class);

        $s->inject($o, 'a', 'foo');
    }

    public function testInjectWithInheritedMethod()
    {
        $strategy = new NamedMethodStrategy;
        $object = new class extends Foo {};

        $this->assertSame(42, $object->someProperty());
        $this->assertSame($object, $strategy->inject($object, 'someProperty', 24));
        $this->assertSame(24, $object->someProperty());
    }
}