Documentation sur les attentes

Documentation SimpleTest : étendre le testeur unitaire avec des classes d'attentes supplémentaires

# fantaisie Plus de contrôle sur les objets fantaisie

Le comportement par défaut des objets fantaisie dans SimpleTest est soit une correspondance identique sur l'argument, soit l'acceptation de n'importe quel argument. Pour la plupart des tests, c'est suffisant. Cependant il est parfois nécessaire de ramollir un scénario de test.

Un des endroits où un test peut être trop serré est la reconnaissance textuelle. Prenons l'exemple d'un composant qui produirait un message d'erreur utile lorsque quelque chose plante. Il serait utile de tester que l'erreur correcte est renvoyée, mais le texte proprement dit risque d'être plutôt long. Si vous testez le texte dans son ensemble alors à chaque modification de ce même message -- même un point ou une virgule -- vous aurez à revenir sur la suite de test pour la modifier.

Voici un cas concret, nous avons un service d'actualités qui a échoué dans sa tentative de connexion à sa source distante. <strong>class NewsService { ... function publish(&$writer) { if (! $this->isConnected()) { $writer->write('Cannot connect to news service "' . $this->_name . '" at this time. ' . 'Please try again later.'); } ... } }</strong> Là il envoie son contenu vers un classe `Writer`. Nous pourrions tester ce comportement avec un `MockWriter`... class TestOfNewsService extends UnitTestCase { ... function testConnectionFailure() {<strong> $writer = &new MockWriter($this); $writer->expectOnce('write', array( 'Cannot connect to news service ' . '"BBC News" at this time. ' . 'Please try again later.')); $service = &new NewsService('BBC News'); $service->publish($writer); $writer->tally();</strong> } } C'est un bon exemple d'un test fragile. Si nous décidons d'ajouter des instructions complémentaires, par exemple proposer une source d'actualités alternative, nous casserons nos tests par la même occasion sans pourtant avoir modifié une seule fonctionnalité.

Pour contourner ce problème, nous voudrions utiliser un test avec une expression rationnelle plutôt qu'une correspondance exacte. Nous pouvons y parvenir avec... class TestOfNewsService extends UnitTestCase { ... function testConnectionFailure() { $writer = &new MockWriter($this);<strong> $writer->expectOnce( 'write', array(new WantedPatternExpectation('/cannot connect/i')));</strong> $service = &new NewsService('BBC News'); $service->publish($writer); $writer->tally(); } } Plutôt que de transmettre le paramètre attendu au `MockWriter`, nous envoyons une classe d'attente appelée `WantedPatternExpectation`. L'objet fantaisie est suffisamment élégant pour reconnaître qu'il s'agit d'un truc spécial et pour le traiter différemment. Plutôt que de comparer l'argument entrant à cet objet, il utilise l'objet attente lui-même pour exécuter le test.

`WantedPatternExpectation` utilise l'expression rationnelle pour la comparaison avec son constructeur. A chaque fois qu'une comparaison est fait à travers `MockWriter` par rapport à cette classe attente, elle fera un `preg_match()` avec ce motif. Dans notre scénario de test ci-dessus, aussi longtemps que la chaîne "cannot connect" apparaît dans le texte, la fantaisie transmettra un succès au testeur unitaire. Peu importe le reste du texte.

Les classes attente possibles sont...

`EqualExpectation` | Une égalité, plutôt que la plus forte comparaison à l'identique
`NotEqualExpectation` | Une comparaison sur la non-égalité
`IndenticalExpectation` | La vérification par défaut de l'objet fantaisie qui doit correspondre exactement
`NotIndenticalExpectation` | Inverse la logique de l'objet fantaisie
`WantedPatternExpectation` | Utilise une expression rationnelle Perl pour comparer une chaîne
`NoUnwantedPatternExpectation` | Passe seulement si l'expression rationnelle Perl échoue
`IsAExpectation` | Vérifie le type ou le nom de la classe uniquement
`NotAExpectation` | L'opposé de `IsAExpectation`
`MethodExistsExpectation` | Vérifie si la méthode est disponible sur un objet

La plupart utilisent la valeur attendue dans le constructeur. Les exceptions sont les vérifications sur motif, qui utilisent une expression rationnelle, ainsi que `IsAExpectation` et `NotAExpectation`, qui prennent un type ou un nom de classe comme chaîne.

# comportement Utiliser les attentes pour contrôler les bouchons serveur

Les classes attente peuvent servir à autre chose que l'envoi d'assertions depuis les objets fantaisie, afin de choisir le comportement d'un objet fantaisie ou celui d'un bouchon serveur. A chaque fois qu'une liste d'arguments est donnée, une liste d'objets d'attente peut être insérée à la place.

Mettons que nous voulons qu'un bouchon serveur d'autorisation simule une connexion réussie seulement si il reçoit un objet de session valide. Nous pouvons y arriver avec ce qui suit... Stub::generate('Authorisation'); <strong> $authorisation = new StubAuthorisation(); $authorisation->setReturnValue( 'isAllowed', true, array(new IsAExpectation('Session', 'Must be a session'))); $authorisation->setReturnValue('isAllowed', false);</strong> Le comportement par défaut du bouchon serveur est défini pour renvoyer `false` quand `isAllowed` est appelé. Lorsque nous appelons cette méthode avec un unique paramètre qui est un objet `Session`, il renverra `true`. Nous avons aussi ajouté un deuxième paramètre comme message. Il sera affiché dans le message d'erreur de l'objet fantaisie si l'attente est la cause de l'échec.

Ce niveau de sophistication est rarement utile : il n'est inclut que pour être complet.

# etendre Créer vos propres attentes

Les classes d'attentes ont une structure très simple. Tellement simple qu'il devient très simple de créer vos propres version de logique pour des tests utilisés couramment.

Par exemple voici la création d'une classe pour tester la validité d'adresses IP. Pour fonctionner correctement avec les bouchons serveurs et les objets fantaisie, cette nouvelle classe d'attente devrait étendre `SimpleExpectation`... <strong>class ValidIp extends SimpleExpectation { function test($ip) { return (ip2long($ip) != -1); } function testMessage($ip) { return "Address [$ip] should be a valid IP address"; } }</strong> Il n'y a véritablement que deux méthodes à mettre en place. La méthode `test()` devrait renvoyer un `true` si l'attente doit passer, et une erreur `false` dans le cas contraire. La méthode `testMessage()` ne devrait renvoyer que du texte utile à la compréhension du test en lui-même.

Cette classe peut désormais être employée à la place des classes d'attente précédentes.

# unitaire Sous le capot du testeur unitaire

Le framework de test unitaire SimpleTest utilise aussi dans son coeur des classes d'attente pour la classe UnitTestCase. Nous pouvons aussi tirer parti de ces mécanismes pour réutiliser nos propres classes attente à l'intérieur même des suites de test.

La méthode la plus directe est d'utiliser la méthode `SimpleTest::assertExpectation()` pour effectuer le test... <strong>class TestOfNetworking extends UnitTestCase { ... function testGetValidIp() { $server = &new Server(); $this->assertExpectation( new ValidIp(), $server->getIp(), 'Server IP address->%s'); } }</strong> C'est plutôt sale par rapport à notre syntaxe habituelle du type `assert...()`.

Pour un cas aussi simple, nous créons d'ordinaire une méthode d'assertion distincte en utilisant la classe d'attente. Supposons un instant que notre attente soit un peu plus compliquée et que par conséquent nous souhaitions la réutiliser, nous obtenons... class TestOfNetworking extends UnitTestCase { ...<strong> function assertValidIp($ip, $message = '%s') { $this->assertExpectation(new ValidIp(), $ip, $message); }</strong> function testGetValidIp() { $server = &new Server();<strong> $this->assertValidIp( $server->getIp(), 'Server IP address->%s');</strong> } } Il est peu probable que nous ayons besoin de ce niveau de contrôle sur la machinerie de test. Il est assez rare que le besoin d'une attente dépasse le stade de la reconnaissance d'un motif. De plus, les classes d'attente complexes peuvent rendre les tests difficiles à lire et à déboguer. Ces mécanismes sont véritablement là pour les auteurs de système qui étendront le framework de test pour leurs propres outils de test.

Utiliser les attentes pour des tests plus précis avec des objets fantaisie Changer le comportement d'un objet fantaisie avec des attentes Créer des attentes Par dessous SimpleTest utilise des classes d'attente
La page du projet SimpleTest sur SourceForge. La page de téléchargement de SimpleTest sur LastCraft. Les attentes imitent les contraintes dans JMock. L'API complète pour SimpleTest réalisé avec PHPDoc.
objets fantaisie, développement piloté par les tests, héritage des attentes, contraintes d'objet fantaisie, test unitaire avancé en PHP, test en premier, architecture de framework de test