Wann sollte ich Integrationstests schreiben?

Nach den TDD-Regeln werden Komponententests vor dem Produktionscode geschrieben. Wie steht es jedoch mit Integrationstests, die die Interaktion zwischen konkreten (nicht nachgebildeten) verdrahteten Objekten ausüben?

Sollten sie vor dem Komponententest oder nach dem Seriencode geschrieben werden, um nur die "Verkabelung" zu testen?

Beachten Sie, dass es sich nicht um Akzeptanz- oder Funktionstests handelt, sondern um Integrationstests auf niedrigerer Ebene.

Das Rspec-Buch schlägt neben anderen BDD-Ressourcen einen Zyklus wie diesen vor:

Im Wesentlichen ist der Prozess:

While behaviour required
    Write an integration test for a specific behaviour
    While integration test failing
        Write a unit test to fulfil partial behavior
        While unit test failing
            Write code to make unit test pass
        Commit
        While refactoring can be done
            Refactor
            While unit test failing
                Write code to make unit test pass
            Commit
    Push

Haftungsausschluss: Ich habe keinen Zweifel daran, dass dies zum besten Code und Produkt führt, aber es kann zeitaufwändig sein. Es gibt alle Arten von Schwierigkeiten mit Daten und Determinismus, wenn es darum geht zu sagen, dass Integrationstests immer bestanden werden sollten. Es ist nicht unter allen Umständen angemessen. Manchmal muss man nur Sachen aus der Tür holen.

Das heißt, einen idealen Prozess im Auge zu haben, ist großartig. Es gibt Ihnen einen Punkt, von dem aus Sie Kompromisse eingehen können.

Ein reales Projekt hat mir gezeigt, dass es nicht möglich ist, Komponententests zu schreiben, und dann ist die Integration und sogar die entgegengesetzte Richtung falsch :-) Also schreibe ich normalerweise Komponententests zusammen mit den Integrationstests.

Warum? Lassen Sie mich schreiben, wie ich beide Arten von Tests sehe:

1. Komponententests - Neben Wikipedia und allen bekannten Informationen helfen Komponententests dabei, Ihr Design einzugrenzen, Ihr Modell und Ihre Beziehungen zu verbessern. Der Ablauf ist einfach: Sobald Sie mit der Eingabe eines neuen Projekts / einer neuen Komponente beginnen, erstellen Sie die meiste Zeit eine Art PoC . Wenn Sie fertig sind, haben Sie immer lange Methoden, lange Klassen, nicht kohärente Methoden und Klassen usw.

   Unit-Tests helfen Ihnen dabei, diese Probleme zu beseitigen, da Sie echte Unit-Tests mit den oben beschriebenen Mock-Klassen (ohne Abhängigkeit von anderen Komponenten) nicht testen können. Ein grundlegendes Zeichen für nicht testbaren Code ist ein großer verspottender Teil der Tests, da Sie gezwungen sind, viele Abhängigkeiten (oder Situationen) zu verspotten.

2. Integrationstests - korrekte und funktionierende Tests sagen Ihnen, dass Ihre neue Komponente (oder Komponenten) zusammen oder mit anderen Komponenten arbeiten - dies ist die übliche Definition. Ich habe festgestellt, dass Integrationstests Ihnen hauptsächlich dabei helfen, den Ablauf für die Verwendung Ihrer Komponente auf der Verbraucherseite zu definieren .

   Dies ist sehr wichtig, da Ihnen manchmal gesagt wird, dass Ihre API von außen keinen Sinn ergibt.

Was passiert, wenn ich später Unit-Tests und Integrationstests geschrieben habe?

Ich habe nette Klassen, klares Design, gute Konstruktoren, kurze und kohärente Methoden, IoC-fähig usw. Nachdem ich meine Klasse / API einem Verbraucher gegeben habe, z. B. einem Entwickler aus der Integration oder einem GUI-Team, konnte er meine API nicht verwenden, da dies unlogisch erscheint , seltsam. Er war nur verwirrt. Also habe ich API nach seiner Ansicht repariert, aber es mussten auch viele Tests neu geschrieben werden, da ich dazu gedrängt wurde, die Methoden und manchmal sogar den Ablauf für die Verwendung der API zu ändern.

Was passiert, wenn ich später Integrationstests und Unit-Tests geschrieben habe?

Ich habe exakten Fluss, gute Bedienbarkeit. Was ich auch habe, sind große Klassen, nicht kohärenter Code, keine Protokollierung, lange Methoden. Spaghetti-Code

Was ist mein Rat?

Ich habe folgenden Ablauf gelernt:

1. Entwickeln Sie das Grundgerüst Ihres Codes
2. Schreiben Sie Integrationstests, aus denen hervorgeht, ob dies aus Verbrauchersicht sinnvoll ist. Grundlegender Anwendungsfall ist fürs Erste ausreichend. Der Test funktioniert offensichtlich nicht.
3. Schreiben Sie Code zusammen mit Unit-Tests für jede Klasse.
4. Schreiben Sie den Rest / das Fehlen von Integrationstests. Es wäre besser, diesen Test innerhalb von # 3 zu implementieren, wie Sie Ihren Code verbessern.

Beachten Sie, dass ich eine kleine Präsentation über Unit- / Integrationstests gemacht habe (siehe Folie 21, in der das Skelett beschrieben wird).

Unit Tests werden verwendet, um das kleinstmögliche testbare Stück Software in einer Anwendung zu testen und deren Funktionalität zu testen. Jedes Gerät wird separat getestet, bevor es zu Teilen oder größeren Komponenten der Anwendung zusammengefügt wird.

Hier kommen Integrationstests ins Spiel :
Sie testen diese neu erstellten Teile, die aus den zuvor getesteten Einheiten bestehen, während sie diese Teile zusammenfügen. Am besten schreiben Sie die Tests an dieser Stelle, während Sie die Anwendung selbst schreiben.

Ich neige dazu, Integrationstests als sehr ähnlich wie Unit-Tests anzusehen. Dabei behandle ich eine Teilmenge des Codes als Black Box. Integrationstests sind also nur eine größere Kiste.

Ich ziehe es vor, sie vor dem Seriencode zu schreiben. Dies hat den Vorteil, dass ich mir merken kann, welche Teile ich noch nicht verkabelt habe oder dass ich ein Detail in der Objektinteraktion geringfügig geändert habe.

Abgesehen von Abnahmetests schreibe ich Integrationstests in der Regel nur an den Grenzen einer Anwendung, um zu überprüfen, ob sie sich gut in Systeme oder Komponenten von Drittanbietern integrieren lassen.

Die Idee ist, Adapterobjekte zu erstellen, die aus der Art und Weise übersetzen, wie der Dritte mit den Anforderungen Ihrer Anwendung spricht, und diese Übersetzer mit dem realen externen System zu testen. Ob du diesen Test zuerst oder den Test zuletzt machst, halte ich für weniger wichtig als bei deinen regulären Unit-Tests, weil

• Die von TDD bereitgestellten Erkenntnisse zum Design sind hier nicht so wichtig, da das Design im Voraus bekannt ist und in der Regel nichts besonders Komplexes involviert ist. Sie ordnen lediglich Dinge von einem System zu einem anderen zu.

• Abhängig von dem Modul / System, das Sie in Angriff nehmen möchten, kann es eine Menge Exploration, Konfigurationsbastelarbeiten und Probenvorbereitung erfordern, was Zeit in Anspruch nimmt und nicht wirklich gut in eine kurze TDD-Rückkopplungsschleife passt.

Wenn Sie sich jedoch wirklich wohler fühlen, wenn Sie Ihren Adapter schrittweise in kleinen, sicheren Schritten aufbauen, würde ich auf jeden Fall empfehlen, zuerst zu testen, da dies nicht schaden kann.

Beispiele für diesen Ansatz finden Sie hier: http://davesquared.net/2011/04/dont-mock-types-you-dont-own.html (6. Absatz) http://blog.8thlight.com/eric- smith / 2011/10/27 / thats-not-yours.html

Also wollte ich die erste Antwort akzeptieren, aber sie wurde gelöscht.
Um es
in einer gegebenen Iteration zusammenzufassen:

1. Unit-Test schreiben
2. Schreiben Sie den Seriencode
3. Schreiben Sie Integrationstests, um Interaktionen zu testen

Berücksichtigen Sie die Integrationstests 1 und 2, um die Testbarkeit auf der Integrationsebene zu gewährleisten.

Integrationstests werden nicht notwendigerweise von Ende zu Ende in Schritt 3 geschrieben. Sie können teilweise zwischen Schritt 1 und 2 geschrieben werden.

Unit-Tests testen einzelne Codeblöcke in Ihrem Projekt.
Integrationstests testen, wie Ihr Code mit anderem Code kommuniziert. Mit anderen Worten, sie testen die Schnittstelle Ihres Codes.

Schreiben Sie Unit-Tests, wenn Sie Code hinter einer Schnittstelle entwickeln.
Schreiben Sie Integrationstests, wenn Sie die Schnittstelle oder einen Code entwickeln, der die Schnittstelle implementiert.

Dies bedeutet, dass Sie Integrationstests manchmal sehr spät in einem Projekt schreiben, da der Großteil der Arbeit hinter der Benutzeroberfläche liegt: Zum Beispiel ein Compiler, ein bestimmter Webservice, der mehrere Logikebenen implementiert, oder ... etwas, das viel Aufwand mit sich bringt interne Logik.

Wenn Sie jedoch eine Reihe von REST-Services implementieren oder das Datenmodell umgestalten und Unterstützung für XA-Transaktionen hinzufügen, werden Sie fast sofort mit der Entwicklung von Integrationstests beginnen, da sich der größte Teil Ihrer Arbeit auf die Schnittstelle konzentriert, unabhängig davon, ob es sich um eine handelt die REST-API oder wie das Programm das Datenmodell verwendet.