<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
</dependency>

public class UserCreationEvent extends ApplicationEvent {
  private final String username;
  private final Long id;
  public UserCreationEvent(Object source, String username, Long id) {
    super(source);
    this.username = username;
    this.id = id;
  }
  // getters
}

@Service
public class UserService {
  private final ApplicationEventPublisher eventPublisher;
  public UserService(ApplicationEventPublisher eventPublisher) {
    this.eventPublisher = eventPublisher;
  }
  public Long createUser(String username) {
    // logic to create a user and store it in a database
    Long primaryKey = ThreadLocalRandom.current().nextLong(1, 1000);
    this.eventPublisher.publishEvent(new UserCreationEvent(this, username, primaryKey));
    return primaryKey;
  }
  public List<Long> createUser(List<String> usernames) {
    List<Long> resultIds = new ArrayList<>();
    for (String username : usernames) {
      resultIds.add(createUser(username));
    }
    return resultIds;
  }
}

@Component
public class ReportingListener {
  @EventListener(UserCreationEvent.class)
  public void reportUserCreation(UserCreationEvent event) {
    // e.g. increment a counter to report the total amount of new users
    System.out.println("Increment counter as new user was created: " + event);
  }
  @EventListener(UserCreationEvent.class)
  public void syncUserToExternalSystem(UserCreationEvent event) {
    // e.g. send a message to a messaging queue to inform other systems
    System.out.println("informing other systems about new user: " + event);
  }
}

@SpringBootTest
@RecordApplicationEvents
class UserServiceFullContextTest {
  @Autowired
  private ApplicationEvents applicationEvents;
  @Autowired
  private UserService userService;
  @Test
  void userCreationShouldPublishEvent() {
    this.userService.createUser("duke");
    assertEquals(1, applicationEvents
      .stream(UserCreationEvent.class)
      .filter(event -> event.getUsername().equals("duke"))
      .count());
    // There are multiple events recorded
    // PrepareInstanceEvent
    // BeforeTestMethodEvent
    // BeforeTestExecutionEvent
    // UserCreationEvent
    applicationEvents.stream().forEach(System.out::println);
  }
}

@Test
void batchUserCreationShouldPublishEvents(@Autowired ApplicationEvents events) {
  List<Long> result = this.userService.createUser(List.of("duke", "mike", "alice"));
  assertEquals(3, result.size());
  assertEquals(3, events.stream(UserCreationEvent.class).count());
}

@RecordApplicationEvents
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = UserService.class)
class UserServicePerClassTest {
  @Autowired
  private ApplicationEvents applicationEvents;
  @Autowired
  private UserService userService;
  @Test
  void userCreationShouldPublishEvent() {
    this.userService.createUser("duke");
    assertEquals(1, applicationEvents
      .stream(UserCreationEvent.class)
      .filter(event -> event.getUsername().equals("duke"))
      .count());
    applicationEvents.stream().forEach(System.out::println);
  }
}

@ExtendWith(MockitoExtension.class)
class UserServiceUnitTest {
  @Mock
  private ApplicationEventPublisher applicationEventPublisher;
  @Captor
  private ArgumentCaptor<UserCreationEvent> eventArgumentCaptor;
  @InjectMocks
  private UserService userService;
  @Test
  void userCreationShouldPublishEvent() {
    Long result = this.userService.createUser("duke");
    Mockito.verify(applicationEventPublisher).publishEvent(eventArgumentCaptor.capture());
    assertEquals("duke", eventArgumentCaptor.getValue().getUsername());
  }
  @Test
  void batchUserCreationShouldPublishEvents() {
    List<Long> result = this.userService.createUser(List.of("duke", "mike", "alice"));
    Mockito
      .verify(applicationEventPublisher, Mockito.times(3))
      .publishEvent(any(UserCreationEvent.class));
  }
}

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class ApplicationIT {
  @Autowired
  private TestRestTemplate testRestTemplate;
  @Test
  void shouldCreateUserAndPerformReporting() {
    ResponseEntity<Void> result = this.testRestTemplate
      .postForEntity("/api/users", "duke", Void.class);
    assertEquals(201, result.getStatusCodeValue());
    assertTrue(result.getHeaders().containsKey("Location"),
      "Response doesn't contain Location header");
    // additional assertion to verify the counter was incremented
    // additional assertion that a new message is part of the queue
  }
}