PHP Master | Test des conditions d'erreur avec phpunit

Points de base

• PHPUNIT convertit la gestion des erreurs natives PHP en exceptions, ce qui peut modifier le flux d'exécution du code pendant les tests. Cela peut causer des problèmes lors du test du code en utilisant les fonctions trigger_error().
• Le phpunit convertit les erreurs à des exceptions, ce qui fait que le code se comporte différemment dans le développement et les tests que dans les environnements de production. En effet, le processus d'exécution change lorsqu'une erreur est rencontrée.
• pour tester avec précision le code à l'aide de trigger_error(), vous pouvez utiliser un gestionnaire d'erreurs personnalisé pour capturer les informations d'erreur pour une analyse ultérieure à l'aide de l'affirmation. Cela permet au code de continuer l'exécution tout en permettant à la vérification de la condition d'erreur soulevée.
• Le comportement par défaut de l'unité est essentiel pour des tests précis. En cas de logique post-déclenchement, la fonctionnalité de la fonctionnalité de Phpunit peut faciliter les tests précis que possible aussi près de l'environnement de production.

Supposons que vous conservez le code qui enregistre les messages d'erreur à l'aide de fonctions PHP Native trigger_error(). En attendant, vous écrivez des tests unitaires pour ce code à l'aide de phpunit. Si vous vous référez au manuel PHPUNIT, il existe une section dédiée à la façon de tester les conditions d'erreur. Il décrit comment PHPUnit implémente son propre gestionnaire d'erreurs qui convertit les erreurs, les avertissements et les notifications en exceptions, et la capture de ces exceptions est de savoir comment vous devriez gérer ces tests d'erreur. Cependant, en fonction de l'apparence de votre code, vous pouvez avoir des problèmes avec cette approche avec PHPUNIT. Cet article expliquera en détail ce qu'est ce problème, comment il affecte votre capacité à tester votre code et comment le résoudre.

Quel est le problème?

Les erreurs et les exceptions se comportent d'une manière fondamentalement différente. En particulier, lié à cet article, si la constante de niveau d'erreur qui lui est transmise n'indique pas une erreur fatale, l'exécution du code peut se poursuivre immédiatement après trigger_error(). Lorsqu'une exception est lancée, l'exécution se poursuivra au début du bloc catch correspondant à cette classe d'exception, qui peut se produire immédiatement après le point où l'exception est lancée. Regardons quelques exemples de ces comportements. Tout d'abord, c'est une erreur.

<?php
error_reporting(E_ALL | E_STRICT);
echo "Before warning\n";
trigger_error("Danger Will Robinson!", E_USER_WARNING);
echo "After warning\n";
?>

Si vous exécutez le code ci-dessus, vous obtiendrez la sortie suivante:

<code>Before warning
PHP Warning:  Danger Will Robinson! in /home/matt/error_handler.php on line 4
After warning</code>

À partir de cela, nous pouvons voir que l'instruction trigger_error() après l'exécution de la echo est exécutée. Maintenant, exception.

<?php
try {
    echo "Before exception\n";
    throw new Exception("Danger Will Robinson!");
    echo "After exception\n";
}
catch (Exception $e) {
    echo "In catch block\n";
}
?>

Sortie:

<code>Before exception
In catch block</code>

Contrairement à l'exemple d'erreur, le code après l'exception n'est pas exécuté. Étant donné que PHPUnit convertit une erreur en une exception, l'erreur se comporte de la même manière que l'exception des tests unitaires. Pendant les tests, tout code exécuté après une erreur déclenchée ne sera pas exécuté. Donnez un autre exemple:

<?php
function foo($param) {
    if (is_string($param)) {
        trigger_error(__FUNCTION__ . " no longer supports strings, pass an array", E_USER_NOTICE);
    }
    // do useful stuff with $param
    ...
}
?>

Avec la conversion d'erreur à exception, il est impossible de tester si $param est géré utilement parce que lorsque l'erreur est convertie en une exception, le code ne sera jamais exécuté.

Effets secondaires du comportement des phpunit

Cette conversion d'erreur à exception entraînera le comportement du code différemment dans le développement et les tests que dans les environnements de production. Voici un exemple:

<?php
error_reporting(E_ALL | E_STRICT);
echo "Before warning\n";
trigger_error("Danger Will Robinson!", E_USER_WARNING);
echo "After warning\n";
?>

Sortie:

<code>Before warning
PHP Warning:  Danger Will Robinson! in /home/matt/error_handler.php on line 4
After warning</code>

Le premier appel var_dump() (pendant ce temps, un gestionnaire d'erreurs personnalisé qui convertit l'erreur en une exception est en train de prendre effet) sort null. Le deuxième var_dump() appel (pendant lequel le gestionnaire d'erreur par défaut de PHP prend effet) diffuse des informations sur l'erreur déclenchée. Notez que ce n'est pas dû au fait que la première sortie d'appel var_dump() NULL est causée par l'utilisation d'un gestionnaire d'erreur personnalisé, mais parce que le gestionnaire d'erreurs lance une exception. Si le gestionnaire d'erreur indiqué dans cet exemple ne le fait pas, la sortie du premier appel var_dump() sera la même que la seconde.

Solution

Nous avons besoin d'une solution qui permet de continuer à exécuter le code testé tout en nous permettant de vérifier si une condition d'erreur a été augmentée. Comme indiqué dans l'exemple ci-dessus, permettre à l'exécution de code de continuer peut être effectué à l'aide d'un gestionnaire d'erreur personnalisé qui ne convertit pas les erreurs en exceptions. Ce que ce gestionnaire d'erreurs doit faire, c'est capturer le message d'erreur afin qu'il puisse être analysé ultérieurement à l'aide d'assutions. Voici à quoi ça ressemble:

<?php
try {
    echo "Before exception\n";
    throw new Exception("Danger Will Robinson!");
    echo "After exception\n";
}
catch (Exception $e) {
    echo "In catch block\n";
}
?>

setUp() (Exécutez avant chaque méthode de test) Gire la configuration d'un gestionnaire d'erreurs, qui n'est qu'une autre méthode de la même classe qui stocke des informations sur chaque erreur dans un tableau. D'autres méthodes (telles que assertError()) sont ensuite utilisées par les méthodes de test (telles que testDoStuff()) pour effectuer des affirmations sur ce message d'erreur et les informations de débogage pertinentes de sortie, telles que ce qui est l'erreur déclenchée par rapport à l'erreur attendue. D'autres types d'assertions utiles incluent l'inversion logique (c'est-à-dire que les affirmations ne déclenchent pas une erreur spécifique), les erreurs qui vérifient les messages correspondent à une expression régulière ou un nombre d'erreurs déclenchées.

Conclusion

Si vous ne vous souciez pas si la logique derrière le test déclenchant une erreur est toujours en train de s'exécuter, le comportement par défaut du phpunit convient parfaitement à vos besoins. Cependant, il est important que vous compreniez ce que signifie le comportement. Si vous vous souciez de l'exécution d'une telle logique, il est également important que vous sachiez comment compléter les capacités de Phpunit afin de faciliter les tests précis de votre code aussi près que possible de l'environnement de production.

Images de Fotolia

(Ce qui suit est la FAQ, le format et l'expression ont été ajustés en fonction du contenu d'origine, et certains problèmes ont été fusionnés ou simplifiés)

FAQ (FAQ) sur l'utilisation de phpunit pour tester les conditions d'erreur

Q1: Pourquoi phpunit ne montre-t-il aucune erreur dans la console?

phpunit est conçu de manière à permettre un test efficace des erreurs et des exceptions. Si vous ne voyez aucune erreur dans la console, PHPUnit peut les capturer et les traiter comme des tests ratés. Pour afficher les détails de ces erreurs, vous pouvez utiliser l'option --debug lors de l'exécution du test. Cela fournira une sortie plus détaillée, y compris toutes les erreurs ou exceptions capturées lors des tests.

Q2: Comment affirmer qu'une exception a été lancée en phpunit?

PHPUnit fournit un ensemble d'affirmes spécifiquement utilisées pour gérer les exceptions. Le plus souvent utilisé est expectException(), que vous pouvez utiliser pour spécifier le type d'exception que vous attendez. Si l'exception spécifiée est lancée pendant le test, le test passera. Sinon, le test échouera. Cela vous permet d'écrire des tests qui vérifient spécifiquement la gestion correcte des conditions d'erreur.

Q3: Comment le rapport d'erreur fonctionne-t-il en PHP?

La fonction de rapport d'erreur de PHP vous permet de contrôler les erreurs signalées et comment les traiter. Par défaut, toutes les erreurs sont signalées et affichées. Cependant, vous pouvez modifier ces paramètres à l'aide de la fonction error_reporting() et de la directive display_errors INI. Cela vous permet de masquer certains types d'erreurs ou des erreurs de journal au lieu de les afficher.

Q4: Comment tester les exceptions dans PHPUNIT?

Identique au Q2.

Q5: Comment rédiger des tests pour phpunit?

Les tests d'écriture pour PHPUnit impliquent la création d'une nouvelle classe de cas de test qui étend la classe PHPUnitFrameworkTestCase. Chaque test est une méthode publique dans cette classe, en commençant par le mot "test". Dans chaque méthode de test, vous pouvez utiliser l'affirmation de Phpunit pour vérifier si votre code est en cours d'exécution comme prévu. Par exemple, vous pouvez utiliser la méthode assertEquals() pour vérifier si la fonction renvoie le résultat attendu.

Q6: Comment gérer les erreurs en phpunit?

PHPUnit fournit un ensemble d'affirmes spécifiquement utilisées pour gérer les erreurs. Le plus couramment utilisé est expectError(), que vous pouvez utiliser pour spécifier le type d'erreur que vous prévoyez de déclencher. Si l'erreur spécifiée est déclenchée pendant le test, le test passe. Sinon, le test échouera. Cela vous permet d'écrire des tests qui vérifient spécifiquement la gestion correcte des conditions d'erreur.

Q7: Comment déboguer les tests dans PHPUNIT?

PHPUnit offre plusieurs options pour les tests de débogage. L'option --debug fournit une sortie plus détaillée, y compris toutes les erreurs ou exceptions capturées lors des tests. Les options --stop-on-error, --stop-on-failure et --stop-on-risky peuvent être utilisées pour arrêter le test en cours d'exécution lorsqu'une erreur d'un type est rencontrée. Cela peut faciliter l'identification et la résolution des problèmes.

Q8: Comment tester les conditions d'erreur dans PHPUNIT?

phpunit fournit plusieurs façons de tester les conditions d'erreur. La méthode expectError() vous permet de spécifier le type d'erreur que vous prévoyez de déclencher. La méthode expectWarning() vous permet de spécifier le type d'avertissement que vous prévoyez de déclencher. Si l'erreur ou l'avertissement spécifié est déclenché pendant le test, le test passera. Sinon, le test échouera.

Q9: Comment gérer les avertissements en phpunit?

phpunit fournit un ensemble d'affirmes spécifiquement utilisées pour gérer les avertissements. Le plus couramment utilisé est expectWarning(), que vous pouvez utiliser pour spécifier le type d'avertissement que vous prévoyez de déclencher. Si l'avertissement spécifié est déclenché pendant le test, le test passe. Sinon, le test échouera. Cela vous permet d'écrire des tests qui vérifient spécifiquement le traitement correct des conditions d'avertissement.

Q10: Comment utiliser les fournisseurs de données dans PHPUNIT?

Le fournisseur de données est une caractéristique puissante de PHPUnit qui vous permet d'exécuter des tests plusieurs fois avec différents ensembles de données. Pour utiliser le fournisseur de données, vous pouvez créer une méthode qui renvoie un tableau de tableaux. Chaque tableau interne est un ensemble de paramètres pour le test. Vous commentez ensuite votre méthode de test à l'aide de @dataProvider suivie du nom de votre méthode de fournisseur de données. PHPUnit exécutera ensuite le test une fois pour chaque ensemble de paramètres et passera les paramètres à la méthode de test.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!