diff --git a/monitor-commons/pom.xml b/monitor-commons/pom.xml index 7f7cbb18..89263854 100644 --- a/monitor-commons/pom.xml +++ b/monitor-commons/pom.xml @@ -33,5 +33,15 @@ 2.2.22 provided + + org.junit.jupiter + junit-jupiter-params + test + + + org.assertj + assertj-core + test + diff --git a/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/LoadFlowConfig.java b/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/LoadFlowConfig.java index 1e0abee4..051b7d31 100644 --- a/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/LoadFlowConfig.java +++ b/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/LoadFlowConfig.java @@ -10,6 +10,7 @@ import org.gridsuite.monitor.commons.types.processexecution.ProcessType; import java.util.List; +import java.util.Objects; import java.util.UUID; /** @@ -25,4 +26,17 @@ public record LoadFlowConfig( public ProcessType processType() { return ProcessType.LOADFLOW; } + + @Override + public List compareWith(ProcessConfig other) { + LoadFlowConfig o = (LoadFlowConfig) other; + return List.of( + new ProcessConfigFieldComparison("modifications", + Objects.equals(this.modificationUuids, o.modificationUuids), + this.modificationUuids, o.modificationUuids), + new ProcessConfigFieldComparison("loadflowParameters", + Objects.equals(this.loadflowParametersUuid, o.loadflowParametersUuid), + this.loadflowParametersUuid, o.loadflowParametersUuid) + ); + } } diff --git a/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/ProcessConfig.java b/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/ProcessConfig.java index 98de853d..fbaec07a 100644 --- a/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/ProcessConfig.java +++ b/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/ProcessConfig.java @@ -29,4 +29,6 @@ public interface ProcessConfig { ProcessType processType(); List modificationUuids(); + + List compareWith(ProcessConfig other); } diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/processconfig/ProcessConfigFieldComparison.java b/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/ProcessConfigFieldComparison.java similarity index 90% rename from monitor-server/src/main/java/org/gridsuite/monitor/server/dto/processconfig/ProcessConfigFieldComparison.java rename to monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/ProcessConfigFieldComparison.java index 71fd2310..1983fdc6 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/processconfig/ProcessConfigFieldComparison.java +++ b/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/ProcessConfigFieldComparison.java @@ -1,10 +1,10 @@ -/** +/* * Copyright (c) 2026, RTE (http://www.rte-france.com) * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -package org.gridsuite.monitor.server.dto.processconfig; +package org.gridsuite.monitor.commons.types.processconfig; import io.swagger.v3.oas.annotations.media.Schema; diff --git a/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/SecurityAnalysisConfig.java b/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/SecurityAnalysisConfig.java index 2cd1611d..7e29a823 100644 --- a/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/SecurityAnalysisConfig.java +++ b/monitor-commons/src/main/java/org/gridsuite/monitor/commons/types/processconfig/SecurityAnalysisConfig.java @@ -10,6 +10,7 @@ import org.gridsuite.monitor.commons.types.processexecution.ProcessType; import java.util.List; +import java.util.Objects; import java.util.UUID; /** @@ -27,4 +28,20 @@ public record SecurityAnalysisConfig( public ProcessType processType() { return ProcessType.SECURITY_ANALYSIS; } + + @Override + public List compareWith(ProcessConfig other) { + SecurityAnalysisConfig o = (SecurityAnalysisConfig) other; + return List.of( + new ProcessConfigFieldComparison("modifications", + Objects.equals(this.modificationUuids, o.modificationUuids), + this.modificationUuids, o.modificationUuids), + new ProcessConfigFieldComparison("securityAnalysisParameters", + Objects.equals(this.securityAnalysisParametersUuid, o.securityAnalysisParametersUuid), + this.securityAnalysisParametersUuid, o.securityAnalysisParametersUuid), + new ProcessConfigFieldComparison("loadflowParameters", + Objects.equals(this.loadflowParametersUuid, o.loadflowParametersUuid), + this.loadflowParametersUuid, o.loadflowParametersUuid) + ); + } } diff --git a/monitor-commons/src/test/java/org/gridsuite/monitor/commons/types/processconfig/LoadFlowConfigTest.java b/monitor-commons/src/test/java/org/gridsuite/monitor/commons/types/processconfig/LoadFlowConfigTest.java new file mode 100644 index 00000000..bf77914a --- /dev/null +++ b/monitor-commons/src/test/java/org/gridsuite/monitor/commons/types/processconfig/LoadFlowConfigTest.java @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.commons.types.processconfig; + +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +/** + * @author Caroline Jeandat {@literal } + */ +class LoadFlowConfigTest { + @Test + void compareWithShouldReturnNoDifferenceWhenConfigsAreEqual() { + LoadFlowConfig processConfig = new LoadFlowConfig(UUID.randomUUID(), List.of(UUID.randomUUID())); + + List result = processConfig.compareWith(processConfig); + + assertThat(result) + .hasSize(2) + .allMatch(ProcessConfigFieldComparison::identical) + .allMatch(fieldComparison -> fieldComparison.value1().equals(fieldComparison.value2())); + } + + @Test + void compareWithShouldReturnDifferentModificationsWhenModificationsAreDifferent() { + UUID loadflowParametersUuid = UUID.randomUUID(); + List modificationUuids1 = List.of(UUID.randomUUID(), UUID.randomUUID()); + List modificationUuids2 = List.of(UUID.randomUUID(), UUID.randomUUID()); + + LoadFlowConfig processConfig1 = new LoadFlowConfig(loadflowParametersUuid, modificationUuids1); + LoadFlowConfig processConfig2 = new LoadFlowConfig(loadflowParametersUuid, modificationUuids2); + + List result = processConfig1.compareWith(processConfig2); + + assertThat(result).hasSize(2); + ProcessConfigFieldComparison comparison = result.stream() + .filter(d -> "modifications".equals(d.field())) + .findFirst() + .orElseThrow(); + assertThat(comparison.identical()).isFalse(); + assertThat(comparison.value1()).isEqualTo(modificationUuids1); + assertThat(comparison.value2()).isEqualTo(modificationUuids2); + } + + @Test + void compareWithShouldDetectOrderDifferenceInModifications() { + UUID loadflowParametersUuid = UUID.randomUUID(); + UUID mod1 = UUID.randomUUID(); + UUID mod2 = UUID.randomUUID(); + List modificationUuids1 = List.of(mod1, mod2); + List modificationUuids2 = List.of(mod2, mod1); // Different order + + LoadFlowConfig processConfig1 = new LoadFlowConfig(loadflowParametersUuid, modificationUuids1); + LoadFlowConfig processConfig2 = new LoadFlowConfig(loadflowParametersUuid, modificationUuids2); + + List result = processConfig1.compareWith(processConfig2); + + assertThat(result).hasSize(2); + ProcessConfigFieldComparison comparison = result.stream() + .filter(d -> "modifications".equals(d.field())) + .findFirst() + .orElseThrow(); + assertThat(comparison.identical()).isFalse(); + assertThat(comparison.value1()).isEqualTo(modificationUuids1); + assertThat(comparison.value2()).isEqualTo(modificationUuids2); + } + + @Test + void compareWithShouldReturnDifferencesWhenParametersAreDifferent() { + UUID loadflowParametersUuid1 = UUID.randomUUID(); + UUID loadflowParametersUuid2 = UUID.randomUUID(); + List modificationUuids = List.of(UUID.randomUUID(), UUID.randomUUID()); + + LoadFlowConfig processConfig1 = new LoadFlowConfig(loadflowParametersUuid1, modificationUuids); + LoadFlowConfig processConfig2 = new LoadFlowConfig(loadflowParametersUuid2, modificationUuids); + + List result = processConfig1.compareWith(processConfig2); + + assertThat(result).hasSize(2); + ProcessConfigFieldComparison comparison = result.stream() + .filter(d -> "loadflowParameters".equals(d.field())) + .findFirst() + .orElseThrow(); + assertThat(comparison.identical()).isFalse(); + assertThat(comparison.value1()).isEqualTo(loadflowParametersUuid1); + assertThat(comparison.value2()).isEqualTo(loadflowParametersUuid2); + } + + @Test + void compareWithShouldThrowWhenProcessTypesAreDifferent() { + LoadFlowConfig loadFlowConfig = new LoadFlowConfig(UUID.randomUUID(), List.of(UUID.randomUUID())); + SecurityAnalysisConfig securityAnalysisConfig = new SecurityAnalysisConfig(UUID.randomUUID(), List.of(UUID.randomUUID()), UUID.randomUUID()); + + assertThatThrownBy(() -> loadFlowConfig.compareWith(securityAnalysisConfig)).isInstanceOf(ClassCastException.class); + } +} diff --git a/monitor-commons/src/test/java/org/gridsuite/monitor/commons/types/processconfig/SecurityAnalysisConfigTest.java b/monitor-commons/src/test/java/org/gridsuite/monitor/commons/types/processconfig/SecurityAnalysisConfigTest.java new file mode 100644 index 00000000..8513da39 --- /dev/null +++ b/monitor-commons/src/test/java/org/gridsuite/monitor/commons/types/processconfig/SecurityAnalysisConfigTest.java @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.commons.types.processconfig; + +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +/** + * @author Caroline Jeandat {@literal } + */ +class SecurityAnalysisConfigTest { + @Test + void compareWithShouldReturnNoDifferenceWhenConfigsAreEqual() { + SecurityAnalysisConfig securityAnalysisConfig = new SecurityAnalysisConfig(UUID.randomUUID(), List.of(UUID.randomUUID()), UUID.randomUUID()); + + List result = securityAnalysisConfig.compareWith(securityAnalysisConfig); + + assertThat(result) + .hasSize(3) + .allMatch(ProcessConfigFieldComparison::identical) + .allMatch(fieldComparison -> fieldComparison.value1().equals(fieldComparison.value2())); + } + + @Test + void compareWithShouldReturnDifferentModificationsWhenModificationsAreDifferent() { + UUID securityAnalysisParametersUuid = UUID.randomUUID(); + List modificationUuids1 = List.of(UUID.randomUUID(), UUID.randomUUID()); + List modificationUuids2 = List.of(UUID.randomUUID(), UUID.randomUUID()); + UUID loadflowParametersUuid = UUID.randomUUID(); + + SecurityAnalysisConfig processConfig1 = new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids1, loadflowParametersUuid); + SecurityAnalysisConfig processConfig2 = new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids2, loadflowParametersUuid); + + List result = processConfig1.compareWith(processConfig2); + + assertThat(result).hasSize(3); + ProcessConfigFieldComparison comparison = result.stream() + .filter(d -> "modifications".equals(d.field())) + .findFirst() + .orElseThrow(); + assertThat(comparison.identical()).isFalse(); + assertThat(comparison.value1()).isEqualTo(modificationUuids1); + assertThat(comparison.value2()).isEqualTo(modificationUuids2); + } + + @Test + void compareWithShouldDetectOrderDifferenceInModifications() { + UUID securityAnalysisParametersUuid = UUID.randomUUID(); + UUID mod1 = UUID.randomUUID(); + UUID mod2 = UUID.randomUUID(); + List modificationUuids1 = List.of(mod1, mod2); + List modificationUuids2 = List.of(mod2, mod1); // Different order + UUID loadflowParametersUuid = UUID.randomUUID(); + + SecurityAnalysisConfig processConfig1 = new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids1, loadflowParametersUuid); + SecurityAnalysisConfig processConfig2 = new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids2, loadflowParametersUuid); + + List result = processConfig1.compareWith(processConfig2); + + assertThat(result).hasSize(3); + ProcessConfigFieldComparison comparison = result.stream() + .filter(d -> "modifications".equals(d.field())) + .findFirst() + .orElseThrow(); + assertThat(comparison.identical()).isFalse(); + assertThat(comparison.value1()).isEqualTo(modificationUuids1); + assertThat(comparison.value2()).isEqualTo(modificationUuids2); + } + + @Test + void compareWithShouldReturnDifferencesWhenSecurityAnalysisParametersAreDifferent() { + UUID securityAnalysisParametersUuid1 = UUID.randomUUID(); + UUID securityAnalysisParametersUuid2 = UUID.randomUUID(); + List modificationUuids = List.of(UUID.randomUUID(), UUID.randomUUID()); + UUID loadflowParametersUuid = UUID.randomUUID(); + + SecurityAnalysisConfig processConfig1 = new SecurityAnalysisConfig(securityAnalysisParametersUuid1, modificationUuids, loadflowParametersUuid); + SecurityAnalysisConfig processConfig2 = new SecurityAnalysisConfig(securityAnalysisParametersUuid2, modificationUuids, loadflowParametersUuid); + + List result = processConfig1.compareWith(processConfig2); + + assertThat(result).hasSize(3); + ProcessConfigFieldComparison comparison = result.stream() + .filter(d -> "securityAnalysisParameters".equals(d.field())) + .findFirst() + .orElseThrow(); + assertThat(comparison.identical()).isFalse(); + assertThat(comparison.value1()).isEqualTo(securityAnalysisParametersUuid1); + assertThat(comparison.value2()).isEqualTo(securityAnalysisParametersUuid2); + } + + @Test + void compareWithShouldReturnDifferencesWhenLoadflowParametersAreDifferent() { + UUID securityAnalysisParametersUuid = UUID.randomUUID(); + List modificationUuids = List.of(UUID.randomUUID(), UUID.randomUUID()); + UUID loadflowParametersUuid1 = UUID.randomUUID(); + UUID loadflowParametersUuid2 = UUID.randomUUID(); + + SecurityAnalysisConfig processConfig1 = new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids, loadflowParametersUuid1); + SecurityAnalysisConfig processConfig2 = new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids, loadflowParametersUuid2); + + List result = processConfig1.compareWith(processConfig2); + + assertThat(result).hasSize(3); + ProcessConfigFieldComparison comparison = result.stream() + .filter(d -> "loadflowParameters".equals(d.field())) + .findFirst() + .orElseThrow(); + assertThat(comparison.identical()).isFalse(); + assertThat(comparison.value1()).isEqualTo(loadflowParametersUuid1); + assertThat(comparison.value2()).isEqualTo(loadflowParametersUuid2); + } + + @Test + void compareWithShouldThrowWhenProcessTypesAreDifferent() { + SecurityAnalysisConfig securityAnalysisConfig = new SecurityAnalysisConfig(UUID.randomUUID(), List.of(UUID.randomUUID()), UUID.randomUUID()); + LoadFlowConfig loadFlowConfig = new LoadFlowConfig(UUID.randomUUID(), List.of(UUID.randomUUID())); + + assertThatThrownBy(() -> securityAnalysisConfig.compareWith(loadFlowConfig)).isInstanceOf(ClassCastException.class); + } +} diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/controllers/ProcessConfigController.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/controllers/ProcessConfigController.java index e54f660a..52a3e020 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/controllers/ProcessConfigController.java +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/controllers/ProcessConfigController.java @@ -134,7 +134,11 @@ public ResponseEntity compareProcessConfigs( @Parameter(description = "First process config UUID") @RequestParam("uuid1") UUID uuid1, @Parameter(description = "Second process config UUID") @RequestParam("uuid2") UUID uuid2) { - Optional comparison = processConfigService.compareProcessConfigs(uuid1, uuid2); - return comparison.map(c -> ResponseEntity.status(HttpStatus.OK).body(c)).orElseGet(() -> ResponseEntity.status(HttpStatus.NOT_FOUND).build()); + try { + Optional comparison = processConfigService.compareProcessConfigs(uuid1, uuid2); + return comparison.map(c -> ResponseEntity.status(HttpStatus.OK).body(c)).orElseGet(() -> ResponseEntity.status(HttpStatus.NOT_FOUND).build()); + } catch (ClassCastException e) { + return ResponseEntity.status(HttpStatus.BAD_REQUEST).build(); + } } } diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/processconfig/ProcessConfigComparison.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/processconfig/ProcessConfigComparison.java index 0b7fd42b..cf1a657a 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/processconfig/ProcessConfigComparison.java +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/processconfig/ProcessConfigComparison.java @@ -7,6 +7,7 @@ package org.gridsuite.monitor.server.dto.processconfig; import io.swagger.v3.oas.annotations.media.Schema; +import org.gridsuite.monitor.commons.types.processconfig.ProcessConfigFieldComparison; import java.util.List; import java.util.UUID; diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/error/MonitorServerBusinessErrorCode.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/error/MonitorServerBusinessErrorCode.java index 4315e801..db96aa3a 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/error/MonitorServerBusinessErrorCode.java +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/error/MonitorServerBusinessErrorCode.java @@ -1,4 +1,4 @@ -/** +/* * Copyright (c) 2026, RTE (http://www.rte-france.com) * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/error/MonitorServerException.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/error/MonitorServerException.java index af755729..8deaf6dd 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/error/MonitorServerException.java +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/error/MonitorServerException.java @@ -1,4 +1,4 @@ -/** +/* * Copyright (c) 2026, RTE (http://www.rte-france.com) * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/LoadFlowConfigMapper.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/LoadFlowConfigMapper.java index cc55dfac..d8991e0c 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/LoadFlowConfigMapper.java +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/LoadFlowConfigMapper.java @@ -16,7 +16,7 @@ * @author Franck Lecuyer */ @Mapper(componentModel = "spring") -public interface LoadFlowConfigMapper { +public interface LoadFlowConfigMapper extends ProcessConfigMapper { @Mapping(target = "processType", expression = "java(dto.processType())") LoadFlowConfigEntity toEntity(LoadFlowConfig dto); diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/ProcessConfigMapper.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/ProcessConfigMapper.java new file mode 100644 index 00000000..5dba8722 --- /dev/null +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/ProcessConfigMapper.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.server.mappers.processconfig; + +import org.gridsuite.monitor.commons.types.processconfig.ProcessConfig; +import org.gridsuite.monitor.server.entities.processconfig.ProcessConfigEntity; + +/** + * @author Caroline Jeandat {@literal } + */ +public interface ProcessConfigMapper { + E toEntity(C dto); + + C toDto(E entity); + + void updateEntityFromDto(C dto, E entity); +} diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/SecurityAnalysisConfigMapper.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/SecurityAnalysisConfigMapper.java index c24c976b..d4818af8 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/SecurityAnalysisConfigMapper.java +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/mappers/processconfig/SecurityAnalysisConfigMapper.java @@ -16,7 +16,7 @@ * @author Radouane Khouadri */ @Mapper(componentModel = "spring") -public interface SecurityAnalysisConfigMapper { +public interface SecurityAnalysisConfigMapper extends ProcessConfigMapper { @Mapping(target = "processType", expression = "java(dto.processType())") SecurityAnalysisConfigEntity toEntity(SecurityAnalysisConfig dto); diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/AbstractProcessConfigHandler.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/AbstractProcessConfigHandler.java new file mode 100644 index 00000000..e35824dd --- /dev/null +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/AbstractProcessConfigHandler.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.server.services.processconfig; + +import org.gridsuite.monitor.commons.types.processconfig.ProcessConfig; +import org.gridsuite.monitor.server.entities.processconfig.ProcessConfigEntity; +import org.gridsuite.monitor.server.mappers.processconfig.ProcessConfigMapper; + +/** + * @author Caroline Jeandat {@literal } + */ +public abstract class AbstractProcessConfigHandler> + implements ProcessConfigHandler { + + protected final M mapper; + + protected AbstractProcessConfigHandler(M mapper) { + this.mapper = mapper; + } + + @Override + public void update(C processConfig, E entity) { + mapper.updateEntityFromDto(processConfig, entity); + } + + @Override + public E copyEntity(E sourceEntity) { + return toEntity(toDto(sourceEntity)); + } + + @Override + public E toEntity(C processConfig) { + return mapper.toEntity(processConfig); + } + + @Override + public C toDto(E entity) { + return mapper.toDto(entity); + } +} diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/LoadFlowConfigHandler.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/LoadFlowConfigHandler.java new file mode 100644 index 00000000..429730c7 --- /dev/null +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/LoadFlowConfigHandler.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.server.services.processconfig; + +import org.gridsuite.monitor.commons.types.processconfig.LoadFlowConfig; +import org.gridsuite.monitor.commons.types.processexecution.ProcessType; +import org.gridsuite.monitor.server.entities.processconfig.LoadFlowConfigEntity; +import org.gridsuite.monitor.server.mappers.processconfig.LoadFlowConfigMapper; +import org.springframework.stereotype.Service; + +/** + * @author Caroline Jeandat {@literal } + */ +@Service +public class LoadFlowConfigHandler extends AbstractProcessConfigHandler { + + public LoadFlowConfigHandler(LoadFlowConfigMapper mapper) { + super(mapper); + } + + @Override + public ProcessType getProcessType() { + return ProcessType.LOADFLOW; + } +} diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigHandler.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigHandler.java new file mode 100644 index 00000000..f80bfd6e --- /dev/null +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigHandler.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.server.services.processconfig; + +import org.gridsuite.monitor.commons.types.processconfig.ProcessConfig; +import org.gridsuite.monitor.commons.types.processexecution.ProcessType; +import org.gridsuite.monitor.server.entities.processconfig.ProcessConfigEntity; + +/** + * @author Caroline Jeandat {@literal } + */ +public interface ProcessConfigHandler { + + ProcessType getProcessType(); + + void update(C processConfig, E entity); + + E copyEntity(E sourceEntity); + + E toEntity(C processConfig); + + C toDto(E entity); +} diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigService.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigService.java index eeb02ab5..fe8bdafc 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigService.java +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigService.java @@ -6,25 +6,21 @@ */ package org.gridsuite.monitor.server.services.processconfig; -import org.gridsuite.monitor.commons.types.processconfig.LoadFlowConfig; import org.gridsuite.monitor.commons.types.processconfig.ProcessConfig; -import org.gridsuite.monitor.commons.types.processconfig.SecurityAnalysisConfig; import org.gridsuite.monitor.commons.types.processexecution.ProcessType; import org.gridsuite.monitor.server.dto.processconfig.MetadataInfos; import org.gridsuite.monitor.server.dto.processconfig.ProcessConfigComparison; -import org.gridsuite.monitor.server.dto.processconfig.ProcessConfigFieldComparison; +import org.gridsuite.monitor.commons.types.processconfig.ProcessConfigFieldComparison; import org.gridsuite.monitor.server.dto.processconfig.PersistedProcessConfig; -import org.gridsuite.monitor.server.entities.processconfig.LoadFlowConfigEntity; import org.gridsuite.monitor.server.entities.processconfig.ProcessConfigEntity; -import org.gridsuite.monitor.server.entities.processconfig.SecurityAnalysisConfigEntity; import org.gridsuite.monitor.server.error.MonitorServerException; -import org.gridsuite.monitor.server.mappers.processconfig.LoadFlowConfigMapper; -import org.gridsuite.monitor.server.mappers.processconfig.SecurityAnalysisConfigMapper; import org.gridsuite.monitor.server.repositories.ProcessConfigRepository; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; import static org.gridsuite.monitor.server.error.MonitorServerBusinessErrorCode.DIFFERENT_PROCESS_CONFIG_TYPE; @@ -34,37 +30,44 @@ @Service public class ProcessConfigService { private final ProcessConfigRepository processConfigRepository; - private final SecurityAnalysisConfigMapper securityAnalysisConfigMapper; - private final LoadFlowConfigMapper loadFlowConfigMapper; + private final Map> processConfigHandlers; public ProcessConfigService(ProcessConfigRepository processConfigRepository, - SecurityAnalysisConfigMapper securityAnalysisConfigMapper, - LoadFlowConfigMapper loadFlowConfigMapper) { + List> listHandlers) { this.processConfigRepository = processConfigRepository; - this.securityAnalysisConfigMapper = securityAnalysisConfigMapper; - this.loadFlowConfigMapper = loadFlowConfigMapper; + this.processConfigHandlers = listHandlers.stream().collect(Collectors.toMap( + ProcessConfigHandler::getProcessType, Function.identity(), (h1, h2) -> { + throw new IllegalStateException(String.format("Duplicate process config handlers for process type: %s", h1.getProcessType())); + } + )); + } + + @SuppressWarnings("unchecked") + private ProcessConfigHandler getHandler(ProcessType processType) { + ProcessConfigHandler handler = processConfigHandlers.get(processType); + if (handler == null) { + throw new IllegalArgumentException("Unsupported process config type: " + processType); + } + return (ProcessConfigHandler) handler; } @Transactional public UUID createProcessConfig(ProcessConfig processConfig) { - return doCreateProcessConfig(processConfig); + ProcessConfigEntity entity = getHandler(processConfig.processType()).toEntity(processConfig); + return processConfigRepository.save(entity).getId(); } - private UUID doCreateProcessConfig(ProcessConfig processConfig) { - switch (processConfig) { - case SecurityAnalysisConfig sac -> { - return processConfigRepository.save(securityAnalysisConfigMapper.toEntity(sac)).getId(); - } - case LoadFlowConfig lfc -> { - return processConfigRepository.save(loadFlowConfigMapper.toEntity(lfc)).getId(); - } - default -> throw new IllegalArgumentException("Unsupported process config type: " + processConfig.processType()); - } + @Transactional(readOnly = true) + public Optional getProcessConfig(UUID processConfigUuid) { + return processConfigRepository.findById(processConfigUuid) + .map(this::toPersistedProcessConfig); } @Transactional(readOnly = true) - public Optional getProcessConfig(UUID processConfigUuid) { - return processConfigRepository.findById(processConfigUuid).map(this::toPersistedProcessConfig); + public List getProcessConfigs(ProcessType processType) { + return processConfigRepository.findAllByProcessType(processType).stream() + .map(this::toPersistedProcessConfig) + .toList(); } @Transactional(readOnly = true) @@ -81,13 +84,7 @@ public Optional updateProcessConfig(UUID processConfigUuid, ProcessConfig if (entity.getProcessType() != processConfig.processType()) { throw new IllegalArgumentException("Process config type mismatch : " + entity.getProcessType()); } - switch (processConfig) { - case SecurityAnalysisConfig sac -> - securityAnalysisConfigMapper.updateEntityFromDto(sac, (SecurityAnalysisConfigEntity) entity); - case LoadFlowConfig lfc -> - loadFlowConfigMapper.updateEntityFromDto(lfc, (LoadFlowConfigEntity) entity); - default -> throw new IllegalArgumentException("Unsupported process config type: " + processConfig.processType()); - } + getHandler(processConfig.processType()).update(processConfig, entity); return processConfigUuid; }); } @@ -95,7 +92,10 @@ public Optional updateProcessConfig(UUID processConfigUuid, ProcessConfig @Transactional public Optional duplicateProcessConfig(UUID sourceProcessConfigUuid) { return processConfigRepository.findById(sourceProcessConfigUuid) - .map(sourceEntity -> doCreateProcessConfig(toProcessConfig(sourceEntity))); + .map(sourceEntity -> { + ProcessConfigEntity entity = getHandler(sourceEntity.getProcessType()).copyEntity(sourceEntity); + return processConfigRepository.save(entity).getId(); + }); } @Transactional @@ -108,23 +108,12 @@ public Optional deleteProcessConfig(UUID processConfigUuid) { } } - @Transactional(readOnly = true) - public List getProcessConfigs(ProcessType processType) { - return processConfigRepository.findAllByProcessType(processType).stream() - .map(this::toPersistedProcessConfig) - .toList(); + private PersistedProcessConfig toPersistedProcessConfig(ProcessConfigEntity entity) { + return new PersistedProcessConfig(entity.getId(), toProcessConfig(entity)); } private ProcessConfig toProcessConfig(ProcessConfigEntity entity) { - return switch (entity) { - case SecurityAnalysisConfigEntity sae -> securityAnalysisConfigMapper.toDto(sae); - case LoadFlowConfigEntity lfe -> loadFlowConfigMapper.toDto(lfe); - default -> throw new IllegalArgumentException("Unsupported entity type: " + entity.getProcessType()); - }; - } - - private PersistedProcessConfig toPersistedProcessConfig(ProcessConfigEntity entity) { - return new PersistedProcessConfig(entity.getId(), toProcessConfig(entity)); + return getHandler(entity.getProcessType()).toDto(entity); } @Transactional(readOnly = true) @@ -136,77 +125,17 @@ public Optional compareProcessConfigs(UUID uuid1, UUID return Optional.empty(); } - ProcessConfig processConfig1 = toProcessConfig(processConfigEntity1.get()); - ProcessConfig processConfig2 = toProcessConfig(processConfigEntity2.get()); - - if (processConfig1.processType() != processConfig2.processType()) { + if (processConfigEntity1.get().getProcessType() != processConfigEntity2.get().getProcessType()) { throw new MonitorServerException(DIFFERENT_PROCESS_CONFIG_TYPE, "Cannot compare different process config types", - Map.of("processConfigEntity1Type", processConfig1.processType(), "processConfigEntity2Type", processConfig2.processType())); + Map.of("processConfigEntity1Type", processConfigEntity1.get().getProcessType(), "processConfigEntity2Type", processConfigEntity2.get().getProcessType())); } - List differences = switch (processConfig1) { - case SecurityAnalysisConfig sac1 -> compareSecurityAnalysisConfigs(sac1, (SecurityAnalysisConfig) processConfig2); - case LoadFlowConfig lfc1 -> compareLoadFlowConfigs(lfc1, (LoadFlowConfig) processConfig2); - default -> throw new IllegalArgumentException("Unsupported process config type: " + processConfig1.processType()); - }; + ProcessConfig processConfig1 = toProcessConfig(processConfigEntity1.get()); + ProcessConfig processConfig2 = toProcessConfig(processConfigEntity2.get()); + List differences = processConfig1.compareWith(processConfig2); boolean identical = differences.stream().allMatch(ProcessConfigFieldComparison::identical); return Optional.of(new ProcessConfigComparison(uuid1, uuid2, identical, differences)); } - - private void compareConfigsModifications(ProcessConfig config1, ProcessConfig config2, List differences) { - boolean modificationsIdentical = Objects.equals(config1.modificationUuids(), config2.modificationUuids()); - differences.add(new ProcessConfigFieldComparison( - "modifications", - modificationsIdentical, - config1.modificationUuids(), - config2.modificationUuids() - )); - } - - private List compareSecurityAnalysisConfigs(SecurityAnalysisConfig config1, SecurityAnalysisConfig config2) { - List differences = new ArrayList<>(); - - // Compare modifications - compareConfigsModifications(config1, config2, differences); - - // Compare security analysis parameters - boolean securityAnalysisParametersIdentical = Objects.equals(config1.securityAnalysisParametersUuid(), config2.securityAnalysisParametersUuid()); - differences.add(new ProcessConfigFieldComparison( - "securityAnalysisParameters", - securityAnalysisParametersIdentical, - config1.securityAnalysisParametersUuid(), - config2.securityAnalysisParametersUuid() - )); - - // Compare loadflow parameters - boolean loadflowParametersIdentical = Objects.equals(config1.loadflowParametersUuid(), config2.loadflowParametersUuid()); - differences.add(new ProcessConfigFieldComparison( - "loadflowParameters", - loadflowParametersIdentical, - config1.loadflowParametersUuid(), - config2.loadflowParametersUuid() - )); - - return differences; - } - - private List compareLoadFlowConfigs(LoadFlowConfig config1, LoadFlowConfig config2) { - List differences = new ArrayList<>(); - - // Compare modifications - compareConfigsModifications(config1, config2, differences); - - // Compare loadflow parameters - boolean loadflowParametersIdentical = Objects.equals(config1.loadflowParametersUuid(), config2.loadflowParametersUuid()); - differences.add(new ProcessConfigFieldComparison( - "loadflowParameters", - loadflowParametersIdentical, - config1.loadflowParametersUuid(), - config2.loadflowParametersUuid() - )); - - return differences; - } } diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/SecurityAnalysisConfigHandler.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/SecurityAnalysisConfigHandler.java new file mode 100644 index 00000000..1e20dbe5 --- /dev/null +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/processconfig/SecurityAnalysisConfigHandler.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.server.services.processconfig; + +import org.gridsuite.monitor.commons.types.processconfig.SecurityAnalysisConfig; +import org.gridsuite.monitor.commons.types.processexecution.ProcessType; +import org.gridsuite.monitor.server.entities.processconfig.SecurityAnalysisConfigEntity; +import org.gridsuite.monitor.server.mappers.processconfig.SecurityAnalysisConfigMapper; +import org.springframework.stereotype.Service; + +/** + * @author Caroline Jeandat {@literal } + */ +@Service +public class SecurityAnalysisConfigHandler extends AbstractProcessConfigHandler { + + public SecurityAnalysisConfigHandler(SecurityAnalysisConfigMapper mapper) { + super(mapper); + } + + @Override + public ProcessType getProcessType() { + return ProcessType.SECURITY_ANALYSIS; + } +} diff --git a/monitor-server/src/test/java/org/gridsuite/monitor/server/controllers/ProcessConfigControllerTest.java b/monitor-server/src/test/java/org/gridsuite/monitor/server/controllers/ProcessConfigControllerTest.java index 848f320e..164d62e6 100644 --- a/monitor-server/src/test/java/org/gridsuite/monitor/server/controllers/ProcessConfigControllerTest.java +++ b/monitor-server/src/test/java/org/gridsuite/monitor/server/controllers/ProcessConfigControllerTest.java @@ -14,7 +14,7 @@ import org.gridsuite.monitor.commons.types.processconfig.SecurityAnalysisConfig; import org.gridsuite.monitor.commons.types.processexecution.ProcessType; import org.gridsuite.monitor.server.dto.processconfig.ProcessConfigComparison; -import org.gridsuite.monitor.server.dto.processconfig.ProcessConfigFieldComparison; +import org.gridsuite.monitor.commons.types.processconfig.ProcessConfigFieldComparison; import org.gridsuite.monitor.server.error.MonitorServerException; import org.gridsuite.monitor.server.services.processconfig.ProcessConfigService; import org.junit.jupiter.api.Test; diff --git a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/AbstractProcessConfigHandlerTest.java b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/AbstractProcessConfigHandlerTest.java new file mode 100644 index 00000000..c607cf22 --- /dev/null +++ b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/AbstractProcessConfigHandlerTest.java @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.server.services.processconfig; + +import org.gridsuite.monitor.commons.types.processconfig.ProcessConfig; +import org.gridsuite.monitor.commons.types.processexecution.ProcessType; +import org.gridsuite.monitor.server.entities.processconfig.ProcessConfigEntity; +import org.gridsuite.monitor.server.mappers.processconfig.ProcessConfigMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +/** + * @author Caroline Jeandat {@literal } + */ +public abstract class AbstractProcessConfigHandlerTest< + C extends ProcessConfig, + E extends ProcessConfigEntity, + M extends ProcessConfigMapper, + H extends ProcessConfigHandler> { + + protected M mapper; + + protected H handler; + + abstract ProcessType getProcessType(); + + abstract C createProcessConfig(); + + abstract E createProcessConfigEntity(); + + @BeforeEach + protected abstract void setUp(); + + @Test + void getProcessTypeTest() { + assertThat(handler.getProcessType()).isEqualTo(getProcessType()); + } + + @Test + void updateTest() { + E processConfigEntity = createProcessConfigEntity(); + C processConfig = createProcessConfig(); + + handler.update(processConfig, processConfigEntity); + + verify(mapper).updateEntityFromDto(processConfig, processConfigEntity); + } + + @Test + void copyEntityTest() { + E processConfigEntity1 = createProcessConfigEntity(); + E expectedProcessConfigEntity = createProcessConfigEntity(); + C processConfig = createProcessConfig(); + + when(mapper.toDto(processConfigEntity1)).thenReturn(processConfig); + when(mapper.toEntity(processConfig)).thenReturn(expectedProcessConfigEntity); + + ProcessConfigEntity result = handler.copyEntity(processConfigEntity1); + + assertThat(result).isEqualTo(expectedProcessConfigEntity); + verify(mapper).toDto(processConfigEntity1); + verify(mapper).toEntity(any()); + } + + @Test + void toEntityTest() { + E expectedProcessConfigEntity = createProcessConfigEntity(); + C processConfig = createProcessConfig(); + + when(mapper.toEntity(processConfig)).thenReturn(expectedProcessConfigEntity); + + ProcessConfigEntity result = handler.toEntity(processConfig); + + assertThat(result).isEqualTo(expectedProcessConfigEntity); + verify(mapper).toEntity(processConfig); + } + + @Test + void toDtoTest() { + E processConfigEntity = createProcessConfigEntity(); + C expectedProcessConfig = createProcessConfig(); + + when(mapper.toDto(processConfigEntity)).thenReturn(expectedProcessConfig); + + ProcessConfig result = handler.toDto(processConfigEntity); + + assertThat(result).isEqualTo(expectedProcessConfig); + verify(mapper).toDto(processConfigEntity); + } +} diff --git a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/LoadFlowConfigHandlerTest.java b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/LoadFlowConfigHandlerTest.java new file mode 100644 index 00000000..a7c62d22 --- /dev/null +++ b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/LoadFlowConfigHandlerTest.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.server.services.processconfig; + +import org.gridsuite.monitor.commons.types.processconfig.LoadFlowConfig; + +import org.gridsuite.monitor.commons.types.processexecution.ProcessType; +import org.gridsuite.monitor.server.entities.processconfig.LoadFlowConfigEntity; +import org.gridsuite.monitor.server.mappers.processconfig.LoadFlowConfigMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mapstruct.factory.Mappers; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.List; +import java.util.UUID; + +/** + * @author Caroline Jeandat {@literal } + */ +@ExtendWith(MockitoExtension.class) +class LoadFlowConfigHandlerTest extends AbstractProcessConfigHandlerTest { + + @Override + @BeforeEach + protected void setUp() { + LoadFlowConfigMapper realMapper = Mappers.getMapper(LoadFlowConfigMapper.class); + mapper = Mockito.spy(realMapper); + handler = new LoadFlowConfigHandler(mapper); + } + + @Override + ProcessType getProcessType() { + return ProcessType.LOADFLOW; + } + + @Override + LoadFlowConfig createProcessConfig() { + return new LoadFlowConfig(UUID.randomUUID(), List.of(UUID.randomUUID())); + } + + @Override + LoadFlowConfigEntity createProcessConfigEntity() { + return new LoadFlowConfigEntity(); + } +} diff --git a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigServiceTest.java b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigServiceTest.java index 81afc2fa..9ddf1bb7 100644 --- a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigServiceTest.java +++ b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/ProcessConfigServiceTest.java @@ -6,36 +6,27 @@ */ package org.gridsuite.monitor.server.services.processconfig; -import org.gridsuite.monitor.commons.types.processconfig.LoadFlowConfig; +import org.gridsuite.monitor.commons.types.processconfig.ProcessConfig; +import org.gridsuite.monitor.commons.types.processexecution.ProcessType; import org.gridsuite.monitor.server.dto.processconfig.MetadataInfos; import org.gridsuite.monitor.server.dto.processconfig.PersistedProcessConfig; -import org.gridsuite.monitor.commons.types.processconfig.SecurityAnalysisConfig; -import org.gridsuite.monitor.commons.types.processexecution.ProcessType; import org.gridsuite.monitor.server.dto.processconfig.ProcessConfigComparison; -import org.gridsuite.monitor.server.dto.processconfig.ProcessConfigFieldComparison; -import org.gridsuite.monitor.server.entities.processconfig.SecurityAnalysisConfigEntity; +import org.gridsuite.monitor.commons.types.processconfig.ProcessConfigFieldComparison; import org.gridsuite.monitor.server.entities.processconfig.LoadFlowConfigEntity; +import org.gridsuite.monitor.server.entities.processconfig.ProcessConfigEntity; +import org.gridsuite.monitor.server.entities.processconfig.SecurityAnalysisConfigEntity; import org.gridsuite.monitor.server.error.MonitorServerException; -import org.gridsuite.monitor.server.mappers.processconfig.LoadFlowConfigMapper; -import org.gridsuite.monitor.server.mappers.processconfig.SecurityAnalysisConfigMapper; import org.gridsuite.monitor.server.repositories.ProcessConfigRepository; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; -import org.mapstruct.factory.Mappers; -import org.mockito.ArgumentCaptor; -import org.mockito.InjectMocks; import org.mockito.Mock; -import org.mockito.Spy; +import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.List; -import java.util.Optional; -import java.util.UUID; +import java.util.*; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.assertj.core.api.AssertionsForClassTypes.catchThrowable; +import static org.assertj.core.api.Assertions.*; import static org.gridsuite.monitor.server.error.MonitorServerBusinessErrorCode.DIFFERENT_PROCESS_CONFIG_TYPE; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.*; @@ -48,665 +39,329 @@ class ProcessConfigServiceTest { @Mock private ProcessConfigRepository processConfigRepository; - @InjectMocks - private ProcessConfigService processConfigService; - - private SecurityAnalysisConfig securityAnalysisConfig; - private LoadFlowConfig loadFlowConfig; + @Mock + private ProcessConfigHandler handler; - @Spy - private final SecurityAnalysisConfigMapper securityAnalysisConfigMapper = Mappers.getMapper(SecurityAnalysisConfigMapper.class); + private ProcessConfigService processConfigService; - @Spy - private final LoadFlowConfigMapper loadFlowConfigMapper = Mappers.getMapper(LoadFlowConfigMapper.class); + private static final ProcessType PROCESS_TYPE = ProcessType.SECURITY_ANALYSIS; + @Mock + private ProcessConfig processConfig; + @Mock + private ProcessConfigEntity processConfigEntity; @BeforeEach void setUp() { - securityAnalysisConfig = new SecurityAnalysisConfig( - UUID.randomUUID(), - List.of(UUID.randomUUID()), - UUID.randomUUID() - ); - loadFlowConfig = new LoadFlowConfig( - UUID.randomUUID(), - List.of(UUID.randomUUID()) - ); - } - - @Test - void createSecurityAnalysisConfig() { - UUID expectedProcessConfigId = UUID.randomUUID(); - when(processConfigRepository.save(any(SecurityAnalysisConfigEntity.class))) - .thenAnswer(invocation -> { - SecurityAnalysisConfigEntity entity = invocation.getArgument(0); - entity.setId(expectedProcessConfigId); - return entity; - }); - - UUID result = processConfigService.createProcessConfig(securityAnalysisConfig); - assertThat(result).isEqualTo(expectedProcessConfigId); - - ArgumentCaptor captor = ArgumentCaptor.forClass(SecurityAnalysisConfigEntity.class); - verify(processConfigRepository).save(captor.capture()); - - SecurityAnalysisConfigEntity savedEntity = captor.getValue(); - assertThat(savedEntity.getId()).isEqualTo(expectedProcessConfigId); - assertThat(savedEntity.getProcessType()).isEqualTo(ProcessType.SECURITY_ANALYSIS); - assertThat(savedEntity.getSecurityAnalysisParametersUuid()).isEqualTo(securityAnalysisConfig.securityAnalysisParametersUuid()); - assertThat(savedEntity.getLoadflowParametersUuid()).isEqualTo(securityAnalysisConfig.loadflowParametersUuid()); - assertThat(savedEntity.getModificationUuids()).isEqualTo(securityAnalysisConfig.modificationUuids()); - } - - @Test - void getSecurityAnalysisConfig() { - UUID processConfigId = UUID.randomUUID(); - SecurityAnalysisConfigEntity securityAnalysisConfigEntity = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig); - - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.of(securityAnalysisConfigEntity)); - - Optional processConfig = processConfigService.getProcessConfig(processConfigId); - verify(processConfigRepository).findById(processConfigId); - assertThat(processConfig).isPresent(); - assertThat(processConfig.get().processConfig()).usingRecursiveComparison().isEqualTo(securityAnalysisConfig); - } - - @Test - void getProcessConfigNotFound() { - UUID processConfigId = UUID.randomUUID(); - - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.empty()); - - Optional processConfig = processConfigService.getProcessConfig(processConfigId); - verify(processConfigRepository).findById(processConfigId); - assertThat(processConfig).isEmpty(); - } - - @Test - void getSecurityAnalysisConfigsMetadata() { - UUID processConfigId1 = UUID.randomUUID(); - UUID processConfigId2 = UUID.randomUUID(); - - SecurityAnalysisConfigEntity entity1 = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig); - entity1.setId(processConfigId1); - SecurityAnalysisConfigEntity entity2 = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig); - entity2.setId(processConfigId2); + when(handler.getProcessType()).thenReturn(PROCESS_TYPE); - when(processConfigRepository.findAllById(List.of(processConfigId1, processConfigId2))) - .thenReturn(List.of(entity1, entity2)); - - List metadataInfos = processConfigService.getProcessConfigsMetadata(List.of(processConfigId1, processConfigId2)); - - verify(processConfigRepository).findAllById(List.of(processConfigId1, processConfigId2)); - assertThat(metadataInfos).isEqualTo(List.of( - new MetadataInfos(processConfigId1, ProcessType.SECURITY_ANALYSIS), - new MetadataInfos(processConfigId2, ProcessType.SECURITY_ANALYSIS) - )); - } - - @Test - void updateSecurityAnalysisConfig() { - UUID processConfigId = UUID.randomUUID(); - SecurityAnalysisConfigEntity securityAnalysisConfigEntity = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig); - - SecurityAnalysisConfig newSecurityAnalysisConfig = new SecurityAnalysisConfig( - UUID.randomUUID(), - List.of(UUID.randomUUID()), - UUID.randomUUID() + processConfigService = new ProcessConfigService( + processConfigRepository, + List.of(handler) ); - - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.of(securityAnalysisConfigEntity)); - - Optional updatedConfigId = processConfigService.updateProcessConfig(processConfigId, newSecurityAnalysisConfig); - assertThat(updatedConfigId).isPresent(); - - verify(processConfigRepository).findById(processConfigId); - - Optional processConfigUpdated = processConfigService.getProcessConfig(processConfigId); - assertThat(processConfigUpdated).isPresent(); - assertThat(processConfigUpdated.get().processConfig()).usingRecursiveComparison().isEqualTo(newSecurityAnalysisConfig); - } - - @Test - void updateSecurityAnalysisConfigNotFound() { - UUID processConfigId = UUID.randomUUID(); - - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.empty()); - - SecurityAnalysisConfig newSecurityAnalysisConfig = new SecurityAnalysisConfig( - UUID.randomUUID(), - List.of(UUID.randomUUID()), - UUID.randomUUID() - ); - Optional updatedProcessConfigId = processConfigService.updateProcessConfig(processConfigId, newSecurityAnalysisConfig); - assertThat(updatedProcessConfigId).isEmpty(); - - verify(processConfigRepository).findById(processConfigId); } @Test - void duplicateSecurityAnalysisConfig() { - UUID sourceProcessConfigId = UUID.randomUUID(); - UUID expectedNewProcessConfigId = UUID.randomUUID(); - - SecurityAnalysisConfigEntity sourceEntity = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig); - sourceEntity.setId(sourceProcessConfigId); - - when(processConfigRepository.findById(sourceProcessConfigId)).thenReturn(Optional.of(sourceEntity)); - when(processConfigRepository.save(any(SecurityAnalysisConfigEntity.class))) - .thenAnswer(invocation -> { - SecurityAnalysisConfigEntity entity = invocation.getArgument(0); - entity.setId(expectedNewProcessConfigId); - return entity; - }); + void createProcessConfig() { + UUID expectedProcessConfigUuid = UUID.randomUUID(); - Optional newProcessConfigId = processConfigService.duplicateProcessConfig(sourceProcessConfigId); + ProcessConfigEntity savedEntity = mock(ProcessConfigEntity.class); - assertThat(newProcessConfigId).contains(expectedNewProcessConfigId); + when(processConfig.processType()).thenReturn(PROCESS_TYPE); + when(handler.toEntity(processConfig)).thenReturn(processConfigEntity); + when(processConfigRepository.save(processConfigEntity)).thenReturn(savedEntity); + when(savedEntity.getId()).thenReturn(expectedProcessConfigUuid); - verify(processConfigRepository).findById(sourceProcessConfigId); - ArgumentCaptor captor = ArgumentCaptor.forClass(SecurityAnalysisConfigEntity.class); - verify(processConfigRepository).save(captor.capture()); + UUID result = processConfigService.createProcessConfig(processConfig); - SecurityAnalysisConfigEntity savedEntity = captor.getValue(); - assertThat(savedEntity.getSecurityAnalysisParametersUuid()).isEqualTo(securityAnalysisConfig.securityAnalysisParametersUuid()); - assertThat(savedEntity.getLoadflowParametersUuid()).isEqualTo(securityAnalysisConfig.loadflowParametersUuid()); - assertThat(savedEntity.getModificationUuids()).isEqualTo(securityAnalysisConfig.modificationUuids()); + assertThat(result).isEqualTo(expectedProcessConfigUuid); + verify(handler).toEntity(processConfig); + verify(processConfigRepository).save(processConfigEntity); } @Test - void duplicateProcessConfigNotFound() { - UUID processConfigId = UUID.randomUUID(); - - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.empty()); - - Optional newProcessConfigId = processConfigService.duplicateProcessConfig(processConfigId); - assertThat(newProcessConfigId).isEmpty(); - verify(processConfigRepository).findById(processConfigId); - } - - @Test - void deleteProcessConfig() { - UUID processConfigId = UUID.randomUUID(); + void getProcessConfig() { + UUID processConfigUuid = UUID.randomUUID(); - when(processConfigRepository.existsById(processConfigId)).thenReturn(Boolean.TRUE); - doNothing().when(processConfigRepository).deleteById(processConfigId); + when(processConfigRepository.findById(processConfigUuid)).thenReturn(Optional.of(processConfigEntity)); + when(processConfigEntity.getProcessType()).thenReturn(PROCESS_TYPE); + when(handler.toDto(processConfigEntity)).thenReturn(processConfig); + when(processConfigEntity.getId()).thenReturn(processConfigUuid); - Optional deletedProcessConfigId = processConfigService.deleteProcessConfig(processConfigId); - assertThat(deletedProcessConfigId).contains(processConfigId); + Optional result = processConfigService.getProcessConfig(processConfigUuid); - verify(processConfigRepository).existsById(processConfigId); - verify(processConfigRepository).deleteById(processConfigId); + assertThat(result).isPresent(); + assertThat(result.get().processConfig()).isEqualTo(processConfig); + verify(processConfigRepository).findById(processConfigUuid); + verify(handler).toDto(processConfigEntity); } @Test - void deleteProcessConfigNotFound() { - UUID processConfigId = UUID.randomUUID(); + void getProcessConfigNotFound() { + UUID processConfigUuid = UUID.randomUUID(); - when(processConfigRepository.existsById(processConfigId)).thenReturn(Boolean.FALSE); + when(processConfigRepository.findById(processConfigUuid)).thenReturn(Optional.empty()); - Optional deletedProcessConfigId = processConfigService.deleteProcessConfig(processConfigId); - assertThat(deletedProcessConfigId).isEmpty(); + Optional result = processConfigService.getProcessConfig(processConfigUuid); - verify(processConfigRepository).existsById(processConfigId); - verify(processConfigRepository, never()).deleteById(processConfigId); + assertThat(result).isEmpty(); + verify(processConfigRepository).findById(processConfigUuid); + verify(handler, never()).toDto(any()); } @Test - void getSecurityAnalysisConfigs() { - SecurityAnalysisConfig securityAnalysisConfig1 = new SecurityAnalysisConfig(UUID.randomUUID(), List.of(UUID.randomUUID(), UUID.randomUUID()), UUID.randomUUID()); - SecurityAnalysisConfigEntity securityAnalysisConfigEntity1 = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig1); - SecurityAnalysisConfig securityAnalysisConfig2 = new SecurityAnalysisConfig(UUID.randomUUID(), List.of(UUID.randomUUID()), UUID.randomUUID()); - SecurityAnalysisConfigEntity securityAnalysisConfigEntity2 = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig2); + void getProcessConfigs() { + UUID processConfigUuid = UUID.randomUUID(); - when(processConfigRepository.findAllByProcessType(ProcessType.SECURITY_ANALYSIS)) - .thenReturn(List.of(securityAnalysisConfigEntity1, securityAnalysisConfigEntity2)); + when(processConfigRepository.findAllByProcessType(PROCESS_TYPE)).thenReturn(List.of(processConfigEntity)); + when(processConfigEntity.getProcessType()).thenReturn(PROCESS_TYPE); + when(handler.toDto(processConfigEntity)).thenReturn(processConfig); + when(processConfigEntity.getId()).thenReturn(processConfigUuid); - List processConfigs = processConfigService.getProcessConfigs(ProcessType.SECURITY_ANALYSIS); + List result = processConfigService.getProcessConfigs(PROCESS_TYPE); - verify(processConfigRepository).findAllByProcessType(ProcessType.SECURITY_ANALYSIS); - assertThat(processConfigs).hasSize(2); - assertThat(processConfigs.get(0).processConfig().processType()).isEqualTo(ProcessType.SECURITY_ANALYSIS); - assertThat(processConfigs.get(1).processConfig().processType()).isEqualTo(ProcessType.SECURITY_ANALYSIS); - - SecurityAnalysisConfig resSecurityAnalysisConfig1 = (SecurityAnalysisConfig) processConfigs.get(0).processConfig(); - assertThat(resSecurityAnalysisConfig1.securityAnalysisParametersUuid()).isEqualTo(securityAnalysisConfig1.securityAnalysisParametersUuid()); - assertThat(resSecurityAnalysisConfig1.modificationUuids()).isEqualTo(securityAnalysisConfig1.modificationUuids()); - - SecurityAnalysisConfig resSecurityAnalysisConfig2 = (SecurityAnalysisConfig) processConfigs.get(1).processConfig(); - assertThat(resSecurityAnalysisConfig2.securityAnalysisParametersUuid()).isEqualTo(securityAnalysisConfig2.securityAnalysisParametersUuid()); - assertThat(resSecurityAnalysisConfig2.modificationUuids()).isEqualTo(securityAnalysisConfig2.modificationUuids()); + assertThat(result).hasSize(1); + assertThat(result.getFirst().processConfig()).isEqualTo(processConfig); + verify(processConfigRepository).findAllByProcessType(PROCESS_TYPE); + verify(handler).toDto(processConfigEntity); } @Test - void getSecurityAnalysisConfigsNotFound() { - when(processConfigRepository.findAllByProcessType(ProcessType.SECURITY_ANALYSIS)).thenReturn(List.of()); + void getProcessConfigsMetadata() { + UUID saUuid = UUID.randomUUID(); + UUID lfUuid = UUID.randomUUID(); + List processConfigUuids = List.of(saUuid, lfUuid); - List processConfigs = processConfigService.getProcessConfigs(ProcessType.SECURITY_ANALYSIS); + SecurityAnalysisConfigEntity saEntity = new SecurityAnalysisConfigEntity(); + saEntity.setId(saUuid); + saEntity.setProcessType(ProcessType.SECURITY_ANALYSIS); + LoadFlowConfigEntity lfEntity = new LoadFlowConfigEntity(); + lfEntity.setId(lfUuid); + lfEntity.setProcessType(ProcessType.LOADFLOW); - verify(processConfigRepository).findAllByProcessType(ProcessType.SECURITY_ANALYSIS); - assertThat(processConfigs).isEmpty(); - } + when(processConfigRepository.findAllById(processConfigUuids)).thenReturn(List.of(saEntity, lfEntity)); - @Test - void createLoadFlowConfig() { - UUID expectedProcessConfigId = UUID.randomUUID(); - when(processConfigRepository.save(any(LoadFlowConfigEntity.class))) - .thenAnswer(invocation -> { - LoadFlowConfigEntity entity = invocation.getArgument(0); - entity.setId(expectedProcessConfigId); - return entity; - }); - - UUID result = processConfigService.createProcessConfig(loadFlowConfig); - assertThat(result).isEqualTo(expectedProcessConfigId); - - ArgumentCaptor captor = ArgumentCaptor.forClass(LoadFlowConfigEntity.class); - verify(processConfigRepository).save(captor.capture()); + List result = processConfigService.getProcessConfigsMetadata(processConfigUuids); - LoadFlowConfigEntity savedEntity = captor.getValue(); - assertThat(savedEntity.getId()).isEqualTo(expectedProcessConfigId); - assertThat(savedEntity.getProcessType()).isEqualTo(ProcessType.LOADFLOW); - assertThat(savedEntity.getLoadflowParametersUuid()).isEqualTo(loadFlowConfig.loadflowParametersUuid()); - assertThat(savedEntity.getModificationUuids()).isEqualTo(loadFlowConfig.modificationUuids()); + assertThat(result).isEqualTo(List.of( + new MetadataInfos(saUuid, ProcessType.SECURITY_ANALYSIS), + new MetadataInfos(lfUuid, ProcessType.LOADFLOW) + )); + verify(processConfigRepository).findAllById(processConfigUuids); } @Test - void getLoadFlowConfig() { - UUID processConfigId = UUID.randomUUID(); - LoadFlowConfigEntity loadFlowConfigEntity = loadFlowConfigMapper.toEntity(loadFlowConfig); + void updateProcessConfig() { + UUID processConfigUuid = UUID.randomUUID(); - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.of(loadFlowConfigEntity)); + when(processConfigRepository.findById(processConfigUuid)).thenReturn(Optional.of(processConfigEntity)); + when(processConfigEntity.getProcessType()).thenReturn(PROCESS_TYPE); + when(processConfig.processType()).thenReturn(PROCESS_TYPE); + doNothing().when(handler).update(processConfig, processConfigEntity); - Optional processConfig = processConfigService.getProcessConfig(processConfigId); - verify(processConfigRepository).findById(processConfigId); - assertThat(processConfig).isPresent(); - assertThat(processConfig.get().processConfig()).usingRecursiveComparison().isEqualTo(loadFlowConfig); - } - - @Test - void updateLoadFlowConfig() { - UUID processConfigId = UUID.randomUUID(); - LoadFlowConfigEntity loadFlowConfigEntity = loadFlowConfigMapper.toEntity(loadFlowConfig); - - LoadFlowConfig newLoadFlowConfig = new LoadFlowConfig( - UUID.randomUUID(), - List.of(UUID.randomUUID(), UUID.randomUUID()) - ); + Optional result = processConfigService.updateProcessConfig(processConfigUuid, processConfig); - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.of(loadFlowConfigEntity)); - - Optional updatedProcessConfigId = processConfigService.updateProcessConfig(processConfigId, newLoadFlowConfig); - assertThat(updatedProcessConfigId).contains(processConfigId); - - verify(processConfigRepository).findById(processConfigId); - - Optional processConfigUpdated = processConfigService.getProcessConfig(processConfigId); - assertThat(processConfigUpdated).isPresent(); - assertThat(processConfigUpdated.get().processConfig()).usingRecursiveComparison().isEqualTo(newLoadFlowConfig); + assertThat(result) + .isPresent() + .contains(processConfigUuid); + verify(processConfigRepository).findById(processConfigUuid); + verify(handler).update(processConfig, processConfigEntity); } @Test - void updateLoadFlowConfigNotFound() { - UUID processConfigId = UUID.randomUUID(); - - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.empty()); + void updateProcessConfigNotFound() { + UUID processConfigUuid = UUID.randomUUID(); - LoadFlowConfig newLoadFlowConfig = new LoadFlowConfig( - UUID.randomUUID(), - List.of(UUID.randomUUID(), UUID.randomUUID()) - ); + when(processConfigRepository.findById(processConfigUuid)).thenReturn(Optional.empty()); - Optional updatedProcessConfigId = processConfigService.updateProcessConfig(processConfigId, newLoadFlowConfig); - assertThat(updatedProcessConfigId).isNotPresent(); + Optional result = processConfigService.updateProcessConfig(processConfigUuid, processConfig); - verify(processConfigRepository).findById(processConfigId); + assertThat(result).isEmpty(); + verify(processConfigRepository).findById(processConfigUuid); + verify(handler, never()).update(processConfig, processConfigEntity); } @Test - void updateProcessConfigWithTypeMismatchShouldThrow() { - UUID processConfigId = UUID.randomUUID(); - SecurityAnalysisConfigEntity entity = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig); + void updateProcessConfigWithProcessTypeMismatch() { + UUID processConfigUuid = UUID.randomUUID(); - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.of(entity)); + when(processConfigRepository.findById(processConfigUuid)).thenReturn(Optional.of(processConfigEntity)); + when(processConfigEntity.getProcessType()).thenReturn(ProcessType.SECURITY_ANALYSIS); + when(processConfig.processType()).thenReturn(ProcessType.LOADFLOW); - assertThatThrownBy(() -> processConfigService.updateProcessConfig(processConfigId, loadFlowConfig)) + assertThatThrownBy(() -> processConfigService.updateProcessConfig(processConfigUuid, processConfig)) .isInstanceOf(IllegalArgumentException.class); + verify(processConfigRepository).findById(processConfigUuid); + verify(handler, never()).update(processConfig, processConfigEntity); } @Test - void duplicateLoadFlowConfig() { - UUID processConfigId = UUID.randomUUID(); - UUID expectedNewProcessConfigId = UUID.randomUUID(); - - LoadFlowConfigEntity sourceEntity = loadFlowConfigMapper.toEntity(loadFlowConfig); - sourceEntity.setId(processConfigId); - - when(processConfigRepository.findById(processConfigId)).thenReturn(Optional.of(sourceEntity)); - when(processConfigRepository.save(any(LoadFlowConfigEntity.class))) - .thenAnswer(invocation -> { - LoadFlowConfigEntity entity = invocation.getArgument(0); - entity.setId(expectedNewProcessConfigId); - return entity; - }); - - Optional newProcessConfigId = processConfigService.duplicateProcessConfig(processConfigId); - - assertThat(newProcessConfigId).contains(expectedNewProcessConfigId); - - verify(processConfigRepository).findById(processConfigId); - ArgumentCaptor captor = ArgumentCaptor.forClass(LoadFlowConfigEntity.class); - verify(processConfigRepository).save(captor.capture()); - - LoadFlowConfigEntity savedEntity = captor.getValue(); - assertThat(savedEntity.getLoadflowParametersUuid()).isEqualTo(loadFlowConfig.loadflowParametersUuid()); - assertThat(savedEntity.getModificationUuids()).isEqualTo(loadFlowConfig.modificationUuids()); - } - - @Test - void getLoadFlowConfigs() { - LoadFlowConfig loadFlowConfig1 = new LoadFlowConfig(UUID.randomUUID(), List.of(UUID.randomUUID(), UUID.randomUUID())); - LoadFlowConfigEntity loadFlowConfigEntity1 = loadFlowConfigMapper.toEntity(loadFlowConfig1); - - LoadFlowConfig loadFlowConfig2 = new LoadFlowConfig(UUID.randomUUID(), List.of(UUID.randomUUID())); - LoadFlowConfigEntity loadFlowConfigEntity2 = loadFlowConfigMapper.toEntity(loadFlowConfig2); - - when(processConfigRepository.findAllByProcessType(ProcessType.LOADFLOW)) - .thenReturn(List.of(loadFlowConfigEntity1, loadFlowConfigEntity2)); - - List processConfigs = processConfigService.getProcessConfigs(ProcessType.LOADFLOW); - - verify(processConfigRepository).findAllByProcessType(ProcessType.LOADFLOW); - assertThat(processConfigs).hasSize(2); - assertThat(processConfigs.get(0).processConfig().processType()).isEqualTo(ProcessType.LOADFLOW); - assertThat(processConfigs.get(1).processConfig().processType()).isEqualTo(ProcessType.LOADFLOW); - - LoadFlowConfig resLoadFlowConfig1 = (LoadFlowConfig) processConfigs.get(0).processConfig(); - assertThat(resLoadFlowConfig1.loadflowParametersUuid()).isEqualTo(loadFlowConfig1.loadflowParametersUuid()); - assertThat(resLoadFlowConfig1.modificationUuids()).isEqualTo(loadFlowConfig1.modificationUuids()); - - LoadFlowConfig resLoadFlowConfig2 = (LoadFlowConfig) processConfigs.get(1).processConfig(); - assertThat(resLoadFlowConfig2.loadflowParametersUuid()).isEqualTo(loadFlowConfig2.loadflowParametersUuid()); - assertThat(resLoadFlowConfig2.modificationUuids()).isEqualTo(loadFlowConfig2.modificationUuids()); - } - - @Test - void getLoadFlowConfigsNotFound() { - when(processConfigRepository.findAllByProcessType(ProcessType.LOADFLOW)).thenReturn(List.of()); - - List processConfigs = processConfigService.getProcessConfigs(ProcessType.LOADFLOW); - - verify(processConfigRepository).findAllByProcessType(ProcessType.LOADFLOW); - assertThat(processConfigs).isEmpty(); + void duplicateSecurityAnalysisConfig() { + UUID processConfigUuid = UUID.randomUUID(); + UUID copiedProcessConfigUuid = UUID.randomUUID(); + ProcessConfigEntity copiedProcessConfigEntity = Mockito.mock(ProcessConfigEntity.class); + + when(processConfigRepository.findById(processConfigUuid)).thenReturn(Optional.of(processConfigEntity)); + when(processConfigEntity.getProcessType()).thenReturn(PROCESS_TYPE); + when(handler.copyEntity(processConfigEntity)).thenReturn(copiedProcessConfigEntity); + when(processConfigRepository.save(copiedProcessConfigEntity)).thenReturn(copiedProcessConfigEntity); + when(copiedProcessConfigEntity.getId()).thenReturn(copiedProcessConfigUuid); + + Optional result = processConfigService.duplicateProcessConfig(processConfigUuid); + + assertThat(result) + .isPresent() + .contains(copiedProcessConfigUuid); + verify(processConfigRepository).findById(processConfigUuid); + verify(handler).copyEntity(processConfigEntity); + verify(processConfigRepository).save(copiedProcessConfigEntity); } @Test - void getLoadFlowConfigsMetadata() { - UUID processConfigId1 = UUID.randomUUID(); - UUID processConfigId2 = UUID.randomUUID(); - - LoadFlowConfigEntity entity1 = loadFlowConfigMapper.toEntity(loadFlowConfig); - entity1.setId(processConfigId1); - LoadFlowConfigEntity entity2 = loadFlowConfigMapper.toEntity(loadFlowConfig); - entity2.setId(processConfigId2); + void duplicateProcessConfigNotFound() { + UUID processConfigUuid = UUID.randomUUID(); - when(processConfigRepository.findAllById(List.of(processConfigId1, processConfigId2))) - .thenReturn(List.of(entity1, entity2)); + when(processConfigRepository.findById(processConfigUuid)).thenReturn(Optional.empty()); - List metadataInfos = processConfigService.getProcessConfigsMetadata(List.of(processConfigId1, processConfigId2)); + Optional result = processConfigService.duplicateProcessConfig(processConfigUuid); - verify(processConfigRepository).findAllById(List.of(processConfigId1, processConfigId2)); - assertThat(metadataInfos).isEqualTo(List.of( - new MetadataInfos(processConfigId1, ProcessType.LOADFLOW), - new MetadataInfos(processConfigId2, ProcessType.LOADFLOW) - )); + assertThat(result).isEmpty(); + verify(processConfigRepository).findById(processConfigUuid); + verify(handler, never()).copyEntity(any()); } @Test - void compareProcessConfigsShouldReturnIdenticalWhenConfigsAreEqual() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - SecurityAnalysisConfig config = new SecurityAnalysisConfig(UUID.randomUUID(), List.of(UUID.randomUUID(), UUID.randomUUID()), UUID.randomUUID()); - - SecurityAnalysisConfigEntity entity1 = securityAnalysisConfigMapper.toEntity(config); - entity1.setId(uuid1); - SecurityAnalysisConfigEntity entity2 = securityAnalysisConfigMapper.toEntity(config); - entity2.setId(uuid2); - - when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); - when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); + void deleteProcessConfig() { + UUID processConfigUuid = UUID.randomUUID(); + when(processConfigRepository.existsById(processConfigUuid)).thenReturn(Boolean.TRUE); + doNothing().when(processConfigRepository).deleteById(processConfigUuid); - Optional result = processConfigService.compareProcessConfigs(uuid1, uuid2); + Optional result = processConfigService.deleteProcessConfig(processConfigUuid); - assertThat(result).isPresent(); - ProcessConfigComparison comparison = result.get(); - assertThat(comparison.processConfigUuid1()).isEqualTo(uuid1); - assertThat(comparison.processConfigUuid2()).isEqualTo(uuid2); - assertThat(comparison.identical()).isTrue(); - assertThat(comparison.differences()).hasSize(3); - assertThat(comparison.differences()).allMatch(ProcessConfigFieldComparison::identical); + assertThat(result).contains(processConfigUuid); + verify(processConfigRepository).existsById(processConfigUuid); + verify(processConfigRepository).deleteById(processConfigUuid); } @Test - void compareProcessConfigsShouldReturnDifferencesWhenModificationsAreDifferent() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - UUID securityAnalysisParametersUuid = UUID.randomUUID(); - UUID loadflowParametersUuid = UUID.randomUUID(); - List modificationUuids1 = List.of(UUID.randomUUID(), UUID.randomUUID()); - List modificationUuids2 = List.of(UUID.randomUUID(), UUID.randomUUID()); - - SecurityAnalysisConfigEntity entity1 = securityAnalysisConfigMapper.toEntity( - new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids1, loadflowParametersUuid)); - entity1.setId(uuid1); - SecurityAnalysisConfigEntity entity2 = securityAnalysisConfigMapper.toEntity( - new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids2, loadflowParametersUuid)); - entity2.setId(uuid2); - - when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); - when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); - - Optional result = processConfigService.compareProcessConfigs(uuid1, uuid2); + void deleteProcessConfigNotFound() { + UUID processConfigUuid = UUID.randomUUID(); - assertThat(result).isPresent(); - ProcessConfigComparison comparison = result.get(); - assertThat(comparison.identical()).isFalse(); - assertThat(comparison.differences()).hasSize(3); - - ProcessConfigFieldComparison modificationsComparison = comparison.differences().stream() - .filter(d -> "modifications".equals(d.field())) - .findFirst() - .orElseThrow(); - assertThat(modificationsComparison.identical()).isFalse(); - assertThat(modificationsComparison.value1()).isEqualTo(modificationUuids1); - assertThat(modificationsComparison.value2()).isEqualTo(modificationUuids2); - } + when(processConfigRepository.existsById(processConfigUuid)).thenReturn(Boolean.FALSE); - @Test - void compareProcessConfigsShouldReturnDifferencesWhenParametersAreDifferent() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - UUID securityAnalysisParametersUuid1 = UUID.randomUUID(); - UUID securityAnalysisParametersUuid2 = UUID.randomUUID(); - UUID loadflowParametersUuid = UUID.randomUUID(); - List modificationUuids = List.of(UUID.randomUUID()); - - SecurityAnalysisConfigEntity entity1 = securityAnalysisConfigMapper.toEntity( - new SecurityAnalysisConfig(securityAnalysisParametersUuid1, modificationUuids, loadflowParametersUuid)); - entity1.setId(uuid1); - SecurityAnalysisConfigEntity entity2 = securityAnalysisConfigMapper.toEntity( - new SecurityAnalysisConfig(securityAnalysisParametersUuid2, modificationUuids, loadflowParametersUuid)); - entity2.setId(uuid2); - - when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); - when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); - - Optional result = processConfigService.compareProcessConfigs(uuid1, uuid2); + Optional result = processConfigService.deleteProcessConfig(processConfigUuid); - assertThat(result).isPresent(); - ProcessConfigComparison comparison = result.get(); - assertThat(comparison.identical()).isFalse(); - - ProcessConfigFieldComparison parametersComparison = comparison.differences().stream() - .filter(d -> "securityAnalysisParameters".equals(d.field())) - .findFirst() - .orElseThrow(); - assertThat(parametersComparison.identical()).isFalse(); - assertThat(parametersComparison.value1()).isEqualTo(securityAnalysisParametersUuid1); - assertThat(parametersComparison.value2()).isEqualTo(securityAnalysisParametersUuid2); + assertThat(result).isEmpty(); + verify(processConfigRepository).existsById(processConfigUuid); + verify(processConfigRepository, never()).deleteById(any()); } @Test - void compareProcessConfigsShouldDetectOrderDifferenceInModifications() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - UUID securityAnalysisParametersUuid = UUID.randomUUID(); - UUID loadflowParametersUuid = UUID.randomUUID(); - UUID mod1 = UUID.randomUUID(); - UUID mod2 = UUID.randomUUID(); - List modificationUuids1 = List.of(mod1, mod2); - List modificationUuids2 = List.of(mod2, mod1); // Different order - - SecurityAnalysisConfigEntity entity1 = securityAnalysisConfigMapper.toEntity( - new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids1, loadflowParametersUuid)); - entity1.setId(uuid1); - SecurityAnalysisConfigEntity entity2 = securityAnalysisConfigMapper.toEntity( - new SecurityAnalysisConfig(securityAnalysisParametersUuid, modificationUuids2, loadflowParametersUuid)); - entity2.setId(uuid2); - - when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); - when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); - - Optional result = processConfigService.compareProcessConfigs(uuid1, uuid2); - - assertThat(result).isPresent(); - ProcessConfigComparison comparison = result.get(); - assertThat(comparison.identical()).isFalse(); - - ProcessConfigFieldComparison modificationsComparison = comparison.differences().stream() - .filter(d -> "modifications".equals(d.field())) - .findFirst() - .orElseThrow(); - assertThat(modificationsComparison.identical()).isFalse(); + void compareProcessConfigsWithEqualProcessConfigs() { + UUID processConfigUuid1 = UUID.randomUUID(); + UUID processConfigUuid2 = UUID.randomUUID(); + ProcessConfigFieldComparison fieldComparison = new ProcessConfigFieldComparison("field", true, "value1", "value2"); + + when(processConfigRepository.findById(processConfigUuid1)).thenReturn(Optional.of(processConfigEntity)); + when(processConfigRepository.findById(processConfigUuid2)).thenReturn(Optional.of(processConfigEntity)); + when(processConfigEntity.getProcessType()).thenReturn(PROCESS_TYPE); + when(handler.toDto(processConfigEntity)).thenReturn(processConfig); + when(processConfig.compareWith(processConfig)).thenReturn(List.of(fieldComparison)); + + Optional result = processConfigService.compareProcessConfigs(processConfigUuid1, processConfigUuid2); + + assertThat(result) + .isPresent() + .contains(new ProcessConfigComparison(processConfigUuid1, processConfigUuid2, true, List.of(fieldComparison))); + verify(processConfigRepository).findById(processConfigUuid1); + verify(processConfigRepository).findById(processConfigUuid2); + verify(handler, times(2)).toDto(processConfigEntity); + verify(processConfig).compareWith(processConfig); } @Test - void compareLoadFlowConfigsShouldReturnIdenticalWhenConfigsAreEqual() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - LoadFlowConfig config = new LoadFlowConfig(UUID.randomUUID(), List.of(UUID.randomUUID(), UUID.randomUUID())); - - LoadFlowConfigEntity entity1 = loadFlowConfigMapper.toEntity(config); - entity1.setId(uuid1); - LoadFlowConfigEntity entity2 = loadFlowConfigMapper.toEntity(config); - entity2.setId(uuid2); - - when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); - when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); - - Optional result = processConfigService.compareProcessConfigs(uuid1, uuid2); - - assertThat(result).isPresent(); - ProcessConfigComparison comparison = result.get(); - assertThat(comparison.processConfigUuid1()).isEqualTo(uuid1); - assertThat(comparison.processConfigUuid2()).isEqualTo(uuid2); - assertThat(comparison.identical()).isTrue(); - assertThat(comparison.differences()).hasSize(2); - assertThat(comparison.differences()).allMatch(ProcessConfigFieldComparison::identical); + void compareProcessConfigsWithDifferentProcessConfigs() { + UUID processConfigUuid1 = UUID.randomUUID(); + UUID processConfigUuid2 = UUID.randomUUID(); + ProcessConfigEntity processConfigEntity1 = Mockito.mock(ProcessConfigEntity.class); + ProcessConfigEntity processConfigEntity2 = Mockito.mock(ProcessConfigEntity.class); + ProcessConfig processConfig1 = Mockito.mock(ProcessConfig.class); + ProcessConfig processConfig2 = Mockito.mock(ProcessConfig.class); + ProcessConfigFieldComparison fieldComparison = new ProcessConfigFieldComparison("field", false, "value1", "value2"); + + when(processConfigRepository.findById(processConfigUuid1)).thenReturn(Optional.of(processConfigEntity1)); + when(processConfigRepository.findById(processConfigUuid2)).thenReturn(Optional.of(processConfigEntity2)); + when(processConfigEntity1.getProcessType()).thenReturn(PROCESS_TYPE); + when(processConfigEntity2.getProcessType()).thenReturn(PROCESS_TYPE); + when(handler.toDto(processConfigEntity1)).thenReturn(processConfig1); + when(handler.toDto(processConfigEntity2)).thenReturn(processConfig2); + when(processConfig1.compareWith(processConfig2)).thenReturn(List.of(fieldComparison)); + + Optional result = processConfigService.compareProcessConfigs(processConfigUuid1, processConfigUuid2); + + assertThat(result) + .isPresent() + .contains(new ProcessConfigComparison(processConfigUuid1, processConfigUuid2, false, List.of(fieldComparison))); + verify(processConfigRepository).findById(processConfigUuid1); + verify(processConfigRepository).findById(processConfigUuid2); + verify(handler).toDto(processConfigEntity1); + verify(handler).toDto(processConfigEntity2); + verify(processConfig1).compareWith(processConfig2); } @Test - void compareLoadFlowConfigsShouldReturnDifferencesWhenModificationsAreDifferent() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - UUID loadflowParametersUuid = UUID.randomUUID(); - List modificationUuids1 = List.of(UUID.randomUUID(), UUID.randomUUID()); - List modificationUuids2 = List.of(UUID.randomUUID(), UUID.randomUUID()); - - LoadFlowConfigEntity entity1 = loadFlowConfigMapper.toEntity(new LoadFlowConfig(loadflowParametersUuid, modificationUuids1)); - entity1.setId(uuid1); - LoadFlowConfigEntity entity2 = loadFlowConfigMapper.toEntity(new LoadFlowConfig(loadflowParametersUuid, modificationUuids2)); - entity2.setId(uuid2); + void compareProcessConfigWithFirstProcessConfigNotFound() { + UUID processConfigUuid1 = UUID.randomUUID(); + UUID processConfigUuid2 = UUID.randomUUID(); - when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); - when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); + // test when the first process config is not found + when(processConfigRepository.findById(processConfigUuid1)).thenReturn(Optional.empty()); - Optional result = processConfigService.compareProcessConfigs(uuid1, uuid2); + Optional result = processConfigService.compareProcessConfigs(processConfigUuid1, processConfigUuid2); - assertThat(result).isPresent(); - ProcessConfigComparison comparison = result.get(); - assertThat(comparison.identical()).isFalse(); - assertThat(comparison.differences()).hasSize(2); - - ProcessConfigFieldComparison modificationsComparison = comparison.differences().stream() - .filter(d -> "modifications".equals(d.field())) - .findFirst() - .orElseThrow(); - assertThat(modificationsComparison.identical()).isFalse(); - assertThat(modificationsComparison.value1()).isEqualTo(modificationUuids1); - assertThat(modificationsComparison.value2()).isEqualTo(modificationUuids2); + assertThat(result).isEmpty(); + verify(processConfigRepository).findById(processConfigUuid1); + verify(handler, never()).toDto(any()); } @Test - void compareLoadFlowConfigsShouldReturnDifferencesWhenParametersAreDifferent() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - UUID loadflowParametersUuid1 = UUID.randomUUID(); - UUID loadflowParametersUuid2 = UUID.randomUUID(); - List modificationUuids = List.of(UUID.randomUUID()); + void compareProcessConfigWithSecondProcessConfigNotFound() { + UUID processConfigUuid1 = UUID.randomUUID(); + UUID processConfigUuid2 = UUID.randomUUID(); - LoadFlowConfigEntity entity1 = loadFlowConfigMapper.toEntity(new LoadFlowConfig(loadflowParametersUuid1, modificationUuids)); - entity1.setId(uuid1); - LoadFlowConfigEntity entity2 = loadFlowConfigMapper.toEntity(new LoadFlowConfig(loadflowParametersUuid2, modificationUuids)); - entity2.setId(uuid2); + // test when the second process config is not found + ProcessConfigEntity processConfigEntity1 = Mockito.mock(ProcessConfigEntity.class); - when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); - when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); + when(processConfigRepository.findById(processConfigUuid1)).thenReturn(Optional.of(processConfigEntity1)); + when(processConfigRepository.findById(processConfigUuid2)).thenReturn(Optional.empty()); - Optional result = processConfigService.compareProcessConfigs(uuid1, uuid2); - - assertThat(result).isPresent(); - ProcessConfigComparison comparison = result.get(); - assertThat(comparison.identical()).isFalse(); - - ProcessConfigFieldComparison parametersComparison = comparison.differences().stream() - .filter(d -> "loadflowParameters".equals(d.field())) - .findFirst() - .orElseThrow(); - assertThat(parametersComparison.identical()).isFalse(); - assertThat(parametersComparison.value1()).isEqualTo(loadflowParametersUuid1); - assertThat(parametersComparison.value2()).isEqualTo(loadflowParametersUuid2); - } - - @Test - void compareProcessConfigsShouldReturnEmptyWhenOneConfigNotFound() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - - SecurityAnalysisConfigEntity entity2 = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig); - when(processConfigRepository.findById(uuid1)).thenReturn(Optional.empty()); - when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); - - Optional result = processConfigService.compareProcessConfigs(uuid1, uuid2); + Optional result = processConfigService.compareProcessConfigs(processConfigUuid1, processConfigUuid2); assertThat(result).isEmpty(); + verify(processConfigRepository).findById(processConfigUuid1); + verify(processConfigRepository).findById(processConfigUuid2); + verify(handler, never()).toDto(any()); } @Test - void compareProcessConfigsShouldThrowWhenDifferentTypes() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - - SecurityAnalysisConfigEntity entity1 = securityAnalysisConfigMapper.toEntity(securityAnalysisConfig); - entity1.setId(uuid1); - LoadFlowConfigEntity entity2 = loadFlowConfigMapper.toEntity(loadFlowConfig); - entity2.setId(uuid2); - - when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); - when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); - - MonitorServerException exception = (MonitorServerException) catchThrowable(() -> processConfigService.compareProcessConfigs(uuid1, uuid2)); - assertThat(exception.getErrorCode()).isEqualTo(DIFFERENT_PROCESS_CONFIG_TYPE); - assertThat(exception.getBusinessErrorValues()).containsEntry("processConfigEntity1Type", ProcessType.SECURITY_ANALYSIS); - assertThat(exception.getBusinessErrorValues()).containsEntry("processConfigEntity2Type", ProcessType.LOADFLOW); + void compareProcessConfigsShouldThrowWhenProcessTypesAreDifferent() { + UUID processConfigUuid1 = UUID.randomUUID(); + UUID processConfigUuid2 = UUID.randomUUID(); + ProcessConfigEntity processConfigEntity1 = Mockito.mock(SecurityAnalysisConfigEntity.class); + ProcessConfigEntity processConfigEntity2 = Mockito.mock(LoadFlowConfigEntity.class); + + when(processConfigRepository.findById(processConfigUuid1)).thenReturn(Optional.of(processConfigEntity1)); + when(processConfigRepository.findById(processConfigUuid2)).thenReturn(Optional.of(processConfigEntity2)); + when(processConfigEntity1.getProcessType()).thenReturn(ProcessType.SECURITY_ANALYSIS); + when(processConfigEntity2.getProcessType()).thenReturn(ProcessType.LOADFLOW); + + assertThatThrownBy(() -> processConfigService.compareProcessConfigs(processConfigUuid1, processConfigUuid2)) + .isInstanceOf(MonitorServerException.class) + .satisfies(ex -> { + MonitorServerException e = (MonitorServerException) ex; + assertThat(e.getErrorCode()).isEqualTo(DIFFERENT_PROCESS_CONFIG_TYPE); + }); + verify(processConfigRepository).findById(processConfigUuid1); + verify(processConfigRepository).findById(processConfigUuid2); + verify(handler, never()).toDto(any()); } } diff --git a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/SecurityAnalysisConfigHandlerTest.java b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/SecurityAnalysisConfigHandlerTest.java new file mode 100644 index 00000000..5aeeeb7a --- /dev/null +++ b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/processconfig/SecurityAnalysisConfigHandlerTest.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.monitor.server.services.processconfig; + +import org.gridsuite.monitor.commons.types.processconfig.SecurityAnalysisConfig; +import org.gridsuite.monitor.commons.types.processexecution.ProcessType; +import org.gridsuite.monitor.server.entities.processconfig.SecurityAnalysisConfigEntity; +import org.gridsuite.monitor.server.mappers.processconfig.SecurityAnalysisConfigMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mapstruct.factory.Mappers; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.List; +import java.util.UUID; + +/** + * @author Caroline Jeandat {@literal } + */ +@ExtendWith(MockitoExtension.class) +class SecurityAnalysisConfigHandlerTest extends AbstractProcessConfigHandlerTest { + + @Override + @BeforeEach + protected void setUp() { + SecurityAnalysisConfigMapper realMapper = Mappers.getMapper(SecurityAnalysisConfigMapper.class); + mapper = Mockito.spy(realMapper); + handler = new SecurityAnalysisConfigHandler(mapper); + } + + @Override + ProcessType getProcessType() { + return ProcessType.SECURITY_ANALYSIS; + } + + @Override + SecurityAnalysisConfig createProcessConfig() { + return new SecurityAnalysisConfig(UUID.randomUUID(), List.of(UUID.randomUUID()), UUID.randomUUID()); + } + + @Override + SecurityAnalysisConfigEntity createProcessConfigEntity() { + return new SecurityAnalysisConfigEntity(); + } +}