La lecture mineutieuse de la source permet de mieux rendre compte de l'idée de l'auteur :
- TDD est là pour influencer (de manière positive) la mise en place de l'architecture. En effet, le code des tests nous forcent à refactorer pour "simplifier" les choses et donc les rendre plus propre. Cependant, en "simulant" des comportements, on se prémunit de gérer la complexité du système et le besoin de refactoring (et donc d'amélioration de l'architecture) tend à être moins important.
- La comparaison avec le C++ tient au faîte que l'outil est relativement puissant et très permissif dans son utilisation. Et donc chaque idée prise séparémment donc très bonnes mais leurs utilisations donnent souvent des résultats monstreux (au sens négatif du terme).
Quelques précisions par rapport aux interventions précédentes :

Envoyé par
Bono_BX
Pour rappel, il y a trois grands types de tests (les dénominations changent selon les personnes, mais les principes sont les mêmes) :
- les tests unitaires, qui ne testent qu'une seule fonction. On utilise donc les mocks pour l'isoler des autres fonctions et de l'environnement (au sens large).
- Les test d'intégration (ATTENTION : ce nom est souvent employé pour d'autres tests), qui sont souvent assimilés aux tests unitaires. Ces tests n'utilisent de préférence pas les mocks, permettant à une fonction d'effectuer "en réel" tous ses appels, et interagit avec l'environnement. Plus coûteux, ils n'en sont pas moins intéressant car en plus de tester les fonctions "en vrai", ils s'avèrent précieux pour tout ce qui est problématiques de performances et de montée en charge (ceci n'est qu'un exemple).
- Les tests d'interface : un automate simule les actions des utilisateurs et vérifie que les retours de l'application (UI, BDD, fichiers ...) sont corrects.
Il existe effectivement trois grand types de tests mais ce sont : white/grey/black-box. Il ne s'agit pas de délimiter un périmètre (ce qui est dedans, ce qui est en dehors) mais de délimiter la connaissance qu'on a du système.
C'est pourquoi les gens désignent par "intégration" des tests très différents. En général, c'est surtout sur la question du périmètre dont les gens ne sont pas d'accord mais il s'agit probablement de test "boîte grise" dans tous les cas.
Pour la distinction "mock"/"stub" (simulacre/bouchon), ce n'est que mon avis mais un bouchon, c'est un truc figé ; histoire qu'il y ait qqn qui réponde avec (ou sans erreur) à la demande. Les "simulacres" sont beaucoup plus dynamiques : ils permettent notamment d'invoquer un comportement réel et d'espionner le comportement interne.

Envoyé par
ZeKiD
Manifestement je suis le seul à voir où il a voulu en venir. A savoir que un grand nombre de tests sont réalisés avec des mocks, car la compréhension du code est imparfaite.
En fait, ce n'est pas le fait d'utiliser car la compréhension est imparfaite mais plutôt que l'utilisation des mocks empêchent de parfaire le code parce qu'une tâche censée devenir complexe (le test et donc l'utilisation d'une classe/méthode) ne l'est plus tant que ça et que le besoin en refactoring se fait donc moins sentir.

Envoyé par
ZeKiD
Evidemment ce n'est pas toujours le cas, mais souvent. Un exemple qui me vient en tête d'une aberration (pour moi!!) d'utilisation des mocks concernent les webservices.
En effet, il n'est pas rare de voir des développeurs utiliser des mocks pour simuler la partie serveur d'un web services, alors qu'un simple appel HTTP avec un assert sur une chaine de caractère de résultat devrait à mon sens être plus judicieux, en plus d'être plus performant. Cela reste mon avis bien entendu.
Cela reste également mon avis mais un test unitaire, doit être unitaire. Si tu commences à dépendre d'un service, je ne vois pas en quoi c'est unitaire. Ca reste un test valable certes, mais pas unitaire.

Envoyé par
ZeKiD
J'aurai pu troller en précisant que les annotations n'aident pas non plus à savoir ce qui se passe EXACTEMENT dans le code... A mon sens ils vont de pair avec les mocks.
Je trouve pas que c'est du troll mais une question de goût. Je trouve les annotations très pratiques pour la programmation déclarative mais elles ont l'inconvénient d'être complètement lié au code.
Par exemple, en Java (JPA/Hibernate) on peut déclarer le mapping Objet-Relationnel avec des annotations. Très rapide et moins sujet à erreur, cependant cela verrouille l'utilisateur (de la librairie) avec un schéma particulier.
Pour moi, c'est un débat à avoir lors de l'introduction des annotations de manière générale et il convient de décrire les cas d'utilisation de chaque type d'annotation. Ca définit un cadre/contrat sur lequel chacun peut se reposer pour avoir une compréhension générale du système et comment rédiger les classes.
Sinon j'aime bien la programmation orientée aspect, parfois couplé justement avec les annotations pour déposer des marqueurs. Mais pour ne pas lié la librairie et les aspects, il faut alors que le tissage (action d'appliquer l'aspect sur les classes) doit être dynamique.
0 |
0 |