Automatisieren Sie das Debuggen in Git mit Unit -Tests

Key Takeaways

• Automatisierung des Debuggens in Git mit Unit -Tests beinhaltet die Verwendung des Befehls "halbiert", um durch die Commits zu durchlaufen und denjenigen zu identifizieren, der einen Fehler eingeführt hat. Dieser Vorgang kann mit einem Skript automatisiert werden, wodurch die Bedarf an manueller Kennzeichnung von Commits als „gut“ oder „schlecht“ erforderlich ist.
• Unit -Tests sind in diesem Prozess von entscheidender Bedeutung, da sie für jedes Verpflichtung durchgeführt werden, um festzustellen, ob sie als „gut“ oder „schlecht“ zugeordnet werden sollten. Dies kann mit einem Befehl wie "Git Halbiers -Lauf [Befehl zum Ausführen von Tests]" erfolgen. Sobald die Tests für jedes Commit durchgeführt werden, kann Git das Commit identifizieren, das den Fehler eingeführt hat.
• Wenn die Codebasis an Größe zunimmt, wird das Schreiben von Unit -Tests für jedes Code -Stück erforderlich. Während es anfangs zeitaufwändig erscheint, hilft es beim Debuggen und spart auf lange Sicht Zeit. Es ist auch möglich, ein benutzerdefiniertes Shell -Skript mit benutzerdefinierten Exit -Codes zu erstellen, um Unit -Tests zu ersetzen.

Vor einiger Zeit habe ich einen Artikel über das Debuggen einer Codebasis in Git unter Verwendung von zwei Befehlen Schuld und Halbier veröffentlicht. Git beschuldigte die Überprüfung des Autors jeder Zeile einer Datei, während BISECT das Durchlaufen der Commits (Verwendung von Binärsuche) beinhaltet, um den einen zu finden, der den Fehler eingeführt hat. In diesem Beitrag werden wir sehen, wie der halbierende Prozess automatisiert wird.

Um Ihr Gedächtnis zu aktualisieren, umfasste Git -Halbzeit einige Schritte, die unten zusammengefasst sind:

• Starten Sie den Halbzeit -Assistenten mit Git BISECT START
• Wählen Sie „gut“ und „schlechte“ Commits oder bekannte Commits, bei denen der Fehler abwesend war und vorhanden ist
• Zuweisen Sie, dass Commits als „gut“ oder „schlecht“ getestet werden, bis Git das Commit herausfindet, das den Fehler eingeführt hat
• Beenden Sie den Assistenten mit Git -Halbektor -Reset

Um eine Vorstellung vom gesamten Prozess zu bekommen, können Sie sich diesen Screencast ansehen, der ausführlich zeigt, wie der Debugging -Prozess funktioniert.

Natürlich war der dritte Schritt zeitaufwändig - Git würde zeigen, dass Sie nacheinander voneinander beginnen, und Sie mussten sie als „gut“ oder „schlecht“ bezeichnen, nachdem Sie überprüft hatten, ob der Fehler in diesem Commit vorhanden war.

Wenn wir ein Skript schreiben, um den Debugging -Prozess zu automatisieren, werden wir im Grunde den dritten Schritt ausführen. Fangen wir an!

Inszenierung der Umgebung

In diesem Beitrag werde ich ein kleines Modul in Python schreiben, das eine Funktion enthält, die zwei Zahlen hinzufügt. Dies ist eine sehr einfache Aufgabe und ich werde dies nur für Demonstrationszwecke tun. Der Code ist selbsterklärend, daher werde ich nicht in Details eingehen.

<span>#add_two_numbers.py
</span>def add_two_numbers<span>(a, b):
</span>    <span>'''
</span>        Function to <span>add two numbers
</span>    <span>'''
</span>    addition <span>= a + b
</span>    <span>return addition</span>

Um den Prozess der Git -Halbzeit zu automatisieren, müssen Sie Tests für Ihren Code schreiben. In Python werden wir das unittestes Modul verwenden, um unsere Testfälle zu schreiben. So sieht ein grundlegender Test aus.

<span>#add_two_numbers.py
</span>def add_two_numbers<span>(a, b):
</span>    <span>'''
</span>        Function to <span>add two numbers
</span>    <span>'''
</span>    addition <span>= a + b
</span>    <span>return addition</span>

Wir konnten mehr dieser Tests schreiben, aber dies war nur, um zu demonstrieren, wie man damit weitergeht. Tatsächlich sollten Sie auf jeden Fall mehr Testfälle schreiben, da Ihre Programme und Apps weitaus komplexer werden.

Um die Unit -Tests auszuführen, führen Sie die Tests.Py -Datei mit Ihren Testfällen aus.

.

<span>#tests.py
</span><span>import unittest
</span>from add_two_numbers <span>import add_two_numbers
</span>
class TestsForAddFunction<span>(unittest.TestCase):
</span>
    def test_zeros<span>(self):
</span>        result <span>= add_two_numbers(0, 0)
</span>        self.assertEqual<span>(0, result)
</span>
<span>if __name__ == '__main__':
</span>    unittest.main<span>()</span>

Wenn die Tests bestehen, sollten Sie die folgende Ausgabe erhalten.

Lassen Sie uns nun einen Fehler in unserer Funktion einführen und den Code festlegen.

python tests.py

Um zu überprüfen, ob die Tests fehlschlagen, lassen Sie uns sie erneut ausführen.

Lassen Sie uns ein paar weitere Commits hinzufügen, damit das Commit, der den Fehler eingeführt hat, nicht der letzte ist.

Starten Sie den Halbzeitprozess

Für den Git -BISECT -Assistenten werden wir das neueste Komitee als schlecht auswählen (B60FE2CF35) und den ersten als gut (98D9DF03B6).

def add_two_numbers<span>(a, b):
</span>    <span>'''
</span>        Function to <span>add two numbers
</span>    <span>'''
</span>    addition <span>= a + 0
</span>    <span>return addition</span>

Zu diesem Zeitpunkt verweist Git uns zu einem Commit und fragt uns, ob es sich um ein gutes oder ein schlechtes Commit handelt. Dies ist der Zeitpunkt, an dem wir Git sagen sollen, die Tests für uns durchzuführen. Der Befehl dafür ist wie folgt.

<span>git bisect start b60fe2cf35 98d9df03b6</span>

In unserem Fall wird es sich herausstellen.

<span>git bisect run [command to run tests]</span>

Wenn wir Git den Befehl zur Ausführung der Tests selbst zur Verfügung stellen, anstatt uns zu fragen, führt Git diese Tests für jede Revision aus und entscheidet, ob das Commit gut oder schlecht zugewiesen werden sollte.

Sobald Git durchgeführt wird, um Tests für jedes Commit auszuführen, wurde herausgefunden, welches Commit den Fehler wie Magic! eingeführt hat

Wenn Sie Ihr Commit gefunden haben, vergessen Sie nicht, den Assistenten mit Git -Halbektion zurückzusetzen.

Anstelle Ihrer Unit -Tests können Sie auch ein benutzerdefiniertes Shell -Skript mit benutzerdefinierten Exit -Codes erstellen. Im Allgemeinen wird ein Exit -Code von 0 als Erfolg angesehen, alles andere ist ein Fehler.

endgültige Gedanken

Wenn die Größe Ihrer Codebasis zunimmt, wird das Schreiben von Unit -Tests für jeden kleinen Code, den Sie schreiben, notwendig. Das Schreiben von Tests mag zeitaufwändig erscheinen, aber wie Sie in diesem Fall gesehen haben, helfen sie Ihnen beim Debuggen und sparen Sie auf lange Sicht Zeit.

Wie debug Ihre Teamfehler im Code? Lassen Sie uns in den Kommentaren unten wissen.

häufig gestellte Fragen (FAQs) zur Automatisierung des Debuggens mit Git -Unit -Tests

Wie kann ich automatisiertes Debuggen mit Git -Unit -Tests einrichten? Zunächst müssen Sie ein Git -Repository erstellen und initialisieren. Anschließend müssen Sie Ihre Unit -Tests mit einem Test -Framework schreiben, das mit Ihrer Programmiersprache kompatibel ist. Sobald Ihre Tests geschrieben sind, können Sie ein Continuous Integration (CI) -Tool verwenden, um das Ausführen dieser Tests zu automatisieren. Dieses Tool kann so konfiguriert werden, dass Sie Ihre Tests jedes Mal ausführen, wenn Sie Änderungen in Ihr Git -Repository drücken. Auf diese Weise können Sie zu Beginn des Entwicklungsprozesses Fehler fangen und beheben. Es hilft, zu Beginn des Entwicklungsprozesses Fehler zu erfassen, die Zeit und Ressourcen sparen können. Es stellt auch sicher, dass alle Teile Ihres Codes konsequent getestet werden. Dies kann die Gesamtqualität Ihres Codes verbessern und ihn zuverlässiger machen. Darüber hinaus kann es Ihren Entwicklungsprozess effizienter gestalten, indem die Menge an manuellen Tests, die Sie durchführen müssen, reduziert. > Continuous Integration (CI) ist eine Entwicklungspraxis, in der Entwickler Code häufig in ein gemeinsames Repository integrieren, normalerweise mehrmals pro Tag. Jede Integration wird dann durch ein automatisiertes Build und automatisierte Tests verifiziert. Im Zusammenhang mit Git -Unit -Tests kann CI verwendet werden, um das Ausführen dieser Tests jedes Mal zu automatisieren, wenn Änderungen in das Git -Repository gedrückt werden. Dies hilft, Fehler frühzeitig zu fangen und stellt sicher, dass alle Teile des Codes konsequent getestet werden.

Wie kann ich effektive Unit -Tests für mein Git -Repository schreiben? . Zunächst sollte sich jeder Test auf eine einzelne Funktionalität oder ein einzelnes Verhalten konzentrieren. Dies erleichtert die Ermittlung der Ursache von Fehlern. Zweitens sollten Tests unabhängig sein und in jeder Reihenfolge laufen können. Dies stellt sicher, dass das Ergebnis eines Tests das Ergebnis eines anderen nicht beeinflusst. Drittens sollten die Tests wiederholbar sein und jedes Mal, wenn sie ausgeführt werden, dieselben Ergebnisse liefern. Dies stellt sicher, dass Ihre Tests zuverlässig sind und vertrauenswürdig sind, um Fehler zu fangen. mit Git -Unit -Tests. Dazu gehören Tools (Continuous Integration) wie Jenkins, Travis CI und Circleci. Diese Tools können so konfiguriert werden, dass Sie Ihre Unit -Tests jedes Mal ausführen, wenn Sie Änderungen in Ihr Git -Repository weitergeben. Darüber hinaus können Sie Test -Frameworks wie JUNIT (für Java), PyTest (für Python) und Mocha (für JavaScript) verwenden, um Ihre Unit -Tests zu schreiben.

Wie kann ich meine Git -Unit -Tests in ein Continuous Integration -Tool (CI) integrieren? Zunächst müssen Sie Ihr CI -Tool so konfigurieren, dass Sie eine Verbindung zu Ihrem Git -Repository herstellen. Anschließend müssen Sie es so konfigurieren, dass Ihre Einheitstests jedes Mal, wenn Änderungen auf das Repository gedrückt werden. Dies beinhaltet normalerweise das Schreiben einer Konfigurationsdatei, die die Befehle für die Ausführung der Tests und die Bedingungen angibt, unter denen sie ausgeführt werden sollen. Unit -Tests scheitern, der erste Schritt besteht darin, die Ursache des Fehlers zu identifizieren. Dies beinhaltet normalerweise die Untersuchung der Testausgabe und des getesteten Codes. Sobald Sie die Ursache identifiziert haben, können Sie die erforderlichen Änderungen an Ihrem Code vornehmen und die Tests erneut ausführen. Wenn die Tests bestehen, können Sie Ihre Änderungen in das Git -Repository weitergeben. Wenn sie erneut scheitern, müssen Sie möglicherweise Ihre Tests oder Ihren Code überarbeiten, bis sie bestanden haben. mit Git -Unit -Tests für jede Programmiersprache. Die spezifischen Werkzeuge und Techniken, die Sie verwenden, können jedoch je nach Sprache variieren. Die meisten Programmiersprachen verfügen über ein oder mehrere Test -Frameworks, mit denen Sie Ihre Unit -Tests schreiben können. Darüber hinaus unterstützen die meistkontinuierlichen Integrations -Tools (CETUTOR INTEGRATIONS) mehrere Sprachen und können so konfiguriert werden, dass Sie Ihre Tests unabhängig von der Sprache ausführen, in der sie geschrieben sind.

Wie kann ich sicherstellen, dass meine Git -Unit -Tests effektiv sind?

Sicherstellen, dass Ihre Git -Unit -Tests wirksam sind, beinhaltet mehrere Best Practices. Erstens sollten Ihre Tests alle Teile Ihres Codes, einschließlich Kantenfälle, abdecken. Dies stellt sicher, dass Ihre Tests umfassend sind. Zweitens sollten Ihre Tests unabhängig sein und in jeder Reihenfolge ausgeführt werden. Dies stellt sicher, dass das Ergebnis eines Tests das Ergebnis eines anderen nicht beeinflusst. Drittens sollten Ihre Tests wiederholbar sein und jedes Mal die gleichen Ergebnisse liefern, wenn sie ausgeführt werden. Dies stellt sicher, dass Ihre Tests zuverlässig sind. Code, nicht die Benutzeroberfläche (Benutzeroberfläche) Ihrer Anwendung. Sie können jedoch andere Arten von Tests wie Integrationstests oder End-to-End-Tests verwenden, um Ihre Benutzeroberfläche zu testen. Diese Tests können auch automatisiert und mit einem Continuous Integration (CI) Tool ausgeführt werden. Dies kann dazu beitragen, zu Beginn des Entwicklungsprozesses Fehler in Ihrer Benutzeroberfläche zu fangen.

Das obige ist der detaillierte Inhalt vonAutomatisieren Sie das Debuggen in Git mit Unit -Tests. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!