Was ist ein "Stub"?

Nachdem ich meine Vorsätze für das neue Jahr fortgesetzt habe, um mehr mit TDD zu tun zu haben, beginne ich jetzt, mehr mit Rhino Mocks zu arbeiten .

Eine Sache, die ich gerne tun möchte, ist sicherzustellen, dass ich wirklich weiß, worauf ich mich einlasse. Deshalb wollte ich mein Verständnis für das überprüfen, was ich bisher gesehen habe (und ich dachte, es wäre gut, es hier als zu veröffentlichen Ressource).

Was ist ein "Stub"?

Martin Fowler hat einen ausgezeichneten Artikel zu diesem Thema geschrieben. Aus diesem Artikel:

Meszaros verwendet den Begriff Test Double als Oberbegriff für jede Art von vorgetäuschtem Objekt, das anstelle eines realen Objekts zu Testzwecken verwendet wird. Der Name stammt von der Vorstellung eines Stunt Double in Filmen. (Eines seiner Ziele war es, die Verwendung eines bereits weit verbreiteten Namens zu vermeiden.) Meszaros definierte dann vier bestimmte Arten von Doppel:

• Dummy-Objekte werden herumgereicht, aber nie benutzt. Normalerweise werden sie nur zum Füllen von Parameterlisten verwendet.
• Gefälschte Objekte haben tatsächlich funktionierende Implementierungen, verwenden jedoch normalerweise eine Verknüpfung, die sie für die Produktion nicht geeignet macht (eine In-Memory-Datenbank ist ein gutes Beispiel).
• Stubs bieten vordefinierte Antworten auf Anrufe, die während des Tests getätigt wurden, und reagieren normalerweise überhaupt nicht auf etwas außerhalb der für den Test programmierten. Stubs können auch Informationen über Anrufe aufzeichnen, z. B. einen E-Mail-Gateway-Stub, der sich an die Nachrichten erinnert, die er "gesendet" hat, oder nur an die Anzahl der Nachrichten, die er "gesendet" hat.
• Mocks sind das, worüber wir hier sprechen: Objekte, die mit Erwartungen vorprogrammiert sind und eine Spezifikation der Anrufe bilden, die sie voraussichtlich erhalten.

Um es in meinen eigenen Worten auszudrücken: Scheinobjekte "erwarten", dass bestimmte Methoden für sie aufgerufen werden, und führen normalerweise dazu, dass ein Komponententest fehlschlägt, wenn ihre Erwartungen nicht erfüllt werden. Stub-Objekte liefern vordefinierte Antworten (und können von Hilfsbibliotheken automatisch generiert werden), führen jedoch normalerweise nicht direkt zum Fehlschlagen des Komponententests. Sie werden normalerweise nur verwendet, damit das zu testende Objekt die Daten erhält, die es für seine Arbeit benötigt.

Ein "Stub" ist eine Implementierung einer Schnittstelle, die existiert, um Daten / eine Antwort irgendeiner Art bereitzustellen. Beispielsweise:

• ein DataSet
• Liste der Benutzer
• eine XML-Datei

Normalerweise wird dies von einem anderen Dienst bereitgestellt (sei es ein Webdienst, eine andere Anwendung, eine Datenbank), aber um die Testbarkeit des Codes zu verbessern , werden die Ergebnisse "gefälscht".

Ein wesentlicher Vorteil davon ist, dass Aussagen in Unit-Tests auf der Grundlage der erwarteten Daten gemacht werden können. Wenn aufgrund von Datenfehlern Fehler auftreten, können problemlos Tests hinzugefügt, ein neuer Stub erstellt (Replikation des Datenfehlers) und Code zur Korrektur des Fehlers erstellt werden.

Stubs unterscheiden sich von Mocks darin, dass sie verwendet werden, um den Zustand eines Objekts darzustellen und zu testen , während ein Mock seine Interaktion testet .

Ich glaube, "Stub" kommt von STartUpBlock. Es wird verwendet, um auf Teile des Codes zu verweisen, die automatisch generiert werden, um Ihnen als Entwickler den Einstieg zu erleichtern.

Eine "Stub" - oder "Stub-Methode" ist als Startercode oder vorübergehender Ersatz für noch zu entwickelnden Code konzipiert. Es ist ein integrierter Code, der von einer IDE generiert wird. Stub-Methoden sind Methoden zum Testen von Methoden einer bestimmten Klasse. Es wird verwendet, indem Sie einige Werte für die lokalen Variablen in Ihre tatsächlichen Entwicklungsmethoden eingeben und prüfen, ob die Ausgabe korrekt ist. Es ist wichtig, Fehler in Ihrem Code zu finden.

Ich habe mich kürzlich der Frage gestellt und festgestellt, dass dieser Vergleich zwischen Stub und Driver wirklich klar und hilfreich ist:

Grundsätzlich sind Stubs und Treiber Routinen, die nichts anderes tun, als sich selbst und die von ihnen akzeptierten Parameter zu deklarieren. Der Rest des Codes kann diese Parameter dann als Eingaben verwenden.

+ --------- + ------------------------------- + ------- ------------------------ +
| | Stub | Fahrer |
+ --------- + ------------------------------- + ------- ------------------------ +
| Geben Sie | ein Dummy-Codes | Dummy-Codes |
+ --------- + ------------------------------- + ------- ------------------------ +
| Verwendet in | Top-Down-Integration | Bottom-Up-Integration |
+ --------- + ------------------------------- + ------- ------------------------ +
| Zweck | Um das Testen des oberen | zu ermöglichen Um das Testen des unteren | zu ermöglichen
| | Ebenen des Codes, wenn die | Ebenen des Codes, wenn die |
| | niedrigere Codeebenen sind | Die oberen Ebenen des Codes sind |
| | noch nicht entwickelt. | noch nicht entwickelt. |
+ --------- + ------------------------------- + ------- ------------------------ +
| Beispiel | A und B sind Komponenten. | A und B sind Komponenten. |
| | A ---> B | A ---> B |
| | | |
| | A wurde entwickelt. | A muss noch entwickelt werden
| | B muss noch entwickelt werden B wurde entwickelt. |
| | Daher wird stub | verwendet Daher wird der Treiber | verwendet
| | anstelle von B, um es nachzuahmen. | anstelle von A, um es nachzuahmen |
| | | |
| | A ---> Stub | Treiber ---> B |
+ --------- + ------------------------------- + ------- ------------------------ +

Vom Unterschied zwischen Stub und Driver

Nach einigen Recherchen und basierend auf Stub-Dateien, mit denen ich während meines Codiererlebens konfrontiert war, würde ich sagen, dass eine Stub-Datei nur eine Datei ist, die die gesamte oder einen Teil der Implementierung einer Datei enthält. Es hilft Entwicklern, mit dem Codieren zu beginnen.