Comment utiliser PHPUnit pour les tests unitaires PHP

Avec le développement de l'industrie du développement logiciel, les tests sont progressivement devenus un élément indispensable. En tant que partie la plus fondamentale des tests logiciels, les tests unitaires peuvent non seulement améliorer la qualité du code, mais également accélérer le développement et la maintenance du code par les développeurs. Dans le domaine de PHP, PHPUnit est un framework de tests unitaires très populaire qui fournit diverses fonctions pour nous aider à rédiger des cas de tests de haute qualité. Dans cet article, nous expliquerons comment utiliser PHPUnit pour les tests unitaires PHP.

1. Installer PHPUnit

Avant d'utiliser PHPUnit, nous devons d'abord l'installer. PHPUnit est une bibliothèque PHP qui peut être installée à l'aide de Composer. Depuis la racine de votre projet, exécutez la commande suivante :

composer require --dev phpunit/phpunit

Cela ajoutera PHPUnit à votre projet en tant que dépendance de développement.

2. Rédaction de cas de test

La rédaction de cas de test est généralement la première étape lorsque nous utilisons PHPUnit. Un scénario de test est un script qui teste une ou plusieurs fonctions ou méthodes. Supposons que nous ayons une classe Calculator :

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

Nous pouvons utiliser un scénario de test pour tester la méthode add dans la classe Calculator :

use PHPUnitFrameworkTestCase;

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

Dans ce cas de test, nous créons une classe de test appelée CalculatorTest, qui hérite de la classe PHPUnitFrameworkTestCase . Nous avons également écrit une méthode de test nommée testAdd, dans laquelle nous avons créé une instance de Calculator et exécuté la méthode add, et finalement utilisé $this->assertEquals pour tester si le résultat renvoyé par la méthode add est le même que la valeur attendue.

3. Exécution de cas de test

Une fois que nous avons écrit les cas de test, nous pouvons utiliser PHPUnit pour les exécuter. Dans le répertoire racine de notre projet, exécutez la commande suivante :

vendor/bin/phpunit

Cela exécutera PHPUnit et exécutera tous les cas de test disponibles. Si vous souhaitez uniquement exécuter une classe de test ou une méthode de test spécifique, vous pouvez utiliser la commande suivante :

vendor/bin/phpunit tests/CalculatorTest.php
vendor/bin/phpunit --filter testAdd tests/CalculatorTest.php

4. Using assertions

PHPUnit fournit une variété de fonctions d'assertion qui peuvent être utilisées pour tester si la valeur de retour d'une fonction ou la méthode répond à nos attentes. Voici quelques-unes des fonctions d'assertion les plus couramment utilisées dans PHPUnit :

• assertTrue($value) : Teste si $value est vraie
• assertFalse($value) : Teste si $value est fausse
• assertEquals($expected, $actual) : Teste si $actual est égal à $expected
• assertNotEquals($expected, $actual) : Teste si $actual n'est pas égal à $expected
• assertSame($expected, $actual) : Teste si $actual est identique à $expected
• assertNotSame( $expected, $actual) : Teste si $actual est différent de $expected
• assertNull($value) : Teste si $value est null
• assertNotNull($value) : Teste si $ la valeur n'est pas nulle
• assertInstanceOf($expected, $actual) : Teste si $actual est une instance de $expected
• assertNotInstanceOf($expected, $actual) : Teste si $actual n'est pas une instance de $expected

5. Utilisez un fournisseur de données

Parfois, nous avons besoin de tester si une fonction ou une méthode renvoie le résultat correct pour différentes entrées. Nous pouvons actuellement utiliser la fonction de fournisseur de données de PHPUnit. Un fournisseur de données est une méthode qui fournit un ensemble de paramètres, chacun étant un ensemble de données pouvant être testées.

Dans l'exemple ci-dessous, nous avons écrit un fournisseur de données pour la méthode add de la classe Calculator, qui fournit différentes données d'entrée et sorties attendues.

class CalculatorTest extends TestCase {
    /**
     * @dataProvider additionProvider
     */
    public function testAdd($a, $b, $expected) {
        $calculator = new Calculator();
        $result = $calculator->add($a, $b);
        $this->assertEquals($expected, $result);
    }

    public function additionProvider() {
        return [
            [0, 0, 0],
            [0, 1, 1],
            [1, 0, 1],
            [1, 1, 2],
            [2, 3, 5],
            [-1, 1, 0],
            [10, -5, 5]
        ];
    }
}

Dans ce cas de test, nous utilisons l'annotation @DataProvider pour indiquer à PHPUnit où trouver un fournisseur de données. Nous avons écrit un fournisseur de données appelé additionProvider dans lequel nous fournissons différentes données d'entrée et sorties attendues. Dans la méthode de test testAdd, nous avons transmis ces données directement et les avons testées.

6. Utilisation d'objets simulés

Lorsque nous testons une méthode dans un objet, nous ne souhaitons peut-être pas nous appuyer sur d'autres classes ou ressources externes. À l'heure actuelle, nous pouvons utiliser l'objet Mock de PHPUnit pour simuler ces dépendances. Un objet Mock est un objet fictif qui fournit la même interface, mais il n'est pas réellement instancié.

Dans l'exemple suivant, nous avons écrit un objet Mock pour la méthode add dans la classe Calculator afin de simuler des dépendances externes.

class CalculatorTest extends TestCase {
    public function testAdd() {
        $mock = $this->getMockBuilder('Dependency')
                     ->getMock();
        $mock->expects($this->once())
             ->method('getValue')
             ->will($this->returnValue(5));

        $calculator = new Calculator($mock);
        $result = $calculator->add(2, 3);
        $this->assertEquals(10, $result);
    }
}

Dans ce cas de test, nous utilisons la méthode getMockBuilder pour créer un objet Mock nommé Dependency. Ensuite, nous nous attendons à ce que la méthode getValue de l'objet Mock soit appelée une fois et renvoie 5. Enfin nous passons cet objet Mock au constructeur de la classe Calculator.

Résumé

Dans cet article, nous avons appris à utiliser PHPUnit pour les tests unitaires PHP. Nous avons installé PHPUnit, écrit des cas de test, exécuté les cas de test et utilisé des assertions, des fournisseurs de données et des objets Mock. Grâce à ces étapes, nous pouvons écrire des cas de test de haute qualité pour tester notre code afin d'améliorer la qualité du code et d'accélérer le développement et la maintenance.

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!