La révision du code doit-elle être effectuée avant ou après les tests unitaires

Je discute avec mon collègue du moment de la révision du code - avant ou après les tests unitaires. Quelle est la meilleure pratique?

Certains facteurs dont nous pourrions avoir besoin de prendre en compte (il peut y en avoir plus):

• Taille du changement de code - un grand changement signifie que plus de changements résulteront de la révision du code. Si ces modifications sont importantes, si l'UT était avant la révision du code, vous devrez répéter la plupart de vos UT à nouveau.
• Temps requis pour effectuer le test unitaire
• Est-ce une nouvelle fonctionnalité ou une correction de bogue

Vous devriez toujours tester les unités avant de passer en revue le code et voici pourquoi

1. Si votre code est cassé d'une manière qui serait détectée par les tests unitaires, vous perdrez le temps de l'autre développeur en les faisant participer au cycle rouge / vert / refactor.
2. Les tests montrent aux autres développeurs l'utilisation prévue du code, ce qui facilite sa révision.
3. Les tests doivent être examinés avec le code testé au cas où vous manquez des cas de test ou si vos tests ne fonctionnent pas correctement.
4. Les tests et la révision de code ont tendance à détecter différents problèmes avec seulement un petit chevauchement des problèmes détectés. Les tests unitaires ne sont pas ennuyés de devoir retester le code lorsque le réviseur trouve des problèmes, les développeurs sont ennuyés et ne le feront probablement pas aussi bien la deuxième fois.

Il y a probablement d'autres raisons, mais ce sont celles que j'ai personnellement vues et expérimentées après avoir mis en œuvre des pratiques de révision de code au sein de 3 équipes / entreprises différentes.

Modifier Bien sûr, ce qui précède concerne les moments où la révision de code est une étape de votre processus de développement logiciel (que ce soit en cascade ou agile). Si vous travaillez sur une section de code particulièrement volumineuse ou difficile, n'hésitez pas à y jeter un autre coup d'œil à tout moment.

Les revues de code sont pour quand le code est "fait".

Dans mon organisation, notre définition de «terminé» comprend les tests unitaires (comme nous visons le TDD), donc les révisions de code sont du code complet - et le code complet comprend des tests.

En outre, les tests doivent être revus et refactorisés, il est donc logique qu'ils fassent partie de la révision du code.

Les tests doivent être considérés comme faisant partie du code à réviser. Par conséquent, il est logique de réviser une fois les tests effectués.

Assurez-vous que les tests sont également passés en revue. Ceci est essentiel pour ceux qui débutent dans les tests unitaires.

Assurez-vous que votre équipe sous-tend l'injection de dépendance, les cadres d'isolement, les simulations contre les talons, les coutures, les tests d'interaction contre les états et l'intégration contre les tests unitaires.

Vous n'avez pas besoin de mettre en œuvre les sujets susmentionnés, mais vous devez les comprendre.

Bien,

Cela dépend de ce que vous entendez par "Test unitaire" ...

S'il s'agissait d'un test unitaire de style TDD, il n'a aucun sens car vous écrivez test pendant que vous écrivez votre code. Il n'y a pas de cas postérieur, dans ce cas vous améliorez la qualité du code en continu: Refactoring ...

ET

Si c'était un "test unitaire" classique [quoi que cela signifie, je ne sais pas, mais je veux dire un test après avoir écrit les codes et effectué par d'autres gars en général] alors le critère principal est ce que vous attendez de la révision du code et de la nature des tests unitaires: si vous voulez une évaluation rapide - faites un examen et prenez des mesures et n'avez pas de test unitaire automatisé, vous devrez attendre le test unitaire. Si vous souhaitez identifier les problèmes matures avec la révision de code et appliquer progressivement la solution pour les prochaines itérations, vous pouvez le faire avant le test unitaire ...

Mais après tout personnellement, pour la revue de code, un test unitaire ultérieur ou ultérieur n'est pas un vrai critère pour moi ...

Pourquoi faisons-nous un examen du code? Pour la qualité du code ... Au lieu d'une porte de "contrôle qualité", injectez de la qualité dans votre environnement de processus de développement logiciel ...

J'aurais tendance à dire, soyons "agiles" ... n'attendez pas que le code soit terminé pour faire une révision rapide et informelle du code: il y a des développeurs avec qui et des sujets avec lesquels vous pouvez en effet attendre la totalité code + phase de test à terminer ... mais

quand il s'agit de sujets vraiment nouveaux (toute nouvelle fonctionnalité, quasi-recherche, quelque chose de totalement nouveau pour l'équipe), révision de code tôt, ne perdez pas de temps: demandez à un collègue de regarder de temps en temps: l'isolement est un facteur important d'échec dans ce cas.

si le développeur est nouveau dans l'équipe, vérifiez également le code tôt et peut-être souvent .

et en passant, les tests unitaires doivent également être revus.