C# NServiceBus：测试是否同时发布事件和引发异常

我在我们的一项服务中遇到了如下代码：

try
{
    // Step 1: collect underpants.
}
catch (Exception ex)
{
    // If this is the last retry we'll raise an event.
    if (Bus.IsLastRetry())
    {
        PublishFailedEvent(ex);
    }

    // But we'll also send the error to the error queue no matter what.
    throw;
}

Test.Handler(bus => new Processor() { Bus = bus })
    .ExpectPublish<IFailedEvent>()
    .OnMessage<ISomeHappenedEvent>();

下面是一个测试：

try
{
    // Step 1: collect underpants.
}
catch (Exception ex)
{
    // If this is the last retry we'll raise an event.
    if (Bus.IsLastRetry())
    {
        PublishFailedEvent(ex);
    }

    // But we'll also send the error to the error queue no matter what.
    throw;
}

Test.Handler(bus => new Processor() { Bus = bus })
    .ExpectPublish<IFailedEvent>()
    .OnMessage<ISomeHappenedEvent>();

Test.Handler（总线=>newprocessor（）{bus=bus}）
.publish（）
.OnMessage（）；

因为我们在发布测试失败后立即抛出。有没有办法测试FailedEvent是否已发布并引发异常？

只需将对test（）的调用包装在一个try catch中，然后针对异常进行断言。根据NSB的版本，处理程序可能会引发TargetInvocationException，您需要对其进行查询以获得内部异常

try
{
    Test.Handler(bus => new Processor() { Bus = bus }).OnMessage<ISomeHappenedEvent>();
}
catch (MyExpectedException ex)
{
    // Asserts 
    ...
}

试试看
{
Handler（bus=>newprocessor（）{bus=bus}）.OnMessage（）；
}
捕获（MyExpectedException ex）
{
//断言
...
}

或者

试试看
{
Handler（bus=>newprocessor（）{bus=bus}）.OnMessage（）；
}
捕获（目标异常）
{
//针对ex.InnerException的断言
...
}

只需将对Test（）的调用包装在try catch中，然后针对异常断言即可。根据NSB的版本，处理程序可能会引发TargetInvocationException，您需要对其进行查询以获得内部异常

try
{
    Test.Handler(bus => new Processor() { Bus = bus }).OnMessage<ISomeHappenedEvent>();
}
catch (MyExpectedException ex)
{
    // Asserts 
    ...
}

试试看
{
Handler（bus=>newprocessor（）{bus=bus}）.OnMessage（）；
}
捕获（MyExpectedException ex）
{
//断言
...
}

或者

试试看
{
Handler（bus=>newprocessor（）{bus=bus}）.OnMessage（）；
}
捕获（目标异常）
{
//针对ex.InnerException的断言
...
}

如果使用，还可以使用属性来测试预期的异常

[Test]
    [ExpectedException(typeof(MyException))]
    public void it_should_throw_attribute()
    {
        Assert.Fail();
    }

或者，如果您更愿意使用，您也可以使用它并检查抛出的异常的确切类型，或者只检查基本异常，并进行进一步检查，例如conaining InnerException、Message、

[Test]
    public void it_should_throw_exactly()
    {
        Action actionToTest = () => { throw new MyException(); };
        actionToTest.ShouldThrowExactly<MyException>();
    }

    [Test]
    public void it_should_throw()
    {
        Action actionToTest = () => { throw new MyException(); };
        actionToTest.ShouldThrow<Exception>();
    }

[测试]
公之于众它应该扔它正好（）
{
Action actionToTest=（）=>{抛出新的MyException（）；}；
actionToTest.shouldThrowectly（）；
}
[测试]
公开作废它应该扔（）
{
Action actionToTest=（）=>{抛出新的MyException（）；}；
actionToTest.ShouldThrow（）；
}

如果使用，还可以使用属性来测试预期的异常

[Test]
    [ExpectedException(typeof(MyException))]
    public void it_should_throw_attribute()
    {
        Assert.Fail();
    }

或者，如果您更愿意使用，您也可以使用它并检查抛出的异常的确切类型，或者只检查基本异常，并进行进一步检查，例如conaining InnerException、Message、

[Test]
    public void it_should_throw_exactly()
    {
        Action actionToTest = () => { throw new MyException(); };
        actionToTest.ShouldThrowExactly<MyException>();
    }

    [Test]
    public void it_should_throw()
    {
        Action actionToTest = () => { throw new MyException(); };
        actionToTest.ShouldThrow<Exception>();
    }

[测试]
公之于众它应该扔它正好（）
{
Action actionToTest=（）=>{抛出新的MyException（）；}；
actionToTest.shouldThrowectly（）；
}
[测试]
公开作废它应该扔（）
{
Action actionToTest=（）=>{抛出新的MyException（）；}；
actionToTest.ShouldThrow（）；
}

如果处理程序引发异常，则不会检查期望值。为了测试这一点，您可以向处理程序引入一个布尔标志，并将测试分为两个测试。i、 e

[Test]
public void it_should_publish_event()
{
    Test.Handler(bus => new Processor() { Bus = bus, DoNotThrow = true })
        .ExpectPublish<IFailedEvent>()
        .OnMessage<ISomeHappenedEvent>();
}

[Test, ExpectedException(typeof(YourException))]
public void it_should_throw()
{
    Test.Handler(bus => new Processor() { Bus = bus })
        .OnMessage<ISomeHappenedEvent>();
}

[测试]
public void it\u应该发布\u事件（）
{
Handler（bus=>newprocessor（）{bus=bus，DoNotThrow=true}）
.publish（）
.OnMessage（）；
}
[Test，ExpectedException（typeof（YourException））]
公开作废它应该扔（）
{
Handler（bus=>newprocessor（）{bus=bus}）
.OnMessage（）；
}

---

请注意，如果使用DTC或发件箱配置传输，则如果处理程序中引发异常，则不会发布此事件（除非发布配置为立即分派）

如果处理程序抛出异常，则不会检查期望值。为了测试这一点，您可以向处理程序引入一个布尔标志，并将测试分为两个测试。i、 e

[Test]
public void it_should_publish_event()
{
    Test.Handler(bus => new Processor() { Bus = bus, DoNotThrow = true })
        .ExpectPublish<IFailedEvent>()
        .OnMessage<ISomeHappenedEvent>();
}

[Test, ExpectedException(typeof(YourException))]
public void it_should_throw()
{
    Test.Handler(bus => new Processor() { Bus = bus })
        .OnMessage<ISomeHappenedEvent>();
}

[测试]
public void it\u应该发布\u事件（）
{
Handler（bus=>newprocessor（）{bus=bus，DoNotThrow=true}）
.publish（）
.OnMessage（）；
}
[Test，ExpectedException（typeof（YourException））]
公开作废它应该扔（）
{
Handler（bus=>newprocessor（）{bus=bus}）
.OnMessage（）；
}

---

请注意，如果使用DTC或发件箱配置传输，则如果处理程序中引发异常，则不会发布此事件（除非发布配置为立即分派）

用线，睡一会儿time@viveknuna这绝对不是一个有用的建议。使用线程。睡一会儿time@viveknuna这绝对不是一个有用的建议。