Transkripte
1. Willkommen zu diesem Kurs!: Hallo Leute und willkommen
zu diesem Kurs Java-Unit-Test-Framework, Mockito. Mein Name ist Elks und ich bin ein
Software-Ingenieur, der dieses
Framework seit geraumer Zeit in meinem Codierungs-Workflow verwendet, als ich von der Möglichkeit
hörte, einen Kurs
zu erstellen , um mehr über seine zu erklären
nutzen und auch Vorteile. Ich war sehr begierig darauf
, einen zu entwickeln. Dieser Kurs wird
in 11 Lektionen strukturiert, die
praktische Schritte für Sie
anpingen
können , um genau zu verstehen, was mit Mockito gemacht werden kann Ich werde Ihnen zuerst
zeigen, wie Sie
einen Einheimischen einrichten Umgebung auf Ihrem
Computer mit Mockito drauf. Dann werden wir uns alle Möglichkeiten
genauer
ansehen , wie diese beiden
Komponententests für uns erleichtern. Dinge wie Gewürz,
Argumentabtreter, die Funktionen in Reihenfolge und
Verifizierung, Angabe von Rückgabewerten
für Methoden und so weiter. Wenn Sie daran interessiert sind, sich
im
Komponententest in Java zu verbessern, ist
dieser Kurs genau das Richtige für Sie. Es gibt keine anderen
Voraussetzungen als einen Computer mit einer
Internetverbindung. das Projekt
dieser Klasse betrifft, wird
es äußerst
praktisch sein und Sie müssen die Schritte befolgen, die diesem Kurs
vorgestellt werden. So können Sie auf
Ihrer Reise beginnen,
Komponententests für den Code zu schreiben , den
Sie mit Java entwickeln. Wir dachten, wir sagten, ich glaube, wir
sehen uns bereits in der ersten Lektion.
2. Installieren des JDK: Leute, willkommen nochmal
in diesem Tutorial. In diesem Tutorial werden
wir natürlich
anfangen zu lernen,
indem wir unsere Umgebung auf unserer lokalen Maschine
vorbereiten. Als Framework, dass
es Java-Code verwendet, müssen
wir natürlich sicherstellen, dass
das JDK auf
unserem lokalen Computer installiert ist. BIP stammt also aus dem Java SDK. Sdk stammt aus dem
Softwareentwicklungskit. Für dieses Tutorial. Wir werden die Version von
einem Punkt Punkt 01 für Java 16
verwenden . Zuallererst
müssen Sie sicherstellen, dass Sie diese JDK auf Ihrem Computer
installiert haben. Jetzt habe ich einen
Windows-Computer hier. Wie würden Sie überprüfen, ob
Sie dieses JDK bereits auf Ihrem Computer
installiert haben oder nicht haben,
Sie müssen nur Ihren CMD ausführen. Also deine Eingabeaufforderung
mit Administration und schreibe dann in jede
Java-Dash-Version. Wie Sie sehen können, habe ich es nicht
installiert. Und das, was
auf meinen Bildschirm bringt, ist, dass Java nicht als interner
oder externer Befehl
erkannt
wird, nicht installiert ist. Auf diese Weise können Sie bestätigen , dass Sie es nicht installiert
haben. Wenn es installiert worden wäre, wäre
die Nachricht so etwas wie Java-Version und dann
wird sie Ihnen die Version dann einige andere
landwirtschaftliche Nachrichten mitteilen. Aber jetzt, da wir wissen, dass
wir es nicht installiert haben, werden
wir es mit
dem Image speichern. Wenn Sie es bereits installiert
haben, können
Sie dem nächsten Schritt in wenigen Minuten fortfahren
. Aber im Moment, wie würdest du es
installieren, zu dem Link
zu gehen , den ich auf
diesem Bildschirm hier bereitgestellt habe, und das sind oracle.com,
Java-Technologien. Java SE lädt den HTML-Code herunter. Das können Sie sehen, dass wir hier den Java SE
Download-Job haben, ich sehe 16. Und wir können unter dem
Oracle JDK auf den JDK-Download klicken. Jetzt wird es uns zum
Java Development Kit 60 umleiten. Sie sehen also Java SDK und scrollen
dann nach unten, Sie können die Version
für Ihr
Betriebssystem auswählen , in meinem Fall ist es ein Windows 64-Beats, also ist es die Version genau hier. Ich wähle direkt
die ausführbaren Dateien damit wir die Vereinbarung
überprüfen und dann auf Download klicken können. Sie können sehen, dass die ausführbare gerade
heruntergeladen
wird. In nur wenigen Sekunden
ist es erledigt, damit wir auf den Nagel klicken
können. Und wie Sie sehen können, dass Sie diese Installation
starten, willkommen bei der Installation. Wir können auf Weiter klicken. Nun, das Standardbad, in dem
es installiert werden würde. Und ich schlage vor, dass Sie
es verlassen SEC ist C Program Files ,
Java, Dish und dann
die JDK-Version davon. Der Grund, warum ich Ihnen sage, es so
belassen sollen,
liegt darin, dass wir später einige
Variablen der Umgebung festlegen
werden . Die Spezifikation. Und wenn Sie es ändern, müssen
Sie sich daran
erinnern, dass Beth die beiden
geändert hat und es
möglicherweise im
Notepad-Dokument basiert. Aber im Moment können wir einfach
weitermachen und auf Weiter klicken. Und wie Sie sehen können,
wird es im Grunde genommen GDK
installieren, dass es
vollständig installiert wurde. Wir können es schließen. Und einfach so ist
der erste Schritt dieses Tutorials erledigt. Im zweiten Schritt müssen
wir, wie gesagt, eine
Umgebungsvariable festlegen, genauer gesagt die Umgebungsvariable Java
Home. Und wir müssen es auf
das Bad hinweisen , wo wir diese JDK
stoppen. Um dies zu tun, müssen Sie zur Schaltfläche Suchen
gehen und
dann die Systemumgebungsvariablen schreiben. Klicken Sie auf Enter. Dann hier zu
Umgebungsvariablen. Dann können wir auf Neu klicken. Dann haben wir den Variablennamen
, der Java unter Home
sein wird, und dann das Suchverzeichnis. Und dann
geht das Verzeichnis zu BSA sagte Local Disk C Program Files, und dann natürlich Java, und dann dieses JDK für
die Schulden, es hat uns erwischt. Das wird also in Ordnung sein. Und wie Sie hier sehen können, wird jetzt
die
Systemvariable Java Home hinzugefügt und der Wert davon
ist der eigentliche Beth. Jetzt können wir, abgesehen davon, dass
wir die
Systemvariable von Java Home mit dem Wert des
Pfades hier bei bat hinzufügen, dem Wert des
Pfades hier bei bat hinzufügen, dies bearbeiten
und auch neue hinzufügen müssen. Und dann müssen wir Grafiken für die Bin-Ordner-Schulden
mit edit hier machen. Und wie Sie sehen können, der Java JDK und
dieser Ordner, der
direkt hier war , nachdem ich erreicht habe, meinen Computer
gestartet. Denn wenn Sie es
nicht neu starten, können
Sie nicht sehen,
dass das Java installiert wenn Sie es neu starten und die Java-Dash-Version
eingeben.
Sie können sehen, dass es
Ihnen tatsächlich einige Informationen über die Attribute und insbesondere die
Tatsache, dass das JDK erfolgreich
auf Ihrem Computer
installiert wurde. Wieder einmal habe ich die
Systemvariablen im
Java-Unterstrich hinzugefügt , die
auf den Pfad eingestellt wurden, in
dem der GDK installiert wurde,
und ich habe es hinten hinzugefügt. Benutzervariablen für Ihren Benutzer, klicken Sie
darauf, klicken Sie auf Bearbeiten und
dann neuen Browser
und dann den bin-Ordner von
JDK Installation Breath. Wenn Sie dies nach
der Installation des JDK tun , das Sie über diesen Link
erhalten, werden
Sie
das JDK
erfolgreich auf Ihrem Computer installiert das JDK
erfolgreich auf Ihrem Computer und die
ersten beiden Schritte ausführen. Vorerst. Es ging um den Enter. Ich danke euch
sehr, dass du bis zum Ende
dieser Vorlesung bei
mir geblieben bist.
3. Installieren von IntelliJ IDEA: Hallo Leute und willkommen
zurück zum Tutorial. Für dieses Tutorial müssen wir offensichtlich eine IDE haben
, in der wir Code springen können. Und dafür werden wir die IntelliJ-Ideen-IDE
verwenden, die meiner Meinung nach die beste
IDE für Java ist. Aber wir können einfach
anfangen, für
Intelligent zu wachsen und dann auf
die Website Download on
JetBrains klicken . Dies leitet Sie zum
Download der Intel G Idee weiter. Jetzt werden wir natürlich die Community-Version
verwenden. Nicht das ultimative ist, keinen Code für das Unternehmen
zu schreiben. Wir werden diese einfach bequem
von zu Hause aus nutzen . Aber wenn Sie
das mit allen Mitteln tun möchten, wenn Sie ein Unternehmen
oder ähnliches haben, können
Sie sich für das ultimative entscheiden. Es ist nur so, dass
wir für
dieses Tutorial mit
dem Windows Dot EXE gehen werden. Und wie Sie sehen können, hat der
Download im Grunde genommen begonnen. Ich werde mich wieder bei
euch melden, sobald es fertig ist. Okay, also bin ich zurück,
dass Intel Beads
heruntergeladen hat und jetzt, wenn wir auf diese ausführbare Datei
klicken, werden
wir von
einem Installationsprozess begrüßt. Sie können sehen, dass das Setup-Wochenende
einfach mit der Installation fortgesetzt wird. Es isst unseren
Standardzielordner im Laufwerk C. Der 64-Bit-Längengrad
ist das, was
Sie hier auswählen müssen. Dann verknüpfen wir
die Java-Dateien damit. Dann können wir
das Kontextmenü aktualisieren das Projekt „Ordner öffnen ist“
bearbeiten. Die
Launcher-Verzeichnisse zum Bett. Ich glaube nicht, dass das
notwendig ist, dass wir Dinge aus
der eigentlichen Anwendung öffnen , damit
wir auf
Weiter klicken und dann installieren können . Nachdem es installiert wurde, werden
Sie
mit diesem letzten Fenster begrüßt. Und Sie können
sich entscheiden, Intel J auszuführen, nachdem Installation
abgeschlossen und wir können auf Schulden klicken. Wir haben bestätigt, dass wir Weiter
gelesen und auf „Weiter“ klicken. Sie können sehen,
dass sich die Intel G ID gerade öffnen wird. Und es wird uns auffordern, ein
Projekt zu eröffnen oder ein neues zu erstellen. Und dann natürlich einige Plug-Ins in das
Anpassungsfenster zu Farbthemen
und ähnlichem. Es ging also darum
mit der Installation von GID für den Job , den wir in diesem Tutorial
verwenden werden. Es ist ein ziemlich einfaches und
geradliniges WordPress ist, aber ich dachte, ich sollte das Tutorial dazu machen,
nur um sicherzustellen , dass ihr
euch bewusst seid,
wie du aufstehen wirst . Hoffentlich hast du etwas
aus diesem Tutorial herausgeholt
und ich freue mich sehr darauf, dich im nächsten zu
sehen. Vielen Dank, dass Sie bis
zum Ende
dieser Vorlesung bei
mir geblieben sind.
4. Was ist Mocking?: Hallo Leute und willkommen zurück zu diesem Mockito-Tutorial, in dem wir verstehen, wie wir mit diesem Test-Framework gegen
unsere
Java-Methoden besser
können . In diesem Vortrag
werden wir einen Einblick in einige theoretische
Vorstellungen über Spott werfen. Kurz bevor wir tief in
das
Mockito-Test-Framework eintauchen und verstehen, wie wir Code schreiben können, um unsere Methoden zu
testen. Wir werden
ein paar grundlegende Dinge behandeln ,
wie das, was Spott ist, was markiert werden sollte, verschiedene Arten von Markierungen
und so etwas. Nur damit wir gute Kenntnisse über sie haben
können ,
bevor wir sie anwenden. Wir verstehen den Prozess
, zu
dem wir gehen werden , wo wir den
tatsächlichen Code in unsere IDs schreiben werden. Einfach ausgedrückt bezieht sich
der Markierungsprozess
auf die Bereitstellung von Kontrolle, Instanz oder Implementierung oder
sogar Abhängigkeit, von der der zu
testende Code abhängt. Um
jede Kernlogik zu testen. Im Falle unserer ersten
Mockito-Bewerbung, die sich der Lehrstuhl
in der nächsten Vorlesung
des Abschnitts ansieht in der nächsten Vorlesung
des Abschnitts bevor wir auf
detailliertere Funktionen von Mockito eingehen, werde
ich Ihnen
ein Basic vorstellen Anwendung unter Verwendung von Mockito und im Schuldenantrag. Die Methode,
auf die
in einer Funktion, die wir testen
möchten, referenziert wird, wird verspottet und wird
dazu aufgefordert einen bestimmten
Wert
zurückzugeben, den wir wünschen. Dies ist also die
Praxis des Markierens. Diese Markierungen werden
in Situationen gerettet, in denen Sie,
egal ob Sie Abhängigkeit
haben und
trainieren oder nicht, Ihre Geschäftslogik immer mit einer programmierten Antwort für die Abhängigkeit, die aus dem zu testenden Code
aufgerufen wird . Wenn Sie jemals gehört bezieht sich
das dritte Test-Double
im Wesentlichen auf ein Objekt, das durch
eine äquivalente Baum- oder
Objektinstanz oder Abhängigkeit ersetzt wird . Es gibt zwei
Hauptvorteile, warum die Mocking-Prozesse
beim Testen unseres Codes nützlich sind. Sie können sich diese als
die Basispfeiler vorstellen , auf die wir die Verwendung unserer
Komponententests stützen. Der erste Vorteil ist die Effizienz, die der
Rauchprozess mit sich bringt. Denn beim Verspotten
sind wir sicher, dass nur unser Code ausgeführt
wird. Wenn sie getestet werden. Alle anderen Abhängigkeiten
werden hart codierte,
verspottete Werte haben , die von
uns angegeben werden, und dieser Code wird
nicht wirklich ausgeführt. Der andere
Grund liegt in der genauen Kontrolle, die wir alle anderen Komponenten
haben
, die unsere Test-IF-Funktion benötigt. Dies kann zu einer Trennung führen
, die sehr vorteilhaft ist. helfen uns
auf diese Weise schnell zu sehen ob die Funktion, die
wir testen möchten AES-128
verhält oder nicht als
die Teile,
die im Prozess verwendet werden , die nicht wirklich Teil der Funktion sind
, die wir möchten testen. Wir haben Werte festgelegt, die von uns gekennzeichnet
werden. Wir werden bereits wissen, wie die
Rückkehr und wie sie sich verhalten. Und wir schränken unsere Tests nur ein. Die Funktion, die wir
tatsächlich testen wollten. Es gibt verschiedene Arten
von Test-Doppel oder -markierungen. Und wir werden jeden einzelnen von ihnen
durchlaufen damit Sie ihre Klassifizierung besser verstehen können. Und
wenn Sie in einer zukünftigen Vorlesung einen dieser Namen sehen, werden
Sie
damit vertraut sein und schnell
verstehen und
einen Bezugspunkt dafür haben einen Bezugspunkt ,
was genau diese Art
von diesen Doppel-Es ist. Zuallererst haben wir die Fälschungen. Die Fälschungen funktionieren
Implementierung, die einer echten Abhängigkeit ziemlich ähnlich
ist, mit Ausnahme der Tatsache, dass
sie sich auf
dem lokalen Computer befindet , auf dem der zu
testende Code tatsächlich bleibt. Hier sind das am häufigsten
verwendete Beispiel und
das Szenario, in dem wir
Fälschungen sind, am nützlichsten. Im Umgang mit der
Beharrlichkeit von Theta. Im Umgang mit Datenbanken. Und anstatt eine
echte Produktionsdatenbank anzupassen, verwendet
Test eine einfache Sammlung oder einen In-Memory zum Speichern von Daten. Und warum das sehr nützlich ist,
liegt daran, dass Sie möglicherweise nicht möchten, dass
für jeden Test, den
Sie durchführen einige Zeilen in der
tatsächlichen Produktionsdatenbank
füllen. Oder sogar Sie haben eine
Testdatenbank. Vielleicht möchten Sie es nicht
bevölkern, weil
es Probleme geben kann, wenn wir das tun. Der erste wäre, dass
Daniel es löschen muss. zweite wäre die
Zeit und Effizienz, die diese
beiden Operationen verschwendet
wird. Selbst wenn man sagt, dass die Datenbank nicht einmal eine Tiefe
hat, die Sie testen möchten. Wir möchten eine Methode testen, die die eigentliche Datenbank
aufruft. Sie wollten sehen,
wie sich die Funktion verhält und nicht, ob der Aufruf der Datenbank
tatsächlich funktioniert
, dies sollte in einer anderen Klasse sein. Wenn Sie eine gute
Trennung in Ihrem Projekt haben. Und diese Klasse sollte im Projekt
der Repositorys sein, wo die Mitarbeiter in Bezug auf
die Datenbank immer noch optimiert werden. Welche Fälschungen werden die
meiste Zeit verwendet. Sie sind
aus dieser Perspektive sehr wichtig. Als nächstes haben wir die Stubs. Und diese Dinge sind nur
vorkonfigurierte Antworten, wenn eine Abhängigkeit von
dem System aufgerufen wird , das diese 100 testet. Jetzt, abgesehen von Stopps, haben
wir auch Spice. Diese unterscheiden sich
von den Stopps, Fälschungen und auch Markierungen, da die tatsächliche Funktion oder Abhängigkeit
tatsächlich aufgerufen wird. In Gewürz. Es hat einen Beobachtungsmechanismus , der diesem Aufruf
zum
Delta B-Test beigefügt ist und den
Aufruf dieses Beobachtungsmechanismus veröffentlicht. Es kann überprüft werden, ob die Kohle tatsächlich ausgelöst wurde oder nicht, zusammen mit
den Parametern. Und schließlich haben wir das
wichtigste Test-Doppel , auf das wir uns
den Großteil dieses Kurses konzentrieren werden. Das sind die Mocks. Die Markierungen sind spezielle
Instanzen von Objekten und die Antworten der Subjekte können vom Tester angegeben werden. Das ist es, was sie einzigartig macht. Die Tatsache, dass der
Mach-Darm genannt wird, kann im Test die
SAML-Behauptung
nachgewiesen werden . Und das wird
der Winkel sein ,
in dem Mockito wir glänzen werden, wie Sie in
dem Vorschauprojekt sehen werden , von dem ich spreche. Und das werden wir in der nächsten Vorlesung in
nur einem Moment darauf eingehen. Es erleichtert die nahtlose Erstellung
von Mock-Objekten. So
verwenden Sie die Reflexionsfunktion in
Java, um
Mock-Objekte für eine
bestimmte Schnittstelle zu erstellen . Sie haben also eine Schnittstelle
und es
erstellt im Grunde ein Objekt, das als konkret
instanziiert wird. Aber dieser konkrete
existiert nicht wirklich. Sie markieren es einfach, bis Sie
es erfinden, und lassen einige Werte
zurückgeben
, die Sie
in der Linie denken , an der Sie
interessiert sind, damit Schuldenwerte
in der Funktion erscheinen , die Sie
tatsächlich testen möchten . Und außerdem, um
noch einmal zu sehen, wie sich die Funktion verhält, wenn sie
Eingabeparameter gesteuert hat, entweder als Parameter oder als Ergebnisse
der Funktionen
, die Long image genannt werden. Nun, nur ein paar Worte
darüber, warum Moche W so beliebt ist und Sie sich
entscheiden sollten zu studieren,
ist, dass Sie mit diesem Framework
diese Mock-Objekte
erstellen und konfigurieren
können erstellen und konfigurieren , über
die wir gesprochen haben. Das wäre auch
aus dem Titel dieses
Frameworks ziemlich offensichtlich . Mockito use
vereinfacht jedoch die Entwicklung von Tests, die Sie für
Klassen mit externen Abhängigkeiten oder einfachen Methoden innerhalb
dieser Klassen durchführen, erheblich. Wenn Sie, das
Teststatistik-Framework, können Sie, wie gesagt, die
externen Abhängigkeiten verspotten und auch die Markierungen
in den zu testenden Code einfügen. Dosis, die Sie
diesen spezifischen Wert an
Funktionen innerhalb der
Funktion geben möchten , die Sie testen
möchten, um
zu sehen, wie sie sich verhält. Sie können natürlich den zu
testenden Code
mit Monkey DO ausführen und auch validieren, dass der Code in
dieser kontrollierten
Umgebung, die Sie mit dem Markierungsprozess
eingerichtet haben, korrekt
ausgeführt wird dass der Code in
dieser kontrollierten
Umgebung, die Sie mit dem Markierungsprozess
eingerichtet haben, . Es ging um Essen für die theoretischen spöttischen
Vorstellungen, die Sie drehen, kurz
bevor wir mit
dem eigentlichen Spott im Code beginnen und sehen, wie das funktioniert. Daher weiter. In der nächsten Vorlesung werden
wir einen kurzen
Blick auf das erste Mockito-Projekt sehen , das ich mit dem Gravel
Dependency Resolver
eingerichtet habe . Und wenn das interessant klingt, freue
ich mich darauf,
euch in der nächsten Vorlesung zu sehen. Und ich danke vielmals dafür du bis zum Ende dieser
Zeit bei mir
geblieben bist.
5. Kurzer Blick auf ein Mockito: Hallo Leute und willkommen zurück zu diesem Mockito-Tutorial,
in dem wir verstehen, wie wir unsere
Chatbot-Methoden
mit diesem Unit-Test-Framework besser
testen
können . Für diese Vorlesung
werden wir einen kurzen Blick
darauf werfen, wie wir unser Projekt
in Neu-Delhi einrichten können , damit
wir
Komponententests schreiben können, die hauptsächlich das Mockito-Framework
verwenden. Sobald Sie IntelliJ geöffnet
haben, können Sie auf Neues Projekt klicken damit Sie offensichtlich
genug Griechisch, ein neues Projekt, erhalten. Dann müssen
Sie in diesem Fenster, das Sie
gerade auf dem Bildschirm sehen , Gretel auswählen. Dann müssen Sie
Java ankreuzen und das SDK von Java, das Sie auf
Ihren lokalen Computer heruntergeladen haben. Ich hatte schon einen Vortrag,
jetzt kannst du das machen. Aber wenn Sie
es bereits installiert hatten, können Sie natürlich JDK hinzufügen. Blinzeln Sie also den Pfad, den Sie auf Ihrem lokalen Computer
haben,
oder Sie können den TFEU direkt herunterladen, der dem Schritt des Herunterladens
Ihres GDK nicht direkt vom
Intelligenten
gefolgt ist, aber wir haben es bekommen. Also können wir auf Weiter klicken. Hier ist die Benennung
unseres Projekts. Ich nenne mein
Projekt oder Tutorial. Und der Speicherort wird
der Standardspeicherort sein , der
sich im Ordner
Idea-Projekte befindet. Dann
wird die Artefakt-ID das Tutorial,
die Gruppen-ID oder die
ORT-Punkt-Beispiele schlagen . Das ist ziemlich einfach. Und wenn Sie auf Fertig stellen klicken, wählen Sie das neue
Fenster aus,
dass ich bereits ein Fenster
mit einem anderen Projekt geöffnet habe. Jetzt können Sie sehen, dass wir ein
Basisprojekt geöffnet haben und es ziemlich
bereit ist, Code einzuschreiben. Und Sie können sehen, dass
Gretel,
wenn es sich öffnet, die
Einweihung darauf aufbauen wird. Nur um zu sehen, dass alles
in Ordnung ist und alles bereit machen. Sie können sehen, dass der
Build erfolgreich war. Und hier auf der
rechten Seite haben wir auch einen tollen Zehenhahn ohne
die Aufgabe zu bauen, montieren, zu bauen und
all das gute Zeug. Und Sie können jedes
davon ausführen , damit Sie
sagen können, dass alles gut ist,
aber es
sollte alles in Ihrer Umgebung in Ordnung sein , wenn Sie
die Schritte befolgen , die ich gerade in den Vorlesungen
beschrieben habe. Das erste, was
Sie
tun müssen, um Mockito zum Laufen zu bringen,
ist, zu dieser Rechnungsdatei
zu diesem
Gretel zu gehen , genau hier im Projektfenster,
das sich oben und weiter
öffnet Im
Abschnitt „Abhängigkeiten“ in Zeile 12 müssen
Sie diese beiden Zeilen eingeben. Testen Sie also
die Implementierung unseres Jeeps. Dass Mockito, Mockito in
Linie 377 und Mockito, du brauchst Jupiter 377. Sobald Sie diese beiden Werte eingegeben haben, können
Sie sehen, dass Sie diesen Elefanten
haben. Es hat auch ein synchrone
Sitzungszeichen unten rechts davon. Und wenn Sie den Mauszeiger darauf bewegen, können
Sie sehen, dass
die Mittel, die Sie schrittweise Änderungen zulassen
können. Und es stellt im Grunde fest, dass die Projektstruktur geändert
hat. Und damit
diese Änderungen in das
System aufgenommen und darauf basieren und alle Referenzen
auflösen
können, müssen Sie diese
schrittweisen Änderungen laden. Sobald Sie darauf klicken, können
Sie einen weiteren
Build erstellen. Und sobald dies gemacht wurde, können
Sie grundsätzlich weitermachen
und Ihren Code schreiben. Der Code wird in diesen beiden Ordnern
abgelegt. Sie haben den Hauptordner mit dem Java-Unterordner in dem Sie den Arbeitsplatz platzieren
möchten, diese Schnittstellen und so weiter. Im Grunde genommen wird das der
Code, der getestet
wird . Der Release-Code. Um es also
im Testordner,
genauer gesagt,
im Job als Unterordner zu benennen im Testordner,
genauer gesagt,
im , werden
Sie eine Testklassen
erstellen. Die Klassen
werden Mockito
verwenden um die
Methoden der von Ihnen verfügbaren und
geschriebenen Klassen
zu testen verfügbaren und
geschriebenen , die Sie im Java-Ordner
des übergeordneten Hauptordners
getestet haben möchten . Und natürlich
kannst du nach
diesem grundlegenden Setup einfach weitermachen, um
deinen Mockito-Unit-Test zu reif zu machen. Natürlich
musst du Mockito importieren, aber das ist nur eine Codezeile. Genauer gesagt ist der
Import statischer ORT , dass Mockito Mockito mit einem Großbuchstaben M
und dann Punktstern
punktet damit er
die gesamte Bibliothek abrufen kann. Und danach kannst du
all die guten Sachen wie Methoden
von Mach verwenden , wann und so weiter. Wir werden uns natürlich
in den nächsten Vorträgen einlassen. Aber das war darüber. Wenn Sie jetzt nicht sehen, dass Ihre Gradle einfache Lösung wie
in meinem Fall erstellt wurde, wurde
sie automatisch erstellt. Was Sie tun müssen, ist, dass
Sie auf
dieses blaue Raster klicken und dann mit der rechten Maustaste darauf klicken und
dann das Tutorial ausführen. Und das wird standardmäßig
ausgeführt werden, basieren auf
dem gesamten Projekt. Natürlich wird es es mit
allen Abhängigkeiten
ausführen , die
Sie genau hier eingeben. Dies war eine grundlegende
Umgebung, die Sie auf
Ihrem lokalen Computer einrichten
müssen , bevor
Sie weitergehen Dieses Tutorial, wenn
Sie möchten, hat
tatsächlich
einige gute Erfahrungen. Wenn Sie also
replizieren möchten, was ich tue oder auf Ihre eigene
Weise oder auf ähnliche Weise mache, weil Sie mit den
Abhängigkeiten beginnen und
so
müssen Sie Ihr
Intel J-Projekt einrichten. Aber das war
es für diese Vorlesung. Ich freue mich darauf, Sie
in den nächsten zu sehen, bei
denen wir ein paar Keywords,
Vorstellungen und Dinge, die das Mockito-Framework haben und mehr im Detail tun, es
verstehen
und
einen tiefen Einblick in das Mockito-Framework werfen werden. Das klingt interessant. Ich freue mich darauf, euch dort zu
sehen. Und nochmals vielen Dank, dass
Sie bis zum Ende dieser
Vorlesung bei mir geblieben sind.
6. Einrichtung deines ersten Mockito: Hallo Leute, und willkommen zu diesem Mockito,
Java-Framework-Tutorial, in dem wir besser verstehen,
wie wir
unsere Java-Methoden mit
diesem Test-Framework testen können . Denn für diesen Vortrag werden
wir einen
Blick auf die erste Anwendung werfen ,
die wir haben, einige der Konzepte
,
auf die wir später in diesem Tutorial
vertiefen werden . Nur damit Sie sich ein Bild machen
, wie ein Projekt in jeder Gesamtheit aussehen
würde. Und wie würdest du das Starting von 0
erstellen? Für den Anfang werden
wir natürlich unser ausgewähltes
IBD für Java besuchen. Das ist IntelliJ J, wie Sie in den letzten Vorträgen gesehen haben. In dir wirst du natürlich
ein neues Projekt erstellen. Und Sie können entweder ein neues Projekt
ablegen oder wenn Sie
noch kein geöffnetes Projekt haben, öffnet
es
nichts anderes als ein Startfenster in dem Sie Sie umleiten um ein Projekt
oder ein neues Projekt zu öffnen. Sie können ein neues
Projekt einrichten und was Sie Weiter auswählen
möchten, ist schrittweise. Anstelle von einfachem Java. Der Grund dafür ist,
dass es unsere Arbeit bei der Verknüpfung des
Mockito-Frameworks in unserem Projekt erheblich erleichtert. Anstatt also
einfach
die GIA-IR-Dateien aus
Maven-Repositorys herunterzuladen , die
JAR-Datei Ham Crest, den Mockito, und auch
DOS-Systemvariablen mit der Rückseite zu verknüpfen. Was das tun wird. Der Grader
verknüpft Mockito automatisch sehr einfach, wie ich es Ihnen in einer
Sekunde zu unserem Projekt zeigen werde. Also werden wir Grid
off für dieses Tutorial verwenden. Nur für den Fall, dass Sie es nicht wissen, führe
ich Ihnen
eine kurze Beschreibung
des Kredits durch . Man kann sich also vorstellen, dass es nur
ein Werkzeug für die Automatisierung ist. Was es tut, automatisiert die
Erstellung von Anwendungen macht
es viel
einfacher und schneller. Dies sind Automatisierung
beinhaltet den Link zum Verpacken und Kompilieren
verschiedener Teile Ihres Codes. Aber im Moment können Sie einfach Gretel hier
über die
Projektdichte j wählen , die Sie benötigen. Wählen Sie natürlich JDK aus
, das Sie installiert haben. Auf Ihrem lokalen Computer. Wir haben unsere 16 JDK-Schulden
installiert automatisch von
intelligent erkannt werden , weil wir
sie auf einem eigenen Standardpfad belassen haben. Wenn Sie diesen Pfad jedoch anders gewählt haben oder eine andere Version
von JDK installiert haben, sollte diese automatisch, wie gesagt, hier ausgewählt werden. Wenn dies nicht der Fall ist, können
Sie JDK entweder
herunterladen, wenn Sie es
nicht haben und er wird automatisch für Sie
heruntergeladen. Sie müssen nicht den
ganzen Prozess aus
der früheren Vorlesung durchlaufen . Oder Sie können Ihr JDK hinzufügen, wenn Sie es
bereits installiert haben, aber nicht erkannt wird. Sie können einen Pfad auswählen, in dem
Sie diese Bin-Datei installieren. Aber im Moment können Sie
auch Java auswählen und dann auf den Namen
des Projekts und den Standort klicken . Auch die Artefaktkoordinaten als Artefakt-ID liegen
ganz bei dir. Das wird also in keiner Weise
unser Projekt in keiner Weise sein. Wenn Sie dann auf Fertig stellen klicken, wird
standardmäßig ein
Projekt für Sie geöffnet , beginnend mit der
unteren Breite, die nicht enthalten ist. Natürlich werden
wir das
in einer zukünftigen Vorlesung machen und ich werde Sie genau
durchführen , wie
die Abhängigkeiten
aufgebaut werden und was Sie tun
sollten, um Mockito und
all das gute Zeug zu importieren. Aber diese Vorlesung soll Ihnen ein
schnelles Projekt zeigen, das ich hier mit einigen
Kursen
eingerichtet habe , die tatsächlich mit dem Mockito-Framework
zusammenarbeiten. Um eine bestimmte
Methode aus einer bestimmten Klasse zu testen, werden
wir
nur nach Ihnen suchen, um
eine bessere Vorstellung davon zu bekommen wie die Dinge in diesem
einzigartigen Test-Framework funktionieren. Sie können hier sehen Ich habe Industrial Sees
Datei, die Hauptdatei. Hier habe ich ein Java. Eine Datei, natürlich, zusammen mit der Hauptdatei, haben
wir die Testdatei,
wo
wir intuitiv genug unsere Testmethoden schreiben werden. Im Java. Wir
erklären einfach unsere Kurse. Arten von Methoden, die wir
möglicherweise testen lassen möchten. Zunächst einmal haben wir
das Autoglas hier. Diese Klasse hat drei
Felder, Auto-ID, das ist eine Zeichenfolge, einen Namen, das ist eine Zeichenfolge und eine
Menge, die eine Zeichenfolge ist. Und wir stellen uns vor, dass diese
Übungen wie eine
Art Autorität, die Autos
verkauft, sich gut verkaufen, ich nannte es das Autohaus. Und wir haben auch einen Autoservice , der diesen Transfer erleichtert. Eine weitere Beobachtung
hier ist, dass Sie, wenn Sie hören, dass diese Klasse einen
Dienst im Namen hat, automatisch daran denken
sollten , dass diese Klasse einige
Methoden für Ihre anderen Klassen durchführt. Wir waren im US-Dienst. Und wenn Sie das Repository hören
, dass etwas damit zu tun hat, gute Daten beizubehalten, sie in einer
Datenbank zu
speichern und so weiter. Das war nur eine
schnelle Klammer. Das Klassenauto hat jetzt
natürlich einen Konstruktor mit allen drei Parametern, die hier
noch initialisiert wurden. Und dann bekommen wir ein paar Setter
und Getter, die öffentlich sind. Und dadurch
werden wir
unsere privaten Felder tatsächlich einrichten oder auf diese Weise
erreichen. Kapselung erledigt,
gute Praxis. Dies ist die Liste, hier
nichts Ungewöhnliches. Nur einige Felder, die noch die Zellwand
einstellen und erhalten. Wir können hier nichts wirklich
testen, aber wir werden
sehen, dass wir nur testen oder Klassen machen
, die es leicht machen. Nun, seien Sie jetzt weiter hier, wir haben auch die
Autohäuser. Dies ist also die Methode, mit der
wir die Glaszelle testen werden. Zunächst importieren wir
Java util Biest, da
wir die
Liste hier in Zeile 15 nutzen werden. Aber das
Autohaus der Klasse muss filtern. Sie brauchen einen Autoservice
, der eine Schnittstelle
und eine Weinkarte von
Autos ist , da das Autohaus natürlich zumindest Autos haben
würde. Jetzt bekommt der Autoservice
Getter und auch einen Setter. Und dann bekommt die Liste der Autos
auch einen im Getter. Schließlich haben wir hier eine andere
Methode, die mit
dem Framework-Fall getestet wird . Sie werden in nur einem Moment sehen, was es tut, ist,
dass es eine Variable vom Typ
doppelt genannt Marktwert deklariert und sie mit 0 erhöht. Jetzt werden wir am wenigsten zu
den Autos iterieren , dass er
Mitglied dieser Klasse ist. Wir werden
den Preis für ein Auto erhöhen. So können die Autodienste
sehen, dass es nur eine Schnittstelle , die diese Unterschrift
des Kaufpreises hier hat. Und das ist die Methode, die
wir mit
Mockito verspotten werden , um etwas zurückzugeben
, das wir wollten. Das ist es, was Mark bedeutet. Und abgesehen davon werden
wir den Preis multiplizieren,
den wir den Wert markieren werden , den
wir geben werden. Die Mengenmethode, die
natürlich in der Fahrzeugklasse gehört. Die Menge, die zurückgibt,
wie viele Autos es gibt. Nachdem wir
jedes Auto durchlaufen und es mit
diesem Multiplikationswert
erhöht haben, werden wir diesen Wert
zurückgeben. Wie gesagt, hat der
Autoservice diese Signatur, eine Methode, die nicht
wirklich implementiert wird. Und wir werden jetzt zur Testklasse übergehen
. Wie Sie unter
Test und Java sehen können, wissen wir auf
diese Weise nicht, dass dies die Testmethode ist. Hier passiert
sozusagen die Magie , und
Mockito ist beteiligt. Dies ist die Klasse von
Kartentests, die wir nur
einige Utils importieren werden, die wir verwenden werden. Damit können Sie also sehen, dass
wir den Mockito importieren. Wie ich in einem zukünftigen Vortrag sagte, werden
wir genau
sehen, wie wir diese
Mockito mit Gretel importieren
können. Wir fangen hier in der
Klasse des Kartentesters an. Also haben wir ein Autohaus,
den Autoservice. Der Dienst ist eine Schnittstelle. Hier haben wir die Hauptmethode , die der
Einstiegspunkt ist, an dem wir diese ausführen werden , das
ziemlich einfach. Wir deklarieren
Kartentester, was diese Klasse ist. Also werden wir
es instanziieren und dann nennen
Sie es Setup dafür. Das Setup ist also genau hier diese
Methode, die das Autohaus
und den Autoservice
instanziiert. Kann für den
Autoservice sehen, dass es
nur eine Schnittstelle ist, in der ich gesagt habe, dass sie nicht wirklich
implementiert wird. Wir werden die
Mock-Methode von Mockito verwenden. Und wir geben Ihnen
den Autoservice und das Glas. Also werden wir die Klasse nur
markieren, da es
sich um eine konkrete Klasse handelt,
nicht nur in einer Schnittstelle
für das Autohaus. Wir werden auch den Autoservice
auf diesen markierten Autoservice
einstellen , wie Sie hier neben der
Hauptmethode sehen können , nachdem wir diese Tests
eingerichtet haben, deren Objekt des
Typs Kartentester, wir sind um
diesen Testmarktwert zu codieren. Und je nach
Boolean und es kehrt zurück, werden
wir das am besten gerahmte essen, wenn der Test
bestanden oder fehlschlägt. Wenn es fehlschlägt. Einstieg in diesen
Testmarktwert, eine Methode. Hier werden wir nur eine Liste von Autos
deklarieren. Dann instanziiere ich tatsächlich zwei
Objekte vom Typ Auto. Der erste ist Lamborghini und der
zweite ist ein Audi. Verwenden Sie den Konstruktor
mit allen tatsächlichen Werten. Wir geben
ihnen eine Aktiennummer,
einige Namen und die Mengen, die wir lernen müssen, gut zu arbeiten. Und drei sind diese
beiden Autos, die tatsächlich Listen von
Autos sind, weil diese drei verwenden sollen oder diese natürlich in unsere Liste
aufgenommen werden, die als Autos
bezeichnet wird wie Sie
dort bis 1637 online sehen können. Dann rufen wir am 40 die Methode für das
Händlerobjekt auf. Das ist ein Autohaus. Was diese Setcards
Methode getan hat, war, wenn Sie sich daran erinnern, die Liste
, die wir sie als
Parameter angeben, der Liste des
Feldes des Autohauses anzupassen die Liste
, die wir sie als . Darüber hinaus, nachdem wir das getan haben, ist hier die demo.com-Szene
und natürlich werden wir ist hier die demo.com-Szene
und natürlich werden wir einen späteren Vortrag halten, in dem ich genau erklären
werde,
was diese Methode bewirkt. Aber im Moment, nur damit Sie das Gesamtbild bekommen
können, was diese Methode ist, wenn Sie im Grunde einen Anruf
erhalten. Es heißt, wann die
Lückenpreismethode des Gottesdienstes
Christi mit einem Parameter
von Lamborghini
aufgerufen würde . Dann sollten Sie 250 Tausend
lesen, was der Preis von
Lamborghini wäre, den ich schätzte. Und dann wieder, wenn sie Preismethode des
Autodienstes
bekommen würde mit dem Auto angerufen werden, dann sollten Sie 50 Tausend
zurückgeben. Auch hier markiert es diese Anrufe. Der Code muss also nicht
die gesamte
get-Preisklasse durchlaufen , da
Sie nur die
Marktwertmethode testen möchten. Und genau das macht es. Es markiert das Glas
der Methode von Get Bryce. Und nachdem wir diese gesehen haben, können
Sie sehen, dass
wir
die Funktion „Marktwert erhalten“
aus dem Autohaus aufrufen die Funktion „Marktwert erhalten werden,
das war dieses. Und wie Sie hier sehen können, markieren
wir die
Nettopreismethode , da wir
das nicht testen möchten. Wir wollen nur, dass diese
Marktwert-Methode erhält. Und wie gesagt, wenn dies angerufen wird, würde
es zu den
Autos iterieren und vor allem wird
es an
die Anzahl Guineas liefern. Und wenn der Autoservice Preis von Lamborghini bekommen
würde, sagt
der Mockito Sie, zu 50 Tausend
zurückzukehren und sich
nicht einmal die Mühe zu machen,
den tatsächlichen Preis zu nennen, was natürlich
nicht einmal ist implementiert , weil dies eine Schnittstelle ist
und wir sie markieren. Dann ermöglicht die ganze ADI auf die gleiche Weise
und das Biest ermöglicht es uns,
die Methode zum Marktwert zu erhalten, unter
sehr kontrollierten
Bedingungen zu testen und auch sehr
effizient, wenn sie
Preismethode erhalten,
geht nicht in und auch sehr effizient, wenn sie
Preismethode erhalten die Kälte et al. Wir werden es, wie gesagt, vom Autohaus
anrufen. Danach werden wir den Marktwert
gleich 650 Tausend
machen ,
was angesichts
der Tatsache, dass 250 Tausend Mal zwei
525.000 Tausend Mal 350
Tausend
Mal 350 Tausend sind, der
richtige Wert wäre Mal zwei
525.000 Tausend Mal 350
Tausend
Mal . Addiere die beiden zusammen und du
würdest 650 Tausend bekommen. Natürlich wird es jetzt entweder übergeben oder fehlschlagen, abhängig von diesen Wahr oder nicht,
dem Wert, den dieser
Testmarktwert zurückgibt. Wenn wir also mit der rechten Maustaste auf
die Autotester-Klasse klicken, sagen
wir Ron Cortez Domain. Sie können sehen, dass sich
gerade das gesamte
Projekt tatsächlich aufbaut und Interesse aufbaut. Zweitens sieht man,
dass es das Beste ist. Mal sehen, ob es funktioniert. Wenn wir hier 65 Tausend
hätten, was nicht der richtige Wert ist, sollten
Sie hier einen Fehler bekommen. Mal sehen, ob das passiert. Passiert. Nun ging es um Urkunde für die erste Einführung
zu Mockito. einem größeren Projekt in der Stadt würde sich
Mockito an
ein bereits eingerichtetes Projekt gewöhnen. Aber beginnend mit
der nächsten Vorlesung werden
wir von
Anfang an schrittweise
vorstellen , wie Sie
Ihr erstes Projekt erstellen können. Präsentieren Sie auch bestimmte Keywords und Funktionen des
Mockito-Frameworks und wie sie verwendet werden, was sie tun und so weiter. Wenn das für dich
interessant klingt, hoffe
ich, dass ich
euch dort sehe. Und vielen Dank, dass Sie bis zum Ende
dieses Tutorials bei
mir geblieben sind.
7. Angabe der return: Hallo Leute und willkommen zu diesem Mockito-Tutorial, in dem
wir besser verstehen, wie wir unsere Methoden
in Java mit diesem
Unit-Test-Framework testen können . In dieser Vorlesung werden
wir uns
ansehen, wie Mockito Rückgabewerte
in verschiedenen Szenarien für
einige Funktionen
angeben kann in verschiedenen Szenarien für , die in
verschiedenen Situationen
aufgerufen werden . Mit Mockito können Sie
Funktionen hinzufügen, um ein Objekt
mit verschiedenen Methoden zu markieren. Sie können sehen, dass wir das
hier in unserem Schreibtisch in Zeile 23 gemacht haben. Wir markierten die gesamte
Auto-Serviceklasse , die sich auf einer Schnittstelle befand und leiten keine tatsächliche
Implementierung an. Aber abgesehen von dieser
einen Mockito-Niere kann
es auch das Verhalten
einer Funktion markieren , die
mit bestimmten Parametern aufgerufen wird. Und bei der Kennzeichnung von Schulden kann
es den
genauen Rückgabewert angeben, den
diese Funktion haben sollte wenn sie mit diesem
spezifischen Parameter aufgerufen wird. Zum Beispiel online 43. Wie Sie sehen können, hat der
Mockito
die Funktion angewiesen , den Preis
vom Autoservice zu erhalten
, der tatsächlich keine
Implementierung in der Schnittstelle hatte. Um die 250.000 zurückzugeben,
scheitern Sie, wenn Sie kalt werden, könnten
wir das Argument
von Lamborghini haben. Und wie Sie sehen können, die gestapelte Syntax dafür
das Schlüsselwort wing. Dann die Funktion, die mit einem
bestimmten Parameter aufgerufen wird . Schulden sind also die
Situation , in der dieses
Verhalten hinzugefügt werden soll. Und dann sollte das Schlüsselwort den return und dann der Wert, aufgerufen
wird und dann der Wert,
die Funktion, die mit
diesem spezifischen Parameter in einer schuldengenauen Situation
haben. Zu diesem Zeitpunkt. Mock hat
das Verhalten bereits aufgezeichnet und es funktioniert Mock Objekt, Auto-Service-Art der Schnittstelle. Das Auto-Service-Objekt ist
bereits ein funktionierendes Mock-Objekt. Auch hier habe ich das bereits gesagt,
dieser Code hier
ist sehr nützlich, da dieser Code im Autohaus
ausgeführt wird und Marktwert
erhält. Wir werden testen und möchten, dass
diese beiden Aufrufe
unsere genauen angegebenen Werte und
markierten Werte haben, nur
damit wir diese beiden Aufrufe
unsere genauen angegebenen Werte und
markierten Werte haben sicherstellen können,
dass diese Funktion in Bezug auf
diese Funktion von get gut
läuft oder nicht preis. Ob also die Funktion von
Get Priced funktioniert oder nicht, definite Methode zweimal, da wir die
Werte angeben, die zurückgegeben werden soll. Und wir möchten uns
auf Komponententests konzentrieren , um eine Marktwert-Methode zu erhalten. Dies ist die grundlegende Methode
, wann und dann zurückzugeben,
nämlich SHE, das Mockito-Framework, das die Rückgabewerte angibt. Wie einige andere Programmierer
vielleicht denken. Dies fügt das Verhalten hinzu. In bestimmten Situationen. Das ist eine ziemlich nützliche
Sache, wenn Sie die Trennung
erstellen möchten ,
über
die wir gesprochen haben , von der Klasse
, die Sie in
der Unter-Abhängigkeit testen möchten ,
und Klassen, die darin aufgerufen
werden. Das war also die oberste Urkunde
für diese Vorlesung. Und im nächsten werden
wir uns das verifizierte
Keyword ansehen, das ein sehr
wichtiges Keyword, Demo-Dope,
Unit-Test-Framework ist . Und wir werden
genau sehen, was es tut und all die verschiedenen Szenarien
, die viele von
ihnen sind , die verifizieren
Keyword verwendet werden können. Das klingt interessant. Ich freue mich darauf,
euch dort zu sehen und danke Ihnen vielmals, dass Sie bis
zum Ende
dieser Vorlesung bei
mir geblieben sind.
8. method: Hallo Leute und willkommen
zurück im Smoky erzählte Turiel. Wo immer wir verstehen, wie
wir
unsere in
Java geschriebenen Methoden mit diesem Framework besser testen können. In diesem Vortrag werden
wir über
die Verifizierungsmethode sprechen , die
Mockito uns bietet. Auch wie können wir es verwenden und warum nützlich für uns,
wenn wir versuchen,
diese eine oder noch mehr Methoden
, die wir im R. geschrieben haben, zu integrieren.
Vielleicht in der Produktion
oder vielleicht
möchten wir sie
irgendwann in der Zukunft einsetzen. Als ich hier angefangen
habe, habe ich ein ganz neues
Projekt in Intel J. erstellt Und die Art und Weise, wie ich das gemacht habe, war dem
anderen, das wir in
der vorherigen Vorlesung gesehen haben , in
der ich die Überblick über ein
Projekt für Sie. Genauer gesagt habe ich gerade auf Datei Neues Projekt
geklickt. Und als sich das öffnete, wählte
ich das
Gradle-Abhängigkeitslösungssystem, wählte Java und dann
das JDK meiner Wahl. Dann
wählte ich einfach einen Titel dafür aus,
genauso für die
Artefaktkoordinaten, und dann
klicke ich auf Fertig stellen und dann
hat es mein Projekt für mich erstellt. Danach bin ich einfach zum
Build Gradle gegangen und habe
einige Dinge in einige
Abhängigkeiten importiert , die wir benötigen werden , damit
dieses Projekt funktioniert. Um spezifischer zu sein als Schulden. Benutzte JUnit und auch
die Mockito-Pakete. Die JUnit Jupiter
API war bereits da, nachdem Sie diese
einbeziehen werden. Wie Sie sich erinnern, erhalten Sie, wenn Sie
einen Charakter der
DC-Build-Gradle-Datei ändern , die Sie selbst und mit der Synchronisierungsschaltfläche
klicken müssen damit sie
synchronisiert importiert werden kann
mit
den neuesten Abhängigkeiten, direkt in der Build-Gradle-Datei. Danach wird die Quelle mit
dem
Mittelwert abgelegt und Testordner wurden erstellt, nachdem das Projekt erstellt wurde. Im Java-Ordner habe ich eine Klasse und
das Interface. Die Klasse heißt
Abrechnungsanwendung und die Schnittstelle
heißt Bond-Shop-Service. Der Pfandleihdienst hat zwei Methoden,
die Sie verkaufen und kaufen müssen. Erstens sind sie im Abrechnungsantrag
überhaupt nicht implementiert . Das ist eigentlich eine Klinik,
keine Schnittstelle. Ich habe diese privaten Felder. Das ist ein Schriftart-Shop-Dienst, der die Schnittstelle war. Und dann habe ich den
Set-Scheunen-Shop-Service, der meinen
Bond-Shop-Service einstellt. Dann habe ich eine Zellfunktion
, die nur zwei Zahlen hinzufügt. Der erste sollte
der Gesamtgewinn sein , den der Punch Up bis zu diesem Zeitpunkt erzielt
hat. Und der zweite
sollte tatsächlich
der Preis sein , für den wir unser
spezifisches Objekt verkaufen. Auch dies sind so ziemlich
nur ein Beispiel, da sie nicht in einem Maße implementiert werden, in dem sie intuitiv
oder nicht nach Methode sein
würden . Das nennt das Bike vom Punch-Up-Service,
der
, wie Sie gesehen haben, nicht implementiert
ist,
aber wir werden sehen, wie das
in nur einer Sekunde funktioniert. Jetzt wo es interessant wird, denn bis zu diesem Zeitpunkt war
es dem anderen Projekt,
das wir uns angeschaut haben, ziemlich ähnlich . Erleichtern Sie den Testordner, wo wir automatisch
den Java-Ordner
erstellt haben und ich hier
diese beiden Funktionen erstelle. Dies sind beide Klassen. Einer wird als
Abrechnungsantragstester bezeichnet. Jede Testanwendung für
Displays, die Sie
hier auf dem Bildschirm
sehen, hat also Displays, die Sie
hier auf dem Bildschirm
sehen keine
Abrechnung der Anwendung durchgeführt. Und dann habe ich einen Testläufer der
die
Hauptfunktion hat, die Sie benötigen, wie wir in einer Sekunde sehen werden, dafür verantwortlich
ist, dass die verschiedenen Desk-Klassen
tatsächlich ausgeführt die verschiedenen Desk-Klassen werden, die wir
haben würden dieser Ordner, in meinen Einschränkungen, nur einer. Aber in größeren
Produktionsprojekten kann
es eine
Menge Testgläser geben. Ich weiß, dass es ziemlich
nützlich ist, um
Dam zu betreiben , anstatt eine Domäne in
jedem von ihnen
zu
haben ,
da das viel zeitaufwändiger
wäre viel zeitaufwändiger
wäre ,
auf die Schaltflächen jedes der Projekte viel zu klicken. Darüber hinaus finden Sie den Test für
die Abrechnung direkt hier. Wie Sie sehen können, unterscheidet es sich
ziemlich von dem, das wir
im letzten Projekt gesehen haben. Und der Hauptunterschied besteht darin, dass diese Testerklasse mit JUnit-Trainer
gelesen wird. Und wie Sie gesehen haben, wenn Sie sich erinnern, importieren
wir
Austauscheinheit in meinem Fall 4131, die Version. Und wenn er ein bisschen erklärt,
was diese Punkte sind, ist
ein JUnit-Runner
nur eine Klasse, die die Runner-Klasse von
JUnit
erweitert, was abstrakt ist. Diese Grenzen werden zum
Ausführen der Testklassen verwendet. Sie haben etwas Geduld
mit dem At-Zeichen , das dem Bauprozess hilft zu verstehen,
welches
Objekt die Markierung ist, welches Objekt das Objekt das ihn auch injizieren
sollte, und auch die Testfunktionen. Die JUnit-Tests werden
mit der JUnit-Kernklasse gestartet. Und dies kann geschehen, wenn Sie von der Befehlszeile
aus ausgeführt werden. In unserem Fall wird
dies jedoch standardmäßig von unserem IVE
geschehen, wenn
wir
die Schaltfläche Ausführen auf
dem Laufwerk drücken die Schaltfläche Ausführen auf
dem , das die Hauptmethode
hat. werden wir in einer Sekunde sehen. Dieser JUnit Läufer findet mithilfe von
Reflexion den
passenden Trainer für die beste Testbrille. Und natürlich
wird er zuerst nach der Anmerkung der
Reimbreite in der Testklasse
suchen , und kein anderer Läufer wird gefunden. Der Standardläufer wird verwendet. Es wird instanziiert und die Testklasse wird
an den Läufer weitergegeben. In unserem Fall Schulden, die Klasse des
Bewerbungstesters. Die Aufgabe des Läufers
ist es, Glas zu instanziieren und am besten zu testen. Das ist also der Lauf oder
ist es ziemlich einfach? Es hilft uns nur, unseren Test in Intel J durchzuführen, indem wir intuitiv
und Bedingungen verwenden um der ID zu zeigen
, welche Komponente Switch n ist. Welche Rolle spielt jeder
Akteur in diesem Prozess? Gehen Sie nun zum
Testläufer weiter und wir werden in nur ein bisschen
wieder in diese Best-in-Class
zurückkehren. In der Testrunner-Klasse können
Sie sehen, dass wir
die Hauptfunktion haben und ein Ergebnis haben das der
JUnit-Runn-Klassen-Methode zugewiesen ist. Und das wird als
Parameter d Testklasse angegeben. Wie gesagt, die
Ketteneinheit oder wird die Testklasse
ausführen. Und natürlich werden
diese Anmerkungen
ihm dabei helfen. Das Ergebnis wird
den JMU-Trunk-Klassen zugewiesen. Der Zwei-Minutenkern rangiert dieses Glas mit Reflexion
und bringt
das Ergebnis dann genau hier in diese
Ergebnisvariable. Jetzt werden wir diese Ergebnisfehler
durchlaufen. Dieses Ergebnisobjekt
hat also eine maximale Methode
namens get failures und es wird
alle Fehler zurückgeben , wenn es irgendwelche in unserem Test
gab. Und es wird
sie auf dem Bildschirm drucken. Natürlich wird es auch
gedruckt, ob unser Ergebnis erfolgreich
war oder nicht in DC wird
entweder wahr gedruckt, wenn alle Tests erfolgreich waren oder falsch, wenn einige von
ihnen fehlgeschlagen sind, wie Sie auf der
Beschreibung auf dem Bildschirm sehen können , war dies
gerade
so ziemlich die Struktur
unseres Projekts. Wir sehen auf dem Bildschirm. Ich wollte
dir nur alle Elemente zeigen , die ich gemacht habe. Nur wenn Sie diesem Projekt
folgen oder es
vielleicht sogar schreiben und dann
ändern möchten , dass Sie online sind. wirst du schaffen
können. Nach dieser Präsentation. Ich werde
näher auf
das Konzept
eingehen , über das wir
in dieser Vorlesung tatsächlich sprechen werden. Und die verifizierende Methode, die öffentliche Klasse der Abrechnungsprüfungen, die ich hier auf dem Bildschirm geschrieben habe, macht ein paar Dinge, die
innerhalb des Mockito
sehr gut informiert sind sehr gut informiert Framework in ihrem Dump, sehr gut mit
diesem Framework und deshalb wollte ich sie Ihnen
vorstellen. Zuallererst deklariert es einen Gegenstand des
Abrechnungsantrags. Die Anmerkung von
Inject-Markierungen prüft, dass dies das Objekt ist, in das die
Markierung eingespritzt werden soll. Und wie Sie hier sehen können, ist
der Pfandleihdienst das Zeichen, weil es
nur eine Schnittstelle und wir
es in dieses Glas injizieren sollten. Jetzt erklären wir auch in diesen getesteten
Shop-Service-Objekt, das wir kommentieren. Das ist eigentlich ein Mock,
wie Sie gesehen haben, Iteration, Das ist eine Schnittstelle
und wir sollten Verhalten
vermarkten und vermarkten um genau das zurückzugeben,
was wir
zurückgeben wollen und die es tatsächlich implementiert
haben. Denken Sie daran, dass wir
dies tun, um
Overhead beim Testen unserer
Produktionsklassen zu vermeiden . Entweder indem wir nicht alle
Datenbankflüsse in nur einem von uns angegebenen
Schein
neu erstellen wollen alle
Datenbankflüsse in nur einem von uns angegebenen
Schein
neu erstellen und auch
den Teilefluss besser steuern den Teilefluss , funktionieren
oft, die nicht
wirklich damit zusammenhängen. Und wir wollten diese Funktion nur
getrennt von
anderen Klassen
testen . Und jetzt der Test bei Funktion, der der eigentliche
Einzeltest ist, wir in dieser Anwendung geschrieben haben. Wie Sie sehen können, wird dies mit dem Testzeichen
kommentiert. Wir werden vor allem bei dem Verhalten mit Mockito tun, dass der
Schaden 30 zurückgeben sollte, wenn die Verkaufsmethode
des
Pfandleihdienstes mit
den Parametern 1020 aufgerufen wird . Wir fügen hinzu, dass dieses Verhalten sonst diese
Codezeile hier
nicht existiert hätte. Der Pfandleihdienst
mit der Zellenmethode mit gibt nichts zurück, da diese
Methode keine Komponente ist, haben wir das Verhalten hinzugefügt. Und dann werden
wir diese
Add-Funktionalität testen und behaupten, ob die
Verkaufsmethode des Pfandleihdienstes mit den
Argumenten von 1020 tatsächlich 30
S zurückgibt, die wir angewiesen haben. Und wir werden dies
tun, wie Sie bei der Assert-Methode sehen
können, die
zur JUnit-Klasse gehört, ist die
JUnit-Referenz hier
sehr wichtig. Und dann hat dieser
Ort eine
Assert-Equals-Methode , wie Sie sehen können, die zwei Objekte benötigt und dann beginnt, ob
sie gleich sind oder nicht. Das ist ziemlich einfach. Jetzt können wir das Verhalten
mit diesem verifizierenden Schlüsselwort und der Methode überprüfen. Überprüfen Sie das Verhalten besagt
, dass wir
die
Verkaufsmethode des Pfandleihdienstes mit den
Argumenten dann in 20 überprüfen die
Verkaufsmethode des Pfandleihdienstes sollten. Dies bedeutet
im Grunde zu überprüfen, ob die
Bond-Shop-Serviceklassenmethode von cell mit dem Argument
1020 tatsächlich aufgerufen wurde. Wir können auch
etwas anderes tun, indem wir verifizieren. Und das deutet auch die Zeiten hin, in denen diese
Funktion aufgerufen wird. Jetzt gehen Sie etwas
tiefer in das theoretische
Verifizierungsmethodenwissen ein. Mockito kann
alle
Methodenaufrufe , die Sie
bei Testmethoden durchführen , und auch deren Parameter für
Schuldenmock-Objekt verfolgen. Sie können dies tun, indem Sie
diese Verifizierungsmethode , von der ich gerade
hier auf dem Mock-Objekt spreche. Wie gesagt, müssen
Sie dies verwenden um zu überprüfen, ob die
angegebenen Bedingungen erfüllt sind. Zum Beispiel
können Sie theoretisch
überprüfen, ob die Methode als
bestimmte Parameter bezeichnet
wurde , die wir hier in Zeile 30
durchführen, um diese Art von Tests manchmal als
Verhaltenstests bezeichnet zu werden. Das ist ziemlich suggestiv. Und es
überprüft nicht das Ergebnis
eines Methodenaufrufs Buddy überprüft, ob die Methode mit
den richtigen Parametern aufgerufen wird. Wie Sie in diesen
Überprüfungsaussagen
online sehen können 3333, das tatsächliche Ergebnis, das ist 30 und es
sollte 30 bei Schuldenmethode sein, die
nirgends
markiert ist, um zu finden, also ist das überhaupt nicht betroffen. Als Ergebnis dieses Methodenaufrufs
haben wir gerade überprüft, ob die
depth-Methode
mit roten Parametern aufgerufen wurde oder nicht und auch wie
oft sie aufgerufen wurde. Natürlich kann es viele
andere Dinge machen, die
wir tun werden, schauen Sie sich spätere Vorträge an. Aber in dieser Vorlesung werden
wir uns nur auf
diese beiden Faktoren
konzentrieren. Sie es noch einmal durchgehen, werden
die raffinierten
Methoden des Affenspielzeugs nur verwendet, um das bestimmte
Verhalten zu überprüfen. Wir können diese
Verifizierungsmethoden am Ende
der Testmethoden verwenden , und so sollte sie
verwendet werden, wie Sie es auch
auf meinem Bildschirm sehen können. Um sicherzustellen, dass die
angegebenen Methoden, die wir oben aufgerufen haben, tatsächlich aufgerufen
werden. Auf diese Weise können Sie
auf eine andere Weise überprüfen
, ob der eigentliche Workflow
, den wir vorgeschlagen haben , diese Testmethode tatsächlich
stattgefunden hat und E so funktioniert, wie
wir dachten. Wir können dies
ausführen und sehen was mit
diesen Testfunktionen passiert. Wenn Sie mit der rechten Maustaste auf den
Testläufer klicken und
ihn ausführen, geht er
zur Hauptfunktion. Mit dem JUnit-Kern werden dann alle
Klassen in dieser Testklasse ausgeführt. Dann wird es jeden der
Fehler durchlaufen, falls vorhanden, drucken Sie sie aus und wenn nicht, oder selbst wenn sie weniger waren, wird
VT auf dem Bildschirm
drucken ob das Ergebnis war
erfolgreich oder nicht. Erfolgreich, was bedeutet, dass
es irgendwelche Fehler gab oder nicht. Es ist ziemlich intuitiv, wenn die
JUnit-Kernlaufklassen Methode als Breite des
Rechnungsanwendungstests bezeichnet
wird. Unsere Testmethode
wird aufgerufen. Zuerst fügen wir das Verhalten der
Verkaufsmethode
des Pfandleihdienstes hinzu, die mit
dem ersten Dokument
aufgerufen
wird Dan und das zweite
Argument als 20, es sollte 30 zurückgeben. Jetzt werden wir behaupten
, ob das Verhalten tatsächlich ausgeführt wird, indem behaupten, ob
die Zellmethode dieser Schnittstelle und der tatsächliche
und der 30-Wert gleich sind. Dann werden wir nur überprüfen,
ob diese Zellmethode tatsächlich online 29
heißt. Und wir werden auch prüfen,
ob die Zellenmethode, die Argumente von Mandant 20, was auch einmal
online 20 genannt wird. Wenn wir diese ausführen,
wie Sie hier sehen können, heißt
es, dass die Aufgabe des
Testläufers Maine war. Aufgerufen, was genau hier
diese Aufgabe war. Kartellspannung auf wahr. Weiß führte zu „wahr“. Nun, das liegt daran, dass es all diese
Getfield-Jahre
durchlief und buchstäblich neun Jahre
alt wurde, weil
unsere Testmethode neun Jahre
alt wurde, weil
unsere Testmethode keine Fehler aufwies. Und dann wird gedruckt, dass die
Ergebnisse erfolgreich waren. Dafür steht das, wofür B zutrifft. Alles ist passiert,
als wir hier pflanzen, unsere Zellmethode hieß. Es wurde tatsächlich einmal genannt. Lassen Sie uns jetzt prüfen, was passiert. Wenn wir überprüfen möchten, ob die Zellenmethode mit den
Argumenten Scan in 30 aufgerufen wurde. Wenn wir es bei jedem Shooting ausführen, lassen Sie uns wissen, dass es nicht mit den Werten 1030
aufgerufen wurde, sondern mit den tatsächlichen Werten 1020. Und wie Sie hier auf
dem Task-Test-Render main sehen können, heißt
es, dass die
Argumente unterschiedlich sind. Wir wollten, dass die
Argumente 1030 lauten, aber der eigentliche Aufruf
, der in Zeile 29 stattfand, wie
auch hier angegeben, wo 1020. Es gibt
uns also den Fehler im Detail
an, wie wir im Test
Turner online angewiesen haben ,
dann druckt
uns dann auch , dass das Ergebnis nicht
erfolgreich war, also war es falsch. Lassen Sie uns nun
diesen 1020 weiter überprüfen , damit er ihn zurückgeben
sollte. Okay, aber
lassen Sie uns nun überprüfen, ob die Methodenzelle mit
dem Parameterstandard 20
des Mock-Objekts vom Typ Punch Up Service
tatsächlich zweimal aufgerufen wurde. Also nochmal sollte es uns
warnen und es sollte falsch
zurückgeben, wenn wir es ausführen. Wie Sie hier sehen können, wird
wieder false zurückgegeben. Und insbesondere US-Schulden, die Testmethode ist fehlgeschlagen. Und die Funktion des
Pfandleihdienstes mit diesen Parametern
wollte zweimal aufgerufen werden. Das ist es also, was wir
wollen, dass es passiert. Das haben wir angegeben, dass
es passieren würde. Aber eigentlich war
die
Anzahl der Aufrufe einmal. Das ist ziemlich einfach,
weil es hieß Nur ein Mal hier in Zeile
26 wird nicht aufgerufen. Geben Sie nur an, dass Sie bei
Scott 30 zurückgeben sollten. Dies ist also kein
Aufruf, der ausgeführt wird C. Die
Verifizierungsmethode ist äußerst
nützlich, damit wir überprüfen können, ob der Flow in unserem Test
angegeben
wurde, tatsächlich ausgeführt wurde. Nicht nur, dass die Methoden , die Sie aufrufen möchten, tatsächlich aufgerufen
wurden, sondern auch die Zeiten, in denen
sie aufgerufen wurden. Die Tatsache, dass es angegeben hat,
dass diese Tiefe, die Dinge, die schief gelaufen sind, ist wieder sehr nützlich,
weil man auf
einer tieferen Ebene sehen kann , was genau schief
gelaufen ist. Und du kannst dann viel einfach
debuggen, du test und siehst,
was falsch passiert. Vielleicht entweder in Ihrem Schreibtisch, indem das Falsche
angeben
oder in Ihrer tatsächlichen Methode. Die Methode hat viele andere aktuelle
ergänzende Funktionen wie diese Zeiten, die hier
funktionieren. Und wir werden
sie in den zukünftigen Vorträgen
ausführlich durchgehen . Aber dafür
wollte ich Ihnen nur schnell
unser Setup-Projekt und auch
diese Funktionen des Verifizierens zeigen . Wiederum durch sie zu iterieren, dass die Funktion mit
bestimmten Parametern aufgerufen
wurde und die Zeiten , die gleich sind,
wurden
andere Funktionen aufgerufen ,
die mit der Verifizierungsmethode in Mockito
klingt für dich interessant. Ich schlage vor, dass Sie
in den zukünftigen Vorträgen dabei bleiben. Und wieder bin ich
sehr dankbar, dass du bis
zum Ende dieser Zeit bei mir stehst. Ich freue mich darauf,
euch auch im nächsten zu sehen.
9. Die Auswahl der the überprüfen: Hallo Leute und willkommen zurück zu diesem
Mockito-Test-Framework-Tutorial, können in
dem wir besser
verstehen, wie wir dieses spezielle Framework
verwenden um unsere in der
Programmiersprache von Java. In dieser Vorlesung werden wir
die Methodenverifizierung
des Frameworks Mockito
weiter eingehender verstehen die Methodenverifizierung
des . Und Sie werden
dies durch
einige andere experimentelle
Methoden tun , die mit
dieser Verifizierungsmethode arbeiten können ,
und auch mit einigen anderen verwandten Methoden
zur Überprüfung der Methode. Das Projekt, das
wir uns ansehen, was in
der letzten Vorlesung vorgestellt wird. Es war die
der Gebäudeanwendung
mit der Pfandleihfläche, der Stanzservice wieder mit der Schnittstelle und der
Gebäudeanwendung. Während eine konkrete
Klasse, die
den Pfandleihdienst in der Byte-Methode verwendete. Die Gebäudeanwendung. Dies ist die Klasse, in der wir
unsere eigentlichen Komponententests
geschrieben haben , wir Mockito. Und diese ist nur eine
echte Klasse, die alle Tests
durchführen wird , die wir haben. Irgendein Snarky ist nur der
Abrechnungsantrag nach dem Unterricht. Und das letzte Mal haben wir uns
die Verifizierungsmethode angesehen , um zu überprüfen, ob die
Funktion aufgerufen wurde. Und wir haben uns auch
die ergänzende
Methode der Times angeschaut , die mit der
Überprüfung der Reihenfolge arbeitete , um genau zu überprüfen , wie
diese Methode aufgerufen wurde. Aber mehr als
diese Zeiten funktionieren, gibt es andere
kostenlose Funktionen, die mit dieser Verifikationsmethode von
Mockito
arbeiten und wieder
sehr nützlich sind, wenn wir unsere Methoden
testen möchten. Es ist wieder nützlich, um
com oft natürliche Methode
von Glas zu überprüfen com oft natürliche Methode , die wir
testen, durchgeführt wurde. Zuallererst
müssen Sie sich an
die allgemeine Syntax
dieser Verifizierungsmethode erinnern , bei der das Schlüsselwort verifizieren handelt. Und dann kann es als
Parameter zunächst
das Objekt der Klasse annehmen, die
Sie in unserer Klasse testen möchten, es ist der Marktplatz
der Pfandleihhäusern. Dann kann es optional
einen zweiten Parameter nehmen , der eine Funktion ist. Wir werden sehen, was diese
Funktion in einer Minute macht. Aber nach dieser
tatsächlichen Überprüfung, überprüfen Sie die Methode datiert
das Argument nur das Objekt von Demokrit, das
wir testen möchten. Und dann
gibt die Syntax die Methode dieser Klasse mit
tatsächlichen Parametern an. Es überprüft nicht nur die Methode aus dem Graphen, die wir
als ersten Parameter angeben, sondern auch seine Parameter. Jetzt ist es optional, zum
zweiten Argument zurückzukehren, wird aber erneut in
die verifizierte Methode gegeben. Es gibt die Tanks , bei denen diese Funktion die
tatsächlichen Kosten hatte. Er kann entweder mal sein. Und wir haben das
letzte Mal darüber gesprochen, wie ich schon sagte, das angibt, wie oft diese eigentliche Methode mit diesen tatsächlichen
Argumenten aufgerufen wurde. Es kann aber
zumindest auch höchstens sein und network gibt zumindest an ob das Objekt der Klasse als erster Parameter,
der der Verifizierungsmethode gegeben
wurde, und ihre Methode mit diesen Argumenten aufgerufen
wurde zumindest in diesem
Test. Und dann nimmt jeder
ein Integral, was die Anzahl der Dimes
genannt wird oder äußerste Zelle genannt wird. Sie können hier ein Limit setzen, aber nicht nur das, wir können auch die Netzwerkfunktion
haben, was wiederum sehr nützlich ist da es im Grunde
das Gegenteil von
der einfachen Funktion
verifiziert ist, die überprüft ob
Schuldenfunktion aufgerufen wurde. Die zweite ergänzende
Funktion hier, die niemals
sicherstellt, dass die Methode des Objekts
, in dem diese spezifischen Parameter nie aufgerufen
wurden. Darüber hinaus können wir als
diese ergänzenden Funktionen als verifizierte Parameter entlang
des arktischen Dr. markierten Glases angeben. Wir lassen die Methode auch keine Interaktionen mehr
überprüfen. Das nimmt das
Mock-Objekt als Parameter. Was das bedeutet, überprüft es , dass alle Interaktionen überprüft
wurden. Es nimmt die tatsächliche Ursache von Methoden mit diesen
Klassenobjekten heraus. Und es überprüft, ob all diese
Kosten überprüft wurden. Und wenn es
unbestätigte Interaktionen dieses markierte Objekt gibt, wird
es falsch zurückgeben. Wir geben an, dass es, wie Sie zu diesem Zeitpunkt sehen
können, keine unbestätigten
Interaktionen
gibt. Da die Zellmethode die einzige
ist, die aufgerufen wird und sie
tatsächlich online aufgerufen wird. 29 ist, dass ich auf Zeile 39 eingestellt habe. Es gibt keine nicht überprüfte Methode
des Objekt-Punch-Up-Dienstes . Wenn wir den Test an
diesem Punkt ausführen, können
Sie sehen, dass er wahr zurückgibt und alles verifiziert ist. Aber dann in Zeile 40 habe ich die Zellenmethode
erneut für die Objektgruppe
des Dienstes aufgerufen . Und dieses Mal
schreibe ich noch einmal die Verifizierung
keine Interaktionen mehr. Was diese Funktion tut,
überprüft sie bis zu dem Punkt,
an dem sie geschrieben wurde. Also nur davor, ob es
unbestätigte Interaktionen
von Methoden des
Objekts gibt von Methoden des , das es als Parameter 41
erhält. Jetzt gebe ich diese
Funktion wieder nur an, dass online 40, ich habe die Methode
des Punch of Service genannt. Wie Sie sehen können, sind
die Argumente von 1020 DC weniger wichtig. Aber das Wichtigste
ist, dass ich es, nachdem
ich es angerufen habe, überhaupt nicht überprüft habe. Wenn wir das jetzt ausführen, wenn es hier zu den sehr guten
normalen Richtungen kommt, wird
es spüren, dass es falsch ist. Und wie Sie sehen können, heißt
es sehr detailliert dass man Richtungen kennt,
wo eine Perle, Linie 41, wie wir mit dieser Funktion ausdrücklich
gesagt haben. Aber wir fanden das Zusammenspiel
des Pfandleihdienstes bei 940. Und es
würde Sie auch für
Ihre eigene Referenzliste
aller Orte behalten , die an diesem verspotteten Objekt
online gemacht
wurden 40 wurde nicht überprüft. Online, Kampf am 29. Mittwoch. Und es sagt Ihnen, dass
dieses Zeichen hier bedeutet, dass die tatsächliche
Implikation nicht gekämpft hat. Wie Sie die
Informationen online sehen können 40, bei denen
sie nicht überprüft wurden. Und online 29, das ist
dieses, wurde überprüft. Es gibt also kein
Fragezeichen. Wenn dann weiterhin
false zurückgibt, wie Sie sich erinnern, war
dies das Ergebnis von Zeile 13, ob das
Ergebnis der
Koran-Klasse des
Glasbauanwendungsprüfers erfolgreich
war oder nicht. Und in unserem Fall
war es nicht erfolgreich. Es ging also um dieses
Tutorial, in dem wir uns
noch einmal einige andere
ergänzende Methoden zur Methode zur Verifizierung
der Mehrdosierung angeschaut haben noch einmal einige andere
ergänzende Methoden zur Methode zur . Und wir schauen uns auch die ganz letzte
Interaktion an um zu verstehen,
wie es funktioniert. Im nächsten Tutorial werden
wir einen
Blick auf die Reihenfolge der getätigten Kosten werfen und wie wir diese ebenfalls überprüfen
können. Verwenden Sie erneut das Schlüsselwort verifizieren. Wenn das für dich
interessant klingt, freue
ich mich darauf, euch dort zu
sehen. Noch einmal. Danke, dass du bei mir bleibst. Nach dem Ende dieser Vorlesung.
10. Der InOrder: Hey Leute, und willkommen
zu diesem Mockito, Java Unit Testing
Framework Tutorial, in dem wir besser verstehen,
wie wir unsere Methoden
testen können ,
die in der
Programmiersprache von Java geschrieben sind. In dieser Vorlesung werden wir
weiterhin über
die Verifizierungsmethode, das
Mockito-Framework, sprechen . Und genauer gesagt werden
wir
in dieser Vorlesung
den Altar der Anrufung
bezüglich der Methoden
von unter Objekten überprüfen den Altar der Anrufung . In unserer Testklasse. Wir können es in der Ordnungsklasse verwenden, wie Sie hier sehen können, um die Reihenfolge
der Aufrufe verschiedener
Methoden auf unserem Mock-Objekt zu überprüfen . Wir können tatsächlich
einige Methoden überspringen , die wir überprüfen
wollten. Die Methoden, die
wir überprüfen möchten,
müssen jedoch in der Reihenfolge aufgerufen werden,
damit Sie diese Kette
natürlich
jederzeit überspringen können , aber die
Verifizierung der Kette
muss in der tatsächlichen Reihenfolge liegen, in der geben Sie es in das
Order-Objekt ein, das Sie erstellen. Sie können die Kosten
zwischen den Kosten, die
Sie zu tun haben, nicht überspringen . Mit dem Objekt in der Reihenfolge. Wenn Sie sich den Code
auf dem Bildschirm ansehen, können
Sie in Zeile
40 sehen, wie gesagt,
ich habe ein
Objekt des Typs in der Reihenfolge deklariert, bei
dem es sich um eine Schnittstelle handelt, die im
Mockito-Framework
verfügbar ist . Und das wird tatsächlich
einen Objekttyp in der Reihenfolge annehmen, Mock, den einzigen Parameter. Und dann können wir mit den
Order-Objekten, die
wir erstellen, die verifizierte Methode
aufrufen , die,
wie wir wissen, wieder das verspottete Objekt,
das wir in der Testklasse
haben, als
ersten Parameter annimmt wie wir wissen, wieder das verspottete Objekt,
das wir in der Testklasse
haben, als
ersten Parameter . Und es kann optional einen anderen Parameter verwenden,
der angibt, wie oft der
Anruf getätigt wurde. Und das ist der disparate Phi. Wir haben die Syntax
, die wir inzwischen kennen,
punktieren Sie die Funktion, die
wir testen
wollten, um den Code aus
dem verspotteten Objekt und
dann von seinen Parametern zu erhalten . Durchgezogene Linie 41. Mir geht es sehr gut mit
dem Objekt in Ordnung, ob die Punch Up
Service-Zelle mit dem Argument 20
aufgerufen wurde und versuche es danach. Ich überprüfe, ob
die Zellenmethode der Objektgruppe mit den Argumenten dann in 30 zweimal aufgerufen wurde. Und danach teste
ich, ob die
Bind-Methode mit den Argumenten von 1035
der Objektgruppe aufgerufen wurde. Wir überprüfen erneut
die Reihenfolge der Anrufungen des Diskurses auf dem Markt. Objekt mit diesen
, um die Methode zu klassifizieren und darüber hinaus zu verifizieren. Wie Sie sehen können, habe ich
den Code vor
diesem Methodenaufruf ein wenig geändert . Und online 30 haben wir die Pfandleih-Service-Zelle
mit dem Argument 20 Zelle. Dies ist der Beginn
der Überprüfung der
Verkettungsaufrufe. Dann haben wir online 35362, weil die Zellmethode mit den Argumenten in 30 ausgeführt
wird. Und Sie können sehen, dass wir das auf Linie 42 testen. Und schließlich online für D3 testen
wir, ob
die Bind-Methode, die wir Standard
35
dokumentieren, als nächstes aufgerufen wurde, welches Taxi H online sehen
kann 35. Wenn wir diese Klasse jetzt ausführen, können
Sie sehen, dass sie wahr zurückgeben
wird. Aber was passiert zum Beispiel, wenn ich, anstatt die
Methode mit den Argumenten aufzurufen, dann würde ich
es in 35 Dokumente Standard 45 nennen. Da diese
theoretisch immer noch gut funktionieren,
können Sie auf dem Bildschirm sehen, dass
es nicht funktioniert. Und essen nochmal
spezifiziert im Detail, was sehr nützlich ist , dass die Überprüfung
der Inorder, es Fehler war und 35 Methode gesucht, aber nicht aufgerufen
wurde. Es wurde überall nach
der folgenden Interaktion gesucht
, nämlich der 1030. Aber diese tatsächliche Aufrufung
wurde nie aufgerufen. Ec2 erwartet den 1035, es hat tatsächlich 45. Und die Methode der
Objektfunktion des Dienstes mit dem Argument standard
five wurde in der Sequenz nie wirklich aufgerufen. Dieser falsche Fehler wurde hier angegeben. Dies war mit der im
Multi-Framework verfügbaren
In-Order-Funktion sehr nützlich sein, wenn Sie eine Abfolge von Anrufen
überprüfen möchten eine Abfolge von Anrufen
überprüfen , die Sie in
Ihrer Testklasse tätigen. Ich hoffe, du hast etwas
aus diesem Tutorial herausgeholt. Vielen Dank
Jungs, dass Sie bis zum Ende
dieses Tutorials bei
mir geblieben sind. Und wir sehen uns
im nächsten.
11. Argument: Hallo Leute und willkommen zurück
zum kleinen Keton-Tutorial. In diesem Vortrag hier werden
wir Mockito, Argumentmatcher diskutieren und
genauer gesagt
Amy Argument Matcher im
Demo Quito Framework sein . Dies sind sehr
wichtige Komponenten im
Mockito-Framework und wir werden in einem Moment sehen, warum. ging ein wenig die Dinge ein, über die wir
bereits diskutiert haben, Mockito ging ein wenig auf
die Dinge ein, über die wir
bereits diskutiert haben, und erlaubte uns,
die Mock-Objekte zu erstellen und ihnen auch Verhalten
hinzuzufügen. Die Art und Weise, wie das
Verhalten hinzugefügt wurde, war durch die Schlüsselwörter wann und dann return Schlüsselwort, das Mock-Objekt. Und denken Sie daran, dass wir das
Schlüsselwort wann hatten und dann Parameter die Funktion des
Schulden-Mock-Objekts und
auch seine Parameter
übernommen haben. Und dann das Schlüsselwort return
gefolgt vom Dokument. Was diese Methode
der markierten Objekte mit diesen spezifischen Parametern dort lesen
sollte. Das war die Art und Weise Dänemark. Lassen Sie uns unseren Monatsobjekten
spezifisches Verhalten und natürlich
markiertes Verhalten hinzufügen , damit wir sie
genau das zurückgeben können, was wir wollen. Nun, bis zu
diesem Punkt, an dem Sie hier ein Double
sehen, hatten
wir natürlich diesem Punkt, an dem Sie hier ein Double
sehen, tatsächliche Werte, wie Sie diese hier schmutzig
sehen. Das war eine ziemlich
generische Art,
das Verhalten eines Mock-Objekts zu verspotten. Aber verspätete schwache
Argumentsmatcher von Mockito machen
einen hübschen, unkomplizierten,
viel breiteren Weg um dieses Verhalten im Grunde zu
markieren. Nehmen wir an, wir
wollten das Verhalten
für jedes Argument
des gegebenen Typs markieren . In diesem Fall können wir
diese Argumentmatrix verwenden , von der ich spreche. Sie sind
in die Mockito,
Argumentmatrix-Klasse definiert und
sie sind statische Methoden. Wie Sie sehen, können
wir sie einfach hier anrufen. Wir haben über jedes Objekt gesprochen, das
mit ihnen verwandt ist. Wir können sie selbst anrufen. Wie Sie sehen können, können
wir diese
beliebige Doppelfunktion schreiben, anstatt hier
bestimmte Werte zu schreiben. Und was dies tun wird, wird tatsächlich 34
beliebige doppelte Werte zurückgeben, die als Parameter auf derselben Methode wie
der markierte Objekte,
LB-Dienst der Serviceklasse,
empfangen werden derselben Methode wie
der markierte Objekte, . Und wie Sie sehen können, habe ich hier eine
Reihe von Behauptungen gemacht, die eine Reihe
verschiedener Argumente
haben , die sich ziemlich
voneinander unterscheiden. Und für jeden von ihnen
habe ich angegeben, dass es 30 zurückgeben
sollte. Dies ist nur eine Möglichkeit
für uns zu testen, dass Verhalten von Erwachsenen
hier mit dem Argument wichtig in Mockito
tatsächlich funktioniert. Wenn wir mit der rechten Maustaste
darauf klicken und auf Ausführen klicken, werden
Sie sehen
, dass
diese Methoden für jede dieser Zellenmethoden mit all
diesen verschiedenen
Argumenten tatsächlich 30 zurückgeben sie sehen
können gibt true zurück. Wenn Sie sich daran erinnern
, dass dies das Ergebnis
der erfolgreichen Methode war , die falsche
Klassenmethode auf der JUnit. Für das Argument unserer
Testklasse. Es funktioniert tatsächlich. Diese Argumentmatrix
ist also wieder sehr nützlich, wenn Sie
allgemeines Verhalten verspotten möchten und Sie nicht einmal um
die Argumente kümmern , die die
Funktion erhält. Für jedes Argument
, das es möglicherweise erhalten kann, möchten
Sie nur
das gleiche Ergebnis zurückgeben. Vielleicht weil Sie die Methode testen
möchten und es eine andere Methode
innerhalb dieser Methode gibt und
Sie auf den Markt gegangen sind. Du willst also nur diese Funktion
essen und
keine anderen Funktionen. Und wenn es
eine andere Funktion gibt, haben Sie sie verspottet, um einen ästhetischen Wert
zurückzugeben
, der in diesem Fall,
wie gesagt, 30 sein würde . Und in diesem Szenario sind
Schulden
neben der N-Doppelmethode ziemlich wertvoll, was
Mockito Ihnen ermöglicht . Natürlich haben wir
irgendein Boolean essen und so weiter. Für jeden Datentyp, den
Sie sich vorstellen können, können Sie
jeden Datentyp ersetzen, der möglicherweise als Argument
für die Where-Methode
angegeben wird . Aber vielen Dank,
dass Sie
bis zum
Ende dieser Vorlesung bei mir geblieben sind. Und im nächsten werden
wir über Spione sprechen. Innerhalb des Mockito-Frameworks werden
wir uns
ansehen, was genau sie sind und wie sie nützlich sein können wenn wir unsere Methoden testen. Das klingt also
interessant für dich. Ich freue mich darauf, euch zu sehen. Es ist da.
12. Spione: Hallo Leute und willkommen zurück
zu diesem Mockito-Tutorial, in dem wir besser verstehen,
wie wir
unsere in der Programmiersprache
Java geschriebenen Methoden testen können . In diesem Vortrag
werden wir
über Spice, Mockito-Framework diskutieren . Und verstehe auch,
was genau sie sind und wie sie auf einer Reise
nützlich sein können. Um diese Unit-Tests zu schreiben, können
wir einen Mockito-Spion verwenden, um ein Objekt
teilweise zu verspotten. Ein Objekt teilweise zu verspotten
ist das Verspotten des Schuldenobjekts. Aber wenn wir diesen Spion
tatsächlich von einem Objekt erstellen, werden
diese realen Methoden
der Objekte aufgerufen, obwohl es sich um ein Mock-Objekt handelt. Jetzt habe ich auf dem Bildschirm
eine Implementierung, die ein großartiges Beispiel für
diese Definition
sein wird ein großartiges Beispiel für
diese Definition
sein und
Ihnen helfen wird ,
genau zu verstehen, was Spice ist. Sie kennen
dieses Projekt in Intel J, wir hatten
die Anwendung hier nicht erstellt. Und auch Mock Object. Das Mock-Objekt wurde
in das Gebäude
der Anwendung injiziert , was eigentlich
eine konkrete Methode war. Bei unserer Testmethode habe ich
zunächst
das Verhalten hinzugefügt, das der
Pfandleihdienst war, der das markierte
Objekt war, falls die Zellmethode mit zwei
aufgerufen wurde verdoppelt sich auch immer, Es sind Argumente dann
H2, H3, Stift schmutzig. Nun, was sie getan haben, habe ich ein Objekt der Art
des Abrechnungsantrags deklariert, und ich weise ihm
einen Spion für das
Abrechnungsobjekt zu . Was ich dann getan habe, nannte
ich dieses
Kuchenobjekt die Zellenmethode, Breite, die Argumente von 1020. Bewerbungsklasse für tote Abrechnungen. Die Zell-Methode. Ich habe es implementiert, damit es es zurückgibt
und auf dem Bildschirm ausgibt, die Summe der beiden Zahlen
, die als Parameter angegeben werden. Danach habe ich auch ein Objekt
vom Typ
Pfandleihdienst online 34
erstellt , und sie sind beauftragt,
den SPI des
Pfandleih-Serviceobjekts zu essen . Das war eigentlich
das verspottete Objekt in dieser Testklasse.
Und was sie getan haben. Außerdem habe ich
die Zellmethode
dieses Spionageobjekts mit
den 2323 Argumenten gedruckt . Wenn dies kein Spion
des
Pfandleihdienstes war, sollte er 30 zurückgeben,
weil wir das tun. Wenn die Zellenmethode
des Pfandleih-Serviceobjekts mit zwei Doppelgängen aufgerufen
wird, sollte sie standardmäßig Rückgabe 302223 zwei Doppelgänger sein. Und wenn wir das ausführen, können
Sie sehen, dass
dieser zuerst 30 zurückgibt. Weil dann und 20 30 sind. Und ich drucke
genau die Summe
der beiden Parameter
auf dem Bildschirm aus. Darüber hinaus gibt es 0 zurück. Und warum gibt das 0 zurück? Weil das Punch
Up Service-Objekt eigentlich aus einem Scheinglas
besteht, das nur eine Schnittstelle war. Und die Zellenmethode ist
nicht wirklich implementiert, daher gibt sie das
Standard-Double zurück, das 0 ist. Wenn das kein Spion wäre, und wir hatten tatsächlich hier statt SPI
zum Pfandleihdienst. Sie können sehen, dass es
standardmäßig 30 zurückgibt. Wie Sie hier sehen können, denn das ist es, was
das Verhalten
dieser dann
Return-Anweisung nicht tun muss. Also. Das ist der Unterschied
zwischen einem markierten Objekt mit ADD-Verhalten und
einem nicht markierten Spionageobjekt. Der Spion des
Mock-Objekts wird tatsächlich die reale Methode dieses
Objekts
aufrufen. Wir können anstelle der Spy-Klasse auch die reale Methode
aufrufen,
Methode für ein markiertes Objekt,
um die reale Methode aufzurufen. Das ist auch hier eine Variante, aber es wird nicht empfohlen
und es wird empfohlen, einen Spion für diese
Teilmarkierungen zu verwenden. Und der Hauptgrund dafür ist
, dass Spion, den Hühner, die wir haben, tatsächlich
instanziiert wird. Wenn wir ein Mock-Objekt erstellen, erstellt
der Affe TO eine
Instanz eines Objekts, das so ziemlich genau
das Skelett davon ist. Mit dem bloßen Minimum besteht die Möglichkeit, dass diese erforderlichen
Abhängigkeiten nicht initialisiert
werden,
wenn der Markt mit dem Mockito geschaffen
wird . Und dies kann am Ende zu
schlechten Ergebnissen führen. Und deshalb werden Gewürze tatsächlich anstelle
der folgenden Methode bevorzugt, eine
Methode, die auch in diesem Kontext
verfügbar ist. Ich hoffe, ihr
habt etwas aus
diesem Tutorial herausgeholt und
verstanden, was Spione sind und wie sie für uns nützlich sein
können. Nochmals
vielen Dank, dass Sie bis zum Ende
dieser Vorlesung bei
mir geblieben sind. Und ich freue mich darauf,
euch im nächsten zu sehen.