OZG-4461 OZG-4513 process vorgang by processorName

src/main/java/de/ozgcloud/processor/processor/ProcessorService.java

@@ -46,6 +46,14 @@ public class ProcessorService {
 				.anyMatch(form -> StringUtils.equals(form.getFormId(), vorgang.getFormId()));
 	}
 	
+	public Stream<Mono<ProcessorResult>> processVorgang(Vorgang vorgang, Collection<String> processorNames) {
+		return getProcessors(processorNames).map(processor -> callProcessor(processor, vorgang));
+	}
+	
+	Stream<Processor> getProcessors(Collection<String> processorNames) {
+		return properties.getProcessors().stream().filter(processor -> processorNames.contains(processor.getName()));
+	}
+
 	Mono<ProcessorResult> callProcessor(Processor processor, Vorgang vorgang) {
 		LOG.info("Sending Vorgang {} to processors.", vorgang.getId());
 		return webClient.post()
@@ -68,9 +76,4 @@ public class ProcessorService {
 	Mono<Throwable> buildRedirectError(ClientResponse clientResponse) {
 		return Mono.error(new TechnicalException("Resource was moved (%s) ".formatted(clientResponse.statusCode())));
 	}
-	
-	public Stream<Mono<ProcessorResult>> processVorgang(Vorgang vorgang, Collection<String> processorName) {
-		//TODO Implement OZG-4513
-		return null;
-	}
 }
\ No newline at end of file

src/test/java/de/ozgcloud/processor/processor/ProcessorServiceITCase.java

@@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.*;
 import static org.junit.jupiter.api.Assertions.*;
 
 import java.time.Duration;
+import java.util.Collections;
 import java.util.concurrent.TimeUnit;
 
 import org.junit.jupiter.api.AfterEach;
@@ -54,10 +55,13 @@ class ProcessorServiceITCase {
 		@BeforeEach
 		void setup() {
 			processor = ProcessorTestFactory.createBuilder().address(mockWebServer.url("/").toString()).build();
-			MockResponse response = new MockResponse()
+			mockWebServer.enqueue(createMockResponse());
+		}
+		
+		private MockResponse createMockResponse() {
+			return new MockResponse()
 					.addHeader("Content-Type", "application/json")
 					.setBody("{\"%s\": \"%s\"}".formatted(ProcessorResultTestFactory.KEY_RESULT_ACTION, ProcessorResultTestFactory.RESULT_ACTION));
-			mockWebServer.enqueue(response);
 		}
 
 		@AfterEach
@@ -203,6 +207,40 @@ class ProcessorServiceITCase {
 
 			assertThrows(ProcessorTechnicalException.class, () -> results.forEach(Mono::block));
 		}
+	}
+	
+	@DisplayName("Process vorgang")
+	@Nested
+	class TestProcessVorgang {
+		
+		private MockWebServer mockWebServer = new MockWebServer();
+		private Vorgang vorgang = VorgangTestFactory.create();
+		private Processor processor = ProcessorTestFactory.createBuilder().address(mockWebServer.url("/").toString()).build();
+		private ProcessorProperties properties = ProcessorProperties.builder().processor(processor).build();
+
+		@BeforeEach
+		void setup() {
+			ReflectionTestUtils.setField(service, "properties", properties);
+		}
 
+		@SneakyThrows
+		@AfterEach
+		void cleanup() {
+			mockWebServer.shutdown();
+		}
+		
+		@Test
+		void shouldReturnProcessor() {
+			var result = service.processVorgang(vorgang, Collections.singleton(ProcessorTestFactory.PROCESSOR_NAME));
+			
+			assertThat(result).isNotEmpty();
+		}
+		
+		@Test
+		void shouldReturnEmptyStream() {
+			var result = service.processVorgang(vorgang, Collections.singleton("notMatchingProcessorName"));
+			
+			assertThat(result).isEmpty();
+		}
 	}
 }
\ No newline at end of file

src/test/java/de/ozgcloud/processor/processor/ProcessorServiceTest.java

 package de.ozgcloud.processor.processor;
 
 import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
 
+import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
+import java.util.stream.Stream;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -14,11 +19,12 @@ import org.mockito.Mockito;
 import org.mockito.Spy;
 
 import de.ozgcloud.processor.processor.ProcessorProperties.Processor;
+import de.ozgcloud.processor.vorgang.Vorgang;
 import de.ozgcloud.processor.vorgang.VorgangTestFactory;
+import reactor.core.publisher.Mono;
 
 class ProcessorServiceTest {
 
-
 	@Spy
 	@InjectMocks
 	private ProcessorService service;
@@ -28,7 +34,6 @@ class ProcessorServiceTest {
 	@Mock
 	private ProcessorConfiguration processorConfiguration;
 
-
 	@Nested
 	class TestProcessVorgang {
 
@@ -71,4 +76,78 @@ class ProcessorServiceTest {
 		}
 	}
 	
+	@DisplayName("Process vorgang by given processorNames")
+	@Nested
+	class TestProcessVorgangByGivenProcessorNames {
+		
+		private final Vorgang vorgang = VorgangTestFactory.create();
+		private final Collection<String> processorNames = Collections.singleton(ProcessorTestFactory.PROCESSOR_NAME);
+		private final Processor processor = ProcessorTestFactory.create();
+		private final Mono<ProcessorResult> processorMonoResponse = Mono.just(ProcessorResultTestFactory.create());
+		
+		@Test
+		void shouldGetProcessorByNames() {
+			doReturn(Stream.of(processor)).when(service).getProcessors(anyCollection());
+			
+			service.processVorgang(vorgang, processorNames);
+			
+			verify(service).getProcessors(processorNames);
+		}
+		
+		@Test
+		void shouldCallProcessor() {
+			doReturn(processorMonoResponse).when(service).callProcessor(any(), any());
+			doReturn(Stream.of(processor)).when(service).getProcessors(anyCollection());
+			
+			service.processVorgang(vorgang, processorNames).toList();
+			
+			verify(service).callProcessor(any(), any());
+		}
+		
+		@Test
+		void shouldReturnProcessorResult() {
+			doReturn(processorMonoResponse).when(service).callProcessor(any(), any());
+			doReturn(Stream.of(processor)).when(service).getProcessors(anyCollection());
+			
+			var result = service.processVorgang(vorgang, processorNames).toList();
+			
+			assertThat(result).containsExactly(processorMonoResponse);
+		}
+		
+		@DisplayName("get processors")
+		@Nested
+		class TestGetProcessors {
+			
+			private final Processor processor = ProcessorTestFactory.create();
+			
+			@Test
+			void shouldGetConfiguredProcessor() {
+				when(properties.getProcessors()).thenReturn(List.of(processor));
+				
+				service.getProcessors(processorNames);
+				
+				verify(properties).getProcessors();
+			}
+			
+			@DisplayName("should return processors matching processor name")
+			@Test
+			void shouldReturnProcessor() {
+				when(properties.getProcessors()).thenReturn(List.of(processor));
+				
+				var processorResult = service.getProcessors(processorNames).toList();
+				
+				assertThat(processorResult).containsExactly(processor);
+			}
+			
+			@DisplayName("should return empty stream on non matching processor name")
+			@Test
+			void shouldReturnEmpty() {
+				when(properties.getProcessors()).thenReturn(List.of(ProcessorTestFactory.createBuilder().name("notMatchin").build()));
+				
+				var processorResult = service.getProcessors(processorNames).toList();
+				
+				assertThat(processorResult).isEmpty();
+			}
+		}
+	}
 }