Lassen Sie mich kurz mit Ihnen über Winkeltests sprechen.
Wie entwerfen Sie Ihre Winkelanwendungen so, dass sie testbar sind?
Wie entwerfen Sie die Tests für Ihre Winkelapplikation?
Wie führen Sie die Tests aus und stellen sicher, dass
Ihre Winkelanwendung alle Tests erfüllt, die Sie
geschrieben haben, selbst während Sie Ihre Winkelanwendung entwickeln?
Nun würde ich hier auch kurz über die
testgetriebene Entwicklung von Winkelapplikationen sprechen.
Interessanterweise wurde angular selbst von Grund auf gebaut, um Tests zu ermöglichen,
um Teil Ihrer Winkelapplikationsentwicklung zu sein.
Die Hauptkraft hinter eckigen Misko Hevery war selbst ein Google-Testingenieur und daher
kann sein Einfluss auf die Gestaltung von Winkeln, um von Grund auf testbar zu sein, leicht über das gesamte Framework gesehen werden.
Also, eckig selbst, wie Sie aus den vorherigen Vorträgen und Übungen verstanden haben,
ist modular in der Natur.
Die Module von eckig zusammen mit den Komponenten und
ihren Vorlagen und dann die Dienste und die Rohre und die Direktiven,
bedeuten, dass eckig sich leicht zum Testen eignet.
Da nun die Winkelanwendung selbst aus diesen verschiedenen Teilen besteht,
können Sie jedes dieser Teile zunächst isoliert testen,
noch bevor sie Teil der gesamten Winkelanwendung werden.
Der zweite Aspekt ist der Abhängigkeitsinjektionsmechanismus,
den winkelförmig nutzt, um die Kombination der verschiedenen Teile
Ihrer Winkelanwendung selbst zu unterstützen, bedeutet, dass Sie
diese Abhängigkeiten innerhalb
Ihrer verschiedenen Teile der Winkelanwendung und Durchführung von Tests.
Ich habe das Wort Mock in verwendet,
im vorherigen Satz wird kommen, um zu verstehen
, dass in ein bisschen mehr Detail und mehr, dass, später Folien.
Hier müssen wir uns
eines Ansatzes für die Anwendungsentwicklung bewusst sein, der als testgesteuerte Entwicklung bezeichnet wird.
In der testgesteuerten Entwicklung, wie Sie an dem Namen selbst verstehen können,
bedeutet, dass Sie zuerst automatisierte Tests für
alle Funktionen schreiben, die Sie innerhalb Ihrer Anwendung implementieren möchten.
Also zuerst kommt der Test,
danach schreiben Sie Ihren Anwendungscode, um den Test zu bestehen.
Der Test selbst gibt also an, welche Funktionalität Sie implementieren möchten.
Danach schreiben Sie den Code, um diese Funktionalität zu implementieren.
Da der Test bereits vorhanden ist,
können Sie testen, ob die Implementierung, die Sie durchführen, den Test erfüllt oder nicht.
Sobald Ihre Realisierung Ihrer Funktionalität den Test erfüllt,
können Sie den Code natürlich jederzeit umgestalten, um den Software-Engineering-Standards zu entsprechen.
Aber auch danach
können Sie den Code erneut testen, um sicherzustellen, dass er immer noch die
Anforderungen erfüllt, die in
diesem spezifischen Test angegeben sind, den Sie in Ihrer testgesteuerten Entwicklung verwenden.
In der Tat ist die testgesteuerte Entwicklung
ein sehr praktikabler Ansatz, um eine
gute Anwendung von Grund auf zu entwickeln, um vollständig getestet zu werden.
Jetzt, wenn wir über Testen sprechen,
können Sie Tests aus verschiedenen Aspekten nähern.
Die erste und vor allem ist, dass, wenn Ihre Anwendung
selbst als verschiedene Teile implementiert wird,
wie Komponenten, wie Dienste, wie Direktiven,
wie die Pipes, die Sie innerhalb Ihrer Anwendung implementieren.
Das bedeutet, dass Sie jede dieser einzelnen Einheiten ganz einfach isoliert testen können.
Das ist also, wo Komponententests in den Vordergrund rücken.
Komponententest bedeutet, dass Sie die einzelnen Codeeinheiten testen und
sicherstellen, dass diese bestimmte einzelne Einheit
die Funktionalität erfüllt, die sie unterstützen soll,
und dass Funktionalität und die Logik innerhalb dieses Codeabschnitts korrekt implementiert werden.
Jetzt die Einheit zu isolieren und zu testen, ist
sehr nützlich, um die meisten anfänglichen Probleme
in Ihrem Code herauszufinden und sie dann zu beheben, noch bevor Sie diesen Patch in den Code integrieren.
Sobald Sie nun beginnen, diese Teile in das Ganze
zu integrieren, wird es noch umständlicher, detaillierte Tests Ihres Codes durchführen zu können.
Daher bilden isolierte Komponententests die erste
Verteidigungslinie gegen Fehler, wenn Sie Ihre Anwendung entwickeln,
insbesondere Ihre Winkelanwendung.
Jetzt, wie wir mit einem Winkel sehen,
haben wir eine klare Trennung zwischen den Winkelkomponenten und dem DOM selbst.
So
wird in einer Komponente beispielsweise dort die Logik Ihrer Komponente vollständig in den
Typoskriptcode implementiert, den Sie innerhalb einer Komponente implementiert haben, die Typoskriptdateien enthält.
Und dann wird das DOM selbst über
die Vorlage gesteuert, die Sie für Ihre Winkelkomponente entworfen haben.
Also Beta selbst, Sie sehen die klare Trennung zwischen den beiden.
So könnten Sie einfach nur die Logik
Ihres Komponentencodes selbst testen, ohne eine vertikale Vorlage zu schreiben.
Aber dann könnten Sie auch die beiden zusammen betrachten und dann diese Aspekte bewerten.
Wie wir in der Übung sehen werden, die diesem Vortrag folgt,
werden wir beide Ansätze tatsächlich tun.
Nicht nur das, die Tatsache, dass angular
Abhängigkeitsinjektion verwendet, bedeutet, dass Sie Mock-Abhängigkeiten in Ihrer Anwendung injizieren können.
Wenn ich Mock sage, meine ich zum Beispiel,
wenn Ihre Komponente von einem bestimmten Dienst abhängig ist, können Sie immer
einen Mock-Service implementieren, der das Verhalten des Dienstes nachahmt
und dann beim Testen der Komponente ersetzt, so dass Sie
Ihre Komponente unabhängig halten können , wie der Dienst tatsächlich implementiert wird.
Solange die Schnittstelle zwischen Ihrer Komponente und dem Service richtig gestaltet ist,
können Sie einen Mock-Service ersetzen und trotzdem Ihre Komponente testen.
Dort
können Sie aus dem Mock leicht steuern, was der Komponente vom Service geliefert wird.
Dieser Ansatz ermöglicht es Ihnen, Komponententests
in Ihrer Winkelanwendung sehr detailliert durchzuführen.
Dies ist, wo die Verfügbarkeit von Test-Frameworks wie „Jasmine“.
Was Jasmine bietet, ist
ein verhaltensgesteuertes Test-Framework, das vollständig in JavaScript entwickelt wurde.
Nun ist dieses Jasmine-Framework ein allgemeines Framework, das
zum Testen von JavaScript-Anwendungen zur Verfügung steht.
Angular verwendet Jasmine als Ansatz für die Spezifikation unserer Tests für andere Winkelteile,
deren Komponenten, die Dienstleistungen und verschiedene Aspekte unserer Winkelanwendung.
Nun, in Jasmine, nutzt Jasmine zwei Dinge, die Ihnen zu Hilfe kommen.
Eine ist die Verwendung einer „beschreiben“ -Funktion.
Die Funktion „beschreiben“ ermöglicht es Ihnen, eine Reihe von Tests zu gruppieren und
diese Tests dann zusammen als eine einzelne Gruppe von Tests auszuführen.
Wenn wir den Code in der Übung schreiben, werden Sie sehen, wie ich
eine Reihe von Tests in eine beschreibende Funktion einschließt.
Dann schreiben wir unseren Code für unseren,
den Jasmin-Code, für unsere Winkeltests.
Jetzt werden Sie innerhalb dieser „beschreiben“ -Funktionen auch die sogenannten „it“ -Funktionen verwenden.
Mit den „it“ -Funktionen können Sie
individuelle Tests festlegen, die Sie für Ihre Winkelapplikation durchführen möchten.
Also, hier werden Sie sehen, wie ich „es“ angibt und dann angeben, dass
die Art des bestimmten Tests und dann
den Code für diesen bestimmten Test mit einer Funktion in „it“ entwerfen.
Wenn wir also den Code in der Übung entwerfen, achten Sie auf das „beschreiben“ und
das „es“ in Ihren Winkeltestanwendungen.
Sobald Sie den Test mit dem Jasmine-Framework entworfen haben,
ist Karma ein JavaScript-basiertes Befehlszeilentool
, mit dem Sie diese Tests automatisch durchführen können.
Jetzt, Karma zusammen mit Jasmine,
ermöglicht es Ihnen, Tests für Ihre Winkelapplikation durchzuführen.
Jetzt mit Karma, was Karma unterstützt,
ist, dass es Ihnen ermöglicht,
einen Webserver zu erzeugen, in dem Sie Ihren Anwendungsquellcode laden und
dann Karma dann einen Browser verwendet, um die tatsächlichen Tests Ihrer verschiedenen Einheiten durchzuführen.
Wenn Sie also Ihre Tests mit Karma ausführen,
werden Sie sehen, wie Karma einen Browser stapelt,
ob es sich um ein Browserfenster eines vorhandenen Browsers handelt oder
ob Sie etwas namens PhantomJS verwenden würden, das
einen Phantom-Browser hinter den Kulissen startet, um den Test durchzuführen.
Es spielt keine Rolle, aber Karma verwendet
den Browser in einem Moment, um den Test für Ihre Winkelanwendung durchzuführen.
Wie Sie in der folgenden Übung sehen werden,
ist dies, wo, wenn einer Ihrer Kollegen weiterhin darauf besteht, dass seine Implementierung
eines bestimmten Teils Ihrer Winkelanwendung
korrekt ist und den Punkt betont,
können Sie immer ein paar Tests mit Jasmine und
Karma und dann die Tests durchführen und sollten die Tests scheitern,
können Sie immer ihre Argumente widerlegen.
Dann kannst du dich umdrehen, dich
zu deinem Kollegen umdrehen und sagen,
mein Karma hat dein Dogma überwunden.
Nun, natürlich, Ihre Winkelanwendungen sind nicht vollständig frei
von der Beteiligung des Winkelrahmens selbst.
Ihre Komponente kann nicht selbst entworfen werden, ohne
viele der Bibliotheksfunktionen zu verwenden, die angular für Sie bereitstellt,
obwohl einige der grundlegenden Logik unabhängig von eckig getestet werden können.
Was wir als isolierte Tests nennen.
Aber, mehr und mehr,
Sie werden feststellen, dass, wenn Sie in,
wollen die Winkelrahmenstütze selbst
werden Sie nicht in der Lage sein, einen Großteil der Prüfung
Ihrer Winkelteile durchzuführen, ob es Komponenten oder Dienstleistungen oder Rohre oder Richtlinien.
Hier stellen die Winkel-Test-Dienstprogramme
eine Testumgebung bereit, mit der Sie
die Komponententests innerhalb Ihrer Winkelanwendung durchführen können.
Die Winkel-Test-Dienstprogramme, wie Sie mich in den Übungen
in der nächsten Übung verwenden,
werden uns bestimmte Implementierungen von Winkelfunktionen bereitstellen, die Sie
innerhalb Ihrer Tests verwenden, um die Umgebung einzurichten, in der Sie ihre Tests durchführen können.
Dies ist also, wo die Interaktion mit der Winkelumgebung,
anstatt die echten Winkelimplementierungen zu
verwenden, werden Sie diese Testdienstprogramme verwenden, die
ausreichende Funktionalität bieten, damit Sie die Tests durchführen können.
Und hier ist das TestBed, das wir
in unserer Winkelanwendung verwenden werden, sehr nützlich.
Das TestBed erstellt im Wesentlichen eine eckige Prüfung modular.
Wie Sie erkennen, existieren Ihre Komponenten nicht von selbst.
Ihre Komponenten müssen in einem NG-Modul enthalten sein.
Jetzt können Sie nicht einfach ein Standard-NG-Modul für die Durchführung Ihrer Tests verwenden.
Das TestBed,
das vom Winkel-Test-Dienstprogramm unterstützt wird,
stellt Ihnen eine NG-Modulumgebung zur Verfügung, mit der Sie ihre Komponenten testen können.
Also, innerhalb des TestBed,
werden Sie etwas namens TestBed Create Component verwenden, um
eine einzelne Komponente und eine Instanz der Komponente zu erstellen, um die Tests durchzuführen.
Und wenn Sie dies tun,
gibt Ihnen das TestBed Zugriff auf etwas namens ComponentFixture,
die ComponentFixture ist etwas, das Ihnen ein Handle bietet, mit dem Sie
Ihre Komponente mit genügend Funktionalität umgeben können, so dass die Komponente von selbst getestet werden kann.
Die Fixture bietet Zugriff auf die Komponente selbst und
dann auch durch, dass wir etwas namens DebugElement verwenden.
Sie werden sehen, wie ich das in der folgenden Übung verwende.
Das DebugElement gibt Ihnen Zugriff auf das DOM,
das ist die Vorlage, die als Teil Ihrer Komponente unterstützt wird.
So können Sie Manipulationen am DOM wie das Klicken von Elementen im DOM durchführen,
Zugriff auf ein DOM-Element erhalten und dann auslesen, was
in diesen Dom-Elementen eingeschlossen ist und so weiter, was Ihnen ermöglicht, die Tests durchzuführen.
Nun, bevor wir mit der Übung fortfahren,
möchte ich, dass Sie sich dieser Dinge bewusst sind, damit
Sie, wenn wir ihnen in der Übung selbst begegnen, sehen, warum ich jedes dieser verschiedenen Stücke verwende.