Transkripte
1. Einführung: Willkommen bei der testgesteuerten Entwicklung in dotnet Core, dem Handbuch. Ich bin Ihre Instruktorreise oder Williams und ich bin Software-Ingenieur und Literatur seit über einem Jahrzehnt. Jetzt bist du wahrscheinlich neugierig, dass du den Kurstitel gesehen hast und du
fragst dich , was genau die testgesteuerte Entwicklung ist? Nun, es test-gesteuerte Entwicklung ist ein Softwareentwicklungsprozess, der
darauf beruht, dass Anforderungen als Testfälle geschrieben werden, bevor echter Code geschrieben wird. Also, das ist richtig, Sie haben das richtig gelesen? Wir machen die Komponententests. Erster. Ich weiß, dass das Wort Test Sie zu diesem Kurs gebracht hat. Und Sie sehen sich das Wort Test an, ich frage mich, okay, ich weiß ein wenig darüber, was Komponententests sind, aber ich bin mir nicht unbedingt sicher, wie ich sie in meinem Code verwenden kann. Nun, das ist der perfekte Kurs für dich. TDD ist also ein Prozess, um sicherzustellen, dass wir testbaren Code schreiben und es ist modular genug und es ist einfach genug, um die Aufgabe zu erledigen. Es ist auch ein Prozess, der sicherstellt, dass wir maximale Code-Abdeckung haben. Wenn wir also brechen Änderungen und später im Code vornehmen, wird
es nicht notwendigerweise brechen, aber sie passen direkt hinein. Jetzt haben wir, was wir den testgesteuerten Entwicklungszyklus nennen. In diesem Zyklus machen wir unseren roten Test,
was bedeutet, dass wir den Komponententest schreiben. Es gibt keinen Code, keinen unterstützenden Code, aber wenn wir auf dem Test modellieren, müssen
wir alle Artefakte erstellen, die ohnehin im echten Code benötigt werden. Dies hilft uns also mit unseren anfänglichen API- oder anfänglichen Code-Design-Konzepten. Dann schreiben wir den Code zu viel die Tests, die wir geschrieben haben. Also haben wir einen Test geschrieben, um die Anforderung zu erfüllen, nirgends den Code zu schreiben, um den Test zu entsprechen. Und dann wäre das ultimative Ergebnis, dass wir
den Code schreiben , um den Test zu entsprechen, und wir erneut testen und einen grünen Test erhalten. Der rote Test bedeutet also, dass es fehlschlägt. Es gibt keinen Code, um diesen Test zu unterstützen. Wir schreiben den Code und dann testen wir erneut, und dieser Test sollte jetzt bestehen. Das bedeutet also, dass der Code, den wir geschrieben haben, jetzt die Anforderung
erfüllen wird , für die der Test geschrieben wurde. So, wenn wir dies tun und oder Anforderungen wachsen oder unser Verständnis dessen, was implementiert werden muss, verbessert. Wir refactorieren und wiederholen diesen Prozess. Nun, viele Entwickler Nobel Unit-Tests, aber nicht viele Entwickler tatsächlich üben es. Religiös, sie werden es in dem Maße praktiziert, dass sie brauchen. 1, sagt es Ihnen, testbaren Code zu schreiben. Sie werden immer denkbar sein, Ihren Code so zu schreiben , dass ich verschiedene Aspekte davon testen kann ohne sich darum kümmern zu müssen, zu viele Dinge gleichzeitig zu initialisieren oder zu verspotten. Aber all die Dinge sind injizierbar. Es hilft also, das, was wir die soliden Prinzipien nennen, von Anfang an durchzusetzen. Es führt normalerweise zu viel saubereren und prägnanten Code und beinhaltet normalerweise, dass Sie beim Schreiben Ihres Codes geeignete Praktiken einlegen. Außerdem erhalten Sie fast sofortiges Feedback darüber, ob Ihr Code funktioniert oder nicht weil Sie nur automatisierte Tests gegen einen Testfall durchführen. Sie erstellen also ein Szenario, in dem Ihr Test bestehen sollte, wahrscheinlich eines, wenn die Daten waren, aber es sollte dies tun. Sie erstellen einfach Ihre Szenarien und Sie erhalten sofortiges Feedback. Bürger müssen warten, wie lange eine Bewerbung aufspulen kann. Und dann setzst du die Werte ein und dann siehst du das Feedback. Sie können diese Dinge automatisieren, und es wird die Zeit, die Sie mit dem Testen und erneuten Testen von Code verbringen, erheblich reduzieren. Jetzt mit allem, was gesagt hat, gibt es Nachteile und einige von ihnen beinhalten die Tatsache, dass es zeitaufwendig ist, weil Sie tatsächlich doppelt so viel Code schreiben, wie Sie wahrscheinlich
hätten , wenn Sie nur den Code schreiben würden von Anfang an. Es könnte auch schwierig für Anfänger sein, die anfänglich zu bekommen, aber hey, deshalb sind wir alle hier gerade jetzt dieser Kurs ist sehr anfängerfreundlich. Sie lernen, wie Sie ECC-Unit verwenden, um Tests Projekte halten halten, um
Drittanbieter-Bibliotheken zu verwenden , um Tests und Behauptungen viel einfacher zu machen. Wir werden uns ansehen, wie wir den gesamten Testzyklus durchführen. Also werden wir Tests schreiben und dann den Code implementieren, und dann sind wir Faktor, wenn die Anwendung wächst und wir schauen uns nur testgesteuerte Entwicklung an und werfen diesen Kurs, wir werden einige der Fallstricke überprüfen, aber letztendlich wollen wir , um einfach Ihre Komponententests zu erweitern und Ihnen zu helfen, eine Wertschätzung dafür zu haben, warum es wichtig ist und wie es mit maximaler Effizienz gemacht werden kann. Jetzt eine kurze Vorschau von dem, was wir tun werden. Erstens, wir werden eine echte Anwendung erstellen. Es wird nicht die komplizierteste Anwendung sein, aber es wird gerade genug sein, dass wir sehen können wie verschiedene Ebenen der Komponententests funktionieren können, wie es sich im Laufe der Zeit entwickelt, und einige der grundlegenden oder hohen Ebene Anforderungen Artefakt, dass man, Es ist ein Zimmer Buchung Anwendung. Also muss ich in Logik setzen, um zu regieren. Ganze Zimmer ist gebucht, was angefordert wird, welche Art von Feedback die Anwendung geben wird. Und wir werden schließlich an eine Datenbank angeschlossen. Also müssen wir sicherstellen, dass alle diese Verbindungen funktionieren. Also sage ich Ihnen, dass
wir am Ende dieses Kurses etwas gebaut hätten, das dem entspricht, wie unsere echte Unternehmensanwendung aussehen würde. Und wir hätten es mit testgesteuerter Entwicklung getan. Mit all dem, was gesagt und getan ist, ist
dies testgesteuerte Entwicklung mit dotnet Core, dem Handbuch. Und ich kann es kaum erwarten, dich im Kurs zu sehen.
2. Test-Projekt erstellen: Na gut, Leute, also lasst uns in diesem Kurs weitermachen und wir werden anfangen, indem wir Künstlerprojekte aufbauen. Also, wenn Sie noch nicht über Visual Studio, er kann gehen und erhalten 2019 sind die neueste Version, die Ihnen zum Zeitpunkt dieser Aufnahme zur Verfügung steht. Aber was wir tun werden, ist ein neues Projekt zu erstellen. Und wir wollen eine x-Unit testet Projekte oder einfach nur eine Suche nach x-Einheiten. Nun, beachten Sie, dass ja, wir verwenden x unit für diesen Kurs. Aber die allgemeinen Prinzipien des Komponententests können auf
ein End-Unit-Projekt oder sogar ein normales Microsoft-Testprojekt angewendet werden. Denn wenn Sie nur einen Test oder ein Testprojekt eingeben, bin
ich mir sicher, dass Sie MSTest sehen werden. Da gehen wir. Und Unit-Testprojekt sowie die X-Unit-Testprojekte. Also werde ich Ihnen mit x-Einheiten zeigen, aber die allgemeinen Prinzipien des Komponententests werden wahr bleiben. Also lasst uns voran gehen und H-Einheiten treffen. Und wir werden diesen Projektraum anrufen, um Dot Core zu buchen, Punkt. Also Raum Aufbauname der Anwendung. Kern wird sein, wo wir alle Geschäftslogik haben. Also nenne ich es nur Punktkern, aber dann werden wir Komponententests um das Kernprojekt schreiben. Für den Namen der Lösung. Wir werden das umbenennen. Also werde ich nur sagen, Zimmer buchen, das ist in Lösung, aber im Moment haben wir es nur mit einem Testprojekt zu tun. Also wieder, gehen Sie voran und erstellen Sie diese, klicken Sie auf Weiter. Und ja, wir verwenden dotnet fünf Mal dieser Aufnahme. Wenn es eine kleine Version gibt und sich frei fühlen, es zu benutzen, was wahrscheinlich um sechs gemacht werden würde. Und dann gehen wir weiter und drücken „Erstellen“. Das Endergebnis dieser Aktivität ist also, dass wir dieses neue Projekt Zimmer buchen Dot Core Dot Tests
bekommen. Wir erhalten auch diese Standarddatei namens Unittest eins. Jetzt bin ich ganz darauf, einen Komponententest in diesem speziellen Video zu schreiben, aber wir werden bestimmte Konfigurationen durchlaufen, die uns das Ding einfach erleichtern wird. Ich werde mir auch die Grundlagen dessen ansehen, was ein Komponententest ist. Also das erste, was ich tun werde, ist mit der rechten Maustaste auf unsere Projektdatei für das Testprojekt und gehen Sie zu Eigenschaften. Und was ich tun werde, ist den Standard-Namespace zu ändern. Manchmal meine Visual Studio glitchy Oberfläche des Switches 15 Tabs. Aber wir werden den Standard-Namespace in Booking dot core ändern,
jemand, der das entfernen kann, weil das, was passiert, ist, dass es tatsächlich einfacher macht, Ressourcen über die Projekte,
das Testprojekt und den tatsächlichen Punktkern zu teilen -Projekt, wenn er online kommt. Und wenn sie denselben Namespace haben, ist
es einfach, die Ressourcen zu teilen, die definitiv zwischen den beiden geteilt werden müssen. Also sorge ich nur dafür, dass alles damit in
Ordnung ist , und dann kann ich das speichern und schließen. Ich habe Konfigurationen gesagt, aber das ist wirklich die Einzige, die wir zumindest brauchen, oder? Nein, nein. In Bezug auf die Grundlagen eines Komponententests bemerken
Sie, dass wir diese Anmerkung über der Methode namens Fett haben. Nun sagt dies der IDE, dem Programm alles, was dies nur ein Komponententest
ist, dies in die gesamte Laufzeit der Anwendung einfließen. Es ist ein Komponententest. Also, jedes Mal, wenn wir Komponententests schreiben, werden
wir zumindest diese Anmerkung haben wollen, die Fett sagt. Und andere Anmerkung, die wir uns ansehen werden, ist Theorie. Aber wir werden irgendwann dorthin kommen. Das ist also Schritt Nummer eins. Das nächste, was zu beachten ist, ist, dass ein Komponententest normalerweise drei Schritte dazu hat. Du hast die Orange, wir haben das Herz, und dann haben wir behauptet. Also, im Allgemeinen, die Irangen, wo Sie alle Daten vorbereiten, bereiten
Sie Ihre Test-Artefakte. Wissen Sie, wann immer Sie etwas mit einer Benutzeroberfläche testen möchten, kennen Sie
normalerweise einen Wert, den Sie eingeben müssen, um zu erhalten, welche Art von Antwort für welches Ergebnis Sie testen. Also, das ist, was sie angeordnet sind Teil ist vorwärts, wenn
Objekte zu erstellen sind Repräsentationen von allen Daten, die wir erwarten würden, gegen zu testen. Das ist, was wir tun, wir erschaffen sie. Dann werden wir überall optimieren, wenn wir tatsächlich einen Aufruf
der Methode simulieren , von der wir hoffen, dass aufgerufen werden sollte, wenn wir eine solche Aktion ausführen, dann wäre unsere Behauptungen null, was sehen, ob der Test bestanden oder fehlschlägt. Denn dann müssen wir behaupten, dass dies die alte Spalte mit dieser Eingabe für diese Methode ist. Oder ist es passiert? Ist es nicht passiert? Wenn wir also sagen, dass dies passieren sollte und es nicht passiert ist, wird sich
dieser Test im Grunde fühlen. Und dann müssen wir entweder den Code schreiben, um ihn grün
zu machen, oder es wäre die Rolle des Gerichts und führte den Test durch. Das bedeutet, dass wahrscheinlich etwas mit
dem Code nicht stimmt oder etwas falsch auf dem Weg ist. Das ist also im Grunde, wie ein Komponententest funktioniert. Das ist nur die Theorie. Und ich versuche nicht, es so einfach wie möglich zu halten, damit du nicht denkst, dass es
zu schwer oder zu schwer ist zu konzeptualisieren, wie dieses Ding funktionieren wird. Nun, Visual Studio macht es sehr einfach, durch
Tests zu navigieren , weil sie uns einen Test Explorer geben. Und Sie können zu diesem Text Test Explorer gelangen, indem Sie zu
Ansicht gehen und dann auf Test Explorer klicken oder Control E und
T tun . Also dieser Test Explorer wird im Grunde nur
eine Schnittstelle sein , die uns alle Unit-Tests zeigt, die ausstehen alle Tests, Projekte ein, alle Komponententests statt Projekte AC haben wir Komponententest 1, das ist unsere Klasse I dort haben wir test1, oder? Und dann würde es uns erlauben, diese Tests durchzuführen. Jetzt habe ich gerade auf Ausführen geklickt, aber nichts passiert, weil es nichts zu laufen gibt. Also im Wesentlichen, wenn wir Komponententests schreiben, eine bestimmte Methode besitzen, würden
Sie tatsächlich sehen,
dass die Navigationseigenschaften innerhalb von Visual Studio erscheinen, um zu zeigen, welche Methode wie viele Tests hat, wie viele Tests fehlschlagen oder Weitergabe Ideen, diese eine Methode, et cetera. Ein weiterer Vorteil von Komponententests in Ihrem Angebot besteht darin, dass Sie in bestimmten DevOps-Pipelines das einrichten können, was wir als gated Builds
bezeichnen. Also DevOps Pipelines, wenn Sie kontinuierliche Entwicklung,
kontinuierliche Integration wollten , arbeiten Sie an einem Team, verschiedene Leute betrogen in verschiedenen Teilen des Codes. Sie möchten sicherstellen, dass, wenn jemand seinen Code eincheckt , alle Komponententests, die die Arbeit verwenden, weiterhin funktionieren. Und alle neuen, sie haben unsere Politik eingeführt,
tut mir leid, dass sie nicht funktionieren. Wie Biologen sagen, ich wollte sicherstellen, dass alle Tests bestehen, bevor Sie diesen neuen Code in ein zentrales Repository für das gesamte Team
zulassen. Unit-Tests können also als Wächter davor fungieren. Also mit all dem, was gesagt und getan, noch einmal, nur eine kleine Theorie, nur ein wenig Verständnis, warum wir Komponententests schreiben würden. Und wenn wir zurückkommen, lesen wir unseren ersten Test für unsere erste Anforderung.
3. Einheitstest: Erstelle einen Einheitstest mit der Anforderung: Na gut, Leute, also lasst uns weitermachen und unseren allerersten Komponententest erstellen. Unsere erste Anforderung ist, dass
wir, wenn eine bestimmte Methode aufgerufen wird, um die Buchung zu bearbeiten , eine bestimmte Art von Ergebnissen mit allen Buchungsdetails erwarten. Das ist also unsere erste Anforderung, die wir erfüllen werden. Jetzt, natürlich, wie wir ein besseres Verständnis für andere Anforderungen sind Zitat bekommen, unquotierte Blöcke werden sich entwickeln. Also mache ich es in einer Minute. Blöcke, so dass wir sehen können, wie sich der Code entwickelt, wie wir Halle umgestalten, wir wiederholen und alles, was wir wiederholen, und im Grunde, wie der Zyklus funktioniert. Also mit all dem, was gesagt und genug von meinem Monolog getan, lasst uns anfangen. Also werde ich den Komponententest löschen, den wir derzeit sehen, und wir werden eine neue Klasse erstellen. Und ich ging, um diesen einen Raum Buchungsanfrage Prozessortest für beschreibende, oder es ist nichts falsch daran, mit ihren Klassennamen beschreibend zu sein. Jeder, der es auf deine Klasse schaut, sollte wissen, was los ist. Dies ist also ein Test für unsere Zimmerbuchungsanfragen, den Prozessor, den wir irgendwann bauen wollen. Also gehe ich weiter und füge hinzu, triff die Öffentlichkeit der Klasse. Und dann im Inneren werde
ich öffentliche Leere haben. Sollte die Zimmerbuchung eine Anfrage zurückgeben. Und es ist eine Methode, natürlich, nein, ich wollte hier pausieren und 0, dass es
verschiedene Konventionen gibt , wenn man einige Leute benennt, sie verwenden die Unterstriche. Einige DB2 verwenden keine Unterstriche. Sie ziehen es vor, es alle CamelCase oder Pascal Fall eher zu haben. Es gibt also verschiedene Konventionen. Etwas Ebola, richtig? Eins zu übergeben, eins zu scheitern, und Sie haben verschiedene Möglichkeiten, sich ihm zu nähern. Also zeige ich nur darauf hin, ich versuchen werde, die Unterstriche für die Sache zu verwenden, die es tut. Ich mochte die Unterstriche im Testset oder wirklich, dass sie woanders verwendet werden. Ich verwende sie gerne, wenn ich meine Testmethoden benenne. Vielleicht nicht, aber der Punkt ist, dass Sie tun, was mit Ihnen angenehm
ist, solange Ihr Code lesbar ist. Ordnung? Also innerhalb dieses Tests, und noch einmal ist es ein Test, also müssen wir sicherstellen, dass wir ihm unsere Attribute geben
, der Fox-Steuerpunkt ist, um den fehlenden Namespace für x-Einheit einzuschließen. Da gehen wir. Das könnte also etwas anderes sein, diese Annotation könnte etwas anderes sein, wenn Sie ein anderes Testprojekt verwenden. Aber wieder einmal konzentriere ich mich auf x Einheiten in diesem Kurs. Nun, was wir tun werden, ist der orangefarbene Shawn von diesen ganzen Testbedrohungen, die unsere Test-Artefakte erstellen. Also brauche ich eine Instanz des tatsächlichen Prozessors, den wir testen müssen. Also werde ich var Zimmer Buchungsprozessor erstellen, oder ich würde es einfach Prozessor nennen, ist gleich einer neuen Instanz von etwas, das noch nicht existiert. Ok? Wie lassen wir es existieren? Nun, ich werde nur Kontrollpunkte machen. Ich möchte nicht sagen, dass es die Klasse in einer neuen Datei generiert, also ist das alles. Machen Sie voran und erstellen Sie das, damit es null ist. Sie können voran gehen und füllen Sie es mit allen Eigenschaften, die wir wissen, dass es brauchen wird, sind die Methoden, die es brauchen wird. Nun, bevor ich das mache, was ich tun werde, ist RE in etwas Sünde und Durchfall und Jean Phase. Warum sind die Anforderungen denkbar? Ich weiß, dass eine Anfrage vorbeikommen muss und zwei, ich muss etwas mit den gleichen Werten aus der Anfrage zurückgeben, die gerade hereinkam. Dies ist der Prozessor, der die Anfrage verarbeiten und die gesamte Geschäftslogik ausführen wird. Aber letztendlich weiß ich, dass
ich in meinem Arrangement Mach machen muss, wie unsere Wünsche aussehen werden. Also werde ich nur sagen, var Buchungsanfrage ist gleich einer neuen Instanz aus und ich werde nur Zimmerbuchungsanfrage verwenden. Und das wird ein paar Eigenschaften haben. Also nichts dagegen, dass diese Dinge nicht existieren. Das ist ein Punkt der testgesteuerten Entwicklung. Modellieren was? Also weiß ich, dass die Anwendung bestimmte Aufgaben erledigen muss, oder? Also Buchungsanfrage ist gleich neuen Zimmerbuchungsanfragen. Und das wird oder die Felder vollständigen Namen haben. Und ich kann einfach in Testnamen setzen. Also wieder, das sind Testfile, ist, dass sie nicht unbedingt
realisieren müssen , was sie wirklich genug sein müssen, um zu repräsentieren, was hereinkommen könnte. Testen Sie request.com. Und dann haben wir das Datum, was ich sagen kann, ist gleich jedem neuen Datum,
Zeit, wo wir im Jahr,
Monat und Tag passieren . So wird das also aussehen. Dieses Objekt ist eine Buchungsanfrage Objekt. Also, nachdem ich all das getan
habe, kann ich sagen, control dot legit, nein, es sollte eine neue Datei erstellen und unser Visual Studio
so intelligent aussehen , dass es sagt, die Klasse mit diesen Eigenschaften zu generieren und ich werde sagen, warum. Danke. Ich möchte, dass du das tust. Und ich kann einfach rüber springen und sicherstellen, dass alles damit in Ordnung ist. Und das sieht gut aus für mich. Also gehe ich einfach zurück zu meinem Test und meinen Kontinenten. Also habe ich die Prozessorklasse erstellt, ich habe das Anforderungskreuz erstellt. Nein, ich brauche eine Methode, die die Anfrage tatsächlich verarbeiten würde. Wir sind, aber lassen Sie uns das innerhalb der Prozessoren machen. Also werde ich sagen, dass der Prozessor eine Methode haben wird, natürlich nicht existiert. Aber es wird der Buchraum genannt werden, der die Anfrage aufnehmen wird. Okay, also nenne ich meine Methoden R. Das ist, was ich beabsichtige, die Methoden zu nennen. Natürlich hätte ich diesen Prozess Anfragen oder etwas anderes nennen können, aber ich plane nur, dass es Bräutigam wird. Es nimmt in unserem Anforderungsobjekt. Und wir sollen zurückkehren, oder? Wir sollten zurückkehren. Das hat also Zimmeranfragen, Zimmerbuchungsanfragen zurückgegeben. Also werde ich sagen oder sollte die Antwort auf die Zimmerbuchung zurückgeben. Und ich werde nur sagen, welche Werte mit Anforderungswerten sind. Ich denke, das ist klar genug, Fred. Jeder, der das liest, wird wissen, dass dies das ist, worauf die Methode getestet wird. Also dann bedeutet das, ich brauche Zimmerbuchung, Ergebnisklasse für andere, die die Objekte Ergebnisse genannt werden. Und sagen Sie, es ist gleich, was Buchzimmer zurückkehren würde. Was bedeutet, dass der Buchraum etwas von diesem Typ zurückgeben soll, was es nicht gibt. Natürlich werde
ich noch einmal Punkte kontrollieren und diesen Typ in seiner eigenen Klasse generieren. In Ordnung, das ist also erledigt. Was noch etwas zu beachten ist, ist, dass wir diese Methode noch nicht haben. Also diese Reihe von Anfragen, die ein Tippfehler von meiner Seite war. Also sollte dies Buchungsanfrage und null Buchung unseres Buchzimmers gewesen sein. Ich ging zum Kontrollpunkt und lasse es diese Methode generieren. Nein, es kann ableiten, welcher Datentyp der Parameter sein muss, weil alle Fehler, die wir verwenden. Also entschuldige ich mich für die Verwendung der falschen Variable dort. Er hätte Anfragen buchen sollen. Sie sind nicht nur eine Bitte. Und wer das ist, ist unsere generative Methode. Das sieht gut aus, aber es ist natürlich nicht umgesetzt. Also lassen Sie uns überprüfen, was wir bisher getan haben. All dies könnte als der Bereich betrachtet werden. Also haben wir Beispieldaten angeordnet. Wir sind ein Objekt angeordnet, was wir testen müssen. Dann ist hier, wo wir tatsächlich die Methode aufrufen und versuchen, die Ergebnisse zu erhalten. Das bedeutet also, dass dies das OK genannt wird. In Ordnung. So arrangierten wir dann haben wir nein gehandelt. Wir müssen das behaupten, damit wir sicherstellen müssen, dass unsere Annahmen korrekt sind, was wir erwarten. Und obwohl es eingebaut ist, gibt es ein integriertes Schlüsselwort für Behauptungen in überschritten namens Assert, richtig? Aber dann gibt es andere Bibliotheken und ich habe gesehen,
ich würde Ihnen zeigen, eine in Kürze aufgerufen, so dass Sie mit der rechten Maustaste klicken können, springen Sie über, um Pakete zu bekommen. Und wenn Sie nach klug suchen, wäre es ganz oben in der Liste, wo es
eine Art fließende Behauptung Art von Stilwerkzeug verwendet , wie Sie Ihren Code schreiben können. Also ich mag es tatsächlich, es ist entweder einfach voran und installieren Sie es. Selbstverständlich akzeptieren wir alle Allgemeinen Geschäftsbedingungen. Und wenn das erledigt ist, können wir wieder zu unserem Code springen. Also wollte ich Ihnen beide Syntax zeigen, aber Sie können Ihre eigene Entscheidung treffen, ob sie die Bibliothek mochten oder nicht. Sorry, ich möchte den Standard verwenden, das ist in Ordnung. Also kann ich sagen, dass Punkte behaupten. Und an diesem Punkt sollte es die Antwort mit Werten zurückgeben. Das bedeutet also, dass ich am meisten MC bekomme, eine Antwort oder unser Ergebnis, richtig? So kann ich nicht null sehen. Ich behaupte, dass das Objekt, das ich hier bitte, nicht null ist. In diesem Fall möchte ich behaupten, dass das Ergebnis NICHT null ist. Wenn ich in Kürze einen Ergebnispunkt verwenden würde, könnte ich sagen, aber dann müsste ich eine using-Anweisung für die kluge hinzufügen. So sehen Sie einfach die Verwendung sollte Link. So kann ich mir das Objekt ansehen, auf das ich
die Behauptung setzen möchte und Ergebnispunkt sehen. Und ich kann sehen, sollten und schauen Sie sich alle Methoden, die Sie bekommen, richtig. Es sollte also null sein oder sollte nicht null sein. Alles klar, es ist, ich kann sehen, dass es nicht null sein sollte. Dies ermöglicht es mir auch, benutzerdefinierte Nachrichten einzugeben, so dass ich, wenn ich den Testlauf halte, genau sehen kann, was aufgrund der Nachricht, die ich einfüge, fehlgeschlagen ist. Also ist es ziemlich cool. Ich mag es und es ist flexibel. So oder so. Ich werde dich nicht mit der Technik
der Behauptung gegen die Soll-Bibliothek langweilen. Ich möchte nur die Aktivität richtig durchstehen. So können wir an dieser Stelle behaupten, dass dies nicht annulliert werden sollte, wollte körnig werden. Und am Ende des Tages oder Assertions basieren im Grunde auf welcher Grundlage Sie konvertieren möchten, um sicherzustellen, dass der Code, den Sie testen, tatsächlich richtig getestet wird. So können jährliche Zeug Behauptungen von
jemand anderem die Liste der Behauptungen unterscheiden , basierend auf dem, was sie für wichtig halten. Aber am Ende des Tages hoffe
ich, dass sich jeder einigen kann, was auf der Grundlage des Tests zumindest geltend gemacht werden sollte oder abgedeckt werden sollte. Damit wir Granulom bekommen können. Diese sehen die mit den Anforderungswerten, oder? Der Testname erklärt also genau, was passieren soll. Erstens, die Antwort sollte nicht null sein, in Ordnung, also sollte es keine Antwort geben und zwei, dort mit den Anforderungswerten. Das bedeutet also, was auch immer im Ergebnis ist, sollte auch das sein, was in der Antwort ist. So kann ich dot behaupten und ich kann sagen, gleich die Anfrage. Und dann sod diesen Punkt, die Buchungen oder halten Sie ein Szenario Quests die Buchungsanfragen. Ich denke, ich muss das einfach umbenennen, um zu bitten. Nun, die Buchungsanfrage. Lass mich das machen, was den Fehler macht. Also fordern Sie diese Kontrollpunkte und wenig, benennen Sie sie alle um. Da gehen wir. Also fragen Sie Punkte, vollständiger Name. Und dann können wir Ergebnisse sagen. Hotspot-Ergebnis enthält keine Felder,
da es auch die CAM-Gebühren haben muss, die die Anforderung hat. Richtig. Also an dieser Stelle, Refactor und ich dafür gesorgt, dass ihre Ergebnisse auf ihrer Suche. Ich mag, nein, stört nicht die Tatsache, dass ich diese Felder gerade noch wiederhole. Wir werden umgestalten und deshalb haben Sie das Refactoring. An diesem Punkt. Ich will nur den Test durchstehen, sicherstellen, dass alles in Ordnung ist. In Ordnung. Also möchte ich behaupten, dass der vollständige Name in der Anfrage gleich dem vollständigen Namen in den Ergebnissen ist. Und das kann ich für die anderen Felder tun. Duplizieren Sie einfach diese Zeile mit Control D und C, E-Mail muss die gleiche wie E-Mail sein und es muss die gleiche sein, als ob Sie sicher verwenden würden. Und ich werde einfach den Code hier neu anordnen, dann würdest du etwas wie Ergebnispunkt sagen und dann sollte
das Feld, das voller Name sein sollte, sein. Das sollte es also sein. Da gehen wir. Und dann innerhalb dessen setzen
Sie ein, was auch immer das erwartete Ergebnis ist oder das Ergebnis das gleiche sein
sollte wie die Nachdenklichkeit der Anfrage. Und das ist es im Grunde. Also zwei verschiedene Syntaxen, zwei verschiedene Wege. Und am Ende des Tages
gibt es andere Bibliotheken, die Sie verwenden können um wahrscheinlich lesbarere oder komfortabler aussehende Behauptungen zu haben. Aber das liegt an dir. Ich zeige Ihnen nur Ihre Optionen. Ich mag, wie ich schon sagte, das ist nur meine Vorliebe, die ich ganz mag. Die Syntax fließt, wenn ich die sollen Assertionen verwende, richtig? Also für mich kann ich einfach duplizieren und dann mache ich dasselbe. Ergebnis Punkt E-Mail sollte Anforderungspunkt E-Mail und Anfrage Punkt d sein. Also treffen Sie Ihre Wahl, was auch immer Sie bevorzugen. Nun, wenn ich das alles nach einem Build betrachte, sehe
ich, dass es erfolgreich war. Also habe ich keine Syntaxfehler oder irgendetwas. Und ich weiß, dass ACT-Test mit der tatsächlichen Klasse ist nichts noch implementiert, oder? Also nein, ich kann den Test durchführen. Ich kann diesen kleinen Indikator hier klicken und ich kann auf Ausführen klicken. Also kann ich das von hier aus tun, oder ich könnte meinen Test Explorer starten, um den Test von dort aus auszuführen. Nun, es ist entweder klicken Sie einfach auf Ausführen, die zunächst Statistiken für gestartet wird. Und wir sehen hier, dass wir einen fehlgeschlagenen Test haben. Also lesen Tests wegen des Indikators System.Out nicht implementiert Ausnahme. Mit anderen Worten, es versucht, die Methode aufzurufen, aber es ist nicht implementiert. Warum wird diese spezifische Ausnahme gegeben? Das liegt daran, wenn wir zu der Methode gehen und ich nur verwendet habe, wenn 12 zu springen, dann sehen wir hier, dass die, es hat einen Test mit ihm verbunden und es ist nicht vorbei und es durch die nicht implementierte Ausnahme. Okay, wenn wir zurückkommen, werden
wir den Code hier schreiben, dass wir, wenn wir den Test ausführen, zumindest so weit wie die Behauptungen kommen sollten und dann können wir sehen, wie diese aussehen.
4. Implementierung: Code zum Rücksenden von Daten: Hey Leute, das letzte Mal, als wir hier waren, haben wir unsere Tests geschrieben und null, wir kommen bei diesem Wurzeltest zu mir zurück, Gier. Also nur als Zusammenfassung schreiben
wir einen Test, der die Antwort auf die Zimmerbuchung mit
dem Anfragetext zurückgeben sollte , ist das, was Künstlerszenario ist. Und wir haben einige schlechte Anfragen arrangiert, die die Felder email,
fullname und Anfragen D es umfasst , wir haben unseren Prozessor, der noch nicht implementiert ist, oder wir haben die Datei, aber die Methode Buch Raum ist noch nicht implementiert, aber wir haben bestimmte Behauptungen, die wir gesehen haben, wenn wir diesen Test durchführen. Wir haben uns auch die beiden Möglichkeiten angesehen, wie Sie Behauptungen machen können. Dieser ist der natürliche Weg, der innerhalb der Einheiten aus der Box kommt. Und ich stellte eine neue Bibliothek vor,
die kurz genannt wird , die bis zur fließenden Art von Behauptung dazu bringt. Sie haben auch andere Behauptungsbibliotheken wie fließende Behauptungen, und es gibt andere, aber wie gesagt, Sie wählen eine aus und halten sich daran, wenn Sie sich damit wohl fühlen. Kein Problem. Wir sind also hier, um unsere Buchraum-Methode zu implementieren. Nun ist der Test, richtig, keine Anforderung, für die wir Code schreiben möchten, sicherzustellen, dass
alles, was als Ergebnis zurückgegeben wird, alle Werte hat, die in Anforderungen waren. Das macht uns eine einfache Implementierung wirklich. Also alles, was wir wirklich tun müssen, ist eine neue Instanz
des Zimmerbuchungsergebnisses zurückzugeben , wo seine Felder, vollständige Name der Anfrage gleich wären, Punkt das Feld oder Buchungsanfragen oder andere Punkt das Feld mit dem gleichen Namen. Und jetzt diese duplizieren und dann das gleiche für
Datum und das gleiche für E-Mail tun , gab es niedrig. Am Ende müssen wir also
nur sehen, dass es ein Objekt zurückgibt, das unseren Behauptungen entspricht. Also, wenn das erledigt ist, lassen Sie uns unseren Test noch einmal durchführen. Und voila, wir haben jetzt einen grünen Test. So werden Sie hier sehen, dass es anzeigt, dass ein Test aus einem besteht. Unsere Testbehauptungen funktionieren also nicht. Wenn ich also all diese Behauptungen kommentieren und den Test erneut ausführen würde, würden
Sie sehen, dass es gut funktioniert. Also, ob Sie dies Licht behaupten oder Sie kurz und Art von diesem Stil verwenden, sie werden genau die gleiche Art und Weise funktionieren. Also das ist wirklich alles, was es gibt, um Code zu diesem Zeitpunkt zu implementieren, die Phase, zumindest um unseren Test, BI grünen Test zu haben. Also einmal eine Pause hier, und wenn wir zurückkommen, werden
wir den Code als unsere Vorschau umgestalten, warum wir zurückkommen und eins umgestalten müssen. Sie haben gesehen, dass wir Anfragen haben, dann haben wir Ergebnisse. Beide sind irgendwie identisch, oder? Das ist ein Werkzeug. Wir haben den Prozessor im selben Testprojekt wie der Test. Keine dieser Ressourcen, die die realen Ressourcen für die Anwendung sind, sollte wirklich innerhalb des Testprojekts sein. Also werden wir zurückkommen und wir unser Projekt
umgestalten und wegbewegen, was verschoben werden muss,
wenn alle Referenzen korrigieren und den Code so reparieren, dass es überall weniger Wiederholungen gibt.
5. Refactor: Testen und Durchführen: Willkommen zurück. Lassen Sie uns unser Refactoring auf. Also denken Sie daran, dass der Zyklus ist, dass wir den Test schreiben, es ist rot. Wir schreiben den Code an mich, den Testgrad hinein, und dann refactorieren wir, wenn nötig, denn manchmal zwischen den beiden Aktivitäten können wir
Code wiederholen oder Auftragsdateien dort platzieren, wo es nicht unbedingt null sein sollte. Wir werden tatsächlich ein Projekt neu arrangieren, um zu transportieren. Wir wissen, dass es aussehen soll und wie es vorausschauend sein muss. Alles klar, was ich tun werde, ist eine andere Klassenbibliothek zu erstellen. Also fügen wir einfach ein neues Projekt hinzu. Es wird eine Klassenbibliothek sein. Und ich habe meins zur Seite oder an, aber wir haben es mit C-Sharp-Klassenbibliotheken zu tun. Und ich werde wirklich nur diesen einen Raum nennen, der Dot-Kern reserviert. Das sind also Punktcore-Tests, jetzt die Punktkern-Bibliothek
zusammenfassen. Also als nächstes, lassen Sie das Dotnet fünf. Und wenn das erstellt wird, können
wir fortfahren und die Standarddatei der Klasse 1 entfernen. Dann,
nachdem wir das getan haben, werden wir all die Fossa nehmen, die wir brauchen, und ich werde sie einfach ausschneiden und sie in unser Kernprojekt einfügen. Denken Sie also daran, dass
wir von Anfang an gesagt hatten, dass der Namespace für die Core-Doctests, der Standard-Namespace, den wir gesagt hatten, Kern zu sein. Nun, deshalb schauen Sie sich das an. Es ist wie ein Plug and Play. Alles ging einfach nahtlos über. Also, wenn wir uns die Codedateien anschauen, werden sehen, dass sie genau in die Namespaces
passen, wie sie erstellt wurden. Ordnung, aber Sie werden feststellen, dass wir eine Reihe von roten Linien im Test haben. Es ist, als ob es sie nicht mehr sehen kann, oder? Und aus verständlichen Gründen. Das Problem hier ist also, dass sie derzeit
den internen Fluss haben und interne bedeutet, dass der Namespace, alles innerhalb derselben Neon-CSR innerhalb derselben Assembly eher sehen kann, was nichts anderes kann. Deshalb bin ich gegangen, um sie öffentlich zu treffen, weil gut, außerhalb der Tests, müssen
wir auf ihre extern zugreifen, also werde ich sie öffentlich machen. Und wenn wir wieder zu unserem Test gehen, werden
wir sehen, dass wir immer noch ein Problem haben, und das liegt daran, dass wir eine Bibliothek für brauchen. Und so klicke ich mit der rechten Maustaste auf Abhängigkeiten und die Testprojekt- und Projektreferenzen. Und dann werden wir einfach hinzufügen, dass Klassenbibliothek klicken, OK. Und dann ist alles in Ordnung. Da gehen wir. Nun heißt das, dass es diese Methode wegen ihres Schutzniveaus nicht sehen kann. Also noch einmal, das wäre, weil dies intern ist. Das bedeutete also, dass die Öffentlichkeit. Und dann kann jeder jeden sehen, und jeder ist glücklich. Jetzt können wir eine weitere Wurzel der Trennung alles verfeinern das Layout unseres Projekts. Trennung von Bedenken geht also nicht nur darum, einzelne Klassendateien zu erstellen, sondern es stellt auch sicher, dass die Klassen die Assets sind, die miteinander in Beziehung
stehen und sich an einem zentralen Ort befinden. Also ja, Alles Zimmerbuchung, das ist nicht der Künstler ist im selben Projekt. Aber dann haben wir das, was ich Modelle nennen könnte, unsere Domain-Modelle hier, getrennt von dem tatsächlichen Huan mit dem Mythos und die Durchführung eines Prozesses,
jemand, der hier etwas mehr Trennung schafft. Und ich wollte diesen einen Prozessor nennen,
Prozessoren bei Kindern, die mehr Prozessoren haben und der Thron sie dort hingelegt hat. Und in diesem wollen auch eine Domain hinzufügen. Oder wir könnten diese Modelle nennen, dann nennen wir es Modelle statt Domäne. Alles klar, und dann werde ich die zu Models bringen. Und ich ging, um den Prozessor in den Processes-Ordner zu verschieben. Wissen Sie, die Folge davon ist, dass wir den Namespace ändern müssen. Also werde ich diese Gedankenmodelle oft nennen und das gleiche hier tun. Und dann für den Prozessor, werde
ich diesen einen Box-Prozessor nennen müssen. Da gehen wir. Dann ist alles zu sehen, es kann die Referenz finden. Das liegt daran, dass Sie sicherstellen müssen, dass wir die neue Verwendung haben. Also werde ich das einfach mit Anweisung kopieren, zu unserem Test
springen. Und ich werde nur hinzufügen, dass die Verwendung von Steven einen als diejenige für die Prozessoren macht. Alles klar, jetzt kann jeder jeden anderen sehen. Also, wenn wir noch eins tun, nur um sicherzustellen, dann sind die Builds erfolgreich und lassen Sie mich einfach unsere Tests noch einmal ausführen. Ich werde nur mit der rechten Maustaste klicken und Test ausführen sagen. Und die Tests bestehen immer noch. Das ist also gut. Bevor ich fortfahre, zeige
ich Ihnen einige Produktivitätstools,
einige Einstellungen in Visual Studio, die bei der Produktivität helfen können. Erstens, Sie können diese Verknüpfung immer verwenden, um Codefreiheit auszuführen. Also, wenn Sie diese Anweisungen verwenden, die Sie nicht einfach darauf klicken möchten, halten Sie die Steuerung gedrückt und drücken Sie die Taste und dann E. Aber es entfernt und behebt es nur Einrückungen auf all diese Dinge,
so dass alles, was Sie brauchen. Es gibt Möglichkeiten, Ihre eigenen Standards für das anzupassen, wie eine Bereinigung aussehen sollte, aber ich werde nicht in diese Null kommen. Noch ein cooler Tipp oder zwei andere coole Tipps, die ich mit dir teilen werde, richtig? Nein. Beziehen Sie, gehen Sie zu Tools, Optionen, gehen Sie zum Texteditor, C-Sharp, Erweitert. Und dann können Sie auf der Show Vererbung Marge aktivieren, die später
als nützlich sein wird wie unsere Verpflichtung und erweitert und wir werden mehr Abstraktionen haben und so weiter. Das ist also wirklich praktisch, besonders wenn Sie es mit großen Projekten mit vielen Hindernissen zu tun haben. Und eine andere, die Sie nützlich finden, ist die Paste. Wo ist sie? Bei der Verwendung? Da gehen wir. Fügen Sie Fehlende mit ihren Aktiven beim Einfügen hinzu. Das heißt, wenn Sie Code kopieren und einfügen müssen, sagen
wir bei einer Kopie und fügen Sie diesen Codeblock in eine brandneue Datei ein, es wird automatisch die Verwendung für Buchungsanfragen hinzufügen, die so sein wird, dass Sie nicht sitzen müssen und versuchen, Daten zu kontrollieren und füllen Sie alle Dinge, die wir vermissen werden. Es macht es automatisch. Also denke ich, das sind zwei gute Produktionswerkzeuge. Wenn Sie umgestalten, möchten Sie so effizient wie möglich sein. Und wenn Sie diese Art von Tools haben, die Ihnen tatsächlich helfen, unsere Hilfe, um die Wahrscheinlichkeit zu reduzieren, dass Sie einen Fehler auf dem Weg machen. Jetzt, wo wir unseren ersten Testzyklus erfolgreich durchgeführt haben, richtig? Wir schrieben, ich las Tests, schrieb Zitat umgesetzt, und wir refactored. Dann spülen wir im Grunde einfach und wiederholen. Das war's also für den ersten Abschnitt. Das ist unser erster Komponententest. Aber jetzt werden wir in einige mehr der Systemanforderungen bekommen sind
die Anwendungsanforderungen und fangen an, zu fischen oder mehr Dinge sind Tests. Wir werden etwas komplizierter. Und wir werden nur Spaß haben. Ich werde nur sagen, dass wir Spaß haben, während wir mitmachen.
6. Volle Anforderungsliste mit GitHub überprüfen: Hey, Leute, Willkommen zurück. Jetzt in dieser Lektion werden wir nur
alle Anforderungen für die Anwendung angeln , die wir bauen müssen. Du hast schon unser erstes Cyclin durchgemacht. Wir haben einen Vorgeschmack, den Test zu schreiben, den Code zu
implementieren und dann zu refactoring. Wir wissen also, dass wir zwei schriftliche Herzstücke für alles andere haben, aber wir müssen genau wissen, was wir tun müssen. Also in dem Repository, das ich bereits dafür erstellt habe. Und Sie können das Repository erstellen, und Sie können es mit den Sexual- und Quellcode-Links überprüfen. Wir werden zu Projekten springen,
jemand, um unser Projekt in Git Hub zu erstellen, Projekt erstellen. Und ich werde diese Anforderungen nennen. Nun, lassen Sie mich qualifizieren es ein bisschen mehr Zimmer buchen Armaturenbrett Anforderungen sind, ich denke, die Beschreibungsoption auf mindestens für null. Und wir können wählen, ob wir ein grundlegendes Kanban wollen. Kanban mit Bewertungen Buch,
jemand, um eine grundlegende Kanban-Projektvorlagen zu wählen. Also machen Sie weiter und erstellen Sie das Projekt. Und dieses grundlegende Kanban-Projekt kommt mit einem kleinen Layout für uns zu sehen, dass wir
Karten mit todos einfügen und markieren, was im Gange ist und wissen, was getan wird. Also nur für
den Kontext repliziert das ganze Wochenende diese Art von Struktur. Wenn ich auf die drei Punkte auf diesem ersten klicke und Edit naught sage, dann sehen wir eine Vorschau der Art der Syntax, die wir verwenden können. Ein C-Dickdarm-Wunderkerzen dazwischen gibt uns diese Sterneeffekte. Wenn Sie cool, sorry, Sternchen,
Sternchen und Trauer und Texte verwenden, werden
Sie das Fett bekommen. Du bekommst deinen Blutkörper von Texten. Wenn Sie ein Kontrollkästchen möchten, benötigen
Sie nur Ihre quadratischen Klammern. Und dann, wenn Sie ein X hineinlegen, wird es als überprüft interpretieren. In Ordnung, das ist also gut. Für Knotenknoten. Ich werde die anderen beiden Proben entfernen. Jemand wird auf die drei Punkte klicken, sagen Löschen, Notiz klicken Sie auf OK, tun Sie das gleiche für diesen. Knoten löschen, okay? Und wenn wir dann eine Notiz hinzufügen möchten, können
wir einfach auf das Pluszeichen klicken. Die erste Anforderung, die wir wollen, ist eine, die
besagt, was wir bereits getan haben, um Ergebnisse mit den gleichen Werten wie Anfragen zurückzugeben, so dass wir weitergehen und das hinzufügen können. Also, wenn Sie möchten, noch
einmal, Sie könnten bearbeiten, Ich könnte sogar Kontrollkästchen setzen ist eine, die besagt, was wir bereits getan haben, um Ergebnisse mit den gleichen Werten wie Anfragen zu sagen, so können wir voran gehen und hinzufügen, dass. Also, wenn Sie noch einmal bearbeiten möchten, könnte
ich sogar Checkboxen setzen. Um das zu tun, möchten Sie einen Bindestrich haben, um es wie ein Aufzählungspunkt zu machen, dann haben Sie Ihre eckigen Klammern, um es zum Kontrollkästchen mit einem Leerzeichen zu machen, richtig? Also, das ist offene eckige Klammern Raum, schließen quadratische Klammer. Und dann die eigentliche Verbiage für die Aufgabe. Wenn wir also all das tun und auf Knoten speichern klicken, sehen
wir, dass wir unsere Kontrollkästchen hier aufgelistet haben und dass wir immer einfach alle nehmen können. Also haben wir das alles schon gemacht. Ich zeige Ihnen nur, wie wir
unsere Anforderungen subtrahieren können, damit Sie das tun können. Nun, es werde ich weiterhin die anderen Anforderungen hinzufügen. Also ging ich voran und fügte einfach die anderen hinzu. Sie haben also die Rückgabeergebnisse der ersten Ordnung mit demselben Wert wie unsere gleichen Werte, wie die Anforderung die neuen bereits erledigt, die anderen würden eine Nullausnahme ausgelöst, wenn die Anforderung leer ist. Wenn wir also unsere Anfrage für eine Buchung annehmen, müssen
wir sicherstellen, dass unsere Daten innerhalb dieser Anfrage liegen, bevor wir die Buchung versuchen. Das ist also eine weitere wichtige Anforderung, die wir erfüllen müssen. Wir können die Zimmerbuchung Rekord speichern. Wir werden demnächst Datenbank-Funktionalität hinzufügen. Und wir müssen dafür sorgen, dass wir das tun können. Überprüfen Sie die Verfügbarkeit der Zimmer, bevor Sie die Buchung versuchen und speichern Sie einen Datensatz mit der Zimmerkennung, Rückkehr Erfolg Flag auf Ergebnisse. davon, ob der Buchungsversuch erfolgreich war oder nicht, müssen
wir sicherstellen, dass wir das angeben und tatsächlich die Buchungsdatens-ID zu den Ergebnissen hinzufügen. Das sind also die Dinge, die wir erreichen wollen. Und Sie können sehen, dass ich
die Checkbox-Liste von der ursprünglichen über alle anderen kopiert und eingefügt habe. Also kann ich das wirklich ein paar Eier loswerden. Also OK, und jetzt können wir weitermachen. Also kann ich die einfach hinüberschieben. Das ist also erledigt. Und die nächste, die wir haben, ist eine Ausnahme zu werfen. Es ist bedauerlich, dass es auf diese Weise gelistet ist. Und ich kann es nicht neu anordnen. Vielleicht verbringe ich nicht zu viel Zeit damit. Also wissen wir wenigstens, wo wir sind, und wir
ziehen sie einfach zu den laufenden, jedes Mal, wenn wir mit der Arbeit beginnen. Also das ist, ich kaufte es für besonders veränderte Anforderungen, natürlich, wissen
Sie, als Projekte, die allein oder Anforderungen von James, Sie haben, was Sie Scope Creep nennen. Und Projektansicht ist eine ausgezeichnete Möglichkeit, einfach den Überblick über das zu behalten, was getan werden muss. Sie können diesen Aufwand auch mit der Registerkarte Probleme kombinieren, die es ermöglicht, neue Probleme hinzuzufügen, die in Form der Gruppenanforderung, neue Feature-Anforderungen sein können. Sie können ihnen die Etiketten, Glühbirnen, Dokumentation auf Duplikat zuerst, UDC, was immer es ist. Dieses Tool ist also sehr, sehr mächtig. Ich empfehle, dass Sie etwas Zeit damit verbringen, zu lernen, wie es in Ihren Projekten verwendet werden kann. Aber das ist nicht, das ist ein Kurs für ein anderes Mal, gerade jetzt
wollen wir uns nur darauf konzentrieren, diese Anforderungen zu erfüllen. Also, wenn wir zurückkommen, fangen wir an, an der nächsten zu arbeiten.
7. Testen und Durchführen: Schwenken von Ausnahme, wenn die Anfrage: Ordnung, also sind wir wieder in unserem Code auf Wearable, um mit unserem nächsten Test zu beginnen. Also werde ich das vorherige einfach zusammenbrechen. Und dann werde ich meine Wirkung auf die Notation setzen. Und dieses Mal werden wir öffentliche Leere haben. Und der Testtitel sollte eine Ausnahme für Null-Anfragen werfen. Also mit dem im Sinn, und ich werde Sie einfach überprüfen oder einfach daran erinnern, wie der Test 3 aussieht. Wir haben die Orange, wir haben die App, und dann haben wir die Behauptung. Wenn man diesen Test kennt, sieht er, dass es keine Anforderung geben sollte oder der Anforderungswert null sein sollte. Also bin ich nicht zu iRange gegangen und du fragst Objekt. Ich werde den Prozessor jedoch brauchen. Und dann wird meine Behauptung so
aussehen, wie an einem Mittwoch, den Sie dieses Mal lassen sollten. Es wird also ein guter Arzt. Wirft, so dass Sie einen Nagel durch eine Spüle werfen, wenn wir Async verwenden, natürlich werden
wir mit ihr reden, wurde uns gerade auf
AsyncTask beigebracht , was andere werfen für null verwenden. Und dann gebe ich es, welche Art von Ausnahme und es sollte werfen. Also würde ich auf Argument, Null-Ausnahmen, Argument und alle Ausnahme ist das, was wir werfen sollen, weil wir sehen, dass das Argument, das an die Methode übergeben wurde, null war. Also sollte eine Ausnahme auslösen. Und dann öffne ich Zahnspangen. Und wenn Sie sich nur die ansehen, schauen Sie sich die Parameter ist C, Das ist seine Anleitung. Du führst dich, erlaubst uns zu sehen, du kannst hineinlegen. Also hier mache ich so etwas wie einen Delegierten. In diesen Klammern mache
ich ein weiteres Paar Klammern mit Lambdapfeil. Und dann werde ich in diesem Prozess setzen sind nicht Zimmeranruf buchen. Aber hier sage ich null, richtig? Also testen wir, ob die Anfrage als null ist, dann sollte es ein Ausnahmesymbol werfen, richtig? Und wenn Sie die Suche verwenden oder das native, das seine Syntax überschreitet, dann wäre dies ziemlich genau die gleiche Weise, außer dies würde sagen, behaupten, und es wäre Würfe. Sie sehen also, dass sie ähnlich sind. Aber wieder einmal, Benutzerwahlkonflikt darüber, dass immer bestrebt ist, Ihnen das Äquivalent zu zeigen, was ich benutze, die kluge Variation und das ganze Problem. Also, das sind Künstler wirklich, wir wollen sicherstellen, dass, wenn das Argument null ist, dass wir eine Ausnahme auslösen, oder ich kann dies erweitern und tatsächlich die Ausnahme erhalten, die ausgelöst wird. Ausnahme ist gleich. Und dann können wir einige andere Behauptungen tun, sind Überprüfungen, um sicherzustellen, dass der exception.com Name so param Name sein
würde, was üblich ist, die Ausnahme zu schlagen, richtig? Ich kann sehen, sollte oder sollte es sein. Und in den Klammern sehe ich das Wort Anfragen. Wenn diese Ausnahme ausgelöst wird, sollte
sie mit dem Sehen zurückkommen, oh, es wurde wegen dieses Parameters geworfen, der in diesem Fall Anfragen sein sollte, die null sind. In Ordnung, so sehen unsere Behauptungen aus. Natürlich, wenn wir einen Build machen, können
Sie sicherstellen, dass nichts kaputt ist. Wenn ich meine Tests durchführe, dann würden wir einen roten Test bekommen. Und was ich tun werde, ist, den Testexperten zu meiner Rechten zu adoptieren. Ich denke, wir haben genug Immobilien, dass wir es rechts haben und trotzdem gut gehen können , oder? Wenn wir also durchschauen, sehen wir, dass wir
den vorherigen Testbossing immer noch lieben und jetzt haben wir diesen neuen Test fehlgeschlagen. Ordnung, also werde ich einfach voran gehen und dieses gleichzeitig
implementieren , weil es nicht viel Arbeit ist, wo etwas
hinzugefügt werden muss , um sicherzustellen, dass die Dinge nie null sind. Also springen wir zu unserem Prozessor. Und dann innerhalb einer Formularmethode, die jetzt mindestens einer von zwei Tests fehlschlägt, können
wir Code hinzufügen, um es zu PaaS zu machen. Also werde ich nur sagen, ob die Anfrage oder Buchung eher den Namen des Parameters anfordert. Also genau da, werden wir eine Behauptung scheitern, auch das, was wir uns ansehen. Also, wenn die Buchungsanfrage null ist, okay? Und in neueren Versionen von C scharf können Sie tatsächlich schreiben ist null. Also, wenn die Buchungsanfrage null ist, dann werfen wir neue Argumentausnahme. Und dann für diesen Namen werde ich einen Namen absehen. Also möchten Sie immer sicherstellen, dass Sie Ihre Sachen stark getippt halten, da das für das Handeln aber die Zeichenfolge und fügen Sie eine statische Zeichenfolge hinzu, ich stelle nur sicher, dass Sie einen Namen sehen. Ich werde sagen, wenn sich dieser Parameter ändert, ist
der Refactor einfacher. Ordnung? Lassen Sie uns diesen Test erneut ausführen. Und ich denke, eine der Behauptungen wird ungeachtet
scheitern und wir können uns diese Fehlermeldungen ansehen. Also plötzlich behaupten Ausnahme, richtig, param Name,
und dann sollte es sehen, Anfrage gekauft werden, war
Buchungsanfragen Zelle ist ein Strang, um Ihnen zu zeigen, dass das immer noch scheitern würde. Also, wo wir s, haben wir den Test ja geschrieben, Unterroutine Code, von dem wir denken, funktioniert, aber dann basierend auf dem Test, den wir geschrieben haben, ist
es immer noch fehlgeschlagen. Ok. Warum scheitert es? Weil wir den Namen der Buchstützenanfragen zurückgeben. Also, mit anderen Worten, wo der Leser die String-Buchungsanfragen hier zurückgibt, richtig? Aber in unserem Test haben wir gesehen, lassen Sie mich zurück zu den Tests springen, die wir nach den Wortanfragen suchen sollten. Also dann kann ich Dot Glastür ändern müssen meinen Test zu ändern. So manchmal kann der Test erodiert es auf einem Pfad bluten, würde nicht einmal in einem Viertel schreiben. Ella ist alt, vielleicht ist das nicht unbedingt die Halle, die ich tun will. Und dann umgestalten Sie, während Sie weitergehen. Alles klar, wenn ich diesen Test erneut
ausführe, werde ich wissen, dass meine grünen Zecken richtig sind und meine Behauptungen null sind. Also, während ich hier
bin, werde ich nur umgestalten. Also haben wir hier einen Prozessor. Ich hätte hier einen Prozessor. Und für die meisten, wenn nicht alle Tests, die wir durchführen werden, sie alle an Bord eines Prozessors sein. Also, anstatt jedes Mal eine neue Instanz des Prozessors zu machen, wenn wir eine neue Methode haben, richtig? Und dann wären das 10 verschiedene Punkte zu aktualisieren. Was wir tun können, ist einen Konstruktor einzurichten, oder? Also wollte ich sagen, CTR Badewanne, Wanne. Und ich werde nur auf die Punkteprozessor setzen ist gleich unserem neuen Prozessor. Also diese eine Zeile, ich wollte es nehmen. Und dann brauche ich natürlich ein Feld für diesen Kontrollpunkt und generiere das Feld. Da gehen wir. Also, dann will
ich nicht mehr hart, diese Arrangement zu machen. Richtig? Ich muss den Prozessor nicht jedes Mal anordnen, weil ich jetzt mein Orange einmal im Konstruktor machen kann. Und dann kann ich dieses arrangierte Objekt überall sonst verwenden. Also, wo immer ich Prozessor hatte, Es ist immer noch auf der Partitur Prozessor. Also, wenn ich diese Tests erneut durchführe, werden
wir sehen, dass sie immer noch bestehen und wissen, dass der Code sauberer aussieht. So eine Instanz, die vielen Meistern dient. Das ist also eine weitere Woche und beginnen Sie mit der Refactoring Ihrer Tests um die Wiederholung in der Testphase selbst
zu reduzieren.
8. Buchungsdienste erstellen: In Ordnung, Jungs. Die nächste Aufgabe besteht also darin, ein paar Dinge einzurichten, einschließlich unseres Dienstes oder Repositorys, dem alle unsere Gandalf,
Sie wissen schon, datenbezogenen Operationen gespeichert werden. Also nirgends, wenn wir mehr Trennung von Bedenken betrachten, weil wir die Datenbank irgendwie von der tatsächlichen Geschäftslogik
behindern wollen , die if-Anweisungen, ob diese Anfrage OKR ist oder nicht, richtig? Also, was wir in diesem hier tun werden, ist die Einrichtung unseres Augenzimmer-Buchungsservice. Also habe ich bearbeitet, dass Raumbuchung Datensatz speichern, nichts und ich habe diese zusätzliche Aufgabe hinzugefügt. Sie können dies tun, wenn Sie möchten, und auch die letzte oder die zuvor erstellte auf den fertigen Stapel verschieben. Also lassen Sie uns in den Code springen. Und im Kernprojekt werde ich einen neuen Ordner hinzufügen
, den ich Dienste, Datendienste nennen werde. Und da wir eine neue hinzufügen, werde
ich nur Klasse sagen, aber es wird wirklich eine Schnittstelle sein. Und ich putze es auf i Zimmerreservierungsservice. Und das können wir hinzufügen. Wir ändern dies in eine öffentliche Schnittstelle. Und in dieser Schnittstelle werden wir eine Methode haben, die zurückgibt, na ja, es muss nichts zurückgeben. Ja, es ist eine Speichermethode, so dass es nichts zurückgibt, zumindest nicht Netzhaut. Also ist es ungültig, Speichern, und es wird Parameter für die Zimmerbuchung nehmen, nicht wahr? Die Sache ist also, dass wir bis jetzt mit Anfragen und Ergebnissen zu tun haben. Wenn wir jedoch speichern, müssen
wir wie eine datenbankfähige Version der Anfrage sehen. Und das wird von uns verlangen, einen neuen Typ einzuführen. Also werde ich nur in einen neuen Ordner setzen. Ich will es nicht als das Mittel bei den Models bezeichnen und die Domain lieben. Und dann fügen
wir anstelle von Domain eine neue Klasse hinzu. Nun, das ist in Ordnung. Das war der Schritt eins nach dem anderen, richtig. Also ging ich, um diese Zimmerreservierung anzurufen. Richtig? Und dann ist es eine Zimmerbuchung. Das ist also unser neuer Datentyp, den wir brauchen werden. Also ich Zimmerbuchungsservice und es ist gut, eine Methode zu haben, um
die Zimmerbuchung zu sehen und es erwartet, etwas von Datentyp Zimmerbuchungen zu bekommen. So gut der Weg nach oben, um
die Werte aus den Zimmerbuchungsanfragen zu transformieren , was auch immer es ist. Wenn Sie also das Anwendungsdesign gemacht haben, würden
Sie schätzen, dass Sie manchmal
die Eingabe massieren müssen , bevor Sie sie an die Datenbank senden können. Also, das ist, wofür wir unseren Code vorbereiten, indem wir diese null trennen, ich brauche dieses Zimmer buchen einige, nur um diese neue Datei von selbst zu erstellen. Aber für jetzt wird es die gleichen Felder wie die Anfragen haben. In Ordnung, also gehe ich einfach voran und kopiere sie und füge sie ein. Und Sie können diese Erweiterung auf R-Punkt-Funktion sehen, die Sie hinzufügen ermutigen, vor kurzem bei der Arbeit zu aktivieren, richtig, wenn ich es eingefügt automatisch hinzugefügt, dass mit Anweisung für mich. Und er Whoa, was ich tun werde, ist, das
aus den Datendiensten zu entfernen und das in die Rechnung zu setzen. Und dann ändere ich das natürlich in Domäne und aktualisiere die Referenz innerhalb der Schnittstelle. Also, das ist zumindest Schritt eins, um nur auf den nächsten Schritt vorzubereiten, das heißt, wenn wir den Test schreiben, haben
wir die Schnittstelle bereit für den Einsatz. Und was wir tun werden, ist sicherzustellen, dass wir unsere Schreibtisch-Buchungsanfragen speichern. Und das ist es, woran wir im nächsten Test arbeiten werden.
9. Unit Speichern einer Zimmer-Buchung: Ordnung, also sind wir wieder in unserem Testcode und der nächste Test, den wir machen werden ist, sicherzustellen, dass wir den Datensatz tatsächlich speichern, richtig? Also werde ich das alles kopieren und entsprechend belohnen. Und dieser Test wird aufgerufen werden sollte Zimmerbuchungsanfragen sparen. In Ordnung, jetzt müssen
wir unseren Prozessor anrufen. Die müssen wir natürlich anrufen. Und wir rufen Buchräume an, damit Sie sehen, wie viel einfacher das gemacht wird. Wir wissen, dass der Prozessor für Sie da ist, sodass Sie ihn nicht erneut initialisieren müssen. Und darin brauchen
wir unsere Bitte. Nein. Wir haben keine Anfragen. Würde eine weitere Anfrage arrangieren müssen, aber wir haben schon irgendwie unsere Anfrage hier oben arrangiert. Richtig. Also, was ich tun werde, ist, dem Anzug zu folgen. Ich werde das aus dem Arrangement für diesen ersten Test nehmen, den wir gemacht haben. Und ich werde es in den Konstruktor legen. Und anstatt eine lokale Variable zu haben, schaffe ich es in ein Feld. Also generieren wir das Feld auf der Score-Anfrage. Und dann überall, wo nur Anfragen gesagt werden, ersetzen wir einfach durch Unterstrich Anfrage. Diese Anfrage stellt unsere Testanforderungen dar und ein Künstleranfragen können überall dort verwendet werden, wo wir es
brauchen , da dieses Angebot dieses Objekts erneut schlägt, es in den Konstruktor
legen und dann können wir es einfach wiederverwenden in allen Künstlern. Also, jetzt, da ich
die globaleren Leads der Irene gemacht habe, können wir tatsächlich einfach direkt nach rechts springen. Nun, bevor wir alle Behauptungen hier tun können, müssen
wir einrichten, kopieren Sie unsere Tests bereit Version unserer Schnittstelle. Der Grund, warum wir die Schnittstellen gemacht haben, so dass es überall injiziert werden kann, wo wir es brauchen. Aber es ist immer noch eine Schnittstelle, die eingerichtet werden muss, weil es eine Methode hat. Wir müssen unter Testbedingungen Host sehen, sollte diese Methode funktioniert. Das nennen wir also Spott. So zum Glück gibt es eine sehr gute Bibliothek, die für diese Art von Sache verwendet wird. Und wir werden sehen, wie das null funktioniert. Also werde ich sagen, Unterstrich Zimmerbuchung Service-Marke ist gleich neuen Mock Kapital M oder CK von unserer Schnittstelle, die ich werde nur schnell kopieren, dass und fügen Sie es automatisch die using-Anweisungen erhalten, das ist so cool. Und dann schließen Sie Zahnspangen. Und dann für den Spott, es ist offensichtlich nicht etwas, was wir gerade haben. Würden wir WC-Installationspaket steuern, spotten,
sagen, kann voran gehen und lassen NuGet, finden und installieren Sie die neueste Version. Und wenn das erledigt ist, erhalten wir automatisch die using-Anweisung. Und dann können wir unser Feld mit dem Namen Zimmerbuchungsservice Mock oder initialisieren. So. Beachten Sie, dass es von dem Typ ist, den wir wollen, aber es ist auch MC. Also sagen wir, gib mir ein Mock-Objekt vom Datentyp. Dieses Objekt ist jedoch noch irgendwie leer. Wir müssen tun, was wir das Setup nennen. Also sind wir immer noch in dieser Bereichsphase. Und jetzt müssen wir diese Methode tatsächlich setzen, um zu tun, was wir denken, dass sie tun sollte, bevor wir dorthin kommen. mir noch wichtiger ist, ist die Tatsache, dass wir diesen Service in unseren Prozessor
injizieren müssen . Wenn Sie also nicht so vertraut sind, was Injektion oder Abhängigkeitsinjektion ist, schlage
ich vor, dass Sie sich einen meiner vorherigen Kurse zur ASP.Net-Kernentwicklung ansehen, wo wir zeigen, was Abhängigkeitsinjektion wirklich ist und wie es hilft. Jetzt an diesem Punkt ist dies ein Dienst, den der Prozessor
wirklich verwenden wird , nachdem er seine Geschäftslogik bei seinen Prüfungen beendet hat.
Er wird diesen Dienst verwenden, um die
tatsächliche Änderung zu bewirken , die nach Erhalt der Anfragen. Das bedeutet, dass es ein Objekt der Buchung Service benötigt. Darauf ist noch nicht vorbereitet worden. Also, was ich tun werde, ist diese Prozessordeklaration zu nehmen und ich ging, um sie zu verschieben. Also, nachdem wir den Mach haben, dann ging ich, um dies zu sagen, dass es auch einen Parameter unseres Mock-Objekts nehmen sollte. Wenn wir also Mock sagen, ist
es buchstäblich die Art von welchem Typ auch immer. Aber wir wollen den konkreten Typ. Wir müssen die Scheinobjekte sehen. Und wenn Sie mit dem Mauszeiger über Objekt bewegen, sehen
Sie, dass es uns tatsächlich über den Augen-Zimmerbuchungsservice gibt. Der Zimmerbuchungsservice ist eigentlich der MAC aus, dass. Also bekommen wir den physischen Wert. Jetzt die rote Linie, wir können dies ansprechen, indem wir controller.js sagen und dann können wir
es an dem Parameter zu unserem Konstruktor für uns sagen , richtig? Das reduziert also wirklich den Dollar und her zwischen dem Code schnell. Sie sehen nein, die rote Linie ist weg. Wenn wir rüber springen, ist es nicht, dieses Objekt zu bekommen, wir kommen zurück und benennen das unreflektiert so bald um. Aber im Moment zeige ich Ihnen nur, worauf wir uns vorbereiten denn in allem können wir den Service in
unseren Anfrageprozessor injizieren und dann können wir alles aus
dem Dienst innerhalb jeder Methode innerhalb unseres Prozessors verwenden . Also zurück zu unserem Test bisher oder unser Sortiment hat uns mit den Testanfragen. Dann hat es eine Einrichtung des Mach-Repositorys, unser Mock-Service. Und dann richten wir unser Prozessorobjekt ein, das dieses Mock-Objekt als seinen Parameter einnimmt. Wenn ich unseren eigentlichen Test kenne, muss
ich den Spott wissen lassen, wie er sich verhalten soll. Das hätte ich hier oben tun können. Aber dann wäre das global gewesen. Und nur eine Methode benötigt diese Art von Einrichtung zumindest zu diesem Zeitpunkt. Okay, also mal sehen, wie diese ganze Methode aussehen wird. Also müssen wir noch etwas arrangieren. Und ich werde das über der Tat tun. So Einsätze oder das Optimale, wir, klar die Dinge haben sich geändert. Lassen Sie uns also das aufstellen, was wir brauchen. Also werde ich mein Objekt der Art Zimmerbuchung haben. Denken Sie daran, dass wir gerade diese in der Domäne erstellt haben. Also Raum wird König gleich null ist. Also fängt es leer an. Dann sehen wir unser Mock-Objekt. Wir können sagen, MLK Punkt Setup. Da gehen wir. Und das braucht einen Lambda-Ausdruck, ich werde einfach q verwenden und dann können wir die Methode aufrufen, die wir setzen möchten. In Ordnung, also, wenn dieser Mach involviert ist, wie wollen Sie, dass sich bestimmte Methoden verhalten? Beobachten Sie Method2 in einem Testumstand, das bringt auf den Tisch. Also ging ich, um das Sparen zu sehen, weil das ist, was wir gerade testen, oder? Wenn Sie angerufen werden, Sie sind ich Einstellung es einrichten, um zu wissen, dass es jede nehmen sollte, so werde
ich sehen, es ist jedes Objekt aus der Anfrage Buchung. Also Zimmer wird King Anfragen Typ. Da gehen wir. In Ordnung, und schließen Sie dann Klammern. Das sollte also funktionieren, was ich sehe unsere rote Linie. Und es liegt daran, dass ich den falschen Datentyp verwende. Das sollte ein Zimmer buchen Entschuldigungen sein, oder? Diese werden also die Domänenobjekte speichern, oder? Also sollte dies Save sagen, es ist jede Zimmerbuchung. Also es sagt, gib mir irgendein Objekt, solange es eine weiche Diät ist, Zimmerbuchung. Richtig. Dann, um fortzufahren, werde ich tun, was du einen Call-Buck nennst. Mit anderen Worten, wenn diese Methode aufgerufen wird, was sollte sie tun? Die Callback-Methode wird also R. Es gibt Ihnen den Datentyp, der ich unquotierte Rückgabe oder Prozess zitieren sollte. Wenn dies aufgerufen wird. Sie können die Dokumentation lesen, wenn Sie müssen. Aber für den Call Buck sehen
wir nur Buchung und dann einen Lambda-Ausdruck. Es ist also fast wie eine Delegatfunktion wirklich. Und dann werden
wir sehen, dass das Zimmerbuchungsobjekt hier gleich dem Buchungsobjekt ist. Vielleicht kann ich diese Namen ein bisschen mehr quantifizieren. Jemanden zu sehen. Gespeichert suchen. Alles klar, also das Speichern, das Buchungsobjekt, das wir als null angefangen haben, sollte wissen, den Wert dessen
erhalten, was während des Tests übergeben wurde. In Ordnung, Semikolon, Semikolon. Und das ist unser Setup für unseren Mock, oder das Setup für die Speichermethode in unserem Mock-Objekt für unseren Service. Okay, also sieht es kompliziert aus, aber wenn du das immer mehr machst, wird
es einfacher und es wird mehr Sinn ergeben. Nachdem wir das getan haben, rufen wir den Prozessor an. Und dann, nachdem wir den Prozessor aufgerufen
haben, müssen wir überprüfen, ob die Methode jemand genannt wurde, um Mock Dot zu sagen. Bitte überprüfen Sie das. Und dann unser Lambda-Ausdruck, Speichern oder Save Methode. Und wir überprüfen, ob es einen hat, das Buchungsobjekt. Und dann zwei, wir werden es überprüfen. Richtig? Vergewissern Sie sich das, speichern Sie es mit jedem Buchungsobjekt. Und dann wird der nächste Parameter, wenn Sie nur mit dem Mauszeiger fahren, sehen
Sie ihn im Experimentator, wie oft er aufgerufen wurde. So können Sie genug fehlgeschlagene Nachricht setzen, können
Sie in verschiedene Dinge setzen. Aber was wir überprüfen wollen, ist, dass es 1 mal 1 genannt wurde. In Ordnung? In Situationen wie diesem können Sie also
sagen, wenn Sie eine Methode aufrufen oder wenn Sie diese Option ausführen,
überprüfen Sie, ob bestimmte Schlüsselmethoden auf dem Weg ein- oder zweimal aufgerufen wurden. Sagen Sie, wenn Sie dies mit dieser Eingabe testen, sollte
diese Methode zweimal aufgerufen werden, oder wenn sie dreimal, et cetera genannt werden sollte. Sie können einmal sehen, Sie können genau einmal sehen, mindestens einmal, richtig? Die meisten, am wenigsten, sozusagen, oder? So können Sie, Es ist ziemlich flexibel mit den Zeiten, die Sie verwenden können. Also wieder einmal, wir sind sofort. Ich will nicht wissen, ob es zweimal war, dann habe ich einen Fehler. Alles klar, nach dem,
überprüfen Sie, können wir mit weiteren Behauptungen fortfahren. So können wir behaupten, dass dies nicht null ist. Also sparen Booking Punkt sollte nicht r. Lassen Sie mich einfach null. Manchmal ist es, Es ist einfacher, nur das Wort nicht-analytische Filter, die alte ist. Es sollte also nicht null sein. In Ordnung? Und all die Behauptungen würden dem ähnlich sein. Was wir hier oben getan haben, wo diese gleich sein sollten. So fordert Punkt vollständigen Namen. Der vollständige Name des CVE Booking Punkts sollte also dem Namen des Anforderungsflusses entsprechen. Die E-Mail sollte mit der Anforderungs-E-Mail identisch sein und das Datum sollte mit einem Datum übereinstimmen. In Ordnung, das sind also meine Behauptungen. Ich werde nur diesen Test ausführen und mit der rechten Maustaste darauf klicken. Also im Test-Experten-Samen sind sie drauf. Nicht falsch. Es wurde nie ruiniert, also weiß es nicht, ob es ruinieren würde. Und dann kann ich einfach mit der rechten Maustaste darauf klicken und Ausführen sagen. Und in Russland und es ist gescheitert. Und wenn wir nur einen Blick darauf werfen, was Sie gesehen haben, sagt
es, dass der erwartete Aufruf auf dem Mock einmal gekauft 0 mal Save war. In Ordnung, also sagen wir, dass wir erwartet haben, dass dies mindestens eins genannt werden sollte. Also, wann immer wir die Tat taten, aber es wurde nie genannt. In Ordnung. Das ist also alles, was die MAC-Überprüfung funktioniert. Also nein, wir können voran gehen und lesen, sorry, wir können weitergehen und den Code implementieren, um all dies zum Leben gerufen zu machen.
10. Implementierung: Speichern einer Zimmer-Buchung: Also, zurück in unserem Prozessor, werden
wir in das, was wir brauchen, um unseren Test vereinbaren zu lassen. Wir sehen also, dass zwei von drei Tests bestehen, oder? Und wir müssen die Erinnerung daran schreiben, was der Testfehler war. Manchmal ist es also gut, das einfach so zu haben, dass Sie die Nachricht
lesen und dann gleichzeitig Ihren Code ansehen können. Manchmal, weißt du, nur wenn du sie gleichzeitig aufhältst, kann dir
helfen, zu vermuten, was du ändern musst. An diesem Punkt möchte ich das ein bisschen aufräumen. Also muss ich diese Injektion beenden, richtig? So punktet Control die richtige using-Anweisung dafür. Da gehen wir. Und ich ging, um den Namen dieses Objekts selbst unseren Zimmerservice zu nennen,
Kontrollpunkt, und erlauben es ihm, ein zugewiesenes Feld zu erstellen. Wie Sie wissen, ziehe
ich es vor, den Unterstrich für die Feldnamen zu verwenden. Also ändere ich das einfach in einen unären Faktor. Und dann ziemlich viel, was wir tun müssen, ist das von einzuführen. Also eins, wir bekommen die Buchungsanfragen. Wenn es null ist, werfen wir die Ausnahme, damit wir darüber wissen. Aber dann zwischen dem Werfen sind die Überprüfung und Überprüfung, dass es in Ordnung ist und Rückkehr, wir müssen sparen. Also, wenn es okay ist, müssen wir retten. Also, was ich hier tun werde, ist nur sagen Zimmerreservierung Service, dot save. Und dann nimmt das ein neues Zimmer Buchung Objekte. Sagen Sie einfach eine neue Zimmerbuchung. Und ich mag es nicht, dass sich diese Präfixe auf die using-Anweisung beziehen. Also Zimmerreservierung. Und dann benötigt dieses Objekt Daten, die so ziemlich die gleichen Daten sind, die in den Buchungsanfragen vorhanden wären, oder? Also werde ich das eigentlich nur kopieren und dort einfügen. In Ordnung. Und da haben wir es. Da gehen wir. So, jetzt haben wir unsere Zimmerbuchung gespeichert oder speichern Methode aufgerufen wird. Erhalten Sie jedes Zitat unquote, jedes Zimmer aussehende Objekt. Und wissen, wenn ich meinen Test erneut ausführe,
dann stehe ich auf, um die Punktzahl zu übertreffen. So einfach war das nein. Offensichtlich läuft hier jede Menge Wiederholung ab, oder? Zwischen dieser Zeile sind die wenigen Zeilen, die wenigen Zeilen und die Ähnlichkeiten zwischen unserer Buchungsanfrage und unserem Ergebnis auf der tatsächlichen Domain. Es gibt Gelegenheit für uns, den Flur aufzuräumen, der sich nähert alle Teile des Codes
ausbreitet. Lassen Sie uns also beginnen, indem wir die Ähnlichkeiten sehen und sehen, wie wir kondensieren können, oder? Also haben wir die Zimmerbuchung mit diesen drei Feldern, dann haben wir eine Anfrage und die Web-Ergebnisse. ist wichtig, sie getrennt zu halten. Wir wollen jedoch die Wiederholung zwischen allen reduzieren. So können wir vorstellen, Ich werde nur kopieren und einfügen eines der Ergebnisse der Zimmerbuchung. Und Herbst-Winter-Hub hier ist Zimmerbuchung. Sockel Zimmerbuchung bys werden darstellen und nur Kontrollpunkte. Oder vielmehr muss ich diese Datei umbenennen, tut mir leid, also benennen Sie einfach die Klasse um. Da gehen wir. Also haben wir eine Zimmerbuchungsbasis, die alle Objekte hat, richtig? Und ich ging, um diese Zusammenfassung zu treffen, weil ich nicht möchte, dass jemand in der Lage ist, eine Instanz des Raumes zu erstellen, die BCE aussah. Aber es wird dem Zweck der Vererbung über alle anderen dienen. So kann ich ihre offenen Deklarationen von
den Feldern entfernen , die sie gemeinsam haben, weil jetzt alles in der Basis existiert. Ordnung. Also das gleiche für Zimmer suchen, kann
ich das entfernen und es von der Zimmerbuchungsbasis erben lassen. Wenn ich jetzt einen Build mache, sind alle immer noch glücklich. Das ist gut. Also, diese Refactor-Arbeit. In Ordnung. Und wie ich schon sagte, wenn Sie den Vererbungsrand initialisieren, könnten
Sie viel einfacher, in
Ordnung oder viel einfacher zwischen Dateien unter Basisimplementierungen springen . Das ist also, was diese Vererbungsspanne ist. Vier, wenn es für dich funktioniert, wenn du es cool findest, dann kein Problem. Wenn nicht, dann ist das in Ordnung. Wenn wir nun zu unserem Prozessor zurückkehren, haben
wir die Möglichkeit, diese Objekte zu erstellen. Ich werde generischer sein. Weil Sie hier sehen, wiederholen wir wirklich nur Code. Und sie hängen beide an der Akte, die von den Buchungsanfragen kommt. Also werde ich eine private Methode erstellen, die den Datentyp T zurückgeben wird. Also, wenn Sie jemals von generischen Tee
oder Teestube Buchung gehört haben, richtig? Also Teestube Buchung, ich nenne es nur generisch. Erstellen. Zimmerbuchungsobjekt. Oder ich sage einfach erstellen, ja, Zimmer. König Objekt. Ich bin explizit mit meinem Methodennamen, das ist alles. Und dann wird es wissen lassen, dass es ein Generikum ist, richtig? Also nennen wir es einfach T Zimmer Buchungsobjekt, erstellen Zimmer suchen Objekt ist der Name der Methode und es ist generischer Parameter, was auch immer es zurückgeben sollte. Es wird einen Parameter der Zimmerbuchungsanfragen nehmen. Also kopiere ich das einfach, füge es dort ein. Und dann werde ich das lösen, damit wir ein wenig realistischer für diese Aktivität haben. Und dann ging ich, um anzugeben, wo die Teestube wird König Objekt ist vom Typ Zimmer Buchungsbasis. Richtig? Also, mit anderen Worten, ich bin bereit,
in der Lage zu sein , alle diese Methode genannt werden, zu übergeben, und ich muss einen Parameter übergeben oder es wissen lassen, dass das generische relativ zur Datentyp Raumbuchung ist, so dass alles Vererbung von Zimmerbuchung Bienen kann als generische verwendet werden. Ordnung? Also, nachdem das zu tun oder die Implementierung ist im Grunde nur gehen, um ein Objekt der Teestube Buchung zu
sagen. Und so ziemlich es wird nur die gleichen Felder wie der vollständige Name haben. Kehle, E-Mail. Tut mir leid, ich hätte das neue Keyword Rückkehr, neue Teestube Buchung, Semikolon setzen sollen. Und ich bekomme einen Fehler, irgendwie erstelle Instanz 0. Es stoppt nicht die neue, sorry, das hätte neu sein sollen, das Ende davon. Und da gehen wir. Alle roten Linien sind weg. In Ordnung. Also ich denke, ich könnte einige der Namen kürzen,
richtig, so dass es sich nicht so weit auf
den Bildschirmmultipletten dehnt , die ich tun werde, ist einfach die Zeile zu brechen, so dass Sie den gesamten Code sehen können. All das ist also die erste Zeile. Und dann öffnen wir die Klammern, und dann machen wir unsere Implementierung hier. Ordnung? So wird der Zweck dieses wird es sein,
unsere ausdrücklichen Erklärungen hier zu ersetzen ,
anstatt neue Zimmerbuchung zu sehen und zu wiederholen, dass ich wissen kann, sagen schafft Raum suchen Objekt. Ich will etwas vom Typ Zimmer wird King, die von der Basis erbt. Und ich übergebe die Buchungsanfragen als Parameter. Da gehst du. In Ordnung? Und dann kann ich dasselbe für die Renditen tun. Also kann ich einfach sagen, Rückkehr schafft Raum suchen Objekt, aber es wäre off time Regel, die Art Zimmer Buchung Ergebnisse. Und da gehen wir. Das sieht also viel sauberer aus, viel weniger Wiederholung zwischen den beiden. Und wir sehen, wie Generika uns helfen können, unseren Code sauber zu halten. Und blieb mir nur den Vorschlag von Visual Studio bei der Methode statisch. Da gehen wir. Nun, der Moment der Wahrheit ist natürlich drei Tests, also werde ich einfach alle meine Tests durchführen. Und ich bekomme grüne Zecken den ganzen Weg. Also, das ist es für die Implementierung dieses Tests. Wir haben einen Refactor durchgeführt und den Retest durchgeführt. Und wieder einmal, wir werden einfach weiter
durch diese Aktivitäten entsprechend rollen .
11. Einheitstest: Prüfe, ob der Raum verfügbar ist,: Nun, wir sind Ausrüstung. Oh, nett. Also sind wir auf die nächste Aktivität und das ist die Verfügbarkeit
des Scheckzimmers, bevor Sie die Buchung versuchen, richtig? Also müssen wir einige Logik hinzufügen, um sicherzustellen, dass wir überprüfen und sehen, ob es irgendwelche verfügbaren Zimmer. Und dann, wenn es keine verfügbaren Zimmer, dann haben wir nicht routable Schlüssel. Und ich schicke ein Symbol, richtig? Natürlich ist die Buchhaltung das gleiche wie das Speichern des Füllens. Also lasst uns zu unseren Tests springen. Und ich werde nur das regelmäßige Kopieren und Einfügen und Umbenennen machen. Und dieses ist sollte nicht Zimmerbuchungsanfragen speichern, wenn nicht verfügbar. Also innerhalb dieser Methode müssen
wir ein paar Dinge tun. Bevor wir zu dieser Methode kommen. Wir müssen tatsächlich einige neue Methoden innerhalb unseres Buchungsservice erstellen. Also lassen Sie mich zur Schnittstelle springen. Es gibt keine Implementierungen, so sorry, das war Control F 12, Sie sollten haben, Sie können Reste verwenden, können Ctrl-Click. Und hier drüben, werde ich sagen, geben Sie mir eine neue Methode, die zurückkehrt. Ich werde ich unzählige verwenden,
ich denke, das ist ein Generikum in unseren Sammlungstypen. Also gib mir eine Sammlung von Zimmern. Also brauche ich ein neues Objekt namens Raum. Und ich ging, um das anzurufen, noch verfügbare Zimmer zu
bekommen. In Ordnung. Nein, Diese Methode wird die Anfrage nach rechts nehmen müssen. Also sage ich einfach, Datetime hat es getan. Und alles, was wir brauchen, um diese neuen Objekte zu erstellen. So erstellen Sie eine neue Datei. Und natürlich müssen diese Raumobjekte in der Domäne sein, oder? Also werde ich es einfach überziehen, den Namespace ändern. Wir brauchen noch nichts in diesem Objekt. Wir müssen nur wissen, dass es da ist. Und unsere Schnittstellen glücklich bekommt verfügbare Zimmer ist okay, das ist in Ordnung. Jetzt innerhalb unseres Tests mit unserem Setup für unseren Spott, müssen
wir es wissen lassen, dass es zurückkehren sollte. Nun, beim Einrichten des Mach muss
ich die verfügbare Plattenmethode wissen lassen, dass sie die Liste der Räume zurückgeben sollte. Nun, an diesem Punkt werde ich, okay, ich überlasse den ersten Schritt der Refactoring-Phase. Aber was wir tun werden, ist diese Art von Setup zu ziehen, Setup innerhalb des Tests. Was wir zu einem so späteren Zeitpunkt gemacht haben. Also für null, lassen Sie mich einfach voran und machen Sie die gleiche Art von Setup einen IV-Fall, Sie wollen nur eine Erinnerung, Sie können immer auf das vorherige Setup schauen, wo wir das Setup für unseren Safe gemacht haben. Also müssen wir eine Liste von Zimmern haben. Ich werde eine Feld Kürze Liste von
Typ Zimmer für diese Art Raum erstellen . Gehen Sie weiter und fügen Sie die using-Anweisung hinzu, und ich nenne diese verfügbaren Zimmer. Also, wenn es privat auf der Partitur verfügbare Zimmer ist, richtig? Und dann innerhalb unseres Konstruktors werde
ich verfügbare Räume initialisieren, um eine neue Instanz von Listen mit Raum zu sein, mit mindestens einem Raum darin. Also neue Raumobjekte, mindestens eins. So wissen wir, dass es nicht leer ist. Also in der Einrichtung, werden
wir sagen ODER Zimmerbuchungsservice, Mock Dot Setup. Und dieses Mal werde ich auf die verfügbare Zimmermethode aufrufen, die ihre Anfrage als Parameter nehmen wird. Und beachten Sie, dass ich in dieser Situation einen genauen Wert verwende. Ich benutze das Willkürliche nicht. Es ist kein Raum suchen, weil wir buchstäblich gegen die Anfragen testen müssen,
Bedürfnisse, die wir jederzeit ändern können. So Setup noch verfügbare Zimmer. Und dann für diesen ist es ein Wert, der zurückgibt. So ist es nicht zu vermeiden, wie die sparen, wo wir nur auf Sauerstoff durchführen mussten. Also dieses Mal muss ich sehen, dass diese BreakLine Punkte zurückkehren. Und dann wird es uns sagen, was es erwartet wird,
zurückzukehren oder watts Delegierten wir durchführen können, aber ich musste nur die Rückkehr mit den verfügbaren Zimmern Listen durchführen. Wir hatten IRI und vorher wissen, begleichen sich für einen Test, nachdem alle diese Vereinbarung vor diesem getan, was ich tun werde, ist klar oder verfügbar Zimmer, weil denken Sie daran , dass es nicht die Buchung tun sollte, wenn es eine nicht verfügbar ist. Also, wenn verfügbare Zimmer der Bezugspunkt ist,
dann, wenn ich diesen Test durchführe, werde
ich sicherstellen, dass es Zitat unquote, keine verfügbaren Zimmer gibt. Dann werde ich meinen Prozessor anrufen, um Zimmer mit der Anfrage zu buchen. Ordnung? Und dann werde ich überprüfen, und ich werde nur kopieren und einfügen. Wenig schrieb das alles vorher, also überprüfe ich nur, dass dies nie aufgerufen wird. In Ordnung. Schön und einfach, oder? So gehen wir voran und wir sehen wieder verfügbare Zimmer. Ja, wir haben eine Liste der verfügbaren Zimmer. Wir haben eine Liste und es hat mindestens ein Zimmer. Wir wissen also, dass wir nach verfügbaren Räumen testen können. Aber dann wollen wir sagen, dass es keine Buchung machen sollte, wenn sie nicht verfügbar sind. Also werde ich simulieren, dass keine Zimmer verfügbar sind, indem ich meine Liste lösche. Und dann wird der Prozessor seinen regelmäßigen Anruf machen. Und dann werden wir nur überprüfen, dass das nie genannt wird. An diesem Punkt. Dies ist eine Behauptung. Ich brauche keine andere Behauptung, weil ich nicht überprüfen muss, ob irgendwelche Werte zurückkamen oder jemand die gleichen sind wie irgendetwas anderes. Es wird nur sehen, dass es nie genannt wird. Okay, also lasst uns das neue testen. Und wir werden gelesen und ich denke, wir sind gut zu gehen. Lassen Sie uns also zur Implementierung des Codes springen, um dies zu ermöglichen.
12. Implementierung: Prüfe, ob Zimmer verfügbar ist,: In Ordnung, also haben wir bereits getestet, lasst uns rüber springen und unsere Modifikationen machen, um Künstler passieren zu lassen. also zu unserem Anfragen-Prozessor springen, ist
die Bedingung, dass, wenn es verfügbare Zimmer gibt, wir voran gehen und sehen können, ob es keine verfügbaren Zimmer gibt, dann sollte die Speichermethode nicht aufgerufen werden. Jemand, der anfangen kann, indem man die verfügbaren Zimmer bekommt. Ich werde sagen, var verfügbare Zimmer ist gleich meinem
Zimmerbuchungsservice dot bekommt verfügbare Zimmer für die aktuelle Anfrage Bit. das mache, kann ich sehen, ob die verfügbaren Zimmer Dot Kegel. Dies gibt also eine unzählige SF zurück, um zu sagen, dass Kegel offen und schließen größer als 0 ist. Und das erfordert Link. Da gehen wir. Also, wenn die verfügbaren Zimmer Dot Kegel, und dann hier ist es zu sehen, dass auf diesen schlägt, dass ich sehen konnte, übernehmen alle, richtig? Also, wenn es
welche gibt, was mir einfach einen Boolean zurückgeben würde. Wenn es welche gibt, dann kann ich sehen. Also, wenn die Bedingung uns drei Tests einlässt und unser Test bestanden ist, wenn es
also keine gibt, dann würde dies nie aufgerufen werden. In Ordnung. Oder wenn es kein verfügbares Zimmer gibt, das nie angerufen werden würde. In Ordnung. Also werden wir zwei Aktivitäten machen. Nein. Erstens, ich werde nur kurz besprechen, was ich bereits erwähnt habe über wahrscheinlich Refactoring oder Neuanordnung, wie wir unsere Setups machen. In der Vergangenheit habe ich an Projekten gearbeitet, bei denen
anstatt in jeder einzelnen Methode
für jede einzelne Methode einzurichten, wie sie benötigt wird. Was wir taten, war
, dass wir eine einzelne Datei erstellt haben, die gerade den gesamten Mock mit allen Beispieldaten,
allen Setups, allem zurückgab . Also haben wir einen Kontakt. Wenn Sie ein Setup durchführen müssen, wenn Sie etwas im Zusammenhang mit dem Mock-Objekt tun müssen, haben
wir 1 von Kontakten und alles, was relativ dazu ist, wie Sie mit den Daten interagieren. Natürlich, denn in unserer Situation, bevor es ein Versuch ist, diese Dinge zu reißen gebaut, natürlich wie Zimmer. Sie könnten eine Pseudoliste von Räumen an anderer Stelle erstellen, aber die verfügbaren Räume werden von anderen Orten verwendet. Also müssten Sie das in Betracht ziehen. Auch für eine Anzeige für die CFD-Buchung zu begleichen. Wir haben hier den Silbengewinn, aber wir machen einige Behauptungen dagegen. Warum würden sie einfach genug erscheinen, um einfach
all diese OTA zu rippen und einfach das Setup in einer eigenen Datei durchzuführen. Und dann würden wir die Speichermethode bereits einrichten. Wann immer wir ein Mock-Objekt durch diese Datei bekommen, müssen
wir einige der Behauptungen über die Abhängigkeiten berücksichtigen, richtig? In diesem Sinne werde ich nicht unbedingt
voran gehen und jede Refactoring mit den Tests durchführen. Ich wollte nur darauf hinweisen, dass Sie gesagt haben, wenn Sie die Möglichkeit sehen, das zu tun, dann können Sie wissen, dass die zweite Sache, die ich tun wollte, ist, Ihnen zu zeigen, wie Sie debuggen können. Manchmal können Sie also einen Test schreiben, von dem Sie denken, dass er funktioniert oder funktionieren sollte. Und relativ zu dem Code, den Sie geschrieben haben, sollten
zumindest der Test und der Code andere zusammenarbeiten und aus irgendeinem Grund schlägt der Test fehl und Sie sind sich nicht ganz sicher, warum. Und es sagt Ihnen wahrscheinlich etwas MRSA , das ist nicht unbedingt zu sehen, was der Fehler ist. Also habe ich einen Fehler gemacht oder ich ändere einfach die Tests, die wir geschrieben haben, und modifizierte es, damit es fehlschlagen kann, richtig? Du musst also nicht unbedingt diese Aktivität machen, kannst sehen, was ich tue. Das, sie können verstehen, dass das funktioniert. Also habe ich die Testdatei erstellt, richtig? Und es sagt, dass sie Invocation auf dem Mach inspiziert ist einmal, aber es wurde nie genannt. Dann bin ich neugierig auf diesen Spieß. Mein Test sagt, es sollte es 1s nennen, aber basierend auf dem Quartal ROTC, das es angesichts des Testszenarios erinnert. Also natürlich möchte ich wissen, an welchem Punkt mein Code etwas tut, das Sie nicht tun sollten. Manchmal kann er Künstler sein, oder? Sie müssen also nur sicherstellen, dass Sie beide Seiten überprüfen. Also werde ich den Test selbst schreiben und dann Debug sagen. Und bevor ich debuggte, setzen Sie
tatsächlich einen Haltepunkt irgendwo in der Methode, richtig? Also hätte ich das vorhin sagen sollen. Also, bevor Sie aktivieren, möchten Sie Ihren Haltepunkt setzen. Regelmäßige Haltepunkte wie das, was Sie verwenden würden, wenn Sie regelmäßig oder routinemäßig etwas in Ihrem Code erstellen, können
Sie diese verwenden. Und wenn Sie mit dem Test in den Debug-Modus gehen, wird
es sie tatsächlich bestätigen. Also wird es weitergehen, ihr relativ zum Testszenario, richtig? Wenn wir uns also Buchungsanfragen ansehen, werden
Sie sehen, dass dieses Objekt genau das Testmaterial ist, das wir in unserer Testklasse verspottet hatten. Wenn Sie sich die verfügbaren Zimmer ansehen, ist es nicht null. Die angeforderte ist, dass, wenn ich Schritt, dann sehen Sie verfügbare Zimmer ist 0. Warum? Weil wir sie gelöscht haben, bevor dieser spezielle Test durchgeführt wurde. In Ordnung. Dann sage ich, wenn verfügbare Zimmer vorhanden sind, dann sollte es gehen und sagen, ob es 0 ist, wenn der Strom 0 ist, dann gibt es keine. Es überspringt es. Und so hat es nie dazu geführt, dass es soweit es mich betrifft, es tut, was es tun soll. Also, während das ECS, gehe ich fort und dann springt es zu der Zeile, beachten Sie, dass Geschichte und der Fehler, den inspizierten Aufruf
zu sehen, diejenigen sind, die 0 mal genannt wurde. Und dann wurde mir klar, dass meine Anrufung falsch ist. Ich sollte nicht überprüfen, ob es einmal aufgerufen wird. Ich sollte überprüfen, ob es angerufen wird. Nie. In Ordnung. Nun, ich zeige Ihnen nur, wie der Debug-Modus zu 0 helfen kann. Es ist vielleicht heraus, welche Punkte Ihres Codes es etwas tut, wo es relativ zum Test oder an welchen Punkten außerhalb Ihres Tests einen Fehler hat. In Ordnung, also musst du sicherstellen, dass diese beiden zusammen funktionieren, damit ich aufhören kann, zu debuggen, nachdem ich diese Änderung an das nie vorgenommen habe, du hattest das bereits, damit du dir keine Sorgen darüber machen musst. Aber wenn wir diesen Test erneut ausführen wird sehen, dass es nicht bestanden. Alles klar, so können Sie voran gehen und Ihren Tests
ein wenig Debugging hinzufügen , während Sie weitergehen.
13. Testen und Durchführen: Room zum Ergebnis hinzufügen: In Ordnung, Jungs. Also für diese Aktivität, es wird nicht eine lange Aktivität sein, ist wirklich nur ein Addendum zu etwas, das wir bereits getan haben. Und ich denke, wir können sowohl Test als auch Implementierung und Refactoring in einer Sitzung in dieser Situation durchführen. In Ordnung, die nächste Voraussetzung ist, dass die ID
des gebuchten Zimmers auf dem Buchungsdatensatz vorhanden sein sollte. Es ist also wirklich ein Nachtrag, wenn wir wissen, dass wir die Aufzeichnung des Raums sehen, müssen
wir sicherstellen, dass es ein Ausweisgefängnis gibt. Ich springe zu unserer verfügbaren Zimmer Liste und ich werde in das Feld für das Raumobjekt setzen. Es muss nicht existieren. Das ist in Ordnung. Aber ID ist gleich einem anderen, sagen Sie eins, denn ich würde nur die Methode testen wollen. Also wieder, dieses Steuerelement dotnet es die Eigenschaft in springen über. Und Sie sehen, es ist bereits eine ganze Zahl, öffentliche Ganzzahl. Das ist gut. Alles klar, jetzt haben wir zumindest diese ID in für unsere, während es werfen sollte, sollte sehen, da gehen wir. Was ich sagen werde, ist, dass die gespeicherte Booking.com. Und an diesem Punkt gibt es keine Disk-ID auf dem Raum, die sich auch ansehen. Also Zimmer Buchung Zimmer Buchungsbasis, nicht das Ergebnis kann das Ergebnis sein, aber nicht die Basis. Ich möchte es nicht auf der Basis, weil die Anfrage keine Raum-ID hätte. Richtig. Also werde ich ihm nur eine Eigenschaft geben, sagen wir Requisite Top Wanne. Und das wird Raumausweis sein. In Ordnung? Also werde ich sagen, gespeicherte Buchung, Zimmerausweis. Es sollte sein, und es sollte gleich sein, in dieser Situation, die erste ID aus der Liste der verfügbaren Zimmer. Also werde ich nur sagen, es sollte auf einem Platz zur Verfügung stehen Zimmer, Punkte. Zuerst möchte ich das erste Objekt in seinen Kontrollpunkten mit Link First Dot ID verwenden. Also, wenn das einmal aufgerufen wird,
dann, wenn wir all diese Dinge überprüfen,
sollte diese Raumkennung die gleiche sein wie Wasserloch war der erste verfügbare Raum in der Liste. Nun, lassen Sie uns die Tests durchführen. Und manchmal ist es schwer zu sehen, sind sich daran erinnern, welche er immer einfach auf das Häkchen klicken und sagen, es ausführen. In Ordnung, also machen wir einfach einen Projekt-Build wie immer. Und dann kann er Statistiken sehen, und Sie sehen hier, dass es scheitert. Also war es das. So heißt es, dass basierend auf Masse oder Sean getäuscht Buchung Zimmer ID sollte eine Kugel 0 sein. Also, das ist schön. Ein netter englischer Wal, der sieht, was er falsch oder richtig ist? Es sollte eins sein, aber es war 0 und das ist in Ordnung. Das wird erwartet, weil wir noch nichts geschaffen haben. Das ist also die Modifikation des Tests. Lassen Sie uns zum Prozessor springen, kann diesen Haltepunkt entfernen. Und dann, was wir hier sehen werden, ist, wenn es irgendwelche verfügbaren Zimmer gibt, die wir über eine Zeit wissen, dass es den Test durchführt, es wird mindestens einen geben. Dann würde ich sehen wollen, bekommen Sie mir die erste in den Listen unseres Zimmers ist gleich verfügbaren Zimmern. Zuerst der erste in der Liste. Und dann werde ich diese Methode nennen, weil ja, ich brauche das Zimmerbuchungsobjekt, das wirklich einen fantastischen Job von all dem macht. Aber am Ende des Tages muss
ich auch die neue Raumkennung eingeben, die hier sein würde. Also werde ich sagen, geben Sie mir den Raum suchen Anfragen von selbst. So var Zimmerbuchung ist gleich, um das Zimmer aussehende Objekte zu schaffen. Und dann ist die Zimmerbuchung Dot Room ID gleich dem Zimmer, das wir haben. Da gehen wir. Und dann sparen wir oder Raum suchen. Ordnung. Also mit all dem, Helen und lassen Sie mich zurückgehen und die Tests erneut ausführen. Und jetzt haben wir Grün. So beschäftigt manchmal Anforderungen, die bereits kommen, vermissen etwas. Es muss möglicherweise ein Addendum zu einem vorhandenen Test machen und Sie alles so verstauen, wie Sie es brauchen. Also, das ist es wirklich für diese Aktivität. Es gibt nichts viel zu refactorieren, irgendetwas überhaupt zu refactorieren. Wir haben gerade geändert, was eine der Behauptungen und ändern den Code, um sicherzustellen, dass diese Behauptung wahr ist. Und das war's wirklich. Gerade unsere Testdaten modifiziert und diese Anforderung ist nicht erfüllt.
14. Testen und Durchführen: and: In Ordnung, also kommt unsere Bewerbung gut runter. Wir haben alle unsere Aufgaben abgecheckt, während wir weitermachen. Und so haben wir ein paar Schichten. Also die eine, an der wir arbeiten werden, ist Rückkehr Erfolg Flut auf Ergebnisse. Alles klar, wenn wir also eine Anfrage
mit den Ergebnissen einreichen , die vom Code zurückgegeben werden, müssen
wir eine Blume sehen, ob sie erfolgreich war oder nicht. Nein, ich bin auf den Test gesprungen, ich habe die Methode schon gestummt. Und bevor ich weiter gehe, werde ich, wissen
Sie, das Konzept der datengesteuerten Tests zeigen . Datengesteuerte Tests ermöglichen es uns,
anstatt Daten innerhalb der Methode zu verspotten und zu inszenieren, können
wir tatsächlich Parameter eingeben und dann können wir sie einspeisen. Der erste Schritt zu einem datengesteuerten Test besteht also darin, kein Buch zu verwenden, um Theorie zu verwenden. Okay, das ist also unsere neue Anmerkung. Und dann haben wir Inline-Daten, die uns dann viele Parameter nehmen, wie wir für den Test zur Verfügung stellen würden. In dieser Situation wollen
wir also ein Szenario testen, in dem wir eine Erfolgsflagge haben. Und ich könnte das erweitern und sagen, Erfolg oder Misserfolg Flut. Alles klar, denn wir wollen angeben, ob die Buchung erfolgreich war oder nicht, und ich werde eine Aufzählung für diese Konstante verwenden. Also könnte ich sagen, Buchung, Erfolg, Flagge. Und der Typ gibt es noch nicht, die tun das. Und der nächste Parameter wäre, ist verfügbar. Also wollen wir wissen, ist die Flut dieser Wert? Wenn es dieser Wert ist. So ziemlich das sind die Daten, die wir wollen, sind das Szenario , das wir positionieren wollen, basiert auf diesen beiden Werten. Bevor ich weitermache, lass mich das einfach erstellen. Ich werde das nur in Modellen erstellen. Oder Sie könnten es nicht Domäne erstellen, oder Sie könnten einen anderen Ordner erstellen. Ich denke, ich werde nur einen anderen Ordner erstellen und wir werden das eine Enums nennen. Manche wissen sicher, ob das sein wird. Und dann werde ich einfach eine neue Klasse hinzufügen, die es Buchungserfolg-Flag heißt. Aber es ist wirklich eine öffentliche Aufzählung. Und diese Aufzählung wird zu haben Was ist Erfolg und Misserfolg. In Ordnung? Also ist es wieder so ein Zeug wie das Meer. Es war ein Buchungserfolg oder es war ein Fehler bei der Buchung. In Ordnung, also nein, ich kann rüber springen, um zu testen und die fehlende Referenz für die Enumeration einzufügen. In Ordnung, für die Inline-Daten kann
ich Buchungen, Erfolg, Flagge, Misserfolg, Koma sehen . Also sollte es Scheitern sein, wenn das falsch ist, richtig? Wenn nichts verfügbar ist, dann sollte das falsch sein. Und dann sehe ich Erfolg, wenn das wahr ist. So präsentieren diese Datenszenarien, also der Test vorher. Also, egal welcher Code wir schreiben, wird automatisch die Szenarien basierend auf dem, was wir hier zur Verfügung stellen, ableiten. Und natürlich werden die Parameter, die in den Inline-Daten bereitgestellt werden in Übereinstimmung mit den Parametern, die alle für die Methode ausgerichtet sind. Also für den Test selbst werde
ich nur Code schreiben, der für jedes Szenario generisch genug ist. Wenn Sie testen möchten, wenn dies nicht verfügbar ist, möchte
ich meine verfügbaren Zimmer löschen, oder? Das sind also unsere Testdaten. Und natürlich, wenn ich teste, wenn es nicht verfügbar ist, dann möchte ich diese Zeile replizieren. Also mal sehen. Falls nicht verfügbar. Dann führen Sie diese Richtlinie durch. Löschen Sie die verfügbaren Zimmer. In Ordnung. Dann werde ich sagen, var Ergebnisse, die wir wissen, dass wir zurück bekommen, wenn wir unseren Prozessor anrufen. Buchen Sie die Anfrage. Also werde ich diese Zeile einfach kopieren und einfügen. Wir wissen, dass es unsere Ergebnisse liefert. So werden wir kaum selten getestet, es gibt Situationen, in denen wir nicht die Ergebnisse für unsere Behauptungen
bekommen mussten und es gab Situationen, in denen wir Kredit bekommen mussten. Das ist in Ordnung. In dieser Situation ist
var result gleich, um die Anfrage aufzurufen. Und dann werde ich sehen, dass die,
der Buchungserfolg flood dot
sein sollte und es sollte an jedem Punkt gleich dem Code sein. Also r den Anzent Buck durch Ergebnisse zu überschwemmen. So Flag existiert noch nicht, also werde ich nur zu Control dot lassen Sie es
die Eigenschaft innerhalb dieser Ergebnisklasse für uns generieren . Und dann können wir da rüber springen und
diese Eigenschaft ändern und sicherstellen, dass es das ist, was wir erwarten. Und da ist es, öffentliche Erfolgsflagge. Okay, das ist jetzt ein Teil der Ergebnisse. Ich kann sehen, dass der Test zu irgendeinem Zeitpunkt eher das ableiten oder behaupten wird, egal in welcher Situation es sich präsentiert. Wenn es nicht verfügbar ist, löschen
wir und dann versuchen wir, das Ergebnis zu erhalten. Der Buchungserfolg sollte also gleich sein. Was auch immer an dieser Kante vorgesehen ist, sollte in Übereinstimmung mit dem, was von den Ergebnissen zurückgegeben wird. Also werde ich einfach einen schnellen Build machen, nur um sicherzustellen, dass alles in Ordnung ist. Und wenn Sie das überprüfen können, werde
ich das einfach ausführen. Und künstlerischer Entdecker lässt uns wissen, dass das gescheitert ist und das ist in Ordnung. Also, wenn Sie bemerken, als ich auf diese Karotte fiel, zeigt
sie zwei verschachtelte Tests unter dem einen Methodenstub, richtig? Zeigt Ihnen das erste Testszenario. Also das erste Szenario, das das Szenario ist, in dem es Erfolg zurückgeben sollte. Standardmäßig habe ich nichts getan, aber der Aufzählungswert wird immer standardmäßig auf den ersten Standardwert gesetzt, der den Erfolg vorgibt. In Ordnung? Und dann wird das Scheiternszenario nicht
durchgeführt , weil Sie hier die Buchung Erfolg Flag sehen sollte Erfolg sein. Beides war Misserfolg, oder? Jetzt müssen wir Code einfügen, um sicherzustellen, dass all das funktioniert. Also in unserem Prozessor, Da gehen wir. Wir müssen diese if-Aussage ein bisschen mehr verstärken. So ziemlich müsste ich es wissen lassen, dass das Ergebnis, denken Sie daran, die Ergebnisse zurückgibt. Also gehen wir und erstellen die Ergebnisse manuell. Hören Sie nicht. Nun, dann haben wir gerade diese Flut hinzugefügt. Also müssen wir in der Lage sein zu bestimmen, wann der Fluss sein sollte, welchen Wert, oder? Also werde ich, anstatt direkt dorthin zurückzukehren, werde
ich das Ergebnis von oder zu jemandem bauen, um zu sagen, dass Ergebnis gleich ist. Denn unabhängig vom Ergebnis wissen
wir, dass ein Ergebnis diese Werte haben muss. Wir wissen also, dass das Verschieben dieses Refaktors keine große Rolle
spielen sollte , damit sich der Code anders verhält. Zu dem Zeitpunkt, zu dem eine Buchung gespeichert werden soll, wissen
wir, dass, nachdem sie gespeichert wurde, ich sehe, dass die Ergebnisse Punktflagge
gleich Buchung, Erfolg und Erfolg ist . In Ordnung? Und so, wenn es irgendwelche verfügbaren Zimmer gibt, tun
wir, was wir vorher getan haben, und wir setzen die Flagge. Andernfalls werden wir ihm sagen, dass es gescheitert ist. Also der Erfolg, sorry, die Flagge wird wissen, sagen Scheitern. In Ordnung. Das Anrufen dieser Erfolgsflagge für die Buchung ist irgendwie irreführend. Also werde ich das ändern. Also, anstatt erfolgreich zu buchen, werde
ich es Buchungsergebnis-Flag nennen. Das ist generischer. Also dieses Steuerelement Punkte und lassen Sie es alle Referenzen über den ganzen Code aktualisieren. Und das sieht viel besser aus. Am Ende dieser Operation werden
wir nur das Ergebnis zurückgeben. Also haben wir die Ergebnisse von Anfang an erstellt und dann haben wir unsere Geschäftslogik gemacht. Und dann habe ich das nach dem geretteten, weil wenn dieses Feld dann eindeutig das ein Erfolg sein könnte. Sonst war es ein Misserfolg. Und dann gehen wir weiter und geben das Ergebnis zurück. Also, wenn ich diesen Test erneut ausführe und ich mache es einfach vom mittleren Stub, dann bekomme ich grüne Zecken überall, richtig, schön und einfach. Wenn wir also in unsere Tests setzen, implementieren wir, und noch wichtiger ist die Tatsache, dass wir Theorien oder
datengesteuerte Tests durchführen können , wo wir die Szenarien bereitstellen. Und anstatt Sie Aussagen zu schreiben wenn dies dann, dass, wenn dies dann, dass Statistiken, eine ganze Menge Dinge, die wir einen Test schreiben können,
der in die verschiedenen Szenarien passen , die wir erwarten, aus unserer Methode kommen.
15. Testen und Durchführen: Booking für das Ergebnis: Also sind wir wieder für eine andere Übung und dieses Mal wollten wir nur die Zimmerbuchungs-ID zum Ergebnis
hinzufügen. Also bis jetzt haben wir die Zimmerkennung zum Ergebnis hinzugefügt,
also ja, ich habe dieses Zimmer gebucht. Wir möchten jedoch nicht die ID für den Datensatz haben, der gebucht wurde. In Ordnung. Das ist in Ordnung. Also habe ich schon meine Methoden. Beachten Sie keine Anmerkung, weil ich wirklich möchte, dass diese datengesteuert wird. Also werde ich zwei Parameter haben. Ich werde sagen, ein Zimmer, Buchung, Ideen, eine ganze Zahl. Und basierend darauf, ob etwas verfügbar ist, als sich dieser Wert ändern könnte, oder? Also werde ich das gleiche tun hier, wo ich Boolean zur Verfügung habe. Also werde ich meine Theorie wiederverwenden. Und ich werde nur die beiden in Zeilen kopieren und einfügen. Was offensichtlich die Daten Login. Lassen Sie uns also sagen, was uns anschauen lässt, was passiert. Ich würde erwarten, dass vielleicht eine ID von einem wäre daher die Zimmerbuchungs-ID, wenn es wahr ist, dass etwas verfügbar ist. Wenn jedoch nichts verfügbar ist, wie würde nichts für den ID-Wert erwarten? Und das wäre falsch. Oh, ich liebe die Änderung meines Datentyps hier, weil ich null sehe, aber das kann eine Nase dauern, nachdem es nullbar ist, oder? Also werden sie unser Fragezeichen dort aufteilen, das es nullbar macht und dann ist das in Ordnung. Also noch einmal, wegen meines Szenarios, wenn nichts verfügbar ist, dann räumen Sie den Raum frei. Also für das Szenario, wo verfügbar ist falsch, dann löschen Sie die Liste der verfügbaren Zimmer. Andernfalls möchte ich meine Speichermethode einrichten. Also werde ich einfach wieder dahin springen, wo wir das Sieb getestet haben. Da gehen wir. Ich werde mir das wirklich ausleihen. Ich werde es nicht neu eingeben, sondern nur das ganze Setup langweilig. In Ordnung? Und statt all dessen, was ich dort gemacht
habe, werde ich Booking Dot ID speichern. Also ging ich los, um diesen ID-Parameter
zur Buchungsklasse hinzuzufügen , weil es offensichtlich noch keine ID dafür gibt. Und diese ID sollte gleich sein , was ich in der Zimmerbuchungs-ID übergebe, Punktwert. Ordnung. Also werde ich nur Punkte kontrollieren. Lassen Sie es diese Eigenschaft generieren. Und ich weiß, wir haben die Idee und den Zimmerausweis. Wenn Sie also akribisch sind, können
Sie dies neu anordnen und Idee über die Raumkennung setzen. Das ist in Ordnung, aber es wird den Code nicht mehr oder weniger funktionieren lassen. Es ist nur eine Frage der Lesbarkeit, aber das ist in Ordnung. Ich lasse es so, wie es ist. Das ist also das Setup für das C, wenn wir für das Szenario testen, true. Also, wenn es hier nicht verfügbar ist, die Zimmer,
ansonsten, gehen Sie voran und richten Sie auf. Warten Sie, bis diese ID gleich dem Wert ist. Also, nachdem all das erledigt ist, muss
ich auch im Ergebnis für die Zimmerbuchungs-ID eine Darstellung machen. Also muss ich eine öffentliche int Zimmer Buchungsnummer haben. Richtig. Nun, unser OCT auf Behauptung in unserer Testmethode wird
ähnlich sein , wie wir zuvor hatten, wo wir den Aufruf für das Ergebnis durchführen, und dann behaupten wir, dass die Zimmerbuchungs-ID
der Ergebnisse sollte gleich der Zimmerbuchung sein, die wurde übergeben. Jetzt gibt es hier ein Problem und es wird gesehen, dass in keine Definition für enthalten sein sollte. Okay, wir wissen, dass das nicht wahr ist, aber ich denke, es ist nur ein Datentyp in Frage, weil dies ein NULL-fähiger int ist, während dieser nur int ist. Also lassen Sie mich die Zimmerbuchungs-ID nullbar machen. Und da gehen wir. In Ordnung. Also mache ich das NULL-fähig, weil für den Fall, dass etwas nicht verfügbar ist, dann wird die ID, die die Buchungsnummer wird Zimmerbuchungs-ID
sein wird, sowieso nein sein, oder? Also mache ich nur NULL-fähig, dass ein Ergebnis weiß , dass es nicht unbedingt zu jeder Zeit einen Wert haben muss. Also lassen Sie uns die roten Tests machen. Also lass mich laufen. Ich habe es nicht bemerkt, dass es zwei Szenarien gibt, die noch nicht ausgeführt wurden. Wieder einmal werden diese Tests als mehrere Tests innerhalb einer Sitzung gesehen. In Ordnung, also lassen Sie uns zu unserem Code springen. Das wäre also im Zimmerbuchungsprozessor und PR zu viel. Was wir tun werden, ist an diesen Bereich anzuhängen. Das führt zu Punkten. Zimmerbuchungs-ID erhält den Wert, was auch immer Zimmerbuchung Punkt-ID wird. In Ordnung, also an diesem Punkt bekommt es diesen Wert. Sie sehen also, dass test.py den Null-Szenario-Kopf getestet hat. Lassen Sie mich zu den Tests zurückspringen. Es wurde also für das Null-Szenario analysiert, in dem dies null ist und das falsch ist. Also, das wäre tatsächlich in dieser Nacht passiert Charlie, denn hier sitzen wir keinen Wert für die Zimmerbuchungs-ID. Es ist nullfähig. Und so null ist automatisch ein Zentrum ist alles Punkt Zimmer Buchung ID in dieser Situation. Also müssen wir sicherstellen, dass dieser vorbei ist. Also, wenn wir zurückgehen und unsere Tests wieder ausführen, dann werden wir sehen, dass wir grünen Test bekommen. Ordnung. Also wissen Sie unsere Behauptung, dass die Zimmerbuchungs-ID, das ist seine Rückkehr sollte immer ähnlich sein wie der Wert, der zur Verfügung gestellt wurde. So wird mindestens eine zur Verfügung gestellt, dann kommt die Zimmerbuchungs-ID als
eine zurück , wenn Wissen vorausgesetzt, es geht zurück als alles. Das ist also gut. Also lassen Sie mich einfach einen Build machen und wir haben nichts anderes, um keine größeren Änderungen zu tun, also haben wir nichts zu viel zu refactorieren. Das ist es also, um diese Anforderungen zu erfüllen.
16. Abschnitts-: Alles klar, Leute, damit wir alle Checkboxen sicher abhaken können und all unsere Karten
überziehen, die es nicht tun. Und wir sehen, dass
wir für diese vorläufigen Anforderungen Tests implementiert und Code geschrieben haben, und wir haben eine gute Code-Abdeckung für die Kernfunktionalität unserer Anwendung. alles ist also vorerst erledigt. Daher haben wir Komponententests für den Anwendungskern abgeschlossen. Nein, natürlich gibt es noch viel mehr zu tun. Wenn wir zurückkommen, müssen wir die Implementierungen für unsere Schnittstellenmethoden beenden, denn hier passiert eindeutig nichts wirklich. Und im Moment ist es noch in der Theorie. Der Punkt der testgesteuerten Entwicklung ist jedoch, dass
Sie tatsächlich eine gute Vorstellung vom API-Design,
dem gesamten Anwendungsdesign oder dem Geschäftslogikdesign erhalten können. Bevor Sie tatsächlich in das Fleisch von dem gelangen, was wirklich passieren muss, können
Sie alle
Ihre Klassen von sehr früh an Wireframe aussehen sollten und wie sie miteinander in Beziehung stehen. Das haben wir also wirklich getan. Später werden wir uns also mit der Datenbank verbinden und Komponententests schreiben. Stellen Sie sicher, dass Datenbankoperationen sich so verhalten, wie wir sie erwarten würden,
und eskalieren Sie diese dann, um die vollständige Anwendung zu testen. Aber jetzt lasst uns nur unsere Veränderungen auslösen. Und meine Commit-Nachricht ist fertig Unit-Testing-Anwendungskern. Wir können alles begehen und sinken. Und wenn wir zurückkommen, werden
wir uns mehr Aktivitäten ansehen.
17. Refactor für Refactor: Na gut, Leute, willkommen zurück. In dieser Lektion möchten wir die Schritte zum Einrichten unserer Datenzugriffsebenen durchlaufen. Und das wird einige Refactoring und Neuanordnung unserer Projekte beinhalten. Wenn Sie sich meinen Lösungs-Explorer ansehen, würden
Sie sehen, dass ich ein paar neue Projekte habe und einige Dateien an neuen Orten sind. Und ich werde dich Schritt für Schritt durch sie führen wollen. Ich wollte es nicht vor der Kamera machen, weil wir alle wissen, wie man Projekte erstellt. Also werde ich Sie nur leiten und Sie können anhalten und sich replizieren, während wir weitermachen. Aber solange Sie einfach durchschauen und es Schritt für Schritt tun, sollten
sie kein großes Problem haben. Lassen Sie uns also mit den neuen Projekten beginnen, die hinzugefügt wurden. Wir haben die Up Domain hinzugefügt, also Raum aufbauen Punkte Domäne, das ist ein eigenes Projekt. Wir haben auch Zimmer Buchung Punkt Persistenz beider von ihnen hinzugefügt, ich habe nur Klassenbibliotheken. Und wenn Sie sich erinnern, war der Raum, der über den Kern nachsah, nur eine Klassenbibliothek. Also die gleichen Regeln, die Sie verwenden, um den Raum zu steuern, die den Kern aufbauen, können
Sie diese für die Domäne und die Persistenz wiederverwenden. Und dann haben wir einen weiteren X-Unit-Test-Projektraum hinzugefügt, der Punkt-Persistenz aufbaut. Richtig? So können Sie fortfahren und diese drei Projekte zu Ihrer Lösung hinzufügen. Nun in Bezug auf die Neuanordnung der Dateien,
was wir getan haben, war, den Domain-Ordner oder
Dateiserver in den Domain-Ordner zu nehmen und ihn innerhalb der Domain-Projekte zu platzieren. Also habe ich den Ordner nicht vorher losbekommen. Natürlich habe ich die Dateien gefangen und sie in die Domänenprojekte eingefügt. Beschichtungen so einfach wie Klicken auf die Datei, die Sie wollen, und Sie mit Control X gehen in das Projekt, das Sie wollen, und sagen Control V. Also das ist alles, was ich
getan habe , um sie in das Domänenprojekt zu schneiden und einzufügen. Die nächste große Bewegung war die Bewegung der Zimmerbuchungsbasis, richtig? Also denken Sie daran, dass wir die Zimmerbuchung Basisklasse selbst hatten, die Models-Ordner. Ich habe das herausgenommen und es in einen eigenen Ordner in der Domänenklasse namens Basismodelle gelegt. In Ordnung? Nun, natürlich würde das viel von dem stören, was wir an Ort und Stelle haben, weil die Namespaces geändert werden müssen und wir zusätzliche Verwendung hinzufügen müssen. Daher traten die Vorname-Speicheränderungen mit den Dateien auf, die verschoben wurden. Also Zimmer, Zimmerbuchung und Zimmerbuchungsbasis haben alle neue Domain. Sorry, Namespace-Namen in Form von Zimmerbuchung, dot domain Für Zimmer- und Zimmerbuchung, und dann Zimmer buchen dieses Zimmer Buchung bis dot Domain dot basierte Modelle. Also mit dieser Änderung heben Sie
tatsächlich einige der Fehler auf, die erwartet worden wären. Also müssen Sie zuerst dieses Projekt lassen, noch dass es ein Projekt oder einen Verweis auf das Domänenprojekt hat. Sie können das auf zwei Arten tun. Entweder Sie gehen, ich benutze Kontrollpunkt und Sie würden diesen Zusatz
tatsächlich sehen, um die Kernreferenz hinzuzufügen. Wenn Sie jedoch die Dinge selbst in die Hand nehmen möchten, können
Sie immer mit der rechten Maustaste auf Abhängigkeiten klicken, Projektreferenz
hinzufügen und dann nur sicherstellen, dass Sie den Mittelwert verwenden. Sobald diese Projektreferenz vorhanden ist, können
wir jetzt den Punkt steuern und die using-Anweisungen
überall hinzufügen , die durch die Änderung beleidigt wurden, richtig? So können Sie einfach jede Datei
sorgfältig durchgehen und sicherstellen, dass wir die Referenzen auf anderen aktualisieren. Verwenden Sie die Steuerungstaste, um aufzuräumen, während ich mitmache. Und in unserem Prozessor würde wissen, dass dies
eine sehr verärgerte Datei sein würde , weil das ist, wo eine Menge von der Aktion stattgefunden hat. Verwenden Sie also einfach Kontrollpunkte, die Anweisungen verwenden. Und überall, was nicht zufrieden ist. Kontrollieren Sie einfach Punkt, Kontrollpunkte. Und mit ein paar sollte
es sein, alles sollte in Ordnung sein. Stellen Sie also sicher, dass Ihre Namespaces korrekt sind, und Sie aktualisieren alle Referenzen, während Sie im Test fortfahren. Ich bin mir sicher, dass wir ein paar haben, die wir auch aktualisieren müssen. So steuern Sie Punkt und aktualisieren Sie die neuen Namespace-Referenzen. Und mit einem ist alles in Ordnung für mich in diesem Test. Das ist also die Operation mit der Domäne. Ordnung, also können Sie fortfahren und
diesen Persistenzpräsidenten einrichten und alles, indem Sie einen Ordner namens Repositories hinzufügen
, der leer ist, richtig? Kein Wearable, um es zu füllen. Ich mache das zusammen, aber wir machen das zusammen. Aber für den DB-Kontext, was ich getan habe, ist, einen Verweis auf
Microsoft als Entity Framework Core Punkt SQL Server hinzuzufügen . So können Sie es entweder in das Projekt für
das XML setzen oder natürlich verwenden wir neue bekommt Sie einfach mit der rechten Maustaste. Gehen Sie zu NuGet-Pakete verwalten, und Sie können SQL Server
suchen und diese Bibliothek installieren. Also, sobald Sie diese Bibliothek installiert haben. Wenn wir unseren DB-Kontext einrichten. Und ich habe noch einige beleidigende Abstimmung hier, kein Problem, Kontrollpunkte und fügen Sie die using-Anweisungen hinzu. Natürlich benötigen die Persistenzprojekte auch einen Verweis auf das Domain-Projekt. In Ordnung, also noch einmal, stellen
Sie sicher, dass Sie diese Projektabhängigkeit haben. Also, wenn das Steuerelement Dot nicht vorgeschlagen hat, dass es Sie sich selbst tun wollen, kann
er rechts gehen, um uns für den Rest der Datei zu treffen und zu sehen, was wir hier getan haben. Zum einen fügen wir den Verweis auf die Verwendung für Entity Framework Core hinzu, nachdem wir unseren öffentlichen Raum nach DVI-Kontexten erben lassen. Dann haben wir unseren Konstruktor. Und denken Sie daran, dass eine Abkürzung für Konstrukteure, siehe Teer
Wanne, Wanne epic scheitert, weil TOR dort oben obwohl sehen. Sie können das also immer tun und Ihren Konstruktor generieren. Und innerhalb dieses Konstruktors haben wir die Parameter DB, Kontextoptionen Raum aufbauen Didi-Kontexte und Optionen. Und dann müssen wir die an die Basis weiterleiten. In Ordnung? Benötigt keine Inhalte. Stellen Sie einfach sicher, dass Sie diesen Konstruktor haben. Für unsere Tische oder RDB-Sets. Was wir haben wäre DB Satz von Typ Zimmer für die Zimmer, DB Sätze der Art Zimmer Buchung für die Zimmerbuchungen. Und dann haben wir unseren geschützten Ober bei void beim modalen Erstellen von ModelBuilder, richtig? Also für diese Methode, wo religiöse überschreiben eine Abkürzung zu bekommen, um am Ende mit ein wenig zu überschreiben und dann Raum. Und dann gibt es Ihnen alle Methoden, die Sie über sein bewiesenes Serotyping-Modell könnten, dann werden Sie sehen, dass es beim Erstellen von Modellen erscheint. Das ist also gut, dass die Methode weiß, was wir innerhalb dieser Methode tun. Stummel. Das alles rückgängig machen. Was wir in diesem Methodenstub tun, ist das Seeding einiger Daten, richtig? Also sehe ich nur, dass ModelBuilder Punkt-Entitätsraum Daten
hat und dann fügen wir nur drei neue Räume hinzu. Dann wirst du sehen, dass ich ID und Name habe. Also vor diesem Namen gab es nicht. Alles, was wir im Zimmer hatten, war ID, also können Sie einfach zu Zimmer springen und diese Namenseigenschaft hinzufügen. Kein Problem. Nachdem Sie diese Namenseigenschaft hinzugefügt
haben, können Sie voran gehen und ihm einen Namen geben. Man könnte Name sagen, man könnte eine Beschreibung sagen, was auch immer es ist. Wir wollen nur einige Beispieldaten und wissen Sie, damit es ein wenig vernünftiger aussehen, fügen Sie ein wenig mehr hinzu, als würde unsere Anwendung zusammenkommen. Nein, in Bezug auf Fremdschlüssel, müssen
wir auf jeden Fall eine Fremdschlüsselreferenz hinzufügen, die in den Raum und den Raum Blick in den Raum König könnte OS. Also werde ich das einfach schnell neu anordnen. Ich werde Raum-ID sagen, aber ich werde auch die Navigationseigenschaft vom Typ Raum hinzufügen und es Raum nennen. Und dies würde dazu dienen, es wissen zu lassen, dass dies ein Fremdschlüssel Perioden ist. Entity Framework Core ist also intelligent genug, um zu wissen, dass dies ein Fremdschlüssel ist. Wenn Sie mehr in die Tiefe Dinge wissen möchten, funktioniert
ein Bolzenloch Entity Framework Core und wie Ihre Modelldatenbank subtile Fremdschlüssel ist und so weiter. Sie können sich meinen Kurs, Entity Framework Core, eine vollständige Tour ansehen. Also werde ich hier nicht zu tief mit
den Konfigurationen und allen Möglichkeiten von Entity Framework eingehen . Stattdessen werden wir einfach ständig auf unseren
Datenzugriffsebenen sitzen , damit wir mit unseren Projekten beginnen können, richtig? Also an dieser Stelle möchte
ich in das Repository setzen. Also, dass Repository, natürlich, oder vielleicht sollte ich diese Dienste eigentlich Datendienste nennen, richtig? Und dann könnten wir dies in Datendienste umbenennen, wenn Sie möchten. Ich meine, es gibt so viele Möglichkeiten, wie er umbenennen kann. Manchmal benennen Sie einen Namen, einen Namen, und dann stoßen Sie auf Probleme. Das ist, was ich denke, ich werde es Repositories nennen. Denn wirklich und wirklich, obwohl wir es Data Services nennen, sind
sie wirklich nur Repositories für Funktionen. Und er hat, ich werde eine neue Datei hinzufügen. Und ich versichere nur den Namen dort. Also werde ich eine neue Klasse hinzufügen. Und ich wollte es als Zimmerreservierungsservice nennen. Nur mit all dem Ich, richtig. Lassen Sie uns das hinzufügen. Und ich ging, um diese öffentliche Klasse zu treffen und es wird von i Zimmerbuchungsservice erben. Das bedeutet, dass ich eine Projektreferenz auf den Kern brauche. Und ich werde das tun und die using-Anweisung. Und dann ist die nächste wichtige Sache, dass es die Schnittstelle implementieren muss. Alles klar, jetzt haben wir unsere Implementierungsmethoden. Natürlich haben wir die Methode noch gekauft, nicht die eigentliche Implementierung, oder? Also noch einmal, wenn Sie sehen wollen, wie dieser Vererbungsrand Ihnen helfen kann, werden
Sie die blauen Markierungen sehen, die auf meiner linken Seite hören. Und wenn ich klicke, kann ich zur Hauptdatei springen. Das ist also eine schnelle Möglichkeit, zwischen Dateien und
ihrem Aussehen zu navigieren , da es das war, von dem sie erben, richtig? Also, das ist es wirklich für null
für, zum Einrichten der Datenzugriffsebenen. Nun, noch einmal, wenn Sie diese überprüfen müssen, pausieren und durchgehen müssen, sehen Sie genau, was ich bin, wo und, wissen
Sie, Sie könnten leichte Variationen einiger der Namen haben ,
die Sie für Ihr Projekt verwendet haben, im Vergleich zu Ihrem -Ordner. Und das ist in Ordnung, oder? Solange die allgemeine Idee, warum das immer ausgespalten wird, da ist. Und es ist relativ zum Wandel. Es ist bestenfalls philosophisch. Aber solange Sie verstehen, wo wir sind, was muss gehen und das ganze seine Varianz und bekommen die Referenzen, anstatt es sollte in Ordnung sein. Wir sehen uns das nächste Mal, wenn wir unseren ersten Integrationstest lesen.
18. Unit Abrufen von verfügbaren Räumen: Willkommen zurück Jungs. Wir sind ein mutiger Lese- oder erste
Integrationstests oder Komponententest gegen Funktionalität, die vom Entity Framework erwartet wird. Also sind wir bereits Setup oder DB-Kontext und wir würden Setup oder andere Projekte im Testprojekt haben, habe ich hier eine Datei erstellt, Zimmerbuchungs-Service-Tests. So können Sie fortfahren und diese Klassendatei hinzufügen. Natürlich, machen Sie es öffentlich. Und dann innerhalb dieser Datei werden wir unsere erste Methode haben. Also ist es öffentlich leer, sollte verfügbare Zimmer zurückgeben. Also natürlich müssen wir es mit
unseren Attributen und bei jeder using-Anweisung dekorieren , damit das passiert. Jetzt können wir mit unseren Arrangements beginnen. Also, wenn wir zurück zu unserem Code für unseren Prozessor springen, würde sich daran erinnern, dass für uns, um die verfügbaren Zimmer zu bekommen, wir mussten in der Anfrage Buchungsdatum übergeben, richtig? Damit wir gegen die Datenbank testen können, müssen
wir simulieren, was die Datenbank wissen müsste, wenn etwas verfügbar ist. Also zuerst den Bereich abschlagen würde, zu sagen, var ist gleich, um die Zeit zu kennen. Wir können einfach eine Testvorlaufzeit einplanen, oder? Also werde ich in das heutige Datum setzen, das 2021 ist, 0 sechs Komma 09. In Ordnung, und dann werde ich unsere Optionen speichern. Die Sache ist also kein Zweifel, dass wir eine Instanz unserer Datenbank brauchen. Wir müssen die Optionen initialisieren, die wir in den Datenbankkontext übergeben können. Also denken Sie daran, dass unser Kontext den Konstruktor hat, der nach einigen Optionen sucht, Parameter des Typs db
Kontextoptionen und relativ zum Raum sucht, der EV Kontexte sucht, richtig? Also sage ich nur, var-Optionen sind, Sie können DB-Optionen oder Kontext-Optionen sehen, über die Sie dies benennen müssen. Also werde ich sagen, var DB-Optionen sind gleich einer neuen Instanz von
neuen DB-Kontextoptionen Builder relativ zur Raumbuchung von DVI-Kontexten. Und wir haben die Klammern und wir fügen Punkt, verwenden In-Memory-Datenbank. Nun, auf dem Weg werden ein paar Referenzen hinzufügen müssen, während, und Sie müssen Projektverweis auf die Persistenz hinzufügen, richtig? Also wieder klicken Sie mit der rechten Maustaste auf Abhängigkeiten. Gehen Sie weiter und fügen Sie Persistenz hinzu. Und eine weitere, die Sie hinzufügen müssen, ist
eins zu Entity Framework Core im Speicher
, den Sie über NuGet erhalten können. Also klicken Sie einfach mit der rechten Maustaste auf viel Geld und Sie erhalten Pakete. Sie können tatsächlich nur im Speicher danach suchen. Und Sie sollten es ganz leicht finden. Und indem Sie es und ich installiert
haben, erhalten Sie alle anderen und zu den Framework Core-Bibliotheken, die benötigt werden. So können Sie einfach voran gehen und diese beiden Referenzen hinzufügen. Und dann solltest du alle roten Linien loswerden, die sich hier treffen. Natürlich müssen Sie sicherstellen, dass Sie
die entsprechende using-Anweisung haben , während Sie weitergehen. Also hier sehen wir Verwendung In-Memory-Datenbank, und das ist die Datenbank, die ich verwenden werde. Ein weiterer wäre Punktoptionen. In Ordnung, das sind also unsere DB-Optionen, die wir für die In-Memory-Datenbank erstellen, die nur so lange existieren wird, wie es für die Durchführung des Tests benötigt wird. In Ordnung, also ist das in Ordnung. Nein, im Kontext des Bereichs, genau das gleiche. Wir wollen eine Beispielkontexte. Also wollte ich VAR-Kontexte mit var context sehen. Das heißt also im Grunde, schafft uns Umfang, in dem Sie
einen Kontext haben , der einer neuen Instanz unserer Zimmerbuchung entspricht. Baby-Kontexte, die sich daran erinnern, nimmt einen Optionsparameter, gebe
ich ihm die Optionen, die wir gerade erstellt haben, das sind DB-Optionen. In Ordnung? Und dann innerhalb dieses Blocks werden
wir es mit einigen temporären Daten nur für die gesamte Lebensdauer dieses Tests auszeichnen. Also wollte ich sagen, Kontexte dot add. Und Sie können tatsächlich einfach eine neue Entität von allem hinzufügen, was es erkennt, oder? In älteren Versionen von Entity Framework Core sollten
Sie wahrscheinlich spezifischere Kontexte sein. Der Tisch, der Räume sein wird, Punkte ungerade. Aber dann können Sie in den neueren Versionen einfach Kontexte dot-dot sagen, und dann geben Sie ihm ein Objekt, das es kennt, es weiß. Also hast du Zimmer. In Ordnung. Gehen Sie weiter und fügen Sie die Referenz hinzu. Also füge ich einen neuen Raum hinzu und ich kann ihm eine ID gleich 1 geben. Vielleicht, wenn du willst, kannst
du ihm einen Namen geben. Und es hängt davon ab, wie körnig oder wie viel Detail Sie im Test wollen. Also sage ich nur Zimmer 1 und dann Semikolon. Also kann ich vielleicht drei davon hinzufügen, oder? Shin von ihnen entsprechend. Das sind also die drei Proben, die ich hinzufüge. Und dann werde ich zu den Buchungsunterlagen für unsere Zimmer hinzufügen. So weiter für Dan 14 am Vortag. In Ordnung, also Kontexte dot-dot, neue Zimmerbuchungs-ID ist gleich eins. So wurde das Zimmer zu den Terminen gebucht, die wir vorbereitet haben. In Ordnung. Und dann wurde das nächste Zimmer am Vortag oder am Tag danach gebucht, was auch immer Sie wollen. Aber für die heutige, sollte nur einer sein. Das ist das Szenario, das ich erstelle. Natürlich liegt es an dir. Was wollen Sie in Ihrem Testszenario tun? Am Ende all dessen werden
wir nur einen Kontextpunkt-Änderungen vornehmen, um sicherzustellen, dass die Datenbank die Daten an sie gebunden erhält. Und du wirst bemerken, dass ich die geschweiften Klammern losgeworden bin, richtig? Also schlugen sie Editor vor, dass wir einfach Kontrollpunkte verwenden und den Vorschlag gemacht haben und dies in eine using-Anweisung für den Kontext ändern. Und dann können wir weitermachen und unseren ganzen Code schreiben. Damit ist es wirklich für den Bereich des DB-Kontext-Leads zusammengefasst,
muss auch ein Objekt
des Dienstes oder eine Repository-Datei arrangiert werden, um den Zimmerbuchungsservice von Witch zu nennen. Der Zimmerbuchungsservice muss also in der Lage sein, mit der Datenbank zu sprechen, um seinen Betrieb durchführen zu können. Deshalb gingen
wir im Zimmerreservierungsservice voran und injizierten diesen Kontext. Wenn wir nicht ganz sicher sind, wie das geht, für uns, um den Konstruktor CTO, unsere Badewanne, Badewanne zu bekommen. Und dann setzen wir in die Häufigkeit von Raum nach DVI-Kontexten, Kontexten und dann Kontrollpunkte. Weisen Sie das Feld zu und erstellen Sie. Da gehen wir. Und dann verwenden Sie den Unterstrich, nur den Schlüssel namens konsistent. Und das ist alles, was das Injektiv ist. Also nein, obwohl die Methoden noch nicht implementiert sind, haben
wir eine Möglichkeit, mit der Datenbank über den Kontext zu sprechen. Also in unseren arrangierten und allen, müssen
wir eine Instanz dieses Dienstes initialisieren. Lassen Sie mich diesen Zimmerbuchungsservice qualifizieren. Richtig? Und Zimmerbuchungsservice ist gleich einer neuen Instanz der Klasse mit dem gleichen Namen, dem Zimmerbuchungsservice, der den Parameter von den Kontexten nimmt, was in diesem Fall unsere In-Memory-DVI-Kontexte ist. Also, jetzt sind wir fertig mit dem Arrangement, es ist Zeit für uns. Also für unseren ersten Akt, werden
wir var haben, verfügbare Zimmer gleich unserem Zimmer, Buchungsservice, Punkt, bekommen verfügbare Zimmer. Und wir geben einfach die Daten, die wir vorbereitet haben. Also auf allen verfügbaren Zimmern dafür. Einfach ein angebotenes Nein, es ist dann für die Behauptungen, was auch immer wir geltend gemacht haben. Also an diesem Punkt, wenn Sie Ihre Flüssigkeit verwenden wollen, behaupten Sie Ihre fließenden Behauptungen sollten unsere Standardbehauptungen legen, Das ist kein Problem. Ich meine, du wirst sehen, wie sie alle funktionieren. Also, ähm, oder zumindest sicher eine Behauptung, die Standardbehauptung funktioniert. An dieser Stelle können
Sie sich frei fühlen, diejenige zu verwenden, mit der Sie sich wohler fühlen. Was ich dieses Mal die Standard-Assert verwenden werde. Also ging ich zu behaupten, dass der Kegel
des Raumes, der verfügbaren Räume dafür, sollte
es X-Nummer sein. Wie viel Geld sollte es wohl sein? Basierend auf dem Szenario, das Sie vorgestellt haben, haben Sie wahrscheinlich eine andere Behauptung als ich. Aber ich denke, es sollten zwei sein, oder? Weil, und dann wird dies darauf hindeuten, dass ein Austausch der Argumente, richtig? Also, um das gleich zu sein. Also behaupte ich, dass es mindestens zwei sein sollte, weil ich Zimmer eins bis
drei habe und Zimmer ID mit einem gebucht ist, damit es Zimmer ID 2 für den Tag vor gebucht wird, und Zimmer ID3 hat keine Buchung gemäß der Datenbank. sollten also mindestens zwei Zimmer zur Verfügung stehen. Während die Behauptungen, die wir tun können, wäre, sicherzustellen, dass die Zimmer, die wir erwarten, verfügbar zu sein, in der Liste enthalten sind, richtig. Damit Sie die Kantinen behaupten können. Was sind unsere verfügbaren Zimmer? Und dann enthält keine würde sagen, geben Sie mir den Datentyp, was erwartet wird, und dann sagen Sie mir, was erwarten Sie darin zu sehen? Was diese Überladungen zeigen nur vier Strings, richtig? Also hier ist, hier ist ein besseres. Die dritte Überladung zeigt also tatsächlich für eine unzählige Sammlung. Und dann braucht es ein Prädikat R, einen dieser Lambda-Ausdrücke als Filter für die Vergleiche. Mit anderen Worten würde ich sagen, Lambda Ausdruck Q
, der einen der verfügbaren Räume darstellt. Ich könnte sagen, die ID sollte auch sein, oder zumindest verfügbare Zimmer sollten etwas mit der ID zwei enthalten. Richtig? Ich könnte dasselbe für die drei tun. Und ich könnte auch behaupten, enthält nicht die dafür gesorgte, dass es keine ID mit einer hier enthält. Anzahl der Dinge, die Sie an dieser Stelle tun können. Wenn du willst, tut es, tut es mir leid, ich denke ein Name, den du gegen den Namen behaupten könntest. Es liegt also an Ihnen, aber das tut Künstler jetzt, um sicherzustellen, dass wir verfügbare Zimmer bekommen. Und wieder einmal sind wir mit Pseudo-Datenbank Glucose erstellen die Datenbank, arrangieren sie, sitzen oben mit einigen Beispiel-Zeug. Und dann handeln wir auf der Behauptung. Also lassen Sie uns diesen Test durchführen. Und wir wissen, dass wir lesen werden. Aber lassen Sie uns es zumindest ausführen und sicherstellen, dass unsere Syntax korrekt ist. Und wenn wir zum künstlerischen Explorer springen, sehen
wir alle vorherigen grünen Ticks, aber dann sehen wir, dass wir ein neues Testprojekt haben und wirklich zu unserem neuen Test bekannt ist
, der uns unser System nicht implementierte Ausnahmen gibt. Also, das ist in Ordnung. Also wissen wir wenigstens, dass es unsere Kontexte nennt. Entschuldigung, es ruft unseren Service an, unser Repository. Und an dieser Front ist alles in Ordnung. Nehmen wir an, noch einmal, gehen wir durch, wie wir arrangiert und gehandelt und für diesen speziellen Test geltend gemacht haben. Denn obwohl es sich um eine andere Art von Test handelt, ist
dies ein Integrationstest, bei dem wir ein Setup einbeziehen, das
diejenigen hat, die unsere Inszenierung verspotten. Lassen Sie uns orange Staging verwenden, wo kein Staging-System, das ist ein Drittanbieter-System, weil dies, während der Kontext in unserer Datenbank existiert, EF Core eine Bibliothek von Drittanbietern ist. Also inszenieren wir tatsächlich,
was diese Drittanbieter-Bibliothek unter
einem normalen Umstand tun würde , mit der unsere reguläre Datenbank tatsächlich verbunden ist. Wir haben das noch nicht, also können wir es fälschen, indem wir den In-Memory ihm den Namen
geben. Also können wir sagen, okay, verwenden Sie die In-Memory-Datenbank, nannte es, dass für jetzt und bauen Sie diese Optionen und in dem Kontext,
der uns von e, natürlich, so vielseitig, dass, sobald wir Optionen bauen, haben
wir verschiedene Erweiterungen . Wir können SQL-Optionen verwenden, können
Sie PostgressQL-Optionen verwenden. In diesem Fall verwende ich im Speicher. Und einige Leute würden SQL-Light-Optionen verwenden, richtig? Tatsache ist, dass Sie die Optionen und die Erstellerkontexte erstellen. Vergleich zu diesen Optionen stehlen
Sie die Daten, die Sie in der Datenbank für diesen Kontext benötigen, für diesen Test. Und dann Eukaryoten, Protisten, als ob Sie gegen echte Daten
testen, die existieren sollten. Es ist also wie ein kleiner Schritt vom Erstellen einer Liste entfernt, oder? Das sind also unsere roten Tests für diese Aktivität. Wenn wir zurückkommen, werden wir unseren Kern umsetzen.
19. Implementierung: Abrufen von verfügbaren Räumen: Alles klar, Leute. Also haben wir nur Tests für unsere verfügbaren Zimmer geschrieben oder gelesen, genannt die verfügbaren Zimmer. Und ich habe den Code bereits geschrieben und ich habe es getan, nur damit wir gemeinsam durchgehen können. Aber deshalb siehst du, dass ich schon ein grünes Häkchen habe. Aber durch Array habe ich die Änderungen rückgängig gemacht. Also werde ich wieder rennen und es roten Test machen. Und da gehen wir. Also sind wir auf Parität null. Lassen Sie uns also schauen, wie wir dieses Zitat umsetzen können. Also nennen wir die Methode bekommen verfügbare Zimmer. Wenn ich Control und F 12
überspringen wird und Sie die nicht implementierte Ausnahme sehen werden, worüber sich das beschwert, und das ist in Ordnung. Also unsere Erwartung ist, dass, wenn wir diese Methode aufrufen, geben Sie ihr ein Datum, es wird Regeln zurückgeben, die derzeit
verfügbar sind, angesichts der Daten, die angefordert werden. Also, was brauchen wir, um hierher zurückzukehren? Wir müssen sicherstellen, dass wir eine Abfrage schreiben, die erwarteten Daten reflektieren wird. So kann ich sagen, var, verfügbare Zimmer ist gleich unserem Kontext, Punkte Zimmer. Also kann ich in den Zimmertisch schauen und dann offensichtlich einen Filter
brauchen, wo Lambda-Ausdruck, wie würde ich den Raum bekommen? Also habe ich zwei Möglichkeiten. Ich könnte wahrscheinlich in der ich in den Zimmerbuchungen suchen könnte. Australien, die Zimmerbuchung stabil, wo die DNA entspricht der aktuellen Ziffer. Richtig? Aber woher weiß ich dann, ob ich Glück in der Zimmerbuchung stabil habe? Woher weiß ich, welche Tabellen nicht sind? Richtig? Also schätze ich, ich könnte das Zimmer selbst auswählen. Also Q Punkt, Punkt. Ja, wir haben das Zimmer, also nein, ich weiß, welche Zimmer gebucht sind. Also sollte ich dies auf verfügbare Festplatten ändern. Also mache ich das eigentlich. Dies ist wie mein üblicher Denkprozess beim Schreiben älterer Abfrage, was sind die, was ist am einfachsten, den wir den Lambda-Ausdruck ableiten, um die Daten richtig zu bekommen? So kann ich leicht die nicht verfügbaren Zimmer finden, aber nein, ich muss die verfügbaren finden. Also kann ich sagen, var verfügbare Zimmer ist gleich dem Kontext Punkt Räume,
Punkte, wo der Q Lambda Ausdruck, Q Punkt ID des Raumes sind eher, würde
ich sagen, wo auf verfügbaren Zimmern. Also haben sie diese Liste gemacht. In Ordnung. Also auf verfügbaren Zimmern ist keine Liste. Zweitens sehen Sie, wo die Liste der verfügbaren Zimmer Punkt enthält, die aktuelle Raum-ID entspricht false. Ich mache das eigentlich absichtlich. Ich zeige Ihnen die kompliziertere, wo Sie wahrscheinlich schon herausgefunden damit Sie es einfach schreiben können und wenn Sie sie Lodos an Sie haben, kein Problem. Ich zeige dir nur, was der Gedankenprozess sein könnte. Einige Seeing bekommen mir die Zimmer, in denen die nicht verfügbaren Zimmer enthält, dass. Also habe ich tatsächlich wegen der Lesbarkeit gleich falsch geschrieben, aber es könnte auch nicht kontinuierlich sein, oder? Aber für Lesbarkeitszwecke, die interagieren oder das Äquivalent zu false. Alles klar, und dann bekommen wir das als Liste. Also, wenn ich das tue und dann die verfügbaren Zimmer zurückgebe, dann hätte ich theoretisch bekommen, was nicht verfügbar ist, dann rief all die harten alle Zimmer an, was verfügbar ist, indem ich diejenigen sah. Es ist nicht in der Liste der nicht verfügbar enthalten, dann geben Sie es zurück und wir geben es zurück. Also werde ich diesen Test ausführen und sehen, ob dieses bisschen Code funktioniert. Und wenn wir uns unseren Test ansehen, sehen
wir, dass wir grünes Licht bekommen. Es funktioniert, oder? So wie wir es getan haben, schreiben
wir wahrscheinlich den Code auf eine Art und Weise, wie wir den Test bestehen lassen. Und dann sagen wir, wie könnte ich diesen Code umgestalten ihn ein wenig besser
zu machen oder was auch immer, aus welchem Grund auch immer. Also für mich, das ist zwei Datenbank, weil dies eine ist, um zu bekommen, was nicht verfügbar ist, dann wollen Sie überprüfen, ob die Tabelle irgendwelche hat, die Watt ist nicht verfügbar. Und dann das Gleichgewicht zurückgeben, richtig? All dies ist wirklich, weil wir bestimmte Navigationseigenschaften innerhalb der Räume
festgelegt haben könnten , sind innerhalb unserer Klassen, um dies einfacher zu erfüllen. Zimmerbuchungen haben also bereits eine Verpflichtung. Eigenschaft vier Zimmer. So haben wir diesen Fremdschlüssel bekommen,
das ist, was wir die Folgerung verwenden, dass es eine Fremdschlüsselbeziehung zwischen dem Raum und dem Raum gibt. Und das ist in Ordnung. Wenn wir uns jetzt ansehen, ist es auf der Ebene der Art der Beziehung. Es ist wirklich ein Eins-zu-viele,
was bedeutet, dass gewonnenes Zimmer wird viele Buchungen haben. Also ja, wir haben die Fremdschlüsselbeziehung dort. Aber dann im Zimmer habe ich die Möglichkeit, und ich
gehe einfach durch das, falls Sie mit Entity Framework Core nicht so vertraut sind, haben
wir die Möglichkeit, dem Raum tatsächlich zu sagen, dass es erwarten kann, eine Sammlung zu haben. Und ich werde nur Listen von Zimmerbuchungen verwenden. So kann jedes Zimmer mehrere Buchungen haben. In Ordnung. Und wann man es Buchungen nennt, um darzustellen, dass es sich um eine Sammlung handelt. Also noch einmal, Entity Framework, wir schließen nur, dass ein Zimmer, viele Buchungen und eine Buchung zu einer Regel. In Ordnung. Das ist alles, was wir jetzt haben. Das ist in Ordnung. Innerhalb der Abfrage kann
ich die Subnetze neu anordnen. Denn in meinem Kopf könnte
ich sagen, zurückkehren oder lassen Sie mich einfach sagen, die verfügbaren Zimmer zu bekommen. Ich kann sagen, var verfügbare Zimmer ist gleich dem Kontext Punkt Räume sind. Lassen Sie mich diese Zeile duplizieren. Alles klar, und machen Sie es irgendwie von Grund auf neu, damit wir sehen können, dass alles passiert. Ich zeige Ihnen nur alle Möglichkeiten. Es ist also nicht unbedingt so, dass man besser arbeitet als das andere. Ich meine, wenn Sie neue Kosten für
den Besuch in die Datenbank mehr als einmal so besser als in Ordnung nennen . Am Ende des Tages besteht der Test. Es ist nur so, dass der Code auf eine andere Weise geschrieben werden könnte, um eine Datenbank
namens so var verfügbare Räume in dieser neuen Anweisung zu machen . Var verfügbare Zimmer, ja, ist gleich Kontexten Punkt Zimmer wir sind, und dann würde mein Lambda-Ausdruck hier Q Punkt durch Buchungen haben. Alles klar, jetzt habe ich die Navigationseigenschaft für die Zimmerbuchung. Also würde Entity Framework automatisch sagen, ich schaue nach einem beliebigen Raum, bekommt alle Buchungen, die dort sind, dass ich auf dieser Sammlung und Amplitude auf anderen Lambda-Ausdrücken sehen
kann , kann
ich sehen, wo es irgendwelche Buchungen, die das heutige Datum oder das angeforderte Datum haben,
also war gleich dem Bit. In Ordnung, das ist also eine komplette Neuschreibung und diese Zeile allein oder Orte, diese beiden Zeilen. Also könnte ich das wirklich entfernen und dann einfach verfügbare Zimmer zurückgeben. Und wenn Sie dann, wenn Sie es in noch weniger Zeilen schreiben möchten, könnten
Sie einfach von Anfang an zurückkehren. Keine Notwendigkeit für diese Variable. Okay, und ich werde den Test noch mal machen, weil ich gerade ein riesiges Dach gemacht habe OK, stirb. Drei Codezeilen in einer Codezeile zusammengefasst. Und dann werde ich zulassen, dass meine Komponententests mir sagen, ob mein Refactor sinnvoll ist und okay ist. In Ordnung. Da ich ein paar Feedback bekomme, behaupten Sie, dass es ein erwartet, Es ist nur eine zu sehen. ich auf das zurückblickte, ist
dies das Problem, das ich hätte sagen sollen, entspricht falsch,
was bedeutet, dass ich nach verfügbaren Zimmern suche, richtig? Also besorgen Sie mir die Zimmer, in denen sie irgendein Wort haben. Es gibt Buchungen mit dem Datum. Und dann sehe ich Stürze gibt es keine Buchungen mit der Tat, also ist es besser lesbar für Sie. Also besorgen Sie mir Zimmer, in denen es keine Buchungen mit den Taten gibt, die angefordert werden. Also lasst uns das Gewebe erneut starten. Also noch einmal, Sie sehen, wie schnell ich Feedback von unserem Refactor bekam, übereifrig wurde. Anna sagte: Oh, ich kann das in einer Zeile tun. Hat es in einer Zeile, den Test fehlgeschlagen? Nein. Ich habe meine einzige Codezeile überprüft und ich bekomme einen grünen Test. einmal ist dies ein Prozess der testgesteuerten Entwicklung. Du schreibst deinen Test, schreibst deinen Code, du refactorierst, erneutes Testen und ECL schnell. Wir machen all diese Art von Scrollen durch sie. Der Grund ist so lange, weil ich versuche, es zu erklären, während ich mitmache. Und wahrscheinlich verlängern meine Monologen die Zeitspanne, die damit verbracht wurde. Aber ich möchte nur sicherstellen, dass Sie
den Wert schätzen , wie diese Tests
uns Echtzeit-Feedback bezüglich der Leistung oder der Genauigkeit geben , anstatt unseres Codes.
20. Testen und Durchführen: Speichern von a: Na gut, Leute, willkommen zurück. Also gehen wir auf und was wir tun werden, ist unsere Integrationstests zu machen, um sicherzustellen, dass die Daten tatsächlich in der Datenbank gespeichert
werden, oder? So ähnlich wie das, was wir getan haben, oder Kontexte für die sollten verfügbare Zimmer zurückkehren. Weil der Kontext innerhalb der Lebensdauer des Vorgangs leben muss. Wir werden kein globales Arrangement machen, wie wir es für den vorherigen Test getan hätten, sorry, für das vorherige Testprojekt, wo wir sowieso die eine arange hinzufügen, setzen Sie eine Instanz für alles. In diesem Fall ist
der Kontext irgendwie flüchtig und muss im Kontext des Tests existieren. Also machen wir das arrangierte entsprechend, richtig? Eine Sache, die wir unsere Wiederholung sicher halten können, wäre RDB-Optionen. Obwohl. Wieder einmal möchten Sie es irgendwie einzigartig halten. Also machen Sie es einzigartig, indem Sie ihm einen anderen Namen geben, oder? Also gehe ich nach Nehemia und sollte Tests retten. Und nachdem ich auf den DB-Optionen sitzt, werde
ich eine Musterraumbuchung erstellen erforderlich. Also werde ich nur sagen, ich reserviere Zimmer mit dem Ausweis eins an diesem Datum. Und natürlich gibt es noch andere Felder. Eine gute füllen Sie die E-Mail und den vollständigen Namen. Nun, Sie würden die ID nicht eingeben, weil wir im Begriff sind zu sehen, ob es nicht die ID geben würde, aber Sie können in all diese Felder einfügen, aber andere halten es einfach und geben die Raum-ID und das Datum nur für unsere Behauptungen ein. Okay, jetzt, da wir das haben, können
wir zu unserem anderen übergehen. So ähnlich wie wir hier oben mit unseren DVI-Kontexten gemacht haben. Ich leihe mir nur diese Linie und dann werde
ich meinen Zimmerbuchungsservice initialisieren. In Ordnung. Und dann, nachdem ich es initialisiert
habe, kann ich sagen, Zimmerbuchungsservice dachte speichern. Und ich gehe bei unserer Zimmerbuchung vorbei, dass wir richtig sparen. Jetzt, nachdem wir vorgegeben haben, ROTC des noch im Speicher zu speichern, gibt es eine Reihe von Dingen, die wir mit der Behauptung beginnen können. Eins. Wir können behaupten, dass nur ein Datensatz in die Datenbank ging weil die Erwartung ist, dass selbst wenn wir unsere Anwendung tun, wenn wir speichern aufrufen, nur ein Datensatz den Goin lesen sollte. Wie zu der Zeit, die ich in einer Buchung. Es sollte nie aufzeichnen müssen. So könnten wir tatsächlich nur die Buchungen abrufen, indem wir
var Buchungen gleich oder Kontexte sehen , Punkte, Buchungen oder Zimmerbuchungen. Punkt-Sortierlisten. Also fragen wir nach MC, alle Buchungen, die derzeit in der Datenbank sind. Dann können wir Var King sagen, diese, die eine Buchung, die da drin sein soll. Und ich kann Single behaupten. In Ordnung. Also behaupte ich, dass nur eine Platte zurückkommen sollte. Wenn Sie also den Mauszeiger über eine einzelne bewegen, werden
Sie sehen, dass eine bestimmte Sammlung
nur ein einzelnes Element des angegebenen Typs enthält . Also sehe ich eine Single von den Buchungen kommen. Alles klar, also behaupten Sie Singlet, aber es gibt auch diesen Typ zurück. Es sagt also eins. Es muss sicherstellen, dass nur eine da drin ist und ich werde den einen zurückgeben. Wenn es hier fehlschlägt, dann wissen Sie, dass es mehr als einmal gespeichert hat und Sie wahrscheinlich einen Fehler in
Ihrem Code haben , wo es wahrscheinlich mehr als einmal zum Zeitpunkt des CVE begeht. Also, nachdem wir das Buchungswochenende oder Behauptungen bekommen, richtig, So behaupten Sie Punkt gleich und wir können beginnen, den gespeicherten Datensatz zu vergleichen, die in diesem Fall mit dem ursprünglichen Datensatz buchen, den wir über geschickt hätten. So kann ich sehen behaupten gleiche Zimmer booking.com und Buchung, was ist, was wir gerade von dieser Sammlung Punkt Punkt Punkt abgerufen. Behaupten Sie, dass diese beiden gleich sind. Stellen Sie auch fest, dass die Raum-ID gleich ist. In Ordnung? Und wie gesagt, Sie hätten Datenfelder für die E-Mail und den vollständigen Namen eingeben können, und dann machen Sie einfach Ihre Behauptungen entsprechend. Nun, es ist ziemlich genau das, was unser Test im Herzen des Tresors macht. Und dann basierend auf den verschiedenen Geschäftsregeln, die Sie haben könnten. An diesem Punkt sollte der Dienst jedoch nicht notwendigerweise irgendwelche Geschäftsregeln haben, die vom Kern abgenommen werden sollten,
was bedeutet, dass er nicht zum Meer kommen sollte, dass nur Zyklus
alle Validierungen einsetzt , um sicherzustellen dass wir das Feuer bekommen müssen, es sei denn, es erfüllt bestimmte Bedingungen. Also sollten alle diese Validierungen wirklich in
die Kernebene oder die Business-Logik-Ebene gehen . Aber genau auf dieser Ebene testen wir nur, was das B2B tun sollte. Angenommen, Sie testen an diesem Punkt wirklich nur auf dem Szenario der Tatsache, dass Sie Motorabfrage tragen. Sobald Sie diese Abfrage ausgeführt
haben, erhalten Sie Ergebnisse wie das, was Sie erwarten würden. Ist es nicht. Tut die Abfrage dies unter diesem Umstand nicht? Das sollte auf der Ebene der Geschäftslogik geschehen. Lassen Sie uns also unsere Tests durchführen, denen wir wissen, dass grün sein wird, sorry, wird es loswerden, vor mir selbst dort. Also baut es ein Projekt und dann wird Test Explorer uns Lesetests zeigen. Da gehen wir, weil es noch nicht implementiert ist und das ist in Ordnung. Also kann ich einfach klicken, zu den Tests springen. Und all diese Methoden müssen wirklich tun, ist die Zimmerbuchung dem Kontext hinzuzufügen und dann CVE, richtig? Also ging ich, um dies durch Kontexte oder Unterstriche Kontexte zu ersetzen, dot add. Und dann kann ich einfach sagen, dass es Zimmerreservierung hatte. Und dann unterstreichen Sie Kontextänderungen. Und jeder sollte offensichtlich wissen, ob ich den Test noch einmal durchführe und ich einfach rennen werde. In Ordnung, also sehen Sie hier, es hat fünf Tests, die diese Methode umsetzen. All diese Vergangenheit, am wenigsten in der Vergangenheit, waren
sie gute Tests und dieses eine Feld. Also werde ich nur alle Tests ausführen, die mit dieser Siebmethode verbunden sind. Und schauen wir uns die alte Com an. Okay, du wirst sehen, dass es irgendwie übersprungen hat, was es nicht erneut ausführen musste Wählen Sie dieses mit dem Weiß und Grün aus. dieses Mal nicht ausgeführt, weil es nicht die Tests waren, die mit dem CVE verbunden sind. Jedoch, alle fünf Tests Arnold Politik einschließlich der, die wir gerade geschrieben. Also, das ist es wirklich, um zu testen, ob Entity Framework den Datensatz sehen wird. Alles klar, denk daran, dass wir das tun. Wir machen ein Integrationstestloch. Unterbricht unsere Anwendung mit dem RM oder der Bibliothek, die für das Gespräch mit der Datenbank zuständig ist. Also, das ist, was wir Einheit
wieder in verschiedene Arbeit getestet haben , macht es so einfach für uns,
einfach eine Datenbank für Künstler Szenario zu drehen und dann löschen Sie es danach. Diese Datenbanken werden also nur existieren, wenn dieser Test ausgeführt wird. Also, das ist es wirklich für unsere Integrationstests. Wenn wir zurückkommen, werden wir einfach alles auf ein höheres Niveau überprüfen und dann weitergehen.
21. Abschnitts-: Alles klar, Leute, das ist es wirklich für diesen Abschnitt. Wir haben ein weiteres Testprojekt hinzugefügt. Wir sehen also in unserer Lösung, dass wir
ziemlich viele Projekte haben und einige von ihnen müssen getestet werden. Manche müssen nicht unbedingt getestet werden. Wir hatten diese Domain nicht, weil sie wirklich nur alle
unsere Klassendateien speichert , die später in die Entitäten für die Datenbank umgewandelt werden. Wir hatten eine Persistenz hinzugefügt, die das Repository schlauch oder unseren Data Service Service Service, ich nenne es Repository-Ordner, aber ich rufe die Dateidienste auf. Damit wir es so nennen können. Sie könnten es ausführen, wenn Sie eine Tastenbenennungskonvention haben, das ist in Ordnung. Aber das Konzept ist, dass die Umsetzung der Augen Zimmerbuchungsservice. Also i Zimmerbuchungsservice wird alle Daten verwandten Methoden Stubs am wenigsten haben. Und dann werden sie vom Zimmerbuchungsservice implementiert, der definitiv den konkreten Code haben wird. Zumindest, als wir Unittest im Kern waren, waren
wir wirklich nur Unit-Tests gegen die Augen Zimmerbuchungsservice. Unsere Behauptungen, bei denen ich denke, der Fuchs, dass die Methode mindestens einmal oder nie einen Anruf erhalten hätte , basierend auf dem Umstand. Also zum Beispiel, in den Speicherraumbuchungsanfragen, wer würde hier sehen, dass wir überprüft haben
, dass die Speichermethode mindestens einmal aufgerufen wurde, richtig? Wenn also mit den aktuellen Daten bereitgestellt wird, basierend auf der Geschäftslogik, die wir in den Prozessor gelegt hätten
, sollte diese Service-Methode mindestens einmal aufgerufen werden. Jetzt, wieder, der Kern ist, wo wir die Geschäftslogik implementiert und getestet haben, die Regeln hinter, wenn es bestimmte Methoden aufruft welchen Umstand es sich in einer bestimmten Woche verhält, das ist in Ordnung. Der Integrationstest Tunnel befindet sich jedoch unter der Geschäftslogik, in der wir integrieren oder wo wir
die Systeme testen , die wir in diese Situation integrieren. Wir integrieren uns mit unserer Datenbank über eine Bibliothek namens Entity Framework Core. Also testen wir, um sicherzustellen, dass, wenn wir die Methoden aufrufen, die
tatsächlich die voneinander abhängige Arbeit ausführen oder arbeiten , die in verschiedenen Work-Core arbeiten, die Art und Weise verhalten, wie wir möchten, dass es sich verhalten. Alles klar, das ist also, was ein Integrationstest ist. Und auf dieser Ebene würden Sie hier anfangen zu testen, wie Sie mit einem QR Kaninchen interagieren, MQ, richtig? Oder Service-Boss. Sie würden bewerten, um mit einem E-Mail-Dienst zu interagieren,
alles, was ein Dritter ist. Jetzt sind Sie nicht der richtige in den Ost-Anweisungen auf dem Code direkt, denn Sie schreiben nur Code, um damit zu interagieren, dann beginnen Sie, Ihre
Integrationstests zu machen , um zu testen, wie ich damit interagieren kann. Habe ich nach der Interaktion ein Ergebnis erhalten, das ich erwartet habe? Also, wenn all das erledigt ist, lassen Sie uns zu unserem Git und einem Check in gehen. Natürlich werden wir eine Nachricht schreiben, die auf die geleistete Arbeit hinweist. Und dann werde ich einfach weitermachen und alles begehen und sinken. Sobald das erledigt ist, können
wir hier pausieren und dann zum nächsten Abschnitt weitergehen.
22. Understanding NET: Na gut, Leute, willkommen zurück. In dieser Lektion werden wir unser Webprojekt einrichten und verstehen, warum es wichtig ist, die eigentlichen Webprojekte zu testen. Jetzt für diesen Teil wollte
ich eine Web-API ohne besonderen Grund verwenden, wird
die Tatsache regeln , dass es irgendwie einfacher zu sehen ist, wie wir Komponententest. Wir haben nicht den Overhead einer Benutzeroberfläche oder so etwas. Mit API können wir Unit-Test die Endpunkte ganz einfach verwenden. Aber das heißt, die Konzepte des Komponententests, eine dotnet Core-API wären für Razor Seiten nach oben oder eine MVC-App sehr ähnlich. Die einzigen wirklichen Unterschiede wären die Rückgabetypen, da dotnet Core so
vielseitig ist , dass die Feinheiten zwischen den verschiedenen Modellen sehr, sehr winzig sind. In Ordnung, also das ist, die Konsistenz ist sehr gut. Lassen Sie uns also voran gehen und erstellen Sie unsere API-Projekte. Ich werde nur ein neues Projekt hinzufügen. Und wir werden Core-Web-APIs wählen. Wenn Sie es nicht auf der linken Seite haben, können
Sie immer nach Core Web API suchen, sind nur diese API. Aber sobald Sie die Vorlage gefunden haben, werden
wir diese benennen, ist der Raum, der diese API aufbaut. Wenn Sie Ariza Seiten verwenden möchten, sind nicht MVC App, würden Sie es wi nennen, etwas anderes, aber sind nicht NVC R-dot Seiten, was auch immer es ist, Sie wollen es nennen. Aber wie gesagt, werde ich die API für den geringeren Overhead im Allgemeinen demonstrieren. So können wir weitermachen und auf Weiter klicken. Und wir können alles so lassen, wie es ist. Und schafft er in ähnlicher Weise wie das, was wir mit den anderen Testprojekten gemacht hatten. Wir werden nur weitermachen und ein neues Projekt hinzufügen,
das ein x-Unit-Testprojekt sein wird. Es wird ein Zimmer sein, das viel reserviert, api dot tests. Und dann können wir das verwenden und auch erstellen. An diesem Punkt werde ich nur voran gehen und Bridgette Abhängigkeiten. Also zuerst für den Test ging, nun, lassen Sie mich mit der API beginnen. Für die API wird es definitiv eine Bridget-Abhängigkeit von
der Persistenzschicht und der Kernschicht haben . So können Sie voran gehen und diese hinzufügen. Jetzt sind wir nicht bereit, viel weiter als das vorerst zu gehen. Stattdessen werden wir uns nur die Konzepte
ansehen warum wir Komponententests auf dieser Ebene durchführen würden. Unit-Tests geht es also darum, automatische Bits zu finden und Teile Ihrer Anwendung werden unter den bestimmten Umständen funktionieren. Je mehr Abdeckung Sie haben, desto besser in dieser Situation, wir haben bereits Abdeckung für unseren Up-Kern. Also jeder andere Prozessor oder jede andere Business-Logik-Klasse oder Operationen, die wir hinzufügen, können
wir Komponententest auf dieser Ebene. Die Persistenztests sind zu unserem Test, halten Sie die Datenbankoperationen bei uns
und stellen Sie sicher, dass sie tun, was sie wissen sollen, wenn Sie einen hinzufügen, er wird nur einer hinzugefügt, et cetera. Jetzt auf Anwendungsebene geht
es mehr darum zu sehen, wie die Anwendung auf die bestimmten Umstände reagieren wird. also eine gültige Eingabe erhalten, erwarten
Sie bei jeder Webanwendung Wenn Siealso eine gültige Eingabe erhalten, erwarten
Sie bei jeder Webanwendung, dass AS oder eine Aktion ausgeführt wird, wenn Sie eine
ungültige Eingabe erhalten , die bestimmte Aktionen erwartet, werden, können
bestimmte Dinge von der Code-Seite, nicht notwendigerweise die Benutzeroberfläche oder die Präsentationen aus dem Code dahinter oder die kleine Logik, die im Hintergrund ausgeführt wird. So etwas wie Codierung gegen ungültige Logik, ungültige Eingabe, sorry, also gibt der Benutzer die falschen Werte ein. Sie haben eine Validierung, die sehen sollte, ob sie ungültig ist, dann an pj zurückgegeben werden, werden im Falle einer API eine Form des Ergebnisses zurückgegeben. Und wenn es gültig ist, dann Gier direkt auf eine andere Seite oder geben eine bestimmte Art von Ergebnissen zurück. Das sind also die Dinge, die Sie
für diese gesamte Anwendungsebene testen möchten . Wenn wir also das Beispielprojekt für die API betrachten, sehen
wir, dass wir Wettervorhersagen Controller bekommen haben, der
einen Endpunkt hat , der einige Ergebnisse vom Typ Wettervorhersage zurückgibt. Wissen Sie, dass ich Ihnen zeigen werde, wie genau ein Komponententest
für diesen API-Endpunkt oder für den Controller im Allgemeinen aussehen würde . also den Komponententest eine Klasse verwenden, die
wir normalerweise löschen, werden wir nur diese Art von Tests schreiben. Erstens benötigen wir unsere Projektabhängigkeit, die für das API-Projekt zu den API-Testprojekten hinzugefügt wird. Also gehen Sie weiter und tun Sie das. Und während wir dort sind, gehen Sie
einfach voran und springen Sie in NuGet und wir müssen das Mock-Tool hinzufügen, die Sperrenbibliothek muss auch sicher hinzufügen. So sehen Sie in hallo klug funktioniert, Sie sehen im Ganzen die Behauptung negative zwei x Einheit Projekte arbeiten. Sie können Ihre eigenen Schlussfolgerungen ziehen, auf welche Sie bevorzugen. Das ist kein Problem. Aber ich werde sicherlich für diese Reihe von Tests verwenden. Also installieren, verspotten und installieren, und dann springen Sie zu unseren Komponententests eine Standarddatei, die ich mit unserem Projekt kam, ich habe sie nicht gelöscht. Wir können dies nur als Beispiel verwenden, um zu sehen, wie diese Wettervorhersagen Controller Einheit getestet werden würde. Also in unserem Unit-Test auf Datei, Lasst uns einfach einen Tester schreiben, der ein sollte. Rückgabe der Prognoseergebnisse In Ordnung? Nein, In meinen using-Anweisungen, die ich benutze, sollte nicht x unit verwenden und System.in verwenden. Zugegeben, wenn wir tippen, werden Sie sie sehen. Sie haben die Chance, das zu unterbringen, was fehlt. Also müssen Sie das jetzt nicht unbedingt replizieren. Aber während wir weitergehen, sehen Sie, was passieren muss. Also zuerst müssen wir den Logger verspotten,
der im Wetterprognose Controller vorhanden ist , weil wir diesen Logger injiziert haben. Um also auf den Logger zuzugreifen, benötigen
wir ein Objekt davon. Und wenn wir all das wissen, verspotten
wir diese Dinge, während wir weitermachen. Ordnung, also werde ich sagen müssen, var logger Mach ist gleich einem neuen Mock von Lager relativ zu Wettervorhersagen Controller. Natürlich, alle fehlenden Typen, die Sie
die Verwendung mock-Anweisung von oben benötigen , sobald Sie das eingeben. Und dann wird ich Logger wahrscheinlich brauchen, um Anweisung zu verwenden. Und dann natürlich, Wetterprognose Controller benötigen, dass mit Anweisung auch. Also gehen Sie einfach voran und Kontrollpunkte und schließen Sie alle fehlenden Referenzen ein. Nächsten Stopp müssen wir initialisieren oder Controller. Also werde ich nur sagen, var Controller ist gleich einer neuen Instanz des Wetterprognose-Controllers
, der Logger Mock-Objekt als seinen Parameter nimmt, ähnlich wie Sie hier sehen würden. Wir instanziieren eine neue Instanz des Wetterprognose Controllers und geben ihm dieses Logger-Objekt. Jetzt, wo wir das alles getan haben, müssen
wir den Anruf treffen. Es hat nur eine Methode, die wir unsere Gerechtigkeit testen, dass wir über ein Ergebnis bekommen. Also müssen wir wirklich nur den Get anrufen. Also, um den Getter aufzurufen, werde
ich sagen, var Ergebnis ist gleich Controller dot gets. Dann können wir unsere Behauptungen auf die bekommt so oder auf die Ergebnisse eher tun. So kann ich behaupten, dass das Ergebnis sein kann, sollte größer als eins sein. Sie könnten wahrscheinlich auch behaupten, dass die Ergebnisse nicht null sein sollten. Zugegeben, diese beiden gehen Hand in Hand. Wenn es nicht null ist, wenn die Zählung größer als eins ist, dann ist es offensichtlich nicht null. Aber es ist möglich, dass dies nicht null ist, aber die Zapfen sind nicht auf einem verwurzelt, oder? Also, wissen Sie, Sie setzen alle Behauptungen ein, wir sehen, dass wir in all die Behauptungen setzen, die wir
sicherstellen wollen , dass unsere Methode tut, was wir von ihr erwarten. Also teste ich nach der Tatsache in dieser Situation. Dies ist also, wo diese Teilung Art von
Komponententests kommt , weil manchmal Komponententests
ist, wird nach der Tatsache eingeführt. Und dann ist es irgendwie unklar, was genau
ich in Bezug auf Code behaupten sollte , der bereits geschrieben ist, richtig? Versus wenn Sie den Test zuerst schreiben, und dann schreiben Sie das Zitat zu viel den Test, dann wissen Sie genau wie für das, was passieren muss. So oder so, lassen Sie uns versuchen, diesen Test durchzuführen und sehen, ob wir gute Ergebnisse erzielen. Und nachdem ich diesen Test durchgeführt
habe, sehe ich, dass wir Übereinstimmungstests haben. Also haben wir natürlich einen grünen Test, weil es bereits Tests
gibt, ist der Code schon eher vorhanden. Also, wenn ich etwas wie null zurückgeben, sagen
wir entweder Refactor wissen, und für, wissen Sie, ich habe versehentlich diese Rückgabe null irgendwo
in dieser Methode eingeführt , die vollständig verzerren wird, was es sollte zurück, dann sollte unser Test wissen, dass fehlschlägt. Und da gehen wir. Jetzt sehen wir, dass sie eine weitere Ausnahme bekamen. Und diese Ausnahme hat mehr mit unserer Behauptung zu tun, dass es mit dem Code selbst, Fred, diese Wissensausnahme bekommt, weil ich null zurückgibt. Und das ist null. Sie können also die Kegel nicht von null finden. Sie können die Nummer des Nichts finden, oder? Lassen Sie mich also diese Behauptung neu anordnen und es erneut versuchen, wir sollten eine andere Art von Ära sehen, zumindest nicht unbekannter Ausnahmefehler. Und da gehen wir. Also nirgends eine Nachricht zu bekommen, die besagt, dass das Ergebnis nicht null sein sollte, gekauft war in Ordnung. Das ist also unsere Behauptung. Wissen Sie, dass ich sehe, dass es nicht null sein sollte. Also hört es auf, bevor es überhaupt zu diesem kommt, um das
Gefühl zu haben, dass es uns wissen lässt, dass die Behauptung Felder. Also, das ist ein grundlegendes Beispiel dafür, wie wir Einheit Testcontroller oder durch r, durch Erweiterung, das Web-Projekt im ASP.Net Core. Also, wenn wir zurückkommen, werden
wir unsere eigenen Controller und Unit-Tests oder
eigenen Controller mit den sinnvolleren oder kontextuell geeigneten Unit-Tests implementieren .
23. Sqlite in Memory Datenspeicher: Hey, Leute, willkommen zurück. Bevor wir mit unserem Testen unserer Web-App weiter gehen, möchte
ich, dass wir den Datenspeicher einrichten und ich werde ihm geben, dass dies nur eine schnelle Musterverpflichtung ist und ich werde nicht so
weit gehen , wie ich eine ganze SQL Server-Datenbank für nur eine oder zwei Tische, wir werden sein Kind behalten. Wir werden eine In-Memory-SQL-Lite-Verbindung verwenden. Ordnung, also in der Startup-Punkt-CSS-Datei, springen
wir da rüber. Und unter der Swagger-Implementierung können
wir damit beginnen, var Verbindungszeichenfolge zu sagen, ich werde nur meinen Khan anrufen. String ist gleich der Datenquelle gleich Doppelpunkt, Memory Doppelpunkt. In Ordnung, jetzt, wenn Sie mehr Informationen dazu wollen, können
Sie immer sehen, wie Sie sich mit SQL Light
In-Memory-Datenbanken in einer dotnet Core-Anwendungverbinden In-Memory-Datenbanken in einer dotnet Core-Anwendung , es
gibt Dokumentation darüber, aber ich werde nicht zu viele Details, stimmt's? NULL. Stattdessen werde ich einfach mit einer Verbindungszeichenfolge fortfahren. Also werde ich sagen, var con, con. Unsere Verbindung ist gleich dem neuen SQL I t0. So OCC SQL ITE-Verbindung. Und dann übergeben wir diese Verbindungszeichenfolge. Also wissen wir inzwischen, wann immer wir diese roten Unterstriche sehen, wir kontrollieren das. Und dann sehen Sie hier, ich brauche ein Paket für Microsoft dot SQL I dot core. Also werde ich voran gehen und die neueste Version finden und installieren. Und wenn das erledigt ist, können
wir fortfahren, indem wir die konischen Sean-Punkte offen sehen. So öffnen wir zu diesem Zeitpunkt die Verbindung zur In-Memory-SQL-Datenbank. Dann müssen wir die Dienste und alles, was wir brauchen, um einen DVI-Kontexte hinzuzufügen lassen. Und unser DB-Kontext wird das sein, was das Setup in der Persistenzschicht ist, was unser Raumbuchung DB-Kontext ist, richtig? Also ist es relativ zu diesen Kontrollpunkten oder ich brauche keinen Kontrollpunkt, weil wir darauf haben. Ich würde Anweisungen beim Einfügen verwenden. Wenn ich es kopiert und eingefügt habe, sehen
Sie, dass es automatisch die using-Anweisung für die Persistenz hinzugefügt hat. Also ermutige ich Sie, diese Funktion sehr viel zu verwenden. Dann kann ich ihm ein paar Optionen geben. Wo ich Ihre Option sehen werde, ist SQL zu verwenden. Es, von dem ich vermute, dass es eine Form der Bibliothek brauchen wird. Aber bis dahin werde ich das Verbindungsobjekt Kontrollpunkte übergeben. Und das hilft mir nicht. Aber ich schmeiße NuGet einfach nicht mit dem hier. Also werde ich zu New get für das Web-Projekt gehen. Und ich glaube, ich werde Entity Framework Core mit SQL IT benötigen. Ordnung, Also in SQL-Idee und bekam eine Reihe von anderen Ergebnissen, ist
es tatsächlich einfach, Entity Framework Core einzugeben, und dann werden Sie zwei verschiedene Work Core Dot SQL
ITE sehen , kann voran gehen und dieses Paket herunterladen und installieren. Und dann gehen Sie zurück zu unserer Startdatei, wenn ich Control Lot mache, werden
Sie sehen, dass die Optionen für die Verwendung von Anweisungen kommen und dann sind wir im Klaren. So wird RDB-Kontexte für unsere Webanwendung aussehen. Natürlich hätten
Sie in einer echten Umgebung eine echte Datenbankverbindung, die
wahrscheinlich in der App settings.js auf leben wird . Und dann würdest du das reinspritzen. Wenn Sie wissen wollen, wie das passiert, können
Sie einen meiner anderen dotnet Core-Kurse, in denen wir tatsächlich echte Datenbanken verwenden, durchlaufen. Aber nur für dieses Szenario, in dem wir nur TDD in diesem Kontext betrachten. Ich werde das nicht einstellen, ich werde mich nur mit der In-Memory-Implementierung begnügen. Also wisst, dass das geschehen ist. Wenn wir zurückkommen, können wir damit beginnen,
unseren Controller einzurichten und sich tatsächlich für einige Komponententests versteckt zu werden.
24. Unit erstellen: Alles klar, Jungs, also lasst uns direkt ins Schreiben aller
Komponententests für den API-Controller springen . Also haben wir nur ein Steuerelement, wie Sie sehen können, wir machen nur einen Proof of Concept mit einem sehr kleinen up, aber wir betrachten Komponententests und die verschiedenen Ebenen. Diese API wird also ziemlich einfach sein. Es wird nur unter
der API haben , dass wir verknüpft werden müssen, wenn sie sich in die Mitte bewegen. Und dann werden wir dem Benutzer erlauben, einen Raum zu buchen,
möchten ein altes
Schlüsselergebnis mit Ergebnisobjekt als alles zurückgeben , wenn Sie zu einem Ergebnisobjekt gelangen. Und wir möchten Validierung hinzufügen und schlechte Anfragen ablehnen. In unserem Code gibt es nur wenige Dinge, die wir tun müssen. Erstens, erstellen Sie diesen neuen Controller für die Zimmerbuchung. Also nannte ich es Raumbuchungskontrolle. Wenn Sie mit APIs nicht so vertraut sind, können
Sie meine API-Kurse immer ablegen. Aber wenn Sie wissen müssen, wie Sie diesen Controller direkt hier und nein hinzufügen, klicken
Sie mit der rechten Maustaste auf den Controller-Ordner Gesäßregler, und drücken Sie dann API und erstellen Sie diesen leeren Controller mit dem gleichen Namen. Das wird Ihnen diese grundlegenden Vorlagen geben. Im selben Atemzug. Sie können auch voran gehen und neue treffen, erstellen Sie eine neue Zimmerbuchung Controller-Testdatei in unserer API zu verbreiten oder nicht, wenn Sie zeigen, dass nur noch, weil ich einige Koordinate. Nun, wir werden das zusammen durchgehen, damit sie diese Datei erstellen können. In der Zwischenzeit werde ich jedoch zu unseren Kernprojekten gehen und unseren Datendienst aufzeigen,
oder leider nicht den Datendienst oder den Auftragsverarbeiter. Da gehen wir. Also genau die gleiche Weise, wie wir unseren Augenzimmer Buchungsservice hatten und dann, dass Augenzimmer Buchungsdienste wirklich nur Nikon behindert, oben
auf unserer Datenzugriffsebene. Und dann haben wir die Implementierung hier. Wir brauchen unseren Prozessor, um injizierbar zu sein. Also im Moment ist es nur der konkrete, eine Klasse, die Sie einmal an
einem Ort erstellen und sich entlang bewegen, was Sie sehen, es ist den ganzen Weg hier drüben im Kern und wir brauchen, es ist der ganze Weg hier oben in der API. Also, was ich tun werde, ist auf die Klasse Dampfpresse Control Punkt klicken. Und dann sehen Sie, dass Sie eine Reihe von Optionen haben. Einmaliges, das Extract Interface enthält. Wenn Sie also die Schnittstelle vorher erstellen, muss
die ererbende Klasse diese Schnittstelle implementieren. In diesem Fall haben wir die Klasse bereits erstellt, also nein, wir brauchen die Schnittstelle. Ich werde nur Extract Interface drücken. Ja, ich wollte neue Datei wissen und Sie sehen, dass es
dieser Datei automatisch geben wird , dass ich die Namenskonvention ansporne. Und es wird, Sie können auswählen und deaktivieren, welche Methode Sie wollen, klicken Sie auf OK. Und dann haben wir jetzt unsere, unsere Schnittstelle, die die Buchungsanfragen Prozessor implementiert. Nun muss dies von der APA zugegriffen werden. Um es zugänglich und injizierbar zu
machen, müssen wir zu unserem Startup kommen. Und ich werde nur Zeile, ich kann dies unter dem DB-Kontext tun. Ich werde sagen, Dienste Punkt, und wir können Scoped hinzufügen. Ich nochmals, wenn Sie nicht mit Abhängigkeitsinjektion vertraut sind, kichere einen meiner dotnet-Kernkurse, was ich hinzufüge, und ich werde
den Augenraum Buchungsanfragen Prozessor neben
seiner Implementierung hinzufügen den Augenraum Buchungsanfragen Prozessor neben , so dass es von jedem der Controller in unserer API
injiziert und verwendet werden kann. Das ist also alles, was es braucht, oder? Also lassen Sie uns zu der Testdatei springen. Also, wie ich schon sagte, ich habe etwas Code geschrieben, aber ich werde dich zeilenweise durch. Fühlen Sie sich frei zu pausieren, zu replizieren. Aber ich werde dir alles erklären. Ich denke, sie sind nur ein bisschen die Dinge, die wir tun müssen, damit du mir beim Tippen zusiehst. Also habe ich es gerade vorbereitet und dann führe ich dich durch, egal. Also habe ich alle Vermögenswerte oder zumindest einige der Vermögenswerte, wie ich weiß, es ist irgendwie an der Spitze vorbereitet. Also habe ich meinen Konstruktor, wo ich einen Zimmerbuchungsservice initialisiere, um eine neue Instanz des Buchungsprozessors zu sein. Ich habe eine Instanz meines Controllers. Und denken Sie daran, dass Sie tatsächlich einfach über dieses Land tippen und dann
Kontrollpunkt verwenden können, um rückwirkend diese Methode zu generieren, die wir getan hatten, sorry, dieses Feld. Wir haben es ein paar Mal davor getan. Also für den Controller, sehen
Sie hier, dass ich meinen Zimmerbuchungscontroller initialisiere und es hat eine rote Linie weil ich ihm auch den Zimmerbuchungsservice gebe. Gedankenobjekt. Und das lässt mich wahrscheinlich diesen Zimmerbuchungsprozessor anstelle von Service anrufen, oder? Nur um explizit und klar mit den Namen, Zimmerbuchung Prozessor und Refactor auf dem Weg zu sein. In Ordnung. So
wird das Zimmerbuchungsprozessor-Mock-Objekt an den Raum aussehenden Controller übergeben. Also von hier aus kann ich Kontrollpunkte machen und diesen Konstruktor Jumbo dort erzeugen lassen. Und dann werde ich nur
diese Zimmerbuchungsanfrage Prozess oder Zimmerbuchung Prozessor umbenennen . Mit dem Unterstrich und einer ohne. Also wissen, unser Controller hat die Instanz
der Zimmerbuchungsanfragen Prozessor injiziert und bereit für Sie. Das ist in Ordnung. Ansonsten habe ich eine Instanz unserer Anfrage und eine Instanz von unseren Ergebnissen. Jetzt noch eine Sache, die ich tun werde, und wir können das zusammen machen, ist, diesen Mach zu gründen, oder? Denken Sie also daran, dass dieser Spott wissen muss, dass, wenn er genannt wird, was er tun sollte. In Ordnung, also machen wir das Setup. Wir werden den X-Punkt einstellen. Und es gibt wirklich nur einen Methodenbuch-Raum. Du brauchst natürlich eine Mock-Bibliothek. Und ich werde sollte für meine Behauptungen leben,
strebt danach, nur für den Fall, dass ich diese früher nicht erwähnen konnte, stellen Sie sicher, dass sie zu NuGet gehen und Sie diese beiden Pakete installieren. Wir haben es schon mal getan. Und wenn Sie sich nicht so sicher sind, können
Sie immer einfach zum vorherigen Testprojekt gehen. Sie können diese beiden Zeilen buchstäblich kopieren. Gehen Sie zu Ihrem bemerkten Projekt und fügen Sie sie dort ein. Und dann machen Sie einfach einen Build und es wird automatisch diese Pakete für Sie installieren. Also lassen Sie uns unser Buchzimmer aufstellen. Also unser Buch Zimmer oder erfordert eine Form von Anfrage Objekt. Also werde ich es hier unsere Wünsche geben. Und dann muss es eine Form von Ergebnissen zurückgeben. Also werde ich nur sagen, dass Punktrückgaben tatsächlich ein Typ
sind, der an ihrem eigenen Platz ist, der außerhalb von Punkten zurückgegeben werden sollte. Da gehen wir. Und was es zurückgeben wird, ist eine Form von Ergebnissen. Okay, also verlasse ich auch die hier. Sie sind instanziiert, aber sie haben noch keine nützlichen Daten in ihnen. Das ist in Ordnung. Aber das ist unser Setup für unseren raumaussehenden Prozessor. Wenn wir jetzt ein wenig runtergehen, werden
Sie sehen, dass ich hier Mehrzweck-Test habe. Und dieser Test wird die Toolszenarien aus unserer Anforderung abdecken. Die Voraussetzung ist, dass wir dem Benutzer erlauben müssen, ein Zimmer zu buchen. Ich ging, es ist ungültig. Wir lehnen den Versuch ab. Ordnung? Also habe ich eine Theorie und habe zwei Bits von Daten, zwei Datenzeilen, in die ich passen muss. Der erste sieht also, dass dies
die erwartete Anzahl von Methodenaufrufen ist , die einer ist. Wenn IS-Modell gültig ist true und es sollte den Typ der Ergebnisse des alten Schlüsselobjekts zurückgeben. Das Problem ist also, dass der Typ erwartete Axon-Ergebnistyp ist. Mit APIs können Sie also zurückkehren, okay, kann 404 oder eine schlechte Anfrage, et cetera, zurückgeben. Also wollen wir sicherstellen, dass, wenn alles in Ordnung ist, wir mindestens einen Methodenaufruf in den Buchraum bekommen und wir können abweisen, dass Kirk schnell eingeschaltet ist. Entschuldigung. Also bekommen wir einen Methodenaufruf in unseren Buchraum. Und wenn es gültig ist, und wir bekommen, dass, okay, Objekte Ergebnisse, wenn es nicht gültig ist, wir wollen keine Methodenaufrufe und es sollte eine schlechte Anfrage sein. Diese gehen also in Einklang mit drei Parametern und der Name der Statistik sollte Buchungsmethode aufrufen, wenn gültig. Okay, ich denke, das ist einfach genug. Nun für die Anordnung, werde
ich den Modellzustand des Controllers zwingen, was Boston war. Nun, sie sind wahr oder falsch, oder? Das ist Modell gültig. Also, wenn es nicht gültig ist,
was bedeutet, dass wir Stürze übergeben, dann fahren Sie fort, manuell Modellstatusfehler hinzuzufügen. Dann gehen wir, ich ging, um unsere Gewichte zu sehen, den Controller. Also beachte, dass ich ein Gewicht benutze. Wir haben vorher keine asynchronen Methoden verwendet. Und das war etwas absichtlich, sonst eine Art Sockelleiste um das herum. Aber nein, lassen Sie uns sehen, wie wir asynchrone Tests machen können. Kein Problem damit. So asynchrone Aufgabe, das ist die Signatur für die Testmethode. Und dann warten wir hier auf unsere Kontrolle oder rufen diese Methode namens Buchraum, bekommen ein Anforderungsobjekt. Also, was ich hier tun werde, ist Steuerpunkt zu verwenden und diese Methode zu generieren. Springen Sie dorthin und ich werde es zu einer AsyncTask machen, die I Aktionsergebnisse zurückgibt. Alles klar, nur um sicherzustellen, dass es weiß, dass es etwas zurückgeben sollte , das im Allgemeinen einen HTTP-Antwortnachrichtentyp hat. Alles klar, mit dem erledigen, wir diesen Fehler loswerden. Wir haben diese Mini-Implementierung. Dann können wir behaupten, dass das Ergebnis vom Typ,
erwartete Auktionsergebnisart sein sollte . Also, was auch immer Typ ist, dann bin ich eigentlich Boston mit beiden Szenarien. Wir behaupten, dass das unser Typ sein sollte. Ich werde auch sehen, dass unser Zimmer Buchungsprozessor. Also habe ich ein bisschen umbenannt, seit wir mit dieser Lektion begonnen haben. Zimmer suchen Prozessorpunkt überprüfen, dass Buchraum mit der Anfrage genau die Anzahl der Male aufgerufen wird, die durch unsere Inline-Daten übergeben wird. NULL. Du kannst einfach einen Build machen. Und sobald dieser Aufbau erfolgreich war, springen
Sie zum Test Explorer. Und dann sehen Sie Ihre API-Tests. Und ich werde nur die API-Tests ausführen. Und wir sollten sehen oder es Tests alle gehören, oder zumindest für das, was wir gerade geschrieben haben. Gut. Also müssen wir Tests lesen, weil beide sehen System nicht implementiert. Alles klar, damit wir hier pausieren können. Wieder einmal können Sie überprüfen und pausieren und replizieren, wenn nötig. Aber wenn wir zurückkommen, werden
wir anfangen, die Implementierung zu schreiben. Wir haben also ein paar Dinge, die wir abdecken müssen, einschließlich der WHO-Validierung wird
im Allgemeinen behandelt und was die Controller-Methode basierend auf den Szenarien tun wird.
25. Implement für Tests: In Ordnung, also haben wir unsere Komponententests geschrieben. Es hat wahrscheinlich noch etwas Raum für Verbesserungen, aber es gibt uns eine allgemeine Vorstellung davon, was wir
implementieren müssen , um die Grundvoraussetzung zu erfüllen. Also werde ich mit der Validierung beginnen, weil ich einen Weg brauche, um sicherzustellen, dass die Validierung tatsächlich durchgeführt wird. Das coole an dotnet Core ist, dass wir nur
zu unserem Modell gehen müssen , von dem wir wissen, dass es eingeht und unsere Validierung einrichtet. Also, nur um zu überprüfen, Buch Zimmer Buchungsanfragen erwartet. Zimmerbuchungsanfrage hat eigentlich keine Felder. Wie füge ich Validatoren zu den Feldern hinzu? Nun, denken Sie daran, dass es von unserer Basismethode erbt, wir
die Validierungen hinzufügen können. Und alles, was von dieser Basis erbt, was die Anforderungen, die Ergebnisse und
das eigentliche Domänenobjekt wären, würde diese Validierungsregeln erhalten. Also die erste, die der vollständige Name der Person ist, die ich hinzufügen werde erforderlich. Und dass die String-Länge sollte mehr sein, sollte nicht mehr als 50 sein. Denkbar, ein bisschen scharf, fallen volle Namen. Also lassen Sie es mich drauf setzen. Natürlich, basierend auf Ihrer Geschäftsregel ist, dass Sie Ihre Validierungen entsprechend hinzufügen. Alles klar, der nächste, ich werde die Saitenlänge gleich machen. Also für die E-Mail-Adresse, werde
ich es auch erforderlich machen und dann kann ich hinzufügen, dass ich eine E-Mail-Adresse sein wollte. In Ordnung. Der nächste, ich werde hinzufügen, dass die getan, der Datentyp ist die IT. Und an diesem Punkt könnten Sie sogar über
andere Validierungen nachdenken , die Sie in C einfügen könnten , die in der Zukunft sein oder in der Vergangenheit kopieren müssen, solche Dinge. An diesem Punkt würden Sie entweder ein benutzerdefiniertes Attribut erstellen oder Sie können es vom Objekt invalidates erben lassen. Und das wird Sie diese Methode hier mit dem Auge
unzählige Validierungsergebnis namens validate implementieren und ihm einen Validierungskontext geben. Also an diesem Punkt kann ich wahrscheinlich etwas tun, wie wenn b kleiner ist als die datetime Node.js. In Ordnung, also hier ist, was ich sehe. Wenn sich die vom Benutzer zur Verfügung gestellten Daten als kleiner als das heutige Datum herausstellen. Richtig? Dann werde ich ein neues Validierungsergebnis geben, wo ich ihnen Frau schicke, UND es muss in der Zukunft sein. So kannst du das twittern. Ich sage, muss ein zukünftiges Datum sein, also kann ich leicht sagen, wo es kleiner oder gleich ist. Das bedeutet, dass sie nicht buchen können, dass es unsere Taten in der Vergangenheit sind. Sie müssen in der Zukunft sein. Und dann das zweite Parlament, diese Art von Validierungsergebnissen wäre der Name oder die Namen des Mitglieds. Mitgliedernamen, weil es ein Bereich ist, in dem Sie einen Wert angeben können, was ich tue. Also die Fehlermeldung und dann die Arie mit Mitgliedern, die von dieser Validierung betroffen sind. Also hier sehe ich nur ein neues Array, das Name aus Beat übergibt. Dafür ist es nur der Schlüssel welches Feld oder der Name des Feldes mit dem Fehler. Das Problem dabei ist, dass, wenn ich dies ändere, das Buchungsdatum später und vergesse, diese Zeichenfolge zu aktualisieren, es eine Diskrepanz geben wird. Sie sollten also stark eingegeben werden, indem Sie den Namen aus und dann den Feldnamen sehen. Es wertet also aus, dass die String-Version vom Feldnamen wäre. Und dann wäre die zusätzlichen Vorteile, dass, wenn ich
einen globalen Refactor mache oder selbst wenn ich diesen Namen umfaktoriere und vergesse, ihn hier unten zu ändern, ich nur Compilerfehler bekomme und
ich diesen fehlerhaften Code nicht an Produktion. Das sind also die Dinge, die wir mitmachen. Ja, es ist testgesteuerte Entwicklung. Aber dabei sehen
wir Best Practices, die die Wahrscheinlichkeit von Fehlern reduzieren, während wir in unserem Code weitergehen. Also habe ich gerade all diese kleine Validierung zu unserer Basis hinzugefügt. Das bedeutet also, dass jede der Zimmerbuchungsvarianten wissen wird, dass grundlegende Validierung hat. Alles klar, was wir hier sehen, um die Anfrage zu führen und wir wissen, dass das Domain-Objekt für die Zimmerbuchung auch das haben wird. Jetzt in unserem Controller müssen
wir Code einfügen, der unsere Szenarien behandelt. Also das erste, was ich tun werde, ist zu überprüfen, ob der Modellzustand gültig ist. Also kann ich sagen, ob der Modellzustand gültig ist und dies durch die Daten, die in der Zimmerbuchungsanfrage kommen, informiert werden
würde. Und während ich hier bin, werde ich es nur wissen lassen, dass dies
ein HTTP-Methodenpost ist , richtig? Das ist also HTTP-Post-Methode. Also nur durch Anruf Zimmer Buchung Schrägstrich mit einer Post Anfrage auf diesem Kissen, die wie unsere Buchungsanfragen aussieht. Es würde wissen, dass es hier sein soll, das Ziel. Wenn also der Modellzustand gültig ist, möchte ich
fortfahren, den Zimmerbuchungsprozessor anzurufen. Und ich werde die Buchbesatzungsmethode in den Zimmerbuchungsprozessen anrufen. Also, wenn wir gültig sind, dann gehen Sie weiter und rufen Sie diese Methode auf. In Ordnung. Wenn jedoch das Ergebnis Überschwemmung Boden,
denken Sie daran, dass tatsächlich dies zurückkehrt. Zimmer suchen Ergebnisse. Wenn wir schauen und sehen, was dieser Raum das Ergebnis töten wird, sehen
Sie hier, dass wir bekommen, aber keine Überschwemmung und wir bekommen diesen Ausweis. Also werde ich wissen, dass ich mehr Winter verschraubt denke. Mir wurde klar, dass es vielleicht ein anderes Szenario gibt, auf das ich testen könnte, aber gut. Das bringt die Ergebnisse der Zimmerbuchung. Also var Ergebnisse gleich welchem Ergebnis dieser Begriff ist, gibt dies zurück. Nein, es wäre nicht klug, wenn ich es ihnen sage. Ok. Boot, das Sie buchen, fehlgeschlagen, weil dieses Ergebnis hat, dass Überschwemmungen Erfolg oder Misserfolg. Also werde ich sagen, wenn die Ergebnisse punktflut,
tut mir leid, wenn es eine Flut ist äquivalent zu, und ich kann die Enums direkt dort bekommen. Und ich werde sagen, wenn es dem Erfolg entspricht, dann möchte ich alle Keras Fonds zurückgeben oder drehen, okay, den Teig mit den Ergebnissen behalten. Denken Sie also daran, dass dieses Ergebnis von unseren Buchräumen zusammengestellt worden wäre. Also dieser Roboter DO die Gänseblümchenkette runter zu sehen. Also BOC-Raum ruft das Ergebnis hier an, richtig? Und dann sehen wir, dass erstellt, die auf den Buchstützenanfragen basieren. Also all die Felder, die übertragen wurden, okay? Und dann, wenn es irgendwelche verfügbaren Zimmer gibt, dann wollen wir mit der ID und der Erfolgsflagge zurückkehren. Das ist es, was in Ergebnisse geht. Ansonsten, Ergebnisse Silikone über mit allen Werten, nur mit dem Ausfall Flut. Ordnung? Das ist es, was wir in dieser Situation tun können. Also geben wir einfach die OK-Antwort mit der gesamten Ergebnis-Nutzlast mit der Zimmerbuchungs-ID, der Raum-ID, dem ganzen Shebang,
alles, was von dort kompiliert worden wäre. Also, wenn ich alle meine Tests durchführe, Mal sehen. Oh, es tut mir leid, ich erhalte einen Kompilierfehler, weil nicht alle Codepfade zurückkehren. Also werde ich eine schlechte Anfrage hier zurückgeben, richtig? Hat, wenn es uns nicht weit als die alte K, dann werde ich nur eine Rückkehr schlechte Anfragen sehen. Also lassen Sie mich einfach wieder auf meine Tests werfen. Und dann wirst du sehen, dass ich einen grünen und einen roten Test habe. Der Test sieht also, dass es von schlechten Anforderungsobjektergebnissen sein sollte, und es war nur ein schlechtes Anforderungsergebnis. Alles klar, damit das eine interessante Frage aufwirft. Was ist der Unterschied zwischen fehlerhaften Anforderungsobjektergebnissen und schlechten Anforderungsergebnissen? Nun, genau das Gleiche mit dem alten Fall. OLC-Objektergebnisse unterscheiden sich also von, okay, richtig? So sehen Sie das alte Schlüsselergebnis ist da, weil es keine Parameter gibt. Also okay, allein bedeutet keine Parameter. Sobald Sie jedoch Parameter dort eingefügt haben, sobald Sie ein Objekt mit der Antwort übergeben haben, wird es zu den alten Schlüsselobjektergebnissen. So schlechte Anfrage an sich ist das Batterieergebnis durch Anforderungsergebnisse. Aber wir könnten Daten dort reinlegen. Wenn Sie also eine schlechte Anfrage zurückgeben, da
Sie aus einer Feldvalidierung den Modellstatus einfach dort einfügen können. Und der ganze JSON wird wissen, wie man es deserialisiert und dem Benutzer
präsentiert, dass dies die Validierungspunkte sind, die auf dem Fehler basieren, richtig? In ähnlicher Weise möchte
ich, wenn das Flag nicht erfolgreich ist , wahrscheinlich nicht den Modellstatus geben, da das Modellstatusgesetz gültig ist. Die Buchung ist jedoch fehlgeschlagen, vielleicht gab es keine verfügbaren Zimmer oder etwas. Es war nicht wirklich eine Feldvalidierung für die Batterieergebnisse oder schlechte Anfrage. Und hier fangen Sie wahrscheinlich an, basierend darauf, wie Ihr API-Design funktionieren soll. Nun, was ich tun werde, es ist bereits die Validierung hier bestanden. Und sagen wir, es gab keine Zimmer. Das hat uns also nicht die Erfolgsflut gegeben. Also hier unten, es klar, wenn wir nicht die Erfolgsflagge, die sie brauchten, oder ewigen Schlüssel bekommen, wenn ich ging zu tun, ist sagen Modelle, der Modellfehler, richtig? Und das bin ich nur davon ausgegangen, dass es nur so weit gekommen ist, weil es nicht den Subsisten Flau'jae gültig war, aber nicht die Erfolgsflut bekommen hat, jemand hat selbst einen Modellfehler. Und ich werde es dem Namen hinzufügen. Und das Feld wird aus dem Raum kommen, wird Anfrage Punkt Datumsfeld kümmern. Da ich nur darauf hinweisen wollte, werden
sie wichtig sagen, mit diesem Namen des Parameters ist. Denn wieder einmal, wenn wir refactored, würde
dies definitiv
in der beiden Liste der Fehler berücksichtigt werden , sind eine Liste von Risikofaktoren nicht. Es ist also weniger Massenverfolgung und versucht
, Knochenmagische Saiten zu schärfen, die die Anwendung abwerfen. Also werde ich einen Modellzustand hinzufügen, sind nur eine D8 gemacht. Und ich werde sehen, dass keine Zimmer für ein bestimmtes Datum verfügbar sind. In Ordnung. Das wird der einzige Grund sein, warum es sich richtig anfühlt. Dieser Gedanke basiert auf den Geschäftsregeln, die wir bisher haben. Und dann würde das zu ihnen hinzugefügt werden, all diese Daten, wir geben immer noch die schlechte Anfrage mit dem Modellzustand zurück. In Ordnung, also genau da alles auf einen Schlag, wo entweder
alte QA zurückgeben oder die Butteranforderung mit den Validierungsfehlern zurückgeben. Und das hier ist eine Art Ad-hoc-basiert auf dem Prozess, richtig? Lassen Sie uns also alle Tests erneut ausführen. Und jetzt wirst du sehen, dass ich diese grüne Zecke habe, zwei von zwei vorbei und das ist ausgezeichnet. Sie sehen also, dass wir gerade eine schnelle Implementierung durchgeführt haben, um unsere Testlogik in unserem Brunnen
zu erfüllen, um Künstlerlogik zu treffen, richtig, wir haben die Implementierung durchgeführt, aber wir haben etwas implementiert, das wir nicht unbedingt auf unsere Abrechnung mit Künstlern, die das Ergebnis Flagge ist. Also werde ich zurück zum Test springen und das werde ich dem testgesteuerten Abschnitt
hinzufügen. Also werde ich die Enum hier hinzufügen. Wenn ich mich erinnern kann,
wird es das Ergebnis Flag buchen oder jemanden hinzufügen, um
das als Parameter oder datengesteuerten Test hinzuzufügen , es ist NULL-fähig. Und ich werde sagen Buchhaltung Ergebnis Flagge. Also werde ich hinzufügen müssen, dass die Binnendaten,
wenn alles gültig ist, diese Flagge für den Erfolg
haben sollten wenn alles gültig ist . Und wenn die Dinge nicht gültig sind, sollte
es auch diesen Blumentopf für Scheitern haben. Also in meinem Bereich werde
ich diese if-Anweisung hinzufügen, um zu sehen, ob das Buch King Ergebnisflag einen Wert hat,
was bedeutet, dass man bereitgestellt wurde,
ja, einer wurde zur Verfügung gestellt. Und ehrlich gesagt, ich muss es nicht einmal liberaler machen, kommen Sie, um es zu denken. Ich denke nur darüber nach, es nach der Tatsache einzuführen. Aber ich meine, ich bin derjenige, der die Kontrolle über die Daten hat, also werde ich sie vorstellen und sie in Ruhe lassen. Also habe ich kein Szenario, in dem es jemals nein sein würde, sowieso, nicht in diesem Test. Also lassen Sie mich zurückverfolgen. Es ist kein NULL-fähiger Parameter. Und wir gehen in einem für Erfolg, einer für Misserfolg. Und dann denken Sie daran, dass unser Ergebnisfeld hier oben initialisiert wurde. Und der settle sehen ist, dass die Buchraum-Methode wenn eine Anfrage gegeben wird, ein Ergebnis zurückgeben sollte. Also, ich sehe hier, dass jeder Wert
in diesem Szenario oder in den Daten ist , die für dieses Szenario übergeben werden, setzen Sie dies als das Flag für das Ergebnisobjekt, das zurückgegeben wird, sobald diese Methode sowieso aufgerufen wird. Also werde ich nur noch mal
diese Tests durchführen nur um sicherzustellen, dass ich immer noch eine abschließende Note bekommen werde, richtig. Es ist allein. Und da gehen wir. Also bekomme ich immer noch Pässe. Und das sind alle Tests. Also werde ich nur alle Tests im Blick ausführen und alles ist vorbei. Das ist also eine sehr einfache Möglichkeit, Ihre API und durch Erweiterung Ihrer Webanwendung zu testen. Da der einzige wirkliche Unterschied noch einmal, zwischen dem Testen einer API im Vergleich zum Testen Razor-Seiten oder einem MVC up die Rückgabetypen sind, für die Sie basierend auf Ihren eigenen testen. Jetzt im Allgemeinen, wenn Einkommen der MVC, werden
Sie entweder eine Ansicht zurückgeben oder zu einer anderen umleiten. Umleiten zu einer anderen Ansicht, unser Radar zur Auktion eher. Wenn es unsere Razor Seiten nach oben ist, Sie entweder die Seite zurückkehren oder Sie auf die Seite umleiten und Sie verwenden andere Rückgabe pj, die als Seitenergebnisse gesehen wird. Wenn ich mich nicht irre. So können Sie zu Seitenergebnissen umleiten. Normalerweise tun Sie das, wenn es eine erfolgreiche Operation war. Aber wenn es keine erfolgreiche Operation ist, Sie normalerweise einfach den pH-Wert zurück. Da gehen wir. Also brauche ich nur diese Bibliothek, um zurückzukehren, um zu testen, ob Sie nur Backup-Eat-Ergebnisse senden. In Ordnung, also genauso wie, wenn es gültig ist, willst
du zum Pitch umleiten. Und wenn es ungültig ist, würden Sie in bezahlte Ergebnisse auf IUIE zurückgegeben, Sie würden dem Benutzer die Seite neben den Modellstatusfehlern anzeigen, richtig? Wenn es ein MVC up wäre, würde
es sein, ich werde nur Auktionsergebnisse eingeben. Richtig? Sagen Sie Was tun Sie es wird ein Axon Ergebnisse oder es wäre eine Umleitung zu Aktionsergebnissen. Aber es ist ziemlich dasselbe. Die Szenarien, auf die Sie testen,
unterscheiden sich wahrscheinlich basierend auf der Anwendung, die Sie testen. Aber letztendlich sind die Prinzipien die gleichen. Das wird also wirklich das geringere stoppen. Ich weiß, dass wir nicht zu kompliziert wurden, aber wir haben genug getan. So können Sie ganze Low-Code-Flüsse und Heiliger Unit-Test auf Anwendungsebene schätzen,
testen, was der Controller tut und wie unsere Behauptungen am Ende aussehen könnten. Daher ermutige ich Sie, die Endpunkte zu erstellen, machen Sie weitere Tests und sehen ob Sie sich andere Szenarien vorstellen können, auf die Sie wahrscheinlich testen möchten. Ich werde mich freuen zu hören. Und wenn überhaupt, schießen Sie mir ein Feedback und wir können entsprechend daran arbeiten.
26. ASP.NET ASP.NET laufen und testen: Alles klar, Jungs gehen zu all dem, sitzen und testen. Es ist Zeit, es an die Anwendungsbenutzer zu übergeben, um tatsächlich getestet, um es zu ändern. Um die API in Betrieb zu bringen, benötigen
wir ein paar weitere Konfigurationen. Einer ist der Zusatz zum Service, der IOC-Container, die Schriftart, die wir brauchen, der Augenzimmerbuchungsservice
, der tatsächlich mit der Datenbank spricht. Also ja, wir haben den Prozessor. Der Verarbeiter verlässt sich auf den Dienst und unsere Anwendung muss wissen, dass wir unsere Darstellung
des Dienstes haben
müssen , damit wir eine Vertretung des Verarbeiters haben können. Also wieder, lassen Sie uns voran und fügen Sie hinzu, dass Dienstleistungen dot i Zimmerbuchungsservice, Zimmerbuchungsservice. Und verwenden Sie natürlich Ihren Kontrollpunkt, um alles zu enthalten, was fehlt. Jetzt können wir zu unserer Package Manager-Konsole springen. Und wenn es nicht, wo Sie es auf meinem Bildschirm für sich selbst sehen, können
Sie gehen und drücken Sie Tools NuGet, Paket-Manager, und um die Konsole zu erhalten. Bisher diese Konsole, wollen
wir unser Zielprojekt auf das Persistenzprojekt ändern. Warum? Denn das ist, wo unser DB-Kontext lebt. Also sind alle Bibliotheken und so weiter für die Befehle im Begriff, live in diesem Projekt zu laufen, wir mussten nur darauf hinweisen. Also werde ich sagen, fügen Sie Bindestrich Migration, und ich werde sagen, erste Migration. Also schnelle Abhilfe für diesen Fehler ist, das Design-Paket im API-Projekt zu bekommen, richtig? Wenn ich also auf Persistenz stöße, werden
Sie feststellen, dass dieser gesamte XML-Block dem Design-Paket gewidmet ist. Also werde ich das eigentlich nur kopieren. Und ich denke, eine weitere Modifikation, die wir
machen müssen , sind diese zwei verschiedenen, die wir Kernbibliothek sind. Ich denke, wenn wir diese Persistenz erstellen, haben wir SQL Server verwendet. Also, und als wir dann zur API kamen, entschieden
wir uns, okay, wir werden SQL light verwenden. Also, wenn Sie SQL Server weiterhin verwenden möchten, sind
Sie wohl damit einverstanden, dass dann in Ordnung ist. Kein Problem stellt sicher, dass Sie unsere eigene,
die Verbindungszeichenfolge und alles für die API ändern . Andernfalls, wenn Sie mir nur folgen und sicherstellen wollen, dass Sie keine Probleme haben, können
Sie voran gehen und dies ändern. Sie können einfach das Verbiage von SQL Server in SQL IT ändern. Okay, ich und diese Änderung, aber immer noch den ganzen Block für den Entwurf kopieren. Und wir werden zur API springen,
stellen Sie sicher, dass dies auch SQL ITE sagt und dann eine Wand davon aufschreiben. Ich werde nur diesen Designblock einfügen,
jemanden, der einen Build macht. Und an diesem Punkt das API-Projekt ohne Pick up, dass es dieses Design-Paket hat. Und dann kann ich zu meinem PCM zurückkehren und diese Migration erneut versuchen. Und nach einem erfolgreichen Build werden
Sie sehen, dass wir wissen, dass unsere erste Migration erfolgreich ist. Also, nachdem wir die Migration haben, müssen
wir nur sagen, dass es Datenbank. Und das ist erledigt. Werfen wir einen Blick auf all das, was wir haben. Wir haben Zimmer von Zimmerbuchungen. Dies sind alle Tabellen, die wir erstellt haben, und einige Daten, in denen wir es gesehen hätten. Sie sehen also, wir haben Zimmer. Sieh das in. Wenn Sie möchten, können Sie einen Endpunkt erstellen, an dem der Benutzer die Liste der Räume abrufen kann. Sie können einen anderen Endpunkt erstellen, um die Liste der verfügbaren Räume abzurufen. Aber der Punkt von TDD ist, dass Sie
diesen Test zuerst schreiben müssen und dann implementieren. In Ordnung, ich glaube, ich habe dir
genug Munition gegeben , damit du die alleine erledigen kannst. Lassen Sie uns zunächst die API testen, nur um sicherzustellen, dass unser Code, für den wir eine ausgezeichnete Abdeckung haben, tatsächlich funktioniert. Also, weil wir während der API-Erstellung angekreuzt hatten, die offene API-Unterstützung
enthalten, bekommen
wir diesen Swagger, richtig? Wenn Sie also nicht mit Fußball vertraut sind, ist
es ein leistungsfähiges Tool, das sowohl das Testen als auch die Dokumentation von APIs nützlich ist. Wenn Sie damit vertraut sind, dann sollte dies ein No-Brainer sein muss, um es zu benutzen. Hier sehen Sie, dass sie uns ein Beispiel dafür geben, was
erwartet wird , wenn wir im Begriff sind, eine Post-Anfrage für eine Zimmerbuchung zu tun. Wenn ich auf Probieren, und ich werde nicht unsere eigenen die Werte ändern. Ich werde nur auf Ausführen klicken, dann bekomme ich diesen bösen Fehler. Also werde ich es einfach durchlesen und es sieht SQLite außer Norden. So geteilt, Es gibt etwas, das ich mit den Konfigurationen verpasst habe. Ich werde nur zurück zum Codeblock in der Startdatei springen, wir haben unsere Verbindung, wir haben oder AV-Kontext. Und ich denke, ich brauche noch ein paar Zeilen, um sicherzustellen, dass die Datenbank erstellt wird. Also liebe ich diese Methode, stelle
sicher, dass die Datenbank erstellt wurde und ich gebe ihr
den Parameter für die SQLite-Verbindung. Es gibt also controller.js und generiert diese Methode, die privat und statisch sein kann. Gerade jetzt dafür werde ich tun. Builder-Objekt. Also in allen Builder-Objekt bereits. Dies war also ein neuer DB Context Options
Builder vom Typ der DVI-Kontexte, die wir verwenden. Und dann wissen Sie, dass wir haben, dass ich Builder sagen werde, Sie sollten SQL lite verwenden, oder? Also werde ich das einfach kopieren. Nach all dem werde
ich sagen, dass die Verwendung von var oder Kontexten einer neuen Instanz von RDB-Kontexten gleich ist. Tut mir Leid, ich habe diese Zeilen früher verpasst. Dann werden wir nur
die Builder-Punkt-Optionen übergeben , weil ich ihm jederzeit die Optionen geben
muss, wenn wir das instanziieren. Und dann sagen wir Kontexte, Punkt-Datenbank, Punkt sorgen erstellt. In Ordnung. Wir fügen es nur hinzu, um sicherzustellen, dass die Datenbank erstellt wird. Ja, wir haben das alles kaputt gemacht, aber dann müssen
wir wegen der Natur der Datenbank sicherstellen, dass sie tatsächlich zur Laufzeit erstellt wird. In Ordnung, also versuchen wir es nochmal. So springen zurück in Swagger und tun die Tote und die Hinrichtung
und wissen, wen Sie etwas sehen, das ein bisschen besser aussieht. Was wir hier sehen, ist die Antwort. Also ich meine, es gibt Möglichkeiten, natürlich, die saubere es. Also, weil Sie hier sehen, ist die Flut 000, weil die Erfolgsflagge 0 war und die Fehlerflut eins war. Wir könnten gehen und natürlich dann die Enum-Werte ändern. Oder wir könnten das Ergebnisfeld für
die Flut ändern , um eine Zeichenfolge zu sein und tatsächlich die Wörter,
den Erfolg oder Misserfolg entsprechend drucken . Das liegt an dir. Wenn ich etwas einfüge, das ungültig ist, wie ich in eine Tat, die letzten Monat war, und versuchen, das auszuführen. Dann sehen Sie hier, ich bekomme den 400 Modellzustand oder wo die Taten in der Zukunft sein müssen. In Ordnung, das sind also die Arten von Dingen, die wir implementiert haben und wir
getestet haben , damit wir das Verhalten kennen, sobald wir das Szenario praktikabel ausprobiert haben. Das sind also die verschiedenen Testniveaus, die wir durch unseren Rot-Grün-Zyklus gegangen sind, können sicherstellen, dass unser Code kugelsicher war, inwieweit wir auch taten. Und dann wissen Sie, wenn der Client testet, hätte er sein Testdokument zu sehen bekommen. Hier sind Ihre Szenarien testen und stellen Sie sicher, dass dies die Ergebnisse sind. Jede Abweichung davon würde dazu führen, dass sie Ihnen sagen wollen, dass sie umfaktorieren. Wenn ich also einige Invalidates einfüge, sieht
dies den 18. Monat des Jahres und ich klicke auf Ausführen, das wird zu einem Absturz führen. Also ja, es ist immer noch eine schlechte Anfrage und ja, ich versuche, einige Objekte hier zu bekommen. Sie sehen, dass der JSON-Wert nicht konvertiert werden konnte, aber dann ist dies wahrscheinlich nicht das, was ein Benutzer sehen muss oder jemand die API verbraucht. Also an diesem Punkt und all Ihre QA-Abteilung würde zu Ihnen zurückkommen und sagen, hey, weißt du, unter diesem Umstand, rufen
Sie sie bitte an, haben es nicht dafür gesehen. Also gehen Sie zurück, Sie schreiben einen Test, um sicherzustellen, dass ein solches Szenario nicht existiert oder es sich auf diese Weise verhält. Oder Sie schreiben den Test entsprechend, wie Sie wollen, dass er sich verhalten. Und dann schreiben Sie den Code, um sicherzustellen, dass es das tut. Kurz gesagt, das ist die testgesteuerte Entwicklung mit C-Sharp. Wenn wir zurückkommen, können wir eine kurze Zusammenfassung von allem, was wir durchgemacht haben, machen und dann schließen.
27. Kursbewertung: Na gut, Leute, also habt ihr es bis zum letzten Vortrag in diesem Kurs geschafft. Ich vertraue darauf, dass Sie
Ihr Wissen über die testgesteuerte Entwicklung mit Botnet Core weiterentwickelt haben . Und obwohl wir hier dotnet core gelernt haben, können
die Grundlagen dafür auf
jedes andere Framework oder jede andere Sprache angewendet werden , die Sie am Ende verwenden könnten. Sie haben PHP-Unit für PHP-Entwicklung, Sie haben JUnit für Java-Entwicklung, sogar Angelo und reagieren. Alle haben ihre eigenen Unit Testing Frameworks und die Prinzipien sind die gleichen. Testgesteuerte Entwicklung bedeutet, dass Sie den Komponententest schreiben wird fehlschlagen. Du schreibst den Code und dann bekommst du ihn zum Weitergeben. diesen Zyklus tun, sehen
Sie, wie Sie wackelig,
liebe kalte Art von trennen müssen . Was sind die Dinge, die ich darauf hinweisen wollte
, ist , dass wir auf jeder Ebene Trennung von Bedenken eingesetzt haben. Er versuchte, alle verschiedenen Teile unserer Anwendung in ihre eigenen Projekte zu zerlegen. Also war die API von selbst. Der Kern, die Geschäftslogik war von selbst. Und dann hatten wir die Datenoperationen von selbst. Im Allgemeinen ist dies nur eine Vorlage, die auf ihrem Kontext basiert. Sie können mit mehr oder sogar weniger Projekten enden. Aber der Punkt ist, dass, wenn Sie sie in diese Perlengrößen unterteilt sind Einheiten, es macht es viel einfacher für Sie, die verschiedenen Schichten
Ihrer Anwendung zu testen , um sicherzustellen, dass jede Schicht so wirkt, wie sie sollte. Und dann stellt der Komponententest selbst sicher, dass diese Komponente oder diese Funktionsfunktionalität in dieser Komponente oder in dieser Ebene so funktioniert, wie sie sollte. Also haben wir die Persistenz mit allen Datenoperationen, mit dem Kern, mit der Geschäftslogik, all den if-Anweisungen und der Entscheidungsfindung. wir dieses Date zu oder nicht, diese Art von Zeug? Und dann fügen wir die API hinzu, die im Grunde die Anwendung darstellt. Es hätte eine UI sein können. Die API wegen des geringeren Overheads, der mit der Benutzeroberfläche und so weiter benötigt wird. Aber die Prinzipien des Tests und der Entwicklung bleiben ziemlich gleich. Auf dieser Reise hat auch gelernt, dass Sie in
Komponententests verschiedene Arten von Komponententests haben, Projekte, zumindest mit dotnet Core, Sie haben MSTest, das ist Vanille, das ist direkt von Microsoft. Haben Sie x Einheiten und Sie haben n Einheiten? Jeder hat seine eigenen Vor- und Nachteile. In diesem Diskurs verwenden wir x Einheiten. Und wir sahen, dass wir testgesteuerte, sorry,
datengesteuerte Tests schreiben konnten , bei denen wir eine Theorie erstellen und dann Werte übergeben konnten, die die verschiedenen Szenarien repräsentieren. Während in anderen Frameworks es vielleicht nicht so einfach mit meinem harten, einen Komponententest für
das Shooting und einen R1 zu schreiben , wenn es gültig ist und obwohl 14 und es ungültig ist. Und für vielleicht 23 Tests, die Sie in den anderen Frameworks geschrieben hätten, hätten
Sie nur einen Test geschrieben, aber mit verschiedenen Daten für die Szenarien übergeben. Und für mich hilft das auch, den Code anzuordnen, denn dann muss ich
achtsam sein und wissen, dass diese eine Methode oder repräsentiert, was die Methode, die ich teste, tun sollte. also unter verschiedenen Umständen Was wärealso unter verschiedenen Umständendie alte Kolumne? Also hat
es mir in meinem Kopf geholfen, sicherzustellen, dass ich Code schreibe , der die verschiedenen Szenarien enthält. Und schreibe so wenig Code wie möglich, aber gerade genug, um sicherzustellen, dass meine Komponententestfelder mein Szenario sind, kommt tatsächlich zum Tragen. Also haben wir Tests auf Anwendungsebene durchgeführt, wir haben Persistenz der Tests gemacht, und wir haben Business Logik-Tests durchgeführt, und alle von ihnen sind so weit grün, wenn all das, wenn wir uns nicht machen, wir etwas in unseren Code einführen. Wir wollen immer sicherstellen, dass die Tests bestehen und dann können wir vorwärts gehen. Also mit all dem, was gesagt und erledigt werde
ich nur die Änderungen überprüfen. Und das ist meine Botschaft. Also werde ich einfach weitermachen und alles begehen und sinken. Und Sie können den neuesten Quellcode sehen. Sollten Sie es in den Ressourcen brauchen. Also danke, dass du bei mir geblieben bist und wir sehen uns bald.