feat(open-multi-domain-api): add unit tests

Author: juancgalvis

async/async-commons-api/src/test/java/org/reactivecommons/async/api/HandlerRegistryTest.java

@@ -12,6 +12,7 @@
 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.RawCommandHandler;
 import org.reactivecommons.async.api.handlers.RawEventHandler;
 import org.reactivecommons.async.api.handlers.registered.RegisteredCommandHandler;
 import org.reactivecommons.async.api.handlers.registered.RegisteredEventListener;
@@ -25,6 +26,7 @@
 class HandlerRegistryTest {
     private final HandlerRegistry registry = HandlerRegistry.register();
     private final String name = "some.event";
+    private final String nameRaw = "some.raw.event";
     private final String domain = "some-domain";
 
 
@@ -60,9 +62,9 @@ void shouldListenDomainCloudEvent() {
     void shouldListenDomainRawEvent() {
         SomeRawEventHandler eventHandler = new SomeRawEventHandler();
 
-        registry.listenDomainRawEvent(domain, name, eventHandler);
+        registry.listenRawEvent(name, eventHandler);
 
-        assertThat(registry.getDomainEventListeners().get(domain))
+        assertThat(registry.getDomainEventListeners().get(DEFAULT_DOMAIN))
                 .anySatisfy(registered -> assertThat(registered)
                         .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass,
                                 RegisteredEventListener::getHandler
@@ -131,6 +133,20 @@ void shouldRegisterNotificationCloudEventListener() {
                 .anySatisfy(listener -> assertThat(listener.getPath()).isEqualTo(name));
     }
 
+    @Test
+    void shouldRegisterNotificationRawEventListener() {
+        SomeRawEventHandler eventHandler = new SomeRawEventHandler();
+
+        registry.listenRawEvent(nameRaw, eventHandler);
+
+        assertThat(registry.getEventNotificationListener().get(DEFAULT_DOMAIN))
+                .anySatisfy(registered -> assertThat(registered)
+                        .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass,
+                                RegisteredEventListener::getHandler
+                        )
+                        .containsExactly(nameRaw, RawMessage.class, eventHandler)).hasSize(1);
+    }
+
     @Test
     @SuppressWarnings("unchecked")
     void listenEvent() {
@@ -201,6 +217,20 @@ void handleCloudEventCommand() {
                         .containsExactly(name, CloudEvent.class, cloudCommandHandler)).hasSize(1);
     }
 
+    @Test
+    void handleRawCommand() {
+        SomeRawCommandEventHandler eventHandler = new SomeRawCommandEventHandler();
+
+        registry.handleRawCommand(nameRaw, eventHandler);
+
+        assertThat(registry.getCommandHandlers().get(DEFAULT_DOMAIN))
+                .anySatisfy(registered -> assertThat(registered)
+                        .extracting(RegisteredCommandHandler::getPath, RegisteredCommandHandler::getInputClass,
+                                RegisteredCommandHandler::getHandler
+                        )
+                        .containsExactly(nameRaw, RawMessage.class, eventHandler)).hasSize(1);
+    }
+
     @Test
     void shouldServerCloudEventQuery() {
         SomeCloudEventQueryHandler queryHandler = new SomeCloudEventQueryHandler();
@@ -306,6 +336,13 @@ public Mono<Void> handle(CloudEvent message) {
         }
     }
 
+    private static class SomeRawCommandEventHandler implements RawCommandHandler<RawMessage> {
+        @Override
+        public Mono<Void> handle(RawMessage message) {
+            return Mono.empty();
+        }
+    }
+
     private static class SomeQueryHandler implements QueryHandler<SomeDataClass, SomeDataClass> {
         @Override
         public Mono<SomeDataClass> handle(SomeDataClass message) {

async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/HandlerResolverTest.java

@@ -59,6 +59,17 @@ void shouldMatchForAWildcardEvent() {
         Assertions.assertThat(eventListener.getPath()).isEqualTo("some.*");
     }
 
+    @Test
+    void shouldThrowError() {
+        // Arrange
+        RegisteredQueryHandler<?, ?> handler = new RegisteredQueryHandler<>("*",
+                (from, message) -> Mono.empty(),
+                String.class);
+        // Act
+        // Assert
+        Assertions.assertThatThrownBy(() -> resolver.addQueryHandler(handler)).isInstanceOf(RuntimeException.class);
+    }
+
     @Test
     void shouldMatchForAnExactEvent() {
         // Act
@@ -67,4 +78,13 @@ void shouldMatchForAnExactEvent() {
         Assertions.assertThat(eventListener.getPath()).isEqualTo("event.name");
     }
 
+    @Test
+    void shouldCheckIfHasListenerTypes() {
+        // Act
+        // Assert
+        Assertions.assertThat(resolver.hasCommandHandlers()).isFalse();
+        Assertions.assertThat(resolver.hasQueryHandlers()).isFalse();
+        Assertions.assertThat(resolver.hasNotificationListeners()).isFalse();
+    }
+
 }