Ein Kollege von mir hatte eine Idee, die ich interessant fand.

Wäre es nicht vorteilhaft, Tests während der Codeüberprüfung zu schreiben, wenn die Person, die die Überprüfung durchführt, davon ausgeht, dass wir keine TDD durchführen?

Bei dieser Frage wird davon ausgegangen, dass es sich um ein rein akademisches Projekt handelt, sodass kein Leben auf dem Spiel steht. Außerdem besteht das Team aus 4 Personen. Jeder kennt die Sprache und ist mit allen verwendeten Tools / Bibliotheken / Frameworks vertraut und kann Tests schreiben. Im Grunde genommen führen Leute, die keine hochrangigen Fullstack-Ingenieure sind, Ninja-Ingenieure, sondern anständige Programmierer.

Vorteile, die ich gefunden habe:

1. Ermutigt zu einem tieferen Verständnis des Codes während der Überprüfung, um aussagekräftige Tests zu schreiben.
2. Sie können dann eine Codeüberprüfung der Tests hinzufügen, die vom Autor des getesteten Codes durchgeführt wurden.

Nachteile, die ich gefunden habe:

1. Die Rückkopplungsschleife zwischen dem Schreiben von Code und dem Testen wächst.

EDIT: Ich weiß, dass es auf "normalen" Webanwendungen nicht gut funktioniert. Was ich im Sinn hatte, war ein Eckfall, in dem Sie komplexe wissenschaftliche Algorithmen implementieren, bei denen auf die Details geachtet werden muss. Nehmen wir an, wir implementieren meine eigene Grafikbibliothek, NLP usw. Ich frage mich, ob der von uns geschriebene Code von Datenbanken isoliert ist und nicht die zusätzliche Kontrolle, die andere Person, die die Quelle verstehen muss Code und sinnvolle Tests machen den gesamten Prozess weniger anfällig für diese weniger offensichtlichen Fehler, die die Anwendung nicht zum Absturz bringen, aber letztendlich Ihre Ergebnisse zum Blödsinn machen?

Wäre es nicht vorteilhaft, Tests während der Codeüberprüfung durch die Person zu schreiben, die die Überprüfung durchführt?

Ich habe festgestellt, dass eine gute Zeit zum Schreiben von Tests ist, wenn Sie feststellen, dass Sie einen Test für eine Situation benötigen.

Das Wechseln von Aufgaben für Computer ist teuer - noch mehr für den Menschen.

Zu diesem Zeitpunkt haben Sie im Allgemeinen ein gutes Verständnis der Anforderungen und Abhängigkeiten für den Test. Nutzen Sie also das Eintauchen Ihres Teams in das Problem. Wenn Sie Ihren neuen Test in Zukunft verfeinern müssen, haben Sie das Test-Framework / die Fixtures bereits installiert, und Sie müssen nur den Teil ändern, der verbessert werden muss.

Wenn dies während der Codeüberprüfung passiert, warum nicht weitermachen? Ich habe das schon mal gemacht. Ich habe festgestellt, dass es besser ist als nicht, vor allem, wenn Sie es schnell tun können, und noch besser, wenn Sie es sonst nicht getan hätten.

Angenommen, wir machen keine TDD?

Auch wenn Sie TDD üben, wenn Sie feststellen, dass Sie während der Codeüberprüfung einen Test benötigen, einen, den Sie nicht haben, warum schreiben Sie den Test dann nicht hierher?

Vorteile

• Sie konzentrieren sich auf den zu überprüfenden Code.
• Manchmal wird die Codeüberprüfung zum Hangout und zur Chat-Zeit, wenn die Leute nicht daran interessiert sind. Das Schreiben eines Tests ermutigt alle, aktiver über den zu überprüfenden Code nachzudenken.
• Weitere Junior-Mitglieder des Teams haben die Möglichkeit, aus den Erfahrungen mit dem Schreiben von Tests zu lernen.
• Sie können Talente in Ihrem Team identifizieren, von denen Sie nicht wussten, dass Sie sie haben.

Ist es wirklich ein Nachteil, dass mehr Tests zu mehr Code führen können? Wenn der Test benötigt wurde und der Code für den Test benötigt wurde und Sie ihn jetzt haben, ist das eine gute Sache.

Vorbehalte

Vielleicht muss sich ein Teil des Teams auf andere Dinge konzentrieren. Wenn dies zu einer Ablenkung der Prioritäten führt oder Ihre Codeüberprüfung über den Zeitplan hinausgeht, müssen Sie das tatsächliche Schreiben des Tests einschränken oder ausschließen. Die Codeüberprüfung kann jedoch mit Sicherheit Tests identifizieren, die geschrieben werden müssen, und sie können möglicherweise zumindest ausgeblendet werden, damit der Schreiber sie später ausführen kann.

Dies ist eine wunderbare Idee, mit einer Einschränkung. Ersetzen Sie keine vom Entwickler geschriebenen Tests durch vom Prüfer geschriebene Tests. Lassen Sie Ihre Prüfer nach Eckfällen und Eingaben suchen, die den Code sprengen. Mit anderen Worten, lassen Sie sie versuchen, neue Tests zu schreiben , an die der ursprüngliche Entwickler nicht gedacht hat.

Das Schreiben von Charakterisierungstests ist eine wunderbare Möglichkeit, einen Code zu verstehen, den Sie nicht geschrieben haben. Wenn Ihre Prüfer zusätzliche Tests am Code durchführen, können sie besser verstehen, wie der Code funktioniert, wie er beschädigt werden kann und wie er verbessert werden kann. Währenddessen erhöhen Sie Ihre Code-Abdeckung.

Dies sind alles Gewinne in meinem Buch.

Ich denke nicht, dass die Idee völlig unbegründet ist - der Hauptvorteil von TDD et al. Ist jedoch, dass Probleme frühzeitig gefunden werden . Der Entwickler kann außerdem am besten erkennen, welche Eckfälle besondere Aufmerksamkeit erfordern. Wenn dies bis zur Codeüberprüfung verbleibt, besteht die Gefahr, dass dieses Wissen verloren geht.

Das Schreiben von Tests während der Codeüberprüfung würde unter demselben Problem leiden wie das herkömmliche manuelle Testen - das Verständnis der Geschäftsregeln kann von Entwickler zu Entwickler unterschiedlich sein, ebenso wie die Sorgfalt.

Es gibt auch eine uralte Diskussion darüber, ob Entwickler ihren Code so gut testen würden, wenn sie wüssten, dass es eine Testfunktion weiter oben gibt, die die schwerwiegenderen Fehler abfängt.

Ich stimme der Antwort von @ RobbieDee zu, aber ich muss noch etwas hinzufügen.

Wenn Ihnen diese Idee wirklich gefällt, warum lassen Sie nicht dieselben Personen die Tests vor dem Code als ausführbare Akzeptanzkriterien für die User Story schreiben?

Das würde dasselbe tun, aber das Feedback kurz halten und alle dazu bringen, eine Diskussion über die Geschichte zu führen, was meiner Meinung nach von größerem Wert wäre.

Die Nachteile sind die Gefahr eines endlosen Zusammentreffens der Zulassungskriterien :-( und ich denke, Sie versuchen, die Leute in die Codeüberprüfung zu bringen, um einen Blick auf den Implementierungscode zu werfen, aber ich würde Paarprogrammierung und Paardrehung als bessere Lösung vorschlagen dieses Problem.

Das OP fügte eine Bearbeitung hinzu, in der weitere Details zu dieser schwierigen oder algorithmischen Funktion angezeigt werden.

Als Antwort darauf möchte ich hinzufügen, dass Ihr Instinkt, mehr Augen auf das Problem und die Lösung zu werfen, gut ist. Koppeln Sie sich möglicherweise mit mehreren Personen, bis alle die wirklich schwierigen Implementierungscodes und -tests kennen. Jedes davon bringt neue Ideen hervor und steigert den Wert.

Es gibt eine Idee, die manchmal Mob-Programmierung nennt, wie Pairing, aber mit mehr Leuten. Das ist fast das, worüber Sie sprechen, aber sie helfen zum Zeitpunkt des Schreibens und nicht bei einer formellen Überprüfung danach. Dies ist nicht jedermanns Sache und kann einen starken Fahrer (Anführer) oder ein Team erfordern, das sich mit einander und dem Prozess sehr gut auskennt.

Das Mob-Programmieren nach der Tat zu machen, hätte vermutlich viele der gleichen Vorteile, da viele das Problem sehen und Verbesserungen vorschlagen. Wenn Ihr Team sich so wohl fühlt, dann kann das helfen, aber ich würde wirklich versuchen, das Notwendige beizubehalten Vorkommen davon auf ein Minimum, da ich denke, dass es das Team verlangsamen könnte.

Wie Sie sagen, wenn Sie ein TDD-Team leiten, ist dies umstritten, da der Code bereits getestet werden sollte.

Insgesamt halte ich das nicht für eine großartige Idee, aber es hängt von Ihrem aktuellen Ansatz ab und davon, was für Sie funktioniert. Grundsätzlich ist das Problem, das ich sehe, dass Sie den Vorteil der "kurzen Rückkopplungsschleife" von Tests verlieren. In dem Moment, in dem Sie etwas kaputt machen, während Sie neuen Code schreiben, werden Sie sofort benachrichtigt. Wenn Sie das Testen auf die Codeüberprüfung verschieben, sagen Sie im Grunde: "Nun, wir KÖNNTEN dieses Problem früher in kürzerer Zeit und mit weniger involvierten Personen beheben, aber zumindest haben wir alle (vielleicht) etwas gelernt." Ich würde es vorziehen, nur sicherzustellen, dass die Leute den getesteten Code zur Überprüfung einreichen, und dann beurteilen Sie die Richtigkeit und Wartbarkeit der Tests. Schließlich dient die Codeüberprüfung zum Überprüfen und nicht zum Schreiben von Code.

Auf der anderen Seite empfehle ich Ihnen, mit den Tests / Code während der Überprüfung FIDDLE. Versuche etwas zu zerbrechen. Kommentieren Sie eine if-Bedingung aus. Ersetzen Sie einen Booleschen Wert durch ein wahres / falsches Wort. Überprüfen Sie, ob die Tests fehlschlagen.

Aber ja, alles in allem empfehle ich Ihnen, Ihre Tests zusammen mit Ihrem Code zu schreiben und dann alles auf einmal zu überprüfen.

Es hängt davon ab, was Sie bei der Codeüberprüfung tun. Ich denke, es gibt zwei Hauptgründe, um Tests zu schreiben:

• Fügen Sie erstens solche Tests hinzu, wenn Sie während der Codeüberprüfung auch Refactoring durchführen und feststellen, dass nicht genügend Komponententests vorhanden sind, um die Art von Refactoring abzudecken, die Sie anwenden möchten

• Zweitens: Wenn der Code für Sie so aussieht, als hätte er einen Fehler, und Sie möchten, dass er dies beweist (oder widerlegt), schreiben Sie einen Test dafür

In beiden Fällen sind Tests erforderlich, die derzeit nicht vorhanden sind, aber vorhanden sein sollten. Natürlich kann es von Ihrer Teamkultur abhängen, ob diese Art von Tests vom Rezensenten oder vom Originalautor geschrieben werden, aber jemand sollte die Tests schreiben.

Eigentlich glaube ich nicht, dass dies "ein Eckfall" ist, der nur für "komplexe, wissenschaftliche Algorithmen" geeignet ist - im Gegenteil, dies ist für jede Art von Software geeignet, von der Sie ein gewisses Maß an Qualität erwarten.

Nein, tu es nicht. Sie werden sie denken lassen, TDD sei schrecklich.

Ich denke @ k3b hat es richtig in den Kommentaren zur Frage. Code, der mit einem TDD-ähnlichen Verfahren geschrieben wurde, sieht anders aus und interagiert anders als Code, der ohne Tests geschrieben wurde. Das Hinzufügen von (guten) Tests zu ungetestetem Code erfordert in der Regel eine gründliche Überarbeitung des Codes, um seine Absichten und beweglichen Teile zu verdeutlichen.

Wenn Sie die Tests nach dem Schreiben des Codes hinzufügen, übersehen Sie die architektonischen Aspekte der Vorteile von TDD (die meiner Meinung nach einer der Hauptvorteile sind). Darüber hinaus bitten Sie jemanden, der mit dem Code bei weitem nicht so vertraut ist, Tests hinzuzufügen, die sich bereits als schwierig erweisen.

Entweder muss die Person, die Tests hinzufügt, den Code erheblich überarbeiten, oder sie muss sehr hart arbeiten, um nicht testbaren Code zu testen. In jedem Fall werden sie die Erfahrung nicht genießen. Auch wenn dies keine klassische TDD ist, werden sie es nicht so sehen, und Sie können sie ein für alle Mal aus der Hand legen.

(Wenn Sie bereits einem TDD-Prozess folgen, ist das Schreiben zusätzlicher Tests während der Codeüberprüfung weniger schädlich, obwohl es meiner Erfahrung nach genauso einfach ist, der Person, die den Test einreicht, den zusätzlichen Test zu erklären, wenn die Tests bereits gut geschrieben sind Code zur Überprüfung und lassen Sie sie schreiben.)

Unit-Tests während der Codeüberprüfung sind ein schlechter Ersatz für Unit-Tests während der Entwicklung.

Was Sie vorschlagen, ist intuitiv sehr sinnvoll. Wofür ist die Rezension? Um zu überprüfen, ob der Code gut ist. Wofür sind Tests? Um zu überprüfen, ob der Code gut ist. Warum also nicht beides kombinieren?

Hier ist der Grund.

Das Testen von Code ist harte Arbeit. Das Schreiben von Code, der nur bei der einen Sache funktioniert, die er tun soll, ist eine Sache; Ein weiterer Grund ist das Schreiben von Code, der effektiv und effizient getestet werden kann. Allein die Tatsache, dass der Code jetzt in zwei Szenarien ausgeführt wird - "echte Arbeit" und "Test" - erfordert eine viel größere Flexibilität und erfordert, dass dieser Code in der Lage ist, auf sinnvolle Weise für sich selbst zu stehen.

Den Code so zu schreiben, dass er prüfbar ist, erfordert zusätzliche Arbeit und Geschicklichkeit. Es kann eine große Aufgabe sein, den Code eines anderen für die Testbarkeit umzugestalten, wenn dies nicht im Hinblick auf die Testbarkeit geschrieben wurde.

Sie duplizieren den Aufwand zwischen dem Entwickler und dem Prüfer. Vermutlich reicht Ihr Entwickler seinen Code nicht zur Überprüfung ein, ohne zumindest ein gewisses Maß an Sicherheit zu haben, dass er funktioniert. Er muss den Code bereits testen. Jetzt gibt es verschiedene Teststufen und -bereiche. QA testet den Code nach dem Entwickler und dem Prüfer. Aber was auch immer Umfang Sie denken , ist für den Entwickler und Reviewer, macht es keinen Sinn für den Entwickler, um herauszufinden , wie Sie den Code zu testen , um dieses Niveau einmal , sondern macht seine Tests Wegwerf und schwer zu reproduzieren, und dann brachte in dem Rezensenten zu Test erneut entwickelnDiesmal solche, die automatisiert und reproduzierbar sind. Sie müssen nur beide Zeit investieren, um dieselben Tests zu schreiben - einmal schlecht, einmal gut.

Sie verwandeln die Überprüfung in einen viel längeren und mühsameren Schritt. Wenn das Testen einen großen Teil des Überprüfungsprozesses ausmacht, was passiert, wenn einige Tests fehlschlagen ? Ist die Prüferin dafür verantwortlich, dass alle Tests ausgeführt werden, sodass sie auch den Code debuggen muss? Oder wird es ein Ping-Pong sein, der eine schreibt Tests, der andere bringt sie zum Bestehen?

Manchmal können Sie eine ganze Reihe von Tests schreiben, die alle orthogonal zueinander sind, sodass Sie kein Ping-Pong benötigen. Der Prüfer schreibt ein Dutzend Tests, von denen die Hälfte fehlschlägt, der Entwickler behebt die Fehler und alle Tests bleiben gültig und bestehen. Aber ... oft haben Sie Blocker-Bugs oder Bugs, die ein Redesign und API-Änderungen erfordern, oder so weiter. Wenn Sie die Verantwortung für das Hin- und Herschieben von Tests zwischen Prüfer und Entwickler übernehmen, befinden Sie sich nicht in der Prüfungsphase. Du entwickelst dich noch.

Das Schreiben von Tests ist kein Anreiz für eine gründlichere Überprüfung. Im Grunde bedeutet dies, dass je tiefer Sie gehen, desto mehr Tests müssen Sie schreiben, und wahrscheinlich handelt es sich dabei um harte Tests, die tief in das System eindringen müssen.

Vergleichen Sie dies mit dem Entwickler, der die Tests erstellt, wo sein Anreiz lautet: Wenn ich keine wichtigen Tests schreibe, weist der Prüfer in der Überprüfung darauf hin.

Sogar der Prüfer hat ein viel besseres Verständnis des Systems, wenn er den Code gründlich testen muss, und wenn er selbst entscheiden muss, wann er aufhören kann, einen Deep-Digging-Test zu schreiben, und die Code-Überprüfung einfach in Ordnung bringen muss.

Wenn der Entwickler keine Komponententests schreibt, wird der Prüfer dies auch nicht tun. Es gibt viele Hindernisse für die Annahme von Tests als gängige Praxis. Vielleicht stehen Sie unter zu viel Druck und Ihre Codebasis ist schwer zu testen. Vielleicht sind Sie nicht so erfahren im Testen und haben das Gefühl, dass Sie sich die Lernkurve nicht leisten können. Vielleicht haben Sie einen Axtmörder, der Leuten, die Tests schreiben, Drohnotizen schickt. Ich weiß es nicht!

Aber was auch immer die Ursache ist, es ist sicher zu wetten, dass es gleichermaßen für den Rezensenten und für den Entwickler gilt. Wenn das Team gestresst ist, hat der Prüfer nicht mehr Zeit als der Entwickler (wenn dies der Fall ist, verteilen Sie die Arbeit neu, damit die Leute nicht so gestresst sind ). Wenn niemand weiß, wie man Komponententests gut schreibt, tut dies die Prüferin wahrscheinlich auch nicht (wenn dies der Fall ist, sollte sie sich hinsetzen und ihre Teamkollegen unterrichten ).

Dieser Vorschlag klingt wie der Versuch, das Geld von einem Kollegen an einen anderen weiterzugeben. Und ich sehe einfach keine Möglichkeit, dass das gut funktioniert, vor allem, weil es wirklich schwierig (und ungesund) ist, eine Situation zu schaffen, in der nur eine Person testen kann und eine andere Person nicht irgendwelche Tests überhaupt.

Was funktioniert , ist, dass die Überprüfung auch die Tests abdeckt. Wenn der Entwickler bereits zehn Tests geschrieben hat, ist es viel wahrscheinlicher, dass der Prüfer weitere zehn vorschlagen kann, als wenn der Entwickler keine geschrieben hätte.

Und wenn das Testen von Eckfällen eine wichtige Aufgabe ist, ist es möglicherweise sinnvoll, dies auf das gesamte Team zu verteilen. ** Wenn der Code erst einmal getestet werden kann, wird das Schreiben weiterer Tests viel einfacher. **

Überprüfung ist eine gute Zeit, um Eckfälle zu erkennen . Und wenn die Rezensentin einspringen und einen Test für Eckfälle schreiben kann, die sie findet, dann hey - umso besser! Aber im Allgemeinen unter der Annahme, dass der Prüfer Tests schreiben kann, bei denen der Entwickler nicht nach einer sehr schlechten Idee klang.