Comment puis-je utiliser Moq pour se moquer d'une méthode d'extension?

Je suis en train d'écrire un test qui repose sur les résultats d'une méthode d'extension, mais je ne veux pas d'un futur échec de cette méthode d'extension à jamais briser ce test. Se moquant de ce résultat semblait être le choix évident, mais Moq ne semble pas offrir un moyen de surcharger une méthode statique (une demande pour une extension de la méthode). Il y a une idée similaire avec Moq.Protégés et de Moq.Stub, mais ils ne semblent pas offrir quelque chose pour ce scénario. Ai-je raté quelque chose ou dois-je aller sur ce une manière différente?

Voici un exemple trivial qui échoue avec l'habitude "Invalide attente sur un non-substituables membre". C'est un mauvais exemple d'avoir besoin de se moquer d'une méthode d'extension, mais elle devrait faire.

public class SomeType {
    int Id { get; set; }
}

var ListMock = new Mock<List<SomeType>>();
ListMock.Expect(l => l.FirstOrDefault(st => st.Id == 5))
        .Returns(new SomeType { Id = 5 });

Comme pour tout TypeMock junkies qui pourrait me suggère d'utiliser un Isolateur à la place: j'apprécie l'effort fait qu'il ressemble à TypeMock pourrait faire le travail, les yeux bandés et en état d'ébriété, mais notre budget n'est pas en augmentant tout moment bientôt.

  • Un duplicata peut être trouvé ici: stackoverflow.com/questions/2295960/....
  • Cette question est l'ensemble d'un an de plus que celui-là. Si, il y a duplication, il va dans l'autre sens.
  • Toujours pas de solution appropriée en 2019!
InformationsquelleAutor patridge | 2009-02-18
  1. 61

    Les méthodes d'Extension sont juste des méthodes statiques dans le déguisement. Se moquant de cadres comme Moq ou Rhinomocks ne peut se moquer de créer des instances d'objets, cela signifie se moquant de méthodes statiques n'est pas possible.

    • comment pourrait-on unité de tester une méthode interne, est une méthode d'extension ? quelles sont les alternatives possibles ?
    • comment pourrait-on unité de tester une méthode interne, est une méthode d'extension ? quelles sont les alternatives possibles ?
    InformationsquelleAutor Mendelt
  2. 22

    Si vous pouvez changer les méthodes d'extension de code que vous pouvez coder comme ceci pour être en mesure de tester:

    using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

public static class MyExtensions
{
    public static IMyImplementation Implementation = new MyImplementation();

    public static string MyMethod(this object obj)
    {
        return Implementation.MyMethod(obj);
    }
}

public interface IMyImplementation
{
    string MyMethod(object obj);
}

public class MyImplementation : IMyImplementation
{
    public string MyMethod(object obj)
    {
        return "Hello World!";
    }
}

    Donc l'extension des méthodes sont seulement un wrapper autour de la mise en œuvre de l'interface.

    (Vous pouvez utiliser seulement à la mise en œuvre de la classe sans les méthodes d'extension qui sont des sortes de sucre syntaxique.)

    Et vous pouvez vous moquer de la mise en œuvre de l'interface et la définir comme la mise en œuvre des extensions de la classe.

    public class MyClassUsingExtensions
{
    public string ReturnStringForObject(object obj)
    {
        return obj.MyMethod();
    }
}

[TestClass]
public class MyTests
{
    [TestMethod]
    public void MyTest()
    {
        //Given:
        //-------
        var mockMyImplementation = new Mock<IMyImplementation>();

        MyExtensions.Implementation = mockMyImplementation.Object;

        var myClassUsingExtensions = new MyClassUsingExtensions();

        //When:
        //-------
        var myObject = new Object();
        myClassUsingExtensions.ReturnStringForObject(myObject);

        //Then:
        //-------
        //This would fail because you cannot test for the extension method
        //mockMyImplementation.Verify(m => m.MyMethod());

        //This is success because you test for the mocked implementation interface
        mockMyImplementation.Verify(m => m.MyMethod(myObject));
    }
}
    • Je vous remercie beaucoup pour cela. Il a été extrêmement utile et m'a fait plus de quelques obstacles dans les tests.
    InformationsquelleAutor informatorius
  3. 15

    Je sais que cette question n'a pas été actif pendant environ un an, mais Microsoft a publié un cadre pour traiter exactement de ce qu'on appelle Les taupes.

    Voici quelques tutoriels ainsi:

    InformationsquelleAutor Mike Fielden
  4. 13

    J'ai créé une classe wrapper pour l'extension des méthodes que j'ai eu besoin de se moquer.

    public static class MyExtensions
{
    public static string MyExtension<T>(this T obj)
    {
        return "Hello World!";
    }
}

public interface IExtensionMethodsWrapper
{
    string MyExtension<T>(T myObj);
}

public class ExtensionMethodsWrapper : IExtensionMethodsWrapper
{
    public string MyExtension<T>(T myObj)
    {
        return myObj.MyExtension();
    }
}

    Ensuite, vous pouvez simuler le wrapper méthodes dans vos tests et le code avec votre conteneur IOC.

    • C'est une solution où vous ne pouvez pas utiliser les méthodes d'extension de la syntaxe plus dans votre code. Mais il aide quand vous ne pouvez pas modifier l'extension des méthodes de la classe.
    • Qu'entendez-vous par là? Dans votre code que vous utilisez MyExtension() de la MyExtensions classe. Dans vos tests, vous utilisez le MyExtension() de la ExtensionMethodsWrapper() de la classe fournissant le paramètre.
    • Si ma classe de test utilise MyExtension() de la MyExtensions alors je ne peut pas se moquer de la MyExtensions. Donc, la classe sous test doit utiliser le IExtensionMethodsWrapper de sorte qu'il peut se moque de lui. Mais alors la classe sous test ne peut pas utiliser la méthode d'extension de la syntaxe plus.
    • C'est toute la question de l'OP. C'est une solution de contournement pour que.
    InformationsquelleAutor ranthonissen
  5. 4

    Pour les méthodes d'extension j'ai l'habitude d'utiliser l'approche suivante:

    public static class MyExtensions
{
    public static Func<int,int, int> _doSumm = (x, y) => x + y;

    public static int Summ(this int x, int y)
    {
        return _doSumm(x, y);
    }
}

    Il permet d'injecter _doSumm assez facile.

    • J'ai juste essayé cela, mais il y a des problèmes lors du passage de la Mère se moquaient de l'objet que l'extension est pour quand le passage dans une autre méthode qui est dans une autre assemblée. Dans ce cas, même avec cette technique, l'extension d'origine est sélectionné lors de l'appel de la méthode dans l'autre assemblée, une sorte de détermination de la portée d'émission. Si j'appelle directement dans le projet de tests Unitaires, c'est bien, mais quand vous faites des tests de code qui appelle la méthode d'extension, il n'a tout simplement pas de l'aide.
    • Vous ne savez pas comment l'éviter. Je n'ai jamais eu ce genre de problème de cadrage
    InformationsquelleAutor dmigo