Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Web Development

Grundlegende Funktionstests mit dem Symfony 2 Crawler

by
Difficulty:BeginnerLength:LongLanguages:

German (Deutsch) translation by Katharina Nevolina (you can also view the original English article)

Das Testen Ihrer Webanwendungen ist eines der besten Dinge, die Sie tun können, um deren Gesundheit, Sicherheit und Schutz sowohl für die App als auch für die Besucher Ihrer App zu gewährleisten. Symfony 2 bietet eine vollständige Integrationstestsuite, mit der Sie sicherstellen können, dass Ihre Anwendungen wie erwartet ausgeführt werden. Heute werden wir uns ansehen, wie wir Symfony 2 und PHPUnit, das verwendete Testframework, verwenden können, um grundlegende Funktionstests mit dem Crawler zu schreiben.

Installation

Bevor wir mit Tests beginnen können, richten wir unser Projekt ein, indem wir das Symfony 2-Framework herunterladen, konfigurieren und dann auch PHPUnit herunterladen.

Installieren von Symfony 2

Der beste Weg, Symfony 2 herunterzuladen, ist die Verwendung von Composer. Wenn Sie noch nicht wissen, was Composer ist, lesen Sie unbedingt einige der fantastischen Tuts+ Artikel und Kurse, damit Sie schnell auf den neuesten Stand gebracht werden.

Wir möchten zuerst unser Terminal oder die Befehlszeilenschnittstelle öffnen, damit wir einige Composer-Befehle ausgeben können. Wechseln Sie in Ihrem Terminal in die Webroot Ihrer lokalen Entwicklung. Unter OS X ist dies für mich mein ~/Sites-Verzeichnis:

Sobald wir uns im richtigen Verzeichnis befinden, können wir jetzt mit Composer ein neues Symfony 2-Projekt erstellen, das das Framework und alle seine Abhängigkeiten herunterlädt und installiert.

Dieser Befehl weist Composer an, ein neues Projekt mit dem Symfony 2-Framework in einem neuen Verzeichnisnamen crawling/ zu erstellen. Anschließend geben wir auch die genaue Version zum Herunterladen 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.

Nach Abschluss des Downloads sollte auf Ihrem Terminal nun 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 folgt:

Configuring Crawler

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

PHPUnit installieren

Um PHPUnit herunterzuladen, können wir einen .get-Befehl in unserem Terminal verwenden, um die .phar-Datei abzurufen oder sie einfach von ihrer Website herunterzuladen. Es liegt an Ihnen:

Nachdem die .phar heruntergeladen wurde, müssen wir jetzt ihre Berechtigungen anpassen und sie an einen Ort verschieben, an dem unser Terminal oder unsere Befehlszeile und PHP Zugriff darauf haben. Auf meinem Computer mit OS X habe ich dies in mein Verzeichnis /usr/local/bin verschoben. Ich habe die Datei auch in phpunit umbenannt, damit ich mir beim Ausführen meiner Tests keine Gedanken über die Erweiterung machen muss, was mir ein wenig Zeit spart:

Wir sollten nun in der Lage sein zu überprüfen, ob PHPUnit installiert wurde und über das Terminal zugänglich ist, indem wir den Befehl phpunit ausführen. Sie sollten so etwas sehen:

Running PHPUnit

Erstellen des Crawling-Bundles

Jetzt brauchen wir ein Bundle, um unseren Anwendungs- und Testcode zu speichern. Erstellen wir eine mit der Symfony 2-Konsole in unserem Terminal:

Hier ändern wir zuerst die Verzeichnisse in unser crawling-Projekt und generieren dann mithilfe der Konsole ein neues Bundle. Wir geben auch den Hersteller und den Bundle-Namen dieses Bundles an, die durch einen Schrägstrich (/) getrennt sind. Zuletzt empfehlen wir, YAML als Format für unsere Konfiguration zu verwenden. Jetzt können Sie jedes gewünschte Format verwenden, wenn Sie YAML nicht verwenden möchten, und Sie können Ihr Bundle auch nach Belieben benennen, sofern Sie ihm zuerst einen Anbieternamen geben und Ihren Bundle-Namen mit dem Suffix Bundle beenden .

Nachdem Sie den obigen Befehl ausgeführt haben, erhalten wir erneut einen netten Assistenten, der Sie bei der Fertigstellung der Bundle-Installation unterstützt. Ich drücke einfach die Eingabetaste für jede Eingabeaufforderung, um die Standardeinstellungen zu übernehmen, da dies den gesamten Prozess schön und einfach hält und alle Pfadprobleme glättet, indem Ihre Dateien an benutzerdefinierten Speicherorten abgelegt werden. Hier ist ein Screenshot meines Bundle-Assistenten:

Creating the Crawling Bundle

So führen Sie Ihre Tests durch

Ok, wir haben Symfony 2, PHPUnit und unser Bundle. Ich denke, wir sind jetzt bereit zu lernen, wie wir unsere PHPUnit-Tests zusammen mit Symfony ausführen. Es ist eigentlich ganz einfach, ändern Sie einfach die Verzeichnisse in Ihr crawling-Projekt und geben Sie den Befehl phpunit -c app/ ein, um alle Tests Ihrer Anwendung auszuführen. Sie sollten das folgende Ergebnis in Ihrem Terminal erhalten:

Running PHPUnit Tests

Als wir unser Bundle generiert haben, hat es auch einen kleinen Beispielcode für uns generiert. Der oben ausgeführte Test ist Teil dieses Beispielcodes. Sie können sehen, dass wir einen grünen Balken haben, der uns mitteilt, dass unsere Tests bestanden wurden. Jetzt direkt über der Zeit: 1.97 Sekunden haben wir auch einen einzelnen Punkt, der uns zeigt, dass nur ein Test ausgeführt wurde. In der grünen Leiste haben wir den Status OK sowie die Anzahl der durchgeführten Tests und Zusicherungen.

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

Erstellen eines Controllers, einer Vorlage und einer Route

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

Der Controller

Beginnen wir mit dem Erstellen einer neuen Controller-Klassendatei und einer neuen Controller-Aktion. Erstellen Sie in Ihrem crawling-Projekt unter src/crawling/FtestingBundle/Controller eine neue Datei mit dem Namen CrawlingController.php und fügen Sie Folgendes ein:

In dieser Datei definieren wir lediglich unsere grundlegende Controller-Klassenstruktur, geben ihr den richtigen Namespace und enthalten die erforderliche übergeordnete Controller-Klasse.

Die Controller-Aktionen

Definieren wir nun innerhalb unserer Klasse unsere zwei einfachen Controller-Aktionen. Sie werden nur zwei verschiedene Seiten rendern: eine home-Seite und eine other-Seite:

Die Vorlagen

Jetzt müssen wir die Vorlagendateien für diese Controller-Aktionen erstellen. Erstellen Sie unter src/Crawling/Ftesting/Resources/views ein neues Verzeichnis mit dem Namen Crawling, in dem die Vorlagendateien unseres CrawlingControllers gespeichert sind. Erstellen Sie zunächst die Datei home.html.twig mit dem folgenden HTML-Code:

Dies enthält nur einige grundlegende HTML-Dateien und einen Link zur other Seite.

Erstellen Sie jetzt auch die Datei other.html.twig mit diesem HTML-Code:

Die Routen

Definieren wir abschließend für unseren Anwendungscode die Routen für diese beiden Seiten. Öffnen Sie src/Crawling/FtestingBundle/Resources/config/routing.yml und geben Sie die folgenden zwei Routen unter der standardmäßig generierten Route ein, die mit unserer Routendatei geliefert wurde:

Hier definiere ich zwei Routen, eine für jede unserer Controller-Aktionen. Wir beginnen mit dem Routennamen, den wir in Links usw. verwenden können, und geben dann den Routenpfad an, der der URI für den Zugriff auf die Seite im Browser ist, und teilen ihm dann mit, welchen Controller er ebenfalls zuordnen soll.

Denken Sie jetzt daran, dass Sie mit YAML keine Tabulatoren verwenden möchten, immer Leerzeichen verwenden oder Ihre Routen nicht funktionieren!

Mit nur diesen beiden Seiten können wir noch viel darüber lernen, wie man den Crawler von Symfony 2 verwendet, um zu testen, ob das gesamte Spektrum eines Controllers, einer Vorlage, einer Route und von Links als solche funktioniert integriertes Ganzes (ein Funktionstest) sowie sicherstellen, dass unsere Seiten die richtige HTML-Struktur anzeigen.

Funktionstest schreiben

Wir sind jetzt bereit zu lernen, wie man Funktionstests mit dem Crawler schreibt. Zuerst erstellen wir eine Testdatei.

Erstellen unserer Testdatei

Alle Ihre Tests in Symfony 2, PHPUnit-Tests werden im Verzeichnis Tests/Controller Ihres Bundles gespeichert. Jeder Controller sollte über eine eigene Controller-Testdatei verfügen, die nach der zu testenden Controller-Klasse benannt ist. Da wir einen CrawlingController haben, müssen wir eine CrawlingControllerTest.php-Datei in src / Crawling/FtestingBundle/Tests/Controller mit der folgenden Klassendefinition erstellen:

Hier benennen wir unseren Test mit einem Namespace und nehmen ihn dann in die übergeordnete WebTestCase-Klasse auf, um unsere PHPUnit-Testfunktionalität zu erhalten. Unsere Testklasse hat genau den gleichen Namen wie unser Dateiname und wir erweitern die übergeordnete WebTestCase-Klasse so, dass wir ihre Funktionen erben.

Erstellen wir nun eine Testmethode, um unsere Aussagen zu speichern, die wir zum Testen unserer Homepage machen werden. Erstellen wir in unserer Testklasse die folgende Methode:

Jedes Mal, wenn Sie eine Testmethode mit PHPUnit in Symfony 2 erstellen, wird unserem Methodennamen immer das Wort test vorangestellt. Sie können dem Methodennamen selbst einen beliebigen Namen geben, obwohl die Konvention darin besteht, ihn nach der Controller-Aktion zu benennen, die Sie testen. Hier habe ich mein testHome benannt, um dieser Konvention zu folgen.

Der Kunde

Jetzt brauchen wir innerhalb unserer Testmethode eine Möglichkeit, einen Browser zu simulieren, damit wir eine HTTP-Anfrage an eine unserer Routen senden und testen können, ob alles so funktioniert, wie wir es erwarten. Dazu erstellen wir ein Clientobjekt, indem wir eine statische createClient()-Methode aufrufen:

Wir können jetzt dieses $client-Objekt verwenden, um diese HTTP-Anforderung zu stellen und den Crawler zu verwenden.

Der Crawler

Der Crawler ist das Kernstück der Funktionstests in Symfony 2 und ermöglicht es uns, Informationen über die Seite unserer Webanwendung zu durchsuchen und zu sammeln sowie Aktionen wie das Klicken auf Links oder das Senden von Formularen auszuführen. Definieren wir unser Crawler-Objekt, indem wir eine HTTP-Anfrage über den Client stellen. Fügen Sie in Ihrer testHome-Methode das folgende Recht unter Ihrem $client-Objekt hinzu:

Dies gibt ein Crawler-Objekt zurück, um unsere Homepage zu testen. Dadurch erfahren wir beide, dass unsere Seite vorhanden ist, über den richtigen HTML-Code und die richtige Formatierung verfügt und dass Controller, Vorlage und Route alle als Einheit funktionieren.

Überschrift und Absatz testen

Um mit unseren Funktionstests zu beginnen, möchten wir sicherstellen, dass unsere Homepage die richtige Überschrift mit dem richtigen Inhalt enthält. Dazu verwenden wir unser $crawler-Objekt und seine verschiedenen Methoden. Diese Methoden geben alle ein anderes Crawler-Objekt an uns 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 Ihrer testHome-Methode den folgenden Code hinzu:

Wir beginnen mit dem Aufruf der filter()-Methode unseres $crawler-Objekts, um die Antwort der Seite zu filtern und alle h1-Elemente auszuwählen. Wir können dann andere Methodenaufrufe verketten, um unsere Auswahl noch weiter zu filtern. Hier verwende ich die eq()-Methode, die eine Indexposition des h1-Elements akzeptiert, das wir auswählen möchten. Ich habe mich für Index 0 entschieden, die erste Überschrift. Schließlich verkette ich den Textmethodenaufruf, der den Textinhalt dieses HTML-Elements zurückgibt und das Ergebnis in einer $heading-Vriablen speichert.

Nachdem wir das h1-Element gefiltert haben, auf das wir testen möchten, müssen wir nun bestätigen, dass wir das richtige Element haben. Wir tun dies mit der assertEquals() -Methode, die als erstes Argument den Wert akzeptiert, den wir für die Überschrift erwarten, und als zweites Argument den tatsächlichen Wert der zurückgegebenen Antwort, die unsere $heading selbst ist. Auf diese Weise wissen wir, dass wir auf der richtigen Seite sind, wenn der Inhalt dem entspricht, was wir erwarten.

Ausführen des Überschriften-Tests

Mit nur vier einfachen Zeilen PHP-Code können wir unseren Home-Controller, unsere Vorlage und unsere Route testen. Lassen Sie uns unseren Test ausführen, um sicherzustellen, dass er erfolgreich ist. Führen Sie in Ihrem Terminal in Ihrem crawling-Symfony-Projekt phpunit -c app/ aus. Sie sollten Folgendes sehen:

Running the Heading Test

Hier haben wir jetzt zwei Tests und zwei Behauptungen, die alle bestanden werden! Jetzt können Sie den einzelnen Absatz unter der Überschrift auf ähnliche Weise testen, diesmal verwenden wir jedoch die Methode first() wie folgt:

Wenn Sie Ihre Tests erneut ausführen, haben wir jetzt drei bestandene Aussagen. Gut gemacht!

Testen Klicken auf einen Link

Lassen Sie uns nun testen, wie Sie auf diesen Link auf dieser anderen Seite klicken. Es sollte uns auf die andere Seite führen und dort auch den richtigen Inhalt anzeigen. Fügen Sie den folgenden Code in Ihre testHome-Methode ein:

Wir beginnen damit, unsere Startseite nach a-Tags zu filtern. Wir verwenden die Filtermethode :contains(), um die a-Tags nach ihrem Inhalt zu filtern, sodass wir sicherstellen, dass der richtige Link ausgewählt wird. Wir verketten dann einfach die first() Methode, um die erste zu erhalten, und rufen die link()-Methode auf, um ein Linkobjekt zu erstellen, damit wir das Klicken mit unserem $client simulieren können.

Nachdem wir nun ein $link-Objekt haben, müssen wir darauf klicken, indem wir die click()-Methode des $client-Objekts aufrufen, das $link-Objekt an dieses übergeben und die Antwort wieder in der $otherPage-Variablen speichern. Das ist genau wie bei jedem anderen Crawler-Objekt. Die click-Methode gibt die Antwort zurück. Sehr leicht!

Und schließlich behaupten wir nur, dass der Überschriftstext unserer $otherPage dem entspricht, was wir von der Methode assertEquals() erwarten. 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 ordnungsgemäß funktioniert und wir nach dem Klicken auf der richtigen Seite sind. Hier sind meine Terminalergebnisse:

Run Your Tests One Last Time

Wir haben zwei Tests und vier Behauptungen, die alle bestanden werden. App komplett!

Schlussfolgerung

Und das ist es. Wir haben getestet, dass unser Controller, Controller-Aktionen, Vorlagen und Routen zusammenarbeiten, und wir wissen, dass HTML und Inhalt für jedes Element auf der Seite korrekt angezeigt werden und dass unser Link auf den richtigen Speicherort verweist. Gut gemacht.

Ich empfehle Ihnen jetzt, das Gelernte auszuprobieren, indem Sie die other-Seite testen, mehr HTML oder Links hinzufügen und im Allgemeinen nur ein Gefühl für die Verwendung des Crawlers bekommen, um sicherzustellen, dass Ihre Seite wie erwartet funktioniert.

Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.