<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by WealCome on Medium]]></title>
        <description><![CDATA[Stories by WealCome on Medium]]></description>
        <link>https://medium.com/@wealcomecompany?source=rss-40af3020d403------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*uREkrvY7k5a5ZAN93fFnYA.png</url>
            <title>Stories by WealCome on Medium</title>
            <link>https://medium.com/@wealcomecompany?source=rss-40af3020d403------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 11:21:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@wealcomecompany/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Le Planning Poker — à abolir pour le bien du projet et de l’équipe ?]]></title>
            <link>https://medium.com/wealcomecompany/le-poker-planning-une-bonne-chose-hold-on-b35531a61e7b?source=rss-40af3020d403------2</link>
            <guid isPermaLink="false">https://medium.com/p/b35531a61e7b</guid>
            <category><![CDATA[sprint-planning]]></category>
            <category><![CDATA[agilité]]></category>
            <category><![CDATA[développeur]]></category>
            <category><![CDATA[planning-poker]]></category>
            <dc:creator><![CDATA[WealCome]]></dc:creator>
            <pubDate>Fri, 07 Sep 2018 12:36:50 GMT</pubDate>
            <atom:updated>2018-09-09T12:44:15.730Z</atom:updated>
            <content:encoded><![CDATA[<p>Vous connaissez tous les “Sprint planning”, célèbre “cérémonie” de Scrum ?</p><p>Ces réunions qui durent assez longtemps où le Product Owner présente les priorités des développements à assurer pour le sprint qui vient.</p><p>Lors de cette réunion, il est demandé à l’équipe de développement d’estimer les efforts à fournir pour chacune des différentes tâches.</p><p>Pour cela, le Scrum Master présente son fameux jeu, le Planning Poker, connu de la plupart des équipes se revendiquant “agiles”.</p><p>Ce n’est autre qu’un jeu de cartes dont les valeurs sont les suivantes : <br><strong>0, ½, 1, 2, 3, 5, 10, 20, 50, 100.</strong></p><p>Ces valeurs sont censées <strong>quantifier l’effort à fournir pour une tâche donnée</strong>. <br>Plus la valeur est élevée, plus la tâche demandera de l’effort et donc souvent plus de temps.</p><h3>Comment le Planning Poker se déroule-t-il ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*B7pU_fkjknSBSn4V.JPG" /></figure><p>Le Product Owner lit la description de la fonctionnalité à haute voix et l’équipe doit estimer l’effort à fournir pour la réaliser.</p><p>Chaque développeur est doté d’un jeu de cartes contenant toutes les valeurs ci-dessus.</p><blockquote>“Choisissez vos carteesss … à 3 vous les retournez, 1, 2 et 3 !”</blockquote><p>Bruno a choisi <strong>2</strong>.<br>Stéphane a choisi <strong>5</strong>.<br>Julien a choisi <strong>13</strong>.</p><blockquote>“Bah !! On dirait que vous n’êtes pas d’accord, expliquez-vous, il faut trouver un terrain d’entente !”</blockquote><p>On rejoue :</p><p>“Bruno a choisi <strong>5</strong>”.<br>“Stéphane a choisi <strong>5</strong>”.<br>“Julien a choisi <strong>5</strong>”.</p><p>Bruno a augmenté son chiffrage et Julien lui l’a rabaissé. <br>Ils ont coupé la poire en deux sans réel débat approfondi car…la réunion doit continuer et il y a encore beaucoup de tâches à estimer.</p><h3><strong>Mais pourquoi un tel écart de chiffrage entre les développeurs ?!</strong></h3><h3><strong>Hypothèse numéro 1 :</strong></h3><p>Julien est moins expérimenté que les autres.<br>La tâche à accomplir lui parait beaucoup plus ardue.<br>Fatalement, un 13 lui semblait censé.</p><p>Il suffit de 2 ou 3 séances de Planning Poker pour que Julien se dise alors : <br>“Bon…je passe pour un âne à chaque fois, ils vont tous penser que je suis le tracteur de l’équipe; je vais arrêter d’être honnête et je vais tirer des plus petites cartes; tant pis; c’est mon égo qui me guide”.</p><h4><strong>Dénouement assuré : Julien ne sera plus honnête à l’avenir dans ses estimations !</strong></h4><h3><strong>Hypothèse numéro 2 :</strong></h3><p>Julien est bien plus expérimenté et perfectionniste que les autres, il voit le problème soulevé par la tâche d’une manière BEAUCOUP plus complète et profonde !<br>Il a pensé à toutes les validations à implémenter pour le formulaire; à tous les “wrong paths”; tous les aspects de sécurité subtils etc; le côté responsive du site Web à assurer etc... <br>Quant aux autres ils n’ont eu qu’une vision simpliste, remplie de failles, et donc peu perfectionniste de l’histoire.</p><h4>Dénouement assuré : Julien aura de longues discussions/débats avec les autres développeurs après la cérémonie (car oui, y’a pas le temps pour débattre profondément en Sprint Planning) pour leur expliquer qu’ils visualisent à chaque fois la moitié du problème.</h4><h4>Bonjour le froid dans l’équipe !</h4><h4>À l’avenir, devenus moins confiants, Stéphane et Bruno rallongeront leur chiffrage, même si dans les faits ils n’ont pas la capacité d’évaluer réellement la tâche qui les attend car trop peu expérimentés voire ignorants de plein de notions techniques.</h4><h4>Julien quant à lui songera, toujours par égo, à abaisser ses chiffrages pour ne pas paraître exagérant auprès des autres acteurs du projet.</h4><h3>Hypothèse numéro 3 :</h3><p>Julien chiffre large pour ne pas ressentir de pression lors du sprint. <br>Il aime prendre son temps pour travailler, il n’a pas envie de transpirer; après tout il n’est pas si bien payé que cela selon lui.</p><h4>Dénouement assuré : Les autres développeurs le détecteront rapidement et se diront :</h4><h4>“Bon bah je vois pas pourquoi l’on se donnerait corps et âme pour aller vite pour au final n’avoir aucune reconnaissance particulière ?! On va faire comme Julien, on va prendre notre temps et donc chiffrer large ! Et puis personne lui ‘gueule’ dessus; donc bon”.</h4><h3>Hypothèse numéro 4 :</h3><p>Bruno chiffre très bas (2 !) car il souhaite passer pour un employé ultra efficace quantitativement et non qualitativement, et compte tenu de l’état du logiciel à son arrivée, il désire absorber les tâches à la vitesse de l’éclair sans réel soin poussé car de toute façon “Le logiciel est déjà crade en l’état !”. <br>Il a compris que les managers n’étaient pas si exigeants que cela qualitativement parlant et que 10 ou 20 bugs de plus ce n’est pas ce qui va ruiner le business.</p><h4>Dénouement assuré : Il sera bel et bien considéré comme ultra efficace par ses managers qui n’y verront que du feu AU DEBUT; mais sera en froid avec le reste de son équipe; ce dernier voulant être fier d’une bonne copie rendue.</h4><h4>Bruno et éventuellement Stéphane, par égo, chiffreront leurs tâches et finiront par craquer en mettant leur perfectionnisme de côté. <br>“Soit on reste et on fait comme Julien, soit on quitte la mission mais ce sera dur de payer le loyer en attendant de trouver autre chose; on fait comme Julien allez !”</h4><h4>Résultat : La niveau de qualité du produit sera à la baisse; pour finalement engendrer une complexité accidentelle et donc une dette technique gigantesque dans un futur très proche; menant le projet au cimetière le plus proche.</h4><h3>Mais…toutes les hypothèses évoquées n’ont pas de dénouement positifs et les estimations semblent alors tout à fait non-fiables, comment faire alors ?</h3><p><a href="https://medium.com/u/77221ee353e">Michael Azerhad</a>, de WealCome, conseille d’<strong>abolir strictement les séances de Planning Poker. <br>Pas d’anéantir les estimations hein ? (quoique … ce sera l’objet d’un autre article, mais c’est un next level).<br>Mais bien d’anéantir cette pratique qui consiste à estimer “pris au dépourvu” sans réflexion profonde en amont</strong>.</p><h4>What ?!</h4><p>Je cite <a href="https://medium.com/u/77221ee353e">Michael Azerhad</a> :</p><p>“<br>Ce qui suit, je l’ai expérimenté plusieurs fois avec gros succès :</p><p>Pour estimer des tâches à venir, je préfère que les développeurs de l’équipe et UNIQUEMENT EUX se réunissent tous dans une salle, HORS séance de Sprint Planning et en AMONT de celui-ci. <br>L’équipe aura déjà eu auparavant la connaissance du “gourou” de l’équipe, en quelque sorte la personne qui voit les choses bien plus en profondeur que les autres à l’heure actuelle.</p><p>Cherchez bien, il y a TOUJOURS une ou deux personnes dans l’équipe qui surprend (relativement parlant) par ses raisonnements et sa vision à la fois macro et micro des problèmes. <br>Celui-ci (ou ces 2) prend/prennent la parole et présente sur un tableau blanc TOUTES les tâches à accomplir pour assurer une fonctionnalité dans son ENSEMBLE de manière perfectionniste et cohérente.</p><p>Les autres écoutent, et à tout moment peuvent l’interrompre s’ils ont une interrogation, une incompréhension, un avis personnel, voire même une critique !</p><h3>Dans ce genre de réunions entre développeurs, on a le TEMPS de parler/débattre technique.</h3><h3>Ça peut durer même la journée s’il le faut; il faut en profiter !</h3><p>Peu à peu, au fil des sprints, les “juniors” ou “seniors” moins expérimentés auront affiné la vision <strong>micro</strong> des problèmes grâce aux différentes <strong>attentions portées sur le “gourou”</strong> (énorme avantage de cette pratique !) et pourront alors à leur tour est plus autonome quant à leurs estimations.</p><p>Dans ce cas-ci, ils pourront estimer<strong> désormais dans leur coin</strong> en détaillant les tâches, qu’ils <strong>transmettent par mail</strong> (ou Slack pour les plus modernes) au gourou de l’équipe, souvent le Tech Lead, en vue d’avoir un retour et une potentielle validation.</p><p>Ainsi, plus besoin de jeux de cartes car le Tech Lead étudiera ces propositions d’estimations et <strong>réunira à nouveau les développeurs</strong> pour qu’ils estiment <strong>TOUS ENSEMBLE</strong> le chiffrage qui sera <strong>ACCEPTABLE, MOYEN, COHÉRENT ET CONFORTABLE</strong> (sans trop l’être ;)) pour toute l’équipe !</p><p>Lors du Sprint Planning, qui se verra donc insolemment raccourci, l’équipe saura déjà quel nombre annoncer dans la bonne humeur générale; aucune secousse !</p><p>Il y règnera (vécu) une bien meilleure ambiance dans l’équipe ;)</p><p>C’est le rôle du GOUROU =&gt; celui de montrer la direction à suivre pour que Padawan devienne un jour Jedi !</p><p>Et vous, qu’en pensez-vous de cette solution ? ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b35531a61e7b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/wealcomecompany/le-poker-planning-une-bonne-chose-hold-on-b35531a61e7b">Le Planning Poker — à abolir pour le bien du projet et de l’équipe ?</a> was originally published in <a href="https://medium.com/wealcomecompany">WealCome-Company</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Démonstration de BDD (ATDD) et TDD en live !]]></title>
            <link>https://medium.com/wealcomecompany/d%C3%A9monstration-de-bdd-et-tdd-en-live-bbc3329b39e?source=rss-40af3020d403------2</link>
            <guid isPermaLink="false">https://medium.com/p/bbc3329b39e</guid>
            <category><![CDATA[tdd]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <category><![CDATA[bdd]]></category>
            <category><![CDATA[cucumber]]></category>
            <category><![CDATA[gherkin]]></category>
            <dc:creator><![CDATA[WealCome]]></dc:creator>
            <pubDate>Thu, 06 Sep 2018 23:31:29 GMT</pubDate>
            <atom:updated>2019-03-14T11:13:42.180Z</atom:updated>
            <content:encoded><![CDATA[<p>Vous cherchiez un exemple sur le net de réalisation de projet avec <strong>BDD</strong> et <strong>TDD</strong> mais vous tombiez uniquement sur des tutoriels simplistes voire enfantins ?</p><p>Regardez ces<strong> 3 épisodes</strong> <strong>ci-dessous</strong> réalisés par <a href="https://medium.com/u/77221ee353e">Michael Azerhad</a>.</p><p>Il s’agit ici de réaliser une <strong>application tout à fait réaliste permettant de réserver un chauffeur VTC pour un trajet précis</strong>.</p><p><em>Cucumber (Gherkin) / Java 8+ / Spring / Clean Architecture</em></p><p>Dans le 1er épisode, il est montré comment implémenter les scénarios écrits en Gherkin avec Cucumber (BDD/ATDD). <br>Pas de TDD dans cet épisode. <br>On implémente uniquement les scénarios en “programming wishful thinking” (naïvement) jusqu’à … un cul-de-sac attendu.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FrYX51DaJifw%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DrYX51DaJifw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FrYX51DaJifw%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/29fcc800fac57d891f76269f1fc11811/href">https://medium.com/media/29fcc800fac57d891f76269f1fc11811/href</a></iframe><p>À la fin du 1er épisode, on se rend compte que pour faire passer les scénarios avec succès, on a besoin de … TDD ! <br>Les premières specs TDD voient alors le jour dans ce 2ème épisode ! <br>La complémentarité entre BDD/ATDD et TDD y est expliquée.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FCMjy7csMMko%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DCMjy7csMMko&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FCMjy7csMMko%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/b3bfef17c91cfcfc660d769fbf1f702f/href">https://medium.com/media/b3bfef17c91cfcfc660d769fbf1f702f/href</a></iframe><p>Dans le 3ème épisode, on découvre tout l’avantage de TDD avec l’émergence par à-coups naturels d’un très bon design de code.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FHbF4MAr0kk8%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DHbF4MAr0kk8&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FHbF4MAr0kk8%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/f707e88b7c978f19afd486c866e129e7/href">https://medium.com/media/f707e88b7c978f19afd486c866e129e7/href</a></iframe><p>Ces épisodes ont convaincu énormément de développeurs ayant des préjugés sur ces pratiques.</p><p>Avec cette pratique, WealCome garantit un projet sans AUCUN bug, sans mode “debug”, sans code mort, mais avec un code ÉLÉGANT, bien designé et toujours fidèle à l’énoncé !</p><p>Productivité décuplée, haute qualité et coût bien moindre; que demande le peuple ;) !</p><p>Chez <a href="http://wealcomecompany.com/"><strong>http://wealcomecompany.com</strong></a>, on code comme ça TOUT LE TEMPS en Front comme en Back ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bbc3329b39e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/wealcomecompany/d%C3%A9monstration-de-bdd-et-tdd-en-live-bbc3329b39e">Démonstration de BDD (ATDD) et TDD en live !</a> was originally published in <a href="https://medium.com/wealcomecompany">WealCome-Company</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TDD = perte de temps ?]]></title>
            <link>https://medium.com/wealcomecompany/tdd-perte-de-temps-a2e2dda73cf7?source=rss-40af3020d403------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2e2dda73cf7</guid>
            <category><![CDATA[test-unitaire]]></category>
            <category><![CDATA[come-down]]></category>
            <category><![CDATA[démonstration-tdd]]></category>
            <category><![CDATA[tdd]]></category>
            <category><![CDATA[kata]]></category>
            <dc:creator><![CDATA[WealCome]]></dc:creator>
            <pubDate>Thu, 06 Sep 2018 23:15:10 GMT</pubDate>
            <atom:updated>2019-01-02T10:20:15.623Z</atom:updated>
            <content:encoded><![CDATA[<p>Qui n’a jamais entendu que pratiquer le Test-Driven Development était coûteux car soi-disant contre-productif ?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*1wQkXwYctp4NvVh0NhyNwA.png" /></figure><p>Avec les vidéos suivantes, <a href="https://medium.com/u/77221ee353e">Michael Azerhad</a>, fondateur de WealCome, démontre que la productivité est au contraire décuplée si l’on suit scrupuleusement les règles du Test-Driven Development.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FyiCpfd-kz3g%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DyiCpfd-kz3g&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FyiCpfd-kz3g%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/f42fe04e998b0b285bda9d49eedbd1b9/href">https://medium.com/media/f42fe04e998b0b285bda9d49eedbd1b9/href</a></iframe><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FnbSaq_ykOl4%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DnbSaq_ykOl4&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FnbSaq_ykOl4%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/77b800326ea4f6e942ef0740767178ea/href">https://medium.com/media/77b800326ea4f6e942ef0740767178ea/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2e2dda73cf7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/wealcomecompany/tdd-perte-de-temps-a2e2dda73cf7">TDD = perte de temps ?</a> was originally published in <a href="https://medium.com/wealcomecompany">WealCome-Company</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vous ne verrez plus les tests unitaires de la même manière …]]></title>
            <link>https://medium.com/wealcomecompany/vous-ne-verrez-plus-les-tests-unitaires-de-la-m%C3%AAme-mani%C3%A8re-7b0f92c460cb?source=rss-40af3020d403------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b0f92c460cb</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[test-unitaire]]></category>
            <category><![CDATA[craftsmanship]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[WealCome]]></dc:creator>
            <pubDate>Thu, 06 Sep 2018 22:31:06 GMT</pubDate>
            <atom:updated>2018-09-09T11:24:21.154Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>TL;DR:</strong> Si vous pensez maîtriser le concept de test unitaire, lisez cet article <strong>jusqu’à la fin</strong>, vous serez très probablement surpris.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/914/1*eiOK6b64s0ASn9EbKBIkjw.png" /></figure><p>D’abord une notion de vocabulaire importante :</p><blockquote>Un <strong>SUT</strong> ou encore « System under test » désigne un système qui fait l’objet d’un test vérifiant l’exactitude d’une opération.</blockquote><p>On définit alors un test unitaire ainsi :</p><blockquote>Un test unitaire est un test vérifiant <strong>en isolation</strong> l’exactitude d’une opération d’un SUT.</blockquote><p>La notion la plus importante est la notion d’<strong>isolation</strong>.</p><p>Faîtes un petit jeu avec vos collègues développeurs; retournez-vous et posez-leur cette question :</p><p>« Que signifie le terme ‘en isolation’ dans cette définition ? »</p><p>99% si ce n’est pas tous vous répondront :</p><blockquote>‘En isolation’ signifie que tous les <strong>réels</strong> <strong>collaborateurs</strong> <strong>du SUT</strong> ne doivent <strong>pas être traversés par le test</strong>; de façon à se focaliser uniquement sur le SUT lui-même. Il faut alors « simuler » les collaborateurs lors du test.</blockquote><p>Prenons un exemple pour illustrer leur raisonnement :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2eb0cbaaabd3221283b56fb95cd9ce55/href">https://medium.com/media/2eb0cbaaabd3221283b56fb95cd9ce55/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e944a1fa83851466d0a2aff301dbf145/href">https://medium.com/media/e944a1fa83851466d0a2aff301dbf145/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f127cf00917fae1356ea6d7b015c60e/href">https://medium.com/media/1f127cf00917fae1356ea6d7b015c60e/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1fa20687139311c704a81b760a886851/href">https://medium.com/media/1fa20687139311c704a81b760a886851/href</a></iframe><p>La réelle implémentation de <strong>B</strong>, collaborateur de <strong>A</strong>, n’est donc pas traversée par le test ‘<strong>shouldFoo()</strong>‘, comme spécifié par la définition donnée par tes collègues.<br>La conséquence est que chaque réelle implémentation (<strong>A</strong> et <strong>RealB</strong>) devra avoir sa propre suite de tests.</p><p>Cette définition est très présente dans l’esprit de nombreux développeurs et est même portée par un célèbre livre intitulé : <br>« Growing Object-Oriented Software Guided By Tests » <br>de Steve Freeman et Nat Price.<br>On y apprend à faire émerger des <strong>rôles;</strong> une interface de collaborateur représentant un rôle; et de les tester séparément afin de mieux expliciter les concepts et les interactions entre les objets.</p><p>Si vous êtes friands de ce type d’interprétation du terme « En isolation »,<strong> sachez qu’il y a un problème majeur avec cela</strong>, bien <strong>subtil</strong>, qui à terme détourne les développeurs de leur tâche la plus professionnelle, à savoir l’écriture de tests unitaires de sorte à maîtriser ce qui est livré en production.</p><p>Maintenant que vous maîtrisez les concepts de SUT et de collaborateurs, prenons un exemple plus concret mettant en valeur une problématique majeure.</p><p>Il s’agit ici d’organiser une course d’animaux (en l’occurrence entre un guépard et un cheval) et de remonter la vitesse maximale de chacun ainsi que le classement final :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/900b7f1a7a2c618a241d31540a67bb26/href">https://medium.com/media/900b7f1a7a2c618a241d31540a67bb26/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6f3d9ac32fb072b7a35a9df0ebb0ad1c/href">https://medium.com/media/6f3d9ac32fb072b7a35a9df0ebb0ad1c/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1b07eaeda619c2a00cca0e69d94cb91c/href">https://medium.com/media/1b07eaeda619c2a00cca0e69d94cb91c/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b1112d4da266787d7beb93275f3093ac/href">https://medium.com/media/b1112d4da266787d7beb93275f3093ac/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e729554e75d12b279e43736cd11a833d/href">https://medium.com/media/e729554e75d12b279e43736cd11a833d/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7370effec4f6885983a3b209c062942a/href">https://medium.com/media/7370effec4f6885983a3b209c062942a/href</a></iframe><p>Le <strong>SUT</strong> ici est l’instance de <strong>Race</strong>.</p><p>Le teste passe avec succès.<br>Cependant, un dev quelque peu senior entre dans la pièce et se dit :<br>« Oula ! Y’a du refactoring à faire; abats les instanceof et le procédural ! »</p><p>Son implémentation souhaitée est celle-ci :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/99d2fa16ace12eaf21c5d330c13efc16/href">https://medium.com/media/99d2fa16ace12eaf21c5d330c13efc16/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/015a4834441a7c40ac0e677e636d26c6/href">https://medium.com/media/015a4834441a7c40ac0e677e636d26c6/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4c22301e601e7086cb742e52acd3e639/href">https://medium.com/media/4c22301e601e7086cb742e52acd3e639/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0f82b8feb7d46b5db5d34590c2e32ea8/href">https://medium.com/media/0f82b8feb7d46b5db5d34590c2e32ea8/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e4d375b8666adb689eec929546955f8a/href">https://medium.com/media/e4d375b8666adb689eec929546955f8a/href</a></iframe><p>Hey ! Mais selon la définition du test unitaire énoncée plus haut, chaque objet doit être testé <strong>en isolation</strong>; et là ce n’est plus le cas !<br>En effet, le test unitaire <strong>shouldRunARaceBetweenSomeAnimals</strong> n’a pas trop l’air de se focaliser uniquement sur le SUT vu qu’il traverse le code des méthodes <strong>getName()</strong> et <strong>run()</strong> des classes dérivées de la classe <strong>Animal</strong> ! <br>Il semble qu’il faille donc tester ces deux dernières séparément :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/adbdd0b25e1afbd439e2df445c7a33db/href">https://medium.com/media/adbdd0b25e1afbd439e2df445c7a33db/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e4d375b8666adb689eec929546955f8a/href">https://medium.com/media/e4d375b8666adb689eec929546955f8a/href</a></iframe><p>Avant d’aller plus loin, on stoppe tout de suite et on se pose les bonnes questions.<br>Faîtes le vide dans votre tête, oubliez tout et reprenez ce test, lisez le et dîtes-moi ce qu’il fait :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9867ee4d332ad748b50b933049a1456e/href">https://medium.com/media/9867ee4d332ad748b50b933049a1456e/href</a></iframe><p>Développeur : « Bah … il vérifie qu’un un guépard court à 110 à l’heure ».</p><p>Mentor : « Et…tu n’as pas l’impression qu’il manque le … contexte ?? Pourquoi faire courir un animal ?! »</p><p>Développeur : « C’est sûr que là si on ne voit que cette classe, on ne sait pas pourquoi, c’est trop générique ! »</p><p>Mentor : « Et que se passe-t’il lorsqu’un test n’est pas compréhensible à 100% ? »</p><p>Développeur : « On le touche pas ! On le laisse où il est, même s’il ne semble plus d’actualité ! »</p><p>Mentor : « Tout à fait, et du coup on n’a plus confiance en ses tests car non maîtrisés !<br>Et dis-moi, tu notes pas une redondance au niveau des vérifications par tes tests là ? Ton test du use case de la course et ton test focalisé sur le <strong>run</strong> d’un animal ? »</p><p>Développeur : « Oui je n’ai pas encore adapté le test ! Il faut désormais empêcher la méthode <strong>run</strong> d’être traversée par le test pour que le <strong>SUT</strong> (ici <strong>Race</strong>) soit <strong>en isolation</strong> !<br>Je pense faire un « mock » pour ça, et vérifier que la méthode <strong>run</strong> est appelée deux fois, tout en lui faisant retourner des valeurs adaptées et différentes ! »</p><p>Mentor : « Ahhh… on y vient ! Ne touche plus à rien !!!!</p><h3>Si t’as l’impression que tes suites de tests sont le reflet miroir du code de production, c’est qu’il y a un problème !</h3><p>Mentor : « Regarde, ne touche pas au test <strong>shouldRunARaceBetweenSomeAnimals</strong>, et lance-le; que se passe-t’il ?<strong> »</strong></p><p>Développeur : « Il passe … !!! »</p><p>Mentor : « Et oui il passe !! Car tu n’as fait que changer l’implémentation interne de ton algorithme grâce à ton refactoring ! <br>Le détail d’implémentation qui consiste à avoir employé le polymorphisme au lieu des « instanceof » est masqué au test ! <br>Les détails d’implémentation sont (doivent) être une boite noire pour lui et donc n’est pas affecté par ce type de changement ! »</p><p>Développeur : « C’est cool ! Mais malheureusement j’ai enfreint la règle ! <br>Mon SUT n’est plus en isolation car il a besoin de l’<strong>algo réel des collaborateurs (Cheetah et Horse) </strong>pour fonctionner ! <br>Mon test n’est plus U-N-I-T-A-I-R-E !</p><p>Mentor : « Approche … je vais te révéler un secret …. la définition énoncée plus haute par tes collègues est <strong>totalement fausse</strong> ! »</p><p>Développeur : « ?! Pourquoi ? »</p><p>Mentor : « <em>En isolation</em> <strong>ne s’applique pas au code de prod mais au test</strong> ! <strong>C’est le test qui doit s’exécuter en isolation des autres tests</strong> ! »</p><p>Développeur : « Ah bon ?? Mais encore ?? »</p><p>Mentor : « Un test est qualifié d’U-N-I-T-A-I-R-E s’il n’est aucunement affecté par le lancement d’un autre test; mais peut sans problème traverser plusieurs collaborateurs du SUT, du moment qu’on ne sort pas vers le monde externe (base de données, bibliothèque tierce, accès au disque dur etc. ) ! »</p><p>Développeur : « Un exemple peut-être ? »</p><p>Mentor : « Si tu as un premier test qui échange avec une base de données MySQL, et que ce test ajoute une entrée dans la table ‘Car’, il se pourrait qu’un prochain test soit affecté par cela et démarre avec une entrée ajoutée en base sans même le savoir ! »</p><p>Développeur : « Bah on peut faire un @Before avant chaque test et supprimer les données de la base. »</p><p>Mentor : « Oui, mais ce n’est donc plus un test unitaire car tu as été obligé d’effectuer une action manuelle (l’écriture de ce @Before) pour empêcher des side-effects ! »</p><p>Développeur : « Je comprends mieux ! Du coup, je supprime mes tests qui mettent le focus sur la classe <strong>Cheetah</strong> et <strong>Horse</strong> car ils sont déjà traversés par le code <strong>Race#start</strong> ? »</p><p>Mentor : « Tout à fait ! Les seuls tests unitaires qui ont du sens, sont les tests qui se focalisent sur l’exposition du use case; amenant un contexte au lecteur; à savoir la méthode Race#start !<br>Concernant tout ce qui est embarqué par cette méthode, autrement dit les détails d’implémentations, le test n’a pas à le savoir !<br>Un test unitaire doit être orienté « fonctionnel / métier », pour inclure ce fameux contexte, et non uniquement orienté « programmeur » ! »</p><p>Développeur : « Je comprends totalement !! Mais pourquoi personne ne faisait comme ça autour de moi ? »</p><p>Mentor : « Éternelle question … une fausse idée reçue; <strong>ils oublient qu’un test unitaire a pour but de refactorer son code et non de tester, </strong>et que du coup avoir des tests qui font effet miroir avec ton code de production influerait négativement sur ta capacité à refactorer sans rendre plusieurs tests obsolètes ! »</p><p>Développeur : « Hummm !! Vu comme ça, c’est vrai que j’ai pu faire mon refactoring de manière « safe » sans avoir peur de tout casser car le test du use case existait déjà ».</p><p>Mentor : « Regarde <a href="https://www.youtube.com/watch?v=GvAzrC6-spQ">cette vidéo d’Uncle Bob</a>; elle dure 3 minutes, tu vas voir les choses autrement ! »</p><p>Développeur : « Merci ! Ça a changé ma vision du dev !! »</p><h3>Conclusion</h3><ul><li>« Unitaire » ne signifie pas « ciblant un fichier / une classe / une méthode ».<br>« Unitaire » signifie un test qui s’exécute de manière totalement indépendante NATURELLEMENT des autres tests.<br>Ce n’est pas une unité au sens « unité de structure », mais au sens « unité de comportement / use case ».<br>La nuance est énorme !</li><li>Un test unitaire PEUT traverser plusieurs réelles implémentations des collaborateurs du SUT, tant que celles-ci ne sortent pas en dehors du coeur du domaine métier.<br>Dans ce cas-là, elles devront être doublées (stub par exemple).<br>En général, ces collaborateurs ont émergé par le biais des étapes de refactoring du code, associées à une pratique stricte de Test-Driven Development.</li><li>Les seuls tests unitaires qui ont du sens sont ceux qui ciblent le point d’entrée du use case car elles amènent la connaissance du contexte ! (dans notre exemple Race#start).<br>Un test unitaire est orienté F-O-N-C-T-I-O-N-N-E-L dans 98% des cas.<br>Coupler un test à des détails de d’implémentations (des stratégies d’algorithmes par exemple) freineraient tes possibilités de refactoring car vite cassés au moindre changement important d’implémentation.</li><li>Moins tu utilises de doublures (comme les mocks), moins tes tests seront « connaisseurs » de tes détails d’implémentations et donc meilleures seront tes capacités en futur refactoring.<br>Pour comprendre ce qu’est un mock et saisir ce en quoi il freine le refactoring, lisez <a href="http://www.draconianoverlord.com/2010/07/09/why-i-dont-like-mocks.html">cet article</a>.</li><li>Il peut arriver que si tu suis scrupuleusement le principe d’inversions de dépendances, certains tests ne compilent plus, car ne prenant pas encore en compte une nouvelle dépendance (rôle) qui vient d’émerger; mais ce n’est pas grave et c’est normal !<br>Il te suffit d’ajouter le MINIMUM de code dans le test pour injecter la nouvelle dépendance sans jamais être trop couplée à elle lors de la définition du test (exemple, je ne vérifie pas son nombre d’appels ni vérifie qu’une ou plusieurs de ses méthodes aient été invoquées !).<br>Imagine-là comme une boîte noire; de façon à ce que tes tests soient les plus solides et pérennes possibles !</li><li>Tu vas prendre goût aux tests car avec cette façon de faire, tu seras beaucoup plus productif !<br>Moins de tests éparpillés sans contexte intégré, et plus de robustesse !</li><li>Et si tu as l’impression que tes tests unitaires ressembleront à TA définition de tests d’intégration, c’est bon signe !<br>Ça porte même un nom, on parle d<strong>‘Integrated tests</strong>, pour nuancer avec les <strong>Integration tests</strong>.<br>Un test d’intégration a pour vocation de vérifier les collaborations avec les éléments externes de l’application (ORM etc), de les « intégrer », sans impliquer une seule règle de gestion métier !<br>Alors qu’un test unitaire quant à lui spécifie TOUTES les règles de gestion de l’application, sans jamais être couplé aux collaborateurs externes.<br>Pour plus de détails sur cette nuance, voir la vidéo de Ian Cooper en lien plus bas.</li></ul><p>Si t’as aimé cet article, n’hésite pas à le partager autour de toi de manière à briser cette mauvaise idée reçue explicitant qu’un test unitaire = test sur une méthode d’une classe et seulement d’une classe; cela n’a pas de sens, vraiment</p><p>Et si tu veux davantage d’informations à ce sujet, voici un autre <a href="http://codebetter.com/iancooper/2011/10/06/avoid-testing-implementation-details-test-behaviours/">super article de Ian Cooper</a> ainsi que sa <a href="https://vimeo.com/68375232">vidéo sur le sujet.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b0f92c460cb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/wealcomecompany/vous-ne-verrez-plus-les-tests-unitaires-de-la-m%C3%AAme-mani%C3%A8re-7b0f92c460cb">Vous ne verrez plus les tests unitaires de la même manière …</a> was originally published in <a href="https://medium.com/wealcomecompany">WealCome-Company</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TDD n’est pas ce que tu crois.]]></title>
            <link>https://medium.com/@wealcomecompany/tdd-nest-pas-ce-que-tu-crois-3c097b72079f?source=rss-40af3020d403------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c097b72079f</guid>
            <category><![CDATA[software-craftsmanship]]></category>
            <category><![CDATA[test-driven-development]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[tdd]]></category>
            <dc:creator><![CDATA[WealCome]]></dc:creator>
            <pubDate>Sun, 25 Mar 2018 18:31:27 GMT</pubDate>
            <atom:updated>2018-09-07T13:52:45.096Z</atom:updated>
            <content:encoded><![CDATA[<p>Dans Test-Driven Development, il y a le mot “test”. <br>Tu te dis alors automatiquement que c’est une technique qui va permettre de vérifier que ton code marche.</p><p>Si c’était cela, TDD n’aurait en rien transcendé les esprits des développeurs, car l’aspect testing existe depuis des décennies.</p><p>Le but de TDD c’est tout l’inverse, c’est découvrir <strong>par magie</strong> le code à écrire qui solutionnera ton énoncé du premier coup !</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*R6S7nPsgD6eI9SegD-p45g.png" /></figure><p>TDD veut que t’arrêtes de réfléchir par toi-même dans ton coin. <br>Il a compris que 99% du temps tu t’aventures dans un nouveau bloc de code from scratch compliqué mêlant des boucles, des listes, des variables partagées, des duplications etc. <br>Il a compris que tu perdais un temps fou à coder une portion, très souvent hors-sujet.<br>Le problème c’est que tu remarques que t’es hors-sujet au bout de plusieurs minutes voire de plusieurs heures; voire…des jours argh !<br>Et hop, après 3 heures, un joli ctrl+A =&gt; suppr, petit café, quelques larmes versées et tu recommences ?</p><p>TDD désire désormais que tu réflechisses en compagnie de l’ordinateur, ton nouveau copilote afin de te notifier de tes hors-sujets/code mort/erreurs en 10 secondes max !</p><p>Il ne te laissera plus faire la moindre bêtise !</p><p><em>Comment fait-il, il manipule mon cerveau, me rajoute 50 points de QI, il me drogue le salopiaud ?!</em></p><p>TDD en un mot c’est une <strong>discipline de fer</strong>.</p><ol><li>T’as plus le droit d’écrire du code sans que l’ordinateur te l’ait demandé !<br><em>“Hein????? Il peut me parler ce stupide ordi ?”</em></li><li>Tu écriras le minimum de code que l’ordinateur t’autorisera à écrire et surtout pas plus ! <br><em>“Bah voyons ! J’ai pas payé mon MacBook Pro pour qu’il me donne des ordres !”</em></li><li>Tu arrangeras À FOND chaque millimètre de code que tu écriras quand l’ordinateur te le permettra, et pas avant ! Tout code mort, défensif en mode parano, à la poubelle !<br>À partir de maintenant tu vas devenir un passionné de la propreté car TDD te met en valeur tous les outils de nettoyage dont t’as besoin ‘for free’ !</li><li>Tu connais bien les tableaux les listes et compagnie ? <br> <em>“Oui les ArrayList, les LinkedList, les HashSet, HashMap, je dois tous te les citer Mister”?<br></em>Et bien dorénavant tu en écriras uniquement quand l’ordinateur te l’ordonnera car tu auras désormais une liste des actions possibles à chaque instant ! <em>(</em><a href="https://en.wikipedia.org/wiki/Transformation_Priority_Premise">https://en.wikipedia.org/wiki/Transformation_Priority_Premise</a>)<em><br>“WTF, c’est une dictature ton délire, genre il va me dire ce que je peux utiliser et ce que je peux pas ?!”</em></li><li>Tu arrangeras le code de tes tests autant que ton code de prod, si ce n’est plus. <br><em>“ Bah voyons, c’est du code qui va pas en prod, je vais pas me faire chier !”</em><br>Fais ce que je te dis ! Ca fait parti de la discipline sinon pas de magie à la clé !</li><li>Tu vas apprendre à splitter un problème dans ton cerveau en petits problèmes à difficulté croissante. <br>Tu devras solutionner chaque petit problème un à un et surtout pas en même temps, en suivant toutes les règles précédentes scrupuleusement. <br>Rappelle-toi, l’ordinateur doit savoir toutes les 10 secondes où tu en es avec une belle barre verte de sorte à t’éviter de graves ennuis !<br>C’est lui ton guide ! D’où le terme “Driven” !</li></ol><p><em>“Hey les mecs ! Il veut nous vendre TDD avec toutes ces règles farfelues et nous promet qu’on livrera plus vite les solutions marchant à 100% ? <br>Ca m’a tout l’air d’un faux prophète, on le pend les gars ?”</em></p><p>J’avais 8 ans quand j’ai vu ce super film de l’époque :</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*88XvI92yN4NbQHKYXn2-Uw.jpeg" /><figcaption>Karaté Kid</figcaption></figure><p>Et je me souviens d’une scène qui m’a bien fait comprendre que certaines choses qui nous paraissent insensées, qui semblent nous ralentir, qui semblent nous faire dévier de notre but, sont en réalité le tremplin direct vers la <strong>sublimation</strong> de soi.</p><p>Ce petit jeunot dans le film souhaitait apprendre le Karaté, il était venu chercher le Maître Yoda chinois pour qu’il apprenne à mettre des coups de pied circulaires tranchants et ainsi faire le beau devant sa copine.<br>Il était “chaud” quoi.</p><p>Puis le Maître Yoda chinois lui demande de nettoyer ses carreaux, sa voiture avec de jolis chiffons; et ce…à tous leurs rendez-vous, non-stop.</p><p>Le petit jeunot pète un cable et demande l’intérêt de faire tout ça ! <br><em>“Je perds mon temps, j’ai pas mis un seul coup de pied dans tout ça !”</em></p><p>Le moment de clairvoyance par Yoda-Like en vidéo (à regarder !) :</p><p>TDD c’est une corvée pour certains mais avec un dénouement aussi inespéré que fabuleux !</p><p>Toi t’es tout chaud, tu viens d’être embauché pour du React et du Scala et tu n’as qu’une envie c’est de créer THE app !<br>Alors tu souhaites esquiver toute discipline qui te ferait ralentir et faire fumer le clavier !</p><p>Sans discipline, tu seras ralenti voire carrément bloqué jeune inconscient; c’est inévitable.</p><p>TDD c’est d’une puissance inouïe mais pour s’en apercevoir, il faut accepter la discipline quelque soit les moments du projets; calmes comme hard.<br>Le rush est l’ennemi de TDD et il te demande de ne jamais rusher mais bien d’appliquer la discipline comme il se doit sans <strong>jamais</strong> prendre de raccourcis.</p><p><strong>Et en bonus, en conséquence du respect à la lettre de cette discipline….TDD s’assurera que ton code marche à tout instant de la vie de ton projet ! Youhou, tu as enfin des tests de non-régression ‘for free’ ! Un code coverage à 100%, oui 100% !</strong></p><p>Toutes ces suites de “tests”, arf allez j’aime pas le mot “test”, si t’as lu plus haut, ça s’apparente plutôt à des specs visant à te guider dans ton code n’est-ce pas ?<br>C’est juste que la spec est écrite avec un outil de testing (Junit/ScalaTest/PHPUnit etc.).</p><p>Alors oui, l’aspect “testing” est une conséquence <strong>heureuse de la pratique TDD. <br></strong>Un bonus gratuit qui fera du bien à ton Manager. Que demander de plus ?</p><p>TDD ce n’est pas du test pour du test.<br>TDD c’est du design de code, une discipline qui si bien pratiquée te fera émerger inconsciemment des algorithmes si bien foutus qu’ils t’étonneront toi-même.</p><p><a href="https://medium.com/u/77221ee353e">Michael Azerhad</a> de chez WealCome dira :</p><p>Si bien pratiqué, TDD ne te ralentira pas.<br>Au contraire, il te rendra XXX fois plus productif car tu arriveras à la solution sans aucun obstacle sur ton chemin, et tu pourras enfin dormir tranquille car ton code sera fiable et refactorable à souhait sans peur de tout casser !</p><p>Et crois-moi sur parole, je le pratique depuis 2011 sur des projets simples comme ultra complexes et pour rien au monde je ne retournerai en arrière.<br>Il m’a rendu bien meilleur développeur que je ne l’étais ;)</p><p>Si tu veux entrer dans la danse (et je te le conseille fortement), commence par regarder les épisodes 19 à 24 : <a href="https://cleancoders.com/videos/clean-code/advanced-tdd">https://cleancoders.com/videos/clean-code/advanced-tdd</a>. <br>J’ai appris les bases de TDD grâce à eux en 2011 et c’est agréable à suivre !</p><p>Dans un <a href="https://medium.com/wealcomecompany/vous-ne-verrez-plus-les-tests-unitaires-de-la-m%C3%AAme-mani%C3%A8re-7b0f92c460cb">prochain article</a>, j’expliquerai ce qu’est un VRAI test unitaire et pourquoi beaucoup de gens interprètent mal cette notion.</p><p>Si tu penses que : <br>- Un test unitaire teste une seule classe, sans jamais traverser d’autres sur le chemin. <br>- Que les mocks sont une merveilleuse invention.<br>- Qu’un test unitaire est orienté pur développeur et ne teste pas de ‘métier’.</p><p>Alors tu es le candidat rêvé pour lire le prochain article et constater que … tu te trompes totalement…</p><p><em>Originally published at </em><a href="https://medium.com/wealcomecompany/tdd-nest-pas-ce-que-tu-crois-6b8390cb40c9"><em>medium.com</em></a><em> on March 25, 2018.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c097b72079f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>