Automatiser le débogage en Git avec des tests unitaires

Les plats clés

• L'automatisation du débogage en GIT avec des tests unitaires implique l'utilisation de la commande «BISECT» pour traverser les validations et identifier celle qui a introduit un bogue. Ce processus peut être automatisé avec un script, réduisant le besoin d'étiquetage manuel des commits comme «bons» ou «mauvais».
• Les tests unitaires sont cruciaux dans ce processus, car ils sont exécutés pour chaque engagement pour déterminer si elle doit être attribuée comme «bonne» ou «mauvaise». Cela peut être fait en utilisant une commande comme «Git Bisect Run [Commande pour exécuter les tests]». Une fois les tests exécutés pour chaque engagement, GIT peut identifier l'engagement qui a introduit l'erreur.
• À mesure que la base de code augmente en taille, l'écriture de tests unitaires pour chaque morceau de code devient nécessaire. Bien que cela puisse sembler long au départ, il aide à déboguer et gagner du temps à long terme. Il est également possible de créer un script de shell personnalisé avec des codes de sortie personnalisés pour remplacer les tests unitaires.

Il y a quelque temps, j'ai publié un article sur le débogage d'une base de code dans GIT en utilisant deux commandes blâme et bissect. Git Blame a impliqué la vérification de l'auteur de chaque ligne d'un fichier, tandis que BISECT implique la traversée dans les validations (en utilisant la recherche binaire) pour trouver celle qui a introduit le bogue. Dans cet article, nous verrons comment automatiser le processus de bissect.

Pour rafraîchir votre mémoire, Git Bisect a impliqué quelques étapes, qui sont résumées ci-dessous:

• Démarrez l'assistant BISECT avec Git Bisect Start
• Sélectionnez «Good» et «Bad» Commits, ou Commits connus où le bogue était absent et présent, respectivement
• Attribuer des engagements à tester comme «bons» ou «mauvais» jusqu'à ce que Git découvre l'engagement qui a introduit le bug
• quitter l'assistant avec Git Bisect réinitialiser

Pour avoir une idée de l'ensemble du processus, vous pourriez jeter un coup d'œil à ce screencast, qui montre en détail le fonctionnement du processus de débogage.

Naturellement, la troisième étape a pris du temps - Git vous montrerait que vous engagez un par un et vous deviez les qualifier de «bon» ou «mauvais» après avoir vérifié si le bogue était présent dans cette validation.

Lorsque nous écrivons un script pour automatiser le processus de débogage, nous exécuterons essentiellement la troisième étape. Commençons!

mise en scène de l'environnement

Dans cet article, j'écrirai un petit module dans Python qui contient une fonction qui ajoute deux nombres. C'est une tâche très simple et je vais le faire à des fins de démonstration uniquement. Le code est explicite, donc je n'entrerai pas dans les détails.

<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>

Pour automatiser le processus de BISECT GIT, vous devez rédiger des tests pour votre code. Dans Python, nous utiliserons le module unittest pour écrire nos cas de test. Voici à quoi ressemble un test de base.

<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>

Nous pourrions écrire plus de ces tests, mais c'était juste pour démontrer comment continuer. En fait, vous devriez certainement écrire plus de cas de test car vos programmes et applications vont être beaucoup plus complexes que cela.

Pour exécuter les tests unitaires, exécutez le fichier tests.py contenant vos cas de test.

<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>

Si les tests passent, vous devez obtenir la sortie suivante.

présentons maintenant une erreur dans notre fonction et engageons le code.

python tests.py

Pour vérifier que les tests échouent, faisons-les à nouveau.

Ajoutons quelques commits de plus afin que le commit qui a introduit l'erreur ne soit pas le dernier.

Démarrez le processus de bissect

Pour l'assistant Git Bisect, nous sélectionnerons le dernier engagement en tant que mauvais (B60FE2CF35) et le premier comme bon (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>

À ce stade, Git nous souligne un engagement et nous demande s'il s'agit d'un bon ou d'un mauvais engagement. C'est à ce moment que nous disons à Git de faire les tests pour nous. La commande est comme suit.

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

Dans notre cas, il se révélera être le suivant.

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

Lorsque nous fournissons à Git la commande d'exécuter les tests lui-même, plutôt que de nous demander, Git exécute ces tests pour chaque révision et décide si le commit doit être attribué bon ou mauvais.

Une fois que Git a terminé des tests pour chaque engagement, il découvre quel commit a introduit l'erreur, comme la magie!

Une fois que vous avez trouvé votre engagement, n'oubliez pas de réinitialiser l'assistant avec la réinitialisation de Git Bisect.

À la place de vos tests unitaires, vous pouvez également créer un script de shell personnalisé avec des codes de sortie personnalisés. En général, un code de sortie de 0 est considéré comme un succès, tout le reste est un échec.

Réflexions finales

À mesure que la taille de votre base de code augmente, l'écriture de tests unitaires pour chaque petit morceau de code que vous écrivez devient nécessaire. Les tests d'écriture peuvent sembler longs, mais comme vous l'avez vu dans ce cas, ils vous aident à déboguer et à vous faire gagner du temps à long terme.

Comment votre équipe débogue-t-elle des erreurs dans le code? Faites-nous savoir dans les commentaires ci-dessous.

Questions fréquemment posées (FAQ) sur l'automatisation du débogage avec les tests unitaires git

Comment puis-je configurer le débogage automatisé avec des tests unitaires GIT?

La configuration de débogage automatisé avec des tests unitaires GIT implique plusieurs étapes. Tout d'abord, vous devez créer un référentiel GIT et l'initialiser. Ensuite, vous devez écrire vos tests unitaires à l'aide d'un framework de test compatible avec votre langage de programmation. Une fois vos tests écrits, vous pouvez utiliser un outil d'intégration continue (CI) pour automatiser le fonctionnement de ces tests. Cet outil peut être configuré pour exécuter vos tests chaque fois que vous poussez les modifications à votre référentiel GIT. De cette façon, vous pouvez attraper et corriger les bogues au début du processus de développement.

Quels sont les avantages de l'automatisation de débogage avec des tests unitaires GIT?

L'automatisation du débogage avec les tests unitaires GIT présente plusieurs avantages. Il aide à attraper des bogues au début du processus de développement, ce qui peut gagner du temps et des ressources. Il garantit également que toutes les parties de votre code sont testées de manière cohérente. Cela peut améliorer la qualité globale de votre code et la rendre plus fiable. De plus, il peut rendre votre processus de développement plus efficace en réduisant la quantité de tests manuels que vous devez effectuer.

Qu'est-ce que l'intégration continue (CI) et comment est-il lié aux tests unitaires GIT?

L'intégration continue (CI) est une pratique de développement où les développeurs intègrent fréquemment le code dans un référentiel partagé, généralement plusieurs fois par jour. Chaque intégration est ensuite vérifiée par une version automatisée et des tests automatisés. Dans le contexte des tests unitaires GIT, CI peut être utilisé pour automatiser l'exécution de ces tests à chaque fois que les modifications sont poussées vers le référentiel GIT. Cela aide à attraper les bogues tôt et garantit que toutes les parties du code sont testées de manière cohérente.

Comment puis-je rédiger des tests unitaires efficaces pour mon référentiel GIT?

Écrire des tests unitaires efficaces implique plusieurs meilleures pratiques . Premièrement, chaque test doit se concentrer sur une seule fonctionnalité ou comportement. Cela facilite l'identification de la cause de tout échec. Deuxièmement, les tests doivent être indépendants et en mesure d'exécuter dans n'importe quel ordre. Cela garantit que le résultat d'un test n'affecte pas le résultat d'une autre. Troisièmement, les tests doivent être reproductibles et donner les mêmes résultats à chaque fois qu'ils sont exécutés. Cela garantit que vos tests sont fiables et peuvent être fiables pour attraper des bogues.

Quels outils puis-je utiliser pour automatiser le débogage avec les tests unitaires GIT?

Il existe plusieurs outils que vous pouvez utiliser pour automatiser le débogage avec des tests unitaires GIT. Il s'agit notamment d'outils d'intégration continue (CI) comme Jenkins, Travis CI et Circleci. Ces outils peuvent être configurés pour exécuter vos tests unitaires chaque fois que vous poussez les modifications à votre référentiel GIT. De plus, vous pouvez utiliser des frameworks de test comme JUnit (pour Java), Pytest (pour Python) et Mocha (pour JavaScript) pour écrire vos tests unitaires.

Comment puis-je intégrer mes tests d'unité GIT avec un outil d'intégration continue (CI)?

L'intégration de vos tests d'unité GIT avec un outil d'intégration continue (CI) implique plusieurs étapes. Tout d'abord, vous devez configurer votre outil CI pour vous connecter à votre référentiel GIT. Ensuite, vous devez le configurer pour exécuter vos tests unitaires à chaque fois que les modifications sont poussées vers le référentiel. Cela implique généralement d'écrire un fichier de configuration qui spécifie les commandes pour exécuter les tests et les conditions dans lesquelles les exécuter.

Que dois-je faire si mes tests unitaires GIT échouent?

Si votre git Git Les tests unitaires échouent, la première étape consiste à identifier la cause de l'échec. Cela implique généralement d'examiner la sortie de test et le code qui a été testé. Une fois que vous avez identifié la cause, vous pouvez apporter les modifications nécessaires à votre code et relancer les tests. Si les tests passent, vous pouvez pousser vos modifications au référentiel GIT. S'ils échouent à nouveau, vous devrez peut-être réviser vos tests ou votre code jusqu'à ce qu'ils réussissent.

Puis-je automatiser le débogage avec des tests unitaires GIT pour n'importe quel langage de programmation?

Oui, vous pouvez automatiser le débogage avec des tests unitaires GIT pour tout langage de programmation. Cependant, les outils et techniques spécifiques que vous utilisez peuvent varier en fonction de la langue. La plupart des langages de programmation disposent d'un ou plusieurs cadres de test que vous pouvez utiliser pour rédiger vos tests unitaires. De plus, la plupart des outils d'intégration continue (CI) prennent en charge plusieurs langues et peuvent être configurés pour exécuter vos tests quelle que soit la langue dans laquelle ils sont écrits.

Comment puis-je m'assurer que mes tests d'unité GIT sont efficaces?

Assurer que vos tests d'unité GIT sont efficaces impliquent plusieurs meilleures pratiques. Tout d'abord, vos tests doivent couvrir toutes les parties de votre code, y compris les cas de bord. Cela garantit que vos tests sont complets. Deuxièmement, vos tests doivent être indépendants et en mesure d'exécuter dans n'importe quel ordre. Cela garantit que le résultat d'un test n'affecte pas le résultat d'une autre. Troisièmement, vos tests doivent être reproductibles et donner les mêmes résultats à chaque fois qu'ils sont exécutés. Cela garantit que vos tests sont fiables.

Puis-je utiliser des tests unitaires GIT pour tester l'interface utilisateur (UI) de mon application?

Les tests unitaires GIT sont généralement utilisés pour tester les fonctionnalités de votre Code, pas l'interface utilisateur (UI) de votre application. Cependant, vous pouvez utiliser d'autres types de tests, tels que des tests d'intégration ou des tests de bout en bout, pour tester votre interface utilisateur. Ces tests peuvent également être automatisés et s'exécuter à l'aide d'un outil d'intégration continue (CI). Cela peut aider à attraper des bogues dans votre interface utilisateur au début du processus de développement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!