test: Add unit tests

juancgalvis · juancgalvis · commit 048df9a5fc3e · 2025-02-24T16:06:57.000-05:00
diff --git a/async/async-commons-api/src/main/java/org/reactivecommons/async/api/HandlerRegistry.java b/async/async-commons-api/src/main/java/org/reactivecommons/async/api/HandlerRegistry.java
@@ -52,7 +52,7 @@ public HandlerRegistry listenDomainCloudEvent(String domain, String eventName, C
         return this;
     }
 
-    public HandlerRegistry listenDomainRawEvent(String domain, String eventName, RawEventHandler handler) {
+    public HandlerRegistry listenDomainRawEvent(String domain, String eventName, RawEventHandler<?> handler) {
         domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>())
                 .add(new RegisteredEventListener<>(eventName, handler, RawMessage.class));
         return this;
diff --git a/async/async-commons-api/src/test/java/org/reactivecommons/async/api/HandlerRegistryTest.java b/async/async-commons-api/src/test/java/org/reactivecommons/async/api/HandlerRegistryTest.java
@@ -5,12 +5,14 @@
 import org.junit.jupiter.api.Test;
 import org.reactivecommons.api.domain.Command;
 import org.reactivecommons.api.domain.DomainEvent;
+import org.reactivecommons.api.domain.RawMessage;
 import org.reactivecommons.async.api.handlers.CloudCommandHandler;
 import org.reactivecommons.async.api.handlers.CloudEventHandler;
 import org.reactivecommons.async.api.handlers.DomainCommandHandler;
 import org.reactivecommons.async.api.handlers.DomainEventHandler;
 import org.reactivecommons.async.api.handlers.QueryHandler;
 import org.reactivecommons.async.api.handlers.QueryHandlerDelegate;
+import org.reactivecommons.async.api.handlers.RawEventHandler;
 import org.reactivecommons.async.api.handlers.registered.RegisteredCommandHandler;
 import org.reactivecommons.async.api.handlers.registered.RegisteredEventListener;
 import org.reactivecommons.async.api.handlers.registered.RegisteredQueryHandler;
@@ -54,6 +56,20 @@ void shouldListenDomainCloudEvent() {
                         .containsExactly(name, CloudEvent.class, eventHandler)).hasSize(1);
     }
 
+    @Test
+    void shouldListenDomainRawEvent() {
+        SomeRawEventHandler eventHandler = new SomeRawEventHandler();
+
+        registry.listenDomainRawEvent(domain, name, eventHandler);
+
+        assertThat(registry.getDomainEventListeners().get(domain))
+                .anySatisfy(registered -> assertThat(registered)
+                        .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass,
+                                RegisteredEventListener::getHandler
+                        )
+                        .containsExactly(name, RawMessage.class, eventHandler)).hasSize(1);
+    }
+
     @Test
     void shouldListenEvent() {
         SomeDomainEventHandler<SomeDataClass> eventHandler = new SomeDomainEventHandler<>();
@@ -269,6 +285,13 @@ public Mono<Void> handle(CloudEvent message) {
         }
     }
 
+    private static class SomeRawEventHandler implements RawEventHandler<RawMessage> {
+        @Override
+        public Mono<Void> handle(RawMessage message) {
+            return null;
+        }
+    }
+
     private static class SomeDomainCommandHandler<SomeDataClass> implements DomainCommandHandler<SomeDataClass> {
         @Override
         public Mono<Void> handle(Command<SomeDataClass> message) {
diff --git a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaDomainEventBusTest.java b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaDomainEventBusTest.java
@@ -7,6 +7,7 @@
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.reactivecommons.api.domain.DomainEvent;
+import org.reactivecommons.api.domain.RawMessage;
 import org.reactivecommons.async.kafka.communications.ReactiveMessageSender;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
@@ -21,6 +22,8 @@ class KafkaDomainEventBusTest {
     @Mock
     private CloudEvent cloudEvent;
     @Mock
+    private RawMessage rawMessage;
+    @Mock
     private ReactiveMessageSender sender;
     @InjectMocks
     private KafkaDomainEventBus kafkaDomainEventBus;
@@ -48,9 +51,21 @@ void shouldEmitCloudEvent() {
                 .verifyComplete();
     }
 
+    @Test
+    void shouldEmitRawMessage() {
+        // Arrange
+        when(sender.send(rawMessage)).thenReturn(Mono.empty());
+        // Act
+        Mono<Void> flow = Mono.from(kafkaDomainEventBus.emit(rawMessage));
+        // Assert
+        StepVerifier.create(flow)
+                .verifyComplete();
+    }
+
     @Test
     void operationsShouldNotBeAbleForDomains() {
         assertThrows(UnsupportedOperationException.class, () -> kafkaDomainEventBus.emit(domain, domainEvent));
         assertThrows(UnsupportedOperationException.class, () -> kafkaDomainEventBus.emit(domain, cloudEvent));
+        assertThrows(UnsupportedOperationException.class, () -> kafkaDomainEventBus.emit(domain, rawMessage));
     }
 }
diff --git a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/converters/json/KafkaJacksonMessageConverterTest.java b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/converters/json/KafkaJacksonMessageConverterTest.java
@@ -42,6 +42,7 @@ void shouldSerializeDomainEvent() {
         String expectedJson = "{\"name\":\"test\",\"eventId\":\"" + id + "\",\"data\":{\"name\":\"name\",\"age\":1}}";
         // Act
         Message message = converter.toMessage(testEvent);
+        assertEquals(message, converter.toMessage(message));
         // Assert
         assertEquals("test", message.getProperties().getTopic());
         assertEquals(id, message.getProperties().getKey());
diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitDomainEventBusTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitDomainEventBusTest.java
@@ -7,6 +7,7 @@
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.reactivecommons.api.domain.DomainEvent;
+import org.reactivecommons.api.domain.RawMessage;
 import org.reactivecommons.async.rabbit.communications.ReactiveMessageSender;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
@@ -24,6 +25,8 @@ class RabbitDomainEventBusTest {
     @Mock
     private CloudEvent cloudEvent;
     @Mock
+    private RawMessage rawMessage;
+    @Mock
     private ReactiveMessageSender sender;
     private RabbitDomainEventBus rabbitDomainEventBus;
     private final String domain = "domain";
@@ -59,9 +62,23 @@ void shouldEmitCloudEvent() {
                 .verifyComplete();
     }
 
+    @Test
+    void shouldEmitRawMessage() {
+        // Arrange
+        when(rawMessage.getType()).thenReturn("event");
+        when(sender.sendWithConfirm(any(RawMessage.class), anyString(), anyString(), any(), anyBoolean()))
+                .thenReturn(Mono.empty());
+        // Act
+        Mono<Void> flow = Mono.from(rabbitDomainEventBus.emit(rawMessage));
+        // Assert
+        StepVerifier.create(flow)
+                .verifyComplete();
+    }
+
     @Test
     void operationsShouldNotBeAbleForDomains() {
         assertThrows(UnsupportedOperationException.class, () -> rabbitDomainEventBus.emit(domain, domainEvent));
         assertThrows(UnsupportedOperationException.class, () -> rabbitDomainEventBus.emit(domain, cloudEvent));
+        assertThrows(UnsupportedOperationException.class, () -> rabbitDomainEventBus.emit(domain, rawMessage));
     }
 }
diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/JacksonMessageConverterTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/JacksonMessageConverterTest.java
@@ -19,6 +19,7 @@
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class JacksonMessageConverterTest {
 
@@ -34,6 +35,7 @@ static void setUp() {
     @Test
     void toMessage() {
         final Message message = converter.toMessage(new SampleClass("42", "Daniel", new Date()));
+        assertEquals(message, converter.toMessage(message));
         assertThat(new String(message.getBody())).contains("42").contains("Daniel");
     }
 
diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListenerTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListenerTest.java
@@ -1,5 +1,7 @@
 package org.reactivecommons.async.rabbit.listeners;
 
+import io.cloudevents.CloudEvent;
+import io.cloudevents.core.builder.CloudEventBuilder;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.junit.jupiter.MockitoExtension;
@@ -8,6 +10,7 @@
 import org.reactivecommons.async.commons.HandlerResolver;
 import reactor.core.publisher.Mono;
 
+import java.net.URI;
 import java.util.Optional;
 import java.util.UUID;
 
@@ -25,6 +28,13 @@ public class ApplicationEventListenerTest extends ListenerReporterTestSuperClass
             "app.event.test2", UUID.randomUUID().toString(), new DummyMessage()
     );
 
+    private final CloudEvent cloudEvent = CloudEventBuilder.v1()
+            .withType("app.event.test")
+            .withId(UUID.randomUUID().toString())
+            .withSource(URI.create("/test"))
+            .withData("application/json", "{}".getBytes())
+            .build();
+
     @Test
     void shouldSendErrorToCustomErrorReporter() throws InterruptedException {
         final HandlerRegistry registry = HandlerRegistry.register()
@@ -34,6 +44,20 @@ void shouldSendErrorToCustomErrorReporter() throws InterruptedException {
         assertSendErrorToCustomReporter(registry, createSource(DomainEvent::getName, event1));
     }
 
+    @Test
+    void shouldResolveCorrectCloudEventHandler() throws InterruptedException {
+        final HandlerRegistry registry = HandlerRegistry.register()
+                .listenCloudEvent("app.event.test", m -> error(new RuntimeException("testEx")));
+        assertSendErrorToCustomReporter(registry, createSource(CloudEvent::getType, cloudEvent));
+    }
+
+    @Test
+    void shouldResolveCorrectRawHandler() throws InterruptedException {
+        final HandlerRegistry registry = HandlerRegistry.register()
+                .listenDomainRawEvent("domain","app.event.test", m -> error(new RuntimeException("testEx")));
+        assertSendErrorToCustomReporter(registry, createSource(CloudEvent::getType, cloudEvent));
+    }
+
     @Test
     void shouldContinueAfterReportError() throws InterruptedException {
         final HandlerRegistry handlerRegistry = HandlerRegistry.register()
@@ -44,7 +68,8 @@ void shouldContinueAfterReportError() throws InterruptedException {
                         m -> Mono.fromRunnable(successSemaphore::release), DummyMessage.class
                 );
 
-        assertContinueAfterSendErrorToCustomReporter(handlerRegistry, createSource(DomainEvent::getName, event1, event2));
+        assertContinueAfterSendErrorToCustomReporter(handlerRegistry, createSource(DomainEvent::getName, event1,
+                event2));
     }
 
     @Override
diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ListenerReporterTestSuperClass.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ListenerReporterTestSuperClass.java
@@ -65,7 +65,7 @@ public abstract class ListenerReporterTestSuperClass {
     protected final CustomReporter errorReporter = mock(CustomReporter.class);
     protected final Semaphore semaphore = new Semaphore(0);
     protected final Semaphore successSemaphore = new Semaphore(0);
-    private final ObjectMapper mapper = new ObjectMapper();
+    private final ObjectMapper mapper = new DefaultObjectMapperSupplier().get();
     private final Receiver receiver = mock(Receiver.class);
     protected final ReactiveMessageListener reactiveMessageListener = new ReactiveMessageListener(
             receiver, topologyCreator
@@ -147,9 +147,15 @@ protected <T> Flux<AcknowledgableDelivery> createSource(Function<T, String> rout
     protected abstract GenericMessageListener createMessageListener(final HandlerResolver handlerResolver);
 
     private HandlerResolver createHandlerResolver(final HandlerRegistry registry) {
-        final Map<String, RegisteredEventListener<?, ?>> eventHandlers = Stream.concat(
-                        registry.getDynamicEventHandlers().stream(),
-                        registry.getDomainEventListeners().get(DEFAULT_DOMAIN).stream())
+        Stream<RegisteredEventListener<?, ?>> listenerStream = Stream.concat(
+                registry.getDynamicEventHandlers().stream(),
+                registry.getDomainEventListeners().get(DEFAULT_DOMAIN).stream());
+        if (registry.getDomainEventListeners().containsKey("domain")) {
+            listenerStream = Stream.concat(
+                    listenerStream,
+                    registry.getDomainEventListeners().get("domain").stream());
+        }
+        final Map<String, RegisteredEventListener<?, ?>> eventHandlers = listenerStream
                 .collect(toMap(RegisteredEventListener::getPath, identity()));
         final Map<String, RegisteredEventListener<?, ?>> eventsToBind = registry.getDomainEventListeners()
                 .get(DEFAULT_DOMAIN).stream().collect(toMap(RegisteredEventListener::getPath, identity()));
diff --git a/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/senders/GenericDomainEventBusTest.java b/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/senders/GenericDomainEventBusTest.java
@@ -8,6 +8,7 @@
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.reactivecommons.api.domain.DomainEvent;
 import org.reactivecommons.api.domain.DomainEventBus;
+import org.reactivecommons.async.commons.communications.Message;
 import org.reactivecommons.async.starter.exceptions.InvalidConfigurationException;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
@@ -28,6 +29,8 @@ class GenericDomainEventBusTest {
     @Mock
     private CloudEvent cloudEvent;
     @Mock
+    private Message rawMessage;
+    @Mock
     private DomainEvent<?> domainEvent;
     private GenericDomainEventBus genericDomainEventBus;
 
@@ -108,4 +111,27 @@ void shouldFailWhenNoDomainFoundWithCloudEvent() {
                 .expectError(InvalidConfigurationException.class)
                 .verify();
     }
+
+    @Test
+    void shouldEmitRawEventWithSpecificDomain() {
+        // Arrange
+        when(domainEventBus2.emit(rawMessage)).thenReturn(Mono.empty());
+        // Act
+        Mono<Void> flow = Mono.from(genericDomainEventBus.emit(DOMAIN_2, rawMessage));
+        // Assert
+        StepVerifier.create(flow)
+                .verifyComplete();
+        verify(domainEventBus2).emit(rawMessage);
+    }
+
+    @Test
+    void shouldFailWhenNoDomainFoundEmittingRawEvent() {
+        // Arrange
+        // Act
+        Mono<Void> flow = Mono.from(genericDomainEventBus.emit("another", rawMessage));
+        // Assert
+        StepVerifier.create(flow)
+                .expectError(InvalidConfigurationException.class)
+                .verify();
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public HandlerRegistry listenDomainCloudEvent(String domain, String eventName, C`
`52`	`52`	`return this;`
`53`	`53`	`}`
`54`	`54`
`55`		`- public HandlerRegistry listenDomainRawEvent(String domain, String eventName, RawEventHandler handler) {`
	`55`	`+ public HandlerRegistry listenDomainRawEvent(String domain, String eventName, RawEventHandler<?> handler) {`
`56`	`56`	`domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>())`
`57`	`57`	`.add(new RegisteredEventListener<>(eventName, handler, RawMessage.class));`
`58`	`58`	`return this;`