Question

想要围绕MassTransit消费者设计我的测试，我可以向消费者发送包含各种内容的消息。根据消息的内容，消费者将会“工作”。并转发消息。

我遇到的问题是在运行其中两项测试时，在单独的测试装置中，似乎有一些干扰第二次测试。但是单独运行每个测试运行成功。

在查看MassTransit测试项目后，我提出了一些示例测试代码来演示我遇到的问题。

[TestFixture]
public class PingPongMessageTestFixture : InMemoryTestFixture
{
    private PongConsumer _pongConsumer;
    protected override void ConfigureInMemoryReceiveEndpoint(IInMemoryReceiveEndpointConfigurator configurator)
    {
        _received = Handled<IPongMessage>(configurator);
    }

    protected override void PreCreateBus(IInMemoryBusFactoryConfigurator configurator)
    {
        var _pingConsumer = new PingConsumer();
        _pongConsumer = new PongConsumer();
        configurator.ReceiveEndpoint("test_ping_queue", e =>
        {
            e.Consumer(() => _pingConsumer);
        });

        configurator.ReceiveEndpoint("test_pong_queue", e =>
        {
            e.Consumer(() => _pongConsumer);
        });
    }

    Task<ConsumeContext<IPongMessage>> _received;

    [Test]
    public async Task test_how_to_test_consumers()
    {
        await Bus.Publish<IPingMessage>(new { MessageId = 100 });
        await _received;

        Assert.IsTrue(_pongConsumer.hitme);
        Assert.AreEqual(100, _pongConsumer.pongMessage.MessageId);
    }

    public class PingConsumer : IConsumer<IPingMessage>
    {
        public Task Consume(ConsumeContext<IPingMessage> context)
        {
            context.Publish<IPongMessage>(new { context.Message.MessageId });
            return Task.CompletedTask;
        }
    }

    public class PongConsumer : IConsumer<IPongMessage>
    {
        internal bool hitme;
        internal IPongMessage pongMessage;
        public Task Consume(ConsumeContext<IPongMessage> context)
        {
            hitme = true;
            pongMessage = context.Message;
            return Task.CompletedTask;
        }
    }

    public interface IPingMessage
    {
        int MessageId { get; set; }
    }

    public interface IPongMessage
    {
        int MessageId { get; set; }
    }
}

此测试将向ping消费者发送消息，消费者本身将向消费者发送消息。

这本身可以工作并测试ping消费者将发送一条乒乓消息。在现实生活中，＆＃34; ping＆＃34;消费者将更新消息发送到另一个服务，而消费者消费者只是与测试一起使用的测试消费者。

如果我有第二个测试夹具，对于这个问题非常相似，当两个测试一起运行时它将失败。虽然它会单独通过。

测试做同样的事情

[TestFixture]
public class DingDongMessageTestFixture : InMemoryTestFixture
{
    private DongConsumer _pongConsumer;
    protected override void ConfigureInMemoryReceiveEndpoint(IInMemoryReceiveEndpointConfigurator configurator)
    {
        _received = Handled<IDongMessage>(configurator);
    }

    protected override void PreCreateBus(IInMemoryBusFactoryConfigurator configurator)
    {
        var _dingConsumer = new DingConsumer();
        _dongConsumer = new DongConsumer();
        configurator.ReceiveEndpoint("test_ding_queue", e =>
        {
            e.Consumer(() => _dingConsumer);
        });

        configurator.ReceiveEndpoint("test_dong_queue", e =>
        {
            e.Consumer(() => _dongConsumer);
        });
    }

    Task<ConsumeContext<IDongMessage>> _received;

    [Test]
    public async Task test_how_to_test_consumers()
    {
        await Bus.Publish<IDingMessage>(new { MessageId = 100 });
        await _received;

        Assert.IsTrue(_pongConsumer.hitme);
        Assert.AreEqual(100, _pongConsumer.pongMessage.MessageId);
    }

    public class DingConsumer : IConsumer<IDingMessage>
    {
        public Task Consume(ConsumeContext<IDingMessage> context)
        {
            context.Publish<IDongMessage>(new { context.Message.MessageId });
            return Task.CompletedTask;
        }
    }

    public class DongConsumer : IConsumer<IDongMessage>
    {
        internal bool hitme;
        internal IDongMessage pongMessage;
        public Task Consume(ConsumeContext<IDongMessage> context)
        {
            hitme = true;
            pongMessage = context.Message;
            return Task.CompletedTask;
        }
    }

    public interface IDingMessage
    {
        int MessageId { get; set; }
    }

    public interface IDongMessage
    {
        int MessageId { get; set; }
    }
}

这是测试Masstransit消费者的好方法吗？

如果是这样，我是否需要按照测试夹具重置InMemoryTestFixture？

Answer 1

在你的测试装置中，我不相信应该有任何冲突，但由于与NUnit的互动，可能有一些我不知道的东西，因为基类继承了＃39正在使用。

如果您直接使用InMemoryTestHarness（与文本夹具具有相同的功能，但没有任何测试框架依赖性），我希望您不会遇到两个同时执行的测试之间的任何交互。

你的方法应该是这样做的，但是我再次建议使用InMemoryTestHarness代替灯具。

链接了一个示例测试：https://github.com/MassTransit/MassTransit/blob/master/src/MassTransit.Tests/Testing/ConsumerTest_Specs.cs

Answer 2

此行为的关键在于InMemoryTestFixture的{{3}}。

public class InMemoryTestFixture : BusTestFixture
{

    ...

    [OneTimeSetUp]
    public Task SetupInMemoryTestFixture()
    {
        return InMemoryTestHarness.Start();
    }

    [OneTimeTearDown]
    public async Task TearDownInMemoryTestFixture()
    {
        await InMemoryTestHarness.Stop().ConfigureAwait(false);

        InMemoryTestHarness.Dispose();
    }

    ...

}

从此代码段中可以看到，测试工具在[OneTimeSetUp]和[OneTimeTearDown]标签中启动和停止，即在[TestFixture]中的任何测试运行之前和之后的所有测试中夹具是完整的-对于每个测试用例，都是不是。

我的解决方案是每次创建一个新的测试夹具。我相信MassTransit.TestFramework的作者就是这样做的，就像他们在source code中所做的那样。

使用InMemoryTestFixture测试MassTransit消费者

2 个答案: