monkey patch

Parche de mono

Este paquete es un paquete independiente de Monkey Patching de ci-phpunit-test.

Esto proporciona cuatro parches de monos.

• ExitPatcher : convierte exit() en excepción
• FunctionPatcher : Funciones de parches
• MethodPatcher : parchea métodos en clases definidas por el usuario
• ConstantPatcher : cambia valores constantes

Tabla de contenido

• Requisitos
• Instalación
• Uso
  • Configurar
  • Convertir exit() a excepción
  • Funciones de parche
    • Cambiar valor de retorno
    • Parchear otras funciones
  • Métodos de parche en clases definidas por el usuario
  • Constantes de parche
• Referencia de clase
• Licencia

Requisitos

• PHP 7.3 o posterior

Instalación

$ composer require --dev kenjis/monkey-patch 

Uso

Nota: El número de línea cuando se produce un error probablemente sea diferente del código fuente real. Verifique el archivo de caché de la fuente que crea Monkey Patching.

Nota: El uso de este paquete tiene un impacto negativo en la velocidad de las pruebas.

Configurar

• Para habilitar el parche de mono, agregue el contenido del programa de arranque en su archivo de arranque de PHPUnit.
  • Establezca los argumentos de MonkeyPatchManager::init().
• Para verificar las invocaciones, use MonkeyPatchTrait en su clase TestCase.

Convertir exit() a excepción

Este parche convierte declaraciones exit() o die() en excepciones sobre la marcha.

Si tiene un controlador como el siguiente:

    public function index ()
    {
        $ this -> output
            -> set_status_header ( 200 )
            -> set_content_type ( ' application/json ' , ' utf-8 ' )
            -> set_output ( json_encode ([ ' foo ' => ' bar ' ]))
            -> _display ();
        exit ();
    }

Un caso de prueba podría ser así:

    public function test_index ()
    {
        try {
            $ this -> request ( ' GET ' , ' welcome/index ' );
        } catch ( ExitException $ e ) {
            $ output = ob_get_clean ();
        }
        
        $ this -> assertContains ( ' {"foo":"bar"} ' , $ output );
    }

Funciones de parche

Este parche permite el reemplazo de funciones globales de las que PHPUnit no puede burlarse.

Pero tiene algunas limitaciones. Algunas funciones no se pueden reemplazar y pueden causar errores.

Entonces, de forma predeterminada, solo podemos reemplazar una docena de funciones predefinidas en FunctionPatcher.

    public function test_index ()
    {
        MonkeyPatch:: patchFunction ( ' mt_rand ' , 100 , ' Welcome::index ' );
        
        $ output = $ this -> request ( ' GET ' , ' welcome/index ' );
        
        $ this -> assertContains ( ' 100 ' , $ output );
    }

MonkeyPatch::patchFunction() reemplaza la función nativa de PHP mt_rand() en el método Welcome::index y devolverá 100 en el método de prueba.

Nota: Si llama a MonkeyPatch::patchFunction() sin el tercer argumento, todas las funciones (ubicadas en include_paths y no en exclude_paths ) llamadas en el método de prueba serán reemplazadas. Entonces, por ejemplo, es posible que se reemplace una función en el código de su biblioteca y se produzca un resultado inesperado.

Cambiar valor de retorno

Puede cambiar el valor de retorno de la función parcheada usando el cierre de PHP:

        MonkeyPatch:: patchFunction (
            ' function_exists ' ,
            function ( $ function ) {
                if ( $ function === ' random_bytes ' ) {
                    return true ;
                } elseif ( $ function === ' openssl_random_pseudo_bytes ' ) {
                    return false ;
                } elseif ( $ function === ' mcrypt_create_iv ' ) {
                    return false ;
                } else {
                    return __GO_TO_ORIG__ ;
                }
            },
            Welcome::class
        );

Parchear otras funciones

Si desea parchear otras funciones, puede agregarlas a funciones_to_patch en MonkeyPatchManager::init() .

Pero existen algunas limitaciones conocidas:

• Las funciones parcheadas que tienen parámetros llamados por referencia no funcionan.
• Es posible que vea errores de visibilidad si pasa devoluciones de llamadas no públicas a funciones parcheadas. Por ejemplo, pasas [$this, 'method'] a array_map() y el método method() en la clase no es público.

Métodos de parche en clases definidas por el usuario

Este parche permite el reemplazo de métodos en clases definidas por el usuario.

    public function test_index ()
    {
        MonkeyPatch:: patchMethod (
            Category_model::class,
            [ ' get_category_list ' => [( object ) [ ' name ' => ' Nothing ' ]]]
        );
        
        $ output = $ this -> request ( ' GET ' , ' welcome/index ' );
        
        $ this -> assertContains ( ' Nothing ' , $ output );
    }

MonkeyPatch::patchMethod() reemplaza el método get_category_list() en Category_model y devolverá [(object) ['name' => 'Nothing']] en el método de prueba.

Constantes de parche

Este parche permite el reemplazo de valor constante.

    public function test_index ()
    {
        MonkeyPatch:: patchConstant (
            ' ENVIRONMENT ' , 
            ' development ' , 
            Welcome::class . ' ::index '
        );

        $ output = $ this -> request ( ' GET ' , ' welcome/index ' );

        $ this -> assertContains ( ' development ' , $ output );
    }

MonkeyPatch::patchConstant() reemplaza el valor de retorno de la constante ENVIRONMENT en el método Welcome::index .

Existen algunas limitaciones conocidas:

• No se pueden parchear constantes que se utilizan como valores predeterminados en los argumentos de la función.
• No se pueden parchear constantes que se utilizan como valores predeterminados en declaraciones de constantes.
• No se pueden parchear constantes que se utilizan como valores predeterminados en las declaraciones de propiedades.
• No se pueden parchear constantes que se utilizan como valores predeterminados en declaraciones de variables estáticas.

Referencia de clase

Consulte los documentos de ci-phpunit-test.

Licencia

Este paquete tiene la licencia MIT.

Por favor, eche un vistazo a LICENSE .