C# 单元测试MassTransit时未呼叫消费者

我正在尝试使用MassTransit编写单元测试。在线查看时，我发现访问总线的最佳方法是使用内存测试线束中的

创建总线。我添加我的消费者和一个
PublishObserver
，以获得结果行为

在下面的示例中，我向总线发送一条
TestRequest
消息，然后我的消费者读取请求并将
TestResponse
消息放回总线。最后，观察者得到响应

我不知道问题是否出在我丢失的某些配置上，或者是否有一些任务我没有等待，但请求消息甚至从未到达消费者

我错过了什么

测试

[TestMethod]
public void RequestResponseBusTest()
{
    var harness = new InMemoryTestHarness();

    var consumer = new TestConsumer();
    harness.OnConfigureInMemoryBus += c =>
    {
        c.ReceiveEndpoint("testqueue", e =>
            e.Consumer(() => consumer));
    };

    var observer = new TestPublishObserver();
    harness.OnConnectObservers += c =>
    {
        c.ConnectPublishObserver(observer);
    };

    harness.Start().Wait();
    var bus = harness.Bus;

    bus.Publish(new TestRequest() { X = 99 }).Wait();

    Assert.AreEqual(1, consumer.ConsumedMessages.Count, "consumed");
    Assert.AreEqual(1, observer.PublishedRequests.Count, "requests");
    Assert.AreEqual(1, observer.PublishedResponses.Count, "responses");

}

及支援课程

[Serializable]
public class TestRequest
{
    public int X { get; set; }
}

[Serializable]
public class TestResponse
{
    public int Y { get; set; }
}

public class TestConsumer : IConsumer<TestRequest>
{
    public List<TestRequest> ConsumedMessages { get; } = new List<TestRequest>();

    public Task Consume(ConsumeContext<TestRequest> context)
    {
        ConsumedMessages.Add(context.Message);
        context.Publish(new TestResponse() { Y = 123 }).Wait();
        return Task.CompletedTask;
    }
}

private class TestPublishObserver : IPublishObserver
{
    public List<TestRequest> PublishedRequests { get; } = new List<TestRequest>();
    public List<TestResponse> PublishedResponses { get; } = new List<TestResponse>();

    public Task PrePublish<T>(PublishContext<T> context) where T : class
    {
        return Task.CompletedTask;
    }

    public Task PostPublish<T>(PublishContext<T> context) where T : class
    {
        var msg = context.Message;

        if (msg is TestRequest)
            PublishedRequests.Add((TestRequest)(object)msg);

        if (msg is TestResponse)
            PublishedResponses.Add((TestResponse)(object)msg);

        return Task.CompletedTask;
    }

    public Task PublishFault<T>(PublishContext<T> context, Exception exception) where T : class
    {
        return Task.CompletedTask;
    }
}

[可序列化]
公共类测试请求
{
公共整数X{get；set；}
}
[可序列化]
公共类TestResponse
{
公共整数Y{get；set；}
}
公共类TestConsumer:IConsumer
{
公共列表使用消息{get；}=new List（）；
公共任务消费（消费上下文）
{
添加（context.Message）；
Publish（newtestresponse（）{Y=123}）.Wait（）；
返回Task.CompletedTask；
}
}
私有类TestPublishObserver:IPPublishObserver
{
public List PublishedRequests{get；}=new List（）；
public List PublishedResponses{get；}=new List（）；
公共任务预发布（PublishContext上下文），其中T:class
{
返回Task.CompletedTask；
}
公共任务后发布（PublishContext上下文），其中T:class
{
var msg=context.Message；
if（msg是TestRequest）
Add（（TestRequest）（object）msg）；
if（msg是TestResponse）
Add（（TestResponse）（object）msg）；
返回Task.CompletedTask；
}
公共任务PublishFault（PublishContext上下文，异常异常），其中T:class
{
返回Task.CompletedTask；
}
}
您需要在bus.Publish（newtestrequest（）{X=99}）.Wait（）之后添加Thread.Sleep（2000）；
bus.Publish不保证邮件传递。调用Wait（）方法时，只需等待它被发送，而不是被处理

或者

[TestMethod]
public void requestResponseBustTest（）
{
var线束=新的InMemoryTestHarness（）；
var consumer=newtestconsumer（）；
harness.OnConfigureInMemoryBus+=c=>
{
c、 ReceiveEndpoint（“testqueue”，e=>
e、 消费者（（）=>消费者））；
};
var observer=新的TestPublishObserver（）；
harnese.onconnectobserver+=c=>
{
c、 观察员（观察员）；
};
线束。开始（）。等待（）；
var总线=线束总线；
Publish（newtestrequest（）{X=99}）.Wait（）；
//添加这一行
var receivedMessage=harness.consumered.Select（）.FirstOrDefault（）；
AreEqual（1，consumer.consumerdMessages.Count，“consumered”）；
Assert.AreEqual（1，observer.PublishedRequests.Count，“请求”）；
Assert.AreEqual（1，observer.PublishedResponses.Count，“responses”）；
}
我认为你给出的第二种方法可以解决我的问题。我必须进行一些实验，但我认为我可以在测试中编写一个通用的“等待所有已发布的消息”方法。谢谢我想看看消费者安全带是如何使用的，这会有所帮助：我知道我并没有按照它的使用方式使用它。实际上，我所做的是对EventFlow应用程序进行端到端测试，我在IBusControl上发送消息并观察读取模型的状态。要做到这一点，我必须等待所有消费者结束，然后才能开始评估，我发现没有简单的方法可以做到这一点。你可以使用活动监视器：我会调查它，非常感谢。
[TestMethod]
public void RequestResponseBusTest()
{
    var harness = new InMemoryTestHarness();

    var consumer = new TestConsumer();
    harness.OnConfigureInMemoryBus += c =>
    {
        c.ReceiveEndpoint("testqueue", e =>
            e.Consumer(() => consumer));
    };

    var observer = new TestPublishObserver();
    harness.OnConnectObservers += c =>
    {
        c.ConnectPublishObserver(observer);
    };

    harness.Start().Wait();
    var bus = harness.Bus;

    bus.Publish(new TestRequest() { X = 99 }).Wait();

    //add this line
    var receivedMessage = harness.Consumed.Select<TestRequest>().FirstOrDefault();

    Assert.AreEqual(1, consumer.ConsumedMessages.Count, "consumed");
    Assert.AreEqual(1, observer.PublishedRequests.Count, "requests");
    Assert.AreEqual(1, observer.PublishedResponses.Count, "responses");

}