Comment puis-je simuler des méthodes d'extension à l'aide de Moq ?

Utilisez Moq pour simuler les méthodes d'extension : encapsulez les appels Mixin

Lorsque vous testez des classes qui s'appuient sur des méthodes d'extension, il n'est pas trivial de se moquer de ces méthodes à l'aide de Moq. Cet article résoudra ce problème et fournira une solution en utilisant des objets wrapper.

Considérez le code suivant, où une interface est étendue à l'aide d'un mixin, et une classe appelle cette méthode d'extension :

<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>

Dans la méthode de test, nous essayons de simuler l'interface et de vérifier l'appel à la méthode d'extension :

<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>

Cependant, ce test échouera avec une ArgumentException, indiquant que l'appel mixin ne peut pas être simulé directement.

Pour surmonter ce problème, vous pouvez créer un objet wrapper pour encapsuler l'appel mixin. Cela nous permet de nous moquer des méthodes wrapper au lieu des méthodes d’extension.

Par exemple :

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

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

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

Dans la méthode de test, nous pouvons nous moquer de la méthode wrapper :

<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>

Cette approche fournit un moyen pratique de simuler des appels de méthodes d'extension à l'aide de Moq. En encapsulant les appels mixin dans un objet séparé, nous pouvons facilement simuler le comportement de la méthode d'extension sans modifier le code d'origine. Notez que le constructeur de la classe Caller doit transmettre une instance SomeInterfaceWrapper au lieu de transmettre directement l'objet Mock.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!