Tester vos tests? Qui regarde les gardiens?

Que vous travailliez pour une grande entreprise, une startup ou vous-même, les tests unitaires sont non seulement utiles, mais sont souvent indispensables. Nous utilisons des tests unitaires pour tester le code, mais que se passe-t-il si nos tests sont mauvais ou incomplets? Que pouvons-nous utiliser pour tester nos tests? Qui supervisera l'inspecteur?

Points clés

• Le test de variation est une technique qui évalue sa qualité avec un petit nombre de tests modifiés et peut être utilisé pour tester le test lui-même. Il s'agit de créer une "variante" ou une variante du test d'origine et de vérifier si ces modifications sont détectées par le test.
• Humbug est un cadre de test variant pour PHP qui peut être utilisé pour générer une couverture de code. Cependant, il est spécifique au phpunit et peut être problématique pour les utilisateurs utilisant différents cadres de test.
• Bien que les tests de variantes soient précieux, il a également ses inconvénients, principalement reflétés dans les performances. Il s'agit d'un processus lent car il repose sur de nombreux facteurs tels que l'interaction entre les lignes de code, le nombre de tests, le niveau de couverture du code et les performances du code et des tests.
• À mesure que la complexité de l'application augmente, l'importance de maintenir une couverture de code à 100% augmente. Des outils comme Humbug sont essentiels pour maintenir une telle couverture, en particulier dans l'écosystème d'entreprise.

Test de mutation

Non, ce n'est pas ce genre de mutation. Le test de variation (ou analyse de variation ) est une technique utilisée pour créer et évaluer la qualité des tests logiciels. Cela implique de modifier le test d'une manière très faible. Chaque version modifiée est appelée variante, et le test détecte et rejette les variantes en faisant se comporter la version originale différemment de la variante. Les mutations sont des erreurs dans le code d'origine et l'analyse vérifie si nos tests détectent ces erreurs. En bref, si le test est toujours valable après la mutation, ce n'est pas un bon test.

Test de mutation en utilisant Humbug

Humbug est un cadre de test variant pour PHP. Pour que Humbug génère une couverture de code, nous devons installer et activer XDebug sur notre machine. Nous pouvons ensuite l'installer en tant qu'outil global.

<code class="language-bash">composer global require 'humbug/humbug'</code>

Après

, si nous exécutons

<code class="language-bash">humbug</code>

La commande

devrait être en mesure de voir des informations d'installation de Humbug et une erreur indiquant que nous n'avons pas de fichier humbug.json.

Programme de démarrage

Avant de configurer et d'utiliser Humbug, nous avons besoin d'un projet qui peut être testé. Nous créerons un petit package de calculatrice PHP où nous exécutons nos tests unitaires et nos tests de mutation. Créons un dossier A / calculatrice. Dans ce document, créons nos dossiers / src et / tests. Dans notre dossier / src, nous aurons notre code d'application; Le dossier / tests contiendra nos tests unitaires. Nous devons également utiliser PHPUnit dans notre package. La meilleure façon est d'utiliser le compositeur. Installons PHPUnit en utilisant la commande suivante:

<code class="language-bash">composer global require 'humbug/humbug'</code>

Créons notre calculatrice. Dans le dossier / src, créez un fichier calculateur.php et ajoutez ce qui suit:

<code class="language-bash">humbug</code>

Il s'agit d'un programme assez simple. Une calculatrice simple avec des opérations et fonctions de base arithmétique, pourcentage et logarithmique qui renvoient les valeurs π. Ensuite, dans notre dossier / tests, créons des tests unitaires pour notre calculatrice. Si vous avez besoin d'aide pour les tests unitaires en PHP, consultez ce tutoriel. Créez un fichier calculatortest.php et ajoutez ce qui suit:

<code class="language-bash">composer global require phpunit/phpunit</code>

Ce sera notre pile de test initiale. Si nous exécutons la commande phpunit, nous le verrons exécuter avec succès et nos 4 tests et 4 assertions passeront. Il est important que tous les tests soient passés, sinon Humbug échouera.

Configuration Humbug

Humbug peut être configuré manuellement en créant un fichier humbug.json.dist, ou automatiquement en exécutant la commande suivante:

<code class="language-php"><?php
namespace package\Calculator;

class Calculator {

    /**
     * 基本运算
     */
    public function add($a1, $a2) {
        return $a1 + $a2;
    }

    public function subtract($a1, $a2) {
        return $a1 - $a2;
    }

    public function multiply($a1, $a2) {
        return $a1 * $a2;
    }

    public function divide($a1, $a2) {

        if ($a2 === 0) {
            return false;
        }

        return $a1 / $a2;
    }

    /*
     * 百分比
     */

    // 这将返回 a1 的 a2 百分比
    public function percentage($a1, $a2) {
        return ( $a1 / $a2 ) * 100;
    }

    /*
     * π
     */

    // 返回 π 的值
    public function pi() {
        return pi();
    }

    /*
     * 对数
     */

    // 返回以 10 为底的基本对数
    public function log($a) {
        return log10($a);
    }

}</code>

L'exécution de cette commande nous demandera de répondre à certaines questions:

• Quels répertoires source souhaitez-vous inclure? Ici, nous utiliserons SRC /, qui est notre répertoire de code source.
• Quels répertoires souhaitez-vous exclure du répertoire source? peut être utile dans certains cas, comme le répertoire du fournisseur externe que nous ne voulons pas tester. Il ne s'applique pas à notre situation actuelle.
• Timeout de suite de tests unique (secondes). Utilisons ceci pendant 30 secondes. C'est peut-être trop, mais nous voulons nous assurer que tout a assez de temps pour courir.
• Où souhaitez-vous stocker le journal de texte? Humblog.txt Comme valeur par défaut, nous le garderons.
• Où souhaitez-vous stocker les journaux JSON (si nécessaire)? La valeur par défaut est vide, mais nous le stockons dans humblogjson.json.
• Générer "humblog.json.dist"? Une fois ce fichier généré, il contiendra toutes les valeurs de configuration que nous venons de fournir. Si nous voulons changer quelque chose, nous pouvons le modifier manuellement.

Utilisez Humbug

Maintenant que nous avons exécuté l'application et l'avons testée, et nous avons installé Humbug, faisons courir Humbug et vérifions les résultats.

<code class="language-php"><?php
use package\Calculator\Calculator;

class CalculatorTest extends PHPUnit_Framework_TestCase {

    public function testAdd() {
        $calculator = new Calculator();
        $result = $calculator->add(2, 3);
        $this->assertEquals($result, 5);
    }

    public function testSubtract() {
        $calculator = new Calculator();
        $result = $calculator->subtract(6, 3);
        $this->assertEquals($result, 3);
    }

    public function testMultiply() {
        $calculator = new Calculator();
        $result = $calculator->multiply(6, 3);
        $this->assertEquals($result, 18);
    }

    public function testDivide() {
        $calculator = new Calculator();
        $result = $calculator->divide(6, 3);
        $this->assertEquals($result, 2);
    }

}</code>

Le résultat doit être proche de ceci:

Interprétation des résultats de l'humbug

Le nombre de mutations créées n'est que le nombre de petits changements introduits par Humbug pour tester nos tests. La mutation tuée (.) Est la mutation qui fait échouer le test. Ne soyez pas confus, c'est un résultat positif! La mutation d'échappement (M) est la mutation qui passe toujours le test. Ce n'est pas un résultat positif, nous devons revenir à nos tests et vérifier ce qui manque. Les mutations découvertes sont une mutation qui se produit dans les lignes qui ne sont pas couvertes par des tests unitaires. L'erreur mortelle (E) et le délai d'attente (T) sont les mutations qui créent une erreur fatale et créent des boucles infinies, respectivement.

qu'en est-il des indicateurs?

Les métriques du score de variation représentent le pourcentage de mutations détectées. Notre objectif est à 100%. La couverture du code de variation représente le pourcentage de tests couverts par la mutation. Les mesures de score de variation peuvent vous donner une idée de l'efficacité des tests existants. En analysant nos journaux Humbug, nous pouvons voir que nous avons 9 mutations découvertes, ainsi que de très mauvaises mesures. Découvrez le fichier Humblogjson.json. Ce fichier est automatiquement généré comme le fichier Humblog.txt et contient des informations plus détaillées sur les causes, l'emplacement et les raisons de l'échec. Nous n'avons pas testé nos fonctions pour pourcentage, π et logarithmiques. De plus, nous devons couvrir le cas où le nombre est divisé par 0. Ajoutons plus de tests pour couvrir la situation manquante:

<code class="language-bash">composer global require 'humbug/humbug'</code>

Cette fois, 100% signifie que toutes les mutations sont tuées et que nous avons une couverture complète du code.

Inconvénients

Le plus grand inconvénient des tests de mutation et de Humbug est la performance. Le test de variation est un processus lent car il repose sur de nombreux facteurs tels que les interactions entre les lignes de code, le nombre de tests, le niveau de couverture du code et les performances du code et des tests. Humbug effectue également des essais initiaux, la journalisation et la couverture du code, ce qui augmente la durée totale. De plus, Humbug est spécifique au phpunit et peut être un problème pour les utilisateurs utilisant d'autres cadres de test. Autrement dit, Humbug est en cours de développement actif et continuera de s'améliorer.

Conclusion

Humbug peut être un outil important pour maintenir la durée de vie de votre application. À mesure que la complexité des applications augmente, les tests de test de test - et il devient très important de toujours maintenir des tests à 100%, en particulier lorsqu'il s'agit de l'écosystème d'entreprise. Le code utilisé dans ce tutoriel peut être cloné ici. Avez-vous utilisé Humbug? Faites-vous des tests de mutation d'autres manières? Veuillez nous dire toutes vos réflexions à ce sujet!

Les questions fréquemment posées sur "Qui supervisera l'inspecteur?" Quelle est l'origine de cette phrase "Qui supervisera l'inspecteur?"

"Qui supervisera l'inspecteur?" Cette phrase est souvent utilisée dans des discussions qui remettent en question l'intégrité et la responsabilité des personnes au pouvoir. Il s'agit essentiellement de "qui gardera la garde?" Gardien".

Dans le contexte des tests de logiciels, comment la phrase "qui supervisera l'inspecteur?"

Dans le contexte des tests de logiciels, "Qui supervisera l'inspecteur?" Il s'interroge qui ou ce qui surveille les tests pour s'assurer qu'ils peuvent fonctionner correctement et produire des résultats précis. Il s'agit d'un aspect clé du développement de logiciels car il garantit la qualité et la fiabilité des logiciels développés.

Quelle est l'importance des tests et des tests dans le développement de logiciels?

Le test de test, également connu sous le nom de vérification des tests, est un élément clé du développement de logiciels. Il garantit que les tests mesurent avec précision la fonctionnalité et les performances du logiciel. S'il n'y a pas de vérification du test, il existe un risque que le test puisse produire de faux positifs ou des rapports manqués, ce qui entraîne une évaluation inexacte de la qualité et de la fiabilité du logiciel.

Comment puis-je m'assurer que mes tests sont fiables et précis?

Assurer que la fiabilité et la précision du test impliquent plusieurs étapes. Tout d'abord, vous devez vérifier soigneusement vos tests pour vous assurer qu'ils sont conçus et mis en œuvre correctement. Deuxièmement, vous devez vérifier régulièrement vos tests en comparant les résultats des tests avec des résultats connus. Enfin, vous devez surveiller et mettre à jour en permanence vos tests pour vous assurer qu'ils restent précis à mesure que le logiciel évolue.

Quels sont les pièges communs dans les tests de logiciels?

Certains pièges courants dans les tests de logiciels incluent des tests insuffisants, des tests mauvais et ne pas comprendre l'objectif des tests. D'autres pièges incluent la surdiffion sur les tests automatisés sans comprendre leurs limites, et l'examen périodique et la mise à jour des tests.

Quelle est la relation entre le roman graphique "Watchman" et les tests de logiciels?

Le roman graphique "Watchman" utilise la phrase "qui supervise l'inspecteur?" Dans le contexte des tests de logiciels, cette phrase peut être utilisée pour remettre en question la fiabilité et la précision du test lui-même. Tout comme l'observateur devrait protéger la société, les tests devraient protéger la qualité et la fiabilité des logiciels. Mais tout comme l'observateur doit être surveillé, le test doit être surveillé.

Quel est le rôle d'un testeur de logiciel?

Le rôle des testeurs de logiciels est d'assurer la qualité et la fiabilité du logiciel en concevant et en mettant en œuvre des tests. Ces tests sont utilisés pour identifier et corriger les erreurs, vérifier les fonctionnalités et évaluer les performances. Les testeurs de logiciels doivent également surveiller et mettre à jour ces tests pour s'assurer qu'ils restent précis pendant le processus de développement des logiciels.

Comment améliorer mes compétences de test de logiciel?

Améliorer vos compétences de test de logiciels nécessite un apprentissage et une pratique continus. Vous devez être conscient des dernières méthodes et outils de test et de la pratique de la conception et de la mise en œuvre de tests régulièrement. Vous devez également demander des commentaires sur vos tests et être heureux d'apprendre de vos erreurs.

Quelles sont les bonnes ressources pour en savoir plus sur les tests de logiciels?

Il existe de nombreuses ressources disponibles pour en savoir plus sur les tests de logiciels. Il s'agit notamment de cours en ligne, de livres, de blogs et de forums. Certains livres recommandés incluent "The Art of Software Testing" de Glenford J. Myers, "Software Testing: The Craftsman Method" de Paul C. Jorgensen, et Seim Karnar et Jack Falke "Testing Computer Software" par Huang Q. Ruan.

Quel est l'avenir des tests de logiciels?

L'avenir des tests de logiciels peut être fortement affecté par les progrès technologiques. Cela comprend l'utilisation croissante de l'automatisation et de l'intelligence artificielle dans les tests, ainsi que le développement de nouvelles méthodes de test pour s'adapter aux technologies émergentes telles que la réalité virtuelle et la blockchain. Cependant, les principes de base des tests de logiciels - pour garantir la qualité et la fiabilité du logiciel - resteront les mêmes.

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!