如何模拟无法控制的HttpApplication具体类以测试IHttpModule？

你遇到的问题核心在于Moq的限制：它只能模拟接口或者类中的虚拟/抽象成员，而HttpApplication的BeginRequest、EndRequest这类事件并不是虚拟的，所以直接用Mock<HttpApplication>无法正确模拟事件的订阅和触发。下面给你两种可行的解决方案：

方案一：自定义HttpApplication Stub类（快速解决） #

既然HttpApplication是可继承的，我们可以自己写一个测试用的子类，直接暴露触发事件的方法，不需要依赖Moq：

public class TestHttpApplication : HttpApplication
{
    // 暴露方法用于手动触发BeginRequest事件
    public void TriggerBeginRequest()
    {
        OnBeginRequest(EventArgs.Empty);
    }

    // 暴露方法用于手动触发EndRequest事件
    public void TriggerEndRequest()
    {
        OnEndRequest(EventArgs.Empty);
    }
}

然后修改你的测试代码，用这个Stub类替代Moq的模拟对象：

[Test]
public void MyModule_ShouldRecordRequestTime()
{
    // 准备依赖
    var mockLogger = new Mock<ILogger>();
    var testApplication = new TestHttpApplication();
    var myModule = new MyModule(mockLogger.Object);

    // 初始化模块，订阅事件
    myModule.Init(testApplication);

    // 触发事件
    testApplication.TriggerBeginRequest();
    // 可以在这里模拟一些请求处理的耗时，比如Thread.Sleep(1);
    testApplication.TriggerEndRequest();

    // 验证结果
    Assert.Greater(myModule.RequestTime, 0);
}

这个方案不需要修改你的MyModule代码，快速就能实现测试。

方案二：使用Adapter模式（更优雅的长期方案） #

如果希望你的模块更易于测试和解耦，可以引入一个抽象层，把HttpApplication的事件封装成接口，让MyModule依赖这个接口而非具体的HttpApplication：

第一步：定义事件抽象接口 #

public interface IApplicationEventPublisher
{
    event EventHandler BeginRequest;
    event EventHandler EndRequest;
}

第二步：实现Adapter类，封装HttpApplication #

public class HttpApplicationAdapter : IApplicationEventPublisher
{
    private readonly HttpApplication _application;

    public HttpApplicationAdapter(HttpApplication application)
    {
        _application = application;
    }

    public event EventHandler BeginRequest
    {
        add => _application.BeginRequest += value;
        remove => _application.BeginRequest -= value;
    }

    public event EventHandler EndRequest
    {
        add => _application.EndRequest += value;
        remove => _application.EndRequest -= value;
    }
}

第三步：修改MyModule，依赖抽象接口 #

public class MyModule : IHttpModule
{
    private readonly ILogger _logger;
    public long RequestTime { get; private set; }
    private Stopwatch _stopwatch;

    public MyModule(ILogger logger)
    {
        _logger = logger;
    }

    public void Init(HttpApplication context)
    {
        // 用适配器包装HttpApplication
        var eventPublisher = new HttpApplicationAdapter(context);
        Init(eventPublisher);
    }

    // 新增一个供测试用的重载方法，依赖抽象接口
    public void Init(IApplicationEventPublisher eventPublisher)
    {
        eventPublisher.BeginRequest += OnBeginRequest;
        eventPublisher.EndRequest += OnEndRequest;
    }

    public void Dispose() { }

    void OnBeginRequest(object sender, EventArgs e)
    {
        _stopwatch = Stopwatch.StartNew();
    }

    void OnEndRequest(object sender, EventArgs e)
    {
        _stopwatch.Stop();
        RequestTime = _stopwatch.ElapsedMilliseconds;
    }
}

第四步：编写测试代码，模拟抽象接口 #

现在就可以用Moq轻松模拟IApplicationEventPublisher了：

[Test]
public void MyModule_ShouldRecordRequestTime_WithAdapter()
{
    var mockLogger = new Mock<ILogger>();
    var mockEventPublisher = new Mock<IApplicationEventPublisher>();
    var myModule = new MyModule(mockLogger.Object);

    // 初始化模块，订阅抽象事件
    myModule.Init(mockEventPublisher.Object);

    // 触发事件
    mockEventPublisher.Raise(p => p.BeginRequest += null, EventArgs.Empty);
    mockEventPublisher.Raise(p => p.EndRequest += null, EventArgs.Empty);

    // 验证结果
    Assert.Greater(myModule.RequestTime, 0);
}

这个方案虽然需要修改现有代码，但提升了模块的可测试性和扩展性，后续如果需要更换事件源，只需要实现新的IApplicationEventPublisher适配器即可。

内容的提问来源于stack exchange，提问作者Lews Therin