diff --git a/lombok.config b/lombok.config
index e955a6b5b3b394bbae6458ecf7ac76f3b1b0f446..89d6230792835a66972d94928d8053e014e4fd16 100644
--- a/lombok.config
+++ b/lombok.config
@@ -28,4 +28,5 @@ lombok.log.log4j.flagUsage = ERROR
lombok.data.flagUsage = ERROR
lombok.nonNull.exceptionType = IllegalArgumentException
lombok.addLombokGeneratedAnnotation = true
-lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Qualifier
\ No newline at end of file
+lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Qualifier
+lombok.copyableAnnotations += net.devh.boot.grpc.client.inject.GrpcClient
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index bb7d3fc760eb515e4fa7e018ed2d18407d981dd6..7ed47721fde52888abd872c85ff7e5349a8cb88e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -43,7 +43,7 @@
<description>OZG-Cloud Processor Manager</description>
<properties>
- <vorgang-manager.version>2.17.0</vorgang-manager.version>
+ <vorgang-manager.version>2.22.0-SNAPSHOT</vorgang-manager.version>
<api-lib.version>0.13.0</api-lib.version>
<tyrus-standalone-client.version>2.2.0</tyrus-standalone-client.version>
<okio.version>3.9.1</okio.version>
diff --git a/src/main/java/de/ozgcloud/processor/command/Command.java b/src/main/java/de/ozgcloud/processor/command/Command.java
new file mode 100644
index 0000000000000000000000000000000000000000..e517c170a8f9006deafe4e91d1afcbfe59d582d5
--- /dev/null
+++ b/src/main/java/de/ozgcloud/processor/command/Command.java
@@ -0,0 +1,15 @@
+package de.ozgcloud.processor.command;
+
+import de.ozgcloud.processor.vorgang.VorgangId;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class Command {
+
+ private String id;
+ private String order;
+
+ private VorgangId vorgangId;
+}
diff --git a/src/main/java/de/ozgcloud/processor/command/CommandMapper.java b/src/main/java/de/ozgcloud/processor/command/CommandMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3084d8109e4c56399ba9a7e3dc899bc19e727d2
--- /dev/null
+++ b/src/main/java/de/ozgcloud/processor/command/CommandMapper.java
@@ -0,0 +1,21 @@
+package de.ozgcloud.processor.command;
+
+import java.util.Objects;
+
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+
+import de.ozgcloud.processor.vorgang.VorgangId;
+import de.ozgcloud.vorgang.grpc.command.GrpcCommand;
+
+@Mapper
+interface CommandMapper {
+
+ @Mapping(target = "order", source = "orderString")
+ Command fromGrpc(GrpcCommand command);
+
+ default VorgangId fromString(String idString) {
+ return Objects.nonNull(idString) ? VorgangId.from(idString) : null;
+ }
+
+}
diff --git a/src/main/java/de/ozgcloud/processor/command/CommandRemoteService.java b/src/main/java/de/ozgcloud/processor/command/CommandRemoteService.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f07dc8574ac8396b2739c9dd0d4e4cc04e3d74e
--- /dev/null
+++ b/src/main/java/de/ozgcloud/processor/command/CommandRemoteService.java
@@ -0,0 +1,27 @@
+package de.ozgcloud.processor.command;
+
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.vorgang.grpc.command.CommandServiceGrpc.CommandServiceBlockingStub;
+import de.ozgcloud.vorgang.grpc.command.GrpcGetCommandRequest;
+import lombok.RequiredArgsConstructor;
+import net.devh.boot.grpc.client.inject.GrpcClient;
+
+@Service
+@RequiredArgsConstructor
+class CommandRemoteService {
+
+ @GrpcClient("command-manager")
+ private final CommandServiceBlockingStub commandServiceStub;
+ private final CommandMapper mapper;
+
+ public Command getCommand(String id) {
+ var grpcCommand = commandServiceStub.getCommand(buildRequest(id));
+
+ return mapper.fromGrpc(grpcCommand);
+ }
+
+ private GrpcGetCommandRequest buildRequest(String id) {
+ return GrpcGetCommandRequest.newBuilder().setId(id).build();
+ }
+}
diff --git a/src/main/java/de/ozgcloud/processor/command/CommandService.java b/src/main/java/de/ozgcloud/processor/command/CommandService.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a3c6c6cf745002ae1057cb7edda846fcf71f90f
--- /dev/null
+++ b/src/main/java/de/ozgcloud/processor/command/CommandService.java
@@ -0,0 +1,16 @@
+package de.ozgcloud.processor.command;
+
+import org.springframework.stereotype.Service;
+
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class CommandService {
+
+ private final CommandRemoteService remoteService;
+
+ public Command getCommand(String id) {
+ return remoteService.getCommand(id);
+ }
+}
diff --git a/src/main/java/de/ozgcloud/processor/event/EventService.java b/src/main/java/de/ozgcloud/processor/event/EventService.java
new file mode 100644
index 0000000000000000000000000000000000000000..b13eb001772af0a636233c7aa613f03351123918
--- /dev/null
+++ b/src/main/java/de/ozgcloud/processor/event/EventService.java
@@ -0,0 +1,26 @@
+package de.ozgcloud.processor.event;
+
+import java.util.Map;
+import java.util.Optional;
+
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.processor.command.Command;
+
+@Service
+public class EventService {
+
+ private static final Map<String, String> STATUS_ORDER_TO_EVENT = Map.of(
+ "VORGANG_ANNEHMEN", "ANGENOMMEN",
+ "VORGANG_VERWERFEN", "VERWORFEN",
+ "VORGANG_ZURUECKHOLEN", "ZURUECKGEHOLT",
+ "VORGANG_BEARBEITEN", "BEARBEITUNG_BEGONNEN",
+ "VORGANG_BESCHEIDEN", "BESCHIEDEN",
+ "VORGANG_ZURUECKSTELLEN", "ZURUECKGESTELLT",
+ "VORGANG_ABSCHLIESSEN", "ABGESCHLOSSEN",
+ "VORGANG_WIEDEREROEFFNEN", "WIEDEREROEFFNET");
+
+ public Optional<String> getEventNameFromOrder(Command command) {
+ return Optional.ofNullable(STATUS_ORDER_TO_EVENT.get(command.getOrder()));
+ }
+}
diff --git a/src/main/java/de/ozgcloud/processor/processor/ProcessorEventListener.java b/src/main/java/de/ozgcloud/processor/processor/ProcessorEventListener.java
index 5f8ac51fe140c015f7592cced1d9e922dfce6fe7..a5e4dd0d7859ca578aacfc8e87b0ac140dd04809 100644
--- a/src/main/java/de/ozgcloud/processor/processor/ProcessorEventListener.java
+++ b/src/main/java/de/ozgcloud/processor/processor/ProcessorEventListener.java
@@ -39,11 +39,15 @@ import de.ozgcloud.command.Command;
import de.ozgcloud.command.CommandCreatedEvent;
import de.ozgcloud.command.CommandFailedEvent;
import de.ozgcloud.command.VorgangCreatedEvent;
+import de.ozgcloud.command.status.StatusChangedEvent;
import de.ozgcloud.processor.ProcessorManagerConfiguration;
+import de.ozgcloud.processor.command.CommandService;
+import de.ozgcloud.processor.event.EventService;
import de.ozgcloud.processor.result.ResultService;
import de.ozgcloud.processor.vorgang.Vorgang;
import de.ozgcloud.processor.vorgang.VorgangId;
import de.ozgcloud.processor.vorgang.VorgangService;
+import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.log4j.Log4j2;
import reactor.core.publisher.Mono;
@@ -54,6 +58,15 @@ import reactor.core.publisher.Mono;
@Log4j2
class ProcessorEventListener {
+ public static final String PROCESS_VORGANG_ORDER = "PROCESS_VORGANG";
+ public static final Predicate<Command> IS_PROCESS_VORGANG_EVENT = command -> command.getOrder().equals(PROCESS_VORGANG_ORDER);
+
+ static final String COMMAND_PROCESSOR_NAMES_KEY = "processorNames";
+
+ private static final String IS_PROCESS_VORGANG = "{T(de.ozgcloud.processor.processor.ProcessorEventListener).IS_PROCESS_VORGANG_EVENT.test(event.getSource())}";
+
+ private static final String EVENT_NAME_CREATED = "VORGANG_CREATED";
+
@Qualifier(ProcessorManagerConfiguration.VORGANG_SERVICE_NAME) // NOSONAR
private final VorgangService service;
@@ -63,47 +76,58 @@ class ProcessorEventListener {
@Qualifier(ProcessorManagerConfiguration.RESULT_SERVICE_NAME) // NOSONAR
private final ResultService resultService;
- private final ApplicationEventPublisher publisher;
-
- static final String PROCESS_VORGANG_ORDER = "PROCESS_VORGANG";
- private static final String IS_PROCESS_VORGANG = "{T(de.ozgcloud.processor.processor.ProcessorEventListener).IS_PROCESS_VORGANG_EVENT.test(event.getSource())}";
- public static final Predicate<Command> IS_PROCESS_VORGANG_EVENT = command -> command.getOrder().equals(PROCESS_VORGANG_ORDER);
+ private final CommandService commandService;
+ private final EventService eventService;
- static final String COMMAND_PROCESSOR_NAMES_KEY = "processorNames";
+ private final ApplicationEventPublisher publisher;
@EventListener
public void triggerNewVorgangProcessors(VorgangCreatedEvent event) {
try {
- var vorgang = getVorgang(event.getSource());
- processorService.processVorgang(vorgang).forEach(processorResultMono -> processorResultMono
- .doOnError(cause -> handleError(cause, event.getSource())).onErrorComplete()
- .map(result -> addVorgangId(result, event.getSource()))
- .subscribe(resultService::processResult));
+ processVorgang(VorgangId.from(event.getSource()), EVENT_NAME_CREATED);
} catch (RuntimeException e) {
- handleError(e, event.getSource());
+ handleError(e, VorgangId.from(event.getSource()));
}
}
+ @EventListener
+ public void onStatusChange(StatusChangedEvent event) {
+ var command = commandService.getCommand(event.getSource());
+ var eventName = eventService.getEventNameFromOrder(command);
+
+ eventName.ifPresent(name -> processVorgang(command.getVorgangId(), name));
+ }
+
+ void processVorgang(@NonNull VorgangId vorgangId, String eventName) {
+ var vorgang = getVorgang(vorgangId);
+
+ processorService.processVorgang(vorgang, eventName)
+ .forEach(processorResultMono -> processorResultMono.doOnError(cause -> handleError(cause, vorgangId))
+ .onErrorComplete()
+ .map(result -> addVorgangId(result, vorgangId))
+ .subscribe(resultService::processResult));
+ }
+
@EventListener(condition = IS_PROCESS_VORGANG)
public void onCommandProcessVorgang(CommandCreatedEvent event) {
try {
- var vorgang = getVorgang(event.getSource().getVorgangId());
+ var vorgang = getVorgang(VorgangId.from(event.getSource().getVorgangId()));
processorService.processVorgang(vorgang, getProcessorNames(event.getSource()))
- .forEach(processorResultMono -> processResult(processorResultMono, event.getSource().getVorgangId()));
+ .forEach(processorResultMono -> processResult(processorResultMono, VorgangId.from(event.getSource().getVorgangId())));
publishCommandProcessedEvent(event.getSource());
} catch (Exception e) {
- handleError(e, event.getSource().getVorgangId());
+ handleError(e, VorgangId.from(event.getSource().getVorgangId()));
publishCommandFailedEvent(e.getCause(), event.getSource().getId());
}
}
- void processResult(Mono<ProcessorResult> processorResultMono, String vorgangId) {
+ void processResult(Mono<ProcessorResult> processorResultMono, VorgangId vorgangId) {
var blockedResult = processorResultMono.map(result -> addVorgangId(result, vorgangId)).block();
resultService.processResult(blockedResult);
}
- private Vorgang getVorgang(String vorgangId) {
- return service.getVorgang(VorgangId.from(vorgangId));
+ private Vorgang getVorgang(VorgangId vorgangId) {
+ return service.getVorgang(vorgangId);
}
@SuppressWarnings("unchecked")
@@ -115,11 +139,11 @@ class ProcessorEventListener {
return (Collection<String>) processorNames;
}
- private ProcessorResult addVorgangId(ProcessorResult result, String vorgangId) {
- return result.toBuilder().vorgangId(VorgangId.from(vorgangId)).build();
+ private ProcessorResult addVorgangId(ProcessorResult result, VorgangId vorgangId) {
+ return result.toBuilder().vorgangId(vorgangId).build();
}
- private void handleError(Throwable cause, String vorgangId) {
+ private void handleError(Throwable cause, VorgangId vorgangId) {
try {
LOG.error("Error on procession Vorgang {} externally", vorgangId, cause);
resultService.processError(cause, vorgangId);
diff --git a/src/main/java/de/ozgcloud/processor/processor/ProcessorProperties.java b/src/main/java/de/ozgcloud/processor/processor/ProcessorProperties.java
index 51fe4ae61b818c4320bf1aa144647dd000795ec8..6ca5dcf5c03b1930dc0c4c9151ed570a26d5106e 100644
--- a/src/main/java/de/ozgcloud/processor/processor/ProcessorProperties.java
+++ b/src/main/java/de/ozgcloud/processor/processor/ProcessorProperties.java
@@ -23,9 +23,11 @@
*/
package de.ozgcloud.processor.processor;
+import java.util.Collections;
import java.util.List;
import java.util.Set;
+import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import org.springframework.boot.context.properties.ConfigurationProperties;
@@ -91,6 +93,11 @@ class ProcessorProperties {
@AllArgsConstructor
static class Form {
+ /** Events to trigger Processor for this Form */
+ @NotEmpty
+ @Builder.Default
+ private Set<String> events = Collections.singleton("VORGANG_CREATED");
+
@NotNull
private String formEngineName;
diff --git a/src/main/java/de/ozgcloud/processor/processor/ProcessorService.java b/src/main/java/de/ozgcloud/processor/processor/ProcessorService.java
index ff4d2230dfaf2883bf85450f2c0ea065ad20e4a6..c318ef6bac7adce1ed5fe0227e2ec039179b887c 100644
--- a/src/main/java/de/ozgcloud/processor/processor/ProcessorService.java
+++ b/src/main/java/de/ozgcloud/processor/processor/ProcessorService.java
@@ -64,18 +64,20 @@ public class ProcessorService {
private final WebClient webClient;
- public Stream<Mono<ProcessorResult>> processVorgang(Vorgang vorgang) {
- return getProcessors(vorgang).map(processor -> callProcessor(processor, vorgang));
+ public Stream<Mono<ProcessorResult>> processVorgang(Vorgang vorgang, String event) {
+ return getProcessors(vorgang, event).map(processor -> callProcessor(processor, vorgang));
}
- Stream<Processor> getProcessors(Vorgang vorgang) {
- return properties.getProcessors().parallelStream().filter(processor -> hasFormEngineNameAndFormIds(processor.getForms(), vorgang));
+ Stream<Processor> getProcessors(Vorgang vorgang, String event) {
+ return properties.getProcessors().parallelStream()
+ .filter(processor -> hasFormEngineNameAndFormIds(processor.getForms(), vorgang, event));
}
- boolean hasFormEngineNameAndFormIds(Collection<Form> forms, Vorgang vorgang) {
+ boolean hasFormEngineNameAndFormIds(Collection<Form> forms, Vorgang vorgang, String event) {
return Optional.ofNullable(forms).orElse(Collections.emptySet()).stream()
.filter(form -> StringUtils.equals(form.getFormEngineName(), vorgang.getFormEngineName()))
- .anyMatch(form -> StringUtils.equals(form.getFormId(), vorgang.getFormId()));
+ .filter(form -> StringUtils.equals(form.getFormId(), vorgang.getFormId()))
+ .anyMatch(form -> form.getEvents().contains(event));
}
public Stream<Mono<ProcessorResult>> processVorgang(Vorgang vorgang, Collection<String> processorNames) {
diff --git a/src/main/java/de/ozgcloud/processor/result/AktennotizFactory.java b/src/main/java/de/ozgcloud/processor/result/AktennotizFactory.java
index 5083d57cb9ac80fc9756e49c37f46fefbc570ce9..6db10a803f40301eb344db18da27fa3ab0f35c92 100644
--- a/src/main/java/de/ozgcloud/processor/result/AktennotizFactory.java
+++ b/src/main/java/de/ozgcloud/processor/result/AktennotizFactory.java
@@ -27,6 +27,7 @@ import org.springframework.stereotype.Component;
import de.ozgcloud.processor.ProcessorManagerConfiguration;
import de.ozgcloud.processor.processor.ProcessorResult;
+import de.ozgcloud.processor.vorgang.VorgangId;
@Component(ProcessorManagerConfiguration.AKTENNOTIZ_FACTORY_NAME) // NOSONAR
public class AktennotizFactory {
@@ -46,15 +47,15 @@ public class AktennotizFactory {
.build();
}
- public Aktennotiz createErrorAktennotiz(String vorgangId, String processorName, String exceptionId) {
+ public Aktennotiz createErrorAktennotiz(VorgangId vorgangId, String processorName, String exceptionId) {
return createErrorAktennotizBuilder(vorgangId)
.text(buildErrorText(processorName, exceptionId))
.build();
}
- public Aktennotiz.AktennotizBuilder createErrorAktennotizBuilder(String vorgangId) {
+ public Aktennotiz.AktennotizBuilder createErrorAktennotizBuilder(VorgangId vorgangId) {
return Aktennotiz.builder()
- .vorgangId(vorgangId)
+ .vorgangId(vorgangId.toString())
.severity(Severity.ERROR)
.headline("Fehler");
}
diff --git a/src/main/java/de/ozgcloud/processor/result/ResultService.java b/src/main/java/de/ozgcloud/processor/result/ResultService.java
index 9fdc0b84b92d294f6b63fd7b597e7aafe942426e..3e041010602c5e74f09832185000a515a4f53a97 100644
--- a/src/main/java/de/ozgcloud/processor/result/ResultService.java
+++ b/src/main/java/de/ozgcloud/processor/result/ResultService.java
@@ -33,6 +33,7 @@ import de.ozgcloud.apilib.alfa.AlfaService;
import de.ozgcloud.apilib.vorgang.OzgCloudVorgangIdMapper;
import de.ozgcloud.processor.ProcessorManagerConfiguration;
import de.ozgcloud.processor.processor.ProcessorResult;
+import de.ozgcloud.processor.vorgang.VorgangId;
import lombok.RequiredArgsConstructor;
@Service(ProcessorManagerConfiguration.RESULT_SERVICE_NAME) // NOSONAR
@@ -51,10 +52,11 @@ public class ResultService {
}
}
- public void processError(Throwable cause, String vorgangId) {
+ public void processError(Throwable cause, VorgangId vorgangId) {
if (cause instanceof ProcessorTechnicalException exception) {
addAktenNotiz(
- aktennotizFactory.createErrorAktennotiz(exception.getVorgangId(), exception.getProcessorName(), exception.getExceptionId()));
+ aktennotizFactory.createErrorAktennotiz(VorgangId.from(exception.getVorgangId()), exception.getProcessorName(),
+ exception.getExceptionId()));
} else {
addAktenNotiz(aktennotizFactory.createErrorAktennotizBuilder(vorgangId)
.text("Es ist eine Fehler bei der Verarbeitung des Vorganges aufgetreten").build());
diff --git a/src/test/java/de/ozgcloud/processor/command/CommandRemoteServiceTest.java b/src/test/java/de/ozgcloud/processor/command/CommandRemoteServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..57c2a3c243e4ccd67ab981b87a5a8d670d345738
--- /dev/null
+++ b/src/test/java/de/ozgcloud/processor/command/CommandRemoteServiceTest.java
@@ -0,0 +1,63 @@
+package de.ozgcloud.processor.command;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+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 de.ozgcloud.apilib.common.command.grpc.GrpcCommandTestFactory;
+import de.ozgcloud.vorgang.grpc.command.CommandServiceGrpc.CommandServiceBlockingStub;
+import de.ozgcloud.vorgang.grpc.command.GrpcGetCommandRequest;
+
+class CommandRemoteServiceTest {
+
+ @InjectMocks
+ private CommandRemoteService service;
+
+ @Mock
+ private CommandServiceBlockingStub stub;
+ @Mock
+ private CommandMapper mapper;
+
+ @Nested
+ class TestGetCommand {
+
+ @Captor
+ private ArgumentCaptor<GrpcGetCommandRequest> requestCaptor;
+
+ @Test
+ void shouldCallStub() {
+ service.getCommand(CommandTestFactory.ID);
+
+ verify(stub).getCommand(requestCaptor.capture());
+ assertThat(requestCaptor.getValue()).extracting(GrpcGetCommandRequest::getId)
+ .isEqualTo(CommandTestFactory.ID);
+ }
+
+ @Test
+ void shouldCallMapper() {
+ var grpcCommand = GrpcCommandTestFactory.create();
+ when(stub.getCommand(any())).thenReturn(grpcCommand);
+
+ service.getCommand(CommandTestFactory.ID);
+
+ verify(mapper).fromGrpc(grpcCommand);
+ }
+
+ @Test
+ void shouldReturnMappingResult() {
+ when(mapper.fromGrpc(any())).thenReturn(CommandTestFactory.create());
+
+ var result = service.getCommand(CommandTestFactory.ID);
+
+ assertThat(result).usingRecursiveComparison().isEqualTo(CommandTestFactory.create());
+ }
+ }
+
+}
diff --git a/src/test/java/de/ozgcloud/processor/command/CommandServiceTest.java b/src/test/java/de/ozgcloud/processor/command/CommandServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..75d3946f01939ee1668f8993922bcdb25dbc3011
--- /dev/null
+++ b/src/test/java/de/ozgcloud/processor/command/CommandServiceTest.java
@@ -0,0 +1,39 @@
+package de.ozgcloud.processor.command;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+class CommandServiceTest {
+
+ @InjectMocks
+ private CommandService service;
+ @Mock
+ private CommandRemoteService remoteService;
+
+ @Nested
+ class TestGetCommand {
+ @Test
+ void shouldCallRemoteService() {
+ service.getCommand(CommandTestFactory.ID);
+
+ verify(remoteService).getCommand(CommandTestFactory.ID);
+ }
+
+ @Test
+ void shouldReturnLoadedCommand() {
+ var expected = CommandTestFactory.create();
+ when(remoteService.getCommand(any())).thenReturn(expected);
+
+ var result = service.getCommand(CommandTestFactory.ID);
+
+ assertThat(result).isSameAs(expected);
+ }
+ }
+
+}
diff --git a/src/test/java/de/ozgcloud/processor/command/CommandTestFactory.java b/src/test/java/de/ozgcloud/processor/command/CommandTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..005dbfe9bdea4ea93086342c8ea81c695d966888
--- /dev/null
+++ b/src/test/java/de/ozgcloud/processor/command/CommandTestFactory.java
@@ -0,0 +1,22 @@
+package de.ozgcloud.processor.command;
+
+import java.util.UUID;
+
+import de.ozgcloud.processor.vorgang.VorgangTestFactory;
+
+public class CommandTestFactory {
+
+ public static final String ID = UUID.randomUUID().toString();
+ public static final String ORDER = "ANNEHMEN";
+
+ public static Command create() {
+ return createBuilder().build();
+ }
+
+ public static Command.CommandBuilder createBuilder() {
+ return Command.builder()
+ .id(ID)
+ .order(ORDER)
+ .vorgangId(VorgangTestFactory.ID);
+ }
+}
diff --git a/src/test/java/de/ozgcloud/processor/event/EventServiceTest.java b/src/test/java/de/ozgcloud/processor/event/EventServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..14d6d2836738543913e23bc83d2e983a8fa5097a
--- /dev/null
+++ b/src/test/java/de/ozgcloud/processor/event/EventServiceTest.java
@@ -0,0 +1,36 @@
+package de.ozgcloud.processor.event;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Spy;
+
+import de.ozgcloud.processor.command.CommandTestFactory;
+
+class EventServiceTest {
+
+ @Spy
+ @InjectMocks
+ private EventService service;
+
+ @Nested
+ class TestGetEventName {
+
+ @Test
+ void shouldReturnEventName() {
+ var result = service.getEventNameFromOrder(CommandTestFactory.createBuilder().order("VORGANG_ANNEHMEN").build());
+
+ assertThat(result).contains("ANGENOMMEN");
+ }
+
+ @Test
+ void shouldReturnEmptyForUnkown() {
+ var result = service.getEventNameFromOrder(CommandTestFactory.createBuilder().order("quatsch").build());
+
+ assertThat(result).isEmpty();
+ }
+ }
+
+}
diff --git a/src/test/java/de/ozgcloud/processor/processor/FormTestFactory.java b/src/test/java/de/ozgcloud/processor/processor/FormTestFactory.java
index f0a943e159c6f4d8d6af893a3fc561b36daf4fc3..0210a3b3d5d6959e783e408978e41d0aae605fa0 100644
--- a/src/test/java/de/ozgcloud/processor/processor/FormTestFactory.java
+++ b/src/test/java/de/ozgcloud/processor/processor/FormTestFactory.java
@@ -23,18 +23,23 @@
*/
package de.ozgcloud.processor.processor;
+import java.util.Collections;
+
import de.ozgcloud.apilib.vorgang.OzgCloudEingangHeaderTestFactory;
import de.ozgcloud.processor.processor.ProcessorProperties.Form;
import de.ozgcloud.processor.processor.ProcessorProperties.Form.FormBuilder;
public class FormTestFactory {
+ public static String EVENT = "VORGANG_CREATED";
+
public static Form create() {
return createBuilder().build();
}
public static FormBuilder createBuilder() {
return Form.builder()
+ .events(Collections.singleton(EVENT))
.formId(OzgCloudEingangHeaderTestFactory.FORM_ID)
.formEngineName(OzgCloudEingangHeaderTestFactory.FORM_ENGINE_NAME);
}
diff --git a/src/test/java/de/ozgcloud/processor/processor/ProcessorEventListenerITCase.java b/src/test/java/de/ozgcloud/processor/processor/ProcessorEventListenerITCase.java
index d59d18de59df0b25e28ae41ae7e8fc65791e5d47..531fd3bb1a1013046e1cb5814d9bdf7eb919065c 100644
--- a/src/test/java/de/ozgcloud/processor/processor/ProcessorEventListenerITCase.java
+++ b/src/test/java/de/ozgcloud/processor/processor/ProcessorEventListenerITCase.java
@@ -30,8 +30,8 @@ import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
import de.ozgcloud.apilib.vorgang.OzgCloudVorgangTestFactory;
import de.ozgcloud.command.CommandCreatedEvent;
@@ -46,11 +46,11 @@ import de.ozgcloud.processor.vorgang.VorgangTestFactory;
@ITCase
class ProcessorEventListenerITCase {
- @MockBean
+ @MockitoBean
private ResultService resultService;
- @MockBean
+ @MockitoBean
private VorgangService service;
- @MockBean
+ @MockitoBean
private ProcessorService processorService;
@Autowired
diff --git a/src/test/java/de/ozgcloud/processor/processor/ProcessorEventListenerTest.java b/src/test/java/de/ozgcloud/processor/processor/ProcessorEventListenerTest.java
index e4e11f1733d0ad91e77be9162fd1f74a15b24bee..29273a7e3b02be522c7674c73f50ff9a5e9d32dc 100644
--- a/src/test/java/de/ozgcloud/processor/processor/ProcessorEventListenerTest.java
+++ b/src/test/java/de/ozgcloud/processor/processor/ProcessorEventListenerTest.java
@@ -32,6 +32,7 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.stream.Stream;
import jakarta.validation.ConstraintViolationException;
@@ -44,6 +45,7 @@ import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
+import org.mockito.Mockito;
import org.mockito.Spy;
import org.springframework.context.ApplicationEventPublisher;
@@ -53,6 +55,9 @@ import de.ozgcloud.command.CommandCreatedEvent;
import de.ozgcloud.command.CommandFailedEvent;
import de.ozgcloud.command.CommandTestFactory;
import de.ozgcloud.command.VorgangCreatedEvent;
+import de.ozgcloud.command.status.StatusChangedEvent;
+import de.ozgcloud.processor.command.CommandService;
+import de.ozgcloud.processor.event.EventService;
import de.ozgcloud.processor.result.ProcessorTechnicalException;
import de.ozgcloud.processor.result.ResultService;
import de.ozgcloud.processor.vorgang.Vorgang;
@@ -65,7 +70,7 @@ class ProcessorEventListenerTest {
@Spy
@InjectMocks
- private ProcessorEventListener vorgangEventListener;
+ private ProcessorEventListener listener;
@Mock
private VorgangService vorgangService;
@@ -76,6 +81,11 @@ class ProcessorEventListenerTest {
@Mock
private ApplicationEventPublisher publisher;
+ @Mock
+ private CommandService commandService;
+ @Mock
+ private EventService eventService;
+
@DisplayName("Trigger new vorgang processor")
@Nested
class TestTriggerNewVorgangProcessor {
@@ -95,28 +105,28 @@ class ProcessorEventListenerTest {
when(vorgangService.getVorgang(any())).thenReturn(vorgang);
var result = ProcessorResultTestFactory.createBuilder().vorgangId(null).build();
- when(processorService.processVorgang(any())).thenReturn(Stream.of(Mono.just(result)));
+ when(processorService.processVorgang(any(), anyString())).thenReturn(Stream.of(Mono.just(result)));
}
@Test
void shouldGetVorgang() {
var expectedVorgangId = VorgangId.from(OzgCloudVorgangTestFactory.ID.toString());
- vorgangEventListener.triggerNewVorgangProcessors(EVENT);
+ listener.triggerNewVorgangProcessors(EVENT);
verify(vorgangService).getVorgang(expectedVorgangId);
}
@Test
void shouldCallProcessVorgang() {
- vorgangEventListener.triggerNewVorgangProcessors(EVENT);
+ listener.triggerNewVorgangProcessors(EVENT);
- verify(processorService).processVorgang(vorgang);
+ verify(processorService).processVorgang(vorgang, "VORGANG_CREATED");
}
@Test
void shouldSetVorgangId() {
- vorgangEventListener.triggerNewVorgangProcessors(EVENT);
+ listener.triggerNewVorgangProcessors(EVENT);
verify(resultService).processResult(resultCaptor.capture());
assertThat(resultCaptor.getValue().getVorgangId()).isEqualTo(VorgangTestFactory.ID);
@@ -125,21 +135,21 @@ class ProcessorEventListenerTest {
@Test
void shouldCallConsumeException() {
when(vorgangService.getVorgang(any())).thenReturn(VorgangTestFactory.create());
- when(processorService.processVorgang(any())).thenReturn(Stream.of(Mono.error(exception)));
+ when(processorService.processVorgang(any(), anyString())).thenReturn(Stream.of(Mono.error(exception)));
- vorgangEventListener.triggerNewVorgangProcessors(EVENT);
+ listener.triggerNewVorgangProcessors(EVENT);
- verify(resultService).processError(exception, VorgangTestFactory.ID.toString());
+ verify(resultService).processError(exception, VorgangTestFactory.ID);
}
@Test
void shouldCallConsumeUnexpectedExceptionType() {
when(vorgangService.getVorgang(any())).thenReturn(VorgangTestFactory.create());
- when(processorService.processVorgang(any())).thenReturn(Stream.of(Mono.error(new Exception())));
+ when(processorService.processVorgang(any(), anyString())).thenReturn(Stream.of(Mono.error(new Exception())));
- vorgangEventListener.triggerNewVorgangProcessors(EVENT);
+ listener.triggerNewVorgangProcessors(EVENT);
- verify(resultService).processError(any(Exception.class), eq(VorgangTestFactory.ID.toString()));
+ verify(resultService).processError(any(Exception.class), eq(VorgangTestFactory.ID));
}
}
@@ -170,35 +180,35 @@ class ProcessorEventListenerTest {
@BeforeEach
void init() {
when(vorgangService.getVorgang(any())).thenReturn(vorgang);
- when(processorService.processVorgang(any(), any())).thenReturn(monoStream);
+ when(processorService.processVorgang(any(), Mockito.<Collection<String>>any())).thenReturn(monoStream);
}
@Test
void shouldGetVorgang() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
verify(vorgangService).getVorgang(VorgangId.from(CommandTestFactory.VORGANG_ID));
}
@Test
void shouldCallService() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
verify(processorService).processVorgang(vorgang, processorNames);
}
@Test
void shouldProcessResult() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
- verify(vorgangEventListener).processResult(any(), eq(CommandTestFactory.VORGANG_ID));
+ verify(listener).processResult(any(), eq(VorgangId.from(CommandTestFactory.VORGANG_ID)));
}
@Test
void shouldPublishCommandProcessedEvent() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
- verify(vorgangEventListener).publishCommandProcessedEvent(event.getSource());
+ verify(listener).publishCommandProcessedEvent(event.getSource());
}
}
@@ -208,16 +218,16 @@ class ProcessorEventListenerTest {
@Test
void shouldReturnSingletonList() {
- var processorNames = vorgangEventListener.getProcessorNames(createCommand("singleName"));
+ var result = listener.getProcessorNames(createCommand("singleName"));
- assertThat(processorNames).isInstanceOf(Collection.class).containsExactly("singleName");
+ assertThat(result).isInstanceOf(Collection.class).containsExactly("singleName");
}
@Test
void shouldReturnList() {
- var processorNames = vorgangEventListener.getProcessorNames(createCommand(List.of("name", "otherName")));
+ var result = listener.getProcessorNames(createCommand(List.of("name", "otherName")));
- assertThat(processorNames).isInstanceOf(Collection.class).containsExactly("name", "otherName");
+ assertThat(result).isInstanceOf(Collection.class).containsExactly("name", "otherName");
}
private Command createCommand(Object processorNames) {
@@ -233,12 +243,12 @@ class ProcessorEventListenerTest {
@BeforeEach
void init() {
- when(processorService.processVorgang(any(), any())).thenReturn(Stream.empty());
+ when(processorService.processVorgang(any(), Mockito.<Collection<String>>any())).thenReturn(Stream.empty());
}
@Test
void shouldPublishEventBeClassOf() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
verify(publisher).publishEvent(commandSuccessEventCaptor.capture());
assertThat(commandSuccessEventCaptor.getValue().getClass()).isEqualTo(VorgangProcessedEvent.class);
@@ -246,7 +256,7 @@ class ProcessorEventListenerTest {
@Test
void shouldPublishEventHasCommanIdAsSource() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
verify(publisher).publishEvent(commandSuccessEventCaptor.capture());
assertThat(commandSuccessEventCaptor.getValue().getSource()).isEqualTo(CommandTestFactory.ID);
@@ -254,7 +264,7 @@ class ProcessorEventListenerTest {
@Test
void shouldPublishEventHasCommand() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
verify(publisher).publishEvent(commandSuccessEventCaptor.capture());
assertThat(commandSuccessEventCaptor.getValue().getCommand()).isEqualTo(command);
@@ -272,23 +282,23 @@ class ProcessorEventListenerTest {
@BeforeEach
void init() {
when(vorgangService.getVorgang(any())).thenReturn(vorgang);
- when(processorService.processVorgang(any(), any())).thenReturn(monoStream);
- doThrow(exception).when(vorgangEventListener).processResult(any(), any());
- doNothing().when(vorgangEventListener).publishCommandFailedEvent(any(), any());
+ when(processorService.processVorgang(any(), Mockito.<Collection<String>>any())).thenReturn(monoStream);
+ doThrow(exception).when(listener).processResult(any(), any());
+ doNothing().when(listener).publishCommandFailedEvent(any(), any());
}
@Test
void shouldProcessError() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
- verify(resultService).processError(any(), eq(CommandTestFactory.VORGANG_ID));
+ verify(resultService).processError(any(), eq(VorgangId.from(CommandTestFactory.VORGANG_ID)));
}
@Test
void shouldPublishEventOnConstraintException() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
- verify(vorgangEventListener).publishCommandFailedEvent(any(), any());
+ verify(listener).publishCommandFailedEvent(any(), any());
}
}
@@ -298,21 +308,21 @@ class ProcessorEventListenerTest {
@BeforeEach
void init() {
- when(processorService.processVorgang(any(), any())).thenReturn(Stream.of(Mono.error(exception)));
+ when(processorService.processVorgang(any(), Mockito.<Collection<String>>any())).thenReturn(Stream.of(Mono.error(exception)));
}
@Test
void shouldProcessError() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
- verify(vorgangEventListener).publishCommandFailedEvent(any(), any());
+ verify(listener).publishCommandFailedEvent(any(), any());
}
@Test
void shouldPublishCommandFailedEvent() {
- vorgangEventListener.onCommandProcessVorgang(event);
+ listener.onCommandProcessVorgang(event);
- verify(resultService).processError(any(), eq(CommandTestFactory.VORGANG_ID));
+ verify(resultService).processError(any(), eq(VorgangId.from(CommandTestFactory.VORGANG_ID)));
}
}
@@ -320,7 +330,7 @@ class ProcessorEventListenerTest {
@Nested
class TestPublishCommandFailedEvent {
- private final static String ERROR_MSG = "ErrorMsg";
+ private static final String ERROR_MSG = "ErrorMsg";
@BeforeEach
void init() {
@@ -329,7 +339,7 @@ class ProcessorEventListenerTest {
@Test
void shouldPublishEventBeClassOf() {
- vorgangEventListener.publishCommandFailedEvent(exception, CommandTestFactory.ID);
+ listener.publishCommandFailedEvent(exception, CommandTestFactory.ID);
verify(publisher).publishEvent(commandFailedEventCaptor.capture());
assertThat(commandFailedEventCaptor.getValue().getClass()).isEqualTo(CommandFailedEvent.class);
@@ -337,7 +347,7 @@ class ProcessorEventListenerTest {
@Test
void shouldPublishEventHasCommanIdAsSource() {
- vorgangEventListener.publishCommandFailedEvent(exception, CommandTestFactory.ID);
+ listener.publishCommandFailedEvent(exception, CommandTestFactory.ID);
verify(publisher).publishEvent(commandFailedEventCaptor.capture());
assertThat(commandFailedEventCaptor.getValue().getSource()).isEqualTo(CommandTestFactory.ID);
@@ -345,11 +355,46 @@ class ProcessorEventListenerTest {
@Test
void shouldPublishEventHasErrorMessage() {
- vorgangEventListener.publishCommandFailedEvent(exception, CommandTestFactory.ID);
+ listener.publishCommandFailedEvent(exception, CommandTestFactory.ID);
verify(publisher).publishEvent(commandFailedEventCaptor.capture());
assertThat(commandFailedEventCaptor.getValue().getErrorMessage()).isEqualTo(ERROR_MSG);
}
}
}
+
+ @Nested
+ class TestOnStatusChange {
+
+ private StatusChangedEvent event = new StatusChangedEvent(CommandTestFactory.create());
+ private de.ozgcloud.processor.command.Command command = de.ozgcloud.processor.command.CommandTestFactory.create();
+ private static final String EVENT_NAME = "EVENT";
+
+ @BeforeEach
+ void init() {
+ when(commandService.getCommand(any())).thenReturn(command);
+ when(eventService.getEventNameFromOrder(any())).thenReturn(Optional.of(EVENT_NAME));
+ }
+
+ @Test
+ void shouldLoadCommand() {
+ listener.onStatusChange(event);
+
+ verify(commandService).getCommand(CommandTestFactory.ID);
+ }
+
+ @Test
+ void shouldGetEventName() {
+ listener.onStatusChange(event);
+
+ verify(eventService).getEventNameFromOrder(command);
+ }
+
+ @Test
+ void shouldProcessVorgang() {
+ listener.onStatusChange(event);
+
+ verify(listener).processVorgang(VorgangTestFactory.ID, EVENT_NAME);
+ }
+ }
}
\ No newline at end of file
diff --git a/src/test/java/de/ozgcloud/processor/processor/ProcessorServiceITCase.java b/src/test/java/de/ozgcloud/processor/processor/ProcessorServiceITCase.java
index c05616259f4ad99759753c1ad796e7f358946027..e1c09dfbcc05c00109d5e096993aecaac0ab3cf4 100644
--- a/src/test/java/de/ozgcloud/processor/processor/ProcessorServiceITCase.java
+++ b/src/test/java/de/ozgcloud/processor/processor/ProcessorServiceITCase.java
@@ -40,9 +40,9 @@ import org.junit.jupiter.params.provider.NullAndEmptySource;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
+import org.springframework.test.context.bean.override.mockito.MockitoSpyBean;
import org.springframework.test.util.ReflectionTestUtils;
import de.ozgcloud.common.test.ITCase;
@@ -62,7 +62,7 @@ class ProcessorServiceITCase {
@Autowired
private ProcessorService service;
- @SpyBean
+ @MockitoSpyBean
private ResultService resultService;
private Processor processor;
@@ -197,7 +197,7 @@ class ProcessorServiceITCase {
MockResponse response = new MockResponse().setResponseCode(HttpStatus.BAD_REQUEST.value());
mockWebServer.enqueue(response);
- var results = service.processVorgang(vorgang);
+ var results = service.processVorgang(vorgang, FormTestFactory.EVENT);
assertThrows(ProcessorTechnicalException.class, () -> results.forEach(Mono::block));
}
@@ -207,7 +207,7 @@ class ProcessorServiceITCase {
MockResponse response = new MockResponse().setResponseCode(HttpStatus.BAD_GATEWAY.value());
mockWebServer.enqueue(response);
- var results = service.processVorgang(vorgang);
+ var results = service.processVorgang(vorgang, FormTestFactory.EVENT);
assertThrows(ProcessorTechnicalException.class, () -> results.forEach(Mono::block));
}
@@ -216,7 +216,7 @@ class ProcessorServiceITCase {
void shouldHandleRedirectStatus() {
mockWebServer.enqueue(new MockResponse().setResponseCode(301));
- var results = service.processVorgang(vorgang);
+ var results = service.processVorgang(vorgang, FormTestFactory.EVENT);
assertThrows(ProcessorTechnicalException.class, () -> results.forEach(Mono::block));
}
@@ -226,7 +226,7 @@ class ProcessorServiceITCase {
MockResponse response = new MockResponse().addHeader("content-type", MediaType.APPLICATION_JSON).setBody("test");
mockWebServer.enqueue(response);
- var results = service.processVorgang(vorgang);
+ var results = service.processVorgang(vorgang, FormTestFactory.EVENT);
assertThrows(ProcessorTechnicalException.class, () -> results.forEach(Mono::block));
}
diff --git a/src/test/java/de/ozgcloud/processor/processor/ProcessorServiceTest.java b/src/test/java/de/ozgcloud/processor/processor/ProcessorServiceTest.java
index c9a87204347c1039119adde275cd3508af8a3d8d..20f759718888aee6f19bd0cae69f23857f4ae30a 100644
--- a/src/test/java/de/ozgcloud/processor/processor/ProcessorServiceTest.java
+++ b/src/test/java/de/ozgcloud/processor/processor/ProcessorServiceTest.java
@@ -72,7 +72,7 @@ class ProcessorServiceTest {
@Test
void shouldReturnProcessor() {
- var processor = service.getProcessors(VorgangTestFactory.create());
+ var processor = service.getProcessors(VorgangTestFactory.create(), FormTestFactory.EVENT);
assertThat(processor).contains(configuredProcessor);
}
@@ -82,7 +82,7 @@ class ProcessorServiceTest {
void shouldReturnEmptyIfNoFormId() {
var vorgang = VorgangTestFactory.createBuilder().formId("other").build();
- var processor = service.getProcessors(vorgang);
+ var processor = service.getProcessors(vorgang, FormTestFactory.EVENT);
assertThat(processor).isEmpty();
}
@@ -92,7 +92,14 @@ class ProcessorServiceTest {
void shouldReturnEmptyIfNoFormEngineName() {
var vorgang = VorgangTestFactory.createBuilder().formEngineName("other").build();
- var processor = service.getProcessors(vorgang);
+ var processor = service.getProcessors(vorgang, FormTestFactory.EVENT);
+
+ assertThat(processor).isEmpty();
+ }
+
+ @Test
+ void shouldReturnEmptyForOtherEvent() {
+ var processor = service.getProcessors(VorgangTestFactory.create(), "other");
assertThat(processor).isEmpty();
}
diff --git a/src/test/java/de/ozgcloud/processor/processor/ProxyPropertiesITCase.java b/src/test/java/de/ozgcloud/processor/processor/ProxyPropertiesITCase.java
index 4a356c22ac0782ce0f7e6b3de8982dac05af1717..52cdb54791551012e1e6dae12e9bb9a8f0417628 100644
--- a/src/test/java/de/ozgcloud/processor/processor/ProxyPropertiesITCase.java
+++ b/src/test/java/de/ozgcloud/processor/processor/ProxyPropertiesITCase.java
@@ -29,7 +29,9 @@ import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+@ActiveProfiles("itcase")
public class ProxyPropertiesITCase {
@Nested
diff --git a/src/test/java/de/ozgcloud/processor/result/AktennotizFactoryTest.java b/src/test/java/de/ozgcloud/processor/result/AktennotizFactoryTest.java
index 1b041a90146dd5a8395369cf5dc132009f37dd26..561ffe55d404bb22dc65c9a1e4ab7c7406d409ef 100644
--- a/src/test/java/de/ozgcloud/processor/result/AktennotizFactoryTest.java
+++ b/src/test/java/de/ozgcloud/processor/result/AktennotizFactoryTest.java
@@ -33,6 +33,7 @@ import org.mockito.Spy;
import de.ozgcloud.processor.processor.ProcessorResult;
import de.ozgcloud.processor.processor.ProcessorResultTestFactory;
+import de.ozgcloud.processor.vorgang.VorgangId;
import de.ozgcloud.processor.vorgang.VorgangTestFactory;
class AktennotizFactoryTest {
@@ -77,7 +78,7 @@ class AktennotizFactoryTest {
@Nested
class TestCreateErrorAktennotiz {
- private static final String VORGANG_ID = VorgangTestFactory.ID.toString();
+ private static final VorgangId VORGANG_ID = VorgangTestFactory.ID;
private static final String PROCESSOR_NAME = "processorName";
diff --git a/src/test/java/de/ozgcloud/processor/result/ResultServiceTest.java b/src/test/java/de/ozgcloud/processor/result/ResultServiceTest.java
index 4597e31aeb93cffb621204c2cdb49ec95f3e5c05..1de5efb5f9e81a6b3a98fa4ec51816f29c739fe2 100644
--- a/src/test/java/de/ozgcloud/processor/result/ResultServiceTest.java
+++ b/src/test/java/de/ozgcloud/processor/result/ResultServiceTest.java
@@ -100,14 +100,14 @@ class ResultServiceTest {
when(exception.getProcessorName()).thenReturn(ProcessorTestFactory.PROCESSOR_NAME);
when(exception.getExceptionId()).thenReturn(EXCEPTION_ID);
- resultService.processError(exception, VorgangTestFactory.ID.toString());
+ resultService.processError(exception, VorgangTestFactory.ID);
- verify(aktennotizFactory).createErrorAktennotiz(VorgangTestFactory.ID.toString(), ProcessorTestFactory.PROCESSOR_NAME, EXCEPTION_ID);
+ verify(aktennotizFactory).createErrorAktennotiz(VorgangTestFactory.ID, ProcessorTestFactory.PROCESSOR_NAME, EXCEPTION_ID);
}
@Test
void shouldCallAddAktenNotiz() {
- resultService.processError(exception, VorgangTestFactory.ID.toString());
+ resultService.processError(exception, VorgangTestFactory.ID);
verify(resultService).addAktenNotiz(aktennotiz);
}
diff --git a/src/test/resources/application-itcase.yml b/src/test/resources/application-itcase.yml
index 4e522a6a1ee94794d05902434e815c204688a8a6..abbc391103440f5116b29485b09f802774c7eeac 100644
--- a/src/test/resources/application-itcase.yml
+++ b/src/test/resources/application-itcase.yml
@@ -21,6 +21,12 @@
# Die sprachspezifischen Genehmigungen und Beschränkungen
# unter der Lizenz sind dem Lizenztext zu entnehmen.
#
+
+logging:
+ level:
+ root: WARN
+ config: classpath:log4j2-local.xml
+
ozgcloud:
processors:
- address: http://test1