OZG-7573 OZG-7923 More tests

vorgang-manager-server/src/main/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingRemoteService.java

@@ -24,7 +24,6 @@
 package de.ozgcloud.vorgang.vorgang.redirect;
 
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
 
 import org.springframework.stereotype.Service;
 
@@ -77,11 +76,11 @@ class ForwardingRemoteService {
 		return GrpcRouteForwardingRequest.newBuilder().setRouteForwarding(routeForwarding).build();
 	}
 
-	private static void waitForCompletion(CompletableFuture<Void> responseFuture) {
+	void waitForCompletion(CompletableFuture<Void> responseFuture) {
 		try {
 			responseFuture.get();
-		} catch (InterruptedException | ExecutionException e) {
-			throw new TechnicalException("Forwarding failed", e);
+		} catch (Throwable t) {
+			throw new TechnicalException("Forwarding failed", t);
 		}
 	}
 

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

@@ -26,13 +26,19 @@ package de.ozgcloud.vorgang.vorgang.redirect;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
+import java.util.concurrent.CompletableFuture;
+
 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 de.ozgcloud.common.errorhandling.TechnicalException;
+import de.ozgcloud.common.test.ReflectionTestUtils;
 import de.ozgcloud.eingang.forwarder.RouteForwardingServiceGrpc;
 import de.ozgcloud.eingang.forwarding.GrpcRouteForwarding;
 import de.ozgcloud.eingang.forwarding.GrpcRouteForwardingRequest;
@@ -44,6 +50,7 @@ import de.ozgcloud.vorgang.vorgang.VorgangService;
 import de.ozgcloud.vorgang.vorgang.VorgangTestFactory;
 import de.ozgcloud.vorgang.vorgang.redirect.ForwardingRemoteService.ForwardingResponseObserver;
 import io.grpc.stub.StreamObserver;
+import lombok.SneakyThrows;
 
 class ForwardingRemoteServiceTest {
 
@@ -66,7 +73,36 @@ class ForwardingRemoteServiceTest {
 	@Nested
 	class TestForward {
 
+		@Captor
+		private ArgumentCaptor<ForwardingResponseObserver> responseObserverCaptor;
+		@Captor
+		private ArgumentCaptor<CompletableFuture<Void>> futureCaptor;
+
+		@BeforeEach
+		void init() {
+			doNothing().when(service).routeForwarding(any(), any());
+			doNothing().when(service).waitForCompletion(any());
+		}
+
+		@Test
+		void shouldRouteForwarding() {
+			forward();
+
+			verify(service).routeForwarding(eq(request), any(ForwardingResponseObserver.class));
+		}
+
+		@Test
+		void shouldWaitForCompletion() {
+			forward();
+
+			verify(service).waitForCompletion(futureCaptor.capture());
+			verify(service).routeForwarding(any(), responseObserverCaptor.capture());
+			assertThat(futureCaptor.getValue()).isSameAs(ReflectionTestUtils.getField(responseObserverCaptor.getValue(), "future", CompletableFuture.class));
+		}
 
+		private void forward() {
+			service.forward(request);
+		}
 	}
 
 	@Nested
@@ -135,6 +171,7 @@ class ForwardingRemoteServiceTest {
 				doThrow(error).when(service).sendEingang(any(), any());
 			}
 
+			@SuppressWarnings("ResultOfMethodCallIgnored")
 			@Test
 			void shouldCallOnError() {
 				catchThrowableOfType(RuntimeException.class, TestRouteForwarding.this::routeForwarding);
@@ -225,4 +262,61 @@ class ForwardingRemoteServiceTest {
 			return service.buildRouteForwardingRequest(request, eingang);
 		}
 	}
+
+	@Nested
+	class TestWaitForCompletion {
+
+		@Mock
+		private CompletableFuture<Void> future;
+
+		@SneakyThrows
+		@Test
+		void shouldGetFromFuture() {
+			waitForCompletion();
+
+			verify(future).get();
+		}
+
+		@SneakyThrows
+		@Test
+		void shouldThrowTechnicalException() {
+			var exception = new RuntimeException();
+			when(future.get()).thenThrow(exception);
+
+			assertThatThrownBy(this::waitForCompletion).isInstanceOf(TechnicalException.class).hasCause(exception);
+		}
+
+		private void waitForCompletion() {
+			service.waitForCompletion(future);
+		}
+	}
+
+	@Nested
+	class ForwardingResponseObserverTest {
+
+		@Mock
+		private CompletableFuture<Void> future;
+		private ForwardingResponseObserver responseObserver;
+
+		@BeforeEach
+		void init() {
+			responseObserver = new ForwardingResponseObserver(future);
+		}
+
+		@Test
+		void shouldCompleteExceptionallyOnError() {
+			var error = new Throwable();
+
+			responseObserver.onError(error);
+
+			verify(future).completeExceptionally(error);
+		}
+
+		@Test
+		void shouldCompleteOnCompleted() {
+			responseObserver.onCompleted();
+
+			verify(future).complete(null);
+		}
+	}
 }