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!