Conseils pour implémenter des tests de performances de code à l'aide de PHP et PHPUnit

Dans le développement de logiciels modernes, les performances du code sont un aspect très important. Si votre code s'exécute lentement, votre programme s'exécutera lentement, ce qui entraînera une perte de confiance et de fidélité de vos utilisateurs. Pour étudier et ajuster les performances du code, vous avez besoin d'outils pour sonder et analyser le comportement de votre code. Dans cet article, nous apprendrons comment utiliser PHP et PHPUnit pour tester les performances du code.

PHPUnit est un framework de test PHP populaire qui peut non seulement effectuer des tests unitaires mais également des tests fonctionnels. Les tests fonctionnels PHPUnit peuvent simuler des scénarios de test dans des environnements réels. Les tests déterminent les cas de test et l'efficacité d'exécution de votre code. Il peut également être utilisé pour tester pendant le cycle de vie d'un projet, identifier les problèmes de performances et optimiser le code.

Afin de tester les performances du code, nous devons utiliser plusieurs composants fournis avec PHPUnit, à savoir PHPUnit_Framework_TestSuite, PHPUnit_Framework_TestCase et PHPUnit_Util_Testdox_ResultPrinter. Voici quelques conseils que vous pouvez utiliser lors des tests de performances de votre code PHP.

1. Utilisez des commentaires pour marquer les tests de performances

Nous pouvons ajouter des balises de commentaires (@group) dans l'en-tête de la méthode de test pour distinguer les différents niveaux de performance Test méthode, par exemple :

/**
 * @group slow
 */
public function testSlow()
{
  //code to test goes here
}

Dans la ligne de commande, nous pouvons choisir d'exécuter uniquement le groupe de tests spécifié, par exemple :

phpunit --group slow

Cela n'exécutera que ceux marqués comme Méthodes de test lentes pour gagner du temps.

2. Utilisez les tests fonctionnels fournis avec PHPUnit

Le framework PHPUnit fournit des cas de tests fonctionnels, qui peuvent facilement tester des opérations spécifiées. À l'aide de ces cas de test, nous pouvons tester les problèmes de performances sous-jacents en termes de latence, de temps de traitement, d'E/S, etc.

Ce qui suit est un exemple de test de retard utilisant les propres cas de test de PHPUnit :

class DelayTest extends PHPUnit_Framework_TestCase
{
    public function testExecutionTime()
    {
        $this->assertGreaterThan(
            10000, //expected time in microseconds
            $this->getExecutionTime()
        );
    }

    protected function getExecutionTime()
    {
        $start = microtime(true);
        //your code implementation
        usleep(10000000); //delay for 10 seconds
        return microtime(true) - $start;
    }
}

Grâce à la méthode getExecutionTime, nous pouvons obtenir le temps requis pour l'exécution et utiliser le assertGreaterThan( ) détermine si le temps d'exécution dépasse le temps prévu que nous avons défini.

3. Tester l'efficacité d'exécution des algorithmes et des structures de données

Les tests de performances sont très importants lors du traitement de données et de l'analyse d'algorithmes à grande échelle, car Les problèmes de performances sont souvent le principal goulot d’étranglement que nous devons optimiser. Par conséquent, nous devons effectuer des tests de performances des algorithmes et des structures de données pour identifier d’éventuels goulots d’étranglement.

Ce qui suit est un exemple d'utilisation de PHPUnit pour tester les performances de l'algorithme de tri rapide :

class QuickSortTest extends PHPUnit_Framework_TestCase
{
    /**
     * @test
     * @group performance
     */
    public function testQuickSortPerformance()
    {
        $this->markTestSkipped(); //skip the test
        $data = range(1, 500);
        shuffle($data);

        $start = microtime(true);
        $quickSort = new QuickSort();
        $quickSort->sort($data);
        $end = microtime(true);

        $this->assertLessThan(0.02, $end - $start); //check execution time
    }
}

Dans cet exemple, nous utilisons un algorithme de tri rapide écrit par nous-mêmes, qui a été ajouté à notre base de code. Nous pouvons utiliser la méthode PHPUnit_Framework_TestCase::markTestSkipped() de PHPUnit pour marquer les tests que nous souhaitons ignorer afin d'éviter d'exécuter le test à chaque fois que le test est exécuté.

4. Utilisez le composant de test PHPUnit pour analyser les problèmes de performances

Enfin, nous pouvons utiliser divers outils d'analyse et plug-ins dans le composant de test PHPUnit pour en savoir plus Problèmes de performances. Le composant PHPUnit_Framework_TestSuite nous permet de collecter et d'analyser des données détaillées et des informations sur les résultats lors de l'exécution de tests.

class CustomTestResultPrinter extends PHPUnit_Util_Testdox_ResultPrinter
{
    public function addError(PHPUnit_Framework_Test $test, Exception $exception, $time)
    {
        //print out custom message
        $this->write('Error: ' . $test->getName());
        parent::addError($test, $exception, $time);
    }

    public function addFailure(PHPUnit_Framework_Test $test, PHPUnit_Framework_AssertionFailedError $exception, $time)
    {
        //print out custom message
        $this->write('Failure: ' . $test->getName());
        parent::addFailure($test, $exception, $time);
    }
}

Dans cet exemple, nous avons créé une imprimante de résultats de test personnalisée pour afficher les résultats des tests et imprimer notre propre message. Nous pouvons définir notre propre comportement en utilisant les méthodes addFailure() et addError(). Lors de l'exécution de PHPUnit, nous pouvons spécifier notre propre imprimante de résultats de test en utilisant l'option --printer.

Résumé

Dans cet article, nous avons appris à utiliser PHP et PHPUnit pour les tests de performances. L'utilisation de balises d'annotation, les propres tests fonctionnels de PHPUnit, le test de l'efficacité d'exécution des algorithmes et des structures de données, ainsi que les composants de test PHPUnit pour analyser les problèmes de performances et d'autres techniques peuvent nous aider à mieux comprendre et optimiser les problèmes de performances en développement. Deuxièmement, les tests ne peuvent pas seulement être utilisés pour découvrir et corriger des problèmes de performances. Au cours du cycle de vie du projet, les tests peuvent aider à stabiliser et vérifier le code, ainsi qu'à améliorer la maintenabilité et l'évolutivité.

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!