ProxyManagerTest\Functional\NullObjectFunctionalTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	testMethodCalls()	0	6	1
A	testMethodCallsAfterUnSerialization()	0	7	1
A	testMethodCallsAfterCloning()	0	6	1
A	testPropertyReadAccess()	0	4	1
A	testPropertyWriteAccess()	0	7	1
A	testPropertyExistence()	0	4	1
A	testPropertyUnset()	0	6	1
B	getProxyMethods()	0	62	1
A	getPropertyAccessProxies()	0	19	1
A	assertNullMethodCall()	0	10	1

<?php

declare(strict_types=1);

namespace ProxyManagerTest\Functional;

use PHPUnit\Framework\TestCase;
use ProxyManager\Factory\NullObjectFactory;
use ProxyManager\Proxy\NullObjectInterface;
use ProxyManagerTestAsset\BaseClass;
use ProxyManagerTestAsset\BaseInterface;
use ProxyManagerTestAsset\ClassWithMethodWithByRefVariadicFunction;
use ProxyManagerTestAsset\ClassWithMethodWithVariadicFunction;
use ProxyManagerTestAsset\ClassWithParentHint;
use ProxyManagerTestAsset\ClassWithSelfHint;
use ProxyManagerTestAsset\EmptyClass;
use ProxyManagerTestAsset\VoidCounter;
use stdClass;
use function array_values;
use function random_int;
use function serialize;
use function uniqid;
use function unserialize;

/**
 * Tests for {@see \ProxyManager\ProxyGenerator\NullObjectGenerator} produced objects
 *
 * @group Functional
 * @coversNothing
 */
final class NullObjectFunctionalTest extends TestCase
{
    /**
     * @param mixed[] $params
     *
     * @dataProvider getProxyMethods
     *
     * @psalm-param class-string $className
     */
    public function testMethodCalls(string $className, string $method, array $params) : void
    {
        $proxy = (new NullObjectFactory())->createProxy($className);

        $this->assertNullMethodCall($proxy, $method, $params);
    }

    /**
     * @param mixed[] $params
     *
     * @dataProvider getProxyMethods
     *
     * @psalm-param class-string $className
     */
    public function testMethodCallsAfterUnSerialization(string $className, string $method, array $params) : void
    {
        /** @var NullObjectInterface $proxy */
        $proxy = unserialize(serialize((new NullObjectFactory())->createProxy($className)));

        $this->assertNullMethodCall($proxy, $method, $params);
    }

    /**
     * @param mixed[] $params
     *
     * @dataProvider getProxyMethods
     *
     * @psalm-param class-string $className
     */
    public function testMethodCallsAfterCloning(string $className, string $method, array $params) : void
    {
        $proxy = (new NullObjectFactory())->createProxy($className);

        $this->assertNullMethodCall(clone $proxy, $method, $params);
    }

    /**
     * @dataProvider getPropertyAccessProxies
     */
    public function testPropertyReadAccess(NullObjectInterface $proxy, string $publicProperty) : void
    {
        self::assertNull($proxy->$publicProperty);

The method assertNull() does not exist on ProxyManagerTest\Functional\NullObjectFunctionalTest. Did you maybe mean assertNullMethodCall()?

    }

    /**
     * @dataProvider getPropertyAccessProxies
     */
    public function testPropertyWriteAccess(NullObjectInterface $proxy, string $publicProperty) : void
    {
        $newValue               = uniqid('', true);
        $proxy->$publicProperty = $newValue;

        self::assertSame($newValue, $proxy->$publicProperty);

The method assertSame() does not seem to exist on object<ProxyManagerTest\Functional\NullObjectFunctionalTest>.

    }

    /**
     * @dataProvider getPropertyAccessProxies
     */
    public function testPropertyExistence(NullObjectInterface $proxy, string $publicProperty) : void
    {
        self::assertNull($proxy->$publicProperty);

The method assertNull() does not exist on ProxyManagerTest\Functional\NullObjectFunctionalTest. Did you maybe mean assertNullMethodCall()?

    }

    /**
     * @dataProvider getPropertyAccessProxies
     */
    public function testPropertyUnset(NullObjectInterface $proxy, string $publicProperty) : void
    {
        unset($proxy->$publicProperty);

        self::assertFalse(isset($proxy->$publicProperty));

The method assertFalse() does not seem to exist on object<ProxyManagerTest\Functional\NullObjectFunctionalTest>.

    }

    /**
     * Generates a list of object | invoked method | parameters | expected result
     *
     * @return string[][]|null[][]|mixed[][][]|object[][]
     */
    public function getProxyMethods() : array
    {
        $selfHintParam = new ClassWithSelfHint();
        $empty         = new EmptyClass();

        return [
            [
                BaseClass::class,
                'publicMethod',
                [],
                'publicMethodDefault',
            ],
            [
                BaseClass::class,
                'publicTypeHintedMethod',
                ['param' => new stdClass()],
                'publicTypeHintedMethodDefault',
            ],
            [
                BaseClass::class,
                'publicByReferenceMethod',
                [],
                'publicByReferenceMethodDefault',
            ],
            [
                BaseInterface::class,
                'publicMethod',
                [],
                'publicMethodDefault',
            ],
            [
                ClassWithSelfHint::class,
                'selfHintMethod',
                ['parameter' => $selfHintParam],
                $selfHintParam,
            ],
            [
                ClassWithParentHint::class,
                'parentHintMethod',
                ['parameter' => $empty],
                $empty,
            ],
            [
                ClassWithMethodWithVariadicFunction::class,
                'buz',
                ['Ocramius', 'Malukenho'],
                null,
            ],
            [
                ClassWithMethodWithByRefVariadicFunction::class,
                'tuz',
                ['Ocramius', 'Malukenho'],
                null,
            ],
            [
                VoidCounter::class,
                'increment',
                [random_int(10, 1000)],
                null,
            ],
        ];
    }

    /**
     * Generates proxies and instances with a public property to feed to the property accessor methods
     *
     * @return array<int, array<int, NullObjectInterface|string>>

The doc-type array<int, could not be parsed: Expected ">" at position 5, but found "end of type". (view supported doc-types)

     */
    public function getPropertyAccessProxies() : array
    {
        $factory = new NullObjectFactory();
        /** @var NullObjectInterface $serialized */
        $serialized = unserialize(serialize($factory->createProxy(BaseClass::class)));

        return [
            [
                $factory->createProxy(BaseClass::class),
                'publicProperty',
                'publicPropertyDefault',
            ],
            [
                $serialized,
                'publicProperty',
                'publicPropertyDefault',
            ],
        ];
    }

    /**
     * @param mixed[] $parameters
     */
    private function assertNullMethodCall(NullObjectInterface $proxy, string $methodName, array $parameters) : void
    {
        $method = [$proxy, $methodName];

        self::assertIsCallable($method);

The method assertIsCallable() does not seem to exist on object<ProxyManagerTest\Functional\NullObjectFunctionalTest>.

        $parameterValues = array_values($parameters);

        self::assertNull($method(...$parameterValues));

The method assertNull() does not exist on ProxyManagerTest\Functional\NullObjectFunctionalTest. Did you maybe mean assertNullMethodCall()?

    }
}