diff --git a/src/main/java/org/gridsuite/shortcircuit/server/RestResponseEntityExceptionHandler.java b/src/main/java/org/gridsuite/shortcircuit/server/RestResponseEntityExceptionHandler.java index 454c3cc5..039f3fbd 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/RestResponseEntityExceptionHandler.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/RestResponseEntityExceptionHandler.java @@ -20,7 +20,7 @@ public class RestResponseEntityExceptionHandler { @ExceptionHandler(ShortCircuitException.class) protected ResponseEntity handleShortCircuitException(ShortCircuitException exception) { return switch (exception.getType()) { - case RESULT_NOT_FOUND -> ResponseEntity.status(HttpStatus.NOT_FOUND).body(exception.getMessage()); + case RESULT_NOT_FOUND, PARAMETERS_NOT_FOUND -> ResponseEntity.status(HttpStatus.NOT_FOUND).body(exception.getMessage()); case INVALID_EXPORT_PARAMS -> ResponseEntity.status(HttpStatus.BAD_REQUEST).body(exception.getMessage()); case BUS_OUT_OF_VOLTAGE, FILE_EXPORT_ERROR, MISSING_EXTENSION_DATA, INCONSISTENT_VOLTAGE_LEVELS -> ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(exception.getMessage()); diff --git a/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitController.java b/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitController.java index 4597d8e1..4cbb11d8 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitController.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitController.java @@ -9,6 +9,7 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.powsybl.iidm.network.ThreeSides; import com.powsybl.security.LimitViolationType; + import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.responses.ApiResponse; @@ -16,8 +17,11 @@ import io.swagger.v3.oas.annotations.tags.Tag; import lombok.AllArgsConstructor; import org.gridsuite.computation.dto.GlobalFilter; +import org.gridsuite.computation.dto.ReportInfos; +import org.gridsuite.computation.service.UuidGeneratorService; import org.gridsuite.computation.utils.FilterUtils; import org.gridsuite.shortcircuit.server.dto.*; +import org.gridsuite.shortcircuit.server.service.ShortCircuitRunContext; import org.gridsuite.shortcircuit.server.service.ShortCircuitService; import org.springframework.core.io.Resource; import org.springframework.data.domain.Page; @@ -29,7 +33,6 @@ import java.net.URLDecoder; import java.nio.charset.StandardCharsets; import java.util.List; -import java.util.Optional; import java.util.UUID; import static com.powsybl.shortcircuit.Fault.FaultType; @@ -46,6 +49,7 @@ public class ShortCircuitController { private final ShortCircuitService shortCircuitService; + private final UuidGeneratorService uuidGeneratorService; private final ObjectMapper objectMapper; @PostMapping(value = "/networks/{networkUuid}/run-and-save", produces = APPLICATION_JSON_VALUE) @@ -59,9 +63,23 @@ public ResponseEntity runAndSave(@Parameter(description = "Network UUID") @Parameter(description = "The type name for the report") @RequestParam(name = "reportType", required = false) String reportType, @Parameter(description = "Bus Id - Used for analysis targeting one bus") @RequestParam(name = "busId", required = false) String busId, @Parameter(description = "Debug") @RequestParam(name = "debug", required = false, defaultValue = "false") boolean debug, - @Parameter(description = "ID of parameters to use, fallback on default ones if none") @RequestParam(name = "parametersUuid") Optional parametersUuid, + @Parameter(description = "ID of parameters to use, fallback on default ones if none") @RequestParam(name = "parametersUuid", required = false) UUID parametersUuid, + @Parameter(description = "resultUuid") @RequestParam(name = "resultUuid", required = false) UUID resultUuid, @RequestHeader(HEADER_USER_ID) String userId) { - return ResponseEntity.ok().contentType(APPLICATION_JSON).body(shortCircuitService.runAndSaveResult(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, busId, debug, parametersUuid)); + UUID resultUuidToRun = resultUuid != null ? resultUuid : uuidGeneratorService.generate(); + ShortCircuitRunContext shortCircuitRunContext = ShortCircuitRunContext.builder() + .resultUuid(resultUuidToRun) + .networkUuid(networkUuid) + .variantId(variantId) + .receiver(receiver) + .reportInfos(ReportInfos.builder().reportUuid(reportUuid).reporterId(reporterId).computationType(reportType).build()) + .userId(userId) + .parametersUuid(parametersUuid) + .busId(busId) + .debug(debug) + .provider("default-provider") // TODO : replace with null when fix in powsybl-ws-commons will handle null provider + .build(); + return ResponseEntity.ok().contentType(APPLICATION_JSON).body(shortCircuitService.runAndSaveResult(shortCircuitRunContext)); } @GetMapping(value = "/results/{resultUuid}", produces = APPLICATION_JSON_VALUE) diff --git a/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitException.java b/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitException.java index d55f1d4c..e1ea3688 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitException.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitException.java @@ -22,7 +22,8 @@ public enum Type { INVALID_EXPORT_PARAMS, FILE_EXPORT_ERROR, MISSING_EXTENSION_DATA, - INCONSISTENT_VOLTAGE_LEVELS + INCONSISTENT_VOLTAGE_LEVELS, + PARAMETERS_NOT_FOUND } private final Type type; diff --git a/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersController.java b/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersController.java index 711062c2..c06c89ae 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersController.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersController.java @@ -12,10 +12,15 @@ import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.tags.Tag; import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersInfos; -import org.gridsuite.shortcircuit.server.service.ShortCircuitService; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; +import org.gridsuite.shortcircuit.server.service.ShortCircuitParametersService; +import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; import java.util.UUID; import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; @@ -26,10 +31,10 @@ public class ShortCircuitParametersController { public static final String DUPLICATE_FROM = "duplicateFrom"; - private final ShortCircuitService shortCircuitService; + private final ShortCircuitParametersService shortCircuitParametersService; - public ShortCircuitParametersController(ShortCircuitService shortCircuitService) { - this.shortCircuitService = shortCircuitService; + public ShortCircuitParametersController(ShortCircuitParametersService shortCircuitParametersService) { + this.shortCircuitParametersService = shortCircuitParametersService; } @GetMapping(path = "/{parametersUuid}") @@ -37,21 +42,40 @@ public ShortCircuitParametersController(ShortCircuitService shortCircuitService) @ApiResponse(responseCode = "200", description = "The parameters asked") @ApiResponse(responseCode = "404", description = "The parameters don't exists") public ResponseEntity getParameters(@Parameter(description = "UUID of parameters") @PathVariable("parametersUuid") UUID parametersUuid) { - return ResponseEntity.of(shortCircuitService.getParameters(parametersUuid)); + return ResponseEntity.of(shortCircuitParametersService.getParameters(parametersUuid)); + } + + @GetMapping(value = "/{parametersUuid}/values", produces = MediaType.APPLICATION_JSON_VALUE) + @Operation(summary = "Get parameters values") + @ApiResponse(responseCode = "200", description = "parameters values were returned") + @ApiResponse(responseCode = "404", description = "parameters were not found") + public ResponseEntity getParametersValues( + @Parameter(description = "parameters UUID") @PathVariable("parametersUuid") UUID parametersUuid, + @Parameter(description = "provider name") @RequestParam("provider") String provider) { + return ResponseEntity.of(shortCircuitParametersService.getParametersValues(parametersUuid, provider)); + } + + @GetMapping(value = "/specific-parameters") + @Operation(summary = "Get all existing shortcircuit specific parameters for a given provider, or for all of them") + @ApiResponse(responseCode = "200", description = "The shortcircuit model-specific parameters") + public ResponseEntity>> getSpecificShortCircuitParameters( + @Parameter(description = "The model provider") @RequestParam(name = "provider", required = false) String provider) { + return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON) + .body(ShortCircuitParametersService.getSpecificShortCircuitParameters(provider)); } @PostMapping(consumes = APPLICATION_JSON_VALUE) @Operation(summary = "Create a new set of parameters for an analysis using given parameters") @ApiResponse(responseCode = "200", description = "The new parameters entity ID") public ResponseEntity createParameters(@Parameter(description = "Parameters to save") @RequestBody ShortCircuitParametersInfos parameters) { - return ResponseEntity.ok(shortCircuitService.createParameters(parameters)); + return ResponseEntity.ok(shortCircuitParametersService.createParameters(parameters)); } @PostMapping(path = "/default") @Operation(summary = "Create a new set of parameters for an analysis using default parameters") @ApiResponse(responseCode = "200", description = "The new parameters entity ID") public ResponseEntity createDefaultParameters() { - return ResponseEntity.ok(shortCircuitService.createParameters(null)); + return ResponseEntity.ok(shortCircuitParametersService.createDefaultParameters()); } @PostMapping(params = { DUPLICATE_FROM }) @@ -59,24 +83,29 @@ public ResponseEntity createDefaultParameters() { @ApiResponse(responseCode = "200", description = "The new parameters ID") @ApiResponse(responseCode = "404", description = "The parameters don't exist") public ResponseEntity duplicateParameters(@Parameter(description = "UUID of parameters to duplicate") @RequestParam(name = DUPLICATE_FROM) UUID sourceParametersUuid) { - return ResponseEntity.of(shortCircuitService.duplicateParameters(sourceParametersUuid)); + return ResponseEntity.of(shortCircuitParametersService.duplicateParameters(sourceParametersUuid)); } @DeleteMapping(path = "/{parametersUuid}") @Operation(summary = "Delete a set of parameters") - @ApiResponse(responseCode = "204", description = "The parameters are successfully deleted") + @ApiResponse(responseCode = "200", description = "The parameters are successfully deleted") @ApiResponse(responseCode = "404", description = "The parameters don't exists") public ResponseEntity deleteParameters(@Parameter(description = "UUID of parameters") @PathVariable("parametersUuid") UUID parametersUuid) { - return (shortCircuitService.deleteParameters(parametersUuid) ? ResponseEntity.noContent() : ResponseEntity.notFound()).build(); + return (shortCircuitParametersService.deleteParameters(parametersUuid) ? ResponseEntity.ok() : ResponseEntity.notFound()).build(); } @PutMapping(path = "/{parametersUuid}", consumes = APPLICATION_JSON_VALUE) @Operation(summary = "Update parameters for an analysis or reset them to default ones") - @ApiResponse(responseCode = "204", description = "The parameters are successfully updated") + @ApiResponse(responseCode = "200", description = "The parameters are successfully updated") @ApiResponse(responseCode = "404", description = "The parameters don't exists") public ResponseEntity updateOrResetParameters(@Parameter(description = "UUID of parameters") @PathVariable("parametersUuid") UUID parametersUuid, @Parameter(description = "Parameters to save instead of default ones", schema = @Schema(implementation = ShortCircuitParametersInfos.class)) @RequestBody(required = false) ShortCircuitParametersInfos parameters) { - return (shortCircuitService.updateOrResetParameters(parametersUuid, parameters) ? ResponseEntity.noContent() : ResponseEntity.notFound()).build(); + try { + shortCircuitParametersService.updateParameters(parametersUuid, parameters); + return ResponseEntity.ok().build(); + } catch (NoSuchElementException e) { + return ResponseEntity.notFound().build(); + } } } diff --git a/src/main/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersInfos.java b/src/main/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersInfos.java index e4f1c0ca..064ce42e 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersInfos.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersInfos.java @@ -12,9 +12,12 @@ import com.powsybl.shortcircuit.VoltageRange; import lombok.Builder; import lombok.extern.jackson.Jacksonized; -import org.gridsuite.shortcircuit.server.service.ShortCircuitService; + +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitParametersConstants; +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitParametersEntity; import java.util.List; +import java.util.Map; /** * @since 1.7.0 @@ -23,10 +26,15 @@ @Jacksonized public record ShortCircuitParametersInfos( ShortCircuitPredefinedConfiguration predefinedParameters, - ShortCircuitParameters parameters + ShortCircuitParameters commonParameters, + Map> specificParametersPerProvider ) { @JsonProperty(access = Access.READ_ONLY) public List cei909VoltageRanges() { - return ShortCircuitService.CEI909_VOLTAGE_PROFILE; + return ShortCircuitParametersConstants.CEI909_VOLTAGE_PROFILE; + } + + public ShortCircuitParametersEntity toEntity() { + return new ShortCircuitParametersEntity(this); } } diff --git a/src/main/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersValues.java b/src/main/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersValues.java new file mode 100644 index 00000000..88962bf6 --- /dev/null +++ b/src/main/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersValues.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2024, 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.shortcircuit.server.dto; + +import com.powsybl.shortcircuit.ShortCircuitParameters; + +import lombok.Builder; +// import lombok.extern.jackson.Jacksonized; + +import java.util.Map; + +/** + * @since 1.7.0 + */ +// @Jacksonized +@Builder +public record ShortCircuitParametersValues( + String provider, + ShortCircuitPredefinedConfiguration predefinedParameters, + ShortCircuitParameters commonParameters, + Map specificParameters +) { +} diff --git a/src/main/java/org/gridsuite/shortcircuit/server/entities/ShortCircuitParametersEntity.java b/src/main/java/org/gridsuite/shortcircuit/server/entities/ShortCircuitParametersEntity.java deleted file mode 100644 index 61b0ce72..00000000 --- a/src/main/java/org/gridsuite/shortcircuit/server/entities/ShortCircuitParametersEntity.java +++ /dev/null @@ -1,118 +0,0 @@ -/* - * Copyright (c) 2024, 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.shortcircuit.server.entities; - -import com.powsybl.shortcircuit.InitialVoltageProfileMode; -import com.powsybl.shortcircuit.StudyType; -import jakarta.persistence.*; -import lombok.*; -import lombok.experimental.Accessors; -import org.gridsuite.shortcircuit.server.dto.ShortCircuitPredefinedConfiguration; - -import java.util.UUID; - -/** - * @since 1.7.0 - */ -@Builder -@NoArgsConstructor -@AllArgsConstructor -@Accessors(chain = true) -@Getter -@Setter -@Entity -@Table(name = "shortcircuit_parameters") -public class ShortCircuitParametersEntity { - - public ShortCircuitParametersEntity(boolean withLimitViolations, boolean withVoltageResult, boolean withFeederResult, StudyType studyType, - double minVoltageDropProportionalThreshold, ShortCircuitPredefinedConfiguration predefinedParameters, - boolean withLoads, boolean withShuntCompensators, boolean withVscConverterStations, boolean withNeutralPosition, - InitialVoltageProfileMode initialVoltageProfileMode) { - this(null, withLimitViolations, withVoltageResult, withFeederResult, studyType, minVoltageDropProportionalThreshold, - predefinedParameters, withLoads, withShuntCompensators, withVscConverterStations, withNeutralPosition, initialVoltageProfileMode); - } - - public ShortCircuitParametersEntity(@NonNull final ShortCircuitParametersEntity sourceToClone) { - this(sourceToClone.isWithLimitViolations(), - sourceToClone.isWithVoltageResult(), - sourceToClone.isWithFeederResult(), - sourceToClone.getStudyType(), - sourceToClone.getMinVoltageDropProportionalThreshold(), - sourceToClone.getPredefinedParameters(), - sourceToClone.isWithLoads(), - sourceToClone.isWithShuntCompensators(), - sourceToClone.isWithVscConverterStations(), - sourceToClone.isWithNeutralPosition(), - sourceToClone.getInitialVoltageProfileMode()); - } - - @Id - @GeneratedValue(strategy = GenerationType.AUTO) - @Column(name = "id") - private UUID id; - - @Builder.Default - @Column(name = "withLimitViolations", nullable = false, columnDefinition = "boolean default true") - private boolean withLimitViolations = true; - - @Builder.Default - @Column(name = "withVoltageResult", nullable = false, columnDefinition = "boolean default false") - private boolean withVoltageResult = false; - - @Builder.Default - @Column(name = "withFeederResult", nullable = false, columnDefinition = "boolean default false") - private boolean withFeederResult = false; - - @Builder.Default - @Column(name = "studyType", columnDefinition = "varchar(255) default 'TRANSIENT'") - @Enumerated(EnumType.STRING) - private StudyType studyType = StudyType.TRANSIENT; - - @Builder.Default - @Column(name = "minVoltageDropProportionalThreshold", nullable = false, columnDefinition = "double precision default 20.0") - private double minVoltageDropProportionalThreshold = 20.0; - - @Builder.Default - @Column(name = "predefinedParameters", columnDefinition = "varchar(255) default 'ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP'") - @Enumerated(EnumType.STRING) - private ShortCircuitPredefinedConfiguration predefinedParameters = ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP; - - @Builder.Default - @Column(name = "withLoads", nullable = false, columnDefinition = "boolean default false") - private boolean withLoads = false; - - @Builder.Default - @Column(name = "withShuntCompensators", nullable = false, columnDefinition = "boolean default false") - private boolean withShuntCompensators = false; - - @Builder.Default - @Column(name = "withVscConverterStations", nullable = false, columnDefinition = "boolean default true") - private boolean withVscConverterStations = true; - - @Builder.Default - @Column(name = "withNeutralPosition", nullable = false, columnDefinition = "boolean default true") - private boolean withNeutralPosition = true; - - @Builder.Default - @Column(name = "initialVoltageProfileMode", columnDefinition = "varchar(255) default 'NOMINAL'") - @Enumerated(EnumType.STRING) - private InitialVoltageProfileMode initialVoltageProfileMode = InitialVoltageProfileMode.NOMINAL; - - public ShortCircuitParametersEntity updateWith(final ShortCircuitParametersEntity source) { - return this.setWithLimitViolations(source.isWithLimitViolations()) - .setWithVoltageResult(source.isWithVoltageResult()) - .setWithFeederResult(source.isWithFeederResult()) - .setStudyType(source.getStudyType()) - .setMinVoltageDropProportionalThreshold(source.getMinVoltageDropProportionalThreshold()) - .setPredefinedParameters(source.getPredefinedParameters()) - .setWithLoads(source.isWithLoads()) - .setWithShuntCompensators(source.isWithShuntCompensators()) - .setWithVscConverterStations(source.isWithVscConverterStations()) - .setWithNeutralPosition(source.isWithNeutralPosition()) - .setInitialVoltageProfileMode(source.getInitialVoltageProfileMode()); - } -} diff --git a/src/main/java/org/gridsuite/shortcircuit/server/entities/parameters/ShortCircuitParametersConstants.java b/src/main/java/org/gridsuite/shortcircuit/server/entities/parameters/ShortCircuitParametersConstants.java new file mode 100644 index 00000000..be09e344 --- /dev/null +++ b/src/main/java/org/gridsuite/shortcircuit/server/entities/parameters/ShortCircuitParametersConstants.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2025, 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.shortcircuit.server.entities.parameters; + +import com.powsybl.shortcircuit.VoltageRange; + +import java.util.List; + +/** + * Shared constants for short circuit parameters. + */ +public final class ShortCircuitParametersConstants { + // This voltage intervals' definition is not clean and we could potentially lose some buses. + // To be cleaned when VoltageRange uses intervals that are open on the right. + // TODO: to be moved to RTE private config or to powsybl-rte-core + public static final List CEI909_VOLTAGE_PROFILE = List.of( + new VoltageRange(0, 199.999, 1.1), + new VoltageRange(200.0, 299.999, 1.09), + new VoltageRange(300.0, 389.99, 1.10526), + new VoltageRange(390.0, 410.0, 1.05) + ); + + private ShortCircuitParametersConstants() { + // utility class + } +} diff --git a/src/main/java/org/gridsuite/shortcircuit/server/entities/parameters/ShortCircuitParametersEntity.java b/src/main/java/org/gridsuite/shortcircuit/server/entities/parameters/ShortCircuitParametersEntity.java new file mode 100644 index 00000000..ac3b4a96 --- /dev/null +++ b/src/main/java/org/gridsuite/shortcircuit/server/entities/parameters/ShortCircuitParametersEntity.java @@ -0,0 +1,171 @@ +/* + * Copyright (c) 2024, 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.shortcircuit.server.entities.parameters; + +import com.powsybl.shortcircuit.InitialVoltageProfileMode; +import com.powsybl.shortcircuit.ShortCircuitParameters; +import com.powsybl.shortcircuit.StudyType; + +import jakarta.persistence.*; +import lombok.*; +import lombok.experimental.Accessors; + +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersInfos; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitPredefinedConfiguration; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +/** + * @since 1.7.0 + */ +@Builder +@NoArgsConstructor +@AllArgsConstructor +@Accessors(chain = true) +@Getter +@Setter +@Entity +@Table(name = "shortcircuit_parameters") +public class ShortCircuitParametersEntity { + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + @Column(name = "id") + private UUID id; + + @Builder.Default + @Column(name = "withLimitViolations", nullable = false, columnDefinition = "boolean default true") + private boolean withLimitViolations = true; + + @Builder.Default + @Column(name = "withVoltageResult", nullable = false, columnDefinition = "boolean default false") + private boolean withVoltageResult = false; + + @Builder.Default + @Column(name = "withFeederResult", nullable = false, columnDefinition = "boolean default false") + private boolean withFeederResult = false; + + @Builder.Default + @Column(name = "studyType", columnDefinition = "varchar(255) default 'TRANSIENT'") + @Enumerated(EnumType.STRING) + private StudyType studyType = StudyType.TRANSIENT; + + @Builder.Default + @Column(name = "minVoltageDropProportionalThreshold", nullable = false, columnDefinition = "double precision default 20.0") + private double minVoltageDropProportionalThreshold = 20.0; + + @Builder.Default + @Column(name = "predefinedParameters", columnDefinition = "varchar(255) default 'ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP'") + @Enumerated(EnumType.STRING) + private ShortCircuitPredefinedConfiguration predefinedParameters = ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP; + + @Builder.Default + @Column(name = "withLoads", nullable = false, columnDefinition = "boolean default false") + private boolean withLoads = false; + + @Builder.Default + @Column(name = "withShuntCompensators", nullable = false, columnDefinition = "boolean default false") + private boolean withShuntCompensators = false; + + @Builder.Default + @Column(name = "withVscConverterStations", nullable = false, columnDefinition = "boolean default true") + private boolean withVscConverterStations = true; + + @Builder.Default + @Column(name = "withNeutralPosition", nullable = false, columnDefinition = "boolean default true") + private boolean withNeutralPosition = true; + + @Builder.Default + @Column(name = "initialVoltageProfileMode", columnDefinition = "varchar(255) default 'NOMINAL'") + @Enumerated(EnumType.STRING) + private InitialVoltageProfileMode initialVoltageProfileMode = InitialVoltageProfileMode.NOMINAL; + + @Builder.Default + @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY) + @JoinColumn(name = "short_circuit_parameters_id", foreignKey = @ForeignKey(name = "shortCircuitParametersEntity_specificParameters_fk")) + private List specificParameters = new ArrayList<>(); + + public ShortCircuitParametersEntity(ShortCircuitParametersInfos shortCircuitParametersInfos) { + assignAttributes(shortCircuitParametersInfos); + } + + public void update(@NonNull ShortCircuitParametersInfos shortCircuitParametersInfos) { + assignAttributes(shortCircuitParametersInfos); + } + + private void assignAttributes(ShortCircuitParametersInfos shortCircuitParametersInfos) { + ShortCircuitParameters allCommonValues; + List allSpecificValuesEntities = new ArrayList<>(List.of()); + if (shortCircuitParametersInfos == null) { + allCommonValues = ShortCircuitParameters.load(); + } else { + predefinedParameters = shortCircuitParametersInfos.predefinedParameters(); + allCommonValues = shortCircuitParametersInfos.commonParameters(); + Map> specificParametersPerProvider = shortCircuitParametersInfos.specificParametersPerProvider(); + if (specificParametersPerProvider != null) { + specificParametersPerProvider.forEach((p, paramsMap) -> { + if (paramsMap != null) { + paramsMap.forEach((paramName, paramValue) -> { + if (paramValue != null) { + allSpecificValuesEntities.add(new ShortCircuitSpecificParameterEntity( + null, + p, + paramName, + paramValue)); + } + }); + } + }); + } + } + assignCommonValues(allCommonValues); + assignSpecificValues(allSpecificValuesEntities); + } + + private void assignCommonValues(ShortCircuitParameters allCommonValues) { + withLimitViolations = allCommonValues.isWithLimitViolations(); + withVoltageResult = allCommonValues.isWithVoltageResult(); + withFeederResult = allCommonValues.isWithFeederResult(); + studyType = allCommonValues.getStudyType(); + minVoltageDropProportionalThreshold = allCommonValues.getMinVoltageDropProportionalThreshold(); + withLoads = allCommonValues.isWithLoads(); + withShuntCompensators = allCommonValues.isWithShuntCompensators(); + withVscConverterStations = allCommonValues.isWithVSCConverterStations(); + withNeutralPosition = allCommonValues.isWithNeutralPosition(); + initialVoltageProfileMode = allCommonValues.getInitialVoltageProfileMode(); + } + + private void assignSpecificValues(List allSpecificValuesEntities) { + if (specificParameters == null) { + specificParameters = allSpecificValuesEntities; + } else { + specificParameters.clear(); + if (!allSpecificValuesEntities.isEmpty()) { + specificParameters.addAll(allSpecificValuesEntities); + } + } + } + + public ShortCircuitParameters toShortCircuitParameters() { + return ShortCircuitParameters.load() + .setWithLimitViolations(withLimitViolations) + .setWithVoltageResult(withVoltageResult) + .setWithFeederResult(withFeederResult) + .setStudyType(studyType) + .setMinVoltageDropProportionalThreshold(minVoltageDropProportionalThreshold) + .setWithLoads(withLoads) + .setWithShuntCompensators(withShuntCompensators) + .setWithVSCConverterStations(withVscConverterStations) + .setWithNeutralPosition(withNeutralPosition) + .setInitialVoltageProfileMode(initialVoltageProfileMode) + // the voltageRanges is not taken into account when initialVoltageProfileMode=NOMINAL + .setVoltageRanges(InitialVoltageProfileMode.CONFIGURED.equals(initialVoltageProfileMode) ? ShortCircuitParametersConstants.CEI909_VOLTAGE_PROFILE : null); + } +} diff --git a/src/main/java/org/gridsuite/shortcircuit/server/entities/parameters/ShortCircuitSpecificParameterEntity.java b/src/main/java/org/gridsuite/shortcircuit/server/entities/parameters/ShortCircuitSpecificParameterEntity.java new file mode 100644 index 00000000..63baa127 --- /dev/null +++ b/src/main/java/org/gridsuite/shortcircuit/server/entities/parameters/ShortCircuitSpecificParameterEntity.java @@ -0,0 +1,47 @@ +/** + * Copyright (c) 2025, 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.shortcircuit.server.entities.parameters; + +import java.util.UUID; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.Index; +import jakarta.persistence.Table; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; + +/** + * @author Sylvain BOUZOLS + */ + +@NoArgsConstructor +@AllArgsConstructor +@Getter +@Entity +@Table(name = "shortCircuitSpecificParameters", indexes = { + @Index(name = "shortCircuitParametersEntity_specificParameters_index", columnList = "short_circuit_parameters_id") +}) +public class ShortCircuitSpecificParameterEntity { + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + @Column(name = "id", nullable = false) + private UUID id; + + @Column(name = "provider") + private String provider; + + @Column(name = "name") + private String name; + + @Column(name = "value_") + private String value; +} diff --git a/src/main/java/org/gridsuite/shortcircuit/server/repositories/ParametersRepository.java b/src/main/java/org/gridsuite/shortcircuit/server/repositories/ParametersRepository.java index 4cfaa27a..0afe28ee 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/repositories/ParametersRepository.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/repositories/ParametersRepository.java @@ -6,7 +6,7 @@ */ package org.gridsuite.shortcircuit.server.repositories; -import org.gridsuite.shortcircuit.server.entities.ShortCircuitParametersEntity; +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitParametersEntity; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; diff --git a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitObserver.java b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitObserver.java index 1b4af073..b6d23647 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitObserver.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitObserver.java @@ -7,18 +7,18 @@ package org.gridsuite.shortcircuit.server.service; import com.powsybl.shortcircuit.ShortCircuitAnalysisResult; -import com.powsybl.shortcircuit.ShortCircuitParameters; import io.micrometer.core.instrument.MeterRegistry; import io.micrometer.observation.ObservationRegistry; import lombok.NonNull; import org.gridsuite.computation.service.AbstractComputationObserver; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; import org.springframework.stereotype.Service; /** * @author Abdelsalem Hedhili */ @Service -public class ShortCircuitObserver extends AbstractComputationObserver { +public class ShortCircuitObserver extends AbstractComputationObserver { private static final String COMPUTATION_TYPE = "shortcircuitanalysis"; diff --git a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitParametersService.java b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitParametersService.java new file mode 100644 index 00000000..f87940d5 --- /dev/null +++ b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitParametersService.java @@ -0,0 +1,153 @@ +/** + * Copyright (c) 2025, 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.shortcircuit.server.service; + +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.UUID; +import java.util.stream.Collectors; + +import org.apache.commons.lang3.tuple.Pair; +import org.gridsuite.shortcircuit.server.ShortCircuitException; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersInfos; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitParametersEntity; +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitSpecificParameterEntity; +import org.gridsuite.shortcircuit.server.repositories.ParametersRepository; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.powsybl.commons.config.PlatformConfig; +import com.powsybl.commons.parameters.Parameter; +import com.powsybl.commons.parameters.ParameterScope; +import com.powsybl.shortcircuit.ShortCircuitAnalysisProvider; + +import lombok.NonNull; + +/** + * @author Sylvain BOUZOLS + */ +@Service +public class ShortCircuitParametersService { + + private final ParametersRepository parametersRepository; + + public ShortCircuitParametersService(@NonNull ParametersRepository shortCircuitParametersRepository) { + this.parametersRepository = shortCircuitParametersRepository; + } + + public ShortCircuitParametersInfos toShortCircuitParametersInfos(ShortCircuitParametersEntity entity) { + Objects.requireNonNull(entity); + return ShortCircuitParametersInfos.builder() + .predefinedParameters(entity.getPredefinedParameters()) + .commonParameters(entity.toShortCircuitParameters()) + .specificParametersPerProvider(entity.getSpecificParameters().stream() + .collect(Collectors.groupingBy(ShortCircuitSpecificParameterEntity::getProvider, + Collectors.toMap(ShortCircuitSpecificParameterEntity::getName, + ShortCircuitSpecificParameterEntity::getValue)))) + .build(); + } + + public ShortCircuitParametersValues toShortCircuitParametersValues(String provider, ShortCircuitParametersEntity entity) { + return ShortCircuitParametersValues.builder() + .provider(provider) + .predefinedParameters(entity.getPredefinedParameters()) + .commonParameters(entity.toShortCircuitParameters()) + .specificParameters(entity.getSpecificParameters().stream() + .filter(p -> p.getProvider().equalsIgnoreCase(provider)) + .collect(Collectors.toMap(ShortCircuitSpecificParameterEntity::getName, + ShortCircuitSpecificParameterEntity::getValue))) + .build(); + } + + public ShortCircuitParametersValues toShortCircuitParametersValues(ShortCircuitParametersEntity entity) { + return ShortCircuitParametersValues.builder() + .provider("default-provider") + .predefinedParameters(entity.getPredefinedParameters()) + .commonParameters(entity.toShortCircuitParameters()) + .specificParameters(entity.getSpecificParameters().stream() + .filter(p -> p.getProvider().equalsIgnoreCase("default-provider")) + .collect(Collectors.toMap(ShortCircuitSpecificParameterEntity::getName, + ShortCircuitSpecificParameterEntity::getValue))) + .build(); + } + + @Transactional(readOnly = true) + public Optional getParametersValues(UUID parametersUuid, String provider) { + return parametersRepository.findById(parametersUuid).map(this::toShortCircuitParametersValues); + // TODO replace with next line when multiple providers support is added + // return parametersRepository.findById(parametersUuid).map(entity -> toShortCircuitParametersValues(provider, entity)); + } + + public ShortCircuitParametersValues getParametersValues(UUID parametersUuid) { + return parametersRepository.findById(parametersUuid) + .map(this::toShortCircuitParametersValues).orElseThrow(() -> new ShortCircuitException(ShortCircuitException.Type.PARAMETERS_NOT_FOUND, + "ShortCircuit parameters '" + parametersUuid + "' not found")); + } + + @Transactional(readOnly = true) + public Optional getParameters(final UUID parametersUuid) { + return parametersRepository.findById(parametersUuid).map(this::toShortCircuitParametersInfos); + } + + @Transactional + public boolean deleteParameters(final UUID parametersUuid) { + final boolean result = parametersRepository.existsById(parametersUuid); + if (result) { + parametersRepository.deleteById(parametersUuid); + } + return result; + } + + @Transactional + public Optional duplicateParameters(UUID sourceParametersUuid) { + return parametersRepository.findById(sourceParametersUuid) + .map(e -> toShortCircuitParametersInfos(e).toEntity()) + .map(parametersRepository::save) + .map(ShortCircuitParametersEntity::getId); + } + + public UUID createParameters(ShortCircuitParametersInfos parameters) { + return parametersRepository.save(parameters.toEntity()).getId(); + } + + public UUID createDefaultParameters() { + return parametersRepository.save(new ShortCircuitParametersEntity()).getId(); + } + + public ShortCircuitParametersInfos getDefaultParametersInfos() { + return toShortCircuitParametersInfos(new ShortCircuitParametersEntity()); + } + + public ShortCircuitParametersValues getDefaultParametersValues(String provider) { + return toShortCircuitParametersValues(provider, new ShortCircuitParametersEntity()); + } + + @Transactional + public void updateParameters(UUID parametersUuid, ShortCircuitParametersInfos parametersInfos) { + ShortCircuitParametersEntity shortCircuitParametersEntity = parametersRepository.findById(parametersUuid).orElseThrow(); + //if the parameters is null it means it's a reset to defaultValues, but we need to keep the provider because it's updated separately + if (parametersInfos == null) { + shortCircuitParametersEntity.update(getDefaultParametersInfos()); + } else { + shortCircuitParametersEntity.update(parametersInfos); + } + } + + public static Map> getSpecificShortCircuitParameters(String providerName) { + return ShortCircuitAnalysisProvider.findAll().stream() + .filter(provider -> providerName == null || provider.getName().equals(providerName)) + .map(provider -> { + List params = provider.getSpecificParameters(PlatformConfig.defaultConfig()).stream() + .filter(p -> p.getScope() == ParameterScope.FUNCTIONAL) + .toList(); + return Pair.of(provider.getName(), params); + }).collect(Collectors.toMap(Pair::getLeft, Pair::getRight)); + } +} diff --git a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitResultContext.java b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitResultContext.java index da5fcb76..5ca42f1e 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitResultContext.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitResultContext.java @@ -8,9 +8,11 @@ import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; -import com.powsybl.shortcircuit.ShortCircuitParameters; import lombok.Getter; + +import org.gridsuite.computation.dto.ReportInfos; import org.gridsuite.computation.service.AbstractResultContext; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; import org.springframework.messaging.Message; import org.springframework.messaging.MessageHeaders; @@ -46,17 +48,26 @@ public static ShortCircuitResultContext fromMessage(Message message, Obj Boolean debug = (Boolean) headers.get(HEADER_DEBUG); String busId = (String) headers.get(HEADER_BUS_ID); - ShortCircuitParameters parameters; + ShortCircuitParametersValues parameters; try { - parameters = objectMapper.readValue(message.getPayload(), ShortCircuitParameters.class); + parameters = objectMapper.readValue(message.getPayload(), ShortCircuitParametersValues.class); } catch (JsonProcessingException e) { throw new UncheckedIOException(e); } UUID reportUuid = headers.containsKey(REPORT_UUID_HEADER) ? UUID.fromString((String) headers.get(REPORT_UUID_HEADER)) : null; String reporterId = headers.containsKey(REPORTER_ID_HEADER) ? (String) headers.get(REPORTER_ID_HEADER) : null; String reportType = headers.containsKey(REPORT_TYPE_HEADER) ? (String) headers.get(REPORT_TYPE_HEADER) : null; - ShortCircuitRunContext runContext = new ShortCircuitRunContext(networkUuid, variantId, receiver, parameters, - reportUuid, reporterId, reportType, userId, provider, busId, debug); + ShortCircuitRunContext runContext = ShortCircuitRunContext.builder() + .networkUuid(networkUuid) + .variantId(variantId) + .receiver(receiver) + .parameters(parameters) + .reportInfos(new ReportInfos(reportUuid, reporterId, reportType)) + .userId(userId) + .provider(provider) + .busId(busId) + .debug(debug) + .build(); return new ShortCircuitResultContext(resultUuid, runContext); } diff --git a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitRunContext.java b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitRunContext.java index 62f53708..fcacd2c3 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitRunContext.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitRunContext.java @@ -7,12 +7,15 @@ package org.gridsuite.shortcircuit.server.service; import com.powsybl.shortcircuit.ShortCircuitParameters; + +import lombok.Builder; import lombok.Getter; import lombok.Setter; import org.apache.commons.lang3.mutable.MutableLong; import org.gridsuite.computation.dto.ReportInfos; import org.gridsuite.computation.service.AbstractComputationRunContext; import org.gridsuite.shortcircuit.server.dto.ShortCircuitLimits; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; import java.util.*; @@ -20,12 +23,14 @@ * @author Etienne Homer */ @Getter -public class ShortCircuitRunContext extends AbstractComputationRunContext { +public class ShortCircuitRunContext extends AbstractComputationRunContext { @Setter private Map shortCircuitLimits = new HashMap<>(); private final String busId; @Setter private List voltageLevelsWithWrongIsc = new ArrayList<>(); + private final UUID parametersUuid; + private final UUID resultUuid; /** @see org.gridsuite.shortcircuit.server.report.mappers.AdnSummarizeMapper */ private final MutableLong adnSummarizeCounterGenerator = new MutableLong(); @@ -36,9 +41,21 @@ public class ShortCircuitRunContext extends AbstractComputationRunContext CEI909_VOLTAGE_PROFILE = List.of( - new VoltageRange(0, 199.999, 1.1), - new VoltageRange(200.0, 299.999, 1.09), - new VoltageRange(300.0, 389.99, 1.10526), - new VoltageRange(390.0, 410.0, 1.05) - ); - - private final ParametersRepository parametersRepository; private final FilterService filterService; + private final ShortCircuitParametersService parametersService; + public ShortCircuitService(final NotificationService notificationService, final UuidGeneratorService uuidGeneratorService, final ShortCircuitAnalysisResultService resultService, @Autowired(required = false) ComputationS3Service computationS3Service, - final ParametersRepository parametersRepository, final FilterService filterService, + final ShortCircuitParametersService parametersService, final ObjectMapper objectMapper) { super(notificationService, resultService, computationS3Service, objectMapper, uuidGeneratorService, null); - this.parametersRepository = parametersRepository; this.filterService = filterService; - } - - @Transactional - public UUID runAndSaveResult(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, - String userId, String busId, boolean debug, final Optional parametersUuid) { - ShortCircuitParameters parameters = fromEntity(parametersUuid.flatMap(parametersRepository::findById).orElseGet(ShortCircuitParametersEntity::new)).parameters(); - parameters.setWithFortescueResult(StringUtils.isNotBlank(busId)); - parameters.setDetailedReport(false); - return runAndSaveResult(new ShortCircuitRunContext(networkUuid, variantId, receiver, parameters, reportUuid, reporterId, reportType, userId, - "default-provider", // TODO : replace with null when fix in powsybl-ws-commons will handle null provider - busId, debug)); + this.parametersService = parametersService; } @Override + @Transactional public UUID runAndSaveResult(ShortCircuitRunContext runContext) { Objects.requireNonNull(runContext); - final UUID resultUuid = uuidGeneratorService.generate(); + ShortCircuitParametersValues parameters = runContext.getParametersUuid() != null + ? parametersService.getParametersValues(runContext.getParametersUuid()) + : parametersService.toShortCircuitParametersValues(new ShortCircuitParametersEntity()); + parameters.commonParameters().setWithFortescueResult(StringUtils.isNotBlank(runContext.getBusId())); + parameters.commonParameters().setDetailedReport(false); + // set provider and parameters + runContext.setParameters(parameters); + // runContext.setProvider(parameters.provider() != null ? parameters.provider() : getDefaultProvider()); + final UUID resultUuid = runContext.getResultUuid(); // update status to running status setStatus(List.of(resultUuid), ShortCircuitAnalysisStatus.RUNNING); @@ -154,43 +139,6 @@ private static FeederResult fromEntity(FeederResultEntity feederResultEntity) { return new FeederResult(feederResultEntity.getConnectableId(), feederResultEntity.getCurrent(), feederResultEntity.getPositiveMagnitude(), feederResultEntity.getSide() != null ? feederResultEntity.getSide().name() : null); } - private static ShortCircuitParametersEntity toEntity(ShortCircuitParametersInfos parametersInfos) { - final ShortCircuitParameters parameters = parametersInfos.parameters(); - return new ShortCircuitParametersEntity( - parameters.isWithLimitViolations(), - parameters.isWithVoltageResult(), - parameters.isWithFeederResult(), - parameters.getStudyType(), - parameters.getMinVoltageDropProportionalThreshold(), - parametersInfos.predefinedParameters(), - parameters.isWithLoads(), - parameters.isWithShuntCompensators(), - parameters.isWithVSCConverterStations(), - parameters.isWithNeutralPosition(), - parameters.getInitialVoltageProfileMode() - ); - } - - private static ShortCircuitParametersInfos fromEntity(ShortCircuitParametersEntity entity) { - Objects.requireNonNull(entity); - return new ShortCircuitParametersInfos( - entity.getPredefinedParameters(), - new ShortCircuitParameters() - .setStudyType(entity.getStudyType()) - .setMinVoltageDropProportionalThreshold(entity.getMinVoltageDropProportionalThreshold()) - .setWithFeederResult(entity.isWithFeederResult()) - .setWithLimitViolations(entity.isWithLimitViolations()) - .setWithVoltageResult(entity.isWithVoltageResult()) - .setWithLoads(entity.isWithLoads()) - .setWithShuntCompensators(entity.isWithShuntCompensators()) - .setWithVSCConverterStations(entity.isWithVscConverterStations()) - .setWithNeutralPosition(entity.isWithNeutralPosition()) - .setInitialVoltageProfileMode(entity.getInitialVoltageProfileMode()) - // the voltageRanges is not taken into account when initialVoltageProfileMode=NOMINAL - .setVoltageRanges(InitialVoltageProfileMode.CONFIGURED.equals(entity.getInitialVoltageProfileMode()) ? CEI909_VOLTAGE_PROFILE : null) - ); - } - private static ShortCircuitAnalysisResultEntity sortByElementId(ShortCircuitAnalysisResultEntity result) { result.setFaultResults(result.getFaultResults().stream() .sorted(Comparator.comparing(fr -> fr.getFault().getElementId())) @@ -417,38 +365,4 @@ public List getFaultTypes(UUID resultU return resultService.findFaultTypes(resultUuid); } - public Optional getParameters(final UUID parametersUuid) { - return parametersRepository.findById(parametersUuid).map(ShortCircuitService::fromEntity); - } - - @Transactional - public boolean deleteParameters(final UUID parametersUuid) { - final boolean result = parametersRepository.existsById(parametersUuid); - if (result) { - parametersRepository.deleteById(parametersUuid); - } - return result; - } - - @Transactional - public Optional duplicateParameters(UUID sourceParametersUuid) { - return parametersRepository.findById(sourceParametersUuid) - .map(ShortCircuitParametersEntity::new) - .map(parametersRepository::save) - .map(ShortCircuitParametersEntity::getId); - } - - public UUID createParameters(@Nullable final ShortCircuitParametersInfos parameters) { - return parametersRepository.save(parameters != null ? toEntity(parameters) : new ShortCircuitParametersEntity()).getId(); - } - - @Transactional - public boolean updateOrResetParameters(final UUID parametersUuid, @Nullable final ShortCircuitParametersInfos givenParameters) { - return parametersRepository.findById(parametersUuid) - .map(parameters -> { - parameters.updateWith(givenParameters != null ? toEntity(givenParameters) : new ShortCircuitParametersEntity()); - return true; - }) - .orElse(false); - } } diff --git a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerService.java b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerService.java index 1f49a85c..c65acf4b 100644 --- a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerService.java +++ b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerService.java @@ -18,6 +18,7 @@ import org.gridsuite.shortcircuit.server.ShortCircuitException; import org.gridsuite.shortcircuit.server.dto.ShortCircuitAnalysisStatus; import org.gridsuite.shortcircuit.server.dto.ShortCircuitLimits; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; import org.gridsuite.shortcircuit.server.report.ReportMapperService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; @@ -37,7 +38,7 @@ * @author Etienne Homer */ @Service -public class ShortCircuitWorkerService extends AbstractWorkerService { +public class ShortCircuitWorkerService extends AbstractWorkerService { public static final String COMPUTATION_TYPE = "Short circuit analysis"; private final ReportMapperService reportMapper; @@ -95,10 +96,8 @@ private void checkInconsistentVoltageLevels(ShortCircuitRunContext resultContext @Override protected void sendResultMessage(AbstractResultContext resultContext, ShortCircuitAnalysisResult result) { - ShortCircuitRunContext context = resultContext.getRunContext(); - String busId = context.getBusId(); - Map additionalHeaders = new HashMap<>(); - additionalHeaders.put(HEADER_BUS_ID, busId); + Map additionalData = new HashMap<>(); + additionalData.put(HEADER_BUS_ID, resultContext.getRunContext().getBusId()); if (result != null && !result.getFaultResults().isEmpty() && resultContext.getRunContext().getBusId() == null && result.getFaultResults().stream().map(FaultResult::getStatus).allMatch(FaultResult.Status.NO_SHORT_CIRCUIT_DATA::equals)) { @@ -106,7 +105,7 @@ protected void sendResultMessage(AbstractResultContext r } notificationService.sendResultMessage(resultContext.getResultUuid(), resultContext.getRunContext().getReceiver(), - resultContext.getRunContext().getUserId(), additionalHeaders); + resultContext.getRunContext().getUserId(), additionalData); } @Override @@ -121,7 +120,7 @@ protected Map getDebugHeaders(AbstractResultContext getCompletableFuture(ShortCircuitRunContext runContext, String provider, UUID resultUuid) { List faults = runContext.getBusId() == null ? getAllBusfaultFromNetwork(runContext) : getBusFaultFromBusId(runContext); - ShortCircuitParameters parameters = runContext.getParameters(); + ShortCircuitParameters parameters = runContext.buildParameters(); if (runContext.getDebugDir() != null) { parameters.setDebugDir(runContext.getDebugDir().toString()); } diff --git a/src/main/resources/db/changelog/changesets/changelog_20251030T133705Z.xml b/src/main/resources/db/changelog/changesets/changelog_20251030T133705Z.xml new file mode 100644 index 00000000..894799db --- /dev/null +++ b/src/main/resources/db/changelog/changesets/changelog_20251030T133705Z.xml @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/main/resources/db/changelog/db.changelog-master.yaml b/src/main/resources/db/changelog/db.changelog-master.yaml index 48210675..920d21dc 100644 --- a/src/main/resources/db/changelog/db.changelog-master.yaml +++ b/src/main/resources/db/changelog/db.changelog-master.yaml @@ -52,4 +52,8 @@ databaseChangeLog: relativeToChangelogFile: true - include: file: changesets/changelog_20250909T144633Z.xml - relativeToChangelogFile: true \ No newline at end of file + relativeToChangelogFile: true + - include: + file: changesets/changelog_20251030T133705Z.xml + relativeToChangelogFile: true + diff --git a/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitAnalysisControllerTest.java b/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitAnalysisControllerTest.java index 08f5d43d..99ec3cc8 100644 --- a/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitAnalysisControllerTest.java +++ b/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitAnalysisControllerTest.java @@ -30,10 +30,13 @@ import org.gridsuite.computation.service.UuidGeneratorService; import org.gridsuite.shortcircuit.server.dto.CsvTranslation; import org.gridsuite.shortcircuit.server.dto.ShortCircuitAnalysisStatus; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; import org.gridsuite.shortcircuit.server.entities.FaultEmbeddable; import org.gridsuite.shortcircuit.server.entities.FaultResultEntity; +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitParametersEntity; import org.gridsuite.shortcircuit.server.repositories.FaultResultRepository; import org.gridsuite.shortcircuit.server.service.FilterService; +import org.gridsuite.shortcircuit.server.service.ShortCircuitParametersService; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -104,6 +107,7 @@ class ShortCircuitAnalysisControllerTest { private static final UUID RESULT_UUID_TO_STOP = UUID.fromString("1c5212a9-e694-46a9-9eb2-cee60fc34675"); private static final UUID REPORT_UUID = UUID.fromString("762b7298-8c0f-11ed-a1eb-0242ac120002"); private static final ShortCircuitAnalysisResult RESULT = new ShortCircuitAnalysisResult(List.of()); + private static final UUID PARAMETERS_UUID = UUID.fromString("762b7298-8c0f-11ed-a1eb-0242ac120003"); private static final String VARIANT_1_ID = "variant_1"; private static final String VARIANT_2_ID = "variant_2"; @@ -140,6 +144,8 @@ class ShortCircuitAnalysisControllerTest { private static final int TIMEOUT = 1000; @MockitoBean private FilterService filterService; + @MockitoSpyBean + private ShortCircuitParametersService shortCircuitParametersService; @Autowired private ObjectMapper objectMapper; @@ -341,6 +347,15 @@ void setUp() { // UUID service mocking to always generate the same result UUID given(uuidGeneratorService.generate()).willReturn(RESULT_UUID); + + // parameters mocking + // ShortCircuitParametersValues shortCircuitParametersValues = ShortCircuitParametersValues.builder() + // .predefinedParameters(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP) + // .commonParameters(ShortCircuitParameters.load()) + // .specificParameters(Collections.emptyMap()) + // .build(); + ShortCircuitParametersValues shortCircuitParametersValues = shortCircuitParametersService.toShortCircuitParametersValues(new ShortCircuitParametersEntity()); + doReturn(shortCircuitParametersValues).when(shortCircuitParametersService).getParametersValues(any()); } @AfterEach @@ -370,23 +385,17 @@ void runTest() throws Exception { //fault.id DESC and resultUuid (in that order) comparator Comparator comparatorByFaultIdDescAndResultUuid = comparing(FaultResultEntity::getFault, comparatorByFaultId).reversed().thenComparing(comparatorByResultUuid); - ShortCircuitParameters shortCircuitParameters = new ShortCircuitParameters(); - shortCircuitParameters.setWithFortescueResult(false); - String parametersJson = mapper.writeValueAsString(shortCircuitParameters); MvcResult result = mockMvc.perform(post( - "/" + VERSION + "/networks/{networkUuid}/run-and-save?reportType=AllBusesShortCircuitAnalysis&receiver=me&variantId=" + VARIANT_2_ID, NETWORK_UUID) + "/" + VERSION + "/networks/{networkUuid}/run-and-save?reportType=AllBusesShortCircuitAnalysis&receiver=me&variantId=" + VARIANT_2_ID + "¶metersUuid=" + PARAMETERS_UUID, NETWORK_UUID) .header(HEADER_USER_ID, "userId") - .contentType(MediaType.APPLICATION_JSON) - .content(parametersJson)) + .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andReturn(); assertEquals(RESULT_UUID, mapper.readValue(result.getResponse().getContentAsString(), UUID.class)); Message resultMessage = output.receive(TIMEOUT, shortCircuitAnalysisResultDestination); - String resultUuid = Objects.requireNonNull(resultMessage.getHeaders().get("resultUuid")).toString(); - - assertEquals(RESULT_UUID.toString(), resultUuid); + assertEquals(RESULT_UUID.toString(), resultMessage.getHeaders().get("resultUuid")); assertEquals("me", resultMessage.getHeaders().get("receiver")); Message runMessage = output.receive(TIMEOUT, shortCircuitAnalysisRunDestination); @@ -561,17 +570,12 @@ void runWithDebugTest() throws Exception { AbortableInputStream.create(new ByteArrayInputStream("s3 debug file content".getBytes())) )).when(s3Client).getObject(any(GetObjectRequest.class)); - ShortCircuitParameters shortCircuitParameters = new ShortCircuitParameters(); - shortCircuitParameters.setWithFortescueResult(false); - String parametersJson = mapper.writeValueAsString(shortCircuitParameters); - // run with debug for all buses MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?reportType=AllBusesShortCircuitAnalysis&receiver=me&variantId=" + VARIANT_2_ID, NETWORK_UUID) .param(HEADER_DEBUG, "true") .header(HEADER_USER_ID, "userId") - .contentType(MediaType.APPLICATION_JSON) - .content(parametersJson)) + .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andReturn(); @@ -621,18 +625,13 @@ void runOneBusWithDebugTest() throws Exception { AbortableInputStream.create(new ByteArrayInputStream("s3 debug file content".getBytes())) )).when(s3Client).getObject(any(GetObjectRequest.class)); - ShortCircuitParameters shortCircuitParameters = new ShortCircuitParameters(); - shortCircuitParameters.setWithFortescueResult(false); - String parametersJson = mapper.writeValueAsString(shortCircuitParameters); - // run with debug on one bus MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?reportType=AllBusesShortCircuitAnalysis&receiver=me&variantId=" + VARIANT_2_ID, NETWORK_UUID) .param(HEADER_DEBUG, "true") .param(HEADER_BUS_ID, "NGEN") // run on one bus .header(HEADER_USER_ID, "userId") - .contentType(MediaType.APPLICATION_JSON) - .content(parametersJson)) + .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andReturn(); @@ -678,14 +677,11 @@ void testDeterministicResults() throws Exception { Comparator comparatorByResultUuid = comparing(faultResultEntity -> faultResultEntity.getFaultResultUuid().toString()); //current and resultUuid (in that order) comparator Comparator comparatorByCurrentAndResultUuid = comparingDouble(FaultResultEntity::getCurrent).thenComparing(comparatorByResultUuid); - ShortCircuitParameters shortCircuitParameters = new ShortCircuitParameters(); - shortCircuitParameters.setWithFortescueResult(false); - String parametersJson = mapper.writeValueAsString(shortCircuitParameters); + MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?reportType=AllBusesShortCircuitAnalysis&receiver=me&variantId=" + VARIANT_2_ID, NETWORK_UUID) .header(HEADER_USER_ID, "userId") - .contentType(MediaType.APPLICATION_JSON) - .content(parametersJson)) + .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andReturn(); @@ -738,15 +734,11 @@ void runWithBusIdTest() throws Exception { shortCircuitAnalysisMockedStatic.when(ShortCircuitAnalysis::find).thenReturn(runner); when(runner.getName()).thenReturn("providerTest"); - ShortCircuitParameters shortCircuitParameters = new ShortCircuitParameters(); - shortCircuitParameters.setWithFortescueResult(true); - String parametersJson = mapper.writeValueAsString(shortCircuitParameters); MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?reportType=OneBusShortCircuitAnalysis&receiver=me&variantId=" + VARIANT_2_ID, NETWORK_UUID) .param(HEADER_BUS_ID, "NGEN") .header(HEADER_USER_ID, "userId") - .contentType(MediaType.APPLICATION_JSON) - .content(parametersJson)) + .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andReturn(); @@ -799,15 +791,11 @@ void runWithBusBarSectionIdTest() throws Exception { shortCircuitAnalysisMockedStatic.when(ShortCircuitAnalysis::find).thenReturn(runner); when(runner.getName()).thenReturn("providerTest"); - ShortCircuitParameters shortCircuitParameters = new ShortCircuitParameters(); - shortCircuitParameters.setWithFortescueResult(true); - String parametersJson = mapper.writeValueAsString(shortCircuitParameters); MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?reportType=OneBusShortCircuitAnalysis&receiver=me&variantId=" + NODE_BREAKER_NETWORK_VARIANT_ID, NODE_BREAKER_NETWORK_UUID) .param(HEADER_BUS_ID, "S1VL2_BBS1") .header(HEADER_USER_ID, "userId") - .contentType(MediaType.APPLICATION_JSON) - .content(parametersJson)) + .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andReturn(); @@ -933,15 +921,11 @@ void testGetBranchSides() throws Exception { shortCircuitAnalysisMockedStatic.when(ShortCircuitAnalysis::find).thenReturn(runner); when(runner.getName()).thenReturn("providerTest"); - ShortCircuitParameters shortCircuitParameters = new ShortCircuitParameters(); - shortCircuitParameters.setWithFortescueResult(true); - String parametersJson = mapper.writeValueAsString(shortCircuitParameters); MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?reportType=OneBusShortCircuitAnalysis&receiver=me&variantId=" + VARIANT_2_ID, NETWORK_UUID) .param(HEADER_BUS_ID, "NGEN") .header(HEADER_USER_ID, "userId") - .contentType(MediaType.APPLICATION_JSON) - .content(parametersJson)) + .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andReturn(); @@ -1052,13 +1036,10 @@ void checkShortCircuitLimitsTest() throws Exception { shortCircuitAnalysisMockedStatic.when(ShortCircuitAnalysis::find).thenReturn(runner); when(runner.getName()).thenReturn("providerTest"); - ShortCircuitParameters shortCircuitParameters = new ShortCircuitParameters().setWithFortescueResult(false); - String parametersJson = mapper.writeValueAsString(shortCircuitParameters); mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?receiver=me&variantId=" + VARIANT_2_ID, NETWORK_UUID) .header(HEADER_USER_ID, "userId") - .contentType(MediaType.APPLICATION_JSON) - .content(parametersJson)) + .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andReturn(); @@ -1081,8 +1062,7 @@ void checkShortCircuitLimitsTest() throws Exception { mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?receiver=me&variantId=" + VARIANT_4_ID, NETWORK1_UUID) .header(HEADER_USER_ID, "userId") - .contentType(MediaType.APPLICATION_JSON) - .content(parametersJson)) + .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andReturn(); diff --git a/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersControllerTest.java b/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersControllerTest.java index 6167aced..a9e84ab4 100644 --- a/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersControllerTest.java +++ b/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersControllerTest.java @@ -9,7 +9,7 @@ import lombok.NonNull; import org.assertj.core.api.WithAssertions; import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersInfos; -import org.gridsuite.shortcircuit.server.service.ShortCircuitService; +import org.gridsuite.shortcircuit.server.service.ShortCircuitParametersService; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -26,8 +26,13 @@ import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.ResultMatcher; +import com.powsybl.commons.parameters.Parameter; + import java.nio.file.Files; import java.nio.file.Paths; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; import java.util.Optional; import java.util.UUID; import java.util.stream.Stream; @@ -35,6 +40,7 @@ import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import static org.mockito.Mockito.doThrow; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; @@ -52,82 +58,82 @@ public ShortCircuitParametersControllerTest() throws Exception { private MockMvc mockMvc; @MockitoBean - private ShortCircuitService shortCircuitService; + private ShortCircuitParametersService shortCircuitParametersService; @AfterEach void checkMocks() { - Mockito.verifyNoMoreInteractions(shortCircuitService); + Mockito.verifyNoMoreInteractions(shortCircuitParametersService); } @Test void testGetExistingParameters() throws Exception { final UUID arg = UUID.randomUUID(); - final Optional returned = Optional.of(new ShortCircuitParametersInfos(null, null)); - when(shortCircuitService.getParameters(any(UUID.class))).thenReturn(returned); + final Optional returned = Optional.of(new ShortCircuitParametersInfos(null, null, null)); + when(shortCircuitParametersService.getParameters(any(UUID.class))).thenReturn(returned); mockMvc.perform(get("/v1/parameters/{pUuid}", arg.toString())) .andExpectAll(status().isOk(), content().contentType(MediaType.APPLICATION_JSON), content().json(defaultParametersJson)); final ArgumentCaptor uuidCaptor = ArgumentCaptor.forClass(UUID.class); - verify(shortCircuitService).getParameters(uuidCaptor.capture()); + verify(shortCircuitParametersService).getParameters(uuidCaptor.capture()); assertThat(uuidCaptor.getValue()).isEqualTo(arg); } @Test void testGetNonExistingParameters() throws Exception { final UUID arg = UUID.randomUUID(); - when(shortCircuitService.getParameters(any(UUID.class))).thenReturn(Optional.empty()); + when(shortCircuitParametersService.getParameters(any(UUID.class))).thenReturn(Optional.empty()); mockMvc.perform(get("/v1/parameters/{pUuid}", arg.toString())) .andExpectAll(status().isNotFound()); final ArgumentCaptor uuidCaptor = ArgumentCaptor.forClass(UUID.class); - verify(shortCircuitService).getParameters(uuidCaptor.capture()); + verify(shortCircuitParametersService).getParameters(uuidCaptor.capture()); assertThat(uuidCaptor.getValue()).isEqualTo(arg); } @Test void testCreateParameters() throws Exception { final UUID returned = UUID.randomUUID(); - when(shortCircuitService.createParameters(any(ShortCircuitParametersInfos.class))).thenReturn(returned); + when(shortCircuitParametersService.createParameters(any(ShortCircuitParametersInfos.class))).thenReturn(returned); mockMvc.perform(post("/v1/parameters").content(defaultParametersJson).contentType(MediaType.APPLICATION_JSON)) .andExpectAll(status().isOk(), content().contentType(MediaType.APPLICATION_JSON), content().string("\"" + returned + "\"")); final ArgumentCaptor dtoCaptor = ArgumentCaptor.forClass(ShortCircuitParametersInfos.class); - verify(shortCircuitService).createParameters(dtoCaptor.capture()); - assertThat(dtoCaptor.getValue()).isEqualTo(new ShortCircuitParametersInfos(null, null)); + verify(shortCircuitParametersService).createParameters(dtoCaptor.capture()); + assertThat(dtoCaptor.getValue()).isEqualTo(new ShortCircuitParametersInfos(null, null, null)); } @Test void testCreateDefaultParameters() throws Exception { final UUID returned = UUID.randomUUID(); - when(shortCircuitService.createParameters(nullable(ShortCircuitParametersInfos.class))).thenReturn(returned); + when(shortCircuitParametersService.createDefaultParameters()).thenReturn(returned); mockMvc.perform(post("/v1/parameters/default")) .andExpectAll(status().isOk(), content().contentType(MediaType.APPLICATION_JSON), content().string("\"" + returned + "\"")); - verify(shortCircuitService).createParameters(null); + verify(shortCircuitParametersService).createDefaultParameters(); } @Test void testDuplicateExistingParameters() throws Exception { final UUID arg = UUID.randomUUID(); final UUID returned = UUID.randomUUID(); - when(shortCircuitService.duplicateParameters(any(UUID.class))).thenReturn(Optional.of(returned)); + when(shortCircuitParametersService.duplicateParameters(any(UUID.class))).thenReturn(Optional.of(returned)); mockMvc.perform(post("/v1/parameters").param("duplicateFrom", arg.toString())) .andExpectAll(status().isOk(), content().contentType(MediaType.APPLICATION_JSON), content().string("\"" + returned + "\"")); final ArgumentCaptor uuidCaptor = ArgumentCaptor.forClass(UUID.class); - verify(shortCircuitService).duplicateParameters(uuidCaptor.capture()); + verify(shortCircuitParametersService).duplicateParameters(uuidCaptor.capture()); assertThat(uuidCaptor.getValue()).isEqualTo(arg); } @Test void testDuplicateNonExistingParameters() throws Exception { final UUID arg = UUID.randomUUID(); - when(shortCircuitService.duplicateParameters(any(UUID.class))).thenReturn(Optional.empty()); + when(shortCircuitParametersService.duplicateParameters(any(UUID.class))).thenReturn(Optional.empty()); mockMvc.perform(post("/v1/parameters").param(ShortCircuitParametersController.DUPLICATE_FROM, arg.toString())) .andExpectAll(status().isNotFound()); final ArgumentCaptor uuidCaptor = ArgumentCaptor.forClass(UUID.class); - verify(shortCircuitService).duplicateParameters(uuidCaptor.capture()); + verify(shortCircuitParametersService).duplicateParameters(uuidCaptor.capture()); assertThat(uuidCaptor.getValue()).isEqualTo(arg); } private static Stream testParametersArgs() { return Stream.of( - Arguments.arguments(true, status().isNoContent()), + Arguments.arguments(true, status().isOk()), Arguments.arguments(false, status().isNotFound()) ); } @@ -136,11 +142,11 @@ private static Stream testParametersArgs() { @ParameterizedTest void testDeleteParameters(final boolean existing, @NonNull final ResultMatcher statusMatcher) throws Exception { final UUID arg = UUID.randomUUID(); - when(shortCircuitService.deleteParameters(any(UUID.class))).thenReturn(existing); + when(shortCircuitParametersService.deleteParameters(any(UUID.class))).thenReturn(existing); mockMvc.perform(delete("/v1/parameters/{pUuid}", arg.toString())) .andExpectAll(statusMatcher); final ArgumentCaptor uuidCaptor = ArgumentCaptor.forClass(UUID.class); - verify(shortCircuitService).deleteParameters(uuidCaptor.capture()); + verify(shortCircuitParametersService).deleteParameters(uuidCaptor.capture()); assertThat(uuidCaptor.getValue()).isEqualTo(arg); } @@ -148,25 +154,44 @@ void testDeleteParameters(final boolean existing, @NonNull final ResultMatcher s @ParameterizedTest void testUpdateParameters(final boolean existing, @NonNull final ResultMatcher statusMatcher) throws Exception { final UUID arg1 = UUID.randomUUID(); - when(shortCircuitService.updateOrResetParameters(any(UUID.class), any(ShortCircuitParametersInfos.class))).thenReturn(existing); + if (!existing) { + doThrow(new NoSuchElementException()).when(shortCircuitParametersService).updateParameters(any(UUID.class), any(ShortCircuitParametersInfos.class)); + } mockMvc.perform(put("/v1/parameters/{pUuid}", arg1.toString()).content(defaultParametersJson).contentType(MediaType.APPLICATION_JSON)) - .andExpectAll(statusMatcher); + .andExpect(statusMatcher); final ArgumentCaptor uuidCaptor = ArgumentCaptor.forClass(UUID.class); final ArgumentCaptor dtoCaptor = ArgumentCaptor.forClass(ShortCircuitParametersInfos.class); - verify(shortCircuitService).updateOrResetParameters(uuidCaptor.capture(), dtoCaptor.capture()); + verify(shortCircuitParametersService).updateParameters(uuidCaptor.capture(), dtoCaptor.capture()); assertThat(uuidCaptor.getValue()).isEqualTo(arg1); - assertThat(dtoCaptor.getValue()).isEqualTo(new ShortCircuitParametersInfos(null, null)); + assertThat(dtoCaptor.getValue()).isEqualTo(new ShortCircuitParametersInfos(null, null, null)); } @MethodSource("testParametersArgs") @ParameterizedTest void testResetParameters(final boolean existing, @NonNull final ResultMatcher statusMatcher) throws Exception { final UUID arg1 = UUID.randomUUID(); - when(shortCircuitService.updateOrResetParameters(any(UUID.class), nullable(ShortCircuitParametersInfos.class))).thenReturn(existing); + if (!existing) { + doThrow(new NoSuchElementException()).when(shortCircuitParametersService).updateParameters(any(UUID.class), nullable(ShortCircuitParametersInfos.class)); + } + mockMvc.perform(put("/v1/parameters/{pUuid}", arg1.toString())) .andExpectAll(statusMatcher); final ArgumentCaptor uuidCaptor = ArgumentCaptor.forClass(UUID.class); - verify(shortCircuitService).updateOrResetParameters(uuidCaptor.capture(), isNull()); + verify(shortCircuitParametersService).updateParameters(uuidCaptor.capture(), isNull()); assertThat(uuidCaptor.getValue()).isEqualTo(arg1); } + + @Test + void testGetSpecificParameters() throws Exception { + final String provider = "Courcirc_provider"; + final Map> returned = Map.of(provider, List.of()); + try (var mocked = Mockito.mockStatic(ShortCircuitParametersService.class)) { + mocked.when(() -> ShortCircuitParametersService.getSpecificShortCircuitParameters(Mockito.anyString())).thenReturn(returned); + mockMvc.perform(get("/v1/parameters/specific-parameters").param("provider", provider)) + .andExpectAll(status().isOk(), content().contentType(MediaType.APPLICATION_JSON)); + final ArgumentCaptor providerCaptor = ArgumentCaptor.forClass(String.class); + mocked.verify(() -> ShortCircuitParametersService.getSpecificShortCircuitParameters(providerCaptor.capture())); + assertThat(providerCaptor.getValue()).isEqualTo(provider); + } + } } diff --git a/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersITest.java b/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersITest.java index 9cbb82cb..07c9e34e 100644 --- a/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersITest.java +++ b/src/test/java/org/gridsuite/shortcircuit/server/ShortCircuitParametersITest.java @@ -3,16 +3,17 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableMap.Builder; -import com.powsybl.shortcircuit.InitialVoltageProfileMode; +import com.powsybl.shortcircuit.ShortCircuitParameters; import com.powsybl.shortcircuit.StudyType; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.StringUtils; import org.assertj.core.api.WithAssertions; import org.gridsuite.computation.service.NotificationService; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersInfos; import org.gridsuite.shortcircuit.server.dto.ShortCircuitPredefinedConfiguration; -import org.gridsuite.shortcircuit.server.entities.ShortCircuitParametersEntity; +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitParametersConstants; +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitParametersEntity; import org.gridsuite.shortcircuit.server.repositories.ParametersRepository; -import org.gridsuite.shortcircuit.server.service.ShortCircuitService; import org.json.JSONException; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeAll; @@ -45,7 +46,6 @@ import java.util.Map; import java.util.UUID; import java.util.function.Consumer; -import java.util.function.Supplier; import java.util.function.UnaryOperator; import java.util.stream.Stream; @@ -69,10 +69,15 @@ class ShortCircuitParametersITest implements WithAssertions { private static final String USER_ID = "userTestId"; private static final UUID NETWORK_ID = UUID.randomUUID(); - private final String defaultParametersJson; + private final String defaultParametersValuesJson; + private final String defaultParametersInfosJson; + private final String someParametersValuesJson; public ShortCircuitParametersITest() throws Exception { - this.defaultParametersJson = Files.readString(Paths.get(this.getClass().getClassLoader().getResource("default_shorcircuit_parameters.json").toURI())).replaceAll("\\s+", ""); + this.defaultParametersValuesJson = Files.readString(Paths.get(this.getClass().getClassLoader().getResource("default_shorcircuit_values_parameters.json").toURI())).replaceAll("\\s+", ""); + this.someParametersValuesJson = Files.readString(Paths.get(this.getClass().getClassLoader().getResource("default_shorcircuit_values_parameters.json").toURI())).replaceAll("\\s+", "") + .replace("\"minVoltageDropProportionalThreshold\":20.0", "\"minVoltageDropProportionalThreshold\":42.0"); + this.defaultParametersInfosJson = Files.readString(Paths.get(this.getClass().getClassLoader().getResource("default_shorcircuit_infos_parameters.json").toURI())).replaceAll("\\s+", ""); } @Autowired @@ -99,13 +104,13 @@ void verifyMocks() { @Test void runAnalysis() throws Exception { - runAnalysisTest(req -> { }, headers -> headers, false, defaultParametersJson); + runAnalysisTest(req -> { }, headers -> headers, false, defaultParametersValuesJson); } @Test void runAnalysisWithParameters() throws Exception { - final UUID paramsId = parametersRepository.save(new ShortCircuitParametersEntity()).getId(); - runAnalysisTest(req -> req.queryParam("parametersId", paramsId.toString()), headers -> headers, false, defaultParametersJson); + final UUID parametersUuid = parametersRepository.save(new ShortCircuitParametersEntity().setMinVoltageDropProportionalThreshold(42.0)).getId(); + runAnalysisTest(req -> req.queryParam("parametersUuid", parametersUuid.toString()), headers -> headers, false, someParametersValuesJson); } @Test @@ -116,7 +121,13 @@ void runAnalysisWithBusId() throws Exception { .queryParam("busId", busId), headers -> headers.put(HEADER_BUS_ID, busId), true, - defaultParametersJson.replace("\"withFortescueResult\":false", "\"withFortescueResult\":true")); + defaultParametersValuesJson.replace("\"withFortescueResult\":false", "\"withFortescueResult\":true")); + } + + /** Save parameters into the repository and return its UUID. */ + protected UUID saveAndReturnId(ShortCircuitParametersInfos parametersInfos) { + parametersRepository.save(parametersInfos.toEntity()); + return parametersRepository.findAll().get(0).getId(); } private void runAnalysisTest(final Consumer requestSet, final UnaryOperator> headerSet, boolean debug, final String response) throws Exception { @@ -166,93 +177,160 @@ private void runAnalysisTest(final Consumer reque @Test void deleteParameters() throws Exception { final UUID paramsId = parametersRepository.save(new ShortCircuitParametersEntity()).getId(); - mockMvc.perform(delete("/v1/parameters/{id}", paramsId)).andExpectAll(status().isNoContent(), content().bytes(new byte[0])); + mockMvc.perform(delete("/v1/parameters/{id}", paramsId)).andExpectAll(status().isOk(), content().bytes(new byte[0])); assertThat(parametersRepository.count()).isZero(); } @Test void createParameters() throws Exception { - final UUID pUuid = objectMapper.readValue(mockMvc.perform(post("/v1/parameters").contentType(MediaType.APPLICATION_JSON) - .content("{\"predefinedParameters\":\"ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP\",\"parameters\":" + defaultParametersJson + mockMvc.perform(post("/v1/parameters").contentType(MediaType.APPLICATION_JSON) + .content(defaultParametersInfosJson .replace("\"withLoads\":false", "\"withLoads\":true") .replace("\"studyType\":\"TRANSIENT\"", "\"studyType\":\"STEADY_STATE\"") + "}")) .andDo(log()).andExpectAll( status().isOk(), content().contentType(MediaType.APPLICATION_JSON), content().string(matchesPattern(TestUtils.UUID_IN_JSON)) - ).andReturn().getResponse().getContentAsByteArray(), UUID.class); + ).andReturn(); assertThat(parametersRepository.findAll()).as("parameters in database") .singleElement().as("parameters entity") .usingRecursiveComparison() //because JPA entities haven't equals implemented - .isEqualTo(new ShortCircuitParametersEntity(pUuid, true, false, false, StudyType.STEADY_STATE, 20.0, ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP, - true, false, true, true, InitialVoltageProfileMode.NOMINAL)); + .ignoringFields("id") + .isEqualTo(new ShortCircuitParametersEntity(ShortCircuitParametersInfos.builder() + .predefinedParameters(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP) + .commonParameters(ShortCircuitParameters.load() + .setStudyType(StudyType.STEADY_STATE) + .setMinVoltageDropProportionalThreshold(20.0) + .setWithNeutralPosition(true) + .setWithVoltageResult(false) + .setWithFeederResult(false) + .setWithShuntCompensators(false) + ) + .specificParametersPerProvider(Map.of()) + .build())); } @Test void createDefaultParameters() throws Exception { - final UUID pUuid = objectMapper.readValue(mockMvc.perform(post("/v1/parameters/default")).andDo(log()).andExpectAll( + mockMvc.perform(post("/v1/parameters/default")).andDo(log()).andExpectAll( status().isOk(), content().contentType(MediaType.APPLICATION_JSON), content().string(matchesPattern(TestUtils.UUID_IN_JSON)) - ).andReturn().getResponse().getContentAsByteArray(), UUID.class); + ).andReturn(); assertThat(parametersRepository.findAll()).as("parameters in database") .singleElement().as("parameters entity") .usingRecursiveComparison() //because JPA entities haven't equals implemented - .isEqualTo(new ShortCircuitParametersEntity().setId(pUuid)); + .ignoringFields("id") + .isEqualTo(new ShortCircuitParametersEntity()); } @Test void retrieveParameters() throws Exception { - final UUID pId = parametersRepository.save(new ShortCircuitParametersEntity(true, true, true, StudyType.STEADY_STATE, Math.PI, - ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP, true, true, true, true, InitialVoltageProfileMode.NOMINAL)).getId(); - mockMvc.perform(get("/v1/parameters/{id}", pId)).andDo(log()).andExpectAll( + final UUID pUuid = saveAndReturnId(ShortCircuitParametersInfos.builder() + .predefinedParameters(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP) + .commonParameters(ShortCircuitParameters.load() + .setStudyType(StudyType.STEADY_STATE) + .setMinVoltageDropProportionalThreshold(Math.PI) + .setWithNeutralPosition(true) + ) + .specificParametersPerProvider(Map.of()) + .build()); + + // build expected response programmatically (more robust than brittle string replacements) + final ShortCircuitParameters expectedCommon = ShortCircuitParameters.load() + .setStudyType(StudyType.STEADY_STATE) + .setMinVoltageDropProportionalThreshold(Math.PI) + .setWithNeutralPosition(true); + + final Map expected = new java.util.HashMap<>(); + expected.put("predefinedParameters", "ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP"); + expected.put("specificParametersPerProvider", Map.of()); + expected.put("commonParameters", expectedCommon); + expected.put("cei909VoltageRanges", ShortCircuitParametersConstants.CEI909_VOLTAGE_PROFILE); + + final String expectedJson = objectMapper.writeValueAsString(expected); + + mockMvc.perform(get("/v1/parameters/{id}", pUuid)).andDo(log()).andExpectAll( status().isOk(), content().contentType(MediaType.APPLICATION_JSON), - content().json("{\"predefinedParameters\":\"ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP\",\"parameters\":" + defaultParametersJson - .replace("false", "true") - .replace("\"minVoltageDropProportionalThreshold\":20.0", "\"minVoltageDropProportionalThreshold\":3.141592653589793") - .replace("\"studyType\":\"TRANSIENT\"", "\"studyType\":\"STEADY_STATE\"") - + ",\"cei909VoltageRanges\":" + objectMapper.writeValueAsString(ShortCircuitService.CEI909_VOLTAGE_PROFILE) + "}", true) + content().json(expectedJson, false) // non-strict JSON comparison (order independent) ); } @Test void resetParameters() throws Exception { - final UUID pId = parametersRepository.save(new ShortCircuitParametersEntity(true, true, true, StudyType.STEADY_STATE, Math.PI, - ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP, true, true, true, true, InitialVoltageProfileMode.NOMINAL)).getId(); - mockMvc.perform(put("/v1/parameters/{id}", pId)).andDo(log()).andExpectAll( - status().isNoContent(), + final UUID pUuid = saveAndReturnId(ShortCircuitParametersInfos.builder() + .predefinedParameters(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP) + .commonParameters(ShortCircuitParameters.load() + .setStudyType(StudyType.STEADY_STATE) + .setMinVoltageDropProportionalThreshold(Math.PI) + ) + .specificParametersPerProvider(Map.of()) + .build()); + mockMvc.perform(put("/v1/parameters/{id}", pUuid)).andDo(log()).andExpectAll( + status().isOk(), content().bytes(new byte[0]) ); assertThat(parametersRepository.findAll()).as("parameters in database") .singleElement().as("parameters entity") .usingRecursiveComparison() //because JPA entities haven't equals implemented - .isEqualTo(new ShortCircuitParametersEntity().setId(pId)); + .ignoringFields("id") + .isEqualTo(new ShortCircuitParametersEntity() + ); } @Test void updateParameters() throws Exception { - final UUID pUuid = parametersRepository.save(new ShortCircuitParametersEntity(true, true, true, StudyType.STEADY_STATE, Math.PI, - ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP, true, true, true, true, InitialVoltageProfileMode.NOMINAL)).getId(); + final UUID pUuid = saveAndReturnId(ShortCircuitParametersInfos.builder() + .predefinedParameters(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP) + .commonParameters(ShortCircuitParameters.load() + .setStudyType(StudyType.STEADY_STATE) + .setMinVoltageDropProportionalThreshold(Math.PI) + ) + .specificParametersPerProvider(null) + .build()); + mockMvc.perform(put("/v1/parameters/{id}", pUuid) .contentType(MediaType.APPLICATION_JSON) - .content("{\"predefinedParameters\":\"ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP\",\"parameters\":" + defaultParametersJson + .content(defaultParametersInfosJson .replace("\"withLoads\":false", "\"withLoads\":true") .replace("\"studyType\":\"TRANSIENT\"", "\"studyType\":\"STEADY_STATE\"") + "}")) - .andDo(log()).andExpectAll(status().isNoContent(), content().bytes(new byte[0])) + .andDo(log()).andExpectAll(status().isOk(), content().bytes(new byte[0])) .andReturn().getResponse().getContentAsByteArray(); assertThat(parametersRepository.findAll()).as("parameters in database") .singleElement().as("parameters entity") .usingRecursiveComparison() //because JPA entities haven't equals implemented - .isEqualTo(new ShortCircuitParametersEntity(pUuid, true, false, false, StudyType.STEADY_STATE, 20.0, ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP, - true, false, true, true, InitialVoltageProfileMode.NOMINAL)); + .ignoringFields("id") + .isEqualTo(new ShortCircuitParametersEntity(ShortCircuitParametersInfos.builder() + .predefinedParameters(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP) + .commonParameters(ShortCircuitParameters.load() + .setStudyType(StudyType.STEADY_STATE) + .setMinVoltageDropProportionalThreshold(20.0) + .setWithNeutralPosition(true) + .setWithVoltageResult(false) + .setWithFeederResult(false) + .setWithShuntCompensators(false) + ) + .specificParametersPerProvider(null) + .build())); } @Test void duplicateParameters() throws Exception { - final Supplier generatorEntity = () -> new ShortCircuitParametersEntity(false, false, false, StudyType.TRANSIENT, 1.234, - ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, false, false, false, false, InitialVoltageProfileMode.NOMINAL); - final UUID pUuid = parametersRepository.save(generatorEntity.get()).getId(); + final ShortCircuitParametersInfos infos = ShortCircuitParametersInfos.builder() + .predefinedParameters(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909) + .commonParameters(ShortCircuitParameters.load() + .setWithLimitViolations(false) + .setWithFeederResult(false) + .setWithVoltageResult(false) + .setMinVoltageDropProportionalThreshold(1.234) + .setWithLoads(false) + .setWithShuntCompensators(false) + .setWithVSCConverterStations(false) + ) + .specificParametersPerProvider(Map.of()) + .build(); + final UUID pUuid = saveAndReturnId(infos); final UUID pUuidDuplicated = objectMapper.readValue(mockMvc.perform(post("/v1/parameters").queryParam(DUPLICATE_FROM, pUuid.toString())) .andDo(log()).andExpectAll( status().isOk(), @@ -263,8 +341,8 @@ void duplicateParameters() throws Exception { .usingRecursiveComparison() //because JPA entities haven't equals implemented .ignoringCollectionOrder() .isEqualTo(List.of( - generatorEntity.get().setId(pUuid), - generatorEntity.get().setId(pUuidDuplicated) + infos.toEntity().setId(pUuid), + infos.toEntity().setId(pUuidDuplicated) )); } diff --git a/src/test/java/org/gridsuite/shortcircuit/server/TestUtils.java b/src/test/java/org/gridsuite/shortcircuit/server/TestUtils.java index a29988b4..9975239e 100644 --- a/src/test/java/org/gridsuite/shortcircuit/server/TestUtils.java +++ b/src/test/java/org/gridsuite/shortcircuit/server/TestUtils.java @@ -8,8 +8,9 @@ import com.powsybl.shortcircuit.ShortCircuitAnalysis; import com.powsybl.shortcircuit.ShortCircuitAnalysisProvider; -import com.powsybl.shortcircuit.ShortCircuitParameters; import lombok.NonNull; + +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; import org.gridsuite.shortcircuit.server.service.ShortCircuitRunContext; import org.mockito.MockedStatic; import org.mockito.Mockito; @@ -46,14 +47,14 @@ private TestUtils() { UUID.randomUUID(), null, null, - new ShortCircuitParameters(), - null, + ShortCircuitParametersValues.builder().build(), null, null, null, "default-provider", // TODO : replace with null when fix in powsybl-ws-commons will handle null provider null, - false + false, + null ); public static void assertQueuesEmptyThenClear(List destinations, OutputDestination output) { diff --git a/src/test/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersInfosTest.java b/src/test/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersInfosTest.java index c5dd5b0b..8b8e6055 100644 --- a/src/test/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersInfosTest.java +++ b/src/test/java/org/gridsuite/shortcircuit/server/dto/ShortCircuitParametersInfosTest.java @@ -23,7 +23,9 @@ import org.springframework.boot.test.autoconfigure.json.JsonTest; import org.springframework.test.context.ContextConfiguration; -import static org.gridsuite.shortcircuit.server.service.ShortCircuitService.CEI909_VOLTAGE_PROFILE; +import static org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitParametersConstants.CEI909_VOLTAGE_PROFILE; + +import java.util.Collections; @ContextConfiguration(classes = { RestTemplateConfig.class }) @JsonTest @@ -42,10 +44,11 @@ private static JSONObject toJson(@NonNull final VoltageRange voltageRange) { @Test void shouldSerializeCei909VoltageRanges() throws Exception { - final String jsonSerialized = objectMapper.writeValueAsString(new ShortCircuitParametersInfos(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, new ShortCircuitParameters())); + final String jsonSerialized = objectMapper.writeValueAsString(new ShortCircuitParametersInfos(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, new ShortCircuitParameters(), Collections.emptyMap())); JSONAssert.assertEquals( new JSONObject().put("predefinedParameters", ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909.toString()) - .put("parameters", new JSONObject().put("version", "1.4")) + .put("commonParameters", new JSONObject().put("version", "1.4")) + .put("specificParametersPerProvider", new JSONObject()) .put("cei909VoltageRanges", CEI909_VOLTAGE_PROFILE.stream() .map(ShortCircuitParametersInfosTest::toJson) .reduce(new JSONArray(), JSONArray::put, (arr1, arr2) -> null)), diff --git a/src/test/java/org/gridsuite/shortcircuit/server/entities/ShortCircuitParametersEntityTest.java b/src/test/java/org/gridsuite/shortcircuit/server/entities/ShortCircuitParametersEntityTest.java deleted file mode 100644 index b0880e25..00000000 --- a/src/test/java/org/gridsuite/shortcircuit/server/entities/ShortCircuitParametersEntityTest.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright (c) 2024, 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.shortcircuit.server.entities; - -import com.powsybl.shortcircuit.ShortCircuitConstants; -import org.assertj.core.api.WithAssertions; -import org.gridsuite.shortcircuit.server.dto.ShortCircuitPredefinedConfiguration; -import org.junit.jupiter.api.Test; - -class ShortCircuitParametersEntityTest implements WithAssertions { - @Test - void testUpdateSimple() { - ShortCircuitParametersEntity entity1 = new ShortCircuitParametersEntity(); - ShortCircuitParametersEntity entity2 = new ShortCircuitParametersEntity().setMinVoltageDropProportionalThreshold(Double.MAX_VALUE); - assertThat(entity1).as("verification").usingRecursiveComparison().isNotEqualTo(entity2); - entity1.updateWith(entity2); - assertThat(entity1).as("check").usingRecursiveComparison().isEqualTo(entity2); - } - - @Test - void testUpdate2() { - ShortCircuitParametersEntity entity1 = new ShortCircuitParametersEntity(); - ShortCircuitParametersEntity entity2 = new ShortCircuitParametersEntity( - ShortCircuitConstants.DEFAULT_WITH_LIMIT_VIOLATIONS, - ShortCircuitConstants.DEFAULT_WITH_VOLTAGE_RESULT, - //ShortCircuitConstants.DEFAULT_WITH_FORTESCUE_RESULT, - ShortCircuitConstants.DEFAULT_WITH_FEEDER_RESULT, - ShortCircuitConstants.DEFAULT_STUDY_TYPE, - ShortCircuitConstants.DEFAULT_MIN_VOLTAGE_DROP_PROPORTIONAL_THRESHOLD, - ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, - ShortCircuitConstants.DEFAULT_WITH_LOADS, - ShortCircuitConstants.DEFAULT_WITH_SHUNT_COMPENSATORS, - ShortCircuitConstants.DEFAULT_WITH_VSC_CONVERTER_STATIONS, - ShortCircuitConstants.DEFAULT_WITH_NEUTRAL_POSITION, - ShortCircuitConstants.DEFAULT_INITIAL_VOLTAGE_PROFILE_MODE - //ShortCircuitConstants.DEFAULT_SUB_TRANSIENT_COEFFICIENT - //ShortCircuitConstants.DEFAULT_DETAILED_REPORT - ); - assertThat(entity1).as("verification").usingRecursiveComparison().isNotEqualTo(entity2); - entity1.updateWith(entity2); - assertThat(entity1).as("check").usingRecursiveComparison().isEqualTo(entity2); - } -} diff --git a/src/test/java/org/gridsuite/shortcircuit/server/report/ReportMapperServiceTest.java b/src/test/java/org/gridsuite/shortcircuit/server/report/ReportMapperServiceTest.java index 906aec2c..d227a291 100644 --- a/src/test/java/org/gridsuite/shortcircuit/server/report/ReportMapperServiceTest.java +++ b/src/test/java/org/gridsuite/shortcircuit/server/report/ReportMapperServiceTest.java @@ -30,7 +30,7 @@ class ReportMapperServiceTest extends AbstractReportMapperTest { private static final String ROOT_REPORTER_ID = "00000000-0000-0000-0000-000000000000"; private static final String SHORTCIRCUIT_TYPE_REPORT = "ShortCircuitAnalysis"; - private final ShortCircuitRunContext runContext = new ShortCircuitRunContext(null, null, null, null, null, null, null, null, null, null, false); + private final ShortCircuitRunContext runContext = new ShortCircuitRunContext(null, null, null, null, null, null, null, null, null, false, null); @Mock ReportMapper reportMapper; private ReportMapperService reportMapperService; diff --git a/src/test/java/org/gridsuite/shortcircuit/server/report/ReportMapperShortCircuitTest.java b/src/test/java/org/gridsuite/shortcircuit/server/report/ReportMapperShortCircuitTest.java index 02cb0a24..59b65c9e 100644 --- a/src/test/java/org/gridsuite/shortcircuit/server/report/ReportMapperShortCircuitTest.java +++ b/src/test/java/org/gridsuite/shortcircuit/server/report/ReportMapperShortCircuitTest.java @@ -9,9 +9,11 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.ReportNodeDeserializer; -import com.powsybl.shortcircuit.ShortCircuitParameters; import lombok.extern.slf4j.Slf4j; + +import org.gridsuite.computation.dto.ReportInfos; import org.gridsuite.shortcircuit.server.RestTemplateConfig; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; import org.gridsuite.shortcircuit.server.report.mappers.VoltageLevelsWithWrongIpValuesMapper; import org.gridsuite.shortcircuit.server.service.ShortCircuitRunContext; import org.junit.jupiter.api.BeforeEach; @@ -44,8 +46,8 @@ void prepare() { beansInit.powsyblAdnTwoWindingsTransformersSummary(), new VoltageLevelsWithWrongIpValuesMapper() )); - this.runContext = new ShortCircuitRunContext(null, "variantId", "receiver", new ShortCircuitParameters(), - null, "reporterId", "reportType", "userId", "default-provider", "busId", false); + this.runContext = new ShortCircuitRunContext(null, "variantId", "receiver", new ShortCircuitParametersValues(null, null, null, null), null, + new ReportInfos(null, "reporterId", "reportType"), "userId", "default-provider", "busId", false, null); } @ParameterizedTest(name = "reporter_{0}.json") diff --git a/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitParametersServiceTest.java b/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitParametersServiceTest.java new file mode 100644 index 00000000..d4ac93cf --- /dev/null +++ b/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitParametersServiceTest.java @@ -0,0 +1,431 @@ +/* + * Copyright (c) 2024, 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.shortcircuit.server.service; + +import com.powsybl.commons.parameters.Parameter; +import com.powsybl.shortcircuit.InitialVoltageProfileMode; +import com.powsybl.shortcircuit.ShortCircuitParameters; +import com.powsybl.shortcircuit.StudyType; +import org.assertj.core.api.WithAssertions; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersInfos; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitPredefinedConfiguration; +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitParametersEntity; +import org.gridsuite.shortcircuit.server.entities.parameters.ShortCircuitSpecificParameterEntity; +import org.gridsuite.shortcircuit.server.repositories.ParametersRepository; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Optional; +import java.util.Random; +import java.util.UUID; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith({ MockitoExtension.class }) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class ShortCircuitParametersServiceTest implements WithAssertions { + + private ShortCircuitParametersService parametersService; + private ParametersRepository parametersRepository; + + @BeforeAll + void setup() { + this.parametersRepository = mock(ParametersRepository.class); + this.parametersService = new ShortCircuitParametersService(parametersRepository); + } + + @AfterEach + void checkMocks() { + try { + Mockito.verifyNoMoreInteractions( + parametersRepository + ); + } finally { + Mockito.reset( + parametersRepository + ); + } + } + + private static void checkParametersEntityHasBeenRead(final ShortCircuitParametersEntity pEntity) { + verify(pEntity).getPredefinedParameters(); + verify(pEntity).getSpecificParameters(); + verify(pEntity).toShortCircuitParameters(); + } + + private void checkParametersEntityHasBeenUpdate(final ShortCircuitParametersEntity pEntity, + final ShortCircuitParametersEntity pEntityUpdate, + final String pEntityUpdateDesc, + ShortCircuitParametersInfos pDtoUpdate) { + final ArgumentCaptor infosCaptor = ArgumentCaptor.forClass(ShortCircuitParametersInfos.class); + verify(pEntity).update(infosCaptor.capture()); + assertThat(infosCaptor.getValue()).as(pEntityUpdateDesc) + .usingRecursiveComparison().ignoringFields("id").isEqualTo(pDtoUpdate); + + // verify possible updates (to pass verifyNoMoreInteractions) + // verify(pEntity).setWithLimitViolations(pEntityUpdate.isWithLimitViolations()); + // verify(pEntity).setWithVoltageResult(pEntityUpdate.isWithVoltageResult()); + // verify(pEntity).setWithFeederResult(pEntityUpdate.isWithFeederResult()); + // verify(pEntity).setStudyType(pEntityUpdate.getStudyType()); + // verify(pEntity).setMinVoltageDropProportionalThreshold(pEntityUpdate.getMinVoltageDropProportionalThreshold()); + // verify(pEntity).setPredefinedParameters(pEntityUpdate.getPredefinedParameters()); + // verify(pEntity).setWithLoads(pEntityUpdate.isWithLoads()); + // verify(pEntity).setWithShuntCompensators(pEntityUpdate.isWithShuntCompensators()); + // verify(pEntity).setWithVscConverterStations(pEntityUpdate.isWithVscConverterStations()); + // verify(pEntity).setWithNeutralPosition(pEntityUpdate.isWithNeutralPosition()); + // verify(pEntity).setInitialVoltageProfileMode(pEntityUpdate.getInitialVoltageProfileMode()); + } + + // private void checkParametersEntityHasBeenUpdate(final ShortCircuitParametersEntity pEntity, + // final ShortCircuitParametersEntity pEntityUpdate, final String pEntityUpdateDesc, ShortCircuitParametersInfos pDtoUpdate) { + // assertThat(pEntity).as(pEntityUpdateDesc) + // .usingRecursiveComparison().isEqualTo(pEntityUpdate); + + // // verify possible updates (to pass verifyNoMoreInteractions) + // // verify(pEntity).update(pDtoUpdate != null ? pDtoUpdate : parametersService.getDefaultParametersInfos()); + // // verify(pEntity, times(4)).isWithLimitViolations(); + // // verify(pEntity, times(4)).isWithVoltageResult(); + // // verify(pEntity, times(4)).isWithFeederResult(); + // // verify(pEntity, times(4)).getStudyType(); + // // verify(pEntity, times(4)).getMinVoltageDropProportionalThreshold(); + // // verify(pEntity, times(4)).getPredefinedParameters(); + // // verify(pEntity, times(4)).isWithLoads(); + // // verify(pEntity, times(4)).isWithShuntCompensators(); + // // verify(pEntity, times(4)).isWithVscConverterStations(); + // // verify(pEntity, times(4)).isWithNeutralPosition(); + // // verify(pEntity, times(4)).getInitialVoltageProfileMode(); + + // // verify possible updates (to pass verifyNoMoreInteractions) + // verify(pEntity).setWithLimitViolations(pEntityUpdate.isWithLimitViolations()); + // verify(pEntity).setWithVoltageResult(pEntityUpdate.isWithVoltageResult()); + // verify(pEntity).setWithFeederResult(pEntityUpdate.isWithFeederResult()); + // verify(pEntity).setStudyType(pEntityUpdate.getStudyType()); + // verify(pEntity).setMinVoltageDropProportionalThreshold(pEntityUpdate.getMinVoltageDropProportionalThreshold()); + // verify(pEntity).setPredefinedParameters(pEntityUpdate.getPredefinedParameters()); + // verify(pEntity).setWithLoads(pEntityUpdate.isWithLoads()); + // verify(pEntity).setWithShuntCompensators(pEntityUpdate.isWithShuntCompensators()); + // verify(pEntity).setWithVscConverterStations(pEntityUpdate.isWithVscConverterStations()); + // verify(pEntity).setWithNeutralPosition(pEntityUpdate.isWithNeutralPosition()); + // verify(pEntity).setInitialVoltageProfileMode(pEntityUpdate.getInitialVoltageProfileMode()); + // } + + @Test + void testGetNonExistingParameters() { + final UUID pUuid = UUID.randomUUID(); + when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.empty()); + assertThat(parametersService.getParameters(pUuid)).as("service call result").isEmpty(); + verify(parametersRepository).findById(pUuid); + } + + @Test + void testGetExistingParametersAndConversionToDto() { + final UUID pUuid = UUID.randomUUID(); + final double minVoltDrop = new Random().nextDouble(); + final ShortCircuitParametersEntity pEntity = spy(new ShortCircuitParametersEntity(pUuid, false, false, false, StudyType.STEADY_STATE, minVoltDrop, + ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, false, false, false, false, InitialVoltageProfileMode.NOMINAL, Collections.emptyList())); + when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.of(pEntity)); + //can't spy call to fromEntity() + assertThat(parametersService.getParameters(pUuid)).as("service call result") + .get().as("dto").usingRecursiveComparison().isEqualTo(new ShortCircuitParametersInfos( + ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, new ShortCircuitParameters() + .setWithLimitViolations(false) + .setWithVoltageResult(false) + .setWithFeederResult(false) + .setStudyType(StudyType.STEADY_STATE) + .setMinVoltageDropProportionalThreshold(minVoltDrop) + .setWithLoads(false) + .setWithShuntCompensators(false) + .setWithVSCConverterStations(false) + .setWithNeutralPosition(false) + .setInitialVoltageProfileMode(InitialVoltageProfileMode.NOMINAL), + Collections.emptyMap())); + checkParametersEntityHasBeenRead(pEntity); + verifyNoMoreInteractions(pEntity); + verify(parametersRepository).findById(pUuid); + } + + @Test + void testDeleteNonExistingParameters() { + final UUID pUuid = UUID.randomUUID(); + when(parametersRepository.existsById(any(UUID.class))).thenReturn(false); + assertThat(parametersService.deleteParameters(pUuid)).as("service call result").isFalse(); + verify(parametersRepository).existsById(pUuid); + } + + @Test + void testDeleteExistingParameters() { + final UUID pUuid = UUID.randomUUID(); + when(parametersRepository.existsById(any(UUID.class))).thenReturn(true); + assertThat(parametersService.deleteParameters(pUuid)).as("service call result").isTrue(); + verify(parametersRepository).existsById(pUuid); + verify(parametersRepository).deleteById(pUuid); + } + + @Test + void testDuplicateNonExistingParameters() { + final UUID pUuid = UUID.randomUUID(); + when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.empty()); + assertThat(parametersService.duplicateParameters(pUuid)).as("service call result").isEmpty(); + verify(parametersRepository).findById(pUuid); + } + + @Test + void testDuplicateExistingParameters() { + final UUID pUuid = UUID.randomUUID(); + final ShortCircuitParametersEntity pEntityRaw = ShortCircuitParametersEntity.builder().id(UUID.randomUUID()).build(); + final ShortCircuitParametersEntity pEntity = spy(pEntityRaw); + final UUID pSavedUuid = UUID.randomUUID(); + final ShortCircuitParametersEntity pSavedEntity = spy(ShortCircuitParametersEntity.builder().id(pSavedUuid).build()); + when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.of(pEntity)); + when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pSavedEntity); + assertThat(parametersService.duplicateParameters(pUuid)).as("service call result").get().isEqualTo(pSavedUuid); + verify(parametersRepository).findById(pUuid); + checkParametersEntityHasBeenRead(pEntity); + final ArgumentCaptor entityCaptor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); + verify(parametersRepository).save(entityCaptor.capture()); + assertThat(entityCaptor.getValue()).as("saved entity").isNotSameAs(pEntity) + .usingRecursiveComparison().ignoringFields("id").isEqualTo(pEntityRaw); + verify(pSavedEntity).getId(); + verifyNoMoreInteractions(pEntity); + verifyNoMoreInteractions(pSavedEntity); + } + + @Test + void testCreateParameters() { + final UUID pUuid = UUID.randomUUID(); + final ShortCircuitParametersEntity pEntity = spy(ShortCircuitParametersEntity.builder().id(pUuid).build()); + when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pEntity); + //dto that must have differences with defaults + assertThat(parametersService.createParameters(new ShortCircuitParametersInfos(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, new ShortCircuitParameters(), null))) + .as("service call result").isEqualTo(pUuid); + verify(pEntity).getId(); + verifyNoMoreInteractions(pEntity); + final ArgumentCaptor captor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); + verify(parametersRepository).save(captor.capture()); + assertThat(captor.getValue()).usingRecursiveComparison().isEqualTo(ShortCircuitParametersEntity.builder() + .withLimitViolations(true) + .withVoltageResult(true) + .withFeederResult(true) + .studyType(StudyType.TRANSIENT) + .minVoltageDropProportionalThreshold(0.0) + .predefinedParameters(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909) + .withLoads(true) + .withShuntCompensators(true) + .withVscConverterStations(true) + .withNeutralPosition(false) + .build()); + } + + @Test + void testCreateDefaultParameters() { + final UUID pUuid = UUID.randomUUID(); + final ShortCircuitParametersEntity pEntity = spy(ShortCircuitParametersEntity.builder().id(pUuid).build()); + when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pEntity); + assertThat(parametersService.createDefaultParameters()).as("service call result").isEqualTo(pUuid); + verify(pEntity).getId(); + verifyNoMoreInteractions(pEntity); + final ArgumentCaptor captor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); + verify(parametersRepository).save(captor.capture()); + assertThat(captor.getValue()).usingRecursiveComparison().isEqualTo(new ShortCircuitParametersEntity()); + } + + @Test + void testUpdateNonExistingParameters() { + final UUID pUuid = UUID.randomUUID(); + when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.empty()); + assertThatThrownBy(() -> parametersService.updateParameters(pUuid, null)) + .isInstanceOf(NoSuchElementException.class); + verify(parametersRepository).findById(pUuid); + } + + @Test + void testUpdateExistingParameters() { + final UUID pUuid = UUID.randomUUID(); + final ShortCircuitParametersEntity pEntity = spy(ShortCircuitParametersEntity.builder().id(pUuid).build()); + final ShortCircuitParameters pDtoUpdateParams = spy(new ShortCircuitParameters()); + final ShortCircuitParametersInfos pDtoUpdateInfos = spy(new ShortCircuitParametersInfos(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, pDtoUpdateParams, Collections.emptyMap())); + //dto that must have differences with defaults + final ShortCircuitParametersEntity pEntityUpdate = new ShortCircuitParametersEntity(pUuid, true, true, true, StudyType.TRANSIENT, 0.0, + ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, true, true, true, false, InitialVoltageProfileMode.NOMINAL, Collections.emptyList()); + when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.of(pEntity)); + + parametersService.updateParameters(pUuid, pDtoUpdateInfos); + + // the service will save the updated entity back to the repository + when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pEntity); + // verify we search the correct uid + verify(parametersRepository).findById(pUuid); + // verify DTO has been read + verify(pDtoUpdateInfos).commonParameters(); + verify(pDtoUpdateInfos).predefinedParameters(); + verify(pDtoUpdateInfos).specificParametersPerProvider(); + verify(pDtoUpdateParams).isWithLimitViolations(); + verify(pDtoUpdateParams).isWithVoltageResult(); + verify(pDtoUpdateParams).isWithFeederResult(); + verify(pDtoUpdateParams).getStudyType(); + verify(pDtoUpdateParams).getMinVoltageDropProportionalThreshold(); + verify(pDtoUpdateParams).isWithLoads(); + verify(pDtoUpdateParams).isWithShuntCompensators(); + verify(pDtoUpdateParams).isWithVSCConverterStations(); + verify(pDtoUpdateParams).isWithNeutralPosition(); + verify(pDtoUpdateParams).getInitialVoltageProfileMode(); + verifyNoMoreInteractions(pDtoUpdateInfos, pDtoUpdateParams); + // verify the parameters has been update + checkParametersEntityHasBeenUpdate(pEntity, pEntityUpdate, "entity from dto", pDtoUpdateInfos); + // verify no unwanted actions have been done + verifyNoMoreInteractions(pEntity); + } + + @Test + void testResetExistingParameters() { + final UUID pUuid = UUID.randomUUID(); + final ShortCircuitParametersInfos defaultInfos = parametersService.getDefaultParametersInfos(); + final ShortCircuitParametersEntity pEntity = spy(new ShortCircuitParametersEntity(defaultInfos).setId(pUuid)); + //entity that must have differences with defaults + final ShortCircuitParametersEntity pModifiedEntity = new ShortCircuitParametersEntity(pUuid, true, false, false, StudyType.TRANSIENT, 20.0, + ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP, false, false, true, true, InitialVoltageProfileMode.NOMINAL, null); + when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.of(pEntity)); + parametersService.updateParameters(pUuid, null); + // verify we search the correct uid + verify(parametersRepository).findById(pUuid); + + when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pModifiedEntity); + // verify the parameters has been update + checkParametersEntityHasBeenUpdate(pEntity, pModifiedEntity, "default entity", defaultInfos); + // verify no unwanted actions have been done + verifyNoMoreInteractions(pEntity); + } + + // specific parameters + @Test + void testCreateParametersWithSpecificParameters() { + final UUID pUuid = UUID.randomUUID(); + final ShortCircuitParametersEntity pEntity = spy(ShortCircuitParametersEntity.builder().id(pUuid).build()); + when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pEntity); + + final Map> specific = Collections.singletonMap("my_provider", + Collections.singletonMap("param", "value")); + + final ShortCircuitParameters params = new ShortCircuitParameters(); // keep default common params + final ShortCircuitParametersInfos infos = new ShortCircuitParametersInfos( + ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP, + params, + specific + ); + + assertThat(parametersService.createParameters(infos)).as("service call result").isEqualTo(pUuid); + + verify(pEntity).getId(); + verifyNoMoreInteractions(pEntity); + + final ArgumentCaptor captor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); + verify(parametersRepository).save(captor.capture()); + final ShortCircuitParametersEntity saved = captor.getValue(); + + // ensure specific parameters have been converted and stored + assertThat(saved.getSpecificParameters()).as("specific parameters list").hasSize(1); + final ShortCircuitSpecificParameterEntity spec = saved.getSpecificParameters().get(0); + assertThat(spec.getProvider()).as("provider key").isEqualTo("my_provider"); + assertThat(spec.getName()).as("parameter name").isEqualTo("param"); + assertThat(spec.getValue()).as("parameter value").isEqualTo("value"); + } + + @Test + void testDuplicateParametersWithSpecificParameters() { + final UUID sourceUuid = UUID.randomUUID(); + final UUID savedUuid = UUID.randomUUID(); + + final ShortCircuitSpecificParameterEntity spec = new ShortCircuitSpecificParameterEntity(UUID.randomUUID(), "my_provider", "param", "value"); + final ShortCircuitParametersEntity pEntityRaw = ShortCircuitParametersEntity.builder() + .specificParameters(List.of(spec)) + .build(); + final ShortCircuitParametersEntity pEntity = spy(pEntityRaw); + final ShortCircuitParametersEntity pSavedEntity = spy(ShortCircuitParametersEntity.builder().id(savedUuid).build()); + + when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.of(pEntity)); + when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pSavedEntity); + + final Optional result = parametersService.duplicateParameters(sourceUuid); + assertThat(result).as("service call result").isPresent().contains(savedUuid); + + verify(parametersRepository).findById(sourceUuid); + checkParametersEntityHasBeenRead(pEntity); + + final ArgumentCaptor captor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); + verify(parametersRepository).save(captor.capture()); + final ShortCircuitParametersEntity savedArg = captor.getValue(); + + assertThat(savedArg).as("saved entity must be a copy").isNotSameAs(pEntity); + assertThat(savedArg.getSpecificParameters()).as("specific parameters copied").hasSize(1); + final ShortCircuitSpecificParameterEntity savedSpec = savedArg.getSpecificParameters().get(0); + assertThat(savedSpec.getProvider()).isEqualTo("my_provider"); + assertThat(savedSpec.getName()).isEqualTo("param"); + assertThat(savedSpec.getValue()).isEqualTo("value"); + + verify(pSavedEntity).getId(); + verifyNoMoreInteractions(pEntity); + verifyNoMoreInteractions(pSavedEntity); + } + + @Test + void testGetSpecificShortCircuitParametersNoProvider() { + final String randomProvider = "non_existing_provider_" + UUID.randomUUID(); + final Map> result = ShortCircuitParametersService.getSpecificShortCircuitParameters(randomProvider); + assertThat(result).as("no provider must match a random name").isEmpty(); + } + + @Test + void testCreateAndRetrieveParametersWithSpecificParameters() { + final UUID pUuid = UUID.randomUUID(); + final ShortCircuitParametersEntity pEntity = spy(ShortCircuitParametersEntity.builder().id(pUuid).build()); + when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pEntity); + + final Map> specific = Collections.singletonMap("my_provider", + Collections.singletonMap("param", "value")); + + final ShortCircuitParametersInfos infos = new ShortCircuitParametersInfos( + ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP, + new ShortCircuitParameters(), + specific + ); + + // create + assertThat(parametersService.createParameters(infos)).as("service call result").isEqualTo(pUuid); + + final ArgumentCaptor captor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); + verify(parametersRepository).save(captor.capture()); + final ShortCircuitParametersEntity saved = captor.getValue(); + + // saved entity must contain converted specific parameters + assertThat(saved.getSpecificParameters()).as("specific parameters list").hasSize(1); + final ShortCircuitSpecificParameterEntity spec = saved.getSpecificParameters().get(0); + assertThat(spec.getProvider()).as("provider key").isEqualTo("my_provider"); + assertThat(spec.getName()).as("parameter name").isEqualTo("param"); + assertThat(spec.getValue()).as("parameter value").isEqualTo("value"); + + // now stub findById to return the saved entity and retrieve DTO + when(parametersRepository.findById(pUuid)).thenReturn(Optional.of(saved)); + final ShortCircuitParametersInfos retrieved = parametersService.getParameters(pUuid).orElseThrow(); + assertThat(retrieved.specificParametersPerProvider()).as("retrieved specific parameters").isEqualTo(specific); + + verify(parametersRepository).findById(pUuid); + } +} diff --git a/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitServiceTest.java b/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitServiceTest.java deleted file mode 100644 index 2409d89c..00000000 --- a/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitServiceTest.java +++ /dev/null @@ -1,286 +0,0 @@ -/* - * Copyright (c) 2024, 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.shortcircuit.server.service; - -import com.fasterxml.jackson.databind.ObjectMapper; -import com.powsybl.shortcircuit.InitialVoltageProfileMode; -import com.powsybl.shortcircuit.ShortCircuitParameters; -import com.powsybl.shortcircuit.StudyType; -import org.assertj.core.api.WithAssertions; -import org.gridsuite.computation.s3.ComputationS3Service; -import org.gridsuite.computation.service.NotificationService; -import org.gridsuite.computation.service.UuidGeneratorService; -import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersInfos; -import org.gridsuite.shortcircuit.server.dto.ShortCircuitPredefinedConfiguration; -import org.gridsuite.shortcircuit.server.entities.ShortCircuitParametersEntity; -import org.gridsuite.shortcircuit.server.repositories.ParametersRepository; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.TestInstance; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; - -import java.util.Optional; -import java.util.Random; -import java.util.UUID; - -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.*; - -@ExtendWith({ MockitoExtension.class }) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) -@TestInstance(TestInstance.Lifecycle.PER_CLASS) -class ShortCircuitServiceTest implements WithAssertions { - private NotificationService notificationService; - private UuidGeneratorService uuidGeneratorService; - private ShortCircuitAnalysisResultService resultService; - private ComputationS3Service computationS3Service; - private ParametersRepository parametersRepository; - private FilterService filterService; - private ObjectMapper objectMapper; - private ShortCircuitService shortCircuitService; - - @BeforeAll - void setUp() { - this.notificationService = mock(NotificationService.class); - this.uuidGeneratorService = spy(new UuidGeneratorService()); - this.resultService = mock(ShortCircuitAnalysisResultService.class); - this.parametersRepository = mock(ParametersRepository.class); - this.filterService = mock(FilterService.class); - this.objectMapper = spy(new ObjectMapper()); - this.shortCircuitService = new ShortCircuitService(notificationService, uuidGeneratorService, resultService, computationS3Service, parametersRepository, filterService, objectMapper); - } - - @AfterEach - void checkMocks() { - try { - Mockito.verifyNoMoreInteractions( - notificationService, - uuidGeneratorService, - resultService, - parametersRepository, - filterService, - objectMapper - ); - } finally { - Mockito.reset( - notificationService, - uuidGeneratorService, - resultService, - parametersRepository, - filterService, - objectMapper - ); - } - } - - private static void checkParametersEntityHasBeenRead(final ShortCircuitParametersEntity pEntity) { - verify(pEntity).isWithLimitViolations(); - verify(pEntity).isWithVoltageResult(); - verify(pEntity).isWithFeederResult(); - verify(pEntity).getStudyType(); - verify(pEntity).getMinVoltageDropProportionalThreshold(); - verify(pEntity).getPredefinedParameters(); - verify(pEntity).isWithLoads(); - verify(pEntity).isWithShuntCompensators(); - verify(pEntity).isWithVscConverterStations(); - verify(pEntity).isWithNeutralPosition(); - verify(pEntity, atLeastOnce()).getInitialVoltageProfileMode(); - verify(pEntity, atMost(2)).getInitialVoltageProfileMode(); // for fromEntity() case - } - - @Test - void testGetNonExistingParameters() { - final UUID pUuid = UUID.randomUUID(); - when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.empty()); - assertThat(shortCircuitService.getParameters(pUuid)).as("service call result").isEmpty(); - verify(parametersRepository).findById(pUuid); - } - - @Test - void testGetExistingParametersAndConversionToDto() { - final UUID pUuid = UUID.randomUUID(); - final double minVoltDrop = new Random().nextDouble(); - final ShortCircuitParametersEntity pEntity = spy(new ShortCircuitParametersEntity(pUuid, false, false, false, StudyType.STEADY_STATE, minVoltDrop, - ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, false, false, false, false, InitialVoltageProfileMode.NOMINAL)); - when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.of(pEntity)); - //can't spy call to fromEntity() - assertThat(shortCircuitService.getParameters(pUuid)).as("service call result") - .get().as("dto").usingRecursiveComparison().isEqualTo(new ShortCircuitParametersInfos( - ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, new ShortCircuitParameters() - .setWithLimitViolations(false) - .setWithVoltageResult(false) - .setWithFeederResult(false) - .setStudyType(StudyType.STEADY_STATE) - .setMinVoltageDropProportionalThreshold(minVoltDrop) - .setWithLoads(false) - .setWithShuntCompensators(false) - .setWithVSCConverterStations(false) - .setWithNeutralPosition(false) - .setInitialVoltageProfileMode(InitialVoltageProfileMode.NOMINAL))); - checkParametersEntityHasBeenRead(pEntity); - verifyNoMoreInteractions(pEntity); - verify(parametersRepository).findById(pUuid); - } - - @Test - void testDeleteNonExistingParameters() { - final UUID pUuid = UUID.randomUUID(); - when(parametersRepository.existsById(any(UUID.class))).thenReturn(false); - assertThat(shortCircuitService.deleteParameters(pUuid)).as("service call result").isFalse(); - verify(parametersRepository).existsById(pUuid); - } - - @Test - void testDeleteExistingParameters() { - final UUID pUuid = UUID.randomUUID(); - when(parametersRepository.existsById(any(UUID.class))).thenReturn(true); - assertThat(shortCircuitService.deleteParameters(pUuid)).as("service call result").isTrue(); - verify(parametersRepository).existsById(pUuid); - verify(parametersRepository).deleteById(pUuid); - } - - @Test - void testDuplicateNonExistingParameters() { - final UUID pUuid = UUID.randomUUID(); - when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.empty()); - assertThat(shortCircuitService.duplicateParameters(pUuid)).as("service call result").isEmpty(); - verify(parametersRepository).findById(pUuid); - } - - @Test - void testDuplicateExistingParameters() { - final UUID pUuid = UUID.randomUUID(); - final ShortCircuitParametersEntity pEntityRaw = ShortCircuitParametersEntity.builder().id(UUID.randomUUID()).build(); - final ShortCircuitParametersEntity pEntity = spy(pEntityRaw); - final UUID pSavedUuid = UUID.randomUUID(); - final ShortCircuitParametersEntity pSavedEntity = spy(ShortCircuitParametersEntity.builder().id(pSavedUuid).build()); - when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.of(pEntity)); - when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pSavedEntity); - assertThat(shortCircuitService.duplicateParameters(pUuid)).as("service call result").get().isEqualTo(pSavedUuid); - verify(parametersRepository).findById(pUuid); - checkParametersEntityHasBeenRead(pEntity); - final ArgumentCaptor entityCaptor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); - verify(parametersRepository).save(entityCaptor.capture()); - assertThat(entityCaptor.getValue()).as("saved entity").isNotSameAs(pEntity) - .usingRecursiveComparison().ignoringFields("id").isEqualTo(pEntityRaw); - verify(pSavedEntity).getId(); - verifyNoMoreInteractions(pEntity); - verifyNoMoreInteractions(pSavedEntity); - } - - @Test - void testCreateParameters() { - final UUID pUuid = UUID.randomUUID(); - final ShortCircuitParametersEntity pEntity = spy(ShortCircuitParametersEntity.builder().id(pUuid).build()); - when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pEntity); - //dto that must have differences with defaults - assertThat(shortCircuitService.createParameters(new ShortCircuitParametersInfos(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, new ShortCircuitParameters()))) - .as("service call result").isEqualTo(pUuid); - verify(pEntity).getId(); - final ArgumentCaptor captor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); - verify(parametersRepository).save(captor.capture()); - assertThat(captor.getValue()).usingRecursiveComparison().isEqualTo(new ShortCircuitParametersEntity( - true, true, true, StudyType.TRANSIENT, 0.0, ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, - true, true, true, false, InitialVoltageProfileMode.NOMINAL)); - } - - @Test - void testCreateDefaultParameters() { - final UUID pUuid = UUID.randomUUID(); - final ShortCircuitParametersEntity pEntity = spy(ShortCircuitParametersEntity.builder().id(pUuid).build()); - when(parametersRepository.save(any(ShortCircuitParametersEntity.class))).thenReturn(pEntity); - assertThat(shortCircuitService.createParameters(null)).as("service call result").isEqualTo(pUuid); - verify(pEntity).getId(); - final ArgumentCaptor captor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); - verify(parametersRepository).save(captor.capture()); - assertThat(captor.getValue()).usingRecursiveComparison().isEqualTo(new ShortCircuitParametersEntity()); - } - - @Test - void testUpdateNonExistingParameters() { - final UUID pUuid = UUID.randomUUID(); - when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.empty()); - assertThat(shortCircuitService.updateOrResetParameters(pUuid, null)).as("service call result").isFalse(); - verify(parametersRepository).findById(pUuid); - } - - @Test - void testUpdateExistingParameters() { - final UUID pUuid = UUID.randomUUID(); - final ShortCircuitParametersEntity pEntity = spy(ShortCircuitParametersEntity.builder().id(pUuid).build()); - final ShortCircuitParameters pDtoUpdateParams = spy(new ShortCircuitParameters()); - final ShortCircuitParametersInfos pDtoUpdate = spy(new ShortCircuitParametersInfos(ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, pDtoUpdateParams)); - //dto that must have differences with defaults - final ShortCircuitParametersEntity pEntityUpdate = new ShortCircuitParametersEntity(pUuid, true, true, true, StudyType.TRANSIENT, 0.0, - ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_CEI909, true, true, true, false, InitialVoltageProfileMode.NOMINAL); - when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.of(pEntity)); - assertThat(shortCircuitService.updateOrResetParameters(pUuid, pDtoUpdate)).as("service call result").isTrue(); - // verify we search the correct uid - verify(parametersRepository).findById(pUuid); - // verify DTO has been read - verify(pDtoUpdate).parameters(); - verify(pDtoUpdate).predefinedParameters(); - verify(pDtoUpdateParams).isWithLimitViolations(); - verify(pDtoUpdateParams).isWithVoltageResult(); - verify(pDtoUpdateParams).isWithFeederResult(); - verify(pDtoUpdateParams).getStudyType(); - verify(pDtoUpdateParams).getMinVoltageDropProportionalThreshold(); - verify(pDtoUpdateParams).isWithLoads(); - verify(pDtoUpdateParams).isWithShuntCompensators(); - verify(pDtoUpdateParams).isWithVSCConverterStations(); - verify(pDtoUpdateParams).isWithNeutralPosition(); - verify(pDtoUpdateParams).getInitialVoltageProfileMode(); - // verify the parameters has been update - checkParametersEntityHasBeenUpdate(pEntity, pEntityUpdate, "entity from dto"); - // verify no unwanted actions have been done - verifyNoMoreInteractions(pEntity, pDtoUpdate, pDtoUpdateParams); - } - - @Test - void testResetExistingParameters() { - final UUID pUuid = UUID.randomUUID(); - final ShortCircuitParametersEntity pEntity = spy(ShortCircuitParametersEntity.builder().id(pUuid).build()); - //entity that must have differences with defaults - final ShortCircuitParametersEntity pEntityUpdate = new ShortCircuitParametersEntity(pUuid, true, false, false, StudyType.TRANSIENT, 20.0, - ShortCircuitPredefinedConfiguration.ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP, false, false, true, true, InitialVoltageProfileMode.NOMINAL); - when(parametersRepository.findById(any(UUID.class))).thenReturn(Optional.of(pEntity)); - assertThat(shortCircuitService.updateOrResetParameters(pUuid, null)).as("service call result").isTrue(); - // verify we search the correct uid - verify(parametersRepository).findById(pUuid); - // verify the parameters has been update - checkParametersEntityHasBeenUpdate(pEntity, pEntityUpdate, "default entity"); - // verify no unwanted actions have been done - verifyNoMoreInteractions(pEntity); - } - - private void checkParametersEntityHasBeenUpdate(final ShortCircuitParametersEntity pEntity, - final ShortCircuitParametersEntity pEntityUpdate, final String pEntityUpdateDesc) { - final ArgumentCaptor entityCaptor = ArgumentCaptor.forClass(ShortCircuitParametersEntity.class); - verify(pEntity).updateWith(entityCaptor.capture()); - assertThat(entityCaptor.getValue()).as(pEntityUpdateDesc) - .usingRecursiveComparison().ignoringFields("id").isEqualTo(pEntityUpdate); - - // verify possible updates (to pass verifyNoMoreInteractions) - verify(pEntity).setWithLimitViolations(pEntityUpdate.isWithLimitViolations()); - verify(pEntity).setWithVoltageResult(pEntityUpdate.isWithVoltageResult()); - verify(pEntity).setWithFeederResult(pEntityUpdate.isWithFeederResult()); - verify(pEntity).setStudyType(pEntityUpdate.getStudyType()); - verify(pEntity).setMinVoltageDropProportionalThreshold(pEntityUpdate.getMinVoltageDropProportionalThreshold()); - verify(pEntity).setPredefinedParameters(pEntityUpdate.getPredefinedParameters()); - verify(pEntity).setWithLoads(pEntityUpdate.isWithLoads()); - verify(pEntity).setWithShuntCompensators(pEntityUpdate.isWithShuntCompensators()); - verify(pEntity).setWithVscConverterStations(pEntityUpdate.isWithVscConverterStations()); - verify(pEntity).setWithNeutralPosition(pEntityUpdate.isWithNeutralPosition()); - verify(pEntity).setInitialVoltageProfileMode(pEntityUpdate.getInitialVoltageProfileMode()); - } -} diff --git a/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerServiceTest.java b/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerServiceTest.java index 53f93eec..5a07f143 100644 --- a/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerServiceTest.java +++ b/src/test/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerServiceTest.java @@ -23,11 +23,13 @@ import lombok.extern.slf4j.Slf4j; import org.assertj.core.api.WithAssertions; import org.gridsuite.computation.ComputationException; +import org.gridsuite.computation.dto.ReportInfos; import org.gridsuite.computation.s3.ComputationS3Service; import org.gridsuite.computation.service.ExecutionService; import org.gridsuite.computation.service.NotificationService; import org.gridsuite.computation.service.ReportService; import org.gridsuite.shortcircuit.server.TestUtils; +import org.gridsuite.shortcircuit.server.dto.ShortCircuitParametersValues; import org.gridsuite.shortcircuit.server.report.ReportMapperService; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -94,9 +96,9 @@ void testLogsMappersIsCalled() throws Exception { final UUID resultUuid = UUID.fromString("33333333-3333-3333-3333-333333333333"); final String reporterId = "44444444-4444-4444-4444-444444444444"; final ShortCircuitRunContext runContext = new ShortCircuitRunContext(networkUuid, null, null, - new ShortCircuitParameters(), reportUuid, reporterId, "AllBusesShortCircuitAnalysis", null, + new ShortCircuitParametersValues(null, null, null, null), null, new ReportInfos(reportUuid, reporterId, "AllBusesShortCircuitAnalysis"), null, "default-provider", // TODO : replace with null when fix in powsybl-ws-commons will handle null provider - null, false); + null, false, null); final ShortCircuitResultContext resultContext = new ShortCircuitResultContext(resultUuid, runContext); final Network.BusView busViewMocked = Mockito.mock(Network.BusView.class); ReportNode reportNode = ReportNode.newRootReportNode() diff --git a/src/test/resources/default_shorcircuit_infos_parameters.json b/src/test/resources/default_shorcircuit_infos_parameters.json new file mode 100644 index 00000000..4e1e26a3 --- /dev/null +++ b/src/test/resources/default_shorcircuit_infos_parameters.json @@ -0,0 +1,19 @@ +{ + "predefinedParameters": "ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP", + "commonParameters": { + "version": "1.4", + "withLimitViolations": true, + "withVoltageResult": false, + "withFeederResult": false, + "studyType": "TRANSIENT", + "minVoltageDropProportionalThreshold": 20.0, + "withFortescueResult": false, + "withLoads": false, + "withShuntCompensators": false, + "withVSCConverterStations": true, + "withNeutralPosition": true, + "initialVoltageProfileMode": "NOMINAL", + "detailedReport": false + }, + "specificParametersPerProvider": {} +} diff --git a/src/test/resources/default_shorcircuit_parameters.json b/src/test/resources/default_shorcircuit_parameters.json deleted file mode 100644 index 0447b3e9..00000000 --- a/src/test/resources/default_shorcircuit_parameters.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "version": "1.4", - "withLimitViolations": true, - "withVoltageResult": false, - "withFeederResult": false, - "studyType": "TRANSIENT", - "minVoltageDropProportionalThreshold": 20.0, - "withFortescueResult": false, - "withLoads": false, - "withShuntCompensators": false, - "withVSCConverterStations": true, - "withNeutralPosition": true, - "initialVoltageProfileMode": "NOMINAL", - "detailedReport": false -} diff --git a/src/test/resources/default_shorcircuit_values_parameters.json b/src/test/resources/default_shorcircuit_values_parameters.json new file mode 100644 index 00000000..e57f62a3 --- /dev/null +++ b/src/test/resources/default_shorcircuit_values_parameters.json @@ -0,0 +1,20 @@ +{ + "provider": "default-provider", + "predefinedParameters": "ICC_MAX_WITH_NOMINAL_VOLTAGE_MAP", + "commonParameters": { + "version": "1.4", + "withLimitViolations": true, + "withVoltageResult": false, + "withFeederResult": false, + "studyType": "TRANSIENT", + "minVoltageDropProportionalThreshold": 20.0, + "withFortescueResult": false, + "withLoads": false, + "withShuntCompensators": false, + "withVSCConverterStations": true, + "withNeutralPosition": true, + "initialVoltageProfileMode": "NOMINAL", + "detailedReport": false + }, + "specificParameters": {} +} diff --git a/src/test/resources/org/gridsuite/shortcircuit/server/ShortCircuitParametersControllerTest.json b/src/test/resources/org/gridsuite/shortcircuit/server/ShortCircuitParametersControllerTest.json index 8388c0c2..1282292f 100644 --- a/src/test/resources/org/gridsuite/shortcircuit/server/ShortCircuitParametersControllerTest.json +++ b/src/test/resources/org/gridsuite/shortcircuit/server/ShortCircuitParametersControllerTest.json @@ -1,6 +1,7 @@ { "predefinedParameters": null, - "parameters": null, + "commonParameters": null, + "specificParametersPerProvider": null, "cei909VoltageRanges": [ { "range": { @@ -51,4 +52,4 @@ "maximumNominalVoltage": 410.0 } ] -} \ No newline at end of file +}