Tests unitaires et couverture de code avec PHP et PHPUnit

Avec le développement du développement logiciel, de plus en plus de développeurs réalisent l'importance des tests unitaires. Les tests unitaires sont une méthode de test courante dans le développement de logiciels qui garantit l'exactitude et la stabilité du code en testant l'exactitude d'un seul module fonctionnel (également appelé « unité »). Dans cet article, nous expliquerons comment réaliser des tests unitaires et une couverture de code à l'aide de PHP et PHPUnit.

PHPUnit est un framework de test open source pour tester le code PHP. Il prend en charge plusieurs types de tests, notamment les tests unitaires, les tests fonctionnels et les tests d'intégration. Dans cet article, nous nous concentrerons sur les tests unitaires.

Pourquoi les tests unitaires et la couverture de code ?

Lors du développement de logiciels, nous essayons généralement de tester notre code autant que possible. Les tests unitaires sont une méthode de test plus efficace qui permet de tester en continu pendant le processus de développement pour garantir l'exactitude du code. De plus, il présente les avantages suivants :

1. Améliorer la maintenabilité du code : grâce aux tests unitaires, vous pouvez rapidement vérifier l'exactitude du code après l'avoir modifié pour vous assurer qu'il n'endommage pas les fonctions d'origine. .
2. Améliorer la robustesse du code : en testant chaque unité, des problèmes et des erreurs potentiels dans le code peuvent être découverts, afin que ces problèmes puissent être traités à l'avance pour éviter de provoquer des problèmes dans l'environnement de production.
3. Réduisez le coût de mise à l'échelle et de refactorisation : les tests unitaires peuvent vous aider à détecter rapidement les problèmes lors de la modification du code existant, gérant ainsi plus efficacement les modifications dans votre base de code.

La couverture du code est un moyen d'évaluer la couverture des tests. Il vous indique dans quelle mesure votre code a été testé. Par exemple, si votre couverture de test est de 60 %, cela signifie que votre code de test couvre 60 % du code source. Avec la couverture de code, vous pouvez mesurer si la qualité de votre logiciel est élevée et si vous avez besoin de davantage de cas de test.

Commencez à utiliser PHPUnit pour les tests unitaires

Avant de continuer, vous devez vous assurer que PHPUnit est installé. Peut être installé via Composer. Créez un fichier composer.json dans le répertoire de votre projet et ajoutez la dépendance PHPUnit :

{
  "require-dev": {
    "phpunit/phpunit": "^7.0"
  }
}

Exécutez la commande suivante pour installer PHPUnit :

composer install --dev

Ensuite, nous montrerons comment écrire un simple test unitaire. Imaginez que vous écrivez une classe PHP appelée « Calculatrice » qui effectue des opérations arithmétiques de base. Voici son code :

class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }

    public function subtract($a, $b) {
        return $a - $b;
    }
}

Maintenant, écrivez une classe de test appelée « CalculatorTest » qui testera notre classe Calculator :

use PHPUnitFrameworkTestCase;

class CalculatorTest extends TestCase {
    public function testAdd() {
        $calculator = new Calculator();
        $result = $calculator->add(1, 2);
        $this->assertEquals(3, $result);
    }

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

Dans le code ci-dessus, nous avons utilisé l'un des méthodes de test de base fournies par PHPUnit - assertEquals(). Il compare la valeur de test avec la valeur attendue et lève une exception si elles ne sont pas égales.

Maintenant, lancez les tests PHPUnit :

./vendor/bin/phpunit CalculatorTest.php

Si tous les tests réussissent, le résultat suivant sera affiché :

PHPUnit 7.5.1 by Sebastian Bergmann and contributors.

..

Time: 42 ms, Memory: 4.00 MB

OK (2 tests, 2 assertions)

Notez que dans cet exemple A Une petite astuce consiste à définir à la fois la classe Calculator et sa classe de test correspondante CalculatorTest dans le même fichier CalculatorTest.php.

Comprendre les méthodes de test de base de PHPUnit

PHPUnit fournit une variété de méthodes de test Voici des exemples d'utilisation de certaines des méthodes de base :

#🎜🎜 ##🎜 🎜#assertEquals ($expected, $actual, $message) : compare la valeur attendue et la valeur réelle pour l'égalité.

1. assertTrue($value, $message) : Déterminez si une expression est vraie.
2. assertFalse($value, $message) : Déterminez si une expression est fausse.
3. assertNull($value, $message) : Détermine si une valeur est nulle.
4. assertSame ($expected, $actual, $message) : compare la valeur attendue et la valeur réelle pour une égalité complète (y compris le type).
5. assertInstanceOf($expected, $actual, $message) : Déterminez si un objet est une instance d'une classe spécifique.
6. Plus de méthodes de test pour PHPUnit peuvent être trouvées dans la documentation.

Test de couverture de code avec PHPUnit

Nous avons vu comment utiliser PHPUnit pour les tests unitaires. Voyons maintenant comment utiliser PHPUnit pour les tests de couverture de code.

Afin d'obtenir une couverture de code, nous devons ajouter l'option --coverage-html lors de l'exécution de PHPUnit. Il générera un rapport de couverture du code HTML. Exécutez simplement la commande suivante :

./vendor/bin/phpunit --coverage-html reports tests

Cette commande exécute tous les cas de test dans le répertoire de test de notre projet et génère un rapport de couverture de code dans le répertoire des rapports après l'exécution.

Après cela, vous pouvez ouvrir le rapport HTML dans votre navigateur pour voir la couverture du code source.

Résumé

Dans cet article, nous avons présenté comment utiliser PHPUnit pour les tests unitaires et la couverture de code. Grâce aux tests unitaires et à la couverture du code, vous pouvez améliorer la qualité et la stabilité du projet et réduire les coûts de mise à l'échelle et de refactorisation.

Lorsque vous écrivez du code PHP, n'oubliez pas d'écrire de bons tests unitaires. Un bon test unitaire est utilisé pour vérifier l'exactitude du code, prévenir les erreurs de régression et garantir la robustesse du code. En rédigeant de bons cas de test, vous pouvez détecter les problèmes rapidement et les résoudre avant qu'ils ne surviennent.

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!