Làm cách nào để sử dụng Moq để mô phỏng một phương thức mở rộng?

Tôi đang viết một bài kiểm tra phụ thuộc vào kết quả của một phương thức mở rộng nhưng tôi không muốn phương pháp mở rộng đó sẽ không bao giờ phá vỡ bài kiểm tra này trong tương lai. Chế giễu kết quả đó dường như là lựa chọn hiển nhiên nhưng Moq dường như không đưa ra cách ghi đè phương thức tĩnh (một yêu cầu đối với phương thức mở rộng). Có một ý tưởng tương tự với Moq.Protected và Moq.Stub, nhưng họ dường như không cung cấp bất cứ điều gì cho tình huống này. Tôi đang thiếu một cái gì đó hay tôi nên đi về điều này theo một cách khác?

Đây là một ví dụ nhỏ không thành công với thông thường "Kỳ vọng không hợp lệ trên thành viên không thể ghi đè" . Đây là một ví dụ tồi về việc bắt chước một phương thức mở rộng, nhưng nó nên làm.

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

Đối với bất kỳ người nghiện TypeMock nào có thể đề nghị tôi sử dụng Isolator thay thế: Tôi đánh giá cao nỗ lực vì có vẻ như TypeMock có thể thực hiện công việc bị bịt mắt và say xỉn, nhưng ngân sách của chúng tôi sẽ không sớm tăng lên.

Các phương thức mở rộng chỉ là các phương thức tĩnh trong ngụy trang. Các khung công tác chế nhạo như Moq hoặc Rhinomocks chỉ có thể tạo các phiên bản giả của các đối tượng, điều này có nghĩa là không thể chế tạo các phương thức tĩnh.

Nếu bạn có thể thay đổi mã phương thức tiện ích mở rộng thì bạn có thể viết mã như thế này để có thể kiểm tra:

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

Vì vậy, các phương thức mở rộng chỉ là một trình bao bọc xung quanh giao diện thực thi.

(Bạn có thể chỉ sử dụng lớp triển khai mà không có các phương thức mở rộng là một loại đường cú pháp.)

Và bạn có thể giả lập giao diện triển khai và đặt nó làm giao diện triển khai cho lớp phần mở rộng.

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

Tôi biết câu hỏi này đã không hoạt động trong khoảng một năm nhưng Microsoft đã phát hành một khuôn khổ để xử lý chính xác điều này được gọi là Nốt ruồi .

Dưới đây là một số hướng dẫn:

Tôi đã tạo một lớp trình bao bọc cho các phương thức mở rộng mà tôi cần mô phỏng.

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

Sau đó, bạn có thể mô phỏng các phương thức trình bao bọc trong các thử nghiệm và mã bằng vùng chứa IOC của bạn.

Đối với các phương pháp mở rộng, tôi thường sử dụng phương pháp sau:

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

Nó cho phép tiêm _doSumm khá dễ dàng.

Điều tốt nhất bạn có thể làm là cung cấp triển khai tùy chỉnh cho loại có phương thức mở rộng, ví dụ:

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