Comment puis-je utiliser des objets factices dans mes tests unitaires et toujours utiliser la couverture de code?

Actuellement, je suis en commençant à introduire le concept d'objets Fantaisie dans mes Tests Unitaires. En particulier, je suis en utilisant le Moq cadre. Cependant, une des choses que j'ai remarqué, c'est que, soudain, les cours que je suis en essais à l'aide de ce cadre sont montrant la couverture de code de 0%.

Maintenant, je comprends que depuis que je suis tout juste de se moquer de la classe, ce n'est pas l'exécution de l'effectif de la classe elle-même....mais comment puis-je écrire ces tests et ont de Couverture de Code de retour des résultats précis? Dois-je écrire un ensemble de tests qui utilisent des objets fantaisie et un jeu d'instancier la classe directement.

Peut-être que je fais quelque chose de mal sans s'en rendre compte?

Voici un exemple de moi en essayant de Test de l'Unité d'une classe appelée "MyClass":

using Moq;
using NUnitFramework;

namespace MyNameSpace
{
    [TestFixture]
    public class MyClassTests
    {

        [Test]
        public void TestGetSomeString()
        {
            const string EXPECTED_STRING = "Some String!";

            Mock<MyClass> myMock = new Mock<MyClass>();
            myMock.Expect(m => m.GetSomeString()).Returns(EXPECTED_STRING);

            string someString = myMock.Object.GetSomeString();

            Assert.AreEqual(EXPECTED_STRING, someString);
            myMock.VerifyAll();

        }

    }

    public class MyClass
    {
        public virtual string GetSomeString()
        {
            return "Hello World!";
        }
    }
}

Personne ne sait ce que je dois faire différemment?

source d'informationauteur mezoid

.net c#code-coverage moq unit-testing

Vous n'êtes pas à l'aide de votre maquette correctement les objets. Lorsque vous utilisez des objets fantaisie que vous vouliez tester la façon dont votre code interagit avec d'autres objets sans l'aide de l'objet réel. Voir le code ci-dessous:

using Moq;
using NUnitFramework;

namespace MyNameSpace
    {
        [TestFixture]
        public class MyClassTests
        {

            [Test]
            public void TestGetSomeString()
            {
                const string EXPECTED_STRING = "Some String!";

                Mock<IDependance> myMock = new Mock<IDependance>();
                myMock.Expect(m => m.GiveMeAString()).Returns("Hello World");

                MyClass myobject = new MyClass();

                string someString = myobject.GetSomeString(myMock.Object);

                Assert.AreEqual(EXPECTED_STRING, someString);
                myMock.VerifyAll();

            }

        }

        public class MyClass
        {

            public virtual string GetSomeString(IDependance objectThatITalkTo)
            {
                return objectThatITalkTo.GiveMeAString();
            }
        }

        public interface IDependance
        {
            string GiveMeAString();
        }
    }

Il ne regarde pas comme il est en train de faire quelque chose d'utile lorsque votre code est juste retourner une chaîne de caractères sans aucune logique derrière elle.

Le vrai pouvoir vient, si vous GetSomeString() méthode n'a un peu de logique qui peuvent changer le résultat de la chaîne de sortie en fonction du retour de la IDependdance .GiveMeAString() méthode, vous pouvez voir comment votre méthode de poignées de mauvaises données envoyées à partir de la IDependdance interface.

Quelque chose comme:

 public virtual string GetSomeString(IDependance objectThatITalkTo {
     if (objectThatITalkTo.GiveMeAString() == "Hello World")
     return "Hi";
 }

Maintenant, si vous avez cette ligne dans votre fichier de test:

myMock.Expect(m => m.GiveMeAString()).Returns(null);

Ce qui va arriver à votre GetSomeString() méthode?

7

Grosse erreur est de se moquer de la Système Sous Test (SUT), à vous de tester autre chose. Vous devriez maquette uniquement SUT dépendances.
2

Je recommande de rester loin de se moquant de cadres jusqu'à ce que vous comprendre les interactions qui se passe ici.

De l'OMI, il est préférable d'apprendre à créer manuellement de test en double, avant de passer à un moqueur cadre par la suite. Mon raisonnement:
1. Se moquant de cadres abstraction de ce qui se passe réellement; il est plus facile de saisir les interactions si vous devez créer vos dépendances explicitement, puis suivez les tests dans le débogueur.
2. Il est facile d'utilisation abusive des cadres. Si vous roulez votre propre lorsque vous êtes en train d'apprendre, vous êtes plus susceptible de comprendre les différences entre les différents types de test en double. Si vous consultez directement un moqueur cadre, il est facile à utiliser se moque quand vous vouliez talons et vice versa -- il y a une grande différence.
Pensez-y de cette façon: La classe sous test est le focus. Vous créez une instance de celle-ci, d'appeler ses méthodes et alors affirmer que le résultat est correct. Si la classe sous test a des dépendances (par exemple, quelque chose est nécessaire dans le constructeur), vous satisfaire ces dépendances en utilisant soit Un: real classes ou B: test en double.

La raison pour laquelle nous utilisons le test en double, c'est qu'il isole la classe sous test, ce qui signifie que vous pouvez exercer son code plus contrôlée de la mode.

E. g. si vous avez une classe qui contient un objet de réseau, vous ne pouvez pas tester la classe possédant de l'erreur de traitement des routines qui permettent de détecter les connexions mortes si vous êtes obligés d'utiliser un béton de la connexion réseau de l'objet. Au lieu de cela, vous pouvez injecter un faux objet de connexion et dites-lui de lever une exception lorsque sa "SendBytes" la méthode est appelée.

I. e. Dans chaque test, les dépendances de la classe sous test sont créés spécifiquement à l'exercice d'un morceau de code.

Qui fait beaucoup de sens. Essentiellement, vous êtes en train de dire que j'ai besoin de faire le suivant:

public class MyClass
{
    public virtual string GetSomeString(MyOtherClass moc)
    {
        return moc.ToString();
    }
}

.....

Mock<MyOtherClass> myMock = new Mock<MyOtherClass>();

MyClass mc = new MyClass();

string someString = mc.GetSomeString(myMock.Object);
Assert.AreEqual(EXPECTED_STRING, someString);

Essentiellement l'instanciation de la CUS, et en utilisant uniquement des objets fantaisie pour les classes de la CUS?

Vous devez vous connecter pour publier un commentaire.