Guide pratique des tests d'unité PHP: comment utiliser des objets simulés pour améliorer l'efficacité des tests

Aperçu des objets simulés dans les tests unitaires

Un objet simulé est un stand-in de test couramment utilisé dans les tests unitaires, utilisé pour simuler le comportement d'une classe ou d'une interface, et peut contrôler avec précision sa valeur de retour ou lancer des exceptions. Grâce à l'objet simulé, les développeurs peuvent tester la logique interactive des fonctions ou des méthodes sans instancier des dépendances réelles.

Créer un objet simulé

Dans PHP, vous pouvez utiliser la méthode GetMockBuilder pour créer un objet simulé. Cette méthode accepte les paramètres suivants:

• $ originalClassName: le nom de la classe ou de l'interface à simuler.
• $ Méthodes (facultatif): un tableau de méthodes qui nécessitent une simulation.

 // simulation MyInterface interface
$mock = $this->getMockBuilder(MyInterface::class)
             ->getMock();

// simulation MyClass 类并simulation其方法
$mock = $this->getMockBuilder(MyClass::class)
             ->setMethods(['myMethod'])
             ->getMock();

Configurer les objets simulés

Après avoir créé un objet simulé, vous pouvez configurer son comportement via la méthode, tel que la définition d'une valeur de retour ou le lancer une exception:

 // Configuration Mock Objet à retourner 'foo'
$mock->method('getMyMethod')
     ->willReturn('foo');

// Configuration Mock Objet pour lancer l'exception
$mock->method('myOtherMethod')
     ->willThrowException(new RuntimeException());

Cas pratiques

Voici un exemple montrant comment utiliser un objet simulé dans les tests unitaires. Supposons qu'il y ait une classe MyClass qui dépend de la classe MyService:

 class MyClass
{
    private $myService;

    public function __construct(MyService $myService)
    {
        $this->myService = $myService;
    }

    public function doSomething(): string
    {
        return $this->myService->getData();
    }
}

La classe MyService contient une méthode GetData qui renvoie la chaîne "foo". Pour tester la méthode MyClass :: Dosomething, vous pouvez utiliser l'objet simulé:

 class MyClassTest extends PHPUnit_Framework_TestCase
{
    public function testDoSomething()
    {
        // créer MyService Mock Objet
        $mockService = $this->getMockBuilder(MyService::class)
                            ->setMethods(['getData'])
                            ->getMock();

        // Configuration Mock Objetretour "bar"
        $mockService->method('getData')
                    ->willReturn('bar');

        // créer MyClass Instance et injecter Mock Objet
        $myClass = new MyClass($mockService);

        // Affirmation MyClass::doSomething retour "bar"
        $this->assertEquals('bar', $myClass->doSomething());
    }
}

Dans ce test, nous avons créé l'objet simulé de MyService et réglé sa valeur de retour sur "bar". Injectez ensuite l'objet simulé dans l'instance MyClass et vérifiez enfin que l'interaction entre MyClass et MyService est correcte grâce à des affirmations.

En utilisant des objets simulés, les développeurs peuvent vérifier efficacement les dépendances et la logique métier dans les tests unitaires sans compter sur des services réels ou des environnements complexes.