Les tests unitaires avec la librairie JMock

Un test unitaire est un test sur une partie du code dans une classe en bouchonnant les appels à des méthodes de classes extérieures. Ici, il n'est pas question de connexion à une base de données, de déploiement sur un serveur d'applications particulier mais bien simplement du test d'une partie du code bien précise.

Il est primordial pour toute équipe de développement en Java/J2EE d'intégrer des tests unitaires à leur programme. Cela évite des livraisons avec des bugs standards tel que le NullPointerException, les variables vides, etc...

L'utilisation de la librairie JMock version 1.2, par exemple, permet non seulement de faire des tests unitaires de manière simple mais elle nécessite, également, une structuration de code correcte avec l'utilisation du framework Spring. En effet, l'utilisation d'interface pour des classes qui implémente des méthodes publiques est obligatoire, la systématisation des injections Spring devient presque une nécessité. Ceci afin de rendre l'implémentation des tests unitaires la plus simple et productive possible.

Lors de l'utilisation de JMock, la classe de test doit simplement étendre la classe MockObjectTestCase. Ensuite, il faut passer par la méthode setUp pour créer les objects Mock et bouchonner les objets externes à la classe qu'on est entrain de tester. Il faut utiliser la notation @Test pour déclarer tes méthodes de test à partir de Java 1.5.

Voilà un peu de code pour aider à la compréhension de l'implémentation de JMock:

Java
public class MaClasseATesterTest extends MockObjectTestCase {

    // déclaration  d'un objet Mock :
    private Mock maClasseExterneMock;
    private MaClasseATesterImpl maClasseDeTest 
                                             =  new MaClasseATesterImpl();

    private void setUp() {
        // Création de l'objet Mock => ATTENTION ici il faut utiliser 
       // une interface. MaClasseExterne est l'interface de
       //  la classe MaClasseExterneImpl
        maClasseExterneMock 
                                         = new Mock(MaClasseExterne.class);         

        // Initialisation du bouchon
        maClasseDeTest.setMaClasseExterne((MaClasseExterne) maClasseExterneMock.proxy());
    }

    // Première methode de test
    @Test
    public void maMethodeDeTest() {
        // Code d'initialisation de variables
        ....

        // Expectations => On déclare ici que le code a tester va 
        // rencontrer un seul appel (mot clé once()) à une méthode
        // externe appelée maMethodeExterne et que cette méthode
        // devrait renvoyée la valeur valeurPrevueRetourneeParMaMethodeExterne 
        //qui peut être n'importe quel objet sensé être renvoyé par la 
        // méthode => c'est le bouchon ! :)

      maClasseExterneMock.expects(once()).
                       method("maMethodeExterne").withAnyArguments().
                                  will(returnValue(valeurPrevueRetourneeParMaMethodeExterne));  
         
        // Appel à la méthode à tester
        callMethodeATester(..);


        // Vérification finale que la méthode externe a bien été appelée
        maClasseExterneMock.verify();
    }
}

Voilà il n'y a rien de mieux que du code pour mieux comprendre le fonctionnement d'un framework.

Si vous avez des questions, les commentaires sont là pour ça... Si l'article vous a plus, n'hésitez pas non plus à le dire :)