Phương pháp mở rộng mô phỏng với Moq

Tôi có Giao diện từ trước ...

public interface ISomeInterface
{
    void SomeMethod();
}

và tôi đã mở rộng intreface này bằng cách sử dụng mixin ...

public static class SomeInterfaceExtensions
{
    public static void AnotherMethod(this ISomeInterface someInterface)
    {
        // Implementation here
    }
}

Tôi có một lớp học gọi nó mà tôi muốn kiểm tra ...

public class Caller
{
    private readonly ISomeInterface someInterface;

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

    public void Main()
    {
        someInterface.AnotherMethod();
    }
}

và một thử nghiệm mà tôi muốn mô phỏng giao diện và xác minh cuộc gọi đến phương thức mở rộng ...

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

Chạy thử nghiệm này tuy nhiên tạo ra một ngoại lệ ...

System.ArgumentException: Invalid setup on a non-member method:
x => x.AnotherMethod()

Câu hỏi của tôi là, có một cách hay để chế nhạo cuộc gọi mixin?

Bạn không thể "trực tiếp" mô phỏng phương thức tĩnh (do đó là phương thức mở rộng) với khung mô phỏng. Bạn có thể dùng thử Moles ( http://research.microsoft.com/en-us/projects/pex/doads.aspx ), một công cụ miễn phí của Microsoft thực hiện một cách tiếp cận khác. Dưới đây là mô tả của công cụ:

Moles là một khung công tác nhẹ để kiểm tra sơ khai và đường vòng trong .NET dựa trên các đại biểu.

Các nốt ruồi có thể được sử dụng để đi đường vòng bất kỳ phương thức .NET nào, kể cả các phương thức không ảo / tĩnh trong các loại kín.

Bạn có thể sử dụng Moles với bất kỳ khung thử nghiệm nào (nó độc lập về điều đó).

Tôi đã sử dụng một Wrapper để khắc phục vấn đề này. Tạo một đối tượng bao bọc và vượt qua phương thức giả định của bạn.

Xem Phương pháp mô phỏng tĩnh để kiểm tra đơn vị của Paul Irwin, nó có các ví dụ hay.

Tôi thấy rằng tôi phải khám phá bên trong phương thức mở rộng mà tôi đang cố gắng giả định đầu vào và giả định những gì đang diễn ra bên trong tiện ích mở rộng.

Tôi đã xem bằng cách sử dụng một phần mở rộng như thêm mã trực tiếp vào phương thức của bạn. Điều này có nghĩa là tôi cần phải chế giễu những gì xảy ra bên trong tiện ích mở rộng hơn là chính tiện ích mở rộng.

Bạn có thể giả định một giao diện thử nghiệm kế thừa từ giao diện thực và có một thành viên có cùng chữ ký với phương thức mở rộng.

Sau đó, bạn có thể mô phỏng giao diện kiểm tra, thêm giao diện thực vào giả và gọi phương thức kiểm tra trong thiết lập.

Việc triển khai giả của bạn sau đó có thể gọi bất kỳ phương thức nào bạn muốn hoặc chỉ cần kiểm tra phương thức đó được gọi là:

IReal //on which some extension method is defined
{
    ... SomeRegularMethod(...);
}

static ExtensionsForIReal
{
    static ... SomeExtensionMethod(this IReal iReal,...);
}

ITest: IReal
{
    //This is a regular method with same name and signature as the extension without the "this IReal iReal" parameter
    ... SomeExtensionMethod(...);
}

var someMock = new Mock<ITest>();
Mock.As<IReal>(); //ad IReal to the mock
someMock.Setup(x => x.SomeExtensionMethod(...)).Verifiable(); //Calls SomeExtensionMethod on ITest
someMock.As<IReal>().Setup(x => x.SomeRegularMethod(...)).Verifiable(); //Calls SomeRegularMethod on IReal

Cảm ơn giải pháp Håvard S trong bài đăng này về cách triển khai một bản giả hỗ trợ hai giao diện. Khi tôi tìm thấy nó, việc điều chỉnh nó với giao diện thử nghiệm và phương thức tĩnh là một cuộc dạo chơi trên bánh.

Bạn có thể dễ dàng giả định một phương thức mở rộng với JustMock . API giống như phương pháp chế nhạo thông thường. Hãy xem xét những điều sau đây

public static string Echo(this Foo foo, string strValue) 
{ 
    return strValue; 
}

Để sắp xếp và xác minh phương pháp này, hãy sử dụng như sau:

string expected = "World";

var foo = new Foo();
Mock.Arrange(() => foo.Echo(Arg.IsAny<string>())).Returns(expected);

string result = foo.Echo("Hello");

Assert.AreEqual(expected, result);

Đây cũng là một liên kết đến tài liệu: Phương pháp mở rộng Mocking

Tôi thích sử dụng trình bao bọc (mẫu bộ điều hợp) khi tôi tự bọc đối tượng. Tôi không chắc chắn tôi sẽ sử dụng nó để gói một phương thức mở rộng, không phải là một phần của đối tượng.

Tôi sử dụng Thuộc tính Lazy tiêm nội bộ thuộc loại Hành động, Func, Vị ngữ hoặc đại biểu và cho phép tiêm (hoán đổi) phương pháp trong khi thử nghiệm đơn vị.

    internal Func<IMyObject, string, object> DoWorkMethod
    {
        [ExcludeFromCodeCoverage]
        get { return _DoWorkMethod ?? (_DoWorkMethod = (obj, val) => { return obj.DoWork(val); }); }
        set { _DoWorkMethod = value; }
    } private Func<IMyObject, string, object> _DoWorkMethod;

Sau đó, bạn gọi Func thay vì phương thức thực tế.

    public object SomeFunction()
    {
        var val = "doesn't matter for this example";
        return DoWorkMethod.Invoke(MyObjectProperty, val);
    }

Để có một ví dụ đầy đủ hơn, hãy xem http://www.rhyous.com/2016/08/11/unit-testing-calls-to-complex-extension-methods/

Vì vậy, nếu bạn đang sử dụng Moq và muốn mô phỏng kết quả của phương thức Tiện ích mở rộng, thì bạn có thể sử dụng SetupReturnsDefault<ReturnTypeOfExtensionMethod>(new ConcreteInstanceToReturn())ví dụ của lớp giả có phương thức tiện ích mở rộng mà bạn đang cố gắng giả định.

Nó không hoàn hảo, nhưng với mục đích thử nghiệm đơn vị, nó hoạt động tốt.