Wie verspotte ich mit Moq eine Erweiterungsmethode?

Ich schreibe einen Test, der von den Ergebnissen einer Erweiterungsmethode abhängt, aber ich möchte nicht, dass ein zukünftiger Fehler dieser Erweiterungsmethode diesen Test jemals bricht. Das Verspotten dieses Ergebnisses schien die naheliegende Wahl zu sein, aber Moq scheint keine Möglichkeit zu bieten, eine statische Methode zu überschreiben (eine Voraussetzung für eine Erweiterungsmethode). Es gibt eine ähnliche Idee mit Moq.Protected und Moq.Stub, aber sie scheinen für dieses Szenario nichts zu bieten. Vermisse ich etwas oder sollte ich das anders machen?

Hier ist ein triviales Beispiel, das mit der üblichen "Ungültige Erwartung an ein nicht überschreibbares Mitglied" fehlschlägt . Dies ist ein schlechtes Beispiel dafür, wie man eine Erweiterungsmethode verspotten muss, aber es sollte reichen.

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 });

Wie bei allen TypeMock-Junkies, die vorschlagen könnten, stattdessen Isolator zu verwenden: Ich schätze den Aufwand, da TypeMock anscheinend die Arbeit mit verbundenen Augen und betrunken erledigen kann, aber unser Budget steigt nicht so schnell.

Erweiterungsmethoden sind nur verschleierte statische Methoden. Das Verspotten von Frameworks wie Moq oder Rhinomocks kann nur Scheininstanzen von Objekten erstellen. Dies bedeutet, dass das Verspotten statischer Methoden nicht möglich ist.

Wenn Sie den Code für Erweiterungsmethoden ändern können, können Sie ihn wie folgt codieren, um Folgendes testen zu können:

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!";
    }
}

Die Erweiterungsmethoden sind also nur ein Wrapper um die Implementierungsschnittstelle.

(Sie können nur die Implementierungsklasse ohne Erweiterungsmethoden verwenden, die eine Art syntaktischen Zucker darstellen.)

Sie können die Implementierungsschnittstelle verspotten und als Implementierung für die Erweiterungsklasse festlegen.

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));
    }
}

Ich weiß, dass diese Frage seit ungefähr einem Jahr nicht mehr aktiv ist, aber Microsoft hat ein Framework veröffentlicht, das genau dies behandelt und Moles heißt .

Hier sind auch einige Tutorials:

Ich habe eine Wrapper-Klasse für die Erweiterungsmethoden erstellt, die ich verspotten musste.

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();
    }
}

Dann können Sie die Wrapper-Methoden in Ihren Tests verspotten und mit Ihrem IOC-Container codieren.

Für Erweiterungsmethoden verwende ich normalerweise den folgenden Ansatz:

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);
    }
}

Es erlaubt, _doSumm ziemlich einfach zu injizieren.

Das Beste, was Sie tun können, ist, eine benutzerdefinierte Implementierung für den Typ bereitzustellen, der über die Erweiterungsmethode verfügt, z.

[Fact]
public class Tests
{
    public void ShouldRunOk()
    {
        var service = new MyService(new FakeWebHostEnvironment());

        // Service.DoStuff() internally calls the SomeExtensionFunction() on IWebHostEnvironment
        // Here it works just fine as we provide a custom implementation of that interface
        service.DoStuff().Should().NotBeNull();
    }
}

public class FakeWebHostEnvironment : IWebHostEnvironment
{
    /* IWebHostEnvironment implementation */

    public bool SomeExtensionFunction()
    {
        return false;
    }
}