Willkommen zurück.
Lassen Sie uns jetzt unseren ersten Test schreiben, wir haben nur eine einfache Funktion, die wir ausführen, und dieses
Programm erstellt in unserer Haupt-DCPI-Datei, sagen wir, machen wir es etwas größer.
Wir sagen, dass wir eine Funktion namens do stuff haben.
Ja, sehr anschauliche Funktion.
Hier drin sagen wir einfach, dass wir eine Nummer akzeptieren.
Und wir geben einfach NUM plus fünf zurück, eine sehr, sehr einfache Funktion.
Angenommen, dies war unser Code, der unsere App erstellt. Dies ist also nur eine Funktion, aber hypothetisch haben
wir viele Funktionen, die wir testen möchten, da dies Aktionen sind, die wir in unserem Code ausführen
werden.
So funktioniert der Unit-Test.
Ich mag das.
Wir haben unsere Testdatei, und nachdem wir unsere Unit-Tests importiert haben, möchten wir importieren, während die Datei, die
wir testen möchten, in unserem Fall die Haupt-DCPI ist, also importieren wir einfach Haupt.
Was hier richtig ist.
Oder wir können die Funktion einfach auch importieren, wenn wir wollen.
Aber in unserem Fall haben wir hypothetisch viele Funktionen hier, also können wir einfach alle dort verfügbaren
Funktionen importieren, meinen und verwenden.
Der Komponententest funktioniert so, dass wir eine Klasse erstellen und sie dann hier beliebig benennen. Sie enthält alle
unsere Tests.
Nennen wir es einfach Testhaupt.
Und wir erben innerhalb dieser Klasse, was uns der Unit-Test liefert, nämlich ein Test.
Dies ist also nur eine Standardmethode für die Arbeit mit Unit-Tests, also erben wir
alle Unit-Test-Testfälle und haben diese Funktionalität jetzt in unserer Test-Hauptklasse verfügbar.
Jetzt können wir hier mit dem Testen und dem Schreiben von Code zum Testen beginnen.
Wie können wir also main testen?
Mach die Funktion.
Nun, wir sagen einfach, hey, schreiben wir hier eine Funktion oder eine Methode, weil dies Teil
einer Klasse ist, und sagen, hey, ich möchte Dinge testen.
Und hier drin wird es sich selbst empfangen.
Hier drin kann ich meinen Mantel testen, damit ich sagen kann, wenn nein hier gleich 10 ist, gebe ich
ihm nur eine Zufallszahl, dann sage ich, dass das Ergebnis gleich dem Hauptpunkt ist.
Denken Sie also daran, do Stuff kommt aus Maine, das ist die Funktion, die wir
testen möchten, also möchte ich die do Stuff-Funktion ausführen und hier die Parameternummer eingeben, die ich gerade hier angegeben habe, oder rufen wir
einfach diesen Test auf vorbereiten.
In diesem Testprogramm führen wir den Code aus und erhalten ein Ergebnis.
Und diese letzte Zeile ist der Schlüsselteil des Unit-Tests. Unit-Test erlaubt uns, self-dot zu sagen, gleich zu behaupten und gleich zu behaupten
ist etwas, das wir bekommen, wenn wir von Unit-Test erben und gleich behaupten, sagt, hey,
assert.
Oder stellen Sie sicher, dass diese beiden Parameter in unserem Fall gleich sind. Ich möchte testen, ob das Ergebnis
in unserem Fall gleich 10 ist.
Plus fünf sollte 15 ergeben.
Okay, jetzt endlich hier drinnen, wir führen einfach den Unit-Test durch.
Und wie wir das Gerät betreiben, da dies nur ein Test ist, den ich gemacht habe, hätte ich mehrere Tests durchführen
können.
Alles, was wir sagen müssen, ist Unit-Test, Punkt-Haupt.
Dadurch wird die gesamte Testdatei innerhalb des durchgeführten Tests ausgeführt.
Wenn ich das jetzt ausführe, muss ich nur Python drei, meine Befehlszeile und Testpunkt sagen.
Und ich bin OK, einen Test in null Sekunden superschnell gelaufen, das war schön und schnell.
Nehmen wir an, ich mache etwas anderes, bei dem ich gleich behaupte, dass dies gleich 10 ist, wenn ich dies ausführe.
Ich bekomme einen Fehler, was ist fehlgeschlagen?
Nun, der Funktionstest ist fehlgeschlagen.
Auf Zeile acht.
Das ist genau hier, wir haben eine Behauptung, wir haben 15 bekommen, aber wir haben 10 erwartet.
Wie cool ist das?
Ich habe jetzt einen Fehler, also muss ich meinen Code reparieren.
Hier stimmt also etwas nicht.
In meinem Fall liegt dies daran, dass ich behauptet habe.
Die Antwort ist 15, aber was ist, wenn wir hier einen weiteren Test erstellen?
Und überprüfen Sie, hey, was ist, wenn wir auch Testaufgaben haben, und dieses Mal wird das Testprogramm tatsächlich ein
Stück Schnur sein.
Was soll die Funktion also tun?
Nun, in unserem Fall gibt es uns vielleicht einen Wert, also sage ich einfach Wert.
Da dies nicht funktionieren sollte, wenn ich das jetzt ausführe, lass uns das löschen, wenn ich das jetzt ausführe.
Alles klar, ich muss testen.
Aber ich habe ein Ohr und ich sehe hier, dass ich ein Ohr bekomme, das sagt, hey, ich bekomme einen
Taip, der nur Strings verketten kann, nicht acht.
Was schlägt in diesem Fall nun eigentlich fehl?
Ist die Testdatei, denn das, was wir gerade getan haben, scheitert tatsächlich an unserer Funktion.
Aber ich sehe sofort, dass alles in Ordnung ist, das ist etwas, das wir beheben müssen, damit
ich nach Maine zurückkehren und sagen kann, hey, ich möchte sicherstellen, dass wir alle Fehler erkennen.
Wie bei thailändischen Birnen oder Wertschätzern, kann ich als erstes einfach und sagen.
Nein.
Und wenn ich das sage, um sicherzustellen, dass wir etwas in eine ganze Zahl umwandeln, und ich führe dies aus.
Im Moment erhalte ich ein Value-Air und ein Value-Litoral, damit es auf diesem Stück Schnur ausgeführt werden kann.
OK, wir können unseren Code auch verbessern, indem wir ihn in einen Tri-Außer-Block einschließen.
Rechts.
Und dann können wir fangen.
Sagen wir also außer.
Und hier, akzeptieren Sie einen Wertfehler und sagen wir als Luft und hier können wir tun, was wir wollen.
Wir können also zurückkehren, wenn wir die Luft wollen, oder wir können die Luft in unserem Fall sogar erhöhen, lass uns einfach die Luft zurückgeben.
Und ich werde Ihnen gleich zeigen, warum.
Wenn ich das jetzt laufen würde.
Sie sehen, dass mein Test fehlschlägt, aber jetzt ist es tatsächlich eine Behauptung, äh die Behauptung
äh kommt aus unserer Testdatei hier und ich behaupte, dass ich sicherstellen möchte, dass das Ergebnis und der Wert
gleich sind.
Nun, Sie sehen hier, dass es eine kleine Abweichung gibt, wir haben einen Wertfehler hier, der nicht gleich
dem Klassenwertfehler ist.
Nun, das ist ein kleiner Trick, weil wir eine Luft zurückgeben.
Es ist eigentlich eine Instanz der Werter-Klasse.
Also müssen wir so etwas tun, wir müssen sagen, hey, ist ein Beispiel.
Und sagen Sie, was ist es, ein Fall von Krieg ist ein Ergebnis, ein Fall von Wert wie dieser, aber das Problem
hier.
Lassen Sie uns dies etwas größer machen, das Problem dabei ist, dass assert equals zwei Parameter
erwartet, zwei Dinge, die gleich sein müssen.
Aber hier möchte ich nur sicherstellen, dass dies true zurückgibt, dass das Ergebnis eine Instanz von value error ist.
Also, wie kann ich das tun?
Nun, neben assert equal haben wir noch ein paar andere Methoden, die uns der Unit-Test bietet.
Wenn ich hier in der ersten Zeile zur Unit-Test-Dokumentation gehe, steht dort die Liste einer Suchmethode.
Hier sehe ich also, dass dies alle Methoden sind, um unseren Code zu bestätigen und zu testen.
Das, was wir wahrscheinlich wollen, ist dieses Asatru.
Um zu überprüfen, ob etwas wahr ist.
Also wenn ich das behaupte.
Dass dies wahr ist.
Und ich habe meinen Test durchgeführt, lass uns das löschen und meinen Test erneut ausführen.
Nun gut, ich habe zwei Tests durchgeführt und alles scheint in Ordnung zu sein, und noch einmal, um das durchzugehen, warum ist das
so?
Nun, ich führe meinen Test währenddessen durch.
Und dann werde ich den Test ausführen, Dinge tun, die in Ordnung sein werden, dann mache ich den zweiten Teil, in dem der Testparameter etwas
ist, das wir nicht wirklich wollen, das nur ein Stück Schnur ist.
Das Ergebnis gibt uns einen Wertfehler, da wir diesen Fehler abgefangen haben und den Fehler jetzt zurückgeben.
Und dann führen wir schließlich dieses Stück Code aus, hey, ist das wahr, wird das Ergebnis ein Wertfehler sein?
Sie sehen also, was wir hier tun, was wir mit unseren Tests versuchen, ist unsere Funktion zu verbessern, indem wir
einfach versuchen, sie zu zerstören.
Also wollen wir unsere Funktion brechen und sagen, hey, kann ich diese Funktion austricksen, um mir einen Erben zu geben?
Und wenn Sie das tun und ein Test fehlschlägt, kehren Sie zu einer Funktion zurück und versuchen, sie zu reparieren, so wie wir
es hier getan haben, was wirklich, wirklich cool ist.
Dies ist eine gängige Praxis beim Testen, bei der Sie versuchen, Dinge zu unterbrechen, bis die Funktion perfekt
ist.
Nun, ich möchte, dass Sie sich hier Zeit nehmen und sehen, ob wir diese Funktion unterbrechen können und vielleicht im nächsten Video
ein paar weitere Tests hinzufügen. Ich werde ein paar weitere hinzufügen, um diese Funktion noch besser zu machen.
Wir sehen uns im nächsten.