Wie kann ich Erweiterungsmethoden mit Moq simulieren?

Verwenden Sie Moq, um Erweiterungsmethoden zu simulieren: Mixin-Aufrufe kapseln

Beim Testen von Klassen, die auf Erweiterungsmethoden basieren, ist es nicht trivial, diese Methoden mit Moq zu verspotten. In diesem Artikel wird dieses Problem gelöst und eine Lösung mithilfe von Wrapper-Objekten bereitgestellt.

Betrachten Sie den folgenden Code, in dem eine Schnittstelle mithilfe eines Mixins erweitert wird und eine Klasse diese Erweiterungsmethode aufruft:

<code class="language-c#">public interface ISomeInterface
{
    void SomeMethod();
}

public static class SomeInterfaceExtensions
{
    public static void AnotherMethod(this ISomeInterface someInterface)
    {
        // 实现代码
    }
}

public class Caller
{
    private readonly ISomeInterface someInterface;

    public Caller(ISomeInterface someInterface)
    {
        this.someInterface = someInterface;
    }

    public void Main()
    {
        someInterface.AnotherMethod();
    }
}</code>

In der Testmethode versuchen wir, die Schnittstelle zu verspotten und den Aufruf der Erweiterungsmethode zu überprüfen:

<code class="language-c#">    [Test]
    public void Main_BasicCall_CallsAnotherMethod()
    {
        // Arrange
        var someInterfaceMock = new Mock<ISomeInterface>();
        someInterfaceMock.Setup(x => x.AnotherMethod()).Verifiable(); // 此处会报错

        var caller = new Caller(someInterfaceMock.Object);

        // Act
        caller.Main();

        // Assert
        someInterfaceMock.Verify();
    }</code>

Dieser Test schlägt jedoch mit einer ArgumentException fehl, was darauf hinweist, dass der Mixin-Aufruf nicht direkt gemobbt werden kann.

Um dieses Problem zu lösen, können Sie ein Wrapper-Objekt erstellen, um den Mixin-Aufruf zu kapseln. Dadurch können wir Wrapper-Methoden anstelle von Erweiterungsmethoden verspotten.

Zum Beispiel:

<code class="language-c#">public class SomeInterfaceWrapper
{
    private readonly ISomeInterface someInterface;

    public SomeInterfaceWrapper(ISomeInterface someInterface)
    {
        this.someInterface = someInterface;
    }

    public void AnotherMethod()
    {
        someInterface.AnotherMethod();
    }
}</code>

In der Testmethode können wir die Wrapper-Methode nachahmen:

<code class="language-c#">    [Test]
    public void Main_BasicCall_CallsAnotherMethod()
    {
        // Arrange
        var wrapperMock = new Mock<SomeInterfaceWrapper>();
        wrapperMock.Setup(x => x.AnotherMethod()).Verifiable();

        var caller = new Caller(new SomeInterfaceWrapper(wrapperMock.Object)); // 注意此处修改

        // Act
        caller.Main();

        // Assert
        wrapperMock.Verify();
    }</code>

Dieser Ansatz bietet eine bequeme Möglichkeit, Aufrufe von Erweiterungsmethoden mithilfe von Moq zu simulieren. Indem wir die Mixin-Aufrufe in einem separaten Objekt kapseln, können wir das Verhalten der Erweiterungsmethode einfach simulieren, ohne den Originalcode zu ändern. Beachten Sie, dass der Konstruktor der Caller-Klasse eine SomeInterfaceWrapper-Instanz übergeben muss, anstatt das Mock-Objekt direkt zu übergeben.

Das obige ist der detaillierte Inhalt vonWie kann ich Erweiterungsmethoden mit Moq simulieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!