From 0c4992788e452aa9ee9dc462894976fdd1a084ae Mon Sep 17 00:00:00 2001 From: Franck LECUYER Date: Wed, 25 Feb 2026 15:47:18 +0100 Subject: [PATCH 1/6] Add endpoint to compare 2 process configs Signed-off-by: Franck LECUYER --- .../controllers/ProcessConfigController.java | 19 ++ .../server/dto/ProcessConfigComparison.java | 22 ++ .../dto/ProcessConfigFieldComparison.java | 19 ++ .../server/services/ProcessConfigService.java | 63 ++++++ .../ProcessConfigControllerTest.java | 119 ++++++++++ .../services/ProcessConfigServiceTest.java | 206 ++++++++++++++++++ 6 files changed, 448 insertions(+) create mode 100644 monitor-server/src/main/java/org/gridsuite/monitor/server/dto/ProcessConfigComparison.java create mode 100644 monitor-server/src/main/java/org/gridsuite/monitor/server/dto/ProcessConfigFieldComparison.java 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 b9b383f3..36695f84 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 @@ -14,6 +14,7 @@ import org.gridsuite.monitor.commons.PersistedProcessConfig; import org.gridsuite.monitor.commons.ProcessConfig; import org.gridsuite.monitor.commons.ProcessType; +import org.gridsuite.monitor.server.dto.ProcessConfigComparison; import org.gridsuite.monitor.server.services.ProcessConfigService; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; @@ -99,4 +100,22 @@ public ResponseEntity> getProcessConfigs( List processConfigs = processConfigService.getProcessConfigs(processType); return ResponseEntity.ok().body(processConfigs); } + + @GetMapping(value = "/compare", produces = MediaType.APPLICATION_JSON_VALUE) + @Operation(summary = "Compare 2 process configs") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "Comparison result returned"), + @ApiResponse(responseCode = "404", description = "One or both process configs are not found"), + @ApiResponse(responseCode = "400", description = "Process configs are of different types")}) + public ResponseEntity compareProcessConfigs( + @Parameter(description = "First process config UUID") @RequestParam("uuid1") UUID uuid1, + @Parameter(description = "Second process config UUID") @RequestParam("uuid2") UUID uuid2) { + + try { + Optional comparison = processConfigService.compareProcessConfigs(uuid1, uuid2); + return comparison.map(c -> ResponseEntity.ok().body(c)).orElseGet(() -> ResponseEntity.notFound().build()); + } catch (IllegalArgumentException e) { + return ResponseEntity.badRequest().build(); + } + } } diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/ProcessConfigComparison.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/ProcessConfigComparison.java new file mode 100644 index 00000000..cb811bfe --- /dev/null +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/ProcessConfigComparison.java @@ -0,0 +1,22 @@ +/** + * 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; + +import io.swagger.v3.oas.annotations.media.Schema; + +import java.util.List; +import java.util.UUID; + +/** + * @author Franck Lecuyer + */ +@Schema(description = "Process config comparison result") +public record ProcessConfigComparison( + UUID processConfigUuid1, + UUID processConfigUuid2, + boolean identical, + List differences) { } diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/ProcessConfigFieldComparison.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/ProcessConfigFieldComparison.java new file mode 100644 index 00000000..3fc8627f --- /dev/null +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/dto/ProcessConfigFieldComparison.java @@ -0,0 +1,19 @@ +/** + * 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; + +import io.swagger.v3.oas.annotations.media.Schema; + +/** + * @author Franck Lecuyer + */ +@Schema(description = "Field comparison result") +public record ProcessConfigFieldComparison( + String field, + boolean identical, + Object value1, + Object value2) { } diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/ProcessConfigService.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/ProcessConfigService.java index 2ca28cd0..f012306a 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/ProcessConfigService.java +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/ProcessConfigService.java @@ -11,13 +11,17 @@ import org.gridsuite.monitor.commons.ProcessType; import org.gridsuite.monitor.commons.SecurityAnalysisConfig; import org.gridsuite.monitor.server.entities.ProcessConfigEntity; +import org.gridsuite.monitor.server.dto.ProcessConfigComparison; +import org.gridsuite.monitor.server.dto.ProcessConfigFieldComparison; import org.gridsuite.monitor.server.entities.SecurityAnalysisConfigEntity; import org.gridsuite.monitor.server.mapper.SecurityAnalysisConfigMapper; import org.gridsuite.monitor.server.repositories.ProcessConfigRepository; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; +import java.util.ArrayList; import java.util.List; +import java.util.Objects; import java.util.Optional; import java.util.UUID; @@ -84,4 +88,63 @@ public List getProcessConfigs(ProcessType processType) { default -> throw new IllegalArgumentException("Unsupported entity type: " + entity.getProcessType()); }).toList(); } + + @Transactional(readOnly = true) + public Optional compareProcessConfigs(UUID uuid1, UUID uuid2) { + Optional config1 = getProcessConfig(uuid1); + Optional config2 = getProcessConfig(uuid2); + + if (config1.isEmpty() || config2.isEmpty()) { + return Optional.empty(); + } + + ProcessConfig processConfig1 = config1.get().processConfig(); + ProcessConfig processConfig2 = config2.get().processConfig(); + + if (processConfig1.processType() != processConfig2.processType()) { + throw new IllegalArgumentException("Cannot compare different process config types: " + processConfig1.processType() + " vs " + processConfig2.processType()); + } + + List differences = switch (processConfig1) { + case SecurityAnalysisConfig sac1 -> compareSecurityAnalysisConfigs(sac1, (SecurityAnalysisConfig) processConfig2); + default -> throw new IllegalArgumentException("Unsupported process config type: " + processConfig1.processType()); + }; + + boolean identical = differences.stream().allMatch(ProcessConfigFieldComparison::identical); + + return Optional.of(new ProcessConfigComparison(uuid1, uuid2, identical, differences)); + } + + private List compareSecurityAnalysisConfigs(SecurityAnalysisConfig config1, SecurityAnalysisConfig config2) { + List differences = new ArrayList<>(); + + // Compare modifications + boolean modificationsIdentical = Objects.equals(config1.modificationUuids(), config2.modificationUuids()); + differences.add(new ProcessConfigFieldComparison( + "modifications", + modificationsIdentical, + config1.modificationUuids(), + config2.modificationUuids() + )); + + // Compare parameters + boolean parametersIdentical = Objects.equals(config1.parametersUuid(), config2.parametersUuid()); + differences.add(new ProcessConfigFieldComparison( + "securityAnalysisParameters", + parametersIdentical, + config1.parametersUuid(), + config2.parametersUuid() + )); + + // Compare contingencies + boolean contingenciesIdentical = Objects.equals(config1.contingencies(), config2.contingencies()); + differences.add(new ProcessConfigFieldComparison( + "contingencies", + contingenciesIdentical, + config1.contingencies(), + config2.contingencies() + )); + + return differences; + } } 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 a0c46d47..53a97301 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 @@ -11,6 +11,8 @@ import org.gridsuite.monitor.commons.ProcessConfig; import org.gridsuite.monitor.commons.ProcessType; import org.gridsuite.monitor.commons.SecurityAnalysisConfig; +import org.gridsuite.monitor.server.dto.ProcessConfigComparison; +import org.gridsuite.monitor.server.dto.ProcessConfigFieldComparison; import org.gridsuite.monitor.server.services.ProcessConfigService; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -216,4 +218,121 @@ void getAllSecurityAnalysisConfigsNotFound() throws Exception { verify(processConfigService).getProcessConfigs(ProcessType.SECURITY_ANALYSIS); } + + @Test + void compareProcessConfigsShouldReturnComparisonResult() throws Exception { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + UUID parametersUuid = UUID.randomUUID(); + List modificationUuids = List.of(UUID.randomUUID()); + + ProcessConfigComparison comparison = new ProcessConfigComparison( + uuid1, + uuid2, + true, + List.of( + new ProcessConfigFieldComparison("modifications", true, modificationUuids, modificationUuids), + new ProcessConfigFieldComparison("securityAnalysisParameters", true, parametersUuid, parametersUuid), + new ProcessConfigFieldComparison("contingencies", true, List.of("contingency1"), List.of("contingency1")) + ) + ); + + when(processConfigService.compareProcessConfigs(uuid1, uuid2)) + .thenReturn(Optional.of(comparison)); + + mockMvc.perform(get("/v1/process-configs/compare") + .param("uuid1", uuid1.toString()) + .param("uuid2", uuid2.toString()) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(content().contentType(MediaType.APPLICATION_JSON)) + .andExpect(jsonPath("$.processConfigUuid1").value(uuid1.toString())) + .andExpect(jsonPath("$.processConfigUuid2").value(uuid2.toString())) + .andExpect(jsonPath("$.identical").value(true)) + .andExpect(jsonPath("$.differences").isArray()) + .andExpect(jsonPath("$.differences.length()").value(3)); + + verify(processConfigService).compareProcessConfigs(uuid1, uuid2); + } + + @Test + void compareProcessConfigsShouldReturnDifferences() throws Exception { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + List modificationUuids1 = List.of(UUID.randomUUID()); + List modificationUuids2 = List.of(UUID.randomUUID()); + + ProcessConfigComparison comparison = new ProcessConfigComparison( + uuid1, + uuid2, + false, + List.of( + new ProcessConfigFieldComparison("modifications", false, modificationUuids1, modificationUuids2) + ) + ); + + when(processConfigService.compareProcessConfigs(uuid1, uuid2)) + .thenReturn(Optional.of(comparison)); + + mockMvc.perform(get("/v1/process-configs/compare") + .param("uuid1", uuid1.toString()) + .param("uuid2", uuid2.toString()) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.identical").value(false)) + .andExpect(jsonPath("$.differences[0].field").value("modifications")) + .andExpect(jsonPath("$.differences[0].identical").value(false)); + + verify(processConfigService).compareProcessConfigs(uuid1, uuid2); + } + + @Test + void compareProcessConfigsShouldReturn404WhenConfigNotFound() throws Exception { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + + when(processConfigService.compareProcessConfigs(uuid1, uuid2)) + .thenReturn(Optional.empty()); + + mockMvc.perform(get("/v1/process-configs/compare") + .param("uuid1", uuid1.toString()) + .param("uuid2", uuid2.toString()) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isNotFound()); + + verify(processConfigService).compareProcessConfigs(uuid1, uuid2); + } + + @Test + void compareProcessConfigsShouldReturn400WhenDifferentTypes() throws Exception { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + + when(processConfigService.compareProcessConfigs(any(), any())) + .thenThrow(new IllegalArgumentException("Cannot compare different process config types")); + + mockMvc.perform(get("/v1/process-configs/compare") + .param("uuid1", uuid1.toString()) + .param("uuid2", uuid2.toString()) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isBadRequest()); + + verify(processConfigService).compareProcessConfigs(uuid1, uuid2); + } + + @Test + void compareProcessConfigsShouldReturn400WhenMissingParameters() throws Exception { + mockMvc.perform(get("/v1/process-configs/compare") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isBadRequest()); + } + + @Test + void compareProcessConfigsShouldReturn400WhenInvalidUUID() throws Exception { + mockMvc.perform(get("/v1/process-configs/compare") + .param("uuid1", "invalid-uuid") + .param("uuid2", UUID.randomUUID().toString()) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isBadRequest()); + } } diff --git a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java index 130f5d07..20e0a4ee 100644 --- a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java +++ b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java @@ -9,6 +9,8 @@ import org.gridsuite.monitor.commons.PersistedProcessConfig; import org.gridsuite.monitor.commons.ProcessType; import org.gridsuite.monitor.commons.SecurityAnalysisConfig; +import org.gridsuite.monitor.server.dto.ProcessConfigComparison; +import org.gridsuite.monitor.server.dto.ProcessConfigFieldComparison; import org.gridsuite.monitor.server.entities.SecurityAnalysisConfigEntity; import org.gridsuite.monitor.server.mapper.SecurityAnalysisConfigMapper; import org.gridsuite.monitor.server.repositories.ProcessConfigRepository; @@ -205,4 +207,208 @@ void getSecurityAnalysisConfigsNotFound() { verify(processConfigRepository).findAllByProcessType(ProcessType.SECURITY_ANALYSIS); assertThat(processConfigs).isEmpty(); } + + @Test + void compareProcessConfigsShouldReturnIdenticalWhenConfigsAreEqual() { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + UUID parametersUuid = UUID.randomUUID(); + List modificationUuids = List.of(UUID.randomUUID(), UUID.randomUUID()); + List contingencies = List.of("contingency1", "contingency2"); + + SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); + entity1.setId(uuid1); + entity1.setParametersUuid(parametersUuid); + entity1.setModificationUuids(modificationUuids); + entity1.setContingencies(contingencies); + + SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); + entity2.setId(uuid2); + entity2.setParametersUuid(parametersUuid); + entity2.setModificationUuids(modificationUuids); + entity2.setContingencies(contingencies); + + 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(3); + assertThat(comparison.differences()).allMatch(ProcessConfigFieldComparison::identical); + } + + @Test + void compareProcessConfigsShouldReturnDifferencesWhenModificationsAreDifferent() { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + UUID parametersUuid = UUID.randomUUID(); + List modificationUuids1 = List.of(UUID.randomUUID(), UUID.randomUUID()); + List modificationUuids2 = List.of(UUID.randomUUID(), UUID.randomUUID()); + List contingencies = List.of("contingency1", "contingency2"); + + SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); + entity1.setId(uuid1); + entity1.setParametersUuid(parametersUuid); + entity1.setModificationUuids(modificationUuids1); + entity1.setContingencies(contingencies); + + SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); + entity2.setId(uuid2); + entity2.setParametersUuid(parametersUuid); + entity2.setModificationUuids(modificationUuids2); + entity2.setContingencies(contingencies); + + 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(); + 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); + } + + @Test + void compareProcessConfigsShouldReturnDifferencesWhenParametersAreDifferent() { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + UUID parametersUuid1 = UUID.randomUUID(); + UUID parametersUuid2 = UUID.randomUUID(); + List modificationUuids = List.of(UUID.randomUUID()); + List contingencies = List.of("contingency1"); + + SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); + entity1.setId(uuid1); + entity1.setParametersUuid(parametersUuid1); + entity1.setModificationUuids(modificationUuids); + entity1.setContingencies(contingencies); + + SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); + entity2.setId(uuid2); + entity2.setParametersUuid(parametersUuid2); + entity2.setModificationUuids(modificationUuids); + entity2.setContingencies(contingencies); + + 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 parametersComparison = comparison.differences().stream() + .filter(d -> "securityAnalysisParameters".equals(d.field())) + .findFirst() + .orElseThrow(); + assertThat(parametersComparison.identical()).isFalse(); + assertThat(parametersComparison.value1()).isEqualTo(parametersUuid1); + assertThat(parametersComparison.value2()).isEqualTo(parametersUuid2); + } + + @Test + void compareProcessConfigsShouldReturnDifferencesWhenContingenciesAreDifferent() { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + UUID parametersUuid = UUID.randomUUID(); + List modificationUuids = List.of(UUID.randomUUID()); + List contingencies1 = List.of("contingency1", "contingency2"); + List contingencies2 = List.of("contingency1", "contingency3"); + + SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); + entity1.setId(uuid1); + entity1.setParametersUuid(parametersUuid); + entity1.setModificationUuids(modificationUuids); + entity1.setContingencies(contingencies1); + + SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); + entity2.setId(uuid2); + entity2.setParametersUuid(parametersUuid); + entity2.setModificationUuids(modificationUuids); + entity2.setContingencies(contingencies2); + + 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 contingenciesComparison = comparison.differences().stream() + .filter(d -> "contingencies".equals(d.field())) + .findFirst() + .orElseThrow(); + assertThat(contingenciesComparison.identical()).isFalse(); + assertThat(contingenciesComparison.value1()).isEqualTo(contingencies1); + assertThat(contingenciesComparison.value2()).isEqualTo(contingencies2); + } + + @Test + void compareProcessConfigsShouldDetectOrderDifferenceInModifications() { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + UUID parametersUuid = UUID.randomUUID(); + UUID mod1 = UUID.randomUUID(); + UUID mod2 = UUID.randomUUID(); + List modificationUuids1 = List.of(mod1, mod2); + List modificationUuids2 = List.of(mod2, mod1); // Different order + List contingencies = List.of("contingency1"); + + SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); + entity1.setId(uuid1); + entity1.setParametersUuid(parametersUuid); + entity1.setModificationUuids(modificationUuids1); + entity1.setContingencies(contingencies); + + SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); + entity2.setId(uuid2); + entity2.setParametersUuid(parametersUuid); + entity2.setModificationUuids(modificationUuids2); + entity2.setContingencies(contingencies); + + 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(); + } + + @Test + void compareProcessConfigsShouldReturnEmptyWhenOnConfigNotFound() { + UUID uuid1 = UUID.randomUUID(); + UUID uuid2 = UUID.randomUUID(); + + when(processConfigRepository.findById(uuid1)).thenReturn(Optional.empty()); + when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(new SecurityAnalysisConfigEntity())); + + Optional result = processConfigService.compareProcessConfigs(uuid1, uuid2); + + assertThat(result).isEmpty(); + } } From e031027ebcc3e6f0c948bd55e8f6b6021218d041 Mon Sep 17 00:00:00 2001 From: Franck LECUYER Date: Wed, 25 Feb 2026 16:09:15 +0100 Subject: [PATCH 2/6] Fix typo Signed-off-by: Franck LECUYER --- .../monitor/server/services/ProcessConfigServiceTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java index 20e0a4ee..95f43cd1 100644 --- a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java +++ b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java @@ -400,7 +400,7 @@ void compareProcessConfigsShouldDetectOrderDifferenceInModifications() { } @Test - void compareProcessConfigsShouldReturnEmptyWhenOnConfigNotFound() { + void compareProcessConfigsShouldReturnEmptyWhenOneConfigNotFound() { UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); From 4a033592c5201a4d1fd3d4cd162b6d699b68b621 Mon Sep 17 00:00:00 2001 From: Franck LECUYER Date: Wed, 25 Feb 2026 16:23:37 +0100 Subject: [PATCH 3/6] Fix reliability rating Signed-off-by: Franck LECUYER --- .../monitor/server/controllers/ProcessConfigController.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) 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 36695f84..869e74d8 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 @@ -16,6 +16,7 @@ import org.gridsuite.monitor.commons.ProcessType; import org.gridsuite.monitor.server.dto.ProcessConfigComparison; import org.gridsuite.monitor.server.services.ProcessConfigService; +import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.DeleteMapping; @@ -113,7 +114,7 @@ public ResponseEntity compareProcessConfigs( try { Optional comparison = processConfigService.compareProcessConfigs(uuid1, uuid2); - return comparison.map(c -> ResponseEntity.ok().body(c)).orElseGet(() -> ResponseEntity.notFound().build()); + return comparison.map(c -> ResponseEntity.status(HttpStatus.OK).body(c)).orElseGet(() -> ResponseEntity.status(HttpStatus.NOT_FOUND).build()); } catch (IllegalArgumentException e) { return ResponseEntity.badRequest().build(); } From d6caa1fe8b5f1951671765d3e716fa6c8d2497c1 Mon Sep 17 00:00:00 2001 From: Franck LECUYER Date: Wed, 11 Mar 2026 17:29:25 +0100 Subject: [PATCH 4/6] Changes after review Signed-off-by: Franck LECUYER --- .../server/controllers/ProcessConfigController.java | 12 +++--------- .../controllers/ProcessConfigControllerTest.java | 9 +++++---- 2 files changed, 8 insertions(+), 13 deletions(-) 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 869e74d8..37f76940 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 @@ -106,17 +106,11 @@ public ResponseEntity> getProcessConfigs( @Operation(summary = "Compare 2 process configs") @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "Comparison result returned"), - @ApiResponse(responseCode = "404", description = "One or both process configs are not found"), - @ApiResponse(responseCode = "400", description = "Process configs are of different types")}) + @ApiResponse(responseCode = "404", description = "One or both process configs are not found")}) public ResponseEntity compareProcessConfigs( @Parameter(description = "First process config UUID") @RequestParam("uuid1") UUID uuid1, @Parameter(description = "Second process config UUID") @RequestParam("uuid2") UUID uuid2) { - - 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 (IllegalArgumentException e) { - return ResponseEntity.badRequest().build(); - } + Optional comparison = processConfigService.compareProcessConfigs(uuid1, uuid2); + return comparison.map(c -> ResponseEntity.status(HttpStatus.OK).body(c)).orElseGet(() -> ResponseEntity.status(HttpStatus.NOT_FOUND).build()); } } 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 53a97301..fc96fb27 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 @@ -7,6 +7,7 @@ package org.gridsuite.monitor.server.controllers; import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.servlet.ServletException; import org.gridsuite.monitor.commons.PersistedProcessConfig; import org.gridsuite.monitor.commons.ProcessConfig; import org.gridsuite.monitor.commons.ProcessType; @@ -25,6 +26,7 @@ import java.util.Optional; import java.util.UUID; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -304,18 +306,17 @@ void compareProcessConfigsShouldReturn404WhenConfigNotFound() throws Exception { } @Test - void compareProcessConfigsShouldReturn400WhenDifferentTypes() throws Exception { + void compareProcessConfigsShouldThrowExceptionWhenDifferentTypes() throws Exception { UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); when(processConfigService.compareProcessConfigs(any(), any())) .thenThrow(new IllegalArgumentException("Cannot compare different process config types")); - mockMvc.perform(get("/v1/process-configs/compare") + assertThrows(ServletException.class, () -> mockMvc.perform(get("/v1/process-configs/compare") .param("uuid1", uuid1.toString()) .param("uuid2", uuid2.toString()) - .contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isBadRequest()); + .contentType(MediaType.APPLICATION_JSON))); verify(processConfigService).compareProcessConfigs(uuid1, uuid2); } From 8abc325ccddf0a4a95f14b106cfb2af51216da17 Mon Sep 17 00:00:00 2001 From: Franck LECUYER Date: Wed, 11 Mar 2026 18:31:18 +0100 Subject: [PATCH 5/6] Fix one sonar issue Signed-off-by: Franck LECUYER --- .../monitor/server/controllers/ProcessConfigControllerTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 fc96fb27..c2a5c83f 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 @@ -306,7 +306,7 @@ void compareProcessConfigsShouldReturn404WhenConfigNotFound() throws Exception { } @Test - void compareProcessConfigsShouldThrowExceptionWhenDifferentTypes() throws Exception { + void compareProcessConfigsShouldThrowExceptionWhenDifferentTypes() { UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); From 71a0e7253c24ab491e180440c2988b8c8b53bb62 Mon Sep 17 00:00:00 2001 From: Franck LECUYER Date: Thu, 12 Mar 2026 10:26:52 +0100 Subject: [PATCH 6/6] Code adaptations Signed-off-by: Franck LECUYER --- .../controllers/ProcessConfigController.java | 12 ++- .../server/services/ProcessConfigService.java | 22 ++--- .../ProcessConfigControllerTest.java | 16 ++-- .../services/ProcessConfigServiceTest.java | 93 ++++++------------- 4 files changed, 55 insertions(+), 88 deletions(-) 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 37f76940..869e74d8 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 @@ -106,11 +106,17 @@ public ResponseEntity> getProcessConfigs( @Operation(summary = "Compare 2 process configs") @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "Comparison result returned"), - @ApiResponse(responseCode = "404", description = "One or both process configs are not found")}) + @ApiResponse(responseCode = "404", description = "One or both process configs are not found"), + @ApiResponse(responseCode = "400", description = "Process configs are of different types")}) 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 (IllegalArgumentException e) { + return ResponseEntity.badRequest().build(); + } } } diff --git a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/ProcessConfigService.java b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/ProcessConfigService.java index c7e5b8d3..01ea94ad 100644 --- a/monitor-server/src/main/java/org/gridsuite/monitor/server/services/ProcessConfigService.java +++ b/monitor-server/src/main/java/org/gridsuite/monitor/server/services/ProcessConfigService.java @@ -129,22 +129,22 @@ private List compareSecurityAnalysisConfigs(Securi config2.modificationUuids() )); - // Compare parameters - boolean parametersIdentical = Objects.equals(config1.parametersUuid(), config2.parametersUuid()); + // Compare security analysis parameters + boolean securityAnalysisParametersIdentical = Objects.equals(config1.securityAnalysisParametersUuid(), config2.securityAnalysisParametersUuid()); differences.add(new ProcessConfigFieldComparison( "securityAnalysisParameters", - parametersIdentical, - config1.parametersUuid(), - config2.parametersUuid() + securityAnalysisParametersIdentical, + config1.securityAnalysisParametersUuid(), + config2.securityAnalysisParametersUuid() )); - // Compare contingencies - boolean contingenciesIdentical = Objects.equals(config1.contingencies(), config2.contingencies()); + // Compare loadflow parameters + boolean loadflowParametersIdentical = Objects.equals(config1.loadflowParametersUuid(), config2.loadflowParametersUuid()); differences.add(new ProcessConfigFieldComparison( - "contingencies", - contingenciesIdentical, - config1.contingencies(), - config2.contingencies() + "loadflowParameters", + loadflowParametersIdentical, + config1.loadflowParametersUuid(), + config2.loadflowParametersUuid() )); return differences; 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 1f5ac957..a84ca061 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 @@ -7,7 +7,6 @@ package org.gridsuite.monitor.server.controllers; import com.fasterxml.jackson.databind.ObjectMapper; -import jakarta.servlet.ServletException; import org.gridsuite.monitor.commons.PersistedProcessConfig; import org.gridsuite.monitor.commons.ProcessConfig; import org.gridsuite.monitor.commons.ProcessType; @@ -26,7 +25,6 @@ import java.util.Optional; import java.util.UUID; -import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -226,7 +224,8 @@ void getAllSecurityAnalysisConfigsNotFound() throws Exception { void compareProcessConfigsShouldReturnComparisonResult() throws Exception { UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); - UUID parametersUuid = UUID.randomUUID(); + UUID securityAnalysisParametersUuid = UUID.randomUUID(); + UUID loadflowParametersUuid = UUID.randomUUID(); List modificationUuids = List.of(UUID.randomUUID()); ProcessConfigComparison comparison = new ProcessConfigComparison( @@ -235,8 +234,8 @@ void compareProcessConfigsShouldReturnComparisonResult() throws Exception { true, List.of( new ProcessConfigFieldComparison("modifications", true, modificationUuids, modificationUuids), - new ProcessConfigFieldComparison("securityAnalysisParameters", true, parametersUuid, parametersUuid), - new ProcessConfigFieldComparison("contingencies", true, List.of("contingency1"), List.of("contingency1")) + new ProcessConfigFieldComparison("securityAnalysisParameters", true, securityAnalysisParametersUuid, securityAnalysisParametersUuid), + new ProcessConfigFieldComparison("loadflowParameters", true, loadflowParametersUuid, loadflowParametersUuid) ) ); @@ -307,17 +306,18 @@ void compareProcessConfigsShouldReturn404WhenConfigNotFound() throws Exception { } @Test - void compareProcessConfigsShouldThrowExceptionWhenDifferentTypes() { + void compareProcessConfigsShouldReturn400WhenDifferentTypes() throws Exception { UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); when(processConfigService.compareProcessConfigs(any(), any())) .thenThrow(new IllegalArgumentException("Cannot compare different process config types")); - assertThrows(ServletException.class, () -> mockMvc.perform(get("/v1/process-configs/compare") + mockMvc.perform(get("/v1/process-configs/compare") .param("uuid1", uuid1.toString()) .param("uuid2", uuid2.toString()) - .contentType(MediaType.APPLICATION_JSON))); + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isBadRequest()); verify(processConfigService).compareProcessConfigs(uuid1, uuid2); } diff --git a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java index 740c6484..5a144571 100644 --- a/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java +++ b/monitor-server/src/test/java/org/gridsuite/monitor/server/services/ProcessConfigServiceTest.java @@ -211,21 +211,21 @@ void getSecurityAnalysisConfigsNotFound() { void compareProcessConfigsShouldReturnIdenticalWhenConfigsAreEqual() { UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); - UUID parametersUuid = UUID.randomUUID(); + UUID securityAnalysisParametersUuid = UUID.randomUUID(); + UUID loadflowParametersUuid = UUID.randomUUID(); List modificationUuids = List.of(UUID.randomUUID(), UUID.randomUUID()); - List contingencies = List.of("contingency1", "contingency2"); SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); entity1.setId(uuid1); - entity1.setParametersUuid(parametersUuid); + entity1.setSecurityAnalysisParametersUuid(securityAnalysisParametersUuid); entity1.setModificationUuids(modificationUuids); - entity1.setContingencies(contingencies); + entity1.setLoadflowParametersUuid(loadflowParametersUuid); SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); entity2.setId(uuid2); - entity2.setParametersUuid(parametersUuid); + entity2.setSecurityAnalysisParametersUuid(securityAnalysisParametersUuid); entity2.setModificationUuids(modificationUuids); - entity2.setContingencies(contingencies); + entity2.setLoadflowParametersUuid(loadflowParametersUuid); when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); @@ -245,22 +245,22 @@ void compareProcessConfigsShouldReturnIdenticalWhenConfigsAreEqual() { void compareProcessConfigsShouldReturnDifferencesWhenModificationsAreDifferent() { UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); - UUID parametersUuid = 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()); - List contingencies = List.of("contingency1", "contingency2"); SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); entity1.setId(uuid1); - entity1.setParametersUuid(parametersUuid); + entity1.setSecurityAnalysisParametersUuid(securityAnalysisParametersUuid); entity1.setModificationUuids(modificationUuids1); - entity1.setContingencies(contingencies); + entity1.setLoadflowParametersUuid(loadflowParametersUuid); SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); entity2.setId(uuid2); - entity2.setParametersUuid(parametersUuid); + entity2.setSecurityAnalysisParametersUuid(securityAnalysisParametersUuid); entity2.setModificationUuids(modificationUuids2); - entity2.setContingencies(contingencies); + entity2.setLoadflowParametersUuid(loadflowParametersUuid); when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); @@ -285,22 +285,22 @@ void compareProcessConfigsShouldReturnDifferencesWhenModificationsAreDifferent() void compareProcessConfigsShouldReturnDifferencesWhenParametersAreDifferent() { UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); - UUID parametersUuid1 = UUID.randomUUID(); - UUID parametersUuid2 = UUID.randomUUID(); + UUID securityAnalysisParametersUuid1 = UUID.randomUUID(); + UUID securityAnalysisParametersUuid2 = UUID.randomUUID(); + UUID loadflowParametersUuid = UUID.randomUUID(); List modificationUuids = List.of(UUID.randomUUID()); - List contingencies = List.of("contingency1"); SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); entity1.setId(uuid1); - entity1.setParametersUuid(parametersUuid1); + entity1.setSecurityAnalysisParametersUuid(securityAnalysisParametersUuid1); entity1.setModificationUuids(modificationUuids); - entity1.setContingencies(contingencies); + entity1.setLoadflowParametersUuid(loadflowParametersUuid); SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); entity2.setId(uuid2); - entity2.setParametersUuid(parametersUuid2); + entity2.setSecurityAnalysisParametersUuid(securityAnalysisParametersUuid2); entity2.setModificationUuids(modificationUuids); - entity2.setContingencies(contingencies); + entity2.setLoadflowParametersUuid(loadflowParametersUuid); when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2)); @@ -316,71 +316,32 @@ void compareProcessConfigsShouldReturnDifferencesWhenParametersAreDifferent() { .findFirst() .orElseThrow(); assertThat(parametersComparison.identical()).isFalse(); - assertThat(parametersComparison.value1()).isEqualTo(parametersUuid1); - assertThat(parametersComparison.value2()).isEqualTo(parametersUuid2); - } - - @Test - void compareProcessConfigsShouldReturnDifferencesWhenContingenciesAreDifferent() { - UUID uuid1 = UUID.randomUUID(); - UUID uuid2 = UUID.randomUUID(); - UUID parametersUuid = UUID.randomUUID(); - List modificationUuids = List.of(UUID.randomUUID()); - List contingencies1 = List.of("contingency1", "contingency2"); - List contingencies2 = List.of("contingency1", "contingency3"); - - SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); - entity1.setId(uuid1); - entity1.setParametersUuid(parametersUuid); - entity1.setModificationUuids(modificationUuids); - entity1.setContingencies(contingencies1); - - SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); - entity2.setId(uuid2); - entity2.setParametersUuid(parametersUuid); - entity2.setModificationUuids(modificationUuids); - entity2.setContingencies(contingencies2); - - 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 contingenciesComparison = comparison.differences().stream() - .filter(d -> "contingencies".equals(d.field())) - .findFirst() - .orElseThrow(); - assertThat(contingenciesComparison.identical()).isFalse(); - assertThat(contingenciesComparison.value1()).isEqualTo(contingencies1); - assertThat(contingenciesComparison.value2()).isEqualTo(contingencies2); + assertThat(parametersComparison.value1()).isEqualTo(securityAnalysisParametersUuid1); + assertThat(parametersComparison.value2()).isEqualTo(securityAnalysisParametersUuid2); } @Test void compareProcessConfigsShouldDetectOrderDifferenceInModifications() { UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); - UUID parametersUuid = 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 - List contingencies = List.of("contingency1"); SecurityAnalysisConfigEntity entity1 = new SecurityAnalysisConfigEntity(); entity1.setId(uuid1); - entity1.setParametersUuid(parametersUuid); + entity1.setSecurityAnalysisParametersUuid(securityAnalysisParametersUuid); entity1.setModificationUuids(modificationUuids1); - entity1.setContingencies(contingencies); + entity1.setLoadflowParametersUuid(loadflowParametersUuid); SecurityAnalysisConfigEntity entity2 = new SecurityAnalysisConfigEntity(); entity2.setId(uuid2); - entity2.setParametersUuid(parametersUuid); + entity2.setSecurityAnalysisParametersUuid(securityAnalysisParametersUuid); entity2.setModificationUuids(modificationUuids2); - entity2.setContingencies(contingencies); + entity2.setLoadflowParametersUuid(loadflowParametersUuid); when(processConfigRepository.findById(uuid1)).thenReturn(Optional.of(entity1)); when(processConfigRepository.findById(uuid2)).thenReturn(Optional.of(entity2));