Méthode protégée par test unitaire en C # en utilisant Moq

Il est venu à mon attention ces derniers temps que vous pouvez unité de test de classes de base abstraites à l'aide Moq plutôt que de créer un mannequin de classe dans le test qui implémente la classe de base abstraite. Voir Comment utiliser moq pour tester une méthode concrète dans une classe abstraite? E. g. vous pouvez le faire:

public abstract class MyAbstractClass 
{
    public virtual void MyMethod()
    {
        //...    
    }
}

[Test]
public void MyMethodTest()
{
    //Arrange            
    Mock<MyAbstractClass> mock = new Mock<MyAbstractClass>() { CallBase = true };

    //Act
    mock.Object.MyMethod();

    //Assert
    //... 
}

Maintenant, je me demandais si il y avait une technique similaire pour me permettre de test des membres protégés sans avoir à créer une classe wrapper. I. e. comment faites-vous tester cette méthode:

public class MyClassWithProtectedMethod
{
    protected void MyProtectedMethod()
    {

    }
}

Je suis conscient de l'Moq.Noms protégé, cependant, aussi loin que je peux voir, il ne vous permet de configurer les attentes avec, par exemple,

mock.Protected().Setup("MyProtectedMethod").Verifiable();

Je suis également conscient que la réponse la plus évidente ici est "ne pas tester les méthodes protected, seulement tester les méthodes publiques", cependant c'est un autre débat! Je veux juste savoir si c'est possible en utilisant Moq.

Mise à jour: ci-dessous est la façon dont je voudrais tester cette normalement:

public class MyClassWithProtectedMethodTester : MyClassWithProtectedMethod
{
    public void MyProtectedMethod()
    {
        base.MyProtectedMethod();
    }
}

Merci d'avance.

source d'informationauteur magritte

c#moq

7

Pour commencer, il n'y a pas de point dans l'unité de test d'une méthode abstraite. Il n'y a pas de mise en œuvre de! Vous pouvez unité de test d'un impur classe abstraite, que la vérification de la méthode abstraite a été appelé:
```
[Test]
public void Do_WhenCalled_CallsMyAbstractMethod()
{
    var sutMock = new Mock<MyAbstractClass>() { CallBase = true };
    sutMock.Object.Do();
    sutMock.Verify(x => x.MyAbstractMethod());
}

public abstract class MyAbstractClass
{
    public void Do()
    {
        MyAbstractMethod();
    }

    public abstract void MyAbstractMethod();
}
```
Note que j'ai mis CallBase de transformer cela en une fantaisie partielle, dans le cas où le Faire est virtuel. Sinon Moq aurait remplacé la mise en œuvre de la méthode.

À l'aide Protégé (), vous pouvez vérifier qu'une méthode protégée a été appelé d'une manière similaire.

Lorsque vous créez une maquette avec Moq ou d'une autre bibliothèque, le point est primordial de mise en œuvre. Essai d'une méthode protégée consiste à exposer de mise en œuvre existantes. Ce n'est pas ce Moq est conçu pour faire. Protégé() vous permet d'accéder (sans doute par le biais de la réflexion, car il est basé sur des chaînes) pour remplacer des membres protégés.

Écrire un test descendant de la classe avec une méthode qui appelle votre méthode protégée, ou de l'utilisation de la réflexion dans l'unité de test pour appeler la méthode protégée.

Ou, mieux encore, ne pas tester les méthodes protected directement.

Une autre façon de Moq pour appeler protégé membre est le modèle suivant:

Dans votre classe, avec les membres protégés marque de votre fonction en tant que virtuel.
Par exemple:

public class ClassProtected
    {
        public string CallingFunction(Customer customer)
        {
            var firstName = ProtectedFunction(customer.FirstName);
            var lastName = ProtectedFunction(customer.LastName);

            return string.Format("{0}, {1}", lastName, firstName);
        }

        protected virtual string ProtectedFunction(string value)
        {
            return value.Replace("SAP", string.Empty);
        }
    }

Puis dans votre unité de test d'ajouter une référence à

 using Moq.Protected;

et dans votre unité de test, vous pouvez écrire le code suivant:

    [TestFixture]
    public class TestClassProttected
    {
        [Test]
        public void all_bad_words_should_be_scrubbed()
        {
            //Arrange
            var mockCustomerNameFormatter = new Mock<ClassProtected>();

            mockCustomerNameFormatter.Protected()
                .Setup<string>("ProtectedFunction", ItExpr.IsAny<string>())
                .Returns("here can be any value")
                .Verifiable(); //you should call this function in any case. Without calling next Verify will not give you any benefit at all

            //Act
            mockCustomerNameFormatter.Object.CallingFunction(new Customer());

            //Assert
            mockCustomerNameFormatter.Verify();
        }
    }

Prendre note de ItExpr. Il doit être utilisé au lieu de Cela. Un autre piège vous attend à Vérifiables. Je ne sais pas pourquoi, mais sans appeler à Vérifiables Vérifier ne sera pas appelé.

4

Vous l'ai déjà évoqué le "test de l'API publique, et non pas privée" processus de pensée, et vous avez également déjà mentionné la technique de héritant de la classe et puis les essais de ses membres protégés de cette façon. Ces deux sont des approches valables.

En dessous de tout, la simple vérité est que vous considérez que c'est de la mise en œuvre du détail (comme c'est ce que l'privés ou protégés membre est) assez important de tester directement plutôt qu'indirectement par l'intermédiaire de l'API publique qui l'utilisent. Si il est ce important, c'est peut-être suffisamment important pour promouvoir son propre classe. (Après tout, si c'est si important, peut-être que c'est une responsabilité qui MyAbstractClass ne devrait pas avoir.) L'instance de la classe devrait être protégés à l'intérieur de MyAbstractClassde sorte que la base et les types dérivés d'avoir accès à l'instance, mais la classe elle-même serait entièrement vérifiables autrement et utilisable ailleurs si c'est devenu un besoin.
```
abstract class MyAbstractClass 
{
     protected ImportantMethodDoer doer;
}

class ImportantMethodDoer
{
     public void Do() { }
}
```
Sinon, vous êtes de gauche* les démarches que vous avez déjà identifié.

*Moq peut ou ne peut pas fournir un mécanisme pour arriver à les membres privés ou protégés, je ne peux pas dire que je n'utilise pas cet outil particulier. Ma réponse est plus à partir d'un point de vue architectural.

Vous devez vous connecter pour publier un commentaire.