diff --git a/src/main/java/org/gridsuite/study/server/controller/StudyController.java b/src/main/java/org/gridsuite/study/server/controller/StudyController.java index b3f4be47c1..5793290df2 100644 --- a/src/main/java/org/gridsuite/study/server/controller/StudyController.java +++ b/src/main/java/org/gridsuite/study/server/controller/StudyController.java @@ -20,6 +20,8 @@ import org.gridsuite.filter.globalfilter.GlobalFilter; import org.gridsuite.filter.utils.EquipmentType; import org.gridsuite.study.server.StudyApi; +import org.gridsuite.study.server.StudyConstants.CompositeModificationsActionType; +import org.gridsuite.study.server.StudyConstants.ModificationsActionType; import org.gridsuite.study.server.dto.*; import org.gridsuite.study.server.dto.computation.LoadFlowComputationInfos; import org.gridsuite.study.server.dto.dynamicmargincalculation.DynamicMarginCalculationStatus; @@ -897,8 +899,8 @@ public ResponseEntity getShortCircuitAnalysisStatus(@Parameter(descripti @PathVariable("rootNetworkUuid") UUID rootNetworkUuid, @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid, @Parameter(description = "type") @RequestParam(value = "type", required = false, defaultValue = "ALL_BUSES") ShortcircuitAnalysisType type) { - String result = rootNetworkNodeInfoService.getShortCircuitAnalysisStatus(nodeUuid, rootNetworkUuid, type); - return result != null ? ResponseEntity.ok().body(result) : + ShortCircuitAnalysisStatus result = rootNetworkNodeInfoService.getShortCircuitAnalysisStatus(nodeUuid, rootNetworkUuid, type); + return result != null ? ResponseEntity.ok().body(result.name()) : ResponseEntity.noContent().build(); } @@ -990,8 +992,8 @@ public ResponseEntity getVoltageInitResult(@Parameter(description = "stu public ResponseEntity getVoltageInitStatus(@Parameter(description = "Study UUID") @PathVariable("studyUuid") UUID studyUuid, @Parameter(description = "rootNetworkUuid") @PathVariable("rootNetworkUuid") UUID rootNetworkUuid, @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid) { - String result = rootNetworkNodeInfoService.getVoltageInitStatus(nodeUuid, rootNetworkUuid); - return result != null ? ResponseEntity.ok().body(result) : + VoltageInitStatus result = rootNetworkNodeInfoService.getVoltageInitStatus(nodeUuid, rootNetworkUuid); + return result != null ? ResponseEntity.ok().body(result.name()) : ResponseEntity.noContent().build(); } @@ -1830,8 +1832,8 @@ public ResponseEntity getSensitivityAnalysisFilterOptions( public ResponseEntity getSensitivityAnalysisStatus(@Parameter(description = "Study UUID") @PathVariable("studyUuid") UUID studyUuid, @Parameter(description = "rootNetworkUuid") @PathVariable("rootNetworkUuid") UUID rootNetworkUuid, @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid) { - String result = rootNetworkNodeInfoService.getSensitivityAnalysisStatus(nodeUuid, rootNetworkUuid); - return result != null ? ResponseEntity.ok().body(result) : + SensitivityAnalysisStatus result = rootNetworkNodeInfoService.getSensitivityAnalysisStatus(nodeUuid, rootNetworkUuid); + return result != null ? ResponseEntity.ok().body(result.name()) : ResponseEntity.noContent().build(); } @@ -2409,8 +2411,8 @@ public ResponseEntity getStateEstimationResult(@Parameter(description = public ResponseEntity getStateEstimationStatus(@Parameter(description = "Study UUID") @PathVariable("studyUuid") UUID studyUuid, @PathVariable("rootNetworkUuid") UUID rootNetworkUuid, @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid) { - String status = rootNetworkNodeInfoService.getStateEstimationStatus(nodeUuid, rootNetworkUuid); - return status != null ? ResponseEntity.ok().body(status) : ResponseEntity.noContent().build(); + StateEstimationStatus status = rootNetworkNodeInfoService.getStateEstimationStatus(nodeUuid, rootNetworkUuid); + return status != null ? ResponseEntity.ok().body(status.name()) : ResponseEntity.noContent().build(); } @GetMapping(value = "/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/pcc-min/status") @@ -2421,8 +2423,8 @@ public ResponseEntity getStateEstimationStatus(@Parameter(description = public ResponseEntity getPccMinStatus(@Parameter(description = "Study UUID") @PathVariable("studyUuid") UUID studyUuid, @PathVariable("rootNetworkUuid") UUID rootNetworkUuid, @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid) { - String status = rootNetworkNodeInfoService.getPccMinStatus(nodeUuid, rootNetworkUuid); - return status != null ? ResponseEntity.ok().body(status) : ResponseEntity.noContent().build(); + PccMinStatus status = rootNetworkNodeInfoService.getPccMinStatus(nodeUuid, rootNetworkUuid); + return status != null ? ResponseEntity.ok().body(status.name()) : ResponseEntity.noContent().build(); } @PutMapping(value = "/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/state-estimation/stop") diff --git a/src/main/java/org/gridsuite/study/server/dto/ShortCircuitStatus.java b/src/main/java/org/gridsuite/study/server/dto/ShortCircuitAnalysisStatus.java similarity index 91% rename from src/main/java/org/gridsuite/study/server/dto/ShortCircuitStatus.java rename to src/main/java/org/gridsuite/study/server/dto/ShortCircuitAnalysisStatus.java index 524d7a1903..7204334fb8 100644 --- a/src/main/java/org/gridsuite/study/server/dto/ShortCircuitStatus.java +++ b/src/main/java/org/gridsuite/study/server/dto/ShortCircuitAnalysisStatus.java @@ -9,7 +9,7 @@ /** * @author Etienne Homer */ -public enum ShortCircuitStatus { +public enum ShortCircuitAnalysisStatus { NOT_DONE, RUNNING, COMPLETED diff --git a/src/main/java/org/gridsuite/study/server/repository/rootnetwork/RootNetworkNodeInfoRepository.java b/src/main/java/org/gridsuite/study/server/repository/rootnetwork/RootNetworkNodeInfoRepository.java index 6e35daca37..01f20531d6 100644 --- a/src/main/java/org/gridsuite/study/server/repository/rootnetwork/RootNetworkNodeInfoRepository.java +++ b/src/main/java/org/gridsuite/study/server/repository/rootnetwork/RootNetworkNodeInfoRepository.java @@ -51,6 +51,8 @@ public interface RootNetworkNodeInfoRepository extends JpaRepository findAllWithRootNetworkByNodeInfoId(UUID nodeInfoId); + List findAllByNodeInfoIdInAndRootNetworkId(List nodeInfoIds, UUID rootNetworkUuid); + Optional findByNodeInfoIdAndRootNetworkId(UUID nodeInfoId, UUID rootNetworkUuid); @EntityGraph(attributePaths = {"modificationsUuidsToExclude"}, type = EntityGraph.EntityGraphType.LOAD) diff --git a/src/main/java/org/gridsuite/study/server/service/LoadFlowService.java b/src/main/java/org/gridsuite/study/server/service/LoadFlowService.java index 57355c2d5a..ee085a7928 100644 --- a/src/main/java/org/gridsuite/study/server/service/LoadFlowService.java +++ b/src/main/java/org/gridsuite/study/server/service/LoadFlowService.java @@ -21,6 +21,7 @@ import org.springframework.http.*; import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; @@ -28,8 +29,11 @@ import java.net.URLEncoder; import java.nio.charset.StandardCharsets; import java.util.ArrayList; +import java.util.HashSet; import java.util.List; +import java.util.Map; import java.util.Objects; +import java.util.Set; import java.util.UUID; import static org.gridsuite.study.server.StudyConstants.*; @@ -137,11 +141,29 @@ public LoadFlowStatus getLoadFlowStatus(UUID resultUuid) { if (resultUuid == null) { return null; } + return getLoadFlowStatuses(List.of(resultUuid)).get(resultUuid); + } - UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromPath(DELIMITER + LOADFLOW_API_VERSION + "/results/{resultUuid}/status"); - String path = uriComponentsBuilder.buildAndExpand(resultUuid).toUriString(); + public Map getLoadFlowStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } + + UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromPath(DELIMITER + LOADFLOW_API_VERSION + "/results/statuses"); + String path = uriComponentsBuilder.toUriString(); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); - return restTemplate.getForObject(loadFlowServerBaseUri + path, LoadFlowStatus.class); + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); + + Map statuses = restTemplate.exchange( + loadFlowServerBaseUri + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } public void stopLoadFlow(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID resultUuid, String userId) { @@ -192,9 +214,10 @@ public void setLoadFlowServerBaseUri(String loadFlowServerBaseUri) { this.loadFlowServerBaseUri = loadFlowServerBaseUri; } - public void assertLoadFlowNotRunning(UUID resultUuid) { - LoadFlowStatus loadFlowStatus = getLoadFlowStatus(resultUuid); - if (LoadFlowStatus.RUNNING.equals(loadFlowStatus)) { + public void assertNoLoadFlowRunning(List resultUuids) { + Map loadFlowStatuses = getLoadFlowStatuses(resultUuids); + Set values = new HashSet<>(loadFlowStatuses.values()); + if (values.contains(LoadFlowStatus.RUNNING)) { throw new StudyException(COMPUTATION_RUNNING); } } diff --git a/src/main/java/org/gridsuite/study/server/service/PccMinService.java b/src/main/java/org/gridsuite/study/server/service/PccMinService.java index af3d071ca7..e9e66dacf6 100644 --- a/src/main/java/org/gridsuite/study/server/service/PccMinService.java +++ b/src/main/java/org/gridsuite/study/server/service/PccMinService.java @@ -19,10 +19,12 @@ import org.gridsuite.study.server.utils.ResultParameters; import org.gridsuite.study.server.utils.StudyUtils; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.core.ParameterizedTypeReference; import org.springframework.data.domain.Sort; import org.springframework.http.*; import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; @@ -30,8 +32,11 @@ import java.net.URI; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; +import java.util.HashSet; import java.util.List; +import java.util.Map; import java.util.Objects; +import java.util.Set; import java.util.UUID; import org.springframework.data.domain.Pageable; @@ -119,14 +124,33 @@ public void stopPccMin(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID restTemplate.put(pccMinServerBaseUri + path, Void.class); } - public String getPccMinStatus(UUID resultUuid) { + public PccMinStatus getPccMinStatus(UUID resultUuid) { if (resultUuid == null) { return null; } + return getPccMinStatuses(List.of(resultUuid)).get(resultUuid); + } + + public Map getPccMinStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } String path = UriComponentsBuilder - .fromPath(PCC_MIN_URI + DELIMITER + "results/{resultUuid}/status") - .buildAndExpand(resultUuid).toUriString(); - return restTemplate.getForObject(pccMinServerBaseUri + path, String.class); + .fromPath(DELIMITER + PCC_MIN_API_VERSION + "/results/statuses") + .toUriString(); + + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); + Map statuses = restTemplate.exchange( + pccMinServerBaseUri + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } public void deletePccMinResults(List resultsUuids) { @@ -143,9 +167,10 @@ public Integer getPccMinResultsCount() { return restTemplate.getForObject(pccMinServerBaseUri + path, Integer.class); } - public void assertPccMinNotRunning(UUID resultUuid) { - String status = getPccMinStatus(resultUuid); - if (PccMinStatus.RUNNING.name().equals(status)) { + public void assertNoPccMinRunning(List resultUuids) { + Map pccMinStatuses = getPccMinStatuses(resultUuids); + Set values = new HashSet<>(pccMinStatuses.values()); + if (values.contains(PccMinStatus.RUNNING)) { throw new StudyException(COMPUTATION_RUNNING); } } diff --git a/src/main/java/org/gridsuite/study/server/service/RootNetworkNodeInfoService.java b/src/main/java/org/gridsuite/study/server/service/RootNetworkNodeInfoService.java index 002b34bafe..a085e9e5c7 100644 --- a/src/main/java/org/gridsuite/study/server/service/RootNetworkNodeInfoService.java +++ b/src/main/java/org/gridsuite/study/server/service/RootNetworkNodeInfoService.java @@ -10,6 +10,7 @@ import lombok.NonNull; import org.apache.commons.lang3.StringUtils; import org.gridsuite.study.server.dto.*; +import org.gridsuite.study.server.dto.InvalidateNodeTreeParameters.ComputationsInvalidationMode; import org.gridsuite.study.server.dto.computation.LoadFlowComputationInfos; import org.gridsuite.study.server.dto.dynamicmargincalculation.DynamicMarginCalculationStatus; import org.gridsuite.study.server.dto.dynamicsecurityanalysis.DynamicSecurityAnalysisStatus; @@ -449,6 +450,10 @@ public Optional getRootNetworkNodeInfo(UUID nodeUuid, return rootNetworkNodeInfoRepository.findByNodeInfoIdAndRootNetworkId(nodeUuid, rootNetworkUuid); } + public List getRootNetworkNodeInfos(List nodeUuids, UUID rootNetworkUuid) { + return rootNetworkNodeInfoRepository.findAllByNodeInfoIdInAndRootNetworkId(nodeUuids, rootNetworkUuid); + } + private static UUID getComputationResultUuid(RootNetworkNodeInfoEntity rootNetworkNodeInfoEntity, ComputationType computationType) { return switch (computationType) { case LOAD_FLOW -> rootNetworkNodeInfoEntity.getLoadFlowResultUuid(); @@ -470,6 +475,14 @@ public UUID getComputationResultUuid(UUID nodeUuid, UUID rootNetworkUuid, Comput return rootNetworkNodeInfoEntityOpt.map(rootNetworkNodeInfoEntity -> getComputationResultUuid(rootNetworkNodeInfoEntity, computationType)).orElse(null); } + public List getComputationResultUuids(List nodeUuids, UUID rootNetworkUuid, ComputationType computationType) { + List rootNetworkNodeInfoEntities = getRootNetworkNodeInfos(nodeUuids, rootNetworkUuid); + return rootNetworkNodeInfoEntities.stream() + .map(rootNetworkNodeInfoEntity -> getComputationResultUuid(rootNetworkNodeInfoEntity, computationType)) + .filter(Objects::nonNull) + .toList(); + } + public List getComputationResultUuids(UUID studyUuid, ComputationType computationType) { return rootNetworkNodeInfoRepository.findAllByRootNetworkStudyId(studyUuid).stream() .map(rootNetworkNodeInfoEntity -> getComputationResultUuid(rootNetworkNodeInfoEntity, computationType)) @@ -656,17 +669,20 @@ private List getReportUuids(RootNetworkNodeInfo rootNetworkNodeInfo) { .toList(); } - public void assertComputationNotRunning(UUID nodeUuid, UUID rootNetworkUuid) { - loadFlowService.assertLoadFlowNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, LOAD_FLOW)); - securityAnalysisService.assertSecurityAnalysisNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, SECURITY_ANALYSIS)); - dynamicSimulationService.assertDynamicSimulationNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, DYNAMIC_SIMULATION)); - dynamicSecurityAnalysisService.assertDynamicSecurityAnalysisNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, DYNAMIC_SECURITY_ANALYSIS)); - dynamicMarginCalculationService.assertDynamicMarginCalculationNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, DYNAMIC_MARGIN_CALCULATION)); - sensitivityAnalysisService.assertSensitivityAnalysisNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, SENSITIVITY_ANALYSIS)); - shortCircuitService.assertShortCircuitAnalysisNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, SHORT_CIRCUIT), getComputationResultUuid(nodeUuid, rootNetworkUuid, SHORT_CIRCUIT_ONE_BUS)); - voltageInitService.assertVoltageInitNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, VOLTAGE_INITIALIZATION)); - stateEstimationService.assertStateEstimationNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, STATE_ESTIMATION)); - pccMinService.assertPccMinNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, PCC_MIN)); + public void assertComputationsNotRunning(List nodeUuids, UUID rootNetworkUuid) { + loadFlowService.assertNoLoadFlowRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, LOAD_FLOW)); + securityAnalysisService.assertNoSecurityAnalysisRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, SECURITY_ANALYSIS)); + dynamicSimulationService.assertNoDynamicSimulationRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, DYNAMIC_SIMULATION)); + dynamicSecurityAnalysisService.assertNoDynamicSecurityAnalysisRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, DYNAMIC_SECURITY_ANALYSIS)); + dynamicMarginCalculationService.assertNoDynamicMarginCalculationRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, DYNAMIC_MARGIN_CALCULATION)); + sensitivityAnalysisService.assertNoSensitivityAnalysisRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, SENSITIVITY_ANALYSIS)); + shortCircuitService.assertNoShortCircuitAnalysisRunning(Stream.concat( + getComputationResultUuids(nodeUuids, rootNetworkUuid, SHORT_CIRCUIT).stream(), + getComputationResultUuids(nodeUuids, rootNetworkUuid, SHORT_CIRCUIT_ONE_BUS).stream() + ).toList()); + voltageInitService.assertNoVoltageInitRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, VOLTAGE_INITIALIZATION)); + stateEstimationService.assertNoStateEstimationRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, STATE_ESTIMATION)); + pccMinService.assertNoPccMinRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, PCC_MIN)); } /*************************** @@ -857,32 +873,32 @@ public DynamicMarginCalculationStatus getDynamicMarginCalculationStatus(UUID nod return dynamicMarginCalculationService.getStatus(resultUuid); } - public String getSensitivityAnalysisStatus(UUID nodeUuid, UUID rootNetworkUuid) { + public SensitivityAnalysisStatus getSensitivityAnalysisStatus(UUID nodeUuid, UUID rootNetworkUuid) { UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid, SENSITIVITY_ANALYSIS); return sensitivityAnalysisService.getSensitivityAnalysisStatus(resultUuid); } @Transactional(readOnly = true) - public String getShortCircuitAnalysisStatus(UUID nodeUuid, UUID rootNetworkUuid, ShortcircuitAnalysisType type) { + public ShortCircuitAnalysisStatus getShortCircuitAnalysisStatus(UUID nodeUuid, UUID rootNetworkUuid, ShortcircuitAnalysisType type) { UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid, type == ShortcircuitAnalysisType.ALL_BUSES ? SHORT_CIRCUIT : SHORT_CIRCUIT_ONE_BUS); return shortCircuitService.getShortCircuitAnalysisStatus(resultUuid); } @Transactional(readOnly = true) - public String getVoltageInitStatus(UUID nodeUuid, UUID rootNetworkUuid) { + public VoltageInitStatus getVoltageInitStatus(UUID nodeUuid, UUID rootNetworkUuid) { UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid, VOLTAGE_INITIALIZATION); return voltageInitService.getVoltageInitStatus(resultUuid); } @Transactional(readOnly = true) - public String getStateEstimationStatus(UUID nodeUuid, UUID rootNetworkUuid) { + public StateEstimationStatus getStateEstimationStatus(UUID nodeUuid, UUID rootNetworkUuid) { UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid, STATE_ESTIMATION); return stateEstimationService.getStateEstimationStatus(resultUuid); } @Transactional(readOnly = true) - public String getPccMinStatus(UUID nodeUuid, UUID rootNetworkUuid) { + public PccMinStatus getPccMinStatus(UUID nodeUuid, UUID rootNetworkUuid) { UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid, PCC_MIN); return pccMinService.getPccMinStatus(resultUuid); } diff --git a/src/main/java/org/gridsuite/study/server/service/SecurityAnalysisService.java b/src/main/java/org/gridsuite/study/server/service/SecurityAnalysisService.java index 4ebf611275..d086f6775b 100644 --- a/src/main/java/org/gridsuite/study/server/service/SecurityAnalysisService.java +++ b/src/main/java/org/gridsuite/study/server/service/SecurityAnalysisService.java @@ -21,19 +21,24 @@ import org.gridsuite.study.server.service.common.ComputationParameters; import org.gridsuite.study.server.service.securityanalysis.SecurityAnalysisResultType; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.core.ParameterizedTypeReference; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; import org.springframework.http.*; import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; import java.io.UncheckedIOException; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; +import java.util.HashSet; import java.util.List; +import java.util.Map; import java.util.Objects; +import java.util.Set; import java.util.UUID; import static org.gridsuite.study.server.StudyConstants.*; @@ -185,16 +190,32 @@ public void stopSecurityAnalysis(UUID studyUuid, UUID nodeUuid, UUID rootNetwork } public SecurityAnalysisStatus getSecurityAnalysisStatus(UUID resultUuid) { - if (resultUuid == null) { return null; } + return getSecurityAnalysisStatuses(List.of(resultUuid)).get(resultUuid); + } - String path = UriComponentsBuilder - .fromPath(DELIMITER + SECURITY_ANALYSIS_API_VERSION + "/results/{resultUuid}/status") - .buildAndExpand(resultUuid).toUriString(); + public Map getSecurityAnalysisStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } - return restTemplate.getForObject(securityAnalysisServerBaseUri + path, SecurityAnalysisStatus.class); + UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromPath(DELIMITER + SECURITY_ANALYSIS_API_VERSION + "/results/statuses"); + String path = uriComponentsBuilder.toUriString(); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); + + Map statuses = restTemplate.exchange( + securityAnalysisServerBaseUri + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } public void deleteSecurityAnalysisResults(List resultsUuids) { @@ -221,9 +242,10 @@ public void invalidateSaStatus(List uuids) { } } - public void assertSecurityAnalysisNotRunning(UUID resultUuid) { - SecurityAnalysisStatus sas = getSecurityAnalysisStatus(resultUuid); - if (sas == SecurityAnalysisStatus.RUNNING) { + public void assertNoSecurityAnalysisRunning(List resultUuids) { + Map securityAnalysisStatuses = getSecurityAnalysisStatuses(resultUuids); + Set values = new HashSet<>(securityAnalysisStatuses.values()); + if (values.contains(SecurityAnalysisStatus.RUNNING)) { throw new StudyException(COMPUTATION_RUNNING); } } diff --git a/src/main/java/org/gridsuite/study/server/service/SensitivityAnalysisService.java b/src/main/java/org/gridsuite/study/server/service/SensitivityAnalysisService.java index 20803e9ec5..748aedd8e3 100644 --- a/src/main/java/org/gridsuite/study/server/service/SensitivityAnalysisService.java +++ b/src/main/java/org/gridsuite/study/server/service/SensitivityAnalysisService.java @@ -21,6 +21,7 @@ import org.springframework.http.*; import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestClientException; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; @@ -169,15 +170,33 @@ public String getSensitivityResultsFilterOptions(UUID resultUuid, String selecto return restTemplate.getForObject(uri, String.class); } - public String getSensitivityAnalysisStatus(UUID resultUuid) { + public SensitivityAnalysisStatus getSensitivityAnalysisStatus(UUID resultUuid) { if (resultUuid == null) { return null; } + return getSensitivityAnalysisStatuses(List.of(resultUuid)).get(resultUuid); + } - String path = UriComponentsBuilder.fromPath(DELIMITER + SENSITIVITY_ANALYSIS_API_VERSION + "/results/{resultUuid}/status") - .buildAndExpand(resultUuid).toUriString(); + public Map getSensitivityAnalysisStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } - return restTemplate.getForObject(sensitivityAnalysisServerBaseUri + path, String.class); + String path = UriComponentsBuilder.fromPath(DELIMITER + SENSITIVITY_ANALYSIS_API_VERSION + "/results/statuses") + .toUriString(); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); + + Map statuses = restTemplate.exchange( + sensitivityAnalysisServerBaseUri + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } public void stopSensitivityAnalysis(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID resultUuid, String userId) { @@ -230,9 +249,10 @@ public Integer getSensitivityAnalysisResultsCount() { return restTemplate.getForObject(sensitivityAnalysisServerBaseUri + path, Integer.class); } - public void assertSensitivityAnalysisNotRunning(UUID resultUuid) { - String sas = getSensitivityAnalysisStatus(resultUuid); - if (SensitivityAnalysisStatus.RUNNING.name().equals(sas)) { + public void assertNoSensitivityAnalysisRunning(List resultUuids) { + Map sensitivityAnalysisStatuses = getSensitivityAnalysisStatuses(resultUuids); + Set values = new HashSet<>(sensitivityAnalysisStatuses.values()); + if (values.contains(SensitivityAnalysisStatus.RUNNING)) { throw new StudyException(COMPUTATION_RUNNING); } } diff --git a/src/main/java/org/gridsuite/study/server/service/StateEstimationService.java b/src/main/java/org/gridsuite/study/server/service/StateEstimationService.java index 65777796cd..17ced28dee 100644 --- a/src/main/java/org/gridsuite/study/server/service/StateEstimationService.java +++ b/src/main/java/org/gridsuite/study/server/service/StateEstimationService.java @@ -19,20 +19,25 @@ import org.gridsuite.study.server.service.common.AbstractComputationService; import org.gridsuite.study.server.service.common.ComputationParameters; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.core.ParameterizedTypeReference; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.MediaType; import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; import java.io.UncheckedIOException; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; +import java.util.HashSet; import java.util.List; +import java.util.Map; import java.util.Objects; +import java.util.Set; import java.util.UUID; import static org.gridsuite.study.server.StudyConstants.*; @@ -123,14 +128,32 @@ public void stopStateEstimation(UUID studyUuid, UUID nodeUuid, UUID rootNetworkU restTemplate.put(stateEstimationServerServerBaseUri + path, Void.class); } - public String getStateEstimationStatus(UUID resultUuid) { + public StateEstimationStatus getStateEstimationStatus(UUID resultUuid) { if (resultUuid == null) { return null; } + return getStateEstimationStatuses(List.of(resultUuid)).get(resultUuid); + } + + public Map getStateEstimationStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } String path = UriComponentsBuilder - .fromPath(DELIMITER + STATE_ESTIMATION_API_VERSION + "/results/{resultUuid}/status") - .buildAndExpand(resultUuid).toUriString(); - return restTemplate.getForObject(stateEstimationServerServerBaseUri + path, String.class); + .fromPath(DELIMITER + STATE_ESTIMATION_API_VERSION + "/results/statuses") + .toUriString(); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); + Map statuses = restTemplate.exchange( + stateEstimationServerServerBaseUri + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } public void deleteStateEstimationResults(List resultsUuids) { @@ -147,9 +170,10 @@ public Integer getStateEstimationResultsCount() { return restTemplate.getForObject(stateEstimationServerServerBaseUri + path, Integer.class); } - public void assertStateEstimationNotRunning(UUID resultUuid) { - String status = getStateEstimationStatus(resultUuid); - if (StateEstimationStatus.RUNNING.name().equals(status)) { + public void assertNoStateEstimationRunning(List resultUuids) { + Map stateEstimationStatuses = getStateEstimationStatuses(resultUuids); + Set values = new HashSet<>(stateEstimationStatuses.values()); + if (values.contains(StateEstimationStatus.RUNNING)) { throw new StudyException(COMPUTATION_RUNNING); } } diff --git a/src/main/java/org/gridsuite/study/server/service/StudyService.java b/src/main/java/org/gridsuite/study/server/service/StudyService.java index b5c6d1f6c4..9d4b6ae68f 100644 --- a/src/main/java/org/gridsuite/study/server/service/StudyService.java +++ b/src/main/java/org/gridsuite/study/server/service/StudyService.java @@ -12,7 +12,6 @@ import com.powsybl.loadflow.LoadFlowParameters; import io.micrometer.common.util.StringUtils; import lombok.NonNull; -import org.apache.commons.collections4.CollectionUtils; import org.gridsuite.filter.globalfilter.GlobalFilter; import org.gridsuite.filter.utils.EquipmentType; import org.gridsuite.study.server.StudyConstants; @@ -67,6 +66,7 @@ import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; +import org.springframework.util.CollectionUtils; import org.springframework.web.util.UriUtils; import java.io.UncheckedIOException; @@ -1082,8 +1082,7 @@ public void assertCanBuildNode(UUID rootNetworkUuid, UUID nodeUuid) { } private void assertNoBuildNoComputationInTree(UUID rootNetworkUuid, List nodesUuids) { - // TODO modify computations endpoints to test multiple uuids - nodesUuids.forEach(uuid -> rootNetworkNodeInfoService.assertComputationNotRunning(uuid, rootNetworkUuid)); + rootNetworkNodeInfoService.assertComputationsNotRunning(nodesUuids, rootNetworkUuid); rootNetworkNodeInfoService.assertNoBuildingNode(rootNetworkUuid, nodesUuids); } diff --git a/src/main/java/org/gridsuite/study/server/service/VoltageInitService.java b/src/main/java/org/gridsuite/study/server/service/VoltageInitService.java index 5f5290f75c..94ac6852b6 100644 --- a/src/main/java/org/gridsuite/study/server/service/VoltageInitService.java +++ b/src/main/java/org/gridsuite/study/server/service/VoltageInitService.java @@ -9,6 +9,7 @@ import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; + import org.apache.commons.lang3.StringUtils; import org.gridsuite.study.server.RemoteServicesProperties; import org.gridsuite.study.server.dto.voltageinit.ContextInfos; @@ -20,17 +21,22 @@ import org.gridsuite.study.server.dto.voltageinit.parameters.VoltageInitParametersInfos; import org.gridsuite.study.server.service.common.AbstractComputationService; import org.gridsuite.study.server.service.common.ComputationParameters; +import org.springframework.core.ParameterizedTypeReference; import org.springframework.http.*; import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; import java.io.UncheckedIOException; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; +import java.util.HashSet; import java.util.List; +import java.util.Map; import java.util.Objects; +import java.util.Set; import java.util.UUID; import static org.gridsuite.study.server.StudyConstants.*; @@ -122,8 +128,31 @@ public String getVoltageInitResult(UUID resultUuid, UUID networkUuid, String var return getVoltageInitResultOrStatus(resultUuid, "", networkUuid, variantId, globalFilters); } - public String getVoltageInitStatus(UUID resultUuid) { - return getVoltageInitResultOrStatus(resultUuid, "/status", null, null, null); + public VoltageInitStatus getVoltageInitStatus(UUID resultUuid) { + if (resultUuid == null) { + return null; + } + return getVoltageInitStatuses(List.of(resultUuid)).get(resultUuid); + } + + public Map getVoltageInitStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } + String path = UriComponentsBuilder.fromPath(DELIMITER + VOLTAGE_INIT_API_VERSION + "/results/statuses").toUriString(); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); + + Map statuses = restTemplate.exchange( + voltageInitServerBaseUri + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } public VoltageInitParametersInfos getVoltageInitParameters(UUID parametersUuid) { @@ -235,9 +264,10 @@ public Integer getVoltageInitResultsCount() { return restTemplate.getForObject(voltageInitServerBaseUri + path, Integer.class); } - public void assertVoltageInitNotRunning(UUID resultUuid) { - String scs = getVoltageInitStatus(resultUuid); - if (VoltageInitStatus.RUNNING.name().equals(scs)) { + public void assertNoVoltageInitRunning(List resultUuids) { + Map voltageInitStatuses = getVoltageInitStatuses(resultUuids); + Set values = new HashSet<>(voltageInitStatuses.values()); + if (values.contains(VoltageInitStatus.RUNNING)) { throw new StudyException(COMPUTATION_RUNNING); } } diff --git a/src/main/java/org/gridsuite/study/server/service/client/dynamicmargincalculation/DynamicMarginCalculationClient.java b/src/main/java/org/gridsuite/study/server/service/client/dynamicmargincalculation/DynamicMarginCalculationClient.java index 919a32dbc9..16038f6c53 100644 --- a/src/main/java/org/gridsuite/study/server/service/client/dynamicmargincalculation/DynamicMarginCalculationClient.java +++ b/src/main/java/org/gridsuite/study/server/service/client/dynamicmargincalculation/DynamicMarginCalculationClient.java @@ -7,23 +7,25 @@ package org.gridsuite.study.server.service.client.dynamicmargincalculation; -import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.StringUtils; import org.gridsuite.study.server.RemoteServicesProperties; import org.gridsuite.study.server.dto.ReportInfos; import org.gridsuite.study.server.dto.dynamicmargincalculation.DynamicMarginCalculationStatus; import org.gridsuite.study.server.service.StudyService; import org.gridsuite.study.server.service.client.AbstractRestClient; +import org.springframework.core.ParameterizedTypeReference; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.MediaType; import org.springframework.lang.NonNull; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; import java.util.List; +import java.util.Map; import java.util.Objects; import java.util.UUID; @@ -192,19 +194,32 @@ public UUID run(@NonNull String receiver, @NonNull UUID networkUuid, String vari } // --- Related result methods --- // - public DynamicMarginCalculationStatus getStatus(@NonNull UUID resultUuid) { - Objects.requireNonNull(resultUuid); + return getStatuses(List.of(resultUuid)).get(resultUuid); + } - String resultBaseUrl = buildEndPointUrl(getBaseUri(), DYNAMIC_MARGIN_CALCULATION_API_VERSION, DYNAMIC_MARGIN_CALCULATION_END_POINT_RESULT); + public Map getStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } - String url = UriComponentsBuilder - .fromUriString(resultBaseUrl + "/{resultUuid}/status") - .buildAndExpand(resultUuid) - .toUriString(); + String endPointUrl = buildEndPointUrl(getBaseUri(), DYNAMIC_MARGIN_CALCULATION_API_VERSION, DYNAMIC_MARGIN_CALCULATION_END_POINT_RESULT); - // call dynamic-margin-calculation REST API - return getRestTemplate().getForObject(url, DynamicMarginCalculationStatus.class); + var uriComponents = UriComponentsBuilder.fromUriString(endPointUrl + "/statuses").build(); + String path = uriComponents.toUriString(); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); + + Map statuses = getRestTemplate().exchange( + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } public void invalidateStatus(@NonNull List resultUuids) { diff --git a/src/main/java/org/gridsuite/study/server/service/client/dynamicsecurityanalysis/DynamicSecurityAnalysisClient.java b/src/main/java/org/gridsuite/study/server/service/client/dynamicsecurityanalysis/DynamicSecurityAnalysisClient.java index 9250732324..0f02040263 100644 --- a/src/main/java/org/gridsuite/study/server/service/client/dynamicsecurityanalysis/DynamicSecurityAnalysisClient.java +++ b/src/main/java/org/gridsuite/study/server/service/client/dynamicsecurityanalysis/DynamicSecurityAnalysisClient.java @@ -7,22 +7,25 @@ package org.gridsuite.study.server.service.client.dynamicsecurityanalysis; -import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.StringUtils; import org.gridsuite.study.server.RemoteServicesProperties; import org.gridsuite.study.server.dto.ReportInfos; import org.gridsuite.study.server.dto.dynamicsecurityanalysis.DynamicSecurityAnalysisStatus; import org.gridsuite.study.server.service.StudyService; import org.gridsuite.study.server.service.client.AbstractRestClient; +import org.springframework.core.ParameterizedTypeReference; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; import org.springframework.http.MediaType; import org.springframework.lang.NonNull; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; import java.util.List; +import java.util.Map; import java.util.Objects; import java.util.UUID; @@ -178,18 +181,33 @@ public UUID run(@NonNull String receiver, @NonNull UUID networkUuid, String vari } // --- Related result methods --- // - public DynamicSecurityAnalysisStatus getStatus(@NonNull UUID resultUuid) { - Objects.requireNonNull(resultUuid); + return getStatuses(List.of(resultUuid)).get(resultUuid); + } + + public Map getStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } String resultBaseUrl = buildEndPointUrl(getBaseUri(), DYNAMIC_SECURITY_ANALYSIS_API_VERSION, DYNAMIC_SECURITY_ANALYSIS_END_POINT_RESULT); - String url = UriComponentsBuilder.fromUriString(resultBaseUrl + "/{resultUuid}/status") - .buildAndExpand(resultUuid) + String path = UriComponentsBuilder.fromUriString(resultBaseUrl + "/statuses") .toUriString(); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); // call dynamic-security-analysis REST API - return getRestTemplate().getForObject(url, DynamicSecurityAnalysisStatus.class); + Map statuses = getRestTemplate().exchange( + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } public void invalidateStatus(@NonNull List resultUuids) { diff --git a/src/main/java/org/gridsuite/study/server/service/client/dynamicsimulation/DynamicSimulationClient.java b/src/main/java/org/gridsuite/study/server/service/client/dynamicsimulation/DynamicSimulationClient.java index 41f27ccecb..77279c019c 100644 --- a/src/main/java/org/gridsuite/study/server/service/client/dynamicsimulation/DynamicSimulationClient.java +++ b/src/main/java/org/gridsuite/study/server/service/client/dynamicsimulation/DynamicSimulationClient.java @@ -14,6 +14,7 @@ import org.springframework.lang.NonNull; import java.util.List; +import java.util.Map; import java.util.UUID; import static org.gridsuite.study.server.StudyConstants.DYNAMIC_SIMULATION_API_VERSION; @@ -56,6 +57,8 @@ UUID run(String receiver, UUID networkUuid, String variantId, ReportInfos report DynamicSimulationStatus getStatus(UUID resultUuid); + Map getStatuses(List resultUuids); + void invalidateStatus(List resultUuids); void deleteResults(List resultsUuids); diff --git a/src/main/java/org/gridsuite/study/server/service/client/dynamicsimulation/impl/DynamicSimulationClientImpl.java b/src/main/java/org/gridsuite/study/server/service/client/dynamicsimulation/impl/DynamicSimulationClientImpl.java index 226cbf9852..82a6818c01 100644 --- a/src/main/java/org/gridsuite/study/server/service/client/dynamicsimulation/impl/DynamicSimulationClientImpl.java +++ b/src/main/java/org/gridsuite/study/server/service/client/dynamicsimulation/impl/DynamicSimulationClientImpl.java @@ -7,7 +7,6 @@ package org.gridsuite.study.server.service.client.dynamicsimulation.impl; -import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.StringUtils; import org.gridsuite.study.server.RemoteServicesProperties; import org.gridsuite.study.server.dto.ReportInfos; @@ -16,15 +15,19 @@ import org.gridsuite.study.server.service.StudyService; import org.gridsuite.study.server.service.client.AbstractRestClient; import org.gridsuite.study.server.service.client.dynamicsimulation.DynamicSimulationClient; +import org.springframework.core.ParameterizedTypeReference; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; import org.springframework.http.MediaType; import org.springframework.lang.NonNull; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; import java.util.List; +import java.util.Map; import java.util.Objects; import java.util.UUID; @@ -203,13 +206,35 @@ public UUID getTimelineResult(UUID resultUuid) { @Override public DynamicSimulationStatus getStatus(UUID resultUuid) { - Objects.requireNonNull(resultUuid); + if (resultUuid == null) { + return null; + } + return getStatuses(List.of(resultUuid)).get(resultUuid); + } + + @Override + public Map getStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } + String endPointUrl = buildEndPointUrl(getBaseUri(), DYNAMIC_SIMULATION_API_VERSION, DYNAMIC_SIMULATION_END_POINT_RESULT); - var uriComponents = UriComponentsBuilder.fromUriString(endPointUrl + "/{resultUuid}/status") - .buildAndExpand(resultUuid); + var uriComponents = UriComponentsBuilder.fromUriString(endPointUrl + "/statuses").buildAndExpand(); + String path = uriComponents.toUriString(); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); - return getRestTemplate().getForObject(uriComponents.toUriString(), DynamicSimulationStatus.class); + Map statuses = getRestTemplate().exchange( + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } @Override diff --git a/src/main/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationService.java b/src/main/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationService.java index 5c86e5c28f..c6fb992252 100644 --- a/src/main/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationService.java +++ b/src/main/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationService.java @@ -9,7 +9,6 @@ import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; -import org.apache.commons.collections4.CollectionUtils; import org.gridsuite.study.server.dto.NodeReceiver; import org.gridsuite.study.server.dto.ReportInfos; import org.gridsuite.study.server.dto.dynamicmargincalculation.DynamicMarginCalculationStatus; @@ -18,11 +17,15 @@ import org.gridsuite.study.server.service.client.dynamicmargincalculation.DynamicMarginCalculationClient; import org.gridsuite.study.server.service.common.ComputationParameters; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import java.io.UncheckedIOException; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; +import java.util.HashSet; import java.util.List; +import java.util.Map; +import java.util.Set; import java.util.UUID; import static org.gridsuite.study.server.error.StudyBusinessErrorCode.COMPUTATION_RUNNING; @@ -86,11 +89,18 @@ public UUID runDynamicMarginCalculation(UUID nodeUuid, UUID rootNetworkUuid, UUI } public DynamicMarginCalculationStatus getStatus(UUID resultUuid) { - return resultUuid == null ? null : dynamicMarginCalculationClient.getStatus(resultUuid); + if (resultUuid == null) { + return null; + } + return getDynamicMarginCalculationStatuses(List.of(resultUuid)).get(resultUuid); + } + + public Map getDynamicMarginCalculationStatuses(List resultUuids) { + return dynamicMarginCalculationClient.getStatuses(resultUuids); } public void invalidateStatus(List resultUuids) { - if (CollectionUtils.isNotEmpty(resultUuids)) { + if (!CollectionUtils.isEmpty(resultUuids)) { dynamicMarginCalculationClient.invalidateStatus(resultUuids); } } @@ -125,4 +135,12 @@ public UUID getDynamicMarginCalculationParametersUuidOrElseCreateDefault(StudyEn public String getProvider(UUID parametersUuid) { return dynamicMarginCalculationClient.getProvider(parametersUuid); } + + public void assertNoDynamicMarginCalculationRunning(List resultUuids) { + Map dynamicMarginCalculationStatuses = getDynamicMarginCalculationStatuses(resultUuids); + Set values = new HashSet<>(dynamicMarginCalculationStatuses.values()); + if (values.contains(DynamicMarginCalculationStatus.RUNNING)) { + throw new StudyException(COMPUTATION_RUNNING); + } + } } diff --git a/src/main/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisService.java b/src/main/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisService.java index a0824179aa..5dd75652c8 100644 --- a/src/main/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisService.java +++ b/src/main/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisService.java @@ -9,7 +9,7 @@ import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; -import org.apache.commons.collections4.CollectionUtils; + import org.gridsuite.study.server.dto.NodeReceiver; import org.gridsuite.study.server.dto.ReportInfos; import org.gridsuite.study.server.dto.dynamicsecurityanalysis.DynamicSecurityAnalysisStatus; @@ -18,11 +18,15 @@ import org.gridsuite.study.server.service.client.dynamicsecurityanalysis.DynamicSecurityAnalysisClient; import org.gridsuite.study.server.service.common.ComputationParameters; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import java.io.UncheckedIOException; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; +import java.util.HashSet; import java.util.List; +import java.util.Map; +import java.util.Set; import java.util.UUID; import static org.gridsuite.study.server.error.StudyBusinessErrorCode.COMPUTATION_RUNNING; @@ -86,11 +90,21 @@ public UUID runDynamicSecurityAnalysis(UUID nodeUuid, UUID rootNetworkUuid, UUID } public DynamicSecurityAnalysisStatus getStatus(UUID resultUuid) { - return resultUuid == null ? null : dynamicSecurityAnalysisClient.getStatus(resultUuid); + if (resultUuid == null) { + return null; + } + return getDynamicSecurityAnalysisStatuses(List.of(resultUuid)).get(resultUuid); + } + + public Map getDynamicSecurityAnalysisStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } + return dynamicSecurityAnalysisClient.getStatuses(resultUuids); } public void invalidateStatus(List resultUuids) { - if (CollectionUtils.isNotEmpty(resultUuids)) { + if (!CollectionUtils.isEmpty(resultUuids)) { dynamicSecurityAnalysisClient.invalidateStatus(resultUuids); } } @@ -125,4 +139,12 @@ public UUID getDynamicSecurityAnalysisParametersUuidOrElseCreateDefault(StudyEnt public String getProvider(UUID parametersUuid) { return dynamicSecurityAnalysisClient.getProvider(parametersUuid); } + + public void assertNoDynamicSecurityAnalysisRunning(List resultUuids) { + Map dynamicSecurityAnalysisStatuses = getDynamicSecurityAnalysisStatuses(resultUuids); + Set values = new HashSet<>(dynamicSecurityAnalysisStatuses.values()); + if (values.contains(DynamicSecurityAnalysisStatus.RUNNING)) { + throw new StudyException(COMPUTATION_RUNNING); + } + } } diff --git a/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationService.java b/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationService.java index 615d29feed..be7f0c19ad 100644 --- a/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationService.java +++ b/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationService.java @@ -17,6 +17,7 @@ import org.gridsuite.study.server.service.common.ComputationParameters; import java.util.List; +import java.util.Map; import java.util.UUID; /** @@ -84,6 +85,13 @@ UUID runDynamicSimulation(UUID nodeUuid, UUID rootNetworkUuid, UUID networkUuid, */ DynamicSimulationStatus getStatus(UUID resultUuid); + /** + * Get the current status of the simulations + * @param resultUuids a given list of result UUIDs + * @return a map of result UUID and its corresponding dynamic simulation status + */ + Map getDynamicSimulationStatuses(List resultUuids); + /** * invalidate status of the simulation results * @param resultUuids a given list of result UUIDs @@ -118,4 +126,6 @@ UUID runDynamicSimulation(UUID nodeUuid, UUID rootNetworkUuid, UUID networkUuid, * @return a list of time-series metadata */ List getTimeSeriesMetadataList(UUID resultUuid); + + void assertNoDynamicSimulationRunning(List computationResultUuids); } diff --git a/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/impl/DynamicSimulationServiceImpl.java b/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/impl/DynamicSimulationServiceImpl.java index fed8ce764b..c0ed5ce16f 100644 --- a/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/impl/DynamicSimulationServiceImpl.java +++ b/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/impl/DynamicSimulationServiceImpl.java @@ -12,7 +12,6 @@ import com.powsybl.timeseries.DoubleTimeSeries; import com.powsybl.timeseries.StringTimeSeries; import com.powsybl.timeseries.TimeSeries; -import org.apache.commons.collections4.CollectionUtils; import org.gridsuite.study.server.dto.NodeReceiver; import org.gridsuite.study.server.dto.ReportInfos; import org.gridsuite.study.server.dto.dynamicsimulation.DynamicSimulationStatus; @@ -26,13 +25,17 @@ import org.gridsuite.study.server.service.client.timeseries.TimeSeriesClient; import org.gridsuite.study.server.service.dynamicsimulation.DynamicSimulationService; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import java.io.UncheckedIOException; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Collections; +import java.util.HashSet; import java.util.List; +import java.util.Map; +import java.util.Set; import java.util.UUID; import java.util.stream.Stream; @@ -201,12 +204,20 @@ public List getTimelineResult(UUID resultUuid) { @Override public DynamicSimulationStatus getStatus(UUID resultUuid) { - return resultUuid == null ? null : dynamicSimulationClient.getStatus(resultUuid); + if (resultUuid == null) { + return null; + } + return getDynamicSimulationStatuses(List.of(resultUuid)).get(resultUuid); + } + + @Override + public Map getDynamicSimulationStatuses(List resultUuids) { + return dynamicSimulationClient.getStatuses(resultUuids); } @Override public void invalidateStatus(List resultUuids) { - if (CollectionUtils.isNotEmpty(resultUuids)) { + if (!CollectionUtils.isEmpty(resultUuids)) { dynamicSimulationClient.invalidateStatus(resultUuids); } } @@ -233,4 +244,12 @@ public void assertDynamicSimulationNotRunning(UUID resultUuid) { throw new StudyException(COMPUTATION_RUNNING); } } + + public void assertNoDynamicSimulationRunning(List computationResultUuids) { + Map loadFlowStatuses = getDynamicSimulationStatuses(computationResultUuids); + Set values = new HashSet<>(loadFlowStatuses.values()); + if (values.contains(DynamicSimulationStatus.RUNNING)) { + throw new StudyException(COMPUTATION_RUNNING); + } + } } diff --git a/src/main/java/org/gridsuite/study/server/service/shortcircuit/ShortCircuitService.java b/src/main/java/org/gridsuite/study/server/service/shortcircuit/ShortCircuitService.java index 480db529a5..43965a3dfa 100644 --- a/src/main/java/org/gridsuite/study/server/service/shortcircuit/ShortCircuitService.java +++ b/src/main/java/org/gridsuite/study/server/service/shortcircuit/ShortCircuitService.java @@ -16,7 +16,7 @@ import org.gridsuite.study.server.error.StudyException; import org.gridsuite.study.server.dto.NodeReceiver; import org.gridsuite.study.server.dto.ReportInfos; -import org.gridsuite.study.server.dto.ShortCircuitStatus; +import org.gridsuite.study.server.dto.ShortCircuitAnalysisStatus; import org.gridsuite.study.server.dto.VariantInfos; import org.gridsuite.study.server.service.StudyService; import org.gridsuite.study.server.service.common.AbstractComputationService; @@ -29,6 +29,7 @@ import org.springframework.http.*; import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; @@ -36,9 +37,11 @@ import java.net.URI; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; +import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.Set; import java.util.UUID; import static org.gridsuite.study.server.StudyConstants.*; @@ -194,15 +197,33 @@ public String getShortCircuitAnalysisResultsPage(ResultParameters resultParamete return getShortCircuitAnalysisResource(builder.build().encode().toUri()); // need to encode because of filter JSON array } - public String getShortCircuitAnalysisStatus(UUID resultUuid) { - String resultPath = getShortCircuitAnalysisResultResourcePath(resultUuid); - if (resultPath == null) { + public ShortCircuitAnalysisStatus getShortCircuitAnalysisStatus(UUID resultUuid) { + if (resultUuid == null) { return null; } + return getShortCircuitAnalysisStatuses(List.of(resultUuid)).get(resultUuid); + } - UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(shortCircuitServerBaseUri + resultPath + "/status"); + public Map getShortCircuitAnalysisStatuses(List resultUuids) { + if (CollectionUtils.isEmpty(resultUuids)) { + return Map.of(); + } + String path = UriComponentsBuilder + .fromPath(DELIMITER + SHORT_CIRCUIT_API_VERSION + "/results/statuses") + .toUriString(); - return getShortCircuitAnalysisResource(builder.build().toUri()); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + HttpEntity> httpEntity = new HttpEntity<>(resultUuids, headers); + + Map statuses = restTemplate.exchange( + shortCircuitServerBaseUri + path, + HttpMethod.POST, + httpEntity, + new ParameterizedTypeReference>() { + } + ).getBody(); + return statuses != null ? statuses : Map.of(); } public String getShortCircuitAnalysisResource(URI resourcePath) { @@ -249,10 +270,10 @@ public Integer getShortCircuitResultsCount() { return restTemplate.getForObject(shortCircuitServerBaseUri + path, Integer.class); } - public void assertShortCircuitAnalysisNotRunning(UUID scsResultUuid, UUID oneBusScsResultUuid) { - String scs = getShortCircuitAnalysisStatus(scsResultUuid); - String oneBusScs = getShortCircuitAnalysisStatus(oneBusScsResultUuid); - if (ShortCircuitStatus.RUNNING.name().equals(scs) || ShortCircuitStatus.RUNNING.name().equals(oneBusScs)) { + public void assertNoShortCircuitAnalysisRunning(List resultUuids) { + Map shortCircuitStatuses = getShortCircuitAnalysisStatuses(resultUuids); + Set values = new HashSet<>(shortCircuitStatuses.values()); + if (values.contains(ShortCircuitAnalysisStatus.RUNNING)) { throw new StudyException(COMPUTATION_RUNNING); } } diff --git a/src/main/java/org/gridsuite/study/server/utils/JsonUtils.java b/src/main/java/org/gridsuite/study/server/utils/JsonUtils.java index d642c0eac1..697399a077 100644 --- a/src/main/java/org/gridsuite/study/server/utils/JsonUtils.java +++ b/src/main/java/org/gridsuite/study/server/utils/JsonUtils.java @@ -21,6 +21,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.function.Consumer; import java.util.function.Predicate; import static org.gridsuite.study.server.error.StudyBusinessErrorCode.UNPROCESSABLE_IMPORT_PARAMETER; @@ -104,4 +105,14 @@ public static Map serializeImportParameters(Map }); return result; } + + public static Consumer throwingJsonProcessingConsumerWrapper(ThrowingConsumer throwingConsumer) { + return i -> { + try { + throwingConsumer.accept(i); + } catch (JsonProcessingException ex) { + throw new RuntimeException(ex); + } + }; + } } diff --git a/src/main/java/org/gridsuite/study/server/utils/ThrowingConsumer.java b/src/main/java/org/gridsuite/study/server/utils/ThrowingConsumer.java new file mode 100644 index 0000000000..5d278a466b --- /dev/null +++ b/src/main/java/org/gridsuite/study/server/utils/ThrowingConsumer.java @@ -0,0 +1,15 @@ +/* + * 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.study.server.utils; + +/** + * @author Sylvain Bouzols + */ +@FunctionalInterface +public interface ThrowingConsumer { + void accept(T t) throws E; +} diff --git a/src/test/java/org/gridsuite/study/server/NetworkModificationTest.java b/src/test/java/org/gridsuite/study/server/NetworkModificationTest.java index 20ffe5c7c3..84c2fb2fcf 100644 --- a/src/test/java/org/gridsuite/study/server/NetworkModificationTest.java +++ b/src/test/java/org/gridsuite/study/server/NetworkModificationTest.java @@ -83,6 +83,7 @@ import static org.gridsuite.study.server.error.StudyBusinessErrorCode.NOT_FOUND; import static org.gridsuite.study.server.utils.ImpactUtils.createModificationResultWithElementImpact; import static org.gridsuite.study.server.utils.JsonUtils.getModificationContextJsonString; +import static org.gridsuite.study.server.utils.JsonUtils.throwingJsonProcessingConsumerWrapper; import static org.gridsuite.study.server.utils.MatcherCreatedStudyBasicInfos.createMatcherCreatedStudyBasicInfos; import static org.gridsuite.study.server.utils.SendInput.POST_ACTION_SEND_INPUT; import static org.gridsuite.study.server.utils.TestUtils.checkUpdateStatusMessagesReceived; @@ -92,6 +93,8 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.*; import static org.springframework.http.MediaType.APPLICATION_JSON; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete; @@ -131,26 +134,12 @@ class NetworkModificationTest { private static final String DYNAMIC_SECURITY_ANALYSIS_RESULT_UUID = "2e0f05e1-8a6f-6d50-1e6c-0a9071d3f40a"; private static final String DYNAMIC_MARGIN_CALCULATION_RESULT_UUID = "52b88cb8-d3ce-4263-bd4d-8b27849d88bc"; private static final String SECURITY_ANALYSIS_RESULT_UUID = "f3a85c9b-9594-4e55-8ec7-07ea965d24eb"; - private static final String SECURITY_ANALYSIS_STATUS_JSON = "\"CONVERGED\""; - private static final String SENSITIVITY_ANALYSIS_RESULT_UUID = "b3a84c9b-9594-4e85-8ec7-07ea965d24eb"; - private static final String SENSITIVITY_ANALYSIS_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; - private static final String SHORTCIRCUIT_ANALYSIS_RESULT_UUID = "72f94d64-4fc6-11ed-bdc3-0242ac120002"; private static final String ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID = "72f94d88-4fc6-11ed-bdc3-0242ac120009"; - - private static final String SHORTCIRCUIT_ANALYSIS_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; - private static final String ONE_BUS_SHORTCIRCUIT_ANALYSIS_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; - private static final String VOLTAGE_INIT_RESULT_UUID = "37cf33ad-f4a0-4ab8-84c5-6ad2e22d9866"; - private static final String PCC_MIN_RESULT_UUID = "37cf33ad-f4a0-4ab8-84c5-6ad2e22d9863"; - - private static final String VOLTAGE_INIT_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; - private static final String STATE_ESTIMATION_RESULT_UUID = "d3a85e9b-9894-4255-8ec7-07ea965d24eb"; - private static final String STATE_ESTIMATION_STATUS_JSON = "\"COMPLETED\""; - private static final String PCC_MIN_STATUS_JSON = "\"COMPLETED\""; private static final String MODIFICATION_UUID = "796719f5-bd31-48be-be46-ef7b96951e32"; @@ -2624,15 +2613,17 @@ void testNodesInvalidation() throws Exception { List.of( SECURITY_ANALYSIS_RESULT_UUID, SENSITIVITY_ANALYSIS_RESULT_UUID, - SHORTCIRCUIT_ANALYSIS_RESULT_UUID, - ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID, VOLTAGE_INIT_RESULT_UUID, PCC_MIN_RESULT_UUID, STATE_ESTIMATION_RESULT_UUID - ).forEach(resultUuid -> { + ).forEach(throwingJsonProcessingConsumerWrapper(resultUuid -> { computationServerStubs.verifyDeleteResult(resultUuid); - computationServerStubs.verifyGetResultStatus(resultUuid); - }); + computationServerStubs.verifyGetResultStatus(mapper.writeValueAsString(List.of(resultUuid))); + })); + // must verify individually because One bus and full shorticuit analysisi statuses are checked with the same request + computationServerStubs.verifyDeleteResult(SHORTCIRCUIT_ANALYSIS_RESULT_UUID); + computationServerStubs.verifyDeleteResult(ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID); + computationServerStubs.verifyGetResultStatus(mapper.writeValueAsString(List.of(SHORTCIRCUIT_ANALYSIS_RESULT_UUID, ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID))); // Mark nodes 2 and 3 status as built rootNetworkNodeInfoEntity = rootNetworkNodeInfoRepository.findByNodeInfoIdAndRootNetworkId(modificationNode2Uuid, studyTestUtils.getOneRootNetworkUuid(studyNameUserIdUuid)).orElseThrow(() -> new StudyException(NOT_FOUND, "Root network not found")); @@ -2720,22 +2711,24 @@ void testRemoveLoadFlowComputationReport() throws Exception { // 1 status LF + 2 x 10 computations + 1 report computationServerStubs.verifyDeleteResult(LOADFLOW_RESULT_UUID); - computationServerStubs.verifyGetResultStatus(LOADFLOW_RESULT_UUID, 2); + computationServerStubs.verifyGetResultStatuses(mapper.writeValueAsString(List.of(LOADFLOW_RESULT_UUID)), 2); List.of( SECURITY_ANALYSIS_RESULT_UUID, DYNAMIC_SIMULATION_RESULT_UUID, DYNAMIC_SECURITY_ANALYSIS_RESULT_UUID, DYNAMIC_MARGIN_CALCULATION_RESULT_UUID, SENSITIVITY_ANALYSIS_RESULT_UUID, - SHORTCIRCUIT_ANALYSIS_RESULT_UUID, - ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID, VOLTAGE_INIT_RESULT_UUID, STATE_ESTIMATION_RESULT_UUID, PCC_MIN_RESULT_UUID - ).forEach(resultUuid -> { + ).forEach(throwingJsonProcessingConsumerWrapper(resultUuid -> { computationServerStubs.verifyDeleteResult(resultUuid); - computationServerStubs.verifyGetResultStatus(resultUuid); - }); + computationServerStubs.verifyGetResultStatus(mapper.writeValueAsString(List.of(resultUuid))); + })); + // must verify individually because One bus and full shorticuit analysisi statuses are checked with the same request + computationServerStubs.verifyDeleteResult(SHORTCIRCUIT_ANALYSIS_RESULT_UUID); + computationServerStubs.verifyDeleteResult(ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID); + computationServerStubs.verifyGetResultStatus(mapper.writeValueAsString(List.of(SHORTCIRCUIT_ANALYSIS_RESULT_UUID, ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID))); // requests for computation sub-report deletion reportServerStubs.verifyDeleteReport(); } @@ -2973,17 +2966,60 @@ private ComputationResultStubIds stubAllComputationResults() throws JsonProcessi ).forEach(resultUuid -> { deleteResultStubIds.put(resultUuid, computationServerStubs.stubDeleteResult(resultUuid)); }); - getStatusStubIds.put(LOADFLOW_RESULT_UUID, computationServerStubs.stubGetResultStatus(LOADFLOW_RESULT_UUID, mapper.writeValueAsString(LoadFlowStatus.CONVERGED))); - getStatusStubIds.put(SECURITY_ANALYSIS_RESULT_UUID, computationServerStubs.stubGetResultStatus(SECURITY_ANALYSIS_RESULT_UUID, SECURITY_ANALYSIS_STATUS_JSON)); - getStatusStubIds.put(DYNAMIC_SIMULATION_RESULT_UUID, computationServerStubs.stubGetResultStatus(DYNAMIC_SIMULATION_RESULT_UUID, objectMapper.writeValueAsString(DynamicSimulationStatus.CONVERGED))); - getStatusStubIds.put(DYNAMIC_SECURITY_ANALYSIS_RESULT_UUID, computationServerStubs.stubGetResultStatus(DYNAMIC_SECURITY_ANALYSIS_RESULT_UUID, objectMapper.writeValueAsString(DynamicSecurityAnalysisStatus.SUCCEED))); - getStatusStubIds.put(DYNAMIC_MARGIN_CALCULATION_RESULT_UUID, computationServerStubs.stubGetResultStatus(DYNAMIC_MARGIN_CALCULATION_RESULT_UUID, objectMapper.writeValueAsString(DynamicMarginCalculationStatus.SUCCEED))); - getStatusStubIds.put(SENSITIVITY_ANALYSIS_RESULT_UUID, computationServerStubs.stubGetResultStatus(SENSITIVITY_ANALYSIS_RESULT_UUID, SENSITIVITY_ANALYSIS_STATUS_JSON)); - getStatusStubIds.put(SHORTCIRCUIT_ANALYSIS_RESULT_UUID, computationServerStubs.stubGetResultStatus(SHORTCIRCUIT_ANALYSIS_RESULT_UUID, SHORTCIRCUIT_ANALYSIS_STATUS_JSON)); - getStatusStubIds.put(ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID, computationServerStubs.stubGetResultStatus(ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID, ONE_BUS_SHORTCIRCUIT_ANALYSIS_STATUS_JSON)); - getStatusStubIds.put(VOLTAGE_INIT_RESULT_UUID, computationServerStubs.stubGetResultStatus(VOLTAGE_INIT_RESULT_UUID, VOLTAGE_INIT_STATUS_JSON)); - getStatusStubIds.put(STATE_ESTIMATION_RESULT_UUID, computationServerStubs.stubGetResultStatus(STATE_ESTIMATION_RESULT_UUID, STATE_ESTIMATION_STATUS_JSON)); - getStatusStubIds.put(PCC_MIN_RESULT_UUID, computationServerStubs.stubGetResultStatus(PCC_MIN_RESULT_UUID, PCC_MIN_STATUS_JSON)); + getStatusStubIds.put(LOADFLOW_RESULT_UUID, computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(LOADFLOW_RESULT_UUID)), + mapper.writeValueAsString(Map.of(LOADFLOW_RESULT_UUID, LoadFlowStatus.CONVERGED)) + ) + ); + getStatusStubIds.put(SECURITY_ANALYSIS_RESULT_UUID, computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(SECURITY_ANALYSIS_RESULT_UUID)), + mapper.writeValueAsString(Map.of(SECURITY_ANALYSIS_RESULT_UUID, SecurityAnalysisStatus.CONVERGED)) + ) + ); + getStatusStubIds.put(DYNAMIC_SIMULATION_RESULT_UUID, computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(DYNAMIC_SIMULATION_RESULT_UUID)), + mapper.writeValueAsString(Map.of(DYNAMIC_SIMULATION_RESULT_UUID, DynamicSimulationStatus.CONVERGED)) + ) + ); + getStatusStubIds.put(DYNAMIC_SECURITY_ANALYSIS_RESULT_UUID, computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(DYNAMIC_SECURITY_ANALYSIS_RESULT_UUID)), + mapper.writeValueAsString(Map.of(DYNAMIC_SECURITY_ANALYSIS_RESULT_UUID, DynamicSecurityAnalysisStatus.SUCCEED)) + ) + ); + getStatusStubIds.put(DYNAMIC_MARGIN_CALCULATION_RESULT_UUID, computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(DYNAMIC_MARGIN_CALCULATION_RESULT_UUID)), + mapper.writeValueAsString(Map.of(DYNAMIC_MARGIN_CALCULATION_RESULT_UUID, DynamicMarginCalculationStatus.SUCCEED)) + ) + ); + getStatusStubIds.put(SENSITIVITY_ANALYSIS_RESULT_UUID, computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(SENSITIVITY_ANALYSIS_RESULT_UUID)), + mapper.writeValueAsString(Map.of(SENSITIVITY_ANALYSIS_RESULT_UUID, SensitivityAnalysisStatus.COMPLETED)) + ) + ); + UUID bothShortcircuitStubid = computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(SHORTCIRCUIT_ANALYSIS_RESULT_UUID, ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID)), + mapper.writeValueAsString(Map.of( + SHORTCIRCUIT_ANALYSIS_RESULT_UUID, ShortCircuitAnalysisStatus.COMPLETED, + ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID, ShortCircuitAnalysisStatus.COMPLETED + )) + ); + getStatusStubIds.put(SHORTCIRCUIT_ANALYSIS_RESULT_UUID, bothShortcircuitStubid); + getStatusStubIds.put(ONE_BUS_SHORTCIRCUIT_ANALYSIS_RESULT_UUID, bothShortcircuitStubid); + getStatusStubIds.put(VOLTAGE_INIT_RESULT_UUID, computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(VOLTAGE_INIT_RESULT_UUID)), + mapper.writeValueAsString(Map.of(VOLTAGE_INIT_RESULT_UUID, VoltageInitStatus.COMPLETED)) + ) + ); + getStatusStubIds.put(STATE_ESTIMATION_RESULT_UUID, computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(STATE_ESTIMATION_RESULT_UUID)), + mapper.writeValueAsString(Map.of(STATE_ESTIMATION_RESULT_UUID, StateEstimationStatus.COMPLETED)) + ) + ); + getStatusStubIds.put(PCC_MIN_RESULT_UUID, computationServerStubs.stubGetResultStatuses( + mapper.writeValueAsString(List.of(PCC_MIN_RESULT_UUID)), + mapper.writeValueAsString(Map.of(PCC_MIN_RESULT_UUID, PccMinStatus.COMPLETED)) + ) + ); return new ComputationResultStubIds(deleteResultStubIds, getStatusStubIds); } diff --git a/src/test/java/org/gridsuite/study/server/NetworkModificationTreeTest.java b/src/test/java/org/gridsuite/study/server/NetworkModificationTreeTest.java index 511751764d..1e1b587913 100644 --- a/src/test/java/org/gridsuite/study/server/NetworkModificationTreeTest.java +++ b/src/test/java/org/gridsuite/study/server/NetworkModificationTreeTest.java @@ -449,7 +449,7 @@ private void assertForbiddenNodeInsertions(UUID studyId, String userId, NetworkModificationNode security1, NetworkModificationNode security2) throws Exception { // Construction node cannot be inserted before a security node - doNothing().when(rootNetworkNodeInfoService).assertComputationNotRunning(any(), any()); + doNothing().when(rootNetworkNodeInfoService).assertComputationsNotRunning(any(), any()); mockMvc.perform(post("/v1/studies/{studyUuid}/tree/nodes?nodeToCutUuid={nodeUuid}&referenceNodeUuid={referenceNodeUuid}&insertMode={insertMode}", studyId, construction2.getId(), security1.getId(), InsertMode.BEFORE) .header(USER_ID_HEADER, userId)) @@ -637,7 +637,7 @@ void testNodeStashAndRestore() throws Exception { assertEquals("not built node", networkModificationNode.getDescription()); //stash 1 node and do the checks - doNothing().when(rootNetworkNodeInfoService).assertComputationNotRunning(any(), any()); + doNothing().when(rootNetworkNodeInfoService).assertComputationsNotRunning(any(), any()); stashNode(root.getStudyId(), children.get(0), false, Set.of(children.get(0)), userId); var stashedNode = nodeRepository.findById(children.get(0).getId()).orElseThrow(); assertTrue(stashedNode.isStashed()); @@ -1761,7 +1761,7 @@ void testNodeAliases() throws Exception { checkElementUpdatedMessageSent(root.getStudyId(), userId); // Stashing node3 (with stashChildren=true) should result in aliases no more associated to nodes node3, node4 and node5 - doNothing().when(rootNetworkNodeInfoService).assertComputationNotRunning(any(), any()); + doNothing().when(rootNetworkNodeInfoService).assertComputationsNotRunning(any(), any()); stashNode(root.getStudyId(), node3, true, Set.of(node3, node4, node5), userId); nodeAliases = objectMapper.readValue(mockMvc.perform(get("/v1/studies/{studyUuid}/node-aliases", root.getStudyId())).andExpect(status().isOk()).andReturn() .getResponse() diff --git a/src/test/java/org/gridsuite/study/server/PccMinTest.java b/src/test/java/org/gridsuite/study/server/PccMinTest.java index 80de9663bd..013c48331c 100644 --- a/src/test/java/org/gridsuite/study/server/PccMinTest.java +++ b/src/test/java/org/gridsuite/study/server/PccMinTest.java @@ -53,6 +53,10 @@ import java.util.*; import static com.github.tomakehurst.wiremock.client.WireMock.*; +import static com.github.tomakehurst.wiremock.client.WireMock.delete; +import static com.github.tomakehurst.wiremock.client.WireMock.get; +import static com.github.tomakehurst.wiremock.client.WireMock.post; +import static com.github.tomakehurst.wiremock.client.WireMock.put; import com.github.tomakehurst.wiremock.WireMockServer; import com.github.tomakehurst.wiremock.core.WireMockConfiguration; @@ -62,7 +66,11 @@ import static org.gridsuite.study.server.notification.NotificationService.*; import static org.junit.jupiter.api.Assertions.*; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; @SpringBootTest @AutoConfigureMockMvc @@ -75,7 +83,7 @@ class PccMinTest { private static final String PCC_MIN_RESULT_UUID = "cf203721-6150-4203-8960-d61d815a9d16"; private static final String PCC_MIN_ERROR_RESULT_UUID = "25222222-9994-4e55-8ec7-07ea965d24eb"; private static final UUID PCCMIN_PARAMETERS_UUID = UUID.fromString("0c0f1efd-bd22-4a75-83d3-9e530245c7f2"); - private static final String PCC_MIN_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; + private static final String PCC_MIN_STATUS_JSON = "COMPLETED"; private static final String ELEMENT_UPDATE_DESTINATION = "element.update"; private static final String CASE_UUID_STRING = "00000000-8cf0-11bd-b23e-10b96e4ef00d"; @@ -278,12 +286,17 @@ void testRunAndCheckStatus() throws Exception { wireMockStubs.verifyPccMinRun(stubRun, NETWORK_UUID_STRING, VARIANT_ID); // verify pcc min status - computationServerStubs.stubGetResultStatus(PCC_MIN_RESULT_UUID, PCC_MIN_STATUS_JSON); + computationServerStubs.stubGetResultStatuses( + objectMapper.writeValueAsString(List.of(PCC_MIN_RESULT_UUID)), + objectMapper.writeValueAsString(Map.of(PCC_MIN_RESULT_UUID, PCC_MIN_STATUS_JSON)) + ); mockMvc.perform(get(PCC_MIN_URL_BASE + "status", ids.studyId, ids.rootNetworkUuid, ids.nodeId)) - .andExpect(status().isOk()) - .andExpect(org.springframework.test.web.servlet.result.MockMvcResultMatchers.content().string(PCC_MIN_STATUS_JSON)); + .andExpectAll( + status().isOk(), + content().string(PCC_MIN_STATUS_JSON) + ); - computationServerStubs.verifyGetResultStatus(PCC_MIN_RESULT_UUID); + computationServerStubs.verifyGetResultStatus(objectMapper.writeValueAsString(List.of(PCC_MIN_RESULT_UUID))); } @Test diff --git a/src/test/java/org/gridsuite/study/server/SensitivityAnalysisTest.java b/src/test/java/org/gridsuite/study/server/SensitivityAnalysisTest.java index 0c487563f0..de4802e54b 100644 --- a/src/test/java/org/gridsuite/study/server/SensitivityAnalysisTest.java +++ b/src/test/java/org/gridsuite/study/server/SensitivityAnalysisTest.java @@ -50,7 +50,7 @@ import java.util.*; import static com.github.tomakehurst.wiremock.client.WireMock.*; -import static com.github.tomakehurst.wiremock.client.WireMock.post; +// import static com.github.tomakehurst.wiremock.client.WireMock.post; import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig; import static org.gridsuite.study.server.StudyConstants.HEADER_RECEIVER; import static org.gridsuite.study.server.StudyConstants.HEADER_USER_ID; @@ -82,7 +82,7 @@ class SensitivityAnalysisTest { private static final String NOT_FOUND_NODE_UUID = "a3a80c9b-9594-4e55-8ec7-07ea965d24eb"; private static final String FAKE_RESULT_JSON = "fake result json"; - private static final String SENSITIVITY_ANALYSIS_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; + private static final String SENSITIVITY_ANALYSIS_STATUS_JSON = "COMPLETED"; private static final String NETWORK_UUID_STRING = "38400000-8cf0-11bd-b23e-10b96e4ef00d"; private static final String NETWORK_UUID_2_STRING = "11111111-aaaa-48be-be46-ef7b93331e32"; @@ -420,13 +420,16 @@ private void testSensitivityAnalysisWithRootNetworkUuidAndNodeUuid(UUID studyUui )); // --- 6. GET sensitivity analysis status --- - computationServerStubs.stubGetResultStatus(resultUuid, SENSITIVITY_ANALYSIS_STATUS_JSON); + computationServerStubs.stubGetResultStatuses( + objectMapper.writeValueAsString(List.of(resultUuid)), + objectMapper.writeValueAsString(Map.of(resultUuid, SENSITIVITY_ANALYSIS_STATUS_JSON)) + ); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/sensitivity-analysis/status", studyUuid, rootNetworkUuid, nodeUuid)) .andExpectAll(status().isOk(), content().string(SENSITIVITY_ANALYSIS_STATUS_JSON)); - computationServerStubs.verifyGetResultStatus(resultUuid); + computationServerStubs.verifyGetResultStatus(objectMapper.writeValueAsString(List.of(resultUuid))); // --- 7. Export CSV --- String content = objectMapper.writeValueAsString(SensitivityAnalysisCsvFileInfos.builder() @@ -557,7 +560,7 @@ void testGetSensitivityAnalysisFactorCount() throws Exception { UUID firstRootNetworkUuid = studyTestUtils.getOneRootNetworkUuid(studyNameUserIdUuid); UUID rootNodeUuid = getRootNodeUuid(studyNameUserIdUuid); - wireMockServer.stubFor(post(urlPathMatching("/v1/networks/.*/factor-count")) + wireMockServer.stubFor(WireMock.post(urlPathMatching("/v1/networks/.*/factor-count")) .willReturn(aResponse() .withStatus(200) .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) @@ -779,7 +782,7 @@ void testResetSensitivityAnalysisParametersUserHasValidParamsInProfile() throws ); // ---------------- WireMock stubs ---------------- - wireMockServer.stubFor(post(urlPathMatching( + wireMockServer.stubFor(WireMock.post(urlPathMatching( "/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save.*")) .willReturn(ok())); diff --git a/src/test/java/org/gridsuite/study/server/ShortCircuitTest.java b/src/test/java/org/gridsuite/study/server/ShortCircuitTest.java index a7802e0b4f..2a8608e7f2 100644 --- a/src/test/java/org/gridsuite/study/server/ShortCircuitTest.java +++ b/src/test/java/org/gridsuite/study/server/ShortCircuitTest.java @@ -101,7 +101,7 @@ class ShortCircuitTest implements WithAssertions { private static final byte[] SHORT_CIRCUIT_ANALYSIS_CSV_RESULT = {0x00, 0x11}; - private static final String SHORT_CIRCUIT_ANALYSIS_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; + private static final String SHORT_CIRCUIT_ANALYSIS_STATUS_JSON = "COMPLETED"; private static final String SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING = "0c0f1efd-bd22-4a75-83d3-9e530245c7f4"; private static final UUID SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID = UUID.fromString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING); @@ -271,11 +271,14 @@ void testAllBusesShortCircuit() throws Exception { status().isNoContent()); // get short circuit status - computationServerStubs.stubGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_STATUS_JSON); + computationServerStubs.stubGetResultStatuses( + objectMapper.writeValueAsString(List.of(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID)), + objectMapper.writeValueAsString(Map.of(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_STATUS_JSON)) + ); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/status", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid)).andExpectAll( status().isOk(), content().string(SHORT_CIRCUIT_ANALYSIS_STATUS_JSON)); - computationServerStubs.verifyGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); + computationServerStubs.verifyGetResultStatus(objectMapper.writeValueAsString(List.of(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID))); // stop short circuit analysis shortcircuitServerStubs.stubShortCircuitStopWithPostAction(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, shortCircuitAnalysisStoppedDestination, modificationNode3Uuid, firstRootNetworkUuid); @@ -462,11 +465,14 @@ void testPagedShortCircuit() throws Exception { status().isNoContent()); // get short circuit status - computationServerStubs.stubGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_STATUS_JSON); + computationServerStubs.stubGetResultStatuses( + objectMapper.writeValueAsString(List.of(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID)), + objectMapper.writeValueAsString(Map.of(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_STATUS_JSON)) + ); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/status", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode1Uuid)).andExpectAll( status().isOk(), content().string(SHORT_CIRCUIT_ANALYSIS_STATUS_JSON)); - computationServerStubs.verifyGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, 1); + computationServerStubs.verifyGetResultStatus(objectMapper.writeValueAsString(List.of(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID))); // stop short circuit analysis shortcircuitServerStubs.stubShortCircuitStopWithPostAction(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, shortCircuitAnalysisStoppedDestination, modificationNode1Uuid, firstRootNetworkUuid); @@ -534,14 +540,17 @@ void testOneBusShortCircuit() throws Exception { shortcircuitServerStubs.verifyGetPagedFeederResults(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, NETWORK_UUID_STRING, VARIANT_ID_2, "fakeFilters", "FULL", "0", "20", "id,DESC"); // get one bus short circuit status - computationServerStubs.stubGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_STATUS_JSON); + computationServerStubs.stubGetResultStatuses( + objectMapper.writeValueAsString(List.of(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID)), + objectMapper.writeValueAsString(Map.of(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_STATUS_JSON)) + ); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/status", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .param("type", ShortcircuitAnalysisType.ONE_BUS.name())) .andExpectAll( status().isOk(), content().string(SHORT_CIRCUIT_ANALYSIS_STATUS_JSON) ); - WireMockUtilsCriteria.verifyGetRequest(wireMockServer, "/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/status", Map.of()); + computationServerStubs.verifyGetResultStatus(objectMapper.writeValueAsString(List.of(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID))); //Test result count computationServerStubs.stubResultsCount(1); diff --git a/src/test/java/org/gridsuite/study/server/SingleLineDiagramTest.java b/src/test/java/org/gridsuite/study/server/SingleLineDiagramTest.java index 7fc7aadf5b..6158cee42c 100644 --- a/src/test/java/org/gridsuite/study/server/SingleLineDiagramTest.java +++ b/src/test/java/org/gridsuite/study/server/SingleLineDiagramTest.java @@ -185,7 +185,7 @@ public MockResponse dispatch(RecordedRequest request) { return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), "svgandmetadata"); case "/v1/svg-and-metadata/" + NETWORK_UUID_STRING + "/voltageLevelId": { - Map sldRequestInfos = objectMapper.readValue(request.getBody().readUtf8(), new TypeReference<>() { }); + Map sldRequestInfos = objectMapper.readValue(request.getBody().snapshot().utf8(), new TypeReference<>() { }); switch (sldRequestInfos.get("sldDisplayMode")) { case SldDisplayMode.STATE_VARIABLE: return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), "svgandmetadata"); diff --git a/src/test/java/org/gridsuite/study/server/SpreadsheetConfigCollectionTest.java b/src/test/java/org/gridsuite/study/server/SpreadsheetConfigCollectionTest.java index 0ab77c20ae..51a98c1a75 100644 --- a/src/test/java/org/gridsuite/study/server/SpreadsheetConfigCollectionTest.java +++ b/src/test/java/org/gridsuite/study/server/SpreadsheetConfigCollectionTest.java @@ -176,7 +176,7 @@ public MockResponse dispatch(RecordedRequest request) { } else if (path.equals("/v1/spreadsheet-config-collections") && "POST".equals(method)) { String body = null; try { - body = request.getBody().readUtf8(); + body = request.getBody().snapshot().utf8(); } catch (Exception e) { LOGGER.error("Error reading request body", e); } diff --git a/src/test/java/org/gridsuite/study/server/StateEstimationTest.java b/src/test/java/org/gridsuite/study/server/StateEstimationTest.java index 3146384540..ccbacc6b54 100644 --- a/src/test/java/org/gridsuite/study/server/StateEstimationTest.java +++ b/src/test/java/org/gridsuite/study/server/StateEstimationTest.java @@ -31,6 +31,7 @@ import org.gridsuite.study.server.repository.networkmodificationtree.NetworkModificationNodeInfoRepository; import org.gridsuite.study.server.repository.rootnetwork.RootNetworkNodeInfoRepository; import org.gridsuite.study.server.service.*; +import org.gridsuite.study.server.utils.RequestWithBody; import org.gridsuite.study.server.utils.TestUtils; import org.gridsuite.study.server.utils.elasticsearch.DisableElasticsearch; import org.jetbrains.annotations.NotNull; @@ -101,7 +102,7 @@ class StateEstimationTest { private static final UUID STATE_ESTIMATION_PARAMETERS_UUID = UUID.fromString(STATE_ESTIMATION_PARAMETERS_UUID_STRING); private static final String WRONG_STATE_ESTIMATION_PARAMETERS_UUID_STRING = "72c9d1ef-d8ab-4388-a6fe-855604c2dc10"; - private static final String ESTIM_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; + private static final String ESTIM_STATUS_JSON = "COMPLETED"; private static final String VARIANT_ID = "variant_1"; private static final String VARIANT_ID_2 = "variant_2"; @@ -178,6 +179,7 @@ void setup(final MockWebServer server) throws Exception { public MockResponse dispatch(RecordedRequest request) { String path = Objects.requireNonNull(request.getPath()); String method = Objects.requireNonNull(request.getMethod()); + String body = request.getBody().snapshot().utf8(); if (path.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?reportUuid=.*&reporterId=.*&reportType=StateEstimation&variantId=" + VARIANT_ID + "&receiver=.*")) { // estim with success @@ -193,8 +195,9 @@ public MockResponse dispatch(RecordedRequest request) { return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), estimErrorResultUuidStr); } else if (path.matches("/v1/results/" + STATE_ESTIMATION_RESULT_UUID)) { return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), estimResultJson); - } else if (path.matches("/v1/results/" + STATE_ESTIMATION_RESULT_UUID + "/status")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), ESTIM_STATUS_JSON); + } else if (path.matches("/v1/results/statuses") && "POST".equals(method) && body.contains(STATE_ESTIMATION_RESULT_UUID)) { + return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), + objectMapper.writeValueAsString(Map.of(STATE_ESTIMATION_RESULT_UUID, ESTIM_STATUS_JSON))); } else if (path.matches("/v1/results/" + STATE_ESTIMATION_RESULT_UUID + "/stop.*")) { input.send(MessageBuilder.withPayload("") .setHeader("resultUuid", STATE_ESTIMATION_RESULT_UUID) @@ -343,7 +346,9 @@ void testComputation(final MockWebServer server) throws Exception { mockMvc.perform(get(STATE_ESTIMATION_URL_BASE + "status", ids.studyId, ids.rootNetworkUuid, ids.nodeId)).andExpectAll( status().isOk(), content().string(ESTIM_STATUS_JSON)); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + STATE_ESTIMATION_RESULT_UUID + "/status"))); + RequestWithBody request = TestUtils.getRequestsWithBodyDone(1, server).iterator().next(); + assertEquals("/v1/results/statuses", request.getPath()); + assertTrue(request.getBody().contains(STATE_ESTIMATION_RESULT_UUID)); } @Test @@ -476,6 +481,8 @@ void testDebugComputation(final MockWebServer server) throws Exception { mockMvc.perform(get(STATE_ESTIMATION_URL_BASE + "status", ids.studyId, ids.rootNetworkUuid, ids.nodeId)).andExpectAll( status().isOk(), content().string(ESTIM_STATUS_JSON)); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + STATE_ESTIMATION_RESULT_UUID + "/status"))); + RequestWithBody request = TestUtils.getRequestsWithBodyDone(1, server).iterator().next(); + assertEquals("/v1/results/statuses", request.getPath()); + assertTrue(request.getBody().contains(STATE_ESTIMATION_RESULT_UUID)); } } diff --git a/src/test/java/org/gridsuite/study/server/VoltageInitTest.java b/src/test/java/org/gridsuite/study/server/VoltageInitTest.java index 50e2c5e3ed..073b631c7d 100644 --- a/src/test/java/org/gridsuite/study/server/VoltageInitTest.java +++ b/src/test/java/org/gridsuite/study/server/VoltageInitTest.java @@ -51,6 +51,7 @@ import org.gridsuite.study.server.service.*; import org.gridsuite.study.server.service.shortcircuit.ShortCircuitService; import org.gridsuite.study.server.utils.MatcherJson; +import org.gridsuite.study.server.utils.RequestWithBody; import org.gridsuite.study.server.utils.TestUtils; import org.gridsuite.study.server.utils.elasticsearch.DisableElasticsearch; import org.jetbrains.annotations.NotNull; @@ -92,6 +93,7 @@ import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyBoolean; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.*; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; @@ -168,7 +170,7 @@ class VoltageInitTest { private static final String VOLTAGE_INIT_PREVIEW_MODIFICATION_LIST = "[{\"type\": \"VOLTAGE_INIT_MODIFICATION\",\"uuid\": \"254a3b85-14ad-4436-bf62-3e60af831dd1\",\"date\": \"2023-09-18T10:58:32.582239Z\",\"stashed\": false,\"generators\": [],\"transformers\": [],\"staticVarCompensators\": [],\"vscConverterStations\": [],\"shuntCompensators\": []}]"; - private static final String VOLTAGE_INIT_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; + private static final String VOLTAGE_INIT_STATUS_JSON = "COMPLETED"; private static final String VARIANT_ID = "variant_1"; private static final String VARIANT_ID_2 = "variant_2"; @@ -322,6 +324,8 @@ void setup(final MockWebServer server) throws Exception { public MockResponse dispatch(RecordedRequest request) { String path = Objects.requireNonNull(request.getPath()); String method = Objects.requireNonNull(request.getMethod()); + String body = request.getBody().snapshot().utf8(); + if (path.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_3 + "&rootNetworkName=.*&nodeName=.*")) { return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), voltageInitResultUuidStr2); } else if (path.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_2 + ".*" + "&rootNetworkName=.*&nodeName=.*")) { @@ -332,8 +336,9 @@ public MockResponse dispatch(RecordedRequest request) { return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), VOLTAGE_INIT_RESULT_JSON); } else if (path.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "\\?globalFilters=.*networkUuid=.*variantId.*")) { return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), VOLTAGE_INIT_RESULT_JSON); - } else if (path.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/status")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), VOLTAGE_INIT_STATUS_JSON); + } else if (path.matches("/v1/results/statuses") && "POST".equals(method) && body.contains(VOLTAGE_INIT_RESULT_UUID)) { + return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), + objectMapper.writeValueAsString(Map.of(VOLTAGE_INIT_RESULT_UUID, VOLTAGE_INIT_STATUS_JSON))); } else if (path.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/modifications-group-uuid")) { return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), "\"" + MODIFICATIONS_GROUP_UUID + "\""); } else if (path.matches("/v1/groups/.*" + "\\?action=COPY.*")) { @@ -592,8 +597,9 @@ void testVoltageInit(final MockWebServer server) throws Exception { status().isOk(), content().string(VOLTAGE_INIT_STATUS_JSON)); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/status"))); - + RequestWithBody request = TestUtils.getRequestsWithBodyDone(1, server).iterator().next(); + assertEquals("/v1/results/statuses", request.getPath()); + assertTrue(request.getBody().contains(VOLTAGE_INIT_RESULT_UUID)); mockMvc.perform( post("/v1/studies/{studyUuid}/voltage-init/parameters", studyNameUserIdUuid) .header("userId", "userId") @@ -721,7 +727,7 @@ void testInsertVoltageInitModifications(final MockWebServer server) throws Excep .header("userId", "userId")).andExpect(status().isOk()); assertTrue(TestUtils.getRequestsDone(4, server).stream().allMatch(r -> r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/modifications-group-uuid") || - r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/status") || + r.matches("/v1/results/statuses") || r.matches("/v1/groups/.*\\?action=COPY&originGroupUuid=.*") )); @@ -735,7 +741,7 @@ void testInsertVoltageInitModifications(final MockWebServer server) throws Excep .header("userId", "userId")).andExpect(status().isOk()); assertTrue(TestUtils.getRequestsDone(7, server).stream().allMatch(r -> r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/modifications-group-uuid") || - r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/status") || + r.matches("/v1/results/statuses") || r.matches("/v1/results\\?resultsUuids=" + VOLTAGE_INIT_RESULT_UUID) || r.matches("/v1/groups/.*\\?action=COPY.*") || r.matches("/v1/network-modifications/index\\?networkUuid=.*&groupUuids=.*") || @@ -753,7 +759,7 @@ void testInsertVoltageInitModifications(final MockWebServer server) throws Excep .header("userId", "userId")).andExpect(status().isOk()); assertTrue(TestUtils.getRequestsDone(5, server).stream().allMatch(r -> r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/modifications-group-uuid") || - r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/status") || + r.matches("/v1/results/statuses") || r.matches("/v1/groups/.*\\?action=COPY&originGroupUuid=.*") || r.matches("/v1/network-modifications/index\\?networkUuid=.*&groupUuids=.*") )); @@ -767,7 +773,7 @@ void testInsertVoltageInitModifications(final MockWebServer server) throws Excep .header("userId", "userId")).andExpect(status().isOk()); assertTrue(TestUtils.getRequestsDone(5, server).stream().allMatch(r -> r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/modifications-group-uuid") || - r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/status") || + r.matches("/v1/results/statuses") || r.matches("/v1/groups/.*\\?action=COPY.*") || r.matches("/v1/network-modifications/index\\?networkUuid=.*&groupUuids=.*") )); @@ -853,7 +859,7 @@ void testInsertVoltageInitModificationsWithTwoRootNetworks(final MockWebServer s .header("userId", "userId")).andExpect(status().isOk()); assertTrue(TestUtils.getRequestsDone(4, server).stream().allMatch(r -> r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/modifications-group-uuid") || - r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/status") || + r.matches("/v1/results/statuses") || r.matches("/v1/groups/.*\\?action=COPY&originGroupUuid=.*") )); checkEquipmentUpdatingMessagesReceived(studyUuid, nodeUuid); @@ -872,7 +878,9 @@ void testInsertVoltageInitModificationsWithTwoRootNetworks(final MockWebServer s // Error case: try to generate the voltageInit modification on the second root network (where no computation has been made) mockMvc.perform(post("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/network-modifications/voltage-init", studyUuid, secondRootNetworkUuid, nodeUuid) .header("userId", "userId")).andExpect(status().isNotFound()); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + VOLTAGE_INIT_RESULT_UUID + "/status"))); + RequestWithBody request = TestUtils.getRequestsWithBodyDone(1, server).iterator().next(); + assertEquals("/v1/results/statuses", request.getPath()); + assertTrue(request.getBody().contains(VOLTAGE_INIT_RESULT_UUID)); } NodeEntity insertRootNode(StudyEntity study, UUID nodeId) { diff --git a/src/test/java/org/gridsuite/study/server/loadflow/LoadFlowTest.java b/src/test/java/org/gridsuite/study/server/loadflow/LoadFlowTest.java index d6e664ce1b..c3b4a4271b 100644 --- a/src/test/java/org/gridsuite/study/server/loadflow/LoadFlowTest.java +++ b/src/test/java/org/gridsuite/study/server/loadflow/LoadFlowTest.java @@ -75,6 +75,7 @@ import static org.gridsuite.study.server.utils.wiremock.WireMockUtilsCriteria.removeRequestMatching; import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.*; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; @@ -256,7 +257,11 @@ private void consumeLoadFlowResult(UUID studyUuid, UUID rootNetworkUuid, Network // consume loadflow result String resultUuidJson = objectMapper.writeValueAsString(new NodeReceiver(nodeUuid, rootNetworkUuid)); if (modificationNode.isSecurityNode()) { - wireMockStubs.loadflowServer.stubGetLoadflowStatus(UUID.fromString(LOADFLOW_RESULT_UUID), objectMapper.writeValueAsString(LoadFlowStatus.CONVERGED), false); + wireMockStubs.loadflowServer.stubGetLoadflowStatuses( + objectMapper.writeValueAsString(List.of(LOADFLOW_RESULT_UUID)), + objectMapper.writeValueAsString(Map.of(LOADFLOW_RESULT_UUID, LoadFlowStatus.CONVERGED)), + false + ); } MessageHeaders messageHeaders = new MessageHeaders( Map.of( @@ -271,7 +276,7 @@ private void consumeLoadFlowResult(UUID studyUuid, UUID rootNetworkUuid, Network assertNodeBlocked(nodeUuid, rootNetworkUuid, false); if (modificationNode.isSecurityNode()) { // if running successful loadflow on security node -> first children are built - wireMockStubs.loadflowServer.verifyGetLoadflowStatus(UUID.fromString(LOADFLOW_RESULT_UUID)); + wireMockStubs.loadflowServer.verifyGetLoadflowStatus(objectMapper.writeValueAsString(List.of(LOADFLOW_RESULT_UUID))); verify(studyService, times(1)).buildFirstLevelChildren(studyUuid, nodeUuid, rootNetworkUuid, "userId"); } } @@ -350,12 +355,16 @@ private void testLoadFlow(UUID studyNameUserIdUuid, NetworkModificationNode modi wireMockStubs.loadflowServer.verifyGetLoadflowResult(loadflowResultUuid); // get loadflow status - wireMockStubs.loadflowServer.stubGetLoadflowStatus(loadflowResultUuid, objectMapper.writeValueAsString(LoadFlowStatus.CONVERGED), false); + wireMockStubs.loadflowServer.stubGetLoadflowStatuses( + objectMapper.writeValueAsString(List.of(loadflowResultUuid)), + objectMapper.writeValueAsString(Map.of(loadflowResultUuid, LoadFlowStatus.CONVERGED)), + false + ); mvcResult = mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/loadflow/status?withRatioTapChangers={withRatioTapChangers}", studyNameUserIdUuid, firstRootNetworkUuid, modificationNodeUuid, false)) .andExpect(status().isOk()) .andReturn(); assertEquals(LoadFlowStatus.CONVERGED.name(), mvcResult.getResponse().getContentAsString()); - wireMockStubs.loadflowServer.verifyGetLoadflowStatus(loadflowResultUuid); + wireMockStubs.loadflowServer.verifyGetLoadflowStatus(objectMapper.writeValueAsString(List.of(loadflowResultUuid))); // stop loadflow wireMockStubs.loadflowServer.stubStopLoadflow(loadflowResultUuid, modificationNodeUuid, firstRootNetworkUuid, objectMapper.writeValueAsString(LoadFlowStatus.CONVERGED)); @@ -806,11 +815,15 @@ void testGetLoadFlowParametersId() throws Exception { } @Test - void testGetStatusNotFound() { + void testGetStatusNotFound() throws Exception { UUID notExistingNetworkUuid = UUID.fromString(LOADFLOW_ERROR_RESULT_UUID); - wireMockStubs.loadflowServer.stubGetLoadflowStatus(UUID.fromString(LOADFLOW_ERROR_RESULT_UUID), null, true); + wireMockStubs.loadflowServer.stubGetLoadflowStatuses( + objectMapper.writeValueAsString(List.of(LOADFLOW_ERROR_RESULT_UUID)), + null, + true + ); assertThrows(HttpClientErrorException.NotFound.class, () -> loadFlowService.getLoadFlowStatus(notExistingNetworkUuid), NOT_FOUND.name()); - wireMockStubs.loadflowServer.verifyGetLoadflowStatus(UUID.fromString(LOADFLOW_ERROR_RESULT_UUID)); + wireMockStubs.loadflowServer.verifyGetLoadflowStatus(objectMapper.writeValueAsString(List.of(LOADFLOW_ERROR_RESULT_UUID))); } @Test diff --git a/src/test/java/org/gridsuite/study/server/rootnetworks/SecurityAnalysisTest.java b/src/test/java/org/gridsuite/study/server/rootnetworks/SecurityAnalysisTest.java index ba6539ea5b..f90155524e 100644 --- a/src/test/java/org/gridsuite/study/server/rootnetworks/SecurityAnalysisTest.java +++ b/src/test/java/org/gridsuite/study/server/rootnetworks/SecurityAnalysisTest.java @@ -57,7 +57,6 @@ import java.util.UUID; import static com.github.tomakehurst.wiremock.client.WireMock.*; -import static com.github.tomakehurst.wiremock.client.WireMock.post; import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig; import static org.gridsuite.study.server.StudyConstants.HEADER_RECEIVER; import static org.gridsuite.study.server.StudyConstants.HEADER_USER_ID; @@ -97,7 +96,7 @@ class SecurityAnalysisTest { private static final byte[] SECURITY_ANALYSIS_NMK_CONTINGENCIES_RESULT_CSV_ZIPPED = {0x02, 0x03}; private static final byte[] SECURITY_ANALYSIS_NMK_CONSTRAINTS_RESULT_CSV_ZIPPED = {0x04, 0x03}; private static final byte[] SECURITY_ANALYSIS_NMK_CUT_OFF_POWER_RESULT_CSV_ZIPPED = {0x05, 0x03}; - private static final String SECURITY_ANALYSIS_STATUS_JSON = "\"CONVERGED\""; + private static final String SECURITY_ANALYSIS_STATUS_JSON = "CONVERGED"; private static final ContingencyCount CONTINGENCIES_COUNT = new ContingencyCount(2, 0); public static final String SECURITY_ANALYSIS_DEFAULT_PARAMETERS_JSON = "{\"lowVoltageAbsoluteThreshold\":0.0,\"lowVoltageProportionalThreshold\":0.0,\"highVoltageAbsoluteThreshold\":0.0,\"highVoltageProportionalThreshold\":0.0,\"flowProportionalThreshold\":0.1}"; @@ -292,7 +291,7 @@ void getResultZippedCsv() throws Exception { * RUN SECURITY ANALYSIS END */ - wireMockServer.stubFor(post(urlPathEqualTo( + wireMockServer.stubFor(WireMock.post(urlPathEqualTo( "/v1/results/" + SECURITY_ANALYSIS_RESULT_UUID + "/nmk-contingencies-result/csv" )).withQueryParam("resultType", equalTo(SecurityAnalysisResultType.NMK_CONTINGENCIES.name())) .withRequestBody(equalToJson(objectMapper.writeValueAsString(CSV_TRANSLATION_DTO_STRING))) @@ -303,7 +302,7 @@ void getResultZippedCsv() throws Exception { )); // get N security analysis result zipped csv - wireMockServer.stubFor(post(urlPathEqualTo( + wireMockServer.stubFor(WireMock.post(urlPathEqualTo( "/v1/results/" + SECURITY_ANALYSIS_RESULT_UUID + "/n-result/csv" )).withRequestBody(equalToJson(objectMapper.writeValueAsString(CSV_TRANSLATION_DTO_STRING))) .willReturn(aResponse() @@ -324,7 +323,7 @@ void getResultZippedCsv() throws Exception { // get NMK_CONTINGENCIES security analysis result zipped csv wireMockServer.stubFor( - post(urlPathEqualTo("/v1/results/" + SECURITY_ANALYSIS_RESULT_UUID + "/nmk-contingencies-result/csv")) + WireMock.post(urlPathEqualTo("/v1/results/" + SECURITY_ANALYSIS_RESULT_UUID + "/nmk-contingencies-result/csv")) .withRequestBody(equalTo(CSV_TRANSLATION_DTO_STRING)) .willReturn(aResponse() .withStatus(200) @@ -348,7 +347,7 @@ void getResultZippedCsv() throws Exception { // get NMK_CONSTRAINTS security analysis result zipped csv wireMockServer.stubFor( - post(urlPathEqualTo("/v1/results/" + SECURITY_ANALYSIS_RESULT_UUID + "/nmk-constraints-result/csv")) + WireMock.post(urlPathEqualTo("/v1/results/" + SECURITY_ANALYSIS_RESULT_UUID + "/nmk-constraints-result/csv")) .withRequestBody(equalTo(CSV_TRANSLATION_DTO_STRING)) .willReturn(aResponse() .withStatus(200) @@ -371,7 +370,7 @@ void getResultZippedCsv() throws Exception { // get NMK_CUT_OFF_POWER security analysis result zipped csv wireMockServer.stubFor( - post(urlPathEqualTo("/v1/results/" + SECURITY_ANALYSIS_RESULT_UUID + "/nmk-cut-off-power-result/csv")) + WireMock.post(urlPathEqualTo("/v1/results/" + SECURITY_ANALYSIS_RESULT_UUID + "/nmk-cut-off-power-result/csv")) .withRequestBody(equalTo(CSV_TRANSLATION_DTO_STRING)) .willReturn(aResponse() .withStatus(200) @@ -416,7 +415,7 @@ void getResultZippedCsvNotFound() throws Exception { // get NOT_FOUND security analysis result zipped csv wireMockServer.stubFor( - post(urlPathEqualTo("/v1/results/" + SECURITY_ANALYSIS_OTHER_NODE_RESULT_UUID + "/n-result/csv")) + WireMock.post(urlPathEqualTo("/v1/results/" + SECURITY_ANALYSIS_OTHER_NODE_RESULT_UUID + "/n-result/csv")) .withRequestBody(equalTo(CSV_TRANSLATION_DTO_STRING)) .willReturn(aResponse() .withStatus(404) @@ -645,10 +644,13 @@ private void testSecurityAnalysisWithRootNetworkUuidAndNodeUuid(UUID studyUuid, securityAnalysisServerStubs.verifyGetNmkCutOffPowerConstraintsResult(resultUuid, Map.of("page", WireMock.matching(".*"))); // --- 8. GET security analysis status --- - computationServerStubs.stubGetResultStatus(resultUuid, SECURITY_ANALYSIS_STATUS_JSON); + computationServerStubs.stubGetResultStatuses( + objectMapper.writeValueAsString(List.of(resultUuid)), + objectMapper.writeValueAsString(Map.of(resultUuid, SECURITY_ANALYSIS_STATUS_JSON)) + ); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/security-analysis/status", studyUuid, rootNetworkUuid, nodeUuid)).andExpectAll( status().isOk()).andReturn(); - computationServerStubs.verifyGetResultStatus(resultUuid); + computationServerStubs.verifyGetResultStatus(objectMapper.writeValueAsString(List.of(resultUuid))); // stop security analysis computationServerStubs.stubComputationStop(resultUuid); @@ -882,7 +884,7 @@ void testResetSecurityAnalysisParametersUserHasValidParamsInProfile() throws Exc UUID rootNodeUuid = getRootNode(studyUuid).getId(); UUID firstRootNetworkUuid = studyTestUtils.getOneRootNetworkUuid(studyUuid); NetworkModificationNode modificationNode1 = createNetworkModificationNode(studyUuid, rootNodeUuid, UUID.randomUUID(), VARIANT_ID, "node 1"); - wireMockServer.stubFor(post(urlPathMatching("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save.*")) + wireMockServer.stubFor(WireMock.post(urlPathMatching("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save.*")) .willReturn(ok())); userAdminServerStubs.stubGetUserProfile(VALID_PARAMS_IN_PROFILE_USER_ID, USER_PROFILE_VALID_PARAMS_JSON); computationServerStubs.stubDeleteParameters(SECURITY_ANALYSIS_PARAMETERS_UUID_STRING); diff --git a/src/test/java/org/gridsuite/study/server/service/client/dynamicmargincalculation/DynamicMarginCalculationClientTest.java b/src/test/java/org/gridsuite/study/server/service/client/dynamicmargincalculation/DynamicMarginCalculationClientTest.java index 49c5e96d2e..cb3efafbf9 100644 --- a/src/test/java/org/gridsuite/study/server/service/client/dynamicmargincalculation/DynamicMarginCalculationClientTest.java +++ b/src/test/java/org/gridsuite/study/server/service/client/dynamicmargincalculation/DynamicMarginCalculationClientTest.java @@ -25,16 +25,18 @@ import org.springframework.web.client.RestTemplate; import java.util.List; +import java.util.Map; import java.util.UUID; import static com.github.tomakehurst.wiremock.client.WireMock.absent; +import static com.github.tomakehurst.wiremock.client.WireMock.containing; import static com.github.tomakehurst.wiremock.client.WireMock.equalTo; +import static org.assertj.core.api.Assertions.assertThat; import static org.gridsuite.study.server.StudyConstants.*; import static org.gridsuite.study.server.notification.NotificationService.HEADER_USER_ID; import static org.gridsuite.study.server.service.client.RestClient.DELIMITER; import static org.gridsuite.study.server.service.client.dynamicmargincalculation.DynamicMarginCalculationClient.*; import static org.gridsuite.study.server.service.client.util.UrlUtil.buildEndPointUrl; -import static org.gridsuite.study.server.utils.assertions.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertThrows; /** @@ -348,10 +350,11 @@ void testRun() throws Exception { @Test void testGetStatus() throws Exception { // configure mock server response - String url = RESULT_BASE_URL + DELIMITER + RESULT_UUID + "/status"; - wireMockServer.stubFor(WireMock.get(WireMock.urlEqualTo(url)) + String url = RESULT_BASE_URL + DELIMITER + "statuses"; + wireMockServer.stubFor(WireMock.post(WireMock.urlEqualTo(url)) + .withRequestBody(containing(RESULT_UUID.toString())) .willReturn(WireMock.ok() - .withBody(objectMapper.writeValueAsString(DynamicMarginCalculationStatus.SUCCEED)) + .withBody(objectMapper.writeValueAsString(Map.of(RESULT_UUID, DynamicMarginCalculationStatus.SUCCEED))) .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) )); // call service to test diff --git a/src/test/java/org/gridsuite/study/server/service/client/dynamicsecurityanalysis/DynamicSecurityAnalysisClientTest.java b/src/test/java/org/gridsuite/study/server/service/client/dynamicsecurityanalysis/DynamicSecurityAnalysisClientTest.java index 5918f9bae3..8b915bf9ba 100644 --- a/src/test/java/org/gridsuite/study/server/service/client/dynamicsecurityanalysis/DynamicSecurityAnalysisClientTest.java +++ b/src/test/java/org/gridsuite/study/server/service/client/dynamicsecurityanalysis/DynamicSecurityAnalysisClientTest.java @@ -25,9 +25,11 @@ import org.springframework.web.client.RestTemplate; import java.util.List; +import java.util.Map; import java.util.UUID; import static com.github.tomakehurst.wiremock.client.WireMock.absent; +import static com.github.tomakehurst.wiremock.client.WireMock.containing; import static com.github.tomakehurst.wiremock.client.WireMock.equalTo; import static org.gridsuite.study.server.StudyConstants.*; import static org.gridsuite.study.server.notification.NotificationService.HEADER_USER_ID; @@ -347,10 +349,11 @@ void testRun() throws Exception { @Test void testGetStatus() throws Exception { // configure mock server response - String url = RESULT_BASE_URL + DELIMITER + RESULT_UUID + "/status"; - wireMockServer.stubFor(WireMock.get(WireMock.urlEqualTo(url)) + String url = RESULT_BASE_URL + DELIMITER + "statuses"; + wireMockServer.stubFor(WireMock.post(WireMock.urlEqualTo(url)) + .withRequestBody(containing(RESULT_UUID.toString())) .willReturn(WireMock.ok() - .withBody(objectMapper.writeValueAsString(DynamicSecurityAnalysisStatus.SUCCEED)) + .withBody(objectMapper.writeValueAsString(Map.of(RESULT_UUID, DynamicSecurityAnalysisStatus.SUCCEED))) .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) )); // call service to test diff --git a/src/test/java/org/gridsuite/study/server/service/client/dynamicsimulation/DynamicSimulationClientTest.java b/src/test/java/org/gridsuite/study/server/service/client/dynamicsimulation/DynamicSimulationClientTest.java index d430422595..3592ff1c1b 100644 --- a/src/test/java/org/gridsuite/study/server/service/client/dynamicsimulation/DynamicSimulationClientTest.java +++ b/src/test/java/org/gridsuite/study/server/service/client/dynamicsimulation/DynamicSimulationClientTest.java @@ -26,8 +26,10 @@ import org.springframework.web.client.RestTemplate; import java.util.List; +import java.util.Map; import java.util.UUID; +import static com.github.tomakehurst.wiremock.client.WireMock.containing; import static com.github.tomakehurst.wiremock.client.WireMock.equalTo; import static org.assertj.core.api.Assertions.assertThat; import static org.gridsuite.study.server.StudyConstants.*; @@ -408,10 +410,11 @@ void testGetTimelineResultGivenBadUuid() { @Test void testGetStatus() throws Exception { - // configure mock server response for test get status result - results/{resultUuid}/status - wireMockServer.stubFor(WireMock.get(WireMock.urlEqualTo(DYNAMIC_SIMULATION_RESULT_BASE_URL + DELIMITER + RESULT_UUID + DELIMITER + "status")) + // configure mock server response for test get status result - results/statuses + wireMockServer.stubFor(WireMock.post(WireMock.urlEqualTo(DYNAMIC_SIMULATION_RESULT_BASE_URL + DELIMITER + "statuses")) + .withRequestBody(containing(RESULT_UUID.toString())) .willReturn(WireMock.ok() - .withBody(objectMapper.writeValueAsString(DynamicSimulationStatus.CONVERGED)) + .withBody(objectMapper.writeValueAsString(Map.of(RESULT_UUID, DynamicSimulationStatus.CONVERGED))) .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) )); DynamicSimulationStatus status = dynamicSimulationClient.getStatus(RESULT_UUID); @@ -422,7 +425,8 @@ void testGetStatus() throws Exception { @Test void testGetStatusGivenBadUuid() { // configure mock server response - wireMockServer.stubFor(WireMock.get(WireMock.urlEqualTo(DYNAMIC_SIMULATION_RESULT_BASE_URL + DELIMITER + RESULT_NOT_FOUND_UUID + DELIMITER + "status")) + wireMockServer.stubFor(WireMock.post(WireMock.urlEqualTo(DYNAMIC_SIMULATION_RESULT_BASE_URL + DELIMITER + "statuses")) + .withRequestBody(containing(RESULT_NOT_FOUND_UUID.toString())) .willReturn(WireMock.notFound() )); assertThrows( diff --git a/src/test/java/org/gridsuite/study/server/service/client/timeseries/TimeSeriesClientTest.java b/src/test/java/org/gridsuite/study/server/service/client/timeseries/TimeSeriesClientTest.java index a421880b85..48ced1fbfe 100644 --- a/src/test/java/org/gridsuite/study/server/service/client/timeseries/TimeSeriesClientTest.java +++ b/src/test/java/org/gridsuite/study/server/service/client/timeseries/TimeSeriesClientTest.java @@ -20,8 +20,6 @@ import mockwebserver3.junit5.internal.MockWebServerExtension; import okhttp3.Headers; import okhttp3.HttpUrl; -import org.apache.commons.collections4.CollectionUtils; -import org.apache.commons.collections4.ListUtils; import org.gridsuite.study.server.ContextConfigurationWithTestChannel; import org.gridsuite.study.server.RemoteServicesProperties; import org.gridsuite.study.server.dto.timeseries.rest.TimeSeriesGroupRest; @@ -38,11 +36,11 @@ import org.springframework.http.HttpHeaders; import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; +import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; import java.util.*; -import static org.apache.commons.collections4.CollectionUtils.emptyIfNull; import static org.assertj.core.api.Assertions.assertThat; import static org.gridsuite.study.server.service.client.timeseries.TimeSeriesClient.API_VERSION; import static org.gridsuite.study.server.service.client.timeseries.TimeSeriesClient.TIME_SERIES_END_POINT; @@ -92,7 +90,7 @@ public MockResponse dispatch(@NotNull RecordedRequest recordedRequest) { String method = recordedRequest.getMethod(); MockResponse response = new MockResponse(HttpStatus.NOT_FOUND.value()); - List pathSegments = ListUtils.emptyIfNull(recordedRequest.getRequestUrl().pathSegments()); + List pathSegments = Optional.ofNullable(recordedRequest.getRequestUrl().pathSegments()).orElse(List.of()); // timeseries-group/{groupUuid}/xxx if ("GET".equals(method) && path.matches(TIME_SERIES_BASE_URL + "/.*")) { @@ -111,7 +109,7 @@ public MockResponse dispatch(@NotNull RecordedRequest recordedRequest) { } } else { // take {groupUuid} at the last - String groupUuid = emptyIfNull(recordedRequest.getRequestUrl().pathSegments()).stream().reduce((first, second) -> second).orElse(""); + String groupUuid = Optional.ofNullable(recordedRequest.getRequestUrl().pathSegments()).orElse(List.of()).stream().reduce((first, second) -> second).orElse(""); String timeSeriesNames = recordedRequest.getRequestUrl().queryParameter("timeSeriesNames"); LOGGER.info("sent timeSeriesNames = {}", timeSeriesNames); List> timeseries; diff --git a/src/test/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationServiceTest.java b/src/test/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationServiceTest.java index 29b785f00b..b51f4259dd 100644 --- a/src/test/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationServiceTest.java +++ b/src/test/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationServiceTest.java @@ -17,6 +17,7 @@ import org.springframework.test.context.bean.override.mockito.MockitoBean; import java.util.List; +import java.util.Map; import java.util.UUID; import static org.assertj.core.api.Assertions.assertThat; @@ -130,7 +131,7 @@ void testRunDynamicSimulation() { @Test void testGetStatus() { // setup DynamicMarginCalculationClient mock - given(dynamicMarginCalculationClient.getStatus(RESULT_UUID)).willReturn(DynamicMarginCalculationStatus.SUCCEED); + given(dynamicMarginCalculationClient.getStatuses(List.of(RESULT_UUID))).willReturn(Map.of(RESULT_UUID, DynamicMarginCalculationStatus.SUCCEED)); // call method to be tested DynamicMarginCalculationStatus status = dynamicMarginCalculationService.getStatus(RESULT_UUID); @@ -178,18 +179,18 @@ void testResultCount() { @Test void testAssertDynamicSecurityAnalysisNotRunning() { - when(dynamicMarginCalculationClient.getStatus(RESULT_UUID)).thenReturn(DynamicMarginCalculationStatus.SUCCEED); + when(dynamicMarginCalculationClient.getStatuses(List.of(RESULT_UUID))).thenReturn(Map.of(RESULT_UUID, DynamicMarginCalculationStatus.SUCCEED)); // test not running assertDoesNotThrow(() -> dynamicMarginCalculationService.assertDynamicMarginCalculationNotRunning(RESULT_UUID)); - verify(dynamicMarginCalculationClient, times(1)).getStatus(RESULT_UUID); + verify(dynamicMarginCalculationClient, times(1)).getStatuses(List.of(RESULT_UUID)); } @Test void testAssertDynamicSecurityAnalysisRunning() { // setup for running node - given(dynamicMarginCalculationClient.getStatus(RESULT_UUID_RUNNING)).willReturn(DynamicMarginCalculationStatus.RUNNING); + given(dynamicMarginCalculationClient.getStatuses(List.of(RESULT_UUID_RUNNING))).willReturn(Map.of(RESULT_UUID_RUNNING, DynamicMarginCalculationStatus.RUNNING)); // test running assertStudyException(() -> dynamicMarginCalculationService.assertDynamicMarginCalculationNotRunning(RESULT_UUID_RUNNING), diff --git a/src/test/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisServiceTest.java b/src/test/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisServiceTest.java index e84f31ee43..0ede2480a7 100644 --- a/src/test/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisServiceTest.java +++ b/src/test/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisServiceTest.java @@ -17,6 +17,7 @@ import org.springframework.test.context.bean.override.mockito.MockitoBean; import java.util.List; +import java.util.Map; import java.util.UUID; import static org.assertj.core.api.Assertions.assertThat; @@ -129,7 +130,7 @@ void testRunDynamicSimulation() { @Test void testGetStatus() { // setup DynamicSecurityAnalysisClient mock - given(dynamicSecurityAnalysisClient.getStatus(RESULT_UUID)).willReturn(DynamicSecurityAnalysisStatus.SUCCEED); + given(dynamicSecurityAnalysisClient.getStatuses(List.of(RESULT_UUID))).willReturn(Map.of(RESULT_UUID, DynamicSecurityAnalysisStatus.SUCCEED)); // call method to be tested DynamicSecurityAnalysisStatus status = dynamicSecurityAnalysisService.getStatus(RESULT_UUID); @@ -177,18 +178,18 @@ void testResultCount() { @Test void testAssertDynamicSecurityAnalysisNotRunning() { - when(dynamicSecurityAnalysisClient.getStatus(RESULT_UUID)).thenReturn(DynamicSecurityAnalysisStatus.SUCCEED); + when(dynamicSecurityAnalysisClient.getStatuses(List.of(RESULT_UUID))).thenReturn(Map.of(RESULT_UUID, DynamicSecurityAnalysisStatus.SUCCEED)); // test not running assertDoesNotThrow(() -> dynamicSecurityAnalysisService.assertDynamicSecurityAnalysisNotRunning(RESULT_UUID)); - verify(dynamicSecurityAnalysisClient, times(1)).getStatus(RESULT_UUID); + verify(dynamicSecurityAnalysisClient, times(1)).getStatuses(List.of(RESULT_UUID)); } @Test void testAssertDynamicSecurityAnalysisRunning() { // setup for running node - given(dynamicSecurityAnalysisClient.getStatus(RESULT_UUID_RUNNING)).willReturn(DynamicSecurityAnalysisStatus.RUNNING); + given(dynamicSecurityAnalysisClient.getStatuses(List.of(RESULT_UUID_RUNNING))).willReturn(Map.of(RESULT_UUID_RUNNING, DynamicSecurityAnalysisStatus.RUNNING)); // test running assertStudyException(() -> dynamicSecurityAnalysisService.assertDynamicSecurityAnalysisNotRunning(RESULT_UUID_RUNNING), diff --git a/src/test/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationServiceTest.java b/src/test/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationServiceTest.java index 9107a35272..9aed066e14 100644 --- a/src/test/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationServiceTest.java +++ b/src/test/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationServiceTest.java @@ -265,7 +265,7 @@ void testGetTimelineResultGivenBadType() throws Exception { @Test void testGetStatus() { // setup DynamicSimulationClient mock - given(dynamicSimulationClient.getStatus(RESULT_UUID)).willReturn(DynamicSimulationStatus.CONVERGED); + given(dynamicSimulationClient.getStatuses(List.of(RESULT_UUID))).willReturn(Map.of(RESULT_UUID, DynamicSimulationStatus.CONVERGED)); // call method to be tested DynamicSimulationStatus status = dynamicSimulationService.getStatus(RESULT_UUID); @@ -295,7 +295,7 @@ void testAssertDynamicSimulationNotRunning() { @Test void testAssertDynamicSimulationRunning() { // setup for running node - given(dynamicSimulationClient.getStatus(RESULT_UUID_RUNNING)).willReturn(DynamicSimulationStatus.RUNNING); + given(dynamicSimulationClient.getStatuses(List.of(RESULT_UUID_RUNNING))).willReturn(Map.of(RESULT_UUID_RUNNING, DynamicSimulationStatus.RUNNING)); given(rootNetworkNodeInfoService.getComputationResultUuid(NODE_UUID_RUNNING, ROOTNETWORK_UUID, ComputationType.DYNAMIC_SIMULATION)).willReturn(RESULT_UUID_RUNNING); // test running diff --git a/src/test/java/org/gridsuite/study/server/studycontroller/NodeControllerTest.java b/src/test/java/org/gridsuite/study/server/studycontroller/NodeControllerTest.java index 1839778c13..a8dd77f01b 100644 --- a/src/test/java/org/gridsuite/study/server/studycontroller/NodeControllerTest.java +++ b/src/test/java/org/gridsuite/study/server/studycontroller/NodeControllerTest.java @@ -414,7 +414,7 @@ private void cutAndPasteNode(UUID studyUuid, NetworkModificationNode nodeToCopy, boolean wasBuilt = rootNetworkNodeInfoService.getRootNetworkNodeInfo(nodeToCopy.getId(), studyTestUtils.getOneRootNetworkUuid(studyUuid)).get().getNodeBuildStatus().toDto().isBuilt(); UUID deleteModificationIndexStub = wireMockStubs.stubNetworkModificationDeleteIndex(); output.receive(TIMEOUT, studyUpdateDestination); - doNothing().when(rootNetworkNodeInfoService).assertComputationNotRunning(any(), any()); + doNothing().when(rootNetworkNodeInfoService).assertComputationsNotRunning(any(), any()); mockMvc.perform(post(STUDIES_URL + "/{studyUuid}/tree/nodes?nodeToCutUuid={nodeUuid}&referenceNodeUuid={referenceNodeUuid}&insertMode={insertMode}", studyUuid, nodeToCopy.getId(), referenceNodeUuid, insertMode) diff --git a/src/test/java/org/gridsuite/study/server/utils/wiremock/ComputationServerStubs.java b/src/test/java/org/gridsuite/study/server/utils/wiremock/ComputationServerStubs.java index f3cccbf20d..c2cd990921 100644 --- a/src/test/java/org/gridsuite/study/server/utils/wiremock/ComputationServerStubs.java +++ b/src/test/java/org/gridsuite/study/server/utils/wiremock/ComputationServerStubs.java @@ -23,6 +23,7 @@ /** * @author Maissa Souissi + * @author Sylvain Bouzols */ public class ComputationServerStubs { private final WireMockServer wireMock; @@ -63,6 +64,14 @@ public UUID stubGetResultStatus(String resultUuid, String statusJson) { .withBody(statusJson))).getId(); } + public UUID stubGetResultStatuses(String resultUuidsAsJson, String responseBody) { + return wireMock.stubFor(WireMock.post(WireMock.urlPathEqualTo("/v1/results/statuses")) + .withRequestBody(equalToJson(resultUuidsAsJson)) + .willReturn(WireMock.ok() + .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .withBody(responseBody))).getId(); + } + public UUID stubGetResult(String resultUuid, String statusJson) { return wireMock.stubFor(WireMock.get(WireMock.urlPathEqualTo("/v1/results/" + resultUuid)).withQueryParam("mode", WireMock.equalTo("FULL")) .willReturn(WireMock.ok() @@ -74,12 +83,12 @@ public void verifyComputationStop(String resultUuid, Map