Le test de vos applications Web est l’une des meilleures choses que vous puissiez faire pour en assurer la santé, la sécurité et la sûreté, à la fois pour l’application et pour les visiteurs de votre application. Symfony 2 offre une suite complète de tests d’intégration que vous pouvez utiliser pour vous assurer que vos applications fonctionnent comme vous le souhaitez. Aujourd'hui, nous verrons comment utiliser Symfony 2 et PHPUnit, le framework de test utilisé, pour rédiger des tests fonctionnels de base à l'aide du Crawler..

Installation

Avant de pouvoir commencer tout test, configurons notre projet en téléchargeant le framework Symfony 2, configurons-le, puis téléchargeons également PHPUnit.. 

Installation de Symfony 2

Le meilleur moyen de télécharger Symfony 2 est d'utiliser Composer. Si vous ne savez pas encore ce qu'est Composer, assurez-vous de commander quelques-uns des articles et des cours impressionnants de Tuts +, ils vous permettront de vous mettre rapidement au courant.. 

Nous voudrons d’abord ouvrir notre interface de terminal ou de ligne de commande afin d’émettre quelques commandes composer. Une fois dans votre terminal, changez de répertoire dans la racine Web de votre développement local. Pour moi, sous OS X, ce sera mon ~ / Sites annuaire:

cd ~ / Sites

Une fois dans le répertoire approprié, nous pouvons maintenant utiliser Composer pour créer un nouveau projet Symfony 2 qui téléchargera et installera le framework ainsi que ses dépendances.. 

composer créer projet-symfony / framework-édition standard analyse / '~ 2.5'

Cette commande indique au compositeur de créer un nouveau projet en utilisant la structure Symfony 2 dans un nouveau nom de répertoire. rampant/, et puis nous spécifions également la version exacte à télécharger, version ~ 2.5. Si c'est la première fois que vous téléchargez le framework, cela peut prendre un certain temps car il y a beaucoup de bibliothèques à télécharger pour tous les fournisseurs. Donc, vous voudrez peut-être faire une petite pause et revenir dans quelques minutes. 

Une fois le téléchargement terminé, votre terminal devrait maintenant afficher un assistant interactif qui vous aidera à configurer la configuration. C'est très explicite, entrez simplement dans vos propres informations d'identification ou prenez les valeurs par défaut comme je l'ai fait:

Une fois que vous avez entré vos informations de configuration, Symfony 2 est téléchargé, installé et prêt à être utilisé. Maintenant, nous avons juste besoin de PHPUnit pour pouvoir tester notre code.

Installer PHPUnit

Pour télécharger PHPUnit, nous pouvons utiliser une commande wget dans notre terminal pour récupérer le .phar fichier ou tout simplement le télécharger depuis leur site web, à vous de choisir:

wget https://phar.phpunit.de/phpunit.phar

Avec le .phar téléchargé, nous devons maintenant ajuster ses autorisations et le déplacer vers un emplacement où notre terminal ou notre ligne de commande et PHP y aura accès. Sur ma machine sous OS X, j'ai déplacé ceci dans mon / usr / local / bin annuaire. J'ai aussi renommé le fichier juste phpunit je n'ai donc pas à m'inquiéter de l'extension lorsque j'essaie d'exécuter mes tests, ce qui me permet de gagner un peu de temps:

chmod + x phpunit.phar sudo mv phpunit.phar / usr / local / bin / phpunit

Nous devrions maintenant être en mesure de vérifier que PHPUnit a été installé et est accessible via le terminal en exécutant la commande phpunit commander. Vous devriez voir quelque chose comme ça:

Création du paquet de balayage

Nous avons maintenant besoin d’un paquet pour contenir notre code d’application et de test. Créons-en un à l'aide de la console Symfony 2, depuis notre terminal:

cd ~ / Sites / crawling php app / console générer: bundle --namespace = Crawling / FtestingBundle --format = yml

Ici, nous changeons d’abord de répertoires dans notre rampant projet, puis utilisez la console pour générer un nouvel ensemble. Nous spécifions également le nom du fournisseur et du fournisseur de cet ensemble, séparés par une barre oblique (/). Enfin, nous lui disons d'utiliser YAML comme format de notre configuration. Maintenant, vous pouvez utiliser le format de votre choix si vous ne voulez pas utiliser YAML et vous pouvez également nommer votre offre comme vous le souhaitez, à condition de lui attribuer un nom de fournisseur et de terminer avec le suffixe. Paquet.

Après avoir exécuté la commande ci-dessus, un nouvel assistant vous aide à terminer l’installation du paquet. Je viens d'appuyer sur Entrée pour que chaque invite prenne les valeurs par défaut, ce qui simplifie et simplifie le processus et lisse les problèmes de chemin en plaçant vos fichiers dans des emplacements personnalisés. Voici une capture d'écran de mon assistant de paquet:

Comment exécuter vos tests

Ok, nous avons Symfony 2, PHPUnit et notre bundle; Je pense que nous sommes prêts à apprendre comment exécuter nos tests PHPUnit aux côtés de Symfony. C’est vraiment très facile, il suffit de changer de répertoire dans votre rampant projet et émettre le phpunit -c app / commande pour exécuter tous les tests de votre application. Vous devriez obtenir le résultat suivant dans votre terminal:

Lorsque nous avons généré notre bundle, il a également généré un petit exemple de code pour nous. Le test que vous voyez exécuté ci-dessus fait partie de cet exemple de code. Vous pouvez voir que nous avons une barre verte, nous informant que nos tests ont réussi. Maintenant juste au-dessus de la Temps: 1,97 seconde, nous avons également un seul point nous indiquant qu'un seul test a été exécuté. Dans la barre verte, nous avons notre statut de D'accord ainsi que le nombre de tests et d’affirmations effectués. 

Donc, en exécutant uniquement cette commande, nous savons que notre application Symfony 2 est installée, fonctionne correctement et testée! 

Création d'un contrôleur, d'un modèle et d'un itinéraire

Nous avons maintenant besoin de code d'application réel que nous pouvons tester. 

Le controlle

Commençons par créer un nouveau fichier de classe de contrôleur et une nouvelle action de contrôleur. À l'intérieur de votre rampant projet, sous src / Crawling / FtestingBundle / Controller, créer un nouveau fichier nommé CrawlingController.php et insérer ce qui suit:

Dans ce fichier, nous définissons simplement notre structure de classe de contrôleur de base, en lui donnant l’espace de nom approprié et en incluant les éléments nécessaires. Manette classe parent. 
Les actions du contrôleur
Dans notre classe, définissons maintenant nos deux actions simples de contrôleur. Ils vont juste rendre deux pages différentes: un maison page et un autre page:
fonction publique homeAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: home.html.twig');  fonction publique otherAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: other.html.twig'); 
Les modèles
Nous devons maintenant créer les fichiers de modèle pour ces actions de contrôleur. Sous src / Crawling / Ftesting / Ressources / vues, créer un nouveau répertoire nommé Rampant tenir notre CrawlingControllerLes fichiers modèles de. À l'intérieur, commencez par créer le home.html.twig fichier, avec le code HTML suivant à l'intérieur:
Crawling Page d'accueil
 
Voici notre page d'accueil d'exploration.
 
S'il vous plaît visitez cette autre page aussi!
Cela ne contient que du HTML de base et un lien vers le autre page.
Maintenant, allez aussi de l'avant et créez le other.html.twig fichier, avec ce code HTML à l'intérieur:
Autre page
 
Voici une autre page, qui était liée à notre page d'accueil, uniquement à des fins de test.
Les routes
Enfin, pour notre code d’application, définissons les itinéraires pour ces deux pages. S'ouvrir src / Crawling / FtestingBundle / Ressources / config / routing.yml et entrez les deux routes suivantes, sous la route générée par défaut fournie avec notre fichier de route:
crawling_home: chemin: / crawling / home par défaut: _controller: CrawlingFtestingBundle: Crawling: home crawling_other: chemin: / crawling / other par défaut: _controller: CrawlingFtestingBundle: Crawling: autre
Ici, je définis deux routes, une pour chacune de nos actions de contrôleur. Nous commençons par le nom des routes, que nous pouvons utiliser dans les liens, etc.… puis nous spécifions le chemin de la route, qui correspond à son URI, pour accéder à la page dans le navigateur, puis nous lui indiquons le contrôleur à mapper..
Maintenant, souvenez-vous avec YAML que vous ne voulez utiliser aucun onglet, utilisez toujours des espaces ou vos itinéraires ne fonctionneront pas!
Donc, avec juste ces deux pages, même avec leur base et leur statique, nous pouvons toujours apprendre beaucoup explique comment utiliser le robot d'exploration de Symfony 2 pour vérifier que tout le spectre d'un contrôleur, d'un modèle, d'une route et de liens fonctionne comme un tout intégré (test fonctionnel) et que nos pages affichent la structure HTML correcte. 
Écrire un test fonctionnel
Nous sommes maintenant prêts à commencer à apprendre à écrire des tests fonctionnels à l'aide du Crawler. Tout d'abord, nous allons créer un fichier de test.
Créer notre fichier de test
Tous vos tests dans Symfony 2, les tests PHPUnit sont stockés dans vos bundles Tests / Contrôleur répertoire Chaque contrôleur doit avoir son propre fichier de test, nommé d'après la classe de contrôleur qu'il teste. Depuis que nous avons un CrawlingController, nous devrons créer un CrawlingControllerTest.php déposer à l'intérieur src / Crawling / FtestingBundle / Tests / Contrôleur, avec la définition de classe suivante:
Ici, nous faisons un espace de noms pour notre test, puis nous l'incluons dans la classe parent WebTestCase, ce qui nous donne notre fonctionnalité de test PHPUnit. Notre classe de test porte exactement le même nom que notre nom de fichier et nous étendons la classe parent WebTestCase afin d'hériter de ses fonctionnalités..
Créons maintenant une méthode de test pour conserver nos assertions que nous allons faire pour tester notre page d’accueil. Dans notre classe de test, créons la méthode suivante:
fonction publique testHome () 
Chaque fois que vous créez une méthode de test à l'aide de PHPUnit dans Symfony 2, nous préfixons toujours notre nom de méthode par le mot test. Vous pouvez nommer le nom de la méthode à votre guise, bien que la convention préconise de lui attribuer le nom de l'action du contrôleur que vous testez. Alors ici, j'ai nommé le mien testHome suivre cette convention.
Le client
Désormais, dans notre méthode de test, nous avons besoin d’un moyen de simuler un navigateur afin que nous puissions envoyer une demande HTTP à l’une de nos routes et vérifier que tout fonctionne comme prévu. Pour ce faire, nous allons créer un objet client en appelant un objet statique. createClient () méthode:
$ client = static :: createClient ();
Nous pouvons maintenant utiliser cette $ client objet pour faire cette requête HTTP et commencer à utiliser le Crawler.
La chenille
Le Crawler est au cœur des tests fonctionnels dans Symfony 2 et nous permet de parcourir et de collecter des informations sur la page de notre application Web, ainsi que d'effectuer des actions telles que cliquer sur des liens ou soumettre des formulaires. Définissons notre objet Crawler en faisant une requête HTTP en utilisant le client. Ajouter ce qui suit juste sous votre $ client objet, dans votre testHome méthode:
$ crawler = $ client-> request ('GET', '/ crawling / home');
Cela renverra un objet Crawler pour tester notre page d'accueil. Cela nous permettra à la fois de savoir que notre page existe, qu'elle a le format HTML et le formatage correct et que le contrôleur, le modèle et la route fonctionnent tous comme une unité..  
Tester le titre et le paragraphe
Pour commencer nos tests fonctionnels, nous voulons affirmer que notre page d'accueil contient l'en-tête approprié avec le contenu approprié à l'intérieur. Nous utilisons notre $ crawler objet et ses différentes méthodes pour le faire. Ces méthodes nous renverront toutes un autre objet Crawler contenant la réponse réelle de la page testée. Nous allons ensuite tester cette réponse pour nous assurer que tout se passe comme prévu.
Ajoutez le code suivant à votre testHome méthode:
$ heading = $ crawler-> filter ('h1') -> eq (0) -> text (); $ this-> assertEquals ('Crawling Home Page', $ entête);
Nous commençons par appeler notre $ crawler objets filtre() méthode pour filtrer la réponse de la page et tout sélectionner h1 éléments. Nous pouvons ensuite chaîner sur d'autres appels de méthode pour filtrer notre sélection encore plus bas. Ici j'utilise le eq () méthode qui accepte une position d'index de l'élément h1 que nous voulons sélectionner. J'ai choisi de sélectionner l'index 0, la première rubrique. Enfin, j'enchaîne l'appel de la méthode text, qui renvoie le contenu textuel de cet élément HTML et stocke le résultat dans une variable $ cap.
Après avoir filtré l'élément h1 que nous voulons tester, nous devons maintenant affirmer que nous avons le bon élément. Nous faisons cela en utilisant le assertEquals () méthode qui accepte comme premier argument la valeur que nous attendons de l'en-tête et comme second argument, la valeur réelle de la réponse renvoyée, qui correspond à notre en-tête $ lui-même. En faisant cela, nous saurons que nous sommes sur la bonne page, si le contenu correspond à ce que nous attendons..
Exécution du test de cap
Donc, avec seulement quatre lignes simples de code PHP, nous pourrons tester notre contrôleur domestique, notre modèle et notre route. Lançons notre test pour nous assurer qu'il réussit. Dans votre terminal, depuis votre rampant Projet Symfony, lancez phpunit -c app /. Vous devriez voir ce qui suit:
Nous avons maintenant deux tests et deux affirmations, qui passent toutes! Maintenant, vous pouvez tester le paragraphe unique sous l'en-tête de la même manière, mais cette fois, nous utiliserons le premier(), méthode, comme ceci:
$ para1 = $ crawler-> filter ('p') -> premier () -> text (); $ this-> assertEquals ("Voici notre page d’accueil rampante.", $ para1);
Si vous réexécutez vos tests, nous avons maintenant trois assertions de réussite. Bon travail!
Test en cliquant sur un lien
Essayons maintenant de tester le processus consistant à cliquer sur notre lien vers cette autre page. Cela devrait nous amener à l'autre page et y afficher le contenu approprié. Insérez le code suivant dans votre testHome méthode:
$ link = $ crawler-> filter ('a: contient ("cette autre page")') -> first () -> link (); $ otherPage = $ client-> click ($ link); $ this-> assertEquals ('Autre page', $ otherPage-> filtre ('h1') -> premier () -> text ());
Nous commençons par filtrer notre page d'accueil par une Mots clés. Nous utilisons le : contient () méthode de filtrage pour filtrer la une balises par leur contenu afin que nous nous assurions de sélectionner le bon lien. Nous enchaînons alors simplement sur premier() méthode pour saisir le premier et appeler le lien() méthode pour créer un objet de lien afin que nous puissions simuler en cliquant dessus en utilisant notre $ client.
Maintenant que nous avons un $ link objet, nous devons cliquer dessus, en appelant le $ client objets Cliquez sur() méthode et passage dans le $ link objecter et stocker la réponse dans le $ otherPage variable. Comme pour tout autre objet Crawler, la méthode click renvoie la réponse. Très facile!
Et enfin, nous affirmons simplement que notre $ otherPageLe texte de l'en-tête est égal à celui auquel nous nous attendons en utilisant le assertEquals () méthode. Si c'est le cas, nous savons que notre lien fonctionne!
Exécutez vos tests une dernière fois!
Exécutons maintenant nos tests une dernière fois pour nous assurer que notre lien fonctionne correctement et que nous sommes sur la bonne page après avoir cliqué dessus. Voici mes résultats de terminal:
Nous avons deux tests et quatre assertions, qui passent tous. App complète!
Conclusion
Et c'est tout. Nous avons testé le bon fonctionnement de notre contrôleur, de ses actions, de nos modèles et de nos routes, et nous savons que le code HTML et le contenu de chaque élément s'affichent correctement sur la page, ainsi que notre lien, qui renvoie au bon emplacement. Travail bien fait.
Je vous encourage maintenant à essayer ce que vous avez appris en testant la autre page, en ajoutant plus de HTML ou de liens, et généralement en essayant de vous familiariser avec le robot pour vous assurer que votre page fonctionne comme prévu. 



		
			
	   
	




Code