Innmind / Reflection

tests/ExtractionStrategy/ReflectionStrategyTest.php

<?php
declare(strict_types = 1);

namespace Tests\Innmind\Reflection\ExtractionStrategy;

use Innmind\Reflection\{
    ExtractionStrategy\ReflectionStrategy,
    ExtractionStrategy,
    Exception\LogicException,
};
use Fixtures\Innmind\Reflection\Foo;
use PHPUnit\Framework\TestCase;

class ReflectionStrategyTest extends TestCase
{
    public function testInterface()
    {
        $this->assertInstanceOf(
            ExtractionStrategy::class,
            new ReflectionStrategy
        );
    }

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

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

            protected $c;
        };

        $s = new ReflectionStrategy;

        $this->assertTrue($s->supports($o, 'a'));
        $this->assertTrue($s->supports($o, 'b'));
        $this->assertTrue($s->supports($o, 'c'));
        $this->assertFalse($s->supports($o, 'd'));

        $std = new \stdClass;
        $std->foo = 'bar';

        $this->assertTrue($s->supports($std, 'foo'));
    }

    public function testSupportsInheritMethod()
    {
        $strategy = new ReflectionStrategy;
        $object = new class extends Foo {};

        $this->assertTrue($strategy->supports($object, 'someProperty'));
    }

    public function testThrowWhenExtractingUnsuppportedProperty()
    {
        $o = new \stdClass;
        $s = new ReflectionStrategy;

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

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

    public function testExtract()
    {
        $o = new class {
            public $a = 24;
            private $b = 42;

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

            protected $c = 66;
        };
        $s = new ReflectionStrategy;

        $this->assertSame(24, $s->extract($o, 'a'));
        $this->assertSame(42, $s->extract($o, 'b'));
        $this->assertSame(66, $s->extract($o, 'c'));
    }

    public function testExtractInheritedProperty()
    {
        $child = new class extends Foo {};

        $strategy = new ReflectionStrategy;

        $this->assertSame(42, $strategy->extract($child, 'someProperty'));
    }

    public function testExtractDynamicallySetProperty()
    {
        $strategy = new ReflectionStrategy;
        $std = new \stdClass;
        $std->foo = 'bar';

        $this->assertSame('bar', $strategy->extract($std, 'foo'));
    }
}