monkey patch

Macaco Patch

Este pacote é um pacote independente do Monkey Patching do ci-phpunit-test.

Isso fornece quatro patchers de macacos.

• ExitPatcher : converte exit() em exceção
• FunctionPatcher : Funções de patches
• MethodPatcher : corrige métodos em classes definidas pelo usuário
• ConstantPatcher : altera valores constantes

Índice

• Requisitos
• Instalação
• Uso
  • Configurar
  • Converter exit() em exceção
  • Funções de patch
    • Alterar valor de retorno
    • Patch de outras funções
  • Métodos de patch em classes definidas pelo usuário
  • Constantes de correção
• Referência de classe
• Licença

Requisitos

• PHP 7.3 ou posterior

Instalação

$ composer require --dev kenjis/monkey-patch 

Uso

Nota: O número da linha quando ocorre um erro é provavelmente diferente do código-fonte real. Verifique o arquivo de cache da fonte que o Monkey Patching cria.

Nota: O uso deste pacote tem um impacto negativo na velocidade dos testes.

Configurar

• Para habilitar o monkey patching, adicione o conteúdo do bootstrap em seu arquivo de bootstrap do PHPUnit.
  • Defina os argumentos MonkeyPatchManager::init().
• Para verificar invocações, use MonkeyPatchTrait em sua classe TestCase.

Converter exit() em exceção

Este patcher converte instruções exit() ou die() em exceções instantaneamente.

Se você tiver um controlador como abaixo:

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

Um caso de teste poderia ser assim:

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

Funções de patch

Este patcher permite a substituição de funções globais que não podem ser ridicularizadas pelo PHPUnit.

Mas tem algumas limitações. Algumas funções não podem ser substituídas e podem causar erros.

Portanto, por padrão, podemos substituir apenas uma dúzia de funções predefinidas no FunctionPatcher.

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

MonkeyPatch::patchFunction() substitui a função nativa do PHP mt_rand() no método Welcome::index e retornará 100 no método de teste.

Nota: Se você chamar MonkeyPatch::patchFunction() sem o terceiro argumento, todas as funções (localizadas em include_paths e não em exclude_paths ) chamadas no método de teste serão substituídas. Assim, por exemplo, uma função no código da sua biblioteca pode ser substituída e resultar em um resultado inesperado.

Alterar valor de retorno

Você poderia alterar o valor de retorno da função corrigida usando o fechamento do 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
        );

Patch de outras funções

Se quiser corrigir outras funções, você pode adicioná-las a functions_to_patch em MonkeyPatchManager::init() .

Mas existem algumas limitações conhecidas:

• Funções corrigidas que possuem parâmetros chamados por referência não funcionam.
• Você poderá ver erros de visibilidade se passar retornos de chamada não públicos para funções corrigidas. Por exemplo, você passa [$this, 'method'] para array_map() e o método method() na classe não é público.

Métodos de patch em classes definidas pelo usuário

Este patcher permite a substituição de métodos em classes definidas pelo usuário.

    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() substitui o método get_category_list() em Category_model e retornará [(object) ['name' => 'Nothing']] no método de teste.

Constantes de correção

Este patcher permite a substituição de valores constantes.

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

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

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

MonkeyPatch::patchConstant() substitui o valor de retorno da constante ENVIRONMENT no método Welcome::index .

Existem algumas limitações conhecidas:

• Não é possível corrigir constantes usadas como valores padrão em argumentos de função.
• Não é possível corrigir constantes usadas como valores padrão em declarações de constantes.
• Não é possível corrigir constantes usadas como valores padrão em declarações de propriedades.
• Não é possível corrigir constantes usadas como valores padrão em declarações de variáveis ​​estáticas.

Referência de classe

Consulte a documentação do teste ci-phpunit.

Licença

Este pacote é licenciado usando a licença MIT.

Por favor, dê uma olhada em LICENSE .