Clase final de simulación de PHP

Estoy intentando burlarme de un php final class pero como se declara final Sigo recibiendo este error:

PHPUnit_Framework_Exception: Class "Doctrine\ORM\Query" is declared "final" and cannot be mocked.

Hay alguna forma de evitar esto final comportamiento solo para mis pruebas unitarias sin introducir nuevos marcos?

Como mencionó que no desea utilizar ningún otro marco, solo se deja una opción: uopz

uopz es una extensión de magia negra del género runkit-and-scary-stuff, destinado a ayudar con la infraestructura de control de calidad.

uopz_flags es una función que puede modificar las banderas de funciones, métodos y clases.

<?php
final class Test {}

/** ZEND_ACC_CLASS is defined as 0, just looks nicer ... **/

uopz_flags(Test::class, null, ZEND_ACC_CLASS);

$reflector = new ReflectionClass(Test::class);

var_dump($reflector->isFinal());
?>

Rendirá

bool(false)

Respuesta tardía para alguien que está buscando esta respuesta simulada de consulta de doctrina específica.

No puede burlarse de Doctrine\ORM\Query debido a su declaración “final”, pero si observa el código de la clase Query, verá que es una extensión de la clase AbstractQuery y no debería haber ningún problema para burlarse de ella.

/** @var \PHPUnit_Framework_MockObject_MockObject|AbstractQuery $queryMock */
$queryMock = $this
    ->getMockBuilder('Doctrine\ORM\AbstractQuery')
    ->disableOriginalConstructor()
    ->setMethods(['getResult'])
    ->getMockForAbstractClass();

Te sugiero que eches un vistazo a la marco de prueba de burla que tienen una solución para esta situación descrita en la página: Manejo de clases/métodos finales:

Puede crear un simulacro de proxy pasando el objeto instanciado que desea simular a \Mockery::mock(), es decir, Mockery luego generará un Proxy para el objeto real e interceptará selectivamente las llamadas a métodos con el fin de establecer y cumplir las expectativas.

Como ejemplo, esto permite hacer algo como esto:

class MockFinalClassTest extends \PHPUnit_Framework_TestCase {

    public function testMock()
    {
        $em = \Mockery::mock("Doctrine\ORM\EntityManager");

        $query = new Doctrine\ORM\Query($em);
        $proxy = \Mockery::mock($query);
        $this->assertNotNull($proxy);

        $proxy->setMaxResults(4);
        $this->assertEquals(4, $query->getMaxResults());
    }

no se que tienes que hacer pero espero que te sirva

hay una pequeña biblioteca Omitir finales precisamente para tal fin. Descrito en detalle por entrada en el blog.

Lo único que tiene que hacer es habilitar esta utilidad antes de que se carguen las clases:

DG\BypassFinals::enable();

Cuando quieras simular una clase final, es un momento perfecto para hacer uso de Principio de inversión de dependencia:

Uno debería depender de abstracciones, no de concreciones.

Para la burla significa: Crear una abstracción (interfaz o clase abstracta) y asignarla a la clase final, y burlarse de la abstracción.

Respuesta de 2019 para PHPUnit

Veo que estás usando PHPUnit. Puede usar los finales de omisión de esta respuesta.

La configuración es un poco más que bootstrap.php. Leer “por qué” en Cómo simular clases finales en PHPUnit.

Aquí está “cómo” ↓

2 pasos

Necesita usar Hook con llamada de derivación:

<?php declare(strict_types=1);

use DG\BypassFinals;
use PHPUnit\Runner\BeforeTestHook;

final class BypassFinalHook implements BeforeTestHook
{
    public function executeBeforeTest(string $test): void
    {
        BypassFinals::enable();
    }
}

Actualizar phpunit.xml:

<phpunit bootstrap="vendor/autoload.php">
    <extensions>
        <extension class="Hook\BypassFinalHook"/>
    </extensions>
</phpunit>

Entonces tú puede burlarse de cualquier clase final:

Manera graciosa 🙂

PHP7.1, PHPUnit5.7

<?php
use Doctrine\ORM\Query;

//...

$originalQuery      = new Query($em);
$allOriginalMethods = get_class_methods($originalQuery);

// some "unmockable" methods will be skipped
$skipMethods = [
    '__construct',
    'staticProxyConstructor',
    '__get',
    '__set',
    '__isset',
    '__unset',
    '__clone',
    '__sleep',
    '__wakeup',
    'setProxyInitializer',
    'getProxyInitializer',
    'initializeProxy',
    'isProxyInitialized',
    'getWrappedValueHolderValue',
    'create',
];

// list of all methods of Query object
$originalMethods = [];
foreach ($allOriginalMethods as $method) {
    if (!in_array($method, $skipMethods)) {
        $originalMethods[] = $method;
    }
}

// Very dummy mock
$queryMock = $this
    ->getMockBuilder(\stdClass::class)
    ->setMethods($originalMethods)
    ->getMock()
;

foreach ($originalMethods as $method) {

    // skip "unmockable"
    if (in_array($method, $skipMethods)) {
        continue;
    }

    // mock methods you need to be mocked
    if ('getResult' == $method) {
        $queryMock->expects($this->any())
            ->method($method)
            ->will($this->returnCallback(
                function (...$args) {
                    return [];
                }
            )
        );
        continue;
    }

    // make proxy call to rest of the methods
    $queryMock->expects($this->any())
        ->method($method)
        ->will($this->returnCallback(
            function (...$args) use ($originalQuery, $method, $queryMock) {
                $ret = call_user_func_array([$originalQuery, $method], $args);

                // mocking "return $this;" from inside $originalQuery
                if (is_object($ret) && get_class($ret) == get_class($originalQuery)) {
                    if (spl_object_hash($originalQuery) == spl_object_hash($ret)) {
                        return $queryMock;
                    }

                    throw new \Exception(
                        sprintf(
                            'Object [%s] of class [%s] returned clone of itself from method [%s]. Not supported.',
                            spl_object_hash($originalQuery),
                            get_class($originalQuery),
                            $method
                        )
                    );
                }

                return $ret;
            }
        ))
    ;
}


return $queryMock;