Machez vos dépendances de test avec une moquerie

Bien que tout le monde ne fasse pas cela, tester votre application est l'une des parties les plus élémentaires du développeur. Les tests unitaires sont le test le plus courant. Avec les tests unitaires, vous pouvez vérifier si une classe s'exécute exactement comme vous vous y attendez. Parfois, vous utilisez des services tiers dans votre application, et il est difficile de tout configurer pour les tests unitaires. C'est à ce moment que la simulation entre en jeu.

Points clés

• La moquerie est le processus de création d'un substitut à des objets réels dans un test unitaire, ce qui est particulièrement utile lors du test des applications qui reposent fortement à l'injection de dépendance.
• La moquerie est une bibliothèque créée par Pádraic Brady qui peut être utilisée pour se moquer des objets dans les tests unitaires, fournissant une alternative aux capacités de moquerie par défaut de Phpunit.
• La moquerie permet aux développeurs de définir les attentes pour le nombre d'appels de méthode, les paramètres à remettre et les valeurs à retourner, ce qui en fait un outil puissant pour isoler les dépendances dans les tests unitaires.
• Bien que PHPUnit puisse déjà se moquer d'objets, la moquerie offre une plus grande flexibilité et une plus grande commodité aux développeurs qui souhaitent s'assurer que leurs tests unitaires ne sont pas affectés par d'autres classes.

Qu'est-ce que la simulation?

se moquer d'un objet n'est rien de plus que de créer un objet de substitution qui remplace l'objet réel dans les tests unitaires. Si votre application dépend fortement de l'injection de dépendance, la moquerie est une manière viable.

Il peut y avoir plusieurs raisons pour se moquer des objets:

1. Il est préférable d'isoler la classe lors de la réalisation de tests unitaires. Vous ne voulez pas qu'une autre classe ou service interfère avec vos tests unitaires.
2. L'objet n'existe pas encore. Vous pouvez d'abord créer le test, puis construire l'objet final.
3. Les objets simulés sont généralement plus rapides que de préparer toute la base de données pour les tests.

Vous pouvez utiliser PHPUnit lors de l'exécution de tests unitaires. PHPUnit est livré avec certaines fonctionnalités de simulation par défaut comme indiqué dans la documentation. Vous pouvez en savoir plus sur les simulations et les capacités de simulation de Phpunit dans cet article écrit par Jeune Asuncion.

Dans cet article, nous plongerons dans la moquerie de la bibliothèque créée par Pádraic Brady. Nous créerons une classe de température qui injectera des services météorologiques qui n'existent pas actuellement.

Paramètres

Commençons par configurer le projet. Nous commençons par le fichier composer.json qui contient le contenu suivant. Cela garantira que nous avons des moqueries et du phpunit.

<code>{
    "name": "sitepoint/weather",
    "license": "MIT",
    "type": "project",
    "require": {
        "php": ">=5.3.3"
    },
    "autoload": {
        "psr-0": { "": "src/" }
    },
    "require-dev": {
        "phpunit/phpunit": "4.1.*",
        "mockery/mockery": "0.9.*"
    }
}</code>

Nous créons également un fichier de configuration phpunit appelé phpunit.xml

<phpunit>
    <testsuite name="SitePoint Weather">
        <directory>./tests</directory>
    </testsuite>
    <listeners>
        <listener class="\Mockery\Adapter\Phpunit\TestListener"
                  file="vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/TestListener.php"/>
    </listeners>
</phpunit>

Il est important de définir cet auditeur. S'il n'y a pas d'écouteur, si les méthodes once(), twice() et times() sont mal utilisées, aucune erreur ne sera augmentée. Cela sera décrit en détail plus tard.

J'ai également créé 2 répertoires. Le répertoire SRC est utilisé pour maintenir mes cours, et le répertoire des tests est utilisé pour stocker nos tests. Dans le répertoire SRC, j'ai créé le chemin SitePointWeather.

Nous créons d'abord le weatherserviceInterface. Les services météorologiques qui n'existent pas implémenteront cette interface. Dans ce cas, nous ne fournissons qu'une seule méthode qui nous donnera la température de Celsius.

<code>{
    "name": "sitepoint/weather",
    "license": "MIT",
    "type": "project",
    "require": {
        "php": ">=5.3.3"
    },
    "autoload": {
        "psr-0": { "": "src/" }
    },
    "require-dev": {
        "phpunit/phpunit": "4.1.*",
        "mockery/mockery": "0.9.*"
    }
}</code>

Par conséquent, nous avons un service qui nous fournit une température Celsius. Je veux obtenir Fahrenheit. Pour ce faire, j'ai créé une nouvelle classe appelée TemperaturService. Ce service injectera des services météorologiques. En plus de cela, nous définissons également une méthode qui convertit Celsius en Fahrenheit.

<phpunit>
    <testsuite name="SitePoint Weather">
        <directory>./tests</directory>
    </testsuite>
    <listeners>
        <listener class="\Mockery\Adapter\Phpunit\TestListener"
                  file="vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/TestListener.php"/>
    </listeners>
</phpunit>

Créer des tests unitaires

Nous sommes prêts à configurer des tests unitaires. Nous créons une classe TemperaturesServiceTest dans le répertoire des tests. Dans cette classe, nous créons la méthode testGetTempFahrenheit() qui testera notre méthode Fahrenheit.

La première étape à faire dans cette méthode consiste à créer un nouvel objet TemperaturService. Tout comme nous le faisons, notre constructeur demandera un objet qui implémente la WeatherServiceInterface. Comme nous n'avons pas encore un tel objet (nous ne le voulons pas non plus), nous utiliserons la moquerie pour créer un objet simulé pour nous. Voyons à quoi ressemble la méthode après la fin.

namespace SitePoint\Weather;

interface WeatherServiceInterface
{
    /**
     * 返回摄氏温度
     *
     * @return float
     */
    public function getTempCelsius();
}

Nous créons d'abord l'objet simulé. Nous disons à Mockery quel objet (ou interface) nous voulons nous moquer. La deuxième étape consiste à décrire la méthode qui sera appelée sur cet objet simulé. Dans la méthode shouldReceive(), nous définissons le nom de la méthode à appeler.

Nous définissons le nombre de fois que cette méthode sera appelée. Nous pouvons utiliser once(), twice() et times(X). Dans ce cas, nous nous attendons à ce qu'il ne soit appelé qu'une seule fois. Si ce n'est pas appelé ou des appels excessifs sont appelés, le test unitaire échouera.

Enfin, nous définissons la valeur à retourner dans la méthode andReturn(). Dans ce cas, nous retournons 25. Mockery a également des méthodes de retour telles que andReturnNull(), andReturnSelf() et andReturnUndefined(). Si c'est ce que vous attendez, la moquerie peut également lancer des exceptions.

Nous avons maintenant des objets simulés qui peuvent créer notre objet TemperaturService et le tester comme d'habitude. 25 degrés Celsius mesure 77 degrés Fahrenheit, nous vérifions donc si nous recevons 77 de notre méthode getTempFahrenheit().

Si vous exécutez vendor/bin/phpunit tests/ Dans votre répertoire racine, vous obtiendrez un feu vert de Phpunit, indiquant que tout est parfait.

Utilisation avancée

L'exemple ci-dessus est assez simple. Pas de paramètres, juste un simple appel. Rendons les choses plus compliquées.

Supposons que notre service météorologique ait également un moyen d'obtenir la température aux heures exactes. Nous ajoutons la méthode suivante à notre WEATERSERVICEINTERACE actuelle.

namespace SitePoint\Weather;

class TemperatureService
{
    /**
     * @var WeatherServiceInterace $weatherService 保存天气服务
     */
    private $weatherService;

    /**
     * 构造函数。
     *
     * @param WeatherServiceInterface $weatherService
     */
    public function __construct(WeatherServiceInterface $weatherService) {
        $this->weatherService = $weatherService;
    }

    /**
     * 获取当前华氏温度
     *
     * @return float
     */
    public function getTempFahrenheit() {
        return ($this->weatherService->getTempCelsius() * 1.8000) + 32;
    }
}

Nous voulons savoir quelle est la température moyenne entre 0h00 et 18h00. Pour ce faire, nous créons une nouvelle méthode de service de température pour calculer la température moyenne. Pour ce faire, nous récupérons 7 températures de l'assurance-nette et calculons la moyenne.

<code>{
    "name": "sitepoint/weather",
    "license": "MIT",
    "type": "project",
    "require": {
        "php": ">=5.3.3"
    },
    "autoload": {
        "psr-0": { "": "src/" }
    },
    "require-dev": {
        "phpunit/phpunit": "4.1.*",
        "mockery/mockery": "0.9.*"
    }
}</code>

Jetons un coup d'œil à notre méthode de test.

<phpunit>
    <testsuite name="SitePoint Weather">
        <directory>./tests</directory>
    </testsuite>
    <listeners>
        <listener class="\Mockery\Adapter\Phpunit\TestListener"
                  file="vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/TestListener.php"/>
    </listeners>
</phpunit>

Nous simulons à nouveau l'interface et définissons la méthode à appeler. Ensuite, nous définissons le nombre de fois que cette méthode sera appelée. Nous avons utilisé once() dans l'exemple précédent, et maintenant nous utilisons times(7) pour indiquer que nous nous attendons à ce que cette méthode soit appelée 7 fois. Si la méthode n'est pas appelée exactement 7 fois, le test échouera. Si vous ne définissez pas l'auditeur dans le fichier de configuration phpunit.xml, vous ne recevrez pas de notifications à ce sujet.

Ensuite, nous définissons la méthode with(). Dans la méthode with, vous pouvez définir les paramètres que vous attendez. Dans ce cas, nous nous attendons à 7 heures différentes.

Enfin, nous avons la méthode andReturn(). Dans ce cas, nous indiquons 7 valeurs de retour. Si vous définissez un moins de valeurs de retour, la dernière valeur de retour disponible sera répétée à chaque fois.

Bien sûr, la moquerie peut faire plus. Pour le guide complet et la documentation, je vous recommande de consulter la page GitHub.

Si vous êtes intéressé par le code du projet ci-dessus, vous pouvez consulter cette page GitHub.

Conclusion

En utilisant phpunit, vous pouvez déjà se moquer des objets. Cependant, vous pouvez également utiliser la moquerie comme expliqué dans l'exemple ci-dessus. Si vous testez votre classe et que vous ne voulez pas que aucune autre classe affecte vos tests, la moquerie peut vous aider facilement. Si vous voulez vraiment faire des tests fonctionnels, il est préférable de voir si vous pouvez intégrer de vrais tests. Utilisez-vous actuellement la simulation PHPUnit et envisagez-vous de passer à la moquerie? Voulez-vous voir des exemples de moqueries plus importants dans les articles suivants? Veuillez me le faire savoir dans les commentaires ci-dessous.

FAQ sur les moqueries et les dépendances de test (FAQ)

Qu'est-ce que la moquerie et pourquoi est-elle importante dans les tests PHP?

La moquerie est un cadre d'objet PHP puissant et flexible pour les tests unitaires. Il est conçu comme une alternative directe à la fonctionnalité d'objet simulé de Phpunit. Mockery permet aux développeurs d'isoler le code testé et de créer des stand-ins de test qui simulent le comportement des objets complexes. Ceci est crucial dans les tests unitaires car il garantit que le code testé ne dépend d'aucun facteur ou état externe.

Comment installer et configurer la moquerie dans mon projet PHP?

Pour installer des moqueries, vous devez avoir un compositeur, un gestionnaire de dépendances PHP. Vous pouvez installer des moqueries en exécutant la commande composer require --dev mockery/mockery. Après l'installation, vous pouvez configurer la moquerie dans le fichier de test en appelant Mockery::close() dans la méthode de détresse de test pour nettoyer les objets simulés.

Comment créer des objets simulés en utilisant la moquerie?

Créer des objets simulés en moquerie est simple. Vous pouvez utiliser la méthode mock() pour créer un objet simulé. Par exemple, $mock = Mockery::mock('MyClass'); créera un objet simulé pour MyClass.

Comment définir les attentes en moquerie?

En moquerie, vous définissez les attentes en liant des méthodes pour simuler les objets. Par exemple, $mock->shouldReceive('myMethod')->once()->andReturn('mocked value'); ce code indique que la moquerie qui s'attend à ce que "MyMethod" soit appelé une fois et devrait retourner "valeur moquette".

Quelle est la différence entre la simulation et le talon en moquerie?

En moquerie, une simulation est l'objet sur lequel nous pouvons définir celui souhaité, tandis qu'un stub est un objet simulé qui a une réponse préprogrammée. Lorsque la réponse est la seule chose importante, les talons sont généralement utilisés et lors du test de l'interaction elle-même, des simulations sont utilisées.

Comment utiliser la moquerie pour tester les méthodes privées?

Il n'est pas recommandé de tester directement les méthodes privées car elle viole le principe d'encapsulation. Cependant, si vous le souhaitez, vous pouvez utiliser la méthode shouldAllowMockingProtectedMethods() en moquerie pour permettre les méthodes protégées et privées moquées.

Comment gérer les paramètres du constructeur en moquerie?

Si la classe que vous souhaitez simuler a des constructeurs avec des arguments, vous pouvez les transmettre comme un tableau à la méthode mock(). Par exemple, $mock = Mockery::mock('MyClass', [$arg1, $arg2]); passera $ arg1 et $ arg2 au constructeur de myclass.

Comment utiliser la moquerie pour simuler des méthodes statiques?

La moquerie fournit une méthode pour simuler des méthodes statiques à l'aide du préfixe alias:. Par exemple, $mock = Mockery::mock('alias:MyClass'); créera un objet simulé qui peut être utilisé pour définir le paramètre souhaité de la méthode statique de MyClass.

Comment vérifier que toutes les attentes sont satisfaites en moquerie?

Vous pouvez utiliser la méthode Mockery::close() dans la méthode de démontage de test pour vérifier que toutes les attentes ont été satisfaites. Si des attentes ne sont pas satisfaites, Mockery lancera une exception.

Comment gérer les exceptions en moquerie?

Vous pouvez utiliser la méthode andThrow() pour configurer l'objet simulé pour lancer une exception. Par exemple, $mock->shouldReceive('myMethod')->andThrow(new Exception); lancera une exception lorsque "MyMethod" est appelé.

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!