如何测试自定义ISourceBlock的Consume等方法及优化实现方式

1. 编写单元测试验证方法转发逻辑 #

要验证ConsumeMessage、ReleaseReservation和ReserveMessage的转发逻辑未被破坏，核心是隔离内部依赖并验证方法调用的转发关系，以下用NUnit+Moq举例说明：

步骤1：改造自定义块，支持依赖注入 #

先修改SomeCustomBlock<T>的构造函数，允许传入自定义的ISourceBlock<T>实现，方便测试时替换为Mock对象：

public sealed class SomeCustomBlock<T> : ISourceBlock<T>
{
    private readonly int _somePrivateMember = 0;
    private readonly ISourceBlock<T> _source;

    // 构造函数注入，默认使用BufferBlock<T>
    public SomeCustomBlock(ISourceBlock<T>? source = null)
    {
        _source = source ?? new BufferBlock<T>();
    }

    // 原有接口实现代码不变
    public void Complete() => _source.Complete();
    public void Fault(Exception exception) => _source.Fault(exception);
    public Task Completion => _source.Completion;
    
    public T? ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock<T> target, out bool messageConsumed)
    {
        return _source.ConsumeMessage(messageHeader, target, out messageConsumed);
    }

    public IDisposable LinkTo(ITargetBlock<T> target, DataflowLinkOptions linkOptions)
    {
        return _source.LinkTo(target, linkOptions);
    }

    public void ReleaseReservation(DataflowMessageHeader messageHeader, ITargetBlock<T> target)
    {
        _source.ReleaseReservation(messageHeader, target);
    }

    public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock<T> target)
    {
        return _source.ReserveMessage(messageHeader, target);
    }
}

步骤2：编写NUnit测试用例 #

创建测试类，用Moq模拟ISourceBlock<T>和ITargetBlock<T>，验证自定义块的方法是否正确转发到内部依赖：

using NUnit.Framework;
using Moq;
using System.Threading.Tasks.Dataflow;

[TestFixture]
public class SomeCustomBlockTests
{
    [Test]
    public void ConsumeMessage_ShouldForwardToInternalSource()
    {
        // Arrange
        var mockSource = new Mock<ISourceBlock<int>>();
        var mockTarget = new Mock<ITargetBlock<int>>();
        var header = new DataflowMessageHeader(1);
        bool consumed = false;
        mockSource.Setup(s => s.ConsumeMessage(header, mockTarget.Object, out consumed))
                  .Returns(42);

        var customBlock = new SomeCustomBlock<int>(mockSource.Object);

        // Act
        var result = customBlock.ConsumeMessage(header, mockTarget.Object, out bool actualConsumed);

        // Assert
        mockSource.Verify(s => s.ConsumeMessage(header, mockTarget.Object, out consumed), Times.Once);
        Assert.That(result, Is.EqualTo(42));
        Assert.That(actualConsumed, Is.EqualTo(consumed));
    }

    [Test]
    public void ReserveMessage_ShouldForwardToInternalSource()
    {
        // Arrange
        var mockSource = new Mock<ISourceBlock<int>>();
        var mockTarget = new Mock<ITargetBlock<int>>();
        var header = new DataflowMessageHeader(1);
        mockSource.Setup(s => s.ReserveMessage(header, mockTarget.Object))
                  .Returns(true);

        var customBlock = new SomeCustomBlock<int>(mockSource.Object);

        // Act
        var result = customBlock.ReserveMessage(header, mockTarget.Object);

        // Assert
        mockSource.Verify(s => s.ReserveMessage(header, mockTarget.Object), Times.Once);
        Assert.That(result, Is.True);
    }

    [Test]
    public void ReleaseReservation_ShouldForwardToInternalSource()
    {
        // Arrange
        var mockSource = new Mock<ISourceBlock<int>>();
        var mockTarget = new Mock<ITargetBlock<int>>();
        var header = new DataflowMessageHeader(1);

        var customBlock = new SomeCustomBlock<int>(mockSource.Object);

        // Act
        customBlock.ReleaseReservation(header, mockTarget.Object);

        // Assert
        mockSource.Verify(s => s.ReleaseReservation(header, mockTarget.Object), Times.Once);
    }
}

如果不想依赖Moq，也可以手动实现一个TrackedSourceBlock<T>，记录所有方法的调用情况，核心逻辑一致——验证自定义块的方法是否触发了内部依赖的对应调用。

2. 更易测试的自定义TPL块实现方式 #

在必须直接实现ISourceBlock<T>的前提下，可通过以下方式提升可测试性：

• 依赖抽象而非具体实现：如上述改造，将内部数据源（如BufferBlock<T>）通过构造函数注入，依赖ISourceBlock<T>抽象而非具体类。测试时可轻松替换为Mock或测试替身，验证转发逻辑。
• 拆分核心逻辑与接口实现：如果自定义块有业务逻辑（如消息转换、过滤），将这部分抽离到单独的类（如IMessageProcessor<T>），让自定义块依赖该处理器。测试核心逻辑时无需关注Dataflow接口细节，只需单独测试处理器即可。
• 手动实现基础骨架，避免全接口转发：如果需要自主控制消息流转，不要直接转发内部块的所有接口方法，而是手动实现ISourceBlock<T>方法，自行管理消息队列和状态。比如维护私有消息队列，在ConsumeMessage中自行处理消息取出与消费标记，这样所有逻辑都在自定义块内部，测试时直接验证行为即可，无需依赖其他Dataflow块。

简化版手动实现骨架示例：

public sealed class ManualCustomBlock<T> : ISourceBlock<T>
{
    private readonly Queue<T> _messageQueue = new();
    private readonly TaskCompletionSource<bool> _completionSource = new();
    // 其他状态变量：是否已完成、是否出错等

    public T? ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock<T> target, out bool messageConsumed)
    {
        messageConsumed = false;
        lock (_messageQueue)
        {
            if (_messageQueue.Count > 0 && messageHeader.IsValid)
            {
                var message = _messageQueue.Dequeue();
                messageConsumed = true;
                return message;
            }
            return default;
        }
    }

    // 手动实现其他ISourceBlock<T>方法，自行管理状态
    // ...
}

内容的提问来源于stack exchange，提问作者Jake Shanley