Ozg 7501 weiterleitung vorbereiten

vorgang-manager-server/src/test/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingEventListenerTest.java

@@ -23,26 +23,43 @@
  */
 package de.ozgcloud.vorgang.vorgang.redirect;
 
+import static org.assertj.core.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.ConcurrentModificationException;
+import java.util.Map;
 
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Spy;
 import org.springframework.context.ApplicationEventPublisher;
 
+import com.thedeanda.lorem.LoremIpsum;
+
 import de.ozgcloud.command.Command;
+import de.ozgcloud.command.CommandCreatedEvent;
 import de.ozgcloud.command.CommandFailedEvent;
+import de.ozgcloud.command.VorgangLockedEvent;
+import de.ozgcloud.common.errorhandling.TechnicalException;
 import de.ozgcloud.nachrichten.email.MailSentEventTestFactory;
 import de.ozgcloud.vorgang.command.CommandCreatedEventTestFactory;
 import de.ozgcloud.vorgang.command.CommandTestFactory;
 import de.ozgcloud.vorgang.command.Order;
+import de.ozgcloud.vorgang.vorgang.Lock;
+import de.ozgcloud.vorgang.vorgang.LockMapper;
+import de.ozgcloud.vorgang.vorgang.LockTestFactory;
+import de.ozgcloud.vorgang.vorgang.VorgangService;
+import de.ozgcloud.vorgang.vorgang.VorgangTestFactory;
 
 class ForwardingEventListenerTest {
 
+	@Spy
 	@InjectMocks // NOSONAR
 	private ForwardingEventListener listener;
 
@@ -50,13 +67,19 @@ class ForwardingEventListenerTest {
 	private ForwardingService forwardingService;
 	@Mock
 	private ApplicationEventPublisher publisher;
+	@Mock
+	private ForwardingRequestMapper forwardingRequestMapper;
+	@Mock
+	private VorgangService vorgangService;
+	@Mock
+	private LockMapper lockMapper;
 
 	@Nested
-	class onForwardOrderCommand {
+	class OnRedirectVorgangCommand {
 
 		@Test
 		void shouldCallService() {
-			listener.onForwardOrder(CommandCreatedEventTestFactory.create());
+			listener.onRedirectVorgangOrder(CommandCreatedEventTestFactory.create());
 
 			verify(forwardingService).forwardByCommand(notNull());
 		}
@@ -65,16 +88,16 @@ class ForwardingEventListenerTest {
 		void shouldPublishFailedEventOnError() {
 			when(forwardingService.forwardByCommand(any())).thenThrow(ConcurrentModificationException.class);
 
-			listener.onForwardOrder(CommandCreatedEventTestFactory.create());
+			listener.onRedirectVorgangOrder(CommandCreatedEventTestFactory.create());
 
 			verify(publisher).publishEvent(any(CommandFailedEvent.class));
 		}
 	}
 
 	@Nested
-	class onMailSentEvent {
+	class OnMailSentEvent {
 
-		private Forwarding forwarding = ForwardingTestFactory.create();
+		private final Forwarding forwarding = ForwardingTestFactory.create();
 
 		@Test
 		void shouldCallRedirectService() {
@@ -85,6 +108,113 @@ class ForwardingEventListenerTest {
 
 	}
 
+	@Nested
+	class TestOnForwardVorgangOrder {
+
+		private final CommandCreatedEvent event = CommandCreatedEventTestFactory.create();
+
+		@Captor
+		private ArgumentCaptor<CommandFailedEvent> failedEventCaptor;
+
+		@Test
+		void shouldHandleForwardVorgangCommand() {
+			doNothing().when(listener).handleForwardVorgangCommand(any());
+
+			onForwardVorgangOrder();
+
+			verify(listener).handleForwardVorgangCommand(event.getSource());
+		}
+
+		@Test
+		void shouldPublishFailedEventOnError() {
+			doThrow(TechnicalException.class).when(listener).handleForwardVorgangCommand(any());
+
+			onForwardVorgangOrder();
+
+			verify(publisher).publishEvent(failedEventCaptor.capture());
+			assertThat(failedEventCaptor.getValue().getSource()).isEqualTo(event.getSource().getId());
+		}
+
+		private void onForwardVorgangOrder() {
+			listener.onForwardVorgangOrder(event);
+		}
+	}
+
+	@Nested
+	class TestHandleForwardVorgangCommand {
+
+		private final Command command = CommandTestFactory.createBuilder().bodyObject(commandBody()).build();
+		private final Lock lock = LockTestFactory.create();
+		@Captor
+		private ArgumentCaptor<Lock> lockCaptor;
+		@Captor
+		private ArgumentCaptor<VorgangLockedEvent> lockedEventCaptor;
+		@Captor
+		private ArgumentCaptor<ForwardingRequest> requestCaptor;
+
+		@BeforeEach
+		void init() {
+			when(forwardingRequestMapper.fromCommand(any())).thenReturn(ForwardingRequestTestFactory.create());
+			when(lockMapper.fromCommand(any())).thenReturn(lock);
+		}
+
+		@Test
+		void shouldMapToLock() {
+			handleForwardVorgangCommand();
+
+			verify(lockMapper).fromCommand(command);
+		}
+
+		@Test
+		void shouldLockVorgang() {
+			handleForwardVorgangCommand();
+
+			verify(vorgangService).lockVorgang(lockCaptor.capture(), eq(VorgangTestFactory.ID), eq(CommandTestFactory.RELATION_VERSION));
+			assertThat(lockCaptor.getValue()).usingRecursiveComparison()
+					.isEqualTo(LockTestFactory.createBuilder().reason("Vorgang was forwarded").build());
+		}
+
+		@Test
+		void shouldMapCommandToForwardingRequest() {
+			handleForwardVorgangCommand();
+
+			verify(forwardingRequestMapper).fromCommand(command);
+		}
+
+		@Test
+		void shouldCallForwardingService() {
+			handleForwardVorgangCommand();
+
+			verify(forwardingService).forward(requestCaptor.capture());
+			assertThat(requestCaptor.getValue()).usingRecursiveComparison().ignoringFields("version")
+					.isEqualTo(ForwardingRequestTestFactory.create());
+		}
+
+		@Test
+		void shouldIncrementVersionInRequest() {
+			handleForwardVorgangCommand();
+
+			verify(forwardingService).forward(requestCaptor.capture());
+			assertThat(requestCaptor.getValue().getVersion()).isEqualTo(VorgangTestFactory.VERSION + 1);
+		}
+
+		@Test
+		void shouldPublishVorgangLockedEvent() {
+			handleForwardVorgangCommand();
+
+			verify(publisher).publishEvent(lockedEventCaptor.capture());
+			assertThat(lockedEventCaptor.getValue().getCommand()).isSameAs(command);
+		}
+
+		private void handleForwardVorgangCommand() {
+			listener.handleForwardVorgangCommand(command);
+		}
+
+		private static Map<String, Object> commandBody() {
+			return Map.of(LoremIpsum.getInstance().getWords(1), LoremIpsum.getInstance().getWords(1));
+		}
+	}
+
 	@Nested
 	class TestMarkAsSuccessfull {