Das Testen Ihrer Webanwendungen ist eine der besten Möglichkeiten, um Gesundheit, Sicherheit und Sicherheit sowohl für die App als auch für die Besucher Ihrer App sicherzustellen. Symfony 2 bietet eine vollständige Integrationstest-Suite, mit der Sie sicherstellen können, dass Ihre Anwendungen wie erwartet ausgeführt werden. Heute werden wir uns ansehen, wie wir mit Symfony 2 und PHPUnit, dem von ihm verwendeten Test-Framework, grundlegende Funktionstests mit dem Crawler schreiben können.

Installation

Bevor wir mit dem Testen beginnen können, müssen Sie zunächst das Symfony 2-Framework herunterladen, konfigurieren und dann PHPUnit herunterladen. 

Symfony installieren 2

Der beste Weg, Symfony 2 herunterzuladen, ist die Verwendung von Composer. Wenn Sie noch nicht wissen, was Composer ist, sollten Sie sich einige der großartigen Tuts + Artikel und Kurse darüber anschauen, die Sie schnell auf den neuesten Stand bringen. 

Wir wollen zuerst unsere Terminal- oder Befehlszeilenschnittstelle öffnen, damit wir einige Composer-Befehle ausgeben können. Wenn Sie sich in Ihrem Terminal befinden, wechseln Sie die Verzeichnisse in die Webroot Ihrer lokalen Entwicklung. Für mich unter OS X ist dies meine ~ / Sites Verzeichnis:

CD ~ / Sites

Wenn Sie sich im richtigen Verzeichnis befinden, können Sie jetzt mit Composer ein neues Symfony 2-Projekt erstellen, in dem das Framework und seine Abhängigkeiten heruntergeladen und installiert werden. 

Komponist Erstellung eines Projekts Symfony / Framework-Standard-Edition Crawlen / '~ 2.5'

Dieser Befehl weist Composer an, ein neues Projekt mit dem Symfony 2-Framework in einem neuen Verzeichnisnamen zu erstellen krabbeln /, und dann geben wir auch die genaue Version an, Version ~ 2,5. Wenn Sie das Framework zum ersten Mal herunterladen, kann dies eine Weile dauern, da viele Bibliotheken für alle Anbieter heruntergeladen werden müssen. Vielleicht möchten Sie eine kurze Pause einlegen und in wenigen Minuten wiederkommen. 

Nachdem der Download abgeschlossen ist, sollte jetzt auf Ihrem Terminal ein interaktiver Assistent angezeigt werden, der Sie beim Einrichten der Konfiguration unterstützt. Es ist sehr selbsterklärend. Geben Sie einfach Ihre eigenen Anmeldeinformationen ein oder übernehmen Sie die Standardeinstellungen wie ich:

Sobald Sie Ihre Konfigurationsinformationen eingegeben haben, wird Symfony 2 heruntergeladen, installiert und kann verwendet werden. Jetzt brauchen wir nur noch PHPUnit, um unseren Code testen zu können.

PHPUnit installieren

Um PHPUnit herunterzuladen, können wir einen Wget-Befehl in unserem Terminal verwenden, um die .Phar Datei herunterladen oder einfach von ihrer Website herunterladen, es liegt an Ihnen:

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

Mit dem .Phar heruntergeladen, müssen wir nun die Berechtigungen anpassen und an einen Ort verschieben, an dem sich unser Terminal oder die Befehlszeile befindet und PHP wird darauf Zugriff haben. Auf meinem Rechner mit OS X habe ich diesen in meinen verschoben / usr / local / bin Verzeichnis. Ich habe die Datei auch umbenannt, um nur zu sein phpunit Ich muss mir also keine Gedanken um die Erweiterung machen, wenn ich meine Tests ausführen möchte, was mir etwas Zeit spart:

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

Wir sollten jetzt in der Lage sein, zu überprüfen, ob PHPUnit installiert wurde und über das Terminal erreichbar ist, indem Sie das ausführen phpunit Befehl. Sie sollten so etwas sehen:

Das Crawling-Bundle erstellen

Jetzt brauchen wir ein Paket, in dem sich unsere Anwendung und der Testcode befinden. Lassen Sie uns aus unserem Terminal heraus eine Konsole von Symfony 2 erstellen:

cd ~ / sites / crawling php app / console generate: bundle --namespace = Crawling / FtestingBundle --format = yml

Hier wechseln wir zunächst in unser Verzeichnis krabbeln Projekt und verwenden Sie die Konsole, um ein neues Bundle zu erstellen. Wir geben auch den Namen des Herstellers und des Pakets an, getrennt durch einen Schrägstrich (/). Schließlich sagen wir ihm, YAML als Format für unsere Konfiguration zu verwenden. Jetzt können Sie das gewünschte Format verwenden, wenn Sie YAML nicht verwenden möchten, und Sie können Ihr Bundle auch so benennen, wie Sie es möchten, solange Sie ihm zunächst einen Herstellernamen geben und den Namen Ihres Bundles mit dem Suffix abschließen Bündeln.

Nachdem Sie den obigen Befehl ausgeführt haben, erhalten Sie erneut einen schönen Assistenten, der die Installation des Bundles abschließt. Ich drücke einfach bei jeder Eingabeaufforderung die Eingabetaste, um die Standardeinstellungen zu übernehmen, da dies den gesamten Prozess angenehm und einfach macht und alle Pfadprobleme beseitigt, indem Ihre Dateien an benutzerdefinierten Speicherorten abgelegt werden. Hier ist ein Screenshot meines Bundle-Assistenten:

So führen Sie Ihre Tests durch

Ok, wir haben Symfony 2, PHPUnit und unser Bundle. Ich denke, wir können jetzt lernen, wie wir unsere PHPUnit-Tests neben Symfony ausführen. Es ist eigentlich ganz einfach. Wechseln Sie einfach Ihre Verzeichnisse krabbeln projektieren und ausgeben phpunit -c app / Befehl, um alle Tests Ihrer Anwendung auszuführen. Sie sollten das folgende Ergebnis in Ihrem Terminal erhalten:

Bei der Erstellung unseres Bundles wurde auch ein kleiner Beispielcode für uns generiert. Der oben ausgeführte Test ist Teil dieses Beispielcodes. Sie sehen, dass wir einen grünen Balken haben, der uns mitteilt, dass unsere Tests bestanden wurden. Jetzt direkt über dem Zeit: 1,97 Sekunden, Wir haben auch einen Punkt, der uns zeigt, dass nur ein Test durchgeführt wurde. In der grünen Leiste haben wir unseren Status OK sowie wie viele Tests und Assertions durchgeführt wurden. 

Wenn Sie nur diesen einen Befehl ausführen, wissen wir, dass unsere Symfony 2-App installiert ist, ordnungsgemäß ausgeführt und getestet wurde! 

Controller, Vorlage und Route erstellen

Wir benötigen jetzt einen tatsächlichen Anwendungscode, den wir testen können. 

Der Controller

Beginnen wir mit dem Erstellen einer neuen Controller-Klassendatei und einer Controller-Aktion. In deinem krabbeln Projekt unter src / Crawling / FtestingBundle / Controller, Erstellen Sie eine neue Datei mit dem Namen CrawlingController.php und füge folgendes ein:

In dieser Datei definieren wir nur unsere grundlegende Controller-Klassenstruktur, geben den richtigen Namespace an und fügen die erforderlichen ein Regler übergeordnete Klasse. 
Die Controller-Aktionen
In unserer Klasse definieren wir nun unsere zwei einfachen Controller-Aktionen. Sie werden nur zwei verschiedene Seiten darstellen: a Zuhause Seite und ein andere Seite:
public function homeAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: home.html.twig');  public function otherAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: other.html.twig'); 
Die Vorlagen
Jetzt müssen wir die Vorlagendateien für diese Controller-Aktionen erstellen. Unter src / Crawling / Ftesting / Ressourcen / Ansichten, Erstellen Sie ein neues Verzeichnis mit dem Namen Krabbeln halten unsere CrawlingControllerVorlagendateien. Im Inneren erst das erstellen home.html.twig Datei mit folgendem HTML-Code:
Kriechende Startseite
 
Hier ist unsere Crawler-Homepage.
 
Bitte besuchen Sie auch diese andere Seite!
Dieses enthält nur ein paar grundlegende HTML-Codes und einen Link zum andere Seite.
Nun auch loslegen und das erstellen other.html.twig Datei mit diesem HTML-Code:
Andere Seite
 
Hier ist eine andere Seite, die zu Testzwecken von unserer Homepage aus verlinkt wurde.
Die Wege
Als letztes definieren wir für unseren Anwendungscode die Routen für diese beiden Seiten. Aufmachen src / Crawling / FtestingBundle / Resources / config / routing.yml und geben Sie auf den beiden folgenden Routen unter der standardmäßig generierten Route ein, die mit unserer Routendatei geliefert wurde:
crawling_home: Pfad: / crawling / home-Standardwerte: _controller: CrawlingFtestingBundle: Crawling: home crawling_other: Pfad: / crawling / andere Standardwerte: _controller: CrawlingFtestingBundle: andere
Hier definiere ich zwei Routen, eine für jede unserer Controller-Aktionen. Wir beginnen mit dem Routennamen, den wir für Verknüpfungen usw. verwenden können, und geben dann den Routenpfad an, dessen URI für den Zugriff auf die Seite im Browser. Dann geben wir an, welcher Controller ebenfalls zugeordnet werden soll.
Denken Sie jetzt daran, dass Sie mit YAML keine Tabs verwenden möchten, immer Leerzeichen verwenden, da sonst Ihre Routen nicht funktionieren!
Mit nur diesen beiden Seiten können wir, obwohl sie so grundlegend und statisch sind, immer noch lernen viel Wie Sie den Crawler von Symfony 2 verwenden, um zu testen, ob das gesamte Spektrum eines Controllers, einer Vorlage, einer Route und einer Verknüpfung als integriertes Ganzes funktioniert (ein Funktionstest), und sicherstellen, dass unsere Seiten die korrekte HTML-Struktur anzeigen. 
Einen Funktionstest schreiben
Jetzt können Sie lernen, wie Sie mit dem Crawler Funktionstests schreiben. Zuerst erstellen wir eine Testdatei.
Unsere Testdatei erstellen
Alle Ihre Tests in Symfony 2-, PHPUnit-Tests werden in Ihrem Bundle gespeichert Tests / Controller Verzeichnis Jeder Controller sollte über eine eigene Controller-Testdatei verfügen, die nach der getesteten Controller-Klasse benannt ist. Da haben wir eine CrawlingController, wir müssen eine erstellen CrawlingControllerTest.php Datei innen src / Crawling / FtestingBundle / Tests / Controller, mit folgender Klassendefinition:
Hier geben wir unseren Namespace an und fügen ihn in die übergeordnete WebTestCase-Klasse ein, wodurch wir unsere PHPUnit-Testfunktionalität erhalten. Unsere Testklasse hat genau denselben Namen wie unser Dateiname, und wir erweitern die übergeordnete WebTestCase-Klasse, sodass wir deren Funktionen übernehmen.
Lassen Sie uns nun eine Testmethode erstellen, um unsere Aussagen zu untermauern, die wir zum Testen unserer Homepage machen werden. In unserer Testklasse erstellen wir die folgende Methode:
öffentliche Funktion testHome () 
Jedes Mal, wenn Sie in Symfony 2 eine Testmethode mit PHPUnit erstellen, setzen wir unserem Methodennamen immer das Wort test voran. Sie können dem Methodennamen selbst einen beliebigen Namen geben, obwohl er üblicherweise nach der Controller-Aktion benannt wird, die Sie testen. Also hier habe ich meine genannt testHome dieser Konvention folgen.
Der Kunde
Innerhalb unserer Testmethode benötigen wir nun eine Möglichkeit, einen Browser zu simulieren, damit wir eine HTTP-Anforderung an eine unserer Routen absetzen und testen können, ob alles so funktioniert, wie wir es erwarten. Dazu erstellen wir ein Client-Objekt, indem wir eine Statik aufrufen createClient () Methode:
$ client = static :: createClient ();
Wir können das jetzt verwenden $ client Objekt, um diese HTTP-Anforderung auszuführen und den Crawler zu verwenden.
Der Crawler
Der Crawler ist der Kern des Funktionstests in Symfony 2 und ermöglicht uns das Durchsuchen und Sammeln von Informationen über die Seite unserer Webanwendung sowie das Durchführen von Aktionen wie das Klicken auf Links oder das Senden von Formularen. Definieren Sie unser Crawler-Objekt, indem Sie eine HTTP-Anfrage mit dem Client erstellen. Fügen Sie das folgende Recht unter Ihrem hinzu $ client Objekt, in Ihrem testHome Methode:
$ crawler = $ client-> request ('GET', '/ crawling / home');
Dadurch wird ein Crawler-Objekt zurückgegeben, um unsere Homepage zu testen. Dies lässt uns wissen, dass unsere Seite existiert, dass sie die richtige HTML-Formatierung und Formatierung hat und dass Controller, Vorlage und Route alle als Einheit funktionieren.  
Prüfung der Überschrift und des Absatzes
Zu Beginn unserer Funktionstests möchten wir darauf hinweisen, dass auf unserer Homepage die richtige Überschrift mit dem richtigen Inhalt enthalten ist. Wir benutzen unsere $ Crawler Objekt und seine verschiedenen Methoden, um dies zu tun. Diese Methoden geben alle ein anderes Crawler-Objekt zurück, das die Antwort der tatsächlich getesteten Seite enthält. Wir werden diese Antwort dann testen, um sicherzustellen, dass alles wie erwartet ist.
Fügen Sie folgenden Code hinzu testHome Methode:
$ head = $ crawler-> filter ('h1') -> eq (0) -> text (); $ this-> assertEquals ('Crawling Homepage', $ Überschrift);
Wir beginnen mit dem Aufruf unserer $ Crawler Objekt ist Filter() Methode, um die Antwort der Seite zu filtern und alle auszuwählen h1 Elemente. Wir können dann andere Methodenaufrufe verketten, um unsere Auswahl noch weiter zu filtern. Hier benutze ich die eq () Methode, die eine Indexposition des h1-Elements akzeptiert, das Sie auswählen möchten. Ich habe mich für den Index entschieden 0, die erste Überschrift Zum Schluss kette ich den Aufruf der Textmethode, der den Textinhalt dieses HTML-Elements zurückgibt und das Ergebnis in einer $ überschreibenden Variable speichert.
Nachdem wir das h1-Element gefiltert haben, auf das wir testen möchten, müssen wir nun behaupten, dass wir das richtige Element haben. Wir machen das mit dem assertEquals () Diese Methode akzeptiert als erstes Argument den Wert, den wir für die Überschrift erwarten, und als zweites Argument den tatsächlichen Wert der zurückgegebenen Antwort. Dies ist unsere $ -Überschrift selbst. Auf diese Weise wissen wir, dass wir uns auf der richtigen Seite befinden, wenn der Inhalt dem entspricht, was wir erwarten.
Führen Sie den Heading-Test durch
Mit nur vier einfachen Zeilen PHP-Code können wir unseren Heimcontroller, die Vorlage und die Route testen. Lassen Sie uns unseren Test durchführen, um sicherzustellen, dass er erfolgreich ist. In Ihrem Terminal aus Ihrem krabbeln Symfony-Projekt ausführen phpunit -c app /. Sie sollten Folgendes sehen:
Hier haben wir jetzt zwei Tests und zwei Behauptungen, die alle bestanden haben! Auf ähnliche Weise können Sie jetzt den einzelnen Absatz unterhalb der Überschrift testen, diesmal verwenden wir jedoch die zuerst(), Methode wie folgt:
$ para1 = $ crawler-> filter ('p') -> first () -> text (); $ this-> assertEquals ("Hier ist unsere Crawler-Homepage.", $ para1);
Wenn Sie Ihre Tests erneut durchführen, haben wir jetzt drei Pass-Assertions. Gut gemacht!
Testen Klicken Sie auf einen Link
Versuchen wir nun, den Vorgang des Klickens auf diese andere Seite zu testen. Es sollte uns auf die andere Seite bringen und dort auch den richtigen Inhalt anzeigen. Fügen Sie den folgenden Code in Ihr ein testHome Methode:
$ link = $ crawler-> filter ('a: enthält ("diese andere Seite")') -> first () -> link (); $ otherPage = $ client-> click ($ link); $ this-> assertEquals ('Other Page', $ otherPage-> filter ('h1') -> first () -> text ());
Wir beginnen mit dem Filtern unserer Homepage nach ein Stichworte. Wir nehmen das : enthält () Filtermethode zum Filtern der ein Tags nach ihrem Inhalt, so dass wir den richtigen Link auswählen. Wir ketten dann einfach an zuerst() Methode, um die erste zu ergreifen und die Verknüpfung() Methode, um ein Link-Objekt zu erstellen, mit dem wir das Klicken mit unserem simulieren können $ client.
Jetzt haben wir eine $ link Objekt müssen wir darauf klicken, indem Sie die $ client Objekt ist klicken() Methode und Übergabe in der $ link dagegen ablehnen und die Antwort zurück in die $ otherPage Variable. Dies ist wie bei jedem anderen Crawler-Objekt. Die Click-Methode gibt die Antwort zurück. Sehr leicht!
Und schließlich behaupten wir nur, dass unser $ otherPageDer Überschriftentext entspricht dem von uns erwarteten assertEquals () Methode. Wenn ja, wissen wir, dass unser Link funktioniert!
Führen Sie Ihre Tests ein letztes Mal durch!
Lassen Sie uns nun unsere Tests ein letztes Mal ausführen, um sicherzustellen, dass unser Link korrekt funktioniert und wir auf der richtigen Seite sind, nachdem Sie darauf geklickt haben. Hier sind meine Terminal-Ergebnisse:
Wir haben zwei Tests und vier Behauptungen, die alle bestanden haben. App abgeschlossen!
Fazit
Und das ist es. Wir haben getestet, dass alle Controller, Controller-Aktionen, Vorlagen und Routen zusammenarbeiten, und wir wissen, dass der HTML-Code und der Inhalt für jedes Element ordnungsgemäß auf der Seite angezeigt werden und dass unser Link auf den richtigen Speicherort verweist. Gut gemacht.
Ich möchte Sie jetzt dazu ermutigen, das Erprobte auszuprobieren andere Hinzufügen von mehr HTML oder Links und generell ein Gefühl für die Verwendung des Crawlers, um sicherzustellen, dass Ihre Seite wie erwartet funktioniert. 



		
			
	   
	




Code