Previous integration test consumes current test queue message - spring

Question

So I am trying to use some queues in my project(rabbitmq). I decided to create simple publisher/receiver integration tests.
So I ve made simple sender
#Component
public class QueueSender {
...
public void sendMessage(#RequestParam String message) {
rabbitTemplate.convertAndSend(queue, message);
}
}
and corresponding test
#SpringBootTest(classes = QueueSender.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
#Import(RabbitAutoConfiguration.class)
class QueueSenderTest {
... --docker rabbitmq instance is one for all tests.
#Test
void shouldSendMessageToQueue() {
String message = "hello world";
queueSender.sendMessage(message);
Object response = rabbitTemplate.receiveAndConvert(queue, MAX_TIMEOUT_MILLIS);
assertEquals(message, response);
}
}
and simple receiver
#Component
public class QueueListener {
#RabbitListener(queuesToDeclare = #Queue("${queues.listener}"))
public void listener(Message object) {
System.out.println("received " + object);
}
}
and corresponding test
#SpringBootTest(classes = QueueListener.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
#Import(RabbitAutoConfiguration.class)
class QueueListenerTest {
... --docker rabbitmq instance is one for all tests.
#Test
void shouldFireListenerOnNewMessageOnQueue() {
String message = "hello world";
ArgumentCaptor<Message> argument = ArgumentCaptor.forClass(Message.class);
rabbitTemplate.convertAndSend(queue, message);
verify(queueListener, timeout(MAX_TIMEOUT_MILLIS)).listener(argument.capture());
assertEquals(message, new String(argument.getValue().getBody()));
}
}
queues configuration is placed in application.properties
queues:
listener: "listen-queue-name"
sender: "sender-queue-name"
Everything works fine till I will not to try use same queue for both tests and run them at once
queues:
listener: "listen-queue-name"
sender: "listen-queue-name"
In such case always SenderTest fails.
So when I am debuging SenderTest it seems like spring context of previous test consumes message as debugger stops in QueueListener which should not be even in context of QueueSender test -.-
Funny fact that moving one of those test classes to another package fix the problem, so probalby SenderTest is fired so fast that RabbitListener from previous test is still registered.
DirtiesContext works aswell but I dont want to use it.
Any ideas?

Answer 1

from the spring documentation
Spring’s test framework caches application contexts between tests.
Therefore, as long as your tests share the same configuration (no
matter how it is discovered), the potentially time-consuming process
of loading the context happens only once.
So thats your problem.

Answer 2

Not exactly an answer to your problem ,but more of a suggestion.
You could try using Test Containers for RabbitMQ.So essentially your test case would
1--Start RabbitMq Test Container, which will create the Queue.
2--Perform your Tests
3--Destroy the Test Container.
All of this is should be pretty quick.
This will ensure all test classes are using independent queues and hence no
possibility of any conflicts.
This in my view should be a more cleaner approach to testing.
Test Container:
https://www.testcontainers.org/modules/rabbitmq/

Answer 3

I think I had a related problem.
Setup
Integration test, using rabbitmq testcontainer (shared, singleton approach)
SpringBootTest, JUnit5
Test class with a nested class per 'scenario', each with several test methods
The test sends out events and then verifies that the module's event handlers do their job. I use approval testing for asserting the expected state of the resulting new or changed JPA entities, backed by MySQL (also in testcontainer)
rabbitmq test bindings are configured using application-test.yml; it imports the main application.yml and then overrides cloud/stream rabbit and bindings such that events sent by my test event sender arrive at the production code event handlers.
Problem
When running just my integration test class, such as from IDE, all is good.
BUT: when running all of the module's tests in the same JVM - whether from IDE or by Maven, then the preceding integration tests seem to interfere with the later-running. In my experience, each event handler is invoked only the first time within my integration test, when other integration test classes already ran in the same JVM. All subsequent events are not reaching their handlers.
What helped
Override the binding group name to be unique within the module's testing. This ensures that the handlers under test receive the events even when some ghosts (?) are still listening on the same channel.
This can be done in various ways (such as overriding by profiles), but the simplest is: add the overriding property to the class SpringBootTest annotation, e.g.:
#SpringBootTest(properties = "spring.cloud.stream.bindings.myEventHandler-in-0.group=myUnique123EventTestGroup-v1")
public class MyEventConsumersIntegrationTest {
FYI, the binding section in my application-test.yml looks something like this:
### In all testing:
spring:
config:
# application-test.yml is read INSTEAD of application.yml, hence need to import the latter explicitly:
import: classpath:application.yml
---
### Overrides for my module:
spring:
config:
activate:
on-profile: mymodule
cloud:
stream:
function:
definition: myEventHandler
rabbit:
bindings:
myEventHandler-in-0:
bindings:
myTestEventSender-out-0:
destination: myEventChannel
binder: rabbit
myEventHandler-in-0:
destination: myEventChannel
group: myEventGroup-v1 # Override the group value for each integration test class