Premiers pas avec IntelliTest

Les ayatollahs du TDD vont, sans doute, crier au scandale mais soyons objectifs : si l’on pouvait générer automatiquement des tests unitaires à partir du code que l’on vient d’écrire, qui ne voudrait pas s’en servir ? Avec IntelliTest, c’est bien ce que propose Visual Studio 2015 en version Enterprise. En analysant et en instrumentant votre code, cet outil est capable de déterminer un ensemble de tests unitaires qui sont pertinents tout en assurant une couverture de code maximale. Voyons plus en détail ce que cela donne.

Exemple de code à tester

Pour les besoins de cet article, voici le code qui devra être testé :

public int Calcul(int a, int b, int c)
{
    if (a < b && b > c)
    {
        if (b == 5)
        {
            throw new Exception("b doit être différent de 5");
        }

        return a*b*c;
    }
    else if (a < b && b < c)
    {
        return a/b*c;
    }
    else
    {
        if (a > b && b > c)
        {
            return a + b - c;
        }
    }

    return 0;
}

En utilisant les outils d’analyse de Visual Studio, il est possible de calculer la complexité cyclomatique de cette méthode : 8. Ce qui signifie qu’il faut au minimum 8 tests différents afin de tester tous les chemins possibles d’exécution de ce code.

IntelliTest et ses résultats

Lançons maintenant IntelliTest : à l’aide d’un clic droit sur le nom de la méthode, sélectionnez l’option « Run IntelliTest » :

run intellitest

La fenêtre ci-dessous devrait s’ouvrir et contenir les résultats des tests générés automatiquement :

intellitest results

La première constatation que l’on peut faire est que 3 des 8 tests sont en erreur. Remarquez que le nombre de tests est bien égal à la complexité cyclomatique de la méthode, ainsi toutes les portions du code sont testées. Le second élément que l’on peut remarquer est la génération des paramètres. Dans mon algorithme, j’ai une division par b et chacun sait que si b est égal à zéro, le code générera une exception. C’est ce que l’on peut voir à la ligne sept : l’outil a détecté cette division et a fourni les bons paramètres pour tester ce cas de figure. Les paramètres ne sont donc pas générés au hasard mais bien déterminés suite à une analyse du code.

Enregistrer les tests générés

Maintenant que l’on a vu qu’il était possible de générer les tests unitaires de manière dynamique, voyons comment les pérenniser. Comme le montre la capture ci-dessous, sélectionnez l’ensemble des tests et cliquez sur l’icône en forme de disquette pour les sauvegarder.

save tests

IntelliTest va alors créer un nouveau projet et y insérer le code correspondant aux tests :

generated tests

Ces nouveaux tests pourront alors être joués comme n’importe quel autre test unitaire.

test explorer

Allons un peu plus loin …

Dans l’algorithme, si b est égal à 5, dans certains cas, une exception est levée. Si ce mécanisme correspond à un fonctionnement normal, vous pouvez l’indiquez à vos tests. Pour cela, sélectionnez la ligne comportant l’exception et à l’aide d’un clic droit sélectionnez « Allow ». Ainsi votre test apparaitra en vert lorsque l’exception sera générée :

allow exception

Si vous modifiez vos tests, par exemple en remplaçant « return a/b*c; » par « return a*b/c; » vous pourrez constater que vos tests vont évoluer en conséquence. Il n’y a donc rien de figé.

code change

Dernier point des plus remarquables, vous avez la possibilité de contraindre vos tests. Voici le code source du test généré :

[PexMethod]
[PexAllowedException(typeof (Exception))]
public int Calcul(
    [PexAssumeUnderTest] Compute target,
    int a,
    int b,
    int c
    )
{
    PexAssume.AreEqual(3, a);

    var result = target.Calcul(a, b, c);

    PexAssume.IsTrue(result > -10);
    PexAssume.IsTrue(result < 20);

    PexAssert.AreNotEqual(0, result);

    return result;
}

Les méthodes de la classe « PexAssume » permettent de contraindre les différents paramètres du test. Ainsi, dans mon exemple, a sera toujours égal à 3 et le résultat sera toujours compris en -10 et 20. Tandis que les méthodes de « PexAssert » vont forcer le test à trouver un résultat qui échoue. Avec ces différents outils, vous avez donc la possibilité d’avoir des tests correspondants réellement à vos exigences comme en témoigne le résultat ci-dessous :

pexassert_assume

Conclusion

J’espère que cet article vous aura permis de découvrir un outil qui devrait vous faciliter la vie. Bien évidemment rien ne pourra jamais écrire les tests à votre place, mais toute aide est la bienvenue. Et à mon sens c’est bien tout l’avantage de cette technologie : vous écrivez les tests complexes et IntelliTest se charge des tests simples trop fastidieux à écrire. Il ne reste plus qu’à l’inclure dans vos projets, vous pourrez alors le tester en condition réelle.

Pas de commentaire

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *