OZG-7573 OZG-7923 Fix tests

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

@@ -46,7 +46,7 @@ class ForwardingRemoteService {
 	private final VorgangService vorgangService;
 	private final ForwardingRequestMapper forwardingRequestMapper;
 	@GrpcClient("forwarder")
-	private final RouteForwardingServiceGrpc.RouteForwardingServiceStub routeForwardingServiceGrpc;
+	private final RouteForwardingServiceGrpc.RouteForwardingServiceStub serviceStub;
 
 	public void forward(ForwardingRequest request) {
 		CompletableFuture<Void> responseFuture = new CompletableFuture<>();
@@ -55,13 +55,14 @@ class ForwardingRemoteService {
 	}
 
 	void routeForwarding(ForwardingRequest request, ForwardingResponseObserver responseObserver) {
-		var requestStreamObserver = routeForwardingServiceGrpc.withInterceptors(new VorgangManagerClientCallContextAttachingInterceptor())
+		var requestStreamObserver = serviceStub.withInterceptors(new VorgangManagerClientCallContextAttachingInterceptor())
 				.routeForwarding(responseObserver);
 		try {
 			sendEingang(request, requestStreamObserver);
 			requestStreamObserver.onCompleted();
 		} catch (Throwable t) {
 			requestStreamObserver.onError(t);
+			throw t;
 		}
 	}
 

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

@@ -23,6 +23,7 @@
  */
 package de.ozgcloud.vorgang.vorgang.redirect;
 
+import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -33,20 +34,39 @@ import org.mockito.Mock;
 import org.mockito.Spy;
 
 import de.ozgcloud.eingang.forwarder.RouteForwardingServiceGrpc;
+import de.ozgcloud.eingang.forwarding.GrpcRouteForwardingRequest;
 import de.ozgcloud.vorgang.callcontext.VorgangManagerClientCallContextAttachingInterceptor;
+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;
 
 class ForwardingRemoteServiceTest {
 
+	@Mock
+	private VorgangService vorgangService;
+	@Mock
+	private ForwardingRemoteService forwardingRemoteService;
 	@Mock
 	private RouteForwardingServiceGrpc.RouteForwardingServiceStub serviceStub;
 	@Spy
 	@InjectMocks
 	private ForwardingRemoteService service;
 
+	@Mock
+	private StreamObserver<GrpcRouteForwardingRequest> requestObserver;
+	private final ForwardingRequest request = ForwardingRequestTestFactory.create();
+
 	@Nested
 	class TestForward {
 
-		private final ForwardingRequest request = ForwardingRequestTestFactory.create();
+	}
+
+	@Nested
+	class TestRouteForwarding {
+
+		@Mock
+		private ForwardingResponseObserver responseObserver;
 
 		@BeforeEach
 		void init() {
@@ -54,10 +74,11 @@ class ForwardingRemoteServiceTest {
 		}
 
 		@Test
-		void shouldAttachClientCallContext() {
+		void shouldAttachClientCallContextToServiceStub() {
 			givenGrpcCallCompletedSuccessfully();
+			doNothing().when(service).sendEingang(any(), any());
 
-			forward();
+			routeForwarding();
 
 			verify(serviceStub).withInterceptors(any(VorgangManagerClientCallContextAttachingInterceptor.class));
 		}
@@ -65,21 +86,91 @@ class ForwardingRemoteServiceTest {
 		@Test
 		void shouldMakeGrpcCallToRouteForwarding() {
 			givenGrpcCallCompletedSuccessfully();
+			doNothing().when(service).sendEingang(any(), any());
+
+			routeForwarding();
+
+			verify(serviceStub).routeForwarding(any(ForwardingResponseObserver.class));
+		}
+
+		@Nested
+		class OnSuccess {
+
+			@BeforeEach
+			void init() {
+				givenGrpcCallCompletedSuccessfully();
+				doNothing().when(service).sendEingang(any(), any());
+			}
+
+			@Test
+			void shouldSendEingang() {
+				routeForwarding();
+
+				verify(service).sendEingang(request, requestObserver);
+			}
+
+			@Test
+			void shouldCallOnCompleted() {
+				routeForwarding();
+
+				verify(requestObserver).onCompleted();
+			}
+		}
+
+		@Nested
+		class OnFailure {
+
+			private final RuntimeException error = new RuntimeException();
+
+			@BeforeEach
+			void init() {
+				givenGrpcCallCompletedSuccessfully();
+				doThrow(error).when(service).sendEingang(any(), any());
+			}
 
-			forward();
+			@Test
+			void shouldCallOnError() {
+				catchThrowableOfType(RuntimeException.class, TestRouteForwarding.this::routeForwarding);
 
-			verify(serviceStub).routeForwarding(any(ForwardingRemoteService.ForwardingResponseObserver.class));
+				verify(requestObserver).onError(error);
+			}
+
+			@Test
+			void shouldThrowError() {
+				assertThatThrownBy(TestRouteForwarding.this::routeForwarding).isSameAs(error);
+			}
 		}
 
 		private void givenGrpcCallCompletedSuccessfully() {
 			when(serviceStub.routeForwarding(any())).thenAnswer(invocation -> {
-				((ForwardingRemoteService.ForwardingResponseObserver) invocation.getArgument(0)).onCompleted();
-				return null;
+				((ForwardingResponseObserver) invocation.getArgument(0)).onCompleted();
+				return requestObserver;
 			});
 		}
 
-		private void forward() {
-			service.forward(request);
+		private void routeForwarding() {
+			service.routeForwarding(request, responseObserver);
+		}
+	}
+
+	@Nested
+	class TestSendEingang {
+
+		@BeforeEach
+		void init() {
+			when(vorgangService.getById(any())).thenReturn(VorgangTestFactory.create());
+			doReturn(GrpcRouteForwardingRequestTestFactory.create()).when(service).buildRouteForwardingRequest(any(), any());
+		}
+
+		@Test
+		void shouldGetVorgangById() {
+			sendEingang();
+
+			verify(vorgangService).getById(VorgangTestFactory.ID);
+		}
+
+		private void sendEingang() {
+			service.sendEingang(request, requestObserver);
 		}
 	}
 }

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

+/*
+ * Copyright (C) 2025 Das Land Schleswig-Holstein vertreten durch den
+ * Ministerpräsidenten des Landes Schleswig-Holstein
+ * Staatskanzlei
+ * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
+ *
+ * Lizenziert unter der EUPL, Version 1.2 oder - sobald
+ * diese von der Europäischen Kommission genehmigt wurden -
+ * Folgeversionen der EUPL ("Lizenz");
+ * Sie dürfen dieses Werk ausschließlich gemäß
+ * dieser Lizenz nutzen.
+ * Eine Kopie der Lizenz finden Sie hier:
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Sofern nicht durch anwendbare Rechtsvorschriften
+ * gefordert oder in schriftlicher Form vereinbart, wird
+ * die unter der Lizenz verbreitete Software "so wie sie
+ * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
+ * ausdrücklich oder stillschweigend - verbreitet.
+ * Die sprachspezifischen Genehmigungen und Beschränkungen
+ * unter der Lizenz sind dem Lizenztext zu entnehmen.
+ */
+package de.ozgcloud.vorgang.vorgang.redirect;
+
+import de.ozgcloud.eingang.forwarding.GrpcRouteForwardingRequest;
+
+class GrpcRouteForwardingRequestTestFactory {
+
+	public static GrpcRouteForwardingRequest create() {
+		return createBuilder().build();
+	}
+
+	public static GrpcRouteForwardingRequest.Builder createBuilder() {
+		return GrpcRouteForwardingRequest.newBuilder();
+	}
+}