Discussion :

[laliloulelo]

Bonjour tout le monde,
je suis face à un problème pour implémenter un mock dans une optique de TDD (développement piloté par les tests)
J'aimerai savoir si j'ai la bonne méthode et si vous connaissez des Framework me facilitant la création d'un mock.

J'ai une classe connexion qui possède une seule méthode et un attribut:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
using System;
 
namespace ogc
{
    class Connexion : InterfaceConnexion
    {
        private string nomUtilisateur;
 
        //propriété de nomUtilisateur
        public String NomUtilisateur{
            get {return nomUtilisateur;}
        }//nomUtilisateur
 
        public string demanderNomUtilisateur(){
            Console.Write("Nom d'utilisateur: ");
            nomUtilisateur = Console.ReadLine();
            return nomUtilisateur;
        }
    }
}

J'ai une interface toute simple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
using System;
namespace ogc
{
    interface InterfaceConnexion
    {
        string demanderNomUtilisateur();
    }
}

Et une classe de test (j'utilise le framework NUnit):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
using System;
using NUnit.Framework;
 
namespace ogc
{
 
    public class MockConnexion : InterfaceConnexion
    {
        public string demanderNomUtilisateur()
        {
            return "wogcontact";
        }
    }
 
    [TestFixture]
    public class TestConnexion
    {
        //Déclaration d'une interface de Connexion
        MockConnexion mockConnexion;
 
        [SetUp]
        public void init()
        {
            //Initialisation méthodes de test pour la classe Connexion
            mockConnexion = new MockConnexion(); //création d'un objet connexion
        }
 
        [Test]
        public void testDemanderNomUtilisateur()
        {
            Assert.Greater(mockConnexion.demanderNomUtilisateur().Length, 0, "Nom d'utilisateur incorrect égal à 0");
        }
 
        [TearDown]
        public void close() { }
    }
}

Si j'essaye d'expliquer ce que j'ai voulu faire, j'ai créé un bouchon(stub) implémentant mon interface en redéfinissant la méthode demandeNomUtilisateur. Je peux de cette manière lancer mes tests automatisés sur une classe sans attendre une valeur en retour de la part de l'utilisateur.
Je me pose alors une question: comment créer un mock à partir de ça pour tester ma méthode:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
public string demanderNomUtilisateur(){
            Console.Write("Nom d'utilisateur: ");
            nomUtilisateur = Console.ReadLine();
            return nomUtilisateur;
        }

Et pas pour tester une redéfinition de celle ci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
public string demanderNomUtilisateur()
        {
            return "wogcontact";
        }

Je sais pas si j'ai été très clair, mais je débute dans le TDD.
Est ce que mon salut se trouve du coté de Moq ou Rhino ?

[Guulh]

Rhino Mocks ou Moq sont effectivement des librairies de mocks courantes et éprouvées.

Par contre, là, ton test ne sert à rien, puisque c'est le mock que tu testes... L'idée des tests unitaires, c'est que si tu conçois correctement tes classes, alors tu peux les tester séparément. Donc si t'as une classe Bidule à tester, qui a une propriété de Type IMachin (concrétisée dans ton code par une classe Machin), tu peux tester Bidule en créant un mock de IMachin. avec Rhino Mocks ça ressemble à ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
MockRepository mocks = new MockRepository();
Bidule b = new Bidule(); // la classe à tester
IMachin stubMachin = mocks.Stub<IMachin>();
stubMachin.Name = "Bob";
b.Machin = stubMachin;
Assert.IsEqual(b.GetLength(), 3);

Dans cet exemple, on suppose que Bidule a une méthode GetLength, que l'on veut tester, qui est sensé renvoyer la longueur du nom du Machin.

L'idée, c'est que bien que Bidule et Machin fonctionnent ensemble dans ton appli, tu peux tester Bidule sans créer de Machin. Tu demandes à Rhino Mocks de te créer un IMachin.

Je te recommande le tuto du site de Rhino Mocks, il est assez bien fichu (même si on s'y perd parfois entre les différents types de mocks, de stubs, ...)

[laliloulelo]

Merci pour ta réponse.
J'ai du mal à comprendre la différence entre mock stub et fake.
En fait je dois tester des fonctionnalités si j'ai bien compris ?

Je n'ai pas à tester les éventuelles réponses de l'utilisateur (gestion de cas) pour ma chaîne de caractère mais bien tester que ma fonctionnalité est bonne.

Je vais continuer mes recherches et tenter de comprendre mieux quelles sont mes difficultés.

[Guulh]

Merci pour ta réponse.
J'ai du mal à comprendre la différence entre mock stub et fake.

Cette page détaille bien les caractéristiques de chacun:
http://www.martinfowler.com/articles...nMocksAndStubs (les articles de Martin Fowler en général sont très intéressants)

En fait je dois tester des fonctionnalités si j'ai bien compris ?

Ben euh oui. Tu voudrais tester quoi d'autre ?

Je n'ai pas à tester les éventuelles réponses de l'utilisateur (gestion de cas) pour ma chaîne de caractère mais bien tester que ma fonctionnalité est bonne.

L'idée des tests est de s'assurer que le comportement de la méthode à tester, avec certains inputs, est bien celui attendu. Certains méthodes n'ont pas besoin de mocks/stubs (une méthode pour tester une méthode addition, un Assert.IsEqual(x.Add(5+3), 8) suffit), d'autres en ont besoin, et c'est là que les frameworks comme Rhino interviennent.

Ce qu'ils permettent aussi, avec la notion de Playback / Replay, est de s'assurer que la méthode en cours de test a bien appelé telle ou telle méthode de ton mock. Qui, pour le coup, est un StrictMock.

Mais va plutôt voir le tuto de Rhino Mocks, il est bien mieux fichu que mon post tapé d'une main en mangeant mon sandwich

Je vais continuer mes recherches et tenter de comprendre mieux quelles sont mes difficultés.

Bon chance dans ta quête

[laliloulelo]

Bon ça y est je pense avoir réussi à mocker ma fonction par contre j'ai du mal à la tester correctement. Peu de Doc sur Moq, je pêche.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using Moq;
using NUnit.Framework;
using System;
 
namespace main{
    [TestFixture]
    public class testConnexion{
        [Test]
        public void testUtilisateurCorrect(){
            var mockUtilisateurCorrect = new Mock<IConnexion>();
            //mockUtilisateurCorrect.Setup(x => x.demanderNomUtilisateur()).Returns("test");
            mockUtilisateurCorrect.VerifyGet(x => x.demanderNomUtilisateur(), "test");
            var connecteur = new Connecteur(mockUtilisateurCorrect.Object);
        }
    }
 
    public class start{
        static void Main(string[] args){
        }
    }
 
    public class Connecteur{
        private IConnexion Connexion { get; set; }
        //Dependance injection
        //constructeur
        public Connecteur(IConnexion connexion){
            Connexion = connexion;
        }
        public void lancerConnecteur(){
            Console.WriteLine(Connexion.demanderNomUtilisateur());
        }        
    }
 
    public interface IConnexion{
        string demanderNomUtilisateur();
    }
 
    public class Connection : IConnexion{
        public string demanderNomUtilisateur(){
            return "";
        }
    }
}

Par exemple si je suis dans une optique de TDD j'ai pour objectif de réaliser le test de ma fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
       public string demanderNomUtilisateur(){
            return "";
        }

Et c'est la que mon inexpérience se fait ressentir. Pouvez vous me donner un exemple de test que je devrais réaliser avant de réaliser ma fonction?

J'ai pensé à ces tests:
s'assurer que ma chaîne de retour est bien une chaîne de caractère
s'assurer que la longueur de ma chaine est supérieure à 0.

[laliloulelo]

Je commence à comprendre certains concepts et tu avais raison Guulh, Rhino est plus facile d'accès.
Je continue mes recherches et mes tests, si j'ai un peu de temps, je me lancerai dans la réalisation d'un tutoriel pour le TDD pour les nuls. Si ça peut m'aider à mieux conceptualiser et capitaliser ce que j'ai appris ce sera tout benef