Merge branch 'OZG-7573-forwarding-interface' of...

Merge branch 'OZG-7573-forwarding-interface' of code.schleswig-holstein.de:ozg-cloud/app/vorgang-manager into OZG-7573-forwarding-interface

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

@@ -162,11 +162,11 @@ class ForwardingRemoteService {
 		}
 	}
 
-	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

@@ -52,17 +52,21 @@ import org.mockito.Spy;
 import de.ozgcloud.common.binaryfile.GrpcFileUploadUtils;
 import de.ozgcloud.common.binaryfile.GrpcFileUploadUtils.FileSender;
 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;
 import de.ozgcloud.eingang.forwarding.GrpcRouteForwardingResponse;
 import de.ozgcloud.vorgang.callcontext.VorgangManagerClientCallContextAttachingInterceptor;
 import de.ozgcloud.vorgang.files.FileService;
+import de.ozgcloud.vorgang.vorgang.Eingang;
 import de.ozgcloud.vorgang.vorgang.EingangTestFactory;
 import de.ozgcloud.vorgang.vorgang.IncomingFile;
 import de.ozgcloud.vorgang.vorgang.IncomingFileGroup;
 import de.ozgcloud.vorgang.vorgang.IncomingFileGroupTestFactory;
 import de.ozgcloud.vorgang.vorgang.IncomingFileMapper;
 import de.ozgcloud.vorgang.vorgang.IncomingFileTestFactory;
+import de.ozgcloud.vorgang.vorgang.Vorgang;
 import de.ozgcloud.vorgang.vorgang.VorgangService;
 import de.ozgcloud.vorgang.vorgang.VorgangTestFactory;
 import de.ozgcloud.vorgang.vorgang.redirect.ForwardingRemoteService.ForwardingResponseObserver;
@@ -78,7 +82,7 @@ class ForwardingRemoteServiceTest {
 	@Mock
 	private VorgangService vorgangService;
 	@Mock
-	private ForwardingRemoteService forwardingRemoteService;
+	private ForwardingRequestMapper forwardingRequestMapper;
 	@Mock
 	private RouteForwardingServiceGrpc.RouteForwardingServiceStub serviceStub;
 	@Mock
@@ -89,10 +93,43 @@ class ForwardingRemoteServiceTest {
 	@Mock
 	private StreamObserver<GrpcRouteForwardingRequest> requestObserver;
 	private final ForwardingRequest request = ForwardingRequestTestFactory.create();
+	private final Eingang eingang = EingangTestFactory.create();
+	private final Vorgang vorgang = VorgangTestFactory.createBuilder().clearEingangs().eingang(eingang).build();
 
 	@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
@@ -161,6 +198,7 @@ class ForwardingRemoteServiceTest {
 				doThrow(error).when(service).sendEingang(any(), any());
 			}
 
+			@SuppressWarnings("ResultOfMethodCallIgnored")
 			@Test
 			void shouldCallOnError() {
 				catchThrowableOfType(RuntimeException.class, TestRouteForwarding.this::routeForwarding);
@@ -189,10 +227,12 @@ class ForwardingRemoteServiceTest {
 	@Nested
 	class TestSendEingang {
 
+		private final GrpcRouteForwardingRequest routeForwardingRequest = GrpcRouteForwardingRequestTestFactory.create();
+
 		@BeforeEach
 		void init() {
-			when(vorgangService.getById(any())).thenReturn(VorgangTestFactory.create());
-			doReturn(GrpcRouteForwardingRequestTestFactory.create()).when(service).buildRouteForwardingRequest(any(), any());
+			when(vorgangService.getById(any())).thenReturn(vorgang);
+			doReturn(routeForwardingRequest).when(service).buildRouteForwardingRequest(any(), any());
 			doNothing().when(service).sendAttachments(any(), any());
 		}
 
@@ -203,6 +243,19 @@ class ForwardingRemoteServiceTest {
 			verify(vorgangService).getById(VorgangTestFactory.ID);
 		}
 
+		void shouldBuildRouteForwardingRequest() {
+			sendEingang();
+
+			verify(service).buildRouteForwardingRequest(request, eingang);
+		}
+
+		@Test
+		void shouldSendForwardingRequest() {
+			sendEingang();
+
+			verify(requestObserver).onNext(routeForwardingRequest);
+		}
+
 		@Test
 		void shouldCallSendAttachments() {
 			sendEingang();
@@ -215,6 +268,35 @@ class ForwardingRemoteServiceTest {
 		}
 	}
 
+	@Nested
+	class TestBuildRouteForwardingRequest {
+
+		private final GrpcRouteForwarding routeForwarding = GrpcRouteForwardingTestFactory.create();
+
+		@BeforeEach
+		void init() {
+			when(forwardingRequestMapper.toGrpcRouteForwarding(any(), any())).thenReturn(routeForwarding);
+		}
+
+		@Test
+		void shouldMapToRouteForwarding() {
+			buildRouteForwardingRequest();
+
+			verify(forwardingRequestMapper).toGrpcRouteForwarding(request, eingang);
+		}
+
+		@Test
+		void shouldReturnRouteForwardingRequest() {
+			var builtRequest = buildRouteForwardingRequest();
+
+			assertThat(builtRequest).isEqualTo(GrpcRouteForwardingRequestTestFactory.create());
+		}
+
+		private GrpcRouteForwardingRequest buildRouteForwardingRequest() {
+			return service.buildRouteForwardingRequest(request, eingang);
+		}
+	}
+
 	@Nested
 	class TestSendAttachments {
 
@@ -591,4 +673,61 @@ class ForwardingRemoteServiceTest {
 			service.waitForFinishedFileUpload(fileSender, inputStream);
 		}
 	}
+
+	@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);
+		}
+	}
 }

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

@@ -36,7 +36,8 @@ class GrpcRouteForwardingRequestTestFactory {
 	}
 
 	public static GrpcRouteForwardingRequest.Builder createBuilder() {
-		return GrpcRouteForwardingRequest.newBuilder();
+		return GrpcRouteForwardingRequest.newBuilder()
+				.setRouteForwarding(GrpcRouteForwardingTestFactory.create());
 	}
 
 	public static GrpcRouteForwardingRequest createWithAttachmentMetadata() {