Le TDD n'est pas naturel mais très addictif!

Danger

Il faut faire très attention! : un peu comme la chirurgie esthétique, le TDD n'est pas une démarche naturelle mais une fois qu'on y a goûté, cette démarche a un fort pouvoir addictif! (désolé, je n'ai pas trouvé mieux comme métaphore :-))

extrait Nip Tuck

Le TDD c'est :

Le TDD signifie Test Driven Developpement ou Développement Dirigé par les Tests. Comme son nom l'indique c'est une méthode de développement basé (et même dirigé par les tests). L'idée principale est, pour développer une fonctionnalité, de faut d'abord l'exprimer sous forme de tests et d'ensuite développer la fonctionnalité pour faire passer le Test.

On entend souvent parler de "red, green, refactor" pour décrire le TDD :

- D'abord écrire un test qui échoue (vous exécutez votre test dans votre IDE et "la barre est rouge")

- Ecrire le code pour que le test passe  (vous exécutez votre test dans votre IDE et "la barre est verte")

- Refactorer le code pour le rendre clair, lisible, limpide pour fair simple : beau!

Me

Pfff... Après y avoir goûté, on se retrouve à porter des tee-shirts ridicules de geek sur le TDD... :-)

Une des pratiques du TDD poussée à l’extrême est le "TDD as you meant it" qui consiste globalement à tout écrire dans la classe de test (même le code pour faire passer le test) et de ne déplacer les méthodes en refactorant qu'une fois que le test passe.

Constat:

Le TDD n'est pas une démarche naturelle. C'est quelque chose qui fait partie de l'évolution du développeur. En revanche quand on y a goûté, c'est une démarche qui parait naturelle et qu'on a envie de reproduire.

Evolution de l'homme

Quand on commence sa vie de développeur, on ne commence pas à directement faire du TDD. Je pense que la démarche est de d'abord comprendre la technologie, le langage et ses concepts avant de faire des Test Unitaires puis du TDD. Vous souvenez vous de la première ligne de code Java que vous avez écrite?

C'était plutôt ça :

public static void main(String[] args) {
        System.out.println("hello world");
    }

ou plutôt ça :

@Test
public void shouldSayHelloWorld() throws Exception {
    HelloWorld hello = new HelloWorld();
    assertThat(hello.say()).isEqualTo("Hello World");
}

Moi, par exemple, j'ai commencé par la première façon pas par la deuxième. J'imagine que pour beaucoup d'autres nous (les développeurs) c'était aussi le cas. CQFD :

Le TDD n'est pas une démarche facile et naturelle!

Le TDD est une démarche vers laquelle un développeur peut, suivant son évolution et son contexte, avoir envie d'adopter. Cette évolution n'est pas forcément liée à un facteur temps: l'adoption peut être rapide ou ne jamais arriver.

La difficulté du TDD est que pour vraiment comprendre la démarche, je pense qu'il faut l'avoir pratiqué ou l'avoir vu pratiquer. Je pense qu'il est donc difficile de convaincre quelqu'un de faire du TDD simplement en échangeant sur le sujet. La meilleure solution dans ce cas, c'est de lui proposer d'essayer!

Envie d'y goûter?

Pour illustrer l'idée, je vais reprendre la désormais célèbre scène de Matrix : la pilule bleu ou la pilule rouge. L'idée c'est donc ça :

extrait Matrix

• Si tu ne dors plus la nuit car tu n'as pas confiance dans le code de ton application
• Si tu es fatigué après chaque modification de code de devoir passer en mode debug pour voir comment se comporte ton code
• Si à chaque message de commit tu as envie d'écrire "banzaï, on verra bien si ça marche"
• Si tu as peur de refactorer ton code par peur de tout casser
• Si tu ne sais pas comment concevoir ton application car cela te parait trop compliqué et que tu aimerais commencer simplement...

C'est que tu es forcément attiré une autre réalité... et la pilule rouge du Tests Unitaires et du TDD te fait de l'oeil.

A la différence de Matrix, une fois que vous avez pris la pilule rouge, il vous reste encore tout à faire... Comment concrètement vous y mettre :

• Allez à un coding Dojo
• Allez à un code retreat (retour ici ou ici)
• Demander à google

Les outils gravitant autour des tests unitaires du TDD (Java oriented):
Il existe une ensemble d'outillage pour vous aider à faire du TDD :

• une librairie de tests unitaires : JUnit. Le framework de base pour faire des tests unitaires en Java.
• des facilitateurs technologique : *Unit. Ces librairies ont pour but de venir en complément pour simplifier les tests liés à certaines technologies (DBUnit vous aidera sur des tests avec une BDD relationnelle, JWebUnit vous aidera sur des tests avec une application WEB , HtmlUnit vous aidera à tester du HTML, XmlUnit vous aidera à tester du Xml, CassandraUnit vous aidera sur des tests avec Cassandra...)
• des facilitateurs sur la lisibilité du test (notamment sur les assertions) : Hamcrest ou Fest-Assert.
• les librairies de Mock : Les objets "mocké" sont globalement des objets utilisés dans les tests dont on maîtrise le comportement pour tester d'autres objets (JMock ou Mockito par exemple).
• des librairies s'intégrant dans votre IDE pour faire du test en continu comme InfiniTest.

Le TDD partout?

C'est toujours plus facile à dire qu'à faire. Hum, tout un débat possible en perspective... Je ne suis pas un intégriste sur la question, je dirais simplement qu'il y a parfois beaucoup moins de plus value à faire du TDD sur certains couches applicatives... Par exemple, faire du TDD pour tester que quand on clique sur un bouton et bien ça clique sur le bouton...

Le TDD sur du code existant
Oui et oui. Cet article de Xebia ici l'explique d'ailleurs très bien.

Pour conclure

Je pense qu'il y a un réel fossé entre un développeur qui a déjà fait du TDD et un qui n'en a jamais fait. Chacun trouve d'ailleurs que l'autre est un extra terrestre :-). Je pense qu'une fois de plus, c'est une démarche très intéressante que j'ai adoptée mais je comprend aussi que dans certains contextes il est difficile de la mettre en oeuvre. De toute façon, le TDD, c'est un peu la cerise sur le gâteau, car il est très difficile d'expliquer les avantages du TDD lorsqu'il faut parfois commencer par expliquer l'avantage de faire des tests!

Le plus simple en tous cas avec le TDD pour vous faire votre propre avis, c'est d'y goûter :-)

xml vs json vs yaml (Java oriented)

Il existe aujourd'hui un ensemble de format permettant de stocker des données. Il y a du choix!

On connait historiquement le format XML mais d'autres formats sont de plus en plus utilisés tels que JSON ou YAML.

Je vous propose ici de faire une petit comparaison de ces 3 formats notamment lorsqu'on doit faire de la sérialisation/déserialisation en Java.

XML : "le classique"

Le bon "vieux" format XML est un standard incontournable de stockage de données.

Ses forces :

• Il est clairement fortement répandu, voir incontournable.
• Il possède des langages de description permettant de contractualiser le contenu : DTD (Document Type Definition) ou XML Schema.
• Il est très outillé.
• Il est lisible.

Ses faiblesses :

• Il est très (trop) verbeux.
• "complexe" à mettre en oeuvre.

Comment on fait en java? 

Il existe plusieurs type d'APIs pour "discuter XML" en Java. Dans une première approche, Il existe JDOM  qui propose 2 orientations. La première est orienté "DOM" qui est de créer une représentation des données (non typé, à base de classe JDOM) XML en JAVA en mémoire. la seconde est orienté "SAX" qui est une APIs évènementielle qui parcourt le document et sur lequel on vient se câbler pour récupérer des morceaux de document.

Du coté des APIs plus haut niveau, JIBX ou JAXB (notamment dans sa version 2) offre un environnement de travail complet sérialiser/déserialiser. Elles permettent notamment de manipuler en java des objets typés.

Si on prend l’exemple de JAXB, l'idée est :

• de récupérer ou créer le XML Schema représentant le document que l'on souhaite sérialiser/déserialiser (c'est le "contrat")
• de générer avec XJC (outil de génération de classes de JAXB) les classes (annotées) correspondants à la structure du document. Un plugin maven permet d'intégrer ça au process de build : jaxb2-maven-plugin
• à l’exécution, utiliser les APIs JAXB avec les classes générés pour écrire ou lire du XML.

Voilà ce que cela peut donner : 

Pour déserialiser : 

JAXBContext jc = JAXBContext.newInstance(User.class);
Unmarshaller unmarshaller = jc.createUnmarshaller();
SchemaFactory sf = SchemaFactory.newInstance(javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = sf.newSchema(this.getClass().getResource("/user.xsd"));
unmarshaller.setSchema(schema);
User user = (User) unmarshaller.unmarshal(new File("user.xml"));

Pour sérialiser :

Marshaller marshaller = jc.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, 
  Boolean.TRUE);
marshaller.marshal( user, new File("user-modified.xml") );

C'est un peu verbeux mais ça marche bien :-)

JSON : "à la mode"

Ses forces :

• Il est très à la mode et très répandu.
• Il est bien outillé.
• Il est peu verbeux.

Ses faiblesses :

• Il est peu lisible.
• Il n'existe pas de format de définition de schéma (seulement un draft).

Je trouve le JSON moins lisible pour un humain mais il est souvent utilisé comme format d'échange inter applicatif (entre un client et un serveur par exemple) où le but n'est pas qu'il soit lisible mais qu'il soit léger et concis. C'est un format qui est notamment beaucoup utilisé dans les architectures REST.

Comment je fais en java?

Il existe pas mal de librairies permettant de faire la sérialisation/désérialisation en JAVA. Pour en citer quelques unes : json-lib, google-gson, FlexJSON ou encore Jackson. C'est cette dernière que j'utilise en général. 

Dans le cas de Jackson par exemple, l'APIs pour sérialiser/désérialiser en Java est très simple, il n'y a aucun impact sur votre code. Vous pouvez utiliser vos classes existantes et les sérialiser.

Pour désérialiser :

ObjectMapper mapper = new ObjectMapper(); // can reuse, share globally
User user = mapper.readValue(new File("user.json"), User.class);

Pour sérialiser :

mapper.writeValue(new File("user-modified.json"), user);

C'est tout...

YAML : "l'anti balise"

Sa force :

• Il est très peu verbeux.
• Il est très lisible.

Ces faiblesses :

• Il est moins connu et moins répandu.

Le YAML regroupe 2 points très intéressants : il est très lisible et peu verbeux. Comme le précise le site de YAML, son objectif est d'être "human friendly".

Comment je fais en java?
Il y a quelques librairies en java permettant de faire le job : JYaml et SnakeYAML. C'est d'ailleurs cette dernière que j'utilise.

Dans le cas de SnakeYAML, comme pour Jackson avec JSON, il n'y a aucun impact en terme de code et vous pouvez réutiliser vos classes existantes en l'état.

Pour désérialiser :

Yaml yaml = new Yaml();
User user = yaml.loadAs(new File("user.yaml"), User.class);

Pour sérialiser:

Yaml yaml = new Yaml();
yaml.dump(user,new FileWriter("user-modified.yaml"));

C'est tout aussi...

Comparons : 

Bon, et maintenant si on faisait un petit test en exprimant la même chose dans les 3 formats et en regardant le résultat. Je vais baser l'exemple en exprimant un dataSet de CassandraUnit. On peut exprimer un dataSet dans ces 3 formats.

Voici donc une première version xml :

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<keyspace xmlns="http://xml.dataset.cassandraunit.org">
    <name>otherKeyspaceName</name>
    <strategy>org.apache.cassandra.locator.SimpleStrategy</strategy>
    <replicationFactor>1</replicationFactor>
    <columnFamilies>
        <columnFamily>
            <name>beautifulColumnFamilyName</name>
            <type>STANDARD</type>
            <keyType>UTF8Type</keyType>
            <comparatorType>LongType</comparatorType>
            <row>
                <key>key10</key>
                <column>
                    <name>11</name>
                    <value>utf8(value11)</value>
                </column>
                <column>
                    <name>12</name>
                    <value>utf8(value12)</value>
                </column>
            </row>
            <row>
                <key>key20</key>
                <column>
                    <name>21</name>
                    <value>uuid(13816710-1dd2-11b2-879a-782bcb80ff6a)</value>
                </column>
            </row>
        </columnFamily>
        <columnFamily>
            <name>columnFamilyWithCompositeType</name>
            <type>STANDARD</type>
            <keyType>CompositeType(LongType,UTF8Type)</keyType>
            <comparatorType>CompositeType(UTF8Type,IntegerType,UTF8Type)</comparatorType>
            <defaultColumnValueType>UTF8Type</defaultColumnValueType>
            <row>
                <key>10:azerty</key>
                <column>
                    <name>aa:10:aa</name>
                    <value>Chuck</value>
                </column>
                <column>
                    <name>aa:10:ab</name>
                    <value>Larry</value>
                </column>
            </row>
        </columnFamily>
    </columnFamilies>
</keyspace>

Voici le même dataSet exprimé en JSON :

{
    "name" : "otherKeyspaceName",
    "replicationFactor" : 1,
    "strategy" : "org.apache.cassandra.locator.SimpleStrategy",
    "columnFamilies" : [{
        "name" : "beautifulColumnFamilyName",
        "type" : "STANDARD",
        "keyType" : "UTF8Type",
        "comparatorType" : "LongType",
        "rows" : [{
            "key" : "key10",
            "columns" : [{
                "name" : "11",
                "value" : "utf8(value11)"
            },
            {
                "name" : "12",
                "value" : "utf8(value12)"
            }]
        },
        {
            "key" : "key20",
            "columns" : [{
                "name" : "21",
                "value" : "utf8(value11)"
            },
            {
                "name" : "12",
                "value" : "uuid(13816710-1dd2-11b2-879a-782bcb80ff6a)"
            }]
        }]
    },
    {
        "name" : "columnFamilyWithCompositeType",
        "type" : "STANDARD",
        "keyType" : "CompositeType(LongType,UTF8Type)",
        "comparatorType" : "CompositeType(UTF8Type,IntegerType,UTF8Type)",
        "defaultColumnValueType" : "UTF8Type",
        "rows" : [{
            "key" : "10:azerty",
            "columns" : [{
                "name" : "aa:10:aa",
                "value" : "Chuck"
            },
            {
                "name" : "aa:10:ab",
                "value" : "Larry"
            }]
        }]
    }]
}

Enfin, toujours le même dataSet exprimé en YAML :

name: otherKeyspaceName
replicationFactor: 1
strategy: org.apache.cassandra.locator.SimpleStrategy
columnFamilies:
- name: beautifulColumnFamilyName
  type: STANDARD
  keyType: UTF8Type
  comparatorType: LongType
  rows:
  - key: key10
    columns:
    - {name: 11, value: utf8(value11)}
    - {name: 12, value: utf8(value12)}
  - key: key20
    columns:
    - {name: 21, value: utf8(value11)}
    - {name: 12, value: uuid(13816710-1dd2-11b2-879a-782bcb80ff6a)}
- name: columnFamilyWithCompositeType
  type: STANDARD
  keyType: CompositeType(LongType,UTF8Type)
  comparatorType: CompositeType(UTF8Type,IntegerType,UTF8Type)
  defaultColumnValueType: UTF8Type 
  rows:
  - key: "10:azerty"
    columns:
    - {name: "aa:10:aa", value: Chuck}
    - {name: "aa:10:ab", value: Larry}

et là on se dit, tiens, c'est sympa le YAML :-).

Pour exprimer la même chose, il aura fallu :

• 1131 octets au format XML (non formaté)
• 793 octets au format JSON (non formaté)
• 779 octets au format YAML

Conclusion

L'objet de cet article n'est pas de dire qui est le meilleur. Le cas de stockage de DataSet est en effet particulier car un des critères est justement qu'il soit "human readable" mais ce qui est surprenant c'est qu'au final, c'est YAML qui est le plus lisible mais aussi le plus concis.

En général, chacun de ces formats est utilisés dans des contextes différents même s'il est vrai que le XML et le JSON, qui sont plus répandus, sont souvent opposés en terme de comparaison : 

web services SOAP/XML vs web services REST/JSON. 

Oui le XML est plus verbeux que le JSON mais il est plus "contractuel". 

On retrouve en revanche plus le format YAML comme format de fichiers de configuration comme c'est le cas pour le fichier de configuration de Cassandra par exemple. Je trouve en tous cas ce format de fichier comme une alternative intéressante qu'il ne faut pas oublier!

CassandraUnit : un outil Dev & Ops!

CassandraUnit est un framework permettant de vous aider à développer des applications Java basé utilisant Cassandra.

Depuis la version 1.0.1.4, C'est maintenant un outil à la fois Dev & Ops, car il peut vous accompagner dans toutes les phases de votre projet :

Un outil @Dev:
CassandraUnit est initialement né de la volonté de vouloir faire du TDD en testant aussi la persistance dans Cassandra. Le but était de répondre à 2 problématiques : 

• Comment développer un service de lecture de données dans Cassandra en faisant du TDD sans avoir de cluster Cassandra?
• Comment faire en sorte que mes tests unitaires soient portables et isolés pour pouvoir faire de l'intégration continue?

L'idée directrice était de proposer un environnement au niveau des tests unitaires qui permettent avant leur exécution :

• de démarrer une instance embarquée de Cassandra.
• de remplir cette instance avec un keyspace et des données.

Comment ça marche ?

Il faut dans un premier temps définir votre dataSet, C'est le jeu de données qui sera inséré dans Cassandra pour votre test unitaire.

CassandraUnit vous permet selon votre préférence de définir un dataSet au format XML, JSON ou Yaml ( plus d'infos ici)

Il faut ensuite l'intégrer au niveau de votre test ou de votre code. Il est possible de faire ça de plusieurs manières :

• soit de manière native en manipulant l'APIs (donc pas forcément dans un test) : 

EmbeddedCassandraServerHelper.startEmbeddedCassandra();
DataLoader dataLoader = new DataLoader("TestCluster", "localhost:9171");
dataLoader.load(new ClassPathJsonDataSet("simpleDataSet.json"));

• soit par héritage au niveau de votre classe de Test :

public class yourTest extends AbstractCassandraUnit4TestCase {

    @Override
    public DataSet getDataSet() {
        return new ClassPathJsonDataSet("simpleDataSet.json");
    }

    @Test
    public void shouldHaveLoadASimpleDataSet() throws Exception {
        assertThat(getKeyspace(), notNullValue());
        /* and query all what you want */
    }

}

• soit sans héritage! merci Junit @Rule

public class SecondaryIndexWithRuleTest {

    @Rule
    public CassandraUnit cassandraUnit = new CassandraUnit(new ClassPathJsonDataSet("simpleDataSet.json"));

    @Test
    public void shouldHaveLoadASimpleDataSet() throws Exception {
        assertThat(getKeyspace(), notNullValue());
        /* and query all what you want */
    }

}

Un outil @Ops
Depuis la version 1.0.1.4, CassandraUnit propose un outil en ligne de commande multi OS : le "cu-loader".

Cet outil en ligne de commande permet de réutiliser vos dataSets pour créer vos keyspaces et/ou charger vos données dans d'autres cluster Cassandra que votre instance de Cassandra embarquée en @Dev.

L'outil permet de réutiliser les dataSets sans les modifier mais avec la possibilité de surcharger certaines déclaration liées à la configuration du cluster Cassandra (comme le replication factor, la stratégie, ...).

L'objectif de l'outil est d'éviter d'introduire des erreurs liées au changement d'environnement en créant un keyspace qui ne correspondrait au keyspace utilisé en développement.

CassandraUnit est diponible sous forme de distribution téléchargeable depuis github ici ainsi que sur le repo central maven. Il suffit donc de le décompresser et de rajouter

Voici ce que ça donne à l'utilisation :

> cu-loader
Missing required options: f, h, p
usage: CassandraUnitLoader is a tool to load CassandraUnit data Set into cassandra cluster
 -f,--file <arg>                dataset to load
 -h,--host <arg>                target host (required)
 -o,--onlySchema                only load schema (optional)
 -p,--port <arg>                target port (required)
 -r,--replicationFactor <arg>   override the replication factor set in the dataset (optional)
 -s,--strategy <arg>            override the strategy set in the dataset (optional)

Un exemple simple :

> cu-loader -f datasetDefaultValue.xml -h localhost -p 9160

Un exemple complet :

> cu-loader -f datasetDefaultValue.xml -h 10.10.10.01 -p 9160 -o -r 3 -s org.apache.cassandra.locator.NetworkTopologyStrategy

Vous trouverez plus de détails dans le doc ici

Voici des liens qui pourront vous être utile si vous voulez aller plus loin :
- github : https://github.com/jsevellec/cassandra-unit/
- mailing list : https://groups.google.com/group/cassandra-unit-users?hl=fr
- twitter : https://twitter.com/cassandraunit

Bref. Un bel outil. :-)