此版本仍在开发中，目前尚不稳定。如需最新稳定版本，请使用 Spring AMQP 4.0.2！spring-doc.cadn.net.cn

测试支持

为异步应用程序编写集成代码必然比测试更简单的应用程序要复杂得多。当诸如 @RabbitListener 注解之类的抽象引入时，情况会变得更加复杂。问题在于：如何验证在发送消息后，监听器是否按预期收到了该消息。spring-doc.cadn.net.cn

该框架本身包含许多单元测试和集成测试。一些测试使用模拟对象，而另一些则使用带有实时 RabbitMQ 代理的集成测试。您可以查阅这些测试以获取一些测试场景的灵感。spring-doc.cadn.net.cn

Spring AMQP 版本 1.6 引入了 spring-rabbit-test jar 包，该包提供了对其中一些更复杂场景的测试支持。预计该项目将随时间逐步扩展，但我们需要社区反馈，以便就帮助测试所需的功能提出建议。请通过 JIRA 或 GitHub Issues 提供此类反馈。spring-doc.cadn.net.cn

<h1>Spring框架</h1> <p>这是一个使用Spring框架开发的英文网站。</p> <p>@SpringRabbitTest注解用于测试配置。</p>

使用此注解可向 Spring 测试 ApplicationContext 添加基础设施 Bean。在使用例如 @SpringBootTest 等场景时，此操作并非必需，因为 Spring Boot 的自动配置会自动添加这些 Bean。spring-doc.cadn.net.cn

已注册的 Bean 包括：spring-doc.cadn.net.cn

CachingConnectionFactory (autoConnectionFactory). 如果存在 @RabbitEnabled，则使用其连接工厂。spring-doc.cadn.net.cn
RabbitTemplate (autoRabbitTemplate)spring-doc.cadn.net.cn
RabbitAdmin (autoRabbitAdmin)spring-doc.cadn.net.cn
RabbitListenerContainerFactory (autoContainerFactory)spring-doc.cadn.net.cn

此外，与 @EnableRabbit 关联的 Bean（用于支持 @RabbitListener）也会被添加。spring-doc.cadn.net.cn

Junit5 示例

@SpringJUnitConfig
@SpringRabbitTest
public class MyRabbitTests {

	@Autowired
	private RabbitTemplate template;

	@Autowired
	private RabbitAdmin admin;

	@Autowired
	private RabbitListenerEndpointRegistry registry;

	@Test
	void test() {
        ...
	}

	@Configuration
	public static class Config {

        ...

	}

}

Mockito`Answer<?>`实现

目前有两种 Answer<?> 实现方式，用于辅助测试。spring-doc.cadn.net.cn

第一个，LatchCountDownAndCallRealMethodAnswer，提供了一个 Answer<Void>，它返回 null 并递减一个计数器。spring-doc.cadn.net.cn

LatchCountDownAndCallRealMethodAnswer answer = this.harness.getLatchAnswerFor("myListener", 2);
doAnswer(answer)
    .when(listener).foo(anyString(), anyString());

...

assertThat(answer.await(10)).isTrue();

第二种，LambdaAnswer<T> 提供了一种可选机制，用于调用实际方法，并根据 InvocationOnMock 和结果（如有）返回自定义结果。spring-doc.cadn.net.cn

考虑以下POJO：spring-doc.cadn.net.cn

public class Thing {

    public String thing(String thing) {
        return thing.toUpperCase();
    }

}

以下类用于测试 Thing POJO：spring-doc.cadn.net.cn

Thing thing = spy(new Thing());

doAnswer(new LambdaAnswer<String>(true, (i, r) -> r + r))
    .when(thing).thing(anyString());
assertEquals("THINGTHING", thing.thing("thing"));

doAnswer(new LambdaAnswer<String>(true, (i, r) -> r + i.getArguments()[0]))
    .when(thing).thing(anyString());
assertEquals("THINGthing", thing.thing("thing"));

doAnswer(new LambdaAnswer<String>(false, (i, r) ->
    "" + i.getArguments()[0] + i.getArguments()[0])).when(thing).thing(anyString());
assertEquals("thingthing", thing.thing("thing"));

从版本 2.2.3 开始，答案会捕获被测试方法抛出的任何异常。使用 answer.getExceptions() 可获取对这些异常的引用。spring-doc.cadn.net.cn

当与 @RabbitListenerTest 和 RabbitListenerTestHarness 结合使用时，请使用 harness.getLambdaAnswerFor("listenerId", true, …) 为监听器获取一个正确构造的响应。spring-doc.cadn.net.cn

`@RabbitListenerTest`和`RabbitListenerTestHarness`

将 @Configuration 类中的一个类标注为 @RabbitListenerTest，会导致框架用一个名为 RabbitListenerTestHarness 的子类替换标准的 RabbitListenerAnnotationBeanPostProcessor（同时还能通过 @EnableRabbit 实现 @RabbitListener 的检测）。spring-doc.cadn.net.cn

该 RabbitListenerTestHarness 以两种方式增强了监听器。首先，它将监听器包装在一个 Mockito Spy 中，从而支持常规的 Mockito 模拟（stubbing）和验证操作。此外，它还可以向监听器添加一个 Advice，从而可访问调用的参数、结果以及可能抛出的异常。您可以通过 @RabbitListenerTest 上的属性来控制启用其中哪一项（或两项）。后一种方式旨在提供对调用底层数据的访问。它还支持在异步监听器被调用之前阻塞测试线程。spring-doc.cadn.net.cn

final @RabbitListener 方法无法被监视或增强。此外，只有带有 id 属性的监听器才能被监视或增强。

考虑一些示例。spring-doc.cadn.net.cn

以下示例使用了 spy：spring-doc.cadn.net.cn

@Configuration
@RabbitListenerTest
public class Config {

    @Bean
    public Listener listener() {
        return new Listener();
    }

    ...

}

public class Listener {

    @RabbitListener(id="foo", queues="#{queue1.name}")
    public String foo(String foo) {
        return foo.toUpperCase();
    }

    @RabbitListener(id="bar", queues="#{queue2.name}")
    public void foo(@Payload String foo, @Header("amqp_receivedRoutingKey") String rk) {
        ...
    }

}

@SpringJUnitConfig
public class MyTests {

    @Autowired
    private RabbitListenerTestHarness harness; (1)

    @Test
    public void testTwoWay() throws Exception {
        assertEquals("FOO", this.rabbitTemplate.convertSendAndReceive(this.queue1.getName(), "foo"));

        Listener listener = this.harness.getSpy("foo"); (2)
        assertNotNull(listener);
        verify(listener).foo("foo");
    }

    @Test
    public void testOneWay() throws Exception {
        Listener listener = this.harness.getSpy("bar");
        assertNotNull(listener);

        LatchCountDownAndCallRealMethodAnswer answer = this.harness.getLatchAnswerFor("bar", 2); (3)
        doAnswer(answer).when(listener).foo(anyString(), anyString()); (4)

        this.rabbitTemplate.convertAndSend(this.queue2.getName(), "bar");
        this.rabbitTemplate.convertAndSend(this.queue2.getName(), "baz");

        assertTrue(answer.await(10));
        verify(listener).foo("bar", this.queue2.getName());
        verify(listener).foo("baz", this.queue2.getName());
    }

}

1	将测试套件注入到测试用例中，以便我们能够访问模拟对象。
2	获取对模拟对象的引用，以便我们可以验证它是否按预期被调用。由于这是一项 `send` 和 `receive` 操作，无需挂起测试线程，因为线程已在 `RabbitTemplate` 处挂起，等待回复。
3	在这种情况下，我们仅使用发送操作，因此需要一个栅栏（latch）来等待在容器线程上调用监听器的异步调用。我们使用其中一个 Answer<?> 实现来协助完成此操作。重要提示：由于监听器是通过模拟（spy）方式被监控的，因此必须使用 `harness.getLatchAnswerFor()` 才能为该模拟获取一个正确配置的响应。
4	配置代理以调用 `Answer`。

以下示例使用了捕获通知：spring-doc.cadn.net.cn

@Configuration
@ComponentScan
@RabbitListenerTest(spy = false, capture = true)
public class Config {

}

@Service
public class Listener {

    private boolean failed;

    @RabbitListener(id="foo", queues="#{queue1.name}")
    public String foo(String foo) {
        return foo.toUpperCase();
    }

    @RabbitListener(id="bar", queues="#{queue2.name}")
    public void foo(@Payload String foo, @Header("amqp_receivedRoutingKey") String rk) {
        if (!failed && foo.equals("ex")) {
            failed = true;
            throw new RuntimeException(foo);
        }
        failed = false;
    }

}

@SpringJUnitConfig
public class MyTests {

    @Autowired
    private RabbitListenerTestHarness harness; (1)

    @Test
    public void testTwoWay() throws Exception {
        assertEquals("FOO", this.rabbitTemplate.convertSendAndReceive(this.queue1.getName(), "foo"));

        InvocationData invocationData =
            this.harness.getNextInvocationDataFor("foo", 0, TimeUnit.SECONDS); (2)
        assertThat(invocationData.getArguments()[0], equalTo("foo"));     (3)
        assertThat((String) invocationData.getResult(), equalTo("FOO"));
    }

    @Test
    public void testOneWay() throws Exception {
        this.rabbitTemplate.convertAndSend(this.queue2.getName(), "bar");
        this.rabbitTemplate.convertAndSend(this.queue2.getName(), "baz");
        this.rabbitTemplate.convertAndSend(this.queue2.getName(), "ex");

        InvocationData invocationData =
            this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS); (4)
        Object[] args = invocationData.getArguments();
        assertThat((String) args[0], equalTo("bar"));
        assertThat((String) args[1], equalTo(queue2.getName()));

        invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
        args = invocationData.getArguments();
        assertThat((String) args[0], equalTo("baz"));

        invocationData = this.harness.getNextInvocationDataFor("bar", 10, TimeUnit.SECONDS);
        args = invocationData.getArguments();
        assertThat((String) args[0], equalTo("ex"));
        assertEquals("ex", invocationData.getThrowable().getMessage()); (5)
    }

}

1	将测试套件注入到测试用例中，以便我们能够访问模拟对象。
2	使用 `harness.getNextInvocationDataFor()` 来获取调用数据——在此情况下，由于是请求/响应（request/reply）场景，无需等待任何时间，因为测试线程已在 `RabbitTemplate` 处被挂起，等待结果。
3	然后我们可以验证参数和结果是否符合预期。
4	这次我们需要一些时间来等待数据，因为这是在容器线程上的异步操作，我们需要挂起测试线程。
5	当监听器抛出异常时，该异常可在调用数据的 `throwable` 属性中获取。

当使用自定义 Answer<?> 与工具包配合时，为确保其正常运行，此类答案应继承 ForwardsInvocation，并从工具包中获取实际的监听器（而非模拟对象）(getDelegate("myListener"))，然后调用 super.answer(invocation)。有关示例，请参阅提供的 Mockito Answer<?> 实现源代码。

使用`TestRabbitTemplate`

代码 TestRabbitTemplate 提供了基本的集成测试功能，无需依赖消息代理即可运行。当您在测试用例中将其作为 @Bean 添加时，它会自动发现上下文中的所有监听器容器，无论这些容器是通过 @Bean 或 <bean/> 声明的，还是使用 @RabbitListener 注解配置的。目前它仅支持按队列名称进行路由。该模板会从容器中提取消息监听器，并在测试线程上直接调用它。对于返回回复的监听器，也支持请求-回复消息模式（sendAndReceive 方法）。spring-doc.cadn.net.cn

以下测试用例使用了该模板：spring-doc.cadn.net.cn

@SpringJUnitConfig
public class TestRabbitTemplateTests {

    @Autowired
    private TestRabbitTemplate template;

    @Autowired
    private Config config;

    @Test
    public void testSimpleSends() {
        this.template.convertAndSend("foo", "hello1");
        assertThat(this.config.fooIn, equalTo("foo:hello1"));
        this.template.convertAndSend("bar", "hello2");
        assertThat(this.config.barIn, equalTo("bar:hello2"));
        assertThat(this.config.smlc1In, equalTo("smlc1:"));
        this.template.convertAndSend("foo", "hello3");
        assertThat(this.config.fooIn, equalTo("foo:hello1"));
        this.template.convertAndSend("bar", "hello4");
        assertThat(this.config.barIn, equalTo("bar:hello2"));
        assertThat(this.config.smlc1In, equalTo("smlc1:hello3hello4"));

        this.template.setBroadcast(true);
        this.template.convertAndSend("foo", "hello5");
        assertThat(this.config.fooIn, equalTo("foo:hello1foo:hello5"));
        this.template.convertAndSend("bar", "hello6");
        assertThat(this.config.barIn, equalTo("bar:hello2bar:hello6"));
        assertThat(this.config.smlc1In, equalTo("smlc1:hello3hello4hello5hello6"));
    }

    @Test
    public void testSendAndReceive() {
        assertThat(this.template.convertSendAndReceive("baz", "hello"), equalTo("baz:hello"));
    }

}

@Configuration
@EnableRabbit
public static class Config {

    public String fooIn = "";

    public String barIn = "";

    public String smlc1In = "smlc1:";

    @Bean
    public TestRabbitTemplate template() throws IOException {
        return new TestRabbitTemplate(connectionFactory());
    }

    @Bean
    public ConnectionFactory connectionFactory() throws IOException {
        ConnectionFactory factory = mock(ConnectionFactory.class);
        Connection connection = mock(Connection.class);
        Channel channel = mock(Channel.class);
        willReturn(connection).given(factory).createConnection();
        willReturn(channel).given(connection).createChannel(anyBoolean());
        given(channel.isOpen()).willReturn(true);
        return factory;
    }

    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory() throws IOException {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        return factory;
    }

    @RabbitListener(queues = "foo")
    public void foo(String in) {
        this.fooIn += "foo:" + in;
    }

    @RabbitListener(queues = "bar")
    public void bar(String in) {
        this.barIn += "bar:" + in;
    }

    @RabbitListener(queues = "baz")
    public String baz(String in) {
        return "baz:" + in;
    }

    @Bean
    public SimpleMessageListenerContainer smlc1() throws IOException {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
        container.setQueueNames("foo", "bar");
        container.setMessageListener(new MessageListenerAdapter(new Object() {

            public void handleMessage(String in) {
                smlc1In += in;
            }

        }));
        return container;
    }

}

JUnit5 条件

版本 2.0.2 引入了对 JUnit5 的支持。spring-doc.cadn.net.cn

使用`@RabbitAvailable`注解

自定义 JUnit 5 @RabbitAvailable 注解由 RabbitAvailableCondition 进行处理。spring-doc.cadn.net.cn

注解有三个属性：spring-doc.cadn.net.cn

queues: 一组在每次测试前声明（并清除）并在所有测试完成后删除的队列。spring-doc.cadn.net.cn
management: 将此设置为 true，以表示您的测试也需要在代理上安装管理插件。spring-doc.cadn.net.cn
purgeAfterEach: (自版本 2.2 起) 当 true（默认值）时，queues 将在测试之间被清除。spring-doc.cadn.net.cn

用于检查代理是否可用，并在不可用时跳过测试。spring-doc.cadn.net.cn

有时您希望测试在没有消息代理的情况下失败，例如夜间CI构建。要禁用运行时的 BrokerRunningSupport，请将名为 RABBITMQ_SERVER_REQUIRED 的环境变量设置为 true。spring-doc.cadn.net.cn

您可以重写代理属性（如主机名），方法是使用设置器或环境变量。spring-doc.cadn.net.cn

以下示例展示了如何通过setter方法重写属性：spring-doc.cadn.net.cn

@RabbitAvailable
...

@BeforeAll
static void setup() {
    RabbitAvailableCondition.getBrokerRunning().setHostName("10.0.0.1");
}

@AfterAll
static void tearDown() {
    RabbitAvailableCondition.getBrokerRunning().removeTestQueues("some.other.queue.too");
}

您还可以通过设置以下环境变量来重写属性：spring-doc.cadn.net.cn

public static final String BROKER_ADMIN_URI = "RABBITMQ_TEST_ADMIN_URI";
public static final String BROKER_HOSTNAME = "RABBITMQ_TEST_HOSTNAME";
public static final String BROKER_PORT = "RABBITMQ_TEST_PORT";
public static final String BROKER_USER = "RABBITMQ_TEST_USER";
public static final String BROKER_PW = "RABBITMQ_TEST_PASSWORD";
public static final String BROKER_ADMIN_USER = "RABBITMQ_TEST_ADMIN_USER";
public static final String BROKER_ADMIN_PW = "RABBITMQ_TEST_ADMIN_PASSWORD";

这些环境变量会覆盖默认设置（AMQP 为 localhost:5672，管理 REST API 为 localhost:15672/api/）。spring-doc.cadn.net.cn

更改主机名会影响 amqp 和 management REST API 连接（除非已显式设置管理 URI）。spring-doc.cadn.net.cn

BrokerRunningSupport 也提供了一个名为 static 的 setEnvironmentVariableOverrides 方法，您可以通过该方法传入一个包含这些变量的映射（map）。spring-doc.cadn.net.cn

在您的测试用例中，您可以使用 RabbitAvailableCondition.getBrokerRunning() 来创建连接工厂；getConnectionFactory() 返回规则的 RabbitMQ ConnectionFactory。以下示例展示了如何实现这一点：spring-doc.cadn.net.cn

@Bean
public CachingConnectionFactory rabbitConnectionFactory() {
    return new CachingConnectionFactory(RabbitAvailableCondition.getBrokerRunning().getConnectionFactory());
}

此外，RabbitAvailableCondition 还支持参数化测试构造函数和方法的参数解析。支持两种参数类型：spring-doc.cadn.net.cn

BrokerRunningSupport: 实例spring-doc.cadn.net.cn
ConnectionFactory: 该 BrokerRunningSupport 实例的 RabbitMQ 连接工厂spring-doc.cadn.net.cn

以下示例展示了两者：<br/>spring-doc.cadn.net.cn

@RabbitAvailable(queues = "rabbitAvailableTests.queue")
public class RabbitAvailableCTORInjectionTests {

    private final ConnectionFactory connectionFactory;

    public RabbitAvailableCTORInjectionTests(BrokerRunningSupport brokerRunning) {
        this.connectionFactory = brokerRunning.getConnectionFactory();
    }

    @Test
    public void test(ConnectionFactory cf) throws Exception {
        assertSame(cf, this.connectionFactory);
        Connection conn = this.connectionFactory.newConnection();
        Channel channel = conn.createChannel();
        DeclareOk declareOk = channel.queueDeclarePassive("rabbitAvailableTests.queue");
        assertEquals(0, declareOk.getConsumerCount());
        channel.close();
        conn.close();
    }

}

前面的测试在框架本身中执行，用于验证参数注入，并且该条件正确地创建了队列。spring-doc.cadn.net.cn

一个实用的用户测试可能如下所示：spring-doc.cadn.net.cn

@RabbitAvailable(queues = "rabbitAvailableTests.queue")
public class RabbitAvailableCTORInjectionTests {

    private final CachingConnectionFactory connectionFactory;

    public RabbitAvailableCTORInjectionTests(BrokerRunningSupport brokerRunning) {
        this.connectionFactory =
            new CachingConnectionFactory(brokerRunning.getConnectionFactory());
    }

    @Test
    public void test() throws Exception {
        RabbitTemplate template = new RabbitTemplate(this.connectionFactory);
        ...
    }
}

当您在测试类中使用Spring注解式的应用上下文时，可以通过一个名为RabbitAvailableCondition.getBrokerRunning()的静态方法获取到条件的连接工厂引用。spring-doc.cadn.net.cn

下面的测试来自框架，并演示了它的用法。spring-doc.cadn.net.cn

@RabbitAvailable(queues = {
        RabbitTemplateMPPIntegrationTests.QUEUE,
        RabbitTemplateMPPIntegrationTests.REPLIES })
@SpringJUnitConfig
@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD)
public class RabbitTemplateMPPIntegrationTests {

    public static final String QUEUE = "mpp.tests";

    public static final String REPLIES = "mpp.tests.replies";

    @Autowired
    private RabbitTemplate template;

    @Autowired
    private Config config;

    @Test
    public void test() {

        ...

    }

    @Configuration
    @EnableRabbit
    public static class Config {

        @Bean
        public CachingConnectionFactory cf() {
            return new CachingConnectionFactory(RabbitAvailableCondition
                    .getBrokerRunning()
                    .getConnectionFactory());
        }

        @Bean
        public RabbitTemplate template() {

            ...

        }

        @Bean
        public SimpleRabbitListenerContainerFactory
                            rabbitListenerContainerFactory() {

            ...

        }

        @RabbitListener(queues = QUEUE)
        public byte[] foo(byte[] in) {
            return in;
        }

    }

}

使用`@LongRunning`注解

@LongRunning注释会使得测试被跳过，除非设置了环境变量（或者系统属性）为true。下面的例子展示了如何使用它：spring-doc.cadn.net.cn

@RabbitAvailable(queues = SimpleMessageListenerContainerLongTests.QUEUE)
@LongRunning
public class SimpleMessageListenerContainerLongTests {

    public static final String QUEUE = "SimpleMessageListenerContainerLongTests.queue";

...

}

默认情况下，变量为 0 ，但在注释的 1 属性中可以指定变量名。 spring-doc.cadn.net.cn

测试支持

<h1>Spring框架</h1> <p>这是一个使用Spring框架开发的英文网站。</p> <p>@SpringRabbitTest注解用于测试配置。</p>

MockitoAnswer<?>实现

@RabbitListenerTest和RabbitListenerTestHarness

使用TestRabbitTemplate