AssertJ pour des assertions plus expressives

Écrire des tests, c’est bien, écrire des bons tests c’est encore mieux. La technique given when then est une des bonnes pratiques pour écrire des tests (unitaires ou pas d’ailleurs). Les 3 concepts sont en effet nécessaires, y-compris le dernier qui correspond aux assertions. En effet, un test n’apporte vraiment de la valeur que si il procède à des vérifications sur le résultat de son exécution. Ça parait évident mais je suis tombé à plusieurs reprises sur des tests qui exécutaient du code sans rien vérifier…

En Java, les outils de base les plus populaires pour écrire des tests (JUnit et TestNG) sont assez pauvres pour écrire les assertions. Heureusement, il existe des outils permettant de gagner à la fois en puissance et en expressivité pour exprimer les assertions. Continuer la lecture de AssertJ pour des assertions plus expressives

Fin de crise d’ado en vue pour Play Framework

play_full_color J’avais écrit un retour d’expérience à propos de Play Framework il y a un peu plus d’un an. J’y exprimais ma frustration quant au fait qu’il ne manquait pas grand chose à Play Framework pour être un super outil de développement.

J’étais assez peu optimiste sur le fait que ces points puissent s’estomper rapidement parce que c’étaient ceux que Typesafe mettait en avant pour se différencier des autres. Il semblerait cependant que le vent a tourné récemment et il souffle maintenant de mon point de vue dans la bonne direction ! Continuer la lecture de Fin de crise d’ado en vue pour Play Framework

Passage en HTTPS grâce à Let’s Encrypt

Le blog utilise depuis quelques jours HTTPS. J’ai pu mettre en place HTTPS gratuitement grâce à Let’s Encrypt, une initiative supportée par différents acteurs du web visant à sécuriser le web à grande échelle.

Let’s Encrypt

letsencryptLet’s Encrypt résout les deux plus gros freins à l’adoption de HTTPS :

  • Il propose des certificats gratuits reconnus par une autorité de certification et donc considérés comme étant de confiance par la très grande majorité des navigateurs.
  • Il propose également un outil open-source qui prend en charge de manière automatique la configuration du serveur web. Il était jusqu’alors difficile de configurer correctement un serveur web en HTTPS quand on ne connaît pas grand chose au fonctionnement du protocole. L’outil met en place la configuration nécessaire pour le certificat, mais aussi la configuration optimale pour avoir le maximum de sécurité tout en excluant le minimum de clients.

Continuer la lecture de Passage en HTTPS grâce à Let’s Encrypt

Mock ou pas mock ?

C’est quoi un mock ?

Avant de rentrer dans le vif du sujet, il me semble important de faire une mise au point sur les concepts dont je vais parler dans cet article.

Dans le jargon du développeur, le mot mock a tendance à être utilisé à toutes les sauces. Martin Fowler, dans l’article Mocks Aren’t Stubs, parle de différents concepts :

  • Test double : objet factice qui prétend être l’objet attendu mais dont le comportement est adapté spécifiquement aux besoins du test. Le mot double fait allusion à la doublure au cinéma. Le mot mock est souvent utilisé dans ce sens-là.
  • Dummy : objet demandé par l’API qu’on teste mais qui n’est pas utilisé lors de l’exécution du code.
  • Fake : objet qui remplit le contrat (interface) mais dont l’implémentation peut faire abstraction de certaines contraintes, ce qui fait qu’il n’est pas adapté à la production (les bases de données en mémoire en sont un bon exemple).
  • Stub : objet au comportement éventuellement configurable qui peut ne répondre que très partiellement au contrat qu’il est censé remplir. Souvent écrit spécifiquement pour un ou ensemble de tests, il peut parfois enregistrer les interactions qu’on a avec lui dans l’objectif de les vérifier par la suite.
  • Mock : objet magique au comportement pré-câblé très spécifique. Dans la plupart des langages il est nécessaire d’utiliser un outil pour générer ce genre d’objets, cet outil permettant souvent de configurer au moment de l’exécution le comportement de l’objet sous la forme : «quand on te demande ça tu fais ça».

Continuer la lecture de Mock ou pas mock ?

Puis-je avoir confiance en mes tests ?

Il existe un certain nombre d’outils permettant de fournir des métriques qui visent à mesurer la qualité d’un logiciel, notamment à travers l’analyse statique dont j’avais eu déjà l’occasion de parler. Ces métriques sont plus ou moins représentatives de la qualité du code. Mais nous permettent-elles de savoir si nous pouvons avoir confiance en notre code ?

Jusqu’à nouvel ordre, pour s’assurer que du code remplit correctement les besoins, nous n’avons pas vraiment d’autre solution que de le tester, et nous le faisons de manière aussi automatique que possible pour augmenter notre productivité. Mais nos tests sont-ils fiables ? Puis-je sortir une nouvelle version de mon produit en toute confiance ou dois-je croiser les doigts à chaque mise à jour ?

Il existe un certain nombre de façons permettant de savoir si nous pouvons avoir confiance en nos tests. Continuer la lecture de Puis-je avoir confiance en mes tests ?

Architecture multi-tenant, une fausse bonne idée ?

Les concepts de Software as a Service ou de Cloud Computing sont de plus en plus répandus dans l’informatique d’aujourd’hui. Cela a pour conséquence que les éditeurs de logiciel ne vendent plus directement un logiciel mais le service que rend leur logiciel. Cette nouvelle façon de déployer du logiciel a changé la donne dans la façon dont sont conçus ces mêmes logiciels.

Vers un déploiement simplifié

Les architectures multi-tenant (multi-entités ou multi-locataires en français) ont vocation à faire en sorte qu’un logiciel soit capable de gérer un certain nombre de clients en une seule installation. Au lieu d’installer le logiciel une fois pour chaque client, ce dernier est capable de créer des environnement virtuels distincts pour chaque client de sorte à ce que de l’extérieur les autres environnements ne soient pas du tout visibles. En fin de compte, le logiciel répond lui-même aux problématiques de déploiement.

Dans le contexte d’un prestataire de service qui souhaite vendre son service à différents clients, l’architecture multi-tenant semble être la réponse évidente. Il suffit de déployer le logiciel une fois et de créer autant d’environnements que nécessaire, et le tour est joué. L’administration d’un tel système est, du coup, relativement simple. Continuer la lecture de Architecture multi-tenant, une fausse bonne idée ?

Générer les structures de données avec AutoValue

En Java comme dans d’autres langages, nous écrivons souvent des classes qui représentent des structures de données (appelées parfois objets métier, DTO, value objects, ou encore value types). Nous appliquons très souvent le principe d’encapsulation en exposant les valeurs à travers des getters et des setters quand la structure de données est mutable.

Mais implémentez-vous systématiquement la méthode equals de votre classe ? Et la méthode hashcode ? Si c’est le cas, equals et hashcode sont-elles cohérentes ? Et quand vous ajoutez un champ, pensez-vous à mettre à jour ces deux méthodes ? Il est pourtant important que ces méthodes soient correctement implémentées, faute de quoi on peut avoir des surprises en les insérant dans une HashMap ou un HashSet par exemple. Continuer la lecture de Générer les structures de données avec AutoValue

Retour d’expérience sur Java 8 après un an d’utilisation

JavaAlors que Java vient de fêter ses 20 ans, Java 8 a soufflé il y a peu sa première bougie. J’avais suivi de loin l’évolution de Java 8 lors de son développement sans vraiment chercher à l’utiliser en pratique. Mais le hasard fait bien les choses, et Devoxx France 2014 suivait de près sa sortie. Je me suis dit que c’était l’endroit idéal pour se familiariser avec cette toute nouvelle version. Et je n’ai pas été déçu, j’ai suivi deux universités consacrées à Java 8. La première était proposée par Rémi Forax et expliquait l’histoire des lamba et comment elles ont été implémentées, la suivante était celle de José Paumard qui nous montrait toute la puissance de l’API stream. Ainsi, de retour de Devoxx je n’ai pas mis longtemps à me familiariser avec cette nouvelle version que j’utilise maintenant quotidiennement depuis un an. Il est donc temps pour moi d’en dresser un premier bilan. Continuer la lecture de Retour d’expérience sur Java 8 après un an d’utilisation

La face cachée d’AngularJS

Logo AngularJSAngularJS est une technologie très en vogue actuellement qui bénéficie depuis sa sortie d’une grande popularité dans le monde du développement web. Cette popularité est d’autant plus remarquable que l’écosystème dans lequel s’inscrit AngularJS est un des plus actifs en termes de nouveaux outils, évolutions, révolutions. Le tweet suivant tourne d’ailleurs cela à la dérision et nous propose quelques explications :

Sa popularité est d’ailleurs telle aujourd’hui qu’il est courant de rencontrer des développeurs web qui ne jurent plus que par AngularJS.
Continuer la lecture de La face cachée d’AngularJS

Reprise après quelques mois de pause

Vous l’aurez remarqué, je n’ai pas été actif sur le blog depuis l’automne dernier. Pourtant, ce ne sont pas les idées qui me manquent, je complète régulièrement ma boite à idées mais j’ai du mal à les concrétiser sous forme d’un article de blog, principalement par manque de temps.

J’ai en effet consacré beaucoup de temps en octobre et novembre dernier à préparer ma présentation Vos tests ont besoin d’amour à l’agile tour d’Aix Marseille. Comme je l’ai déjà expliqué, ce fût pour moi une très bonne expérience qui valait largement le temps que j’ai pu y consacrer. Continuer la lecture de Reprise après quelques mois de pause