Wie verwende ich Moq, um eine Erweiterungsmethode nachzubilden?

Question

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 unterbricht. Mocking das Ergebnis schien die offensichtliche Wahl, 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 nichts für dieses Szenario zu bieten. Übersehe ich etwas oder sollte ich das anders angehen?

Hier ist ein triviales Beispiel, das mit der üblichen "Ungültige Erwartung an ein nicht überschreibbares Mitglied" . Dies ist ein schlechtes Beispiel für die Notwendigkeit, eine Erweiterungsmethode nachzubilden, 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 für alle TypeMock-Junkies, die vorschlagen, dass ich stattdessen Isolator verwenden könnte: Ich weiß die Mühe zu schätzen, denn es sieht so aus, als könnte TypeMock die Aufgabe mit verbundenen Augen und im Rausch erledigen, aber unser Budget wird in nächster Zeit nicht steigen.

Answer 1

Erweiterungsmethoden sind nur statische Methoden in Verkleidung. Mocking-Frameworks wie Moq oder Rhinomocks können nur Mock-Instanzen von Objekten erstellen, d. h. das Mocking statischer Methoden ist nicht möglich.

Answer 2

Wenn Sie den Code der Erweiterungsmethoden ändern können, dann können Sie ihn so codieren, dass Sie ihn testen 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önnten nur die Implementierungsklasse ohne Erweiterungsmethoden verwenden, die eine Art syntaktischer Zucker sind).

Und Sie können die Implementierungsschnittstelle nachbilden und sie 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));
    }
}

Answer 3

Ich weiß, dass diese Frage seit etwa einem Jahr nicht mehr aktiv ist, aber Microsoft hat ein Framework herausgegeben, das genau dies ermöglicht. Maulwürfe .

Auch hier gibt es ein paar Anleitungen:

• DimeCasts.net
• Anleitung von Nikolai Tillman

Answer 4

Ich habe eine Wrapper-Klasse für die Erweiterungsmethoden erstellt, die ich nachahmen 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 und im Code mit Ihrem IOC-Container nachbilden.

Answer 5

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 relativ einfach zu injizieren.