monkey patch

Patch de singe

Ce package est un package autonome de Monkey Patching de ci-phpunit-test.

Cela fournit quatre patchers de singe.

• ExitPatcher : convertit exit() en exception
• FunctionPatcher : Fonctions des correctifs
• MethodPatcher : corrige les méthodes dans les classes définies par l'utilisateur
• ConstantPatcher : modifie les valeurs constantes

Table des matières

• Exigences
• Installation
• Usage
  • Configurer
  • Convertir exit() en exception
  • Fonctions des correctifs
    • Modifier la valeur de retour
    • Patcher d'autres fonctions
  • Méthodes de correctifs dans les classes définies par l'utilisateur
  • Constantes de correctif
• Référence de classe
• Licence

Exigences

• PHP 7.3 ou version ultérieure

Installation

$ composer require --dev kenjis/monkey-patch 

Usage

Remarque : le numéro de ligne lorsqu'une erreur se produit est probablement différent du code source réel. Veuillez vérifier le fichier cache de la source créée par Monkey Patching.

Remarque : L'utilisation de ce package a un impact négatif sur la vitesse des tests.

Configurer

• Pour activer le patch singe, ajoutez le contenu du bootstrap dans votre fichier de bootstrap PHPUnit.
  • Définissez les arguments MonkeyPatchManager::init().
• Pour vérifier les invocations, utilisez MonkeyPatchTrait dans votre classe TestCase.

Convertir exit() en exception

Ce correctif convertit les instructions exit() ou die() en exceptions à la volée.

Si vous avez un contrôleur comme ci-dessous :

    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 scénario de test pourrait ressembler à ceci :

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

Fonctions des correctifs

Ce patcher permet le remplacement des fonctions globales qui ne peuvent pas être simulées par PHPUnit.

Mais il présente quelques limites. Certaines fonctions ne peuvent pas être remplacées et cela peut provoquer des erreurs.

Ainsi, par défaut, nous ne pouvons remplacer qu'une douzaine de fonctions prédéfinies dans FunctionPatcher.

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

MonkeyPatch::patchFunction() remplace la fonction native PHP mt_rand() dans la méthode Welcome::index , et elle renverra 100 dans la méthode de test.

Remarque : Si vous appelez MonkeyPatch::patchFunction() sans 3ème argument, toutes les fonctions (situées dans include_paths et non dans exclude_paths ) appelées dans la méthode de test seront remplacées. Ainsi, par exemple, une fonction du code de votre bibliothèque peut être remplacée, ce qui entraîne un résultat inattendu.

Modifier la valeur de retour

Vous pouvez modifier la valeur de retour de la fonction corrigée en utilisant la fermeture 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
        );

Corriger d'autres fonctions

Si vous souhaitez patcher d'autres fonctions, vous pouvez les ajouter à function_to_patch dans MonkeyPatchManager::init() .

Mais il existe quelques limitations connues :

• Les fonctions corrigées qui ont des paramètres appelés par référence ne fonctionnent pas.
• Vous pouvez voir des erreurs de visibilité si vous transmettez des rappels non publics aux fonctions corrigées. Par exemple, vous transmettez [$this, 'method'] à array_map() et la méthode method() de la classe n'est pas publique.

Méthodes de correctifs dans les classes définies par l'utilisateur

Ce patcher permet le remplacement des méthodes dans les classes définies par l'utilisateur.

    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() remplace la méthode get_category_list() dans Category_model et renverra [(object) ['name' => 'Nothing']] dans la méthode de test.

Constantes de correctif

Ce patcher permet le remplacement d'une valeur constante.

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

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

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

MonkeyPatch::patchConstant() remplace la valeur de retour de la constante ENVIRONMENT dans la méthode Welcome::index .

Il existe quelques limitations connues :

• Impossible de corriger les constantes utilisées comme valeurs par défaut dans les arguments de fonction.
• Impossible de corriger les constantes utilisées comme valeurs par défaut dans les déclarations de constantes.
• Impossible de corriger les constantes utilisées comme valeurs par défaut dans les déclarations de propriétés.
• Impossible de corriger les constantes utilisées comme valeurs par défaut dans les déclarations de variables statiques.

Référence de classe

Voir la documentation ci-phpunit-test.

Licence

Ce package est sous licence utilisant la licence MIT.

Veuillez consulter LICENSE .